hist2d/RH1Painter.mjs

  1. import { gStyle, settings, constants, kInspect } from '../core.mjs';
  2. import { rgb as d3_rgb } from '../d3.mjs';
  3. import { floatToString, DrawOptions, buildSvgCurve, addHighlightStyle } from '../base/BasePainter.mjs';
  4. import { RHistPainter } from './RHistPainter.mjs';
  5. import { ensureRCanvas } from '../gpad/RCanvasPainter.mjs';
  8. /**
  9.  * @summary Painter for RH1 classes
  10.  *
  11.  * @private
  12.  */
  14. class RH1Painter extends RHistPainter {
  16.    /** @summary Constructor
  17.      * @param {object|string} dom - DOM element or id
  18.      * @param {object} histo - histogram object */
  19.    constructor(dom, histo) {
  20.       super(dom, histo);
  21.       this.wheel_zoomy = false;
  22.    }
  24.    /** @summary Scan content */
  25.    scanContent(when_axis_changed) {
  26.       // if when_axis_changed === true specified, content will be scanned after axis zoom changed
  28.       const histo = this.getHisto();
  29.       if (!histo) return;
  31.       if (!this.nbinsx && when_axis_changed) when_axis_changed = false;
  33.       if (!when_axis_changed)
  34.          this.extractAxesProperties(1);
  36.       let hmin = 0, hmin_nz = 0, hmax = 0, hsum = 0;
  38.       if (this.isDisplayItem()) {
  39.          // take min/max values from the display item
  40.          hmin = histo.fContMin;
  41.          hmin_nz = histo.fContMinPos;
  42.          hmax = histo.fContMax;
  43.          hsum = hmax;
  44.       } else {
  45.          const left = this.getSelectIndex('x', 'left'),
  46.                right = this.getSelectIndex('x', 'right');
  48.          if (when_axis_changed)
  49.             if ((left === this.scan_xleft) && (right === this.scan_xright)) return;
  52.          this.scan_xleft = left;
  53.          this.scan_xright = right;
  55.          let first = true, value, err;
  57.          for (let i = 0; i < this.nbinsx; ++i) {
  58.             value = histo.getBinContent(i+1);
  59.             hsum += value;
  61.             if ((i<left) || (i>=right)) continue;
  63.             if (value > 0)
  64.                if ((hmin_nz === 0) || (value<hmin_nz)) hmin_nz = value;
  65.             if (first) {
  66.                hmin = hmax = value;
  67.                first = false;
  68.             }
  70.             err = 0;
  72.             hmin = Math.min(hmin, value - err);
  73.             hmax = Math.max(hmax, value + err);
  74.          }
  75.       }
  77.       this.stat_entries = hsum;
  79.       this.hmin = hmin;
  80.       this.hmax = hmax;
  82.       this.ymin_nz = hmin_nz; // value can be used to show optimal log scale
  84.       if ((this.nbinsx === 0) || ((Math.abs(hmin) < 1e-300) && (Math.abs(hmax) < 1e-300)))
  85.          this.draw_content = false;
  86.       else
  87.          this.draw_content = true;
  89.       if (this.draw_content) {
  90.          if (hmin >= hmax) {
  91.             if (hmin === 0) {
  92.                this.ymin = 0;
  93.                this.ymax = 1;
  94.             } else if (hmin < 0) {
  95.                this.ymin = 2 * hmin;
  96.                this.ymax = 0;
  97.             } else {
  98.                this.ymin = 0;
  99.                this.ymax = hmin * 2;
  100.             }
  101.          } else {
  102.             const dy = (hmax - hmin) * 0.05;
  103.             this.ymin = hmin - dy;
  104.             if ((this.ymin < 0) && (hmin >= 0)) this.ymin = 0;
  105.             this.ymax = hmax + dy;
  106.          }
  107.       }
  108.    }
  110.    /** @summary Count statistic */
  111.    countStat(cond) {
  112.       const histo = this.getHisto(), xaxis = this.getAxis('x'),
  113.             left = this.getSelectIndex('x', 'left'),
  114.             right = this.getSelectIndex('x', 'right'),
  115.             stat_sumwy = 0, stat_sumwy2 = 0,
  116.             res = { name: 'histo', meanx: 0, meany: 0, rmsx: 0, rmsy: 0, integral: 0, entries: this.stat_entries, xmax: 0, wmax: 0 };
  117.       let stat_sumw = 0, stat_sumwx = 0, stat_sumwx2 = 0,
  118.           i, xmax = null, wmax = null;
  120.       for (i = left; i < right; ++i) {
  121.          const xx = xaxis.GetBinCoord(i+0.5);
  123.          if (cond && !cond(xx)) continue;
  125.          const w = histo.getBinContent(i + 1);
  127.          if ((xmax === null) || (w > wmax)) { xmax = xx; wmax = w; }
  129.          stat_sumw += w;
  130.          stat_sumwx += w * xx;
  131.          stat_sumwx2 += w * xx**2;
  132.       }
  134.       res.integral = stat_sumw;
  136.       if (Math.abs(stat_sumw) > 1e-300) {
  137.          res.meanx = stat_sumwx / stat_sumw;
  138.          res.meany = stat_sumwy / stat_sumw;
  139.          res.rmsx = Math.sqrt(Math.abs(stat_sumwx2 / stat_sumw - res.meanx**2));
  140.          res.rmsy = Math.sqrt(Math.abs(stat_sumwy2 / stat_sumw - res.meany**2));
  141.       }
  143.       if (xmax !== null) {
  144.          res.xmax = xmax;
  145.          res.wmax = wmax;
  146.       }
  148.       return res;
  149.    }
  151.    /** @summary Fill statistic */
  152.    fillStatistic(stat, dostat /* , dofit */) {
  153.       const histo = this.getHisto(),
  154.           data = this.countStat(),
  155.           print_name = dostat % 10,
  156.           print_entries = Math.floor(dostat / 10) % 10,
  157.           print_mean = Math.floor(dostat / 100) % 10,
  158.           print_rms = Math.floor(dostat / 1000) % 10,
  159.           print_under = Math.floor(dostat / 10000) % 10,
  160.           print_over = Math.floor(dostat / 100000) % 10,
  161.           print_integral = Math.floor(dostat / 1000000) % 10,
  162.           print_skew = Math.floor(dostat / 10000000) % 10,
  163.           print_kurt = Math.floor(dostat / 100000000) % 10;
  165.       // make empty at the beginning
  166.       stat.clearStat();
  168.       if (print_name > 0)
  169.          stat.addText(data.name);
  171.       if (print_entries > 0)
  172.          stat.addText('Entries = ' + stat.format(data.entries, 'entries'));
  174.       if (print_mean > 0)
  175.          stat.addText('Mean = ' + stat.format(data.meanx));
  177.       if (print_rms > 0)
  178.          stat.addText('Std Dev = ' + stat.format(data.rmsx));
  180.       if (print_under > 0)
  181.          stat.addText('Underflow = ' + stat.format(histo.getBinContent(0), 'entries'));
  183.       if (print_over > 0)
  184.          stat.addText('Overflow = ' + stat.format(histo.getBinContent(this.nbinsx+1), 'entries'));
  186.       if (print_integral > 0)
  187.          stat.addText('Integral = ' + stat.format(data.integral, 'entries'));
  189.       if (print_skew > 0)
  190.          stat.addText('Skew = <not avail>');
  192.       if (print_kurt > 0)
  193.          stat.addText('Kurt = <not avail>');
  195.       return true;
  196.    }
  198.    /** @summary Get baseline for bar drawings
  199.     * @private */
  200.    getBarBaseline(funcs, height) {
  201.       let gry = funcs.swap_xy ? 0 : height;
  202.       if (Number.isFinite(this.options.BaseLine) && (this.options.BaseLine >= funcs.scale_ymin))
  203.          gry = Math.round(funcs.gry(this.options.BaseLine));
  204.       return gry;
  205.    }
  207.    /** @summary Draw histogram as bars */
  208.    async drawBars(handle, funcs, width, height) {
  209.       this.createG(true);
  211.       const left = handle.i1, right = handle.i2, di = handle.stepi,
  212.             pmain = this.getFramePainter(),
  213.             histo = this.getHisto(), xaxis = this.getAxis('x');
  214.       let i, x1, x2, grx1, grx2, y, gry1, w,
  215.           bars = '', barsl = '', barsr = '';
  217.       const gry2 = this.getBarBaseline(funcs, height);
  219.       for (i = left; i < right; i += di) {
  220.          x1 = xaxis.GetBinCoord(i);
  221.          x2 = xaxis.GetBinCoord(i+di);
  223.          if (funcs.logx && (x2 <= 0)) continue;
  225.          grx1 = Math.round(funcs.grx(x1));
  226.          grx2 = Math.round(funcs.grx(x2));
  228.          y = histo.getBinContent(i+1);
  229.          if (funcs.logy && (y < funcs.scale_ymin)) continue;
  230.          gry1 = Math.round(funcs.gry(y));
  232.          w = grx2 - grx1;
  233.          grx1 += Math.round(this.options.BarOffset*w);
  234.          w = Math.round(this.options.BarWidth*w);
  236.          if (pmain.swap_xy)
  237.             bars += `M${gry2},${grx1}h${gry1-gry2}v${w}h${gry2-gry1}z`;
  238.          else
  239.             bars += `M${grx1},${gry1}h${w}v${gry2-gry1}h${-w}z`;
  241.          if (this.options.BarStyle > 0) {
  242.             grx2 = grx1 + w;
  243.             w = Math.round(w / 10);
  244.             if (pmain.swap_xy) {
  245.                barsl += `M${gry2},${grx1}h${gry1-gry2}v${w}h${gry2-gry1}z`;
  246.                barsr += `M${gry2},${grx2}h${gry1-gry2}v${-w}h${gry2-gry1}z`;
  247.             } else {
  248.                barsl += `M${grx1},${gry1}h${w}v${gry2-gry1}h${-w}z`;
  249.                barsr += `M${grx2},${gry1}h${-w}v${gry2-gry1}h${w}z`;
  250.             }
  251.          }
  252.       }
  254.       if (this.fillatt.empty()) this.fillatt.setSolidColor('blue');
  256.       if (bars) {
  257.          this.draw_g.append('svg:path')
  258.                     .attr('d', bars)
  259.                     .call(this.fillatt.func);
  260.       }
  262.       if (barsl) {
  263.          this.draw_g.append('svg:path')
  264.                .attr('d', barsl)
  265.                .call(this.fillatt.func)
  266.                .style('fill', d3_rgb(this.fillatt.color).brighter(0.5).formatRgb());
  267.       }
  269.       if (barsr) {
  270.          this.draw_g.append('svg:path')
  271.                .attr('d', barsr)
  272.                .call(this.fillatt.func)
  273.                .style('fill', d3_rgb(this.fillatt.color).darker(0.5).formatRgb());
  274.        }
  276.        return true;
  277.    }
  279.    /** @summary Draw histogram as filled errors */
  280.    async drawFilledErrors(handle, funcs /* , width, height */) {
  281.       this.createG(true);
  283.       const left = handle.i1, right = handle.i2, di = handle.stepi,
  284.             histo = this.getHisto(), xaxis = this.getAxis('x'),
  285.             bins1 = [], bins2 = [];
  286.       let i, x, grx, y, yerr, gry;
  288.       for (i = left; i < right; i += di) {
  289.          x = xaxis.GetBinCoord(i+0.5);
  290.          if (funcs.logx && (x <= 0)) continue;
  291.          grx = Math.round(funcs.grx(x));
  293.          y = histo.getBinContent(i+1);
  294.          yerr = histo.getBinError(i+1);
  295.          if (funcs.logy && (y-yerr < funcs.scale_ymin)) continue;
  297.          gry = Math.round(funcs.gry(y + yerr));
  298.          bins1.push({ grx, gry });
  300.          gry = Math.round(funcs.gry(y - yerr));
  301.          bins2.unshift({ grx, gry });
  302.       }
  304.       const path1 = buildSvgCurve(bins1, { line: this.options.ErrorKind !== 4 }),
  305.             path2 = buildSvgCurve(bins2, { line: this.options.ErrorKind !== 4, cmd: 'L' });
  307.       if (this.fillatt.empty()) this.fillatt.setSolidColor('blue');
  309.       this.draw_g.append('svg:path')
  310.                  .attr('d', path1 + path2 + 'Z')
  311.                  .call(this.fillatt.func);
  313.       return true;
  314.    }
  316.    /** @summary Draw 1D histogram as SVG */
  317.    async draw1DBins() {
  318.       const pmain = this.getFramePainter(),
  319.           rect = pmain.getFrameRect();
  321.       if (!this.draw_content || (rect.width <= 0) || (rect.height <= 0)) {
  322.          this.removeG();
  323.          return false;
  324.       }
  326.       this.createHistDrawAttributes();
  328.       const handle = this.prepareDraw({ extra: 1, only_indexes: true }),
  329.           funcs = pmain.getGrFuncs(this.options.second_x, this.options.second_y);
  331.       if (this.options.Bar)
  332.          return this.drawBars(handle, funcs, rect.width, rect.height);
  334.       if ((this.options.ErrorKind === 3) || (this.options.ErrorKind === 4))
  335.          return this.drawFilledErrors(handle, funcs, rect.width, rect.height);
  337.       return this.drawHistBins(handle, funcs, rect.width, rect.height);
  338.    }
  340.    /** @summary Draw histogram bins */
  341.    async drawHistBins(handle, funcs, width, height) {
  342.       this.createG(true);
  344.       const options = this.options,
  345.             left = handle.i1,
  346.             right = handle.i2,
  347.             di = handle.stepi,
  348.             histo = this.getHisto(),
  349.             want_tooltip = !this.isBatchMode() && settings.Tooltip,
  350.             xaxis = this.getAxis('x'),
  351.             exclude_zero = !options.Zero,
  352.             show_errors = options.Error,
  353.             show_line = options.Line,
  354.             show_text = options.Text;
  355.       let show_markers = options.Mark,
  356.           res = '', lastbin = false,
  357.           startx, currx, curry, x, grx, y, gry, curry_min, curry_max, prevy, prevx, i, bestimin, bestimax,
  358.           path_fill = null, path_err = null, path_marker = null, path_line = null,
  359.           hints_err = null,
  360.           endx = '', endy = '', dend = 0, my, yerr1, yerr2, bincont, binerr, mx1, mx2, midx,
  361.           text_font, pr = Promise.resolve();
  363.       if (show_errors && !show_markers && (this.v7EvalAttr('marker_style', 1) > 1))
  364.          show_markers = true;
  366.       if (options.ErrorKind === 2) {
  367.          if (this.fillatt.empty()) show_markers = true;
  368.                               else path_fill = '';
  369.       } else if (options.Error) {
  370.          path_err = '';
  371.          hints_err = want_tooltip ? '' : null;
  372.       }
  374.       if (show_line) path_line = '';
  376.       if (show_markers) {
  377.          // draw markers also when e2 option was specified
  378.          this.createv7AttMarker();
  379.          if (this.markeratt.size > 0) {
  380.             // simply use relative move from point, can optimize in the future
  381.             path_marker = '';
  382.             this.markeratt.resetPos();
  383.          } else
  384.             show_markers = false;
  385.       }
  387.       if (show_text) {
  388.          text_font = this.v7EvalFont('text', { size: 20, color: 'black', align: 22 });
  390.          if (!text_font.angle && !options.TextKind) {
  391.              const space = width / (right - left + 1);
  392.              if (space < 3 * text_font.size) {
  393.                 text_font.setAngle(270);
  394.                 text_font.setSize(Math.round(space*0.7));
  395.              }
  396.          }
  398.          pr = this.startTextDrawingAsync(text_font, 'font');
  399.       }
  401.       return pr.then(() => {
  402.          // if there are too many points, exclude many vertical drawings at the same X position
  403.          // instead define min and max value and made min-max drawing
  404.          let use_minmax = ((right-left) > 3*width);
  406.          if (options.ErrorKind === 1) {
  407.             const lw = this.lineatt.width + gStyle.fEndErrorSize;
  408.             endx = `m0,${lw}v${-2*lw}m0,${lw}`;
  409.             endy = `m${lw},0h${-2*lw}m${lw},0`;
  410.             dend = Math.floor((this.lineatt.width-1)/2);
  411.          }
  413.          const draw_markers = show_errors || show_markers;
  415.          if (draw_markers || show_text || show_line) use_minmax = true;
  417.          const draw_bin = besti => {
  418.             bincont = histo.getBinContent(besti+1);
  419.             if (!exclude_zero || (bincont !== 0)) {
  420.                mx1 = Math.round(funcs.grx(xaxis.GetBinCoord(besti)));
  421.                mx2 = Math.round(funcs.grx(xaxis.GetBinCoord(besti+di)));
  422.                midx = Math.round((mx1+mx2)/2);
  423.                my = Math.round(funcs.gry(bincont));
  424.                yerr1 = yerr2 = 20;
  425.                if (show_errors) {
  426.                   binerr = histo.getBinError(besti+1);
  427.                   yerr1 = Math.round(my - funcs.gry(bincont + binerr)); // up
  428.                   yerr2 = Math.round(funcs.gry(bincont - binerr) - my); // down
  429.                }
  431.                if (show_text && (bincont !== 0)) {
  432.                   const lbl = (bincont === Math.round(bincont)) ? bincont.toString() : floatToString(bincont, gStyle.fPaintTextFormat);
  434.                   if (text_font.angle)
  435.                      this.drawText({ align: 12, x: midx, y: Math.round(my - 2 - text_font.size / 5), text: lbl, latex: 0 });
  436.                   else
  437.                      this.drawText({ x: Math.round(mx1 + (mx2 - mx1) * 0.1), y: Math.round(my - 2 - text_font.size), width: Math.round((mx2 - mx1) * 0.8), height: text_font.size, text: lbl, latex: 0 });
  438.                }
  440.                if (show_line && (path_line !== null))
  441.                   path_line += ((path_line.length === 0) ? 'M' : 'L') + midx + ',' + my;
  443.                if (draw_markers) {
  444.                   if ((my >= -yerr1) && (my <= height + yerr2)) {
  445.                      if (path_fill !== null)
  446.                         path_fill += `M${mx1},${my-yerr1}h${mx2-mx1}v${yerr1+yerr2+1}h${mx1-mx2}z`;
  447.                      if (path_marker !== null)
  448.                         path_marker += this.markeratt.create(midx, my);
  449.                      if (path_err !== null) {
  450.                         let edx = 5;
  451.                         if (this.options.errorX > 0) {
  452.                            edx = Math.round((mx2-mx1)*this.options.errorX);
  453.                            const mmx1 = midx - edx, mmx2 = midx + edx;
  454.                            path_err += `M${mmx1+dend},${my}${endx}h${mmx2-mmx1-2*dend}${endx}`;
  455.                         }
  456.                         path_err += `M${midx},${my-yerr1+dend}${endy}v${yerr1+yerr2-2*dend}${endy}`;
  457.                         if (hints_err !== null)
  458.                            hints_err += `M${midx-edx},${my-yerr1}h${2*edx}v${yerr1+yerr2}h${-2*edx}z`;
  459.                      }
  460.                   }
  461.                }
  462.             }
  463.          };
  465.          for (i = left; i <= right; i += di) {
  466.             x = xaxis.GetBinCoord(i);
  468.             if (funcs.logx && (x <= 0)) continue;
  470.             grx = Math.round(funcs.grx(x));
  472.             lastbin = (i > right - di);
  474.             if (lastbin && (left < right))
  475.                gry = curry;
  476.             else {
  477.                y = histo.getBinContent(i+1);
  478.                gry = Math.round(funcs.gry(y));
  479.             }
  481.             if (res.length === 0) {
  482.                bestimin = bestimax = i;
  483.                prevx = startx = currx = grx;
  484.                prevy = curry_min = curry_max = curry = gry;
  485.                res = 'M'+currx+','+curry;
  486.             } else
  487.             if (use_minmax) {
  488.                if ((grx === currx) && !lastbin) {
  489.                   if (gry < curry_min) bestimax = i; else
  490.                   if (gry > curry_max) bestimin = i;
  491.                   curry_min = Math.min(curry_min, gry);
  492.                   curry_max = Math.max(curry_max, gry);
  493.                   curry = gry;
  494.                } else {
  495.                   if (draw_markers || show_text || show_line) {
  496.                      if (bestimin === bestimax) draw_bin(bestimin); else
  497.                         if (bestimin < bestimax) { draw_bin(bestimin); draw_bin(bestimax); } else {
  498.                            draw_bin(bestimax); draw_bin(bestimin);
  499.                         }
  500.                   }
  502.                   // when several points as same X differs, need complete logic
  503.                   if (!draw_markers && ((curry_min !== curry_max) || (prevy !== curry_min))) {
  504.                      if (prevx !== currx)
  505.                         res += 'h'+(currx-prevx);
  507.                      if (curry === curry_min) {
  508.                         if (curry_max !== prevy)
  509.                            res += 'v' + (curry_max - prevy);
  510.                         if (curry_min !== curry_max)
  511.                            res += 'v' + (curry_min - curry_max);
  512.                      } else {
  513.                         if (curry_min !== prevy)
  514.                            res += 'v' + (curry_min - prevy);
  515.                         if (curry_max !== curry_min)
  516.                            res += 'v' + (curry_max - curry_min);
  517.                         if (curry !== curry_max)
  518.                         res += 'v' + (curry - curry_max);
  519.                      }
  521.                      prevx = currx;
  522.                      prevy = curry;
  523.                   }
  525.                   if (lastbin && (prevx !== grx))
  526.                      res += 'h'+(grx-prevx);
  528.                   bestimin = bestimax = i;
  529.                   curry_min = curry_max = curry = gry;
  530.                   currx = grx;
  531.                }
  532.             } else
  533.             if ((gry !== curry) || lastbin) {
  534.                if (grx !== currx) res += 'h'+(grx-currx);
  535.                if (gry !== curry) res += 'v'+(gry-curry);
  536.                curry = gry;
  537.                currx = grx;
  538.             }
  539.          }
  541.          const fill_for_interactive = !this.isBatchMode() && this.fillatt.empty() && options.Hist && settings.Tooltip && !draw_markers && !show_line;
  542.          let h0 = height + 3;
  543.          if (!fill_for_interactive) {
  544.             const gry0 = Math.round(funcs.gry(0));
  545.             if (gry0 <= 0)
  546.                h0 = -3;
  547.             else if (gry0 < height)
  548.                h0 = gry0;
  549.          }
  550.          const close_path = `L${currx},${h0}H${startx}Z`;
  552.          if (draw_markers || show_line) {
  553.             if (path_fill) {
  554.                this.draw_g.append('svg:path')
  555.                         .attr('d', path_fill)
  556.                         .call(this.fillatt.func);
  557.             }
  559.             if (path_err) {
  560.                this.draw_g.append('svg:path')
  561.                      .attr('d', path_err)
  562.                      .call(this.lineatt.func);
  563.             }
  565.             if (hints_err) {
  566.                this.draw_g.append('svg:path')
  567.                      .attr('d', hints_err)
  568.                      .style('fill', 'none')
  569.                      .style('pointer-events', this.isBatchMode() ? null : 'visibleFill');
  570.             }
  572.             if (path_line) {
  573.                if (!this.fillatt.empty() && !options.Hist) {
  574.                   this.draw_g.append('svg:path')
  575.                         .attr('d', path_line + close_path)
  576.                         .call(this.fillatt.func);
  577.                }
  579.                this.draw_g.append('svg:path')
  580.                      .attr('d', path_line)
  581.                      .style('fill', 'none')
  582.                      .call(this.lineatt.func);
  583.             }
  585.             if (path_marker) {
  586.                this.draw_g.append('svg:path')
  587.                   .attr('d', path_marker)
  588.                   .call(this.markeratt.func);
  589.             }
  590.          } else if (res && options.Hist) {
  591.             this.draw_g.append('svg:path')
  592.                      .attr('d', res + ((!this.fillatt.empty() || fill_for_interactive) ? close_path : ''))
  593.                      .style('stroke-linejoin', 'miter')
  594.                      .call(this.lineatt.func)
  595.                      .call(this.fillatt.func);
  596.          }
  598.          return show_text ? this.finishTextDrawing() : true;
  599.       });
  600.    }
  602.    /** @summary Provide text information (tooltips) for histogram bin */
  603.    getBinTooltips(bin) {
  604.       const tips = [],
  605.             name = this.getObjectHint(),
  606.             pmain = this.getFramePainter(),
  607.             histo = this.getHisto(),
  608.             xaxis = this.getAxis('x'),
  609.             di = this.isDisplayItem() ? histo.stepx : 1,
  610.             x1 = xaxis.GetBinCoord(bin),
  611.             x2 = xaxis.GetBinCoord(bin+di),
  612.             xlbl = this.getAxisBinTip('x', bin, di);
  614.       let cont = histo.getBinContent(bin+1);
  616.       if (name) tips.push(name);
  618.       if (this.options.Error || this.options.Mark) {
  619.          tips.push(`x = ${xlbl}`, `y = ${pmain.axisAsText('y', cont)}`);
  620.          if (this.options.Error) {
  621.             if (xlbl[0] === '[') tips.push('error x = ' + ((x2 - x1) / 2).toPrecision(4));
  622.             tips.push('error y = ' + histo.getBinError(bin + 1).toPrecision(4));
  623.          }
  624.       } else {
  625.          tips.push(`bin = ${bin+1}`, `x = ${xlbl}`);
  626.          if (histo.$baseh) cont -= histo.$baseh.getBinContent(bin+1);
  627.          const lbl = 'entries = ' + (di > 1 ? '~' : '');
  628.          if (cont === Math.round(cont))
  629.             tips.push(lbl + cont);
  630.          else
  631.             tips.push(lbl + floatToString(cont, gStyle.fStatFormat));
  632.       }
  634.       return tips;
  635.    }
  637.    /** @summary Process tooltip event */
  638.    processTooltipEvent(pnt) {
  639.       let ttrect = this.draw_g?.selectChild('.tooltip_bin');
  641.       if (!pnt || !this.draw_content || this.options.Mode3D || !this.draw_g) {
  642.          ttrect?.remove();
  643.          return null;
  644.       }
  646.       const pmain = this.getFramePainter(),
  647.             funcs = pmain.getGrFuncs(this.options.second_x, this.options.second_y),
  648.             width = pmain.getFrameWidth(),
  649.             height = pmain.getFrameHeight(),
  650.             histo = this.getHisto(), xaxis = this.getAxis('x'),
  651.             left = this.getSelectIndex('x', 'left', -1),
  652.             right = this.getSelectIndex('x', 'right', 2);
  654.       let show_rect, grx1, grx2, gry1, gry2, gapx = 2,
  655.           l = left, r = right;
  657.       function GetBinGrX(i) {
  658.          const xx = xaxis.GetBinCoord(i);
  659.          return (funcs.logx && (xx <= 0)) ? null : funcs.grx(xx);
  660.       }
  662.       function GetBinGrY(i) {
  663.          const yy = histo.getBinContent(i + 1);
  664.          if (funcs.logy && (yy < funcs.scale_ymin))
  665.             return funcs.swap_xy ? -1000 : 10*height;
  666.          return Math.round(funcs.gry(yy));
  667.       }
  669.       const pnt_x = funcs.swap_xy ? pnt.y : pnt.x,
  670.             pnt_y = funcs.swap_xy ? pnt.x : pnt.y;
  672.       while (l < r-1) {
  673.          const m = Math.round((l+r)*0.5),
  674.                xx = GetBinGrX(m);
  675.          if ((xx === null) || (xx < pnt_x - 0.5))
  676.             if (funcs.swap_xy) r = m; else l = m;
  677.           else if (xx > pnt_x + 0.5)
  678.             if (funcs.swap_xy) l = m; else r = m;
  679.           else { l++; r--; }
  680.       }
  682.       let findbin = r = l;
  683.       grx1 = GetBinGrX(findbin);
  685.       if (funcs.swap_xy) {
  686.          while ((l > left) && (GetBinGrX(l-1) < grx1 + 2)) --l;
  687.          while ((r < right) && (GetBinGrX(r+1) > grx1 - 2)) ++r;
  688.       } else {
  689.          while ((l > left) && (GetBinGrX(l-1) > grx1 - 2)) --l;
  690.          while ((r < right) && (GetBinGrX(r+1) < grx1 + 2)) ++r;
  691.       }
  693.       if (l < r) {
  694.          // many points can be assigned with the same cursor position
  695.          // first try point around mouse y
  696.          let best = height;
  697.          for (let m = l; m <= r; m++) {
  698.             const dist = Math.abs(GetBinGrY(m) - pnt_y);
  699.             if (dist < best) { best = dist; findbin = m; }
  700.          }
  702.          // if best distance still too far from mouse position, just take from between
  703.          if (best > height/10)
  704.             findbin = Math.round(l + (r-l) / height * pnt_y);
  706.          grx1 = GetBinGrX(findbin);
  707.       }
  709.       grx1 = Math.round(grx1);
  710.       grx2 = Math.round(GetBinGrX(findbin+1));
  712.       if (this.options.Bar) {
  713.          const w = grx2 - grx1;
  714.          grx1 += Math.round(this.options.BarOffset*w);
  715.          grx2 = grx1 + Math.round(this.options.BarWidth*w);
  716.       }
  718.       if (grx1 > grx2)
  719.          [grx1, grx2] = [grx2, grx1];
  721.       if (this.isDisplayItem() && ((findbin <= histo.dx) || (findbin >= histo.dx + histo.nx))) {
  722.          // special case when zoomed out of scale and bin is not available
  723.          ttrect.remove();
  724.          return null;
  725.       }
  727.       const midx = Math.round((grx1 + grx2)/2),
  728.             midy = gry1 = gry2 = GetBinGrY(findbin);
  730.       if (this.options.Bar) {
  731.          show_rect = true;
  733.          gapx = 0;
  735.          gry1 = this.getBarBaseline(funcs, height);
  737.          if (gry1 > gry2)
  738.             [gry1, gry2] = [gry2, gry1];
  740.          if (!pnt.touch && (pnt.nproc === 1))
  741.             if ((pnt_y < gry1) || (pnt_y > gry2)) findbin = null;
  742.       } else if (this.options.Error || this.options.Mark) {
  743.          show_rect = true;
  745.          let msize = 3;
  746.          if (this.markeratt) msize = Math.max(msize, this.markeratt.getFullSize());
  748.          if (this.options.Error) {
  749.             const cont = histo.getBinContent(findbin+1),
  750.                   binerr = histo.getBinError(findbin+1);
  752.             gry1 = Math.round(funcs.gry(cont + binerr)); // up
  753.             gry2 = Math.round(funcs.gry(cont - binerr)); // down
  755.             const dx = (grx2-grx1)*this.options.errorX;
  756.             grx1 = Math.round(midx - dx);
  757.             grx2 = Math.round(midx + dx);
  758.          }
  760.          // show at least 6 pixels as tooltip rect
  761.          if (grx2 - grx1 < 2*msize) { grx1 = midx-msize; grx2 = midx+msize; }
  763.          gry1 = Math.min(gry1, midy - msize);
  764.          gry2 = Math.max(gry2, midy + msize);
  766.          if (!pnt.touch && (pnt.nproc === 1))
  767.             if ((pnt_y < gry1) || (pnt_y > gry2)) findbin = null;
  768.       } else if (this.options.Line)
  770.          show_rect = false;
  772.        else {
  773.          // if histogram alone, use old-style with rects
  774.          // if there are too many points at pixel, use circle
  775.          show_rect = (pnt.nproc === 1) && (right-left < width);
  777.          if (show_rect) {
  778.             gry2 = height;
  780.             if (!this.fillatt.empty()) {
  781.                gry2 = Math.min(height, Math.max(0, Math.round(funcs.gry(0))));
  782.                if (gry2 < gry1)
  783.                   [gry1, gry2] = [gry2, gry1];
  784.             }
  786.             // for mouse events pointer should be between y1 and y2
  787.             if (((pnt.y < gry1) || (pnt.y > gry2)) && !pnt.touch) findbin = null;
  788.          }
  789.       }
  791.       if (findbin !== null) {
  792.          // if bin on boundary found, check that x position is ok
  793.          if ((findbin === left) && (grx1 > pnt_x + gapx)) findbin = null; else
  794.          if ((findbin === right-1) && (grx2 < pnt_x - gapx)) findbin = null; else
  795.          // if bars option used check that bar is not match
  796.          if ((pnt_x < grx1 - gapx) || (pnt_x > grx2 + gapx)) findbin = null; else
  797.          // exclude empty bin if empty bins suppressed
  798.          if (!this.options.Zero && (histo.getBinContent(findbin+1) === 0)) findbin = null;
  799.       }
  801.       if ((findbin === null) || ((gry2 <= 0) || (gry1 >= height))) {
  802.          ttrect.remove();
  803.          return null;
  804.       }
  806.       const res = { name: 'histo', title: histo.fTitle,
  807.                   x: midx, y: midy, exact: true,
  808.                   color1: this.lineatt?.color ?? 'green',
  809.                   color2: this.fillatt?.getFillColorAlt('blue') ?? 'blue',
  810.                   lines: this.getBinTooltips(findbin) };
  812.       if (pnt.disabled) {
  813.          // case when tooltip should not highlight bin
  815.          ttrect.remove();
  816.          res.changed = true;
  817.       } else if (show_rect) {
  818.          if (ttrect.empty()) {
  819.             ttrect = this.draw_g.append('svg:rect')
  820.                                 .attr('class', 'tooltip_bin')
  821.                                 .style('pointer-events', 'none')
  822.                                 .call(addHighlightStyle);
  823.          }
  825.          res.changed = ttrect.property('current_bin') !== findbin;
  827.          if (res.changed) {
  828.             ttrect.attr('x', pmain.swap_xy ? gry1 : grx1)
  829.                   .attr('width', pmain.swap_xy ? gry2-gry1 : grx2-grx1)
  830.                   .attr('y', pmain.swap_xy ? grx1 : gry1)
  831.                   .attr('height', pmain.swap_xy ? grx2-grx1 : gry2-gry1)
  832.                   .style('opacity', '0.3')
  833.                   .property('current_bin', findbin);
  834.          }
  836.          res.exact = (Math.abs(midy - pnt_y) <= 5) || ((pnt_y>=gry1) && (pnt_y<=gry2));
  838.          res.menu = res.exact; // one could show context menu
  839.          // distance to middle point, use to decide which menu to activate
  840.          res.menu_dist = Math.sqrt((midx-pnt_x)**2 + (midy-pnt_y)**2);
  841.       } else {
  842.          const radius = this.lineatt.width + 3;
  844.          if (ttrect.empty()) {
  845.             ttrect = this.draw_g.append('svg:circle')
  846.                                 .attr('class', 'tooltip_bin')
  847.                                 .style('pointer-events', 'none')
  848.                                 .attr('r', radius)
  849.                                 .call(this.lineatt.func)
  850.                                 .call(this.fillatt.func);
  851.          }
  853.          res.exact = (Math.abs(midx - pnt.x) <= radius) && (Math.abs(midy - pnt.y) <= radius);
  855.          res.menu = res.exact; // show menu only when mouse pointer exactly over the histogram
  856.          res.menu_dist = Math.sqrt((midx-pnt.x)**2 + (midy-pnt.y)**2);
  858.          res.changed = ttrect.property('current_bin') !== findbin;
  860.          if (res.changed) {
  861.             ttrect.attr('cx', midx)
  862.                   .attr('cy', midy)
  863.                   .property('current_bin', findbin);
  864.          }
  865.       }
  867.       if (res.changed) {
  868.          res.user_info = { obj: histo, name: 'histo',
  869.                            bin: findbin, cont: histo.getBinContent(findbin+1),
  870.                            grx: midx, gry: midy };
  871.       }
  873.       return res;
  874.    }
  876.    /** @summary Fill histogram context menu */
  877.    fillHistContextMenu(menu) {
  878.       menu.add('Auto zoom-in', () => this.autoZoom());
  880.       const opts = this.getSupportedDrawOptions();
  882.       menu.addDrawMenu('Draw with', opts, arg => {
  883.          if (arg.indexOf(kInspect) === 0)
  884.             return this.showInspector(arg);
  886.          this.decodeOptions(arg); // obsolete, should be implemented differently
  888.          if (this.options.need_fillcol && this.fillatt?.empty())
  889.             this.fillatt.change(5, 1001);
  891.          // redraw all objects
  892.          this.interactiveRedraw('pad', 'drawopt');
  893.       });
  894.    }
  896.    /** @summary Perform automatic zoom inside non-zero region of histogram */
  897.    autoZoom() {
  898.       let left = this.getSelectIndex('x', 'left', -1),
  899.           right = this.getSelectIndex('x', 'right', 1);
  900.       const dist = right - left, histo = this.getHisto(), xaxis = this.getAxis('x');
  902.       if (dist === 0) return;
  904.       // first find minimum
  905.       let min = histo.getBinContent(left + 1);
  906.       for (let indx = left; indx < right; ++indx)
  907.          min = Math.min(min, histo.getBinContent(indx+1));
  908.       if (min > 0) return; // if all points positive, no chance for auto-scale
  910.       while ((left < right) && (histo.getBinContent(left+1) <= min)) ++left;
  911.       while ((left < right) && (histo.getBinContent(right) <= min)) --right;
  913.       // if singular bin
  914.       if ((left === right-1) && (left > 2) && (right < this.nbinsx-2)) {
  915.          --left; ++right;
  916.       }
  918.       if ((right - left < dist) && (left < right))
  919.          return this.getFramePainter().zoom(xaxis.GetBinCoord(left), xaxis.GetBinCoord(right));
  920.    }
  922.    /** @summary Checks if it makes sense to zoom inside specified axis range */
  923.    canZoomInside(axis, min, max) {
  924.       const xaxis = this.getAxis('x');
  926.       if ((axis === 'x') && (xaxis.FindBin(max, 0.5) - xaxis.FindBin(min, 0) > 1)) return true;
  928.       if ((axis === 'y') && (Math.abs(max-min) > Math.abs(this.ymax-this.ymin)*1e-6)) return true;
  930.       return false;
  931.    }
  933.    /** @summary Call appropriate draw function */
  934.    async callDrawFunc(reason) {
  935.       const main = this.getFramePainter();
  937.       if (main && (main.mode3d !== this.options.Mode3D) && !this.isMainPainter())
  938.          this.options.Mode3D = main.mode3d;
  940.       return this.options.Mode3D ? this.draw3D(reason) : this.draw2D(reason);
  941.    }
  943.    /** @summary Draw in 2d */
  944.    async draw2D(reason) {
  945.       this.clear3DScene();
  947.       return this.drawFrameAxes().then(res => {
  948.          return res ? this.drawingBins(reason) : false;
  949.       }).then(res => {
  950.          if (res)
  951.             return this.draw1DBins().then(() => this.addInteractivity());
  952.       }).then(() => this);
  953.    }
  955.    /** @summary Draw in 3d */
  956.    async draw3D(reason) {
  957.       console.log('3D drawing is disabled, load ./hist/RH1Painter.mjs');
  958.       return this.draw2D(reason);
  959.    }
  961.    /** @summary Redraw histogram */
  962.    async redraw(reason) {
  963.       return this.callDrawFunc(reason);
  964.    }
  966.    static async _draw(painter, opt) {
  967.       return ensureRCanvas(painter).then(() => {
  968.          painter.setAsMainPainter();
  970.          painter.options = { Hist: false, Bar: false, BarStyle: 0,
  971.                              Error: false, ErrorKind: -1, errorX: gStyle.fErrorX,
  972.                              Zero: false, Mark: false,
  973.                              Line: false, Fill: false, Lego: 0, Surf: 0,
  974.                              Text: false, TextAngle: 0, TextKind: '', AutoColor: 0,
  975.                              BarOffset: 0, BarWidth: 1, BaseLine: false,
  976.                              Mode3D: false, FrontBox: false, BackBox: false };
  978.          const d = new DrawOptions(opt);
  979.          if (d.check('R3D_', true))
  980.             painter.options.Render3D = constants.Render3D.fromString(d.part.toLowerCase());
  982.          const kind = painter.v7EvalAttr('kind', 'hist'),
  983.                sub = painter.v7EvalAttr('sub', 0),
  984.                has_main = Boolean(painter.getMainPainter()),
  985.                o = painter.options;
  987.          o.Text = painter.v7EvalAttr('drawtext', false);
  988.          o.BarOffset = painter.v7EvalAttr('baroffset', 0.0);
  989.          o.BarWidth = painter.v7EvalAttr('barwidth', 1.0);
  990.          o.second_x = has_main && painter.v7EvalAttr('secondx', false);
  991.          o.second_y = has_main && painter.v7EvalAttr('secondy', false);
  993.          switch (kind) {
  994.             case 'bar': o.Bar = true; o.BarStyle = sub; break;
  995.             case 'err': o.Error = true; o.ErrorKind = sub; break;
  996.             case 'p': o.Mark = true; break;
  997.             case 'l': o.Line = true; break;
  998.             case 'lego': o.Lego = sub > 0 ? 10+sub : 12; o.Mode3D = true; break;
  999.             default: o.Hist = true;
  1000.          }
  1002.          painter.scanContent();
  1004.          return painter.callDrawFunc();
  1005.       });
  1006.    }
  1008.    /** @summary draw RH1 object */
  1009.    static async draw(dom, histo, opt) {
  1010.       return RH1Painter._draw(new RH1Painter(dom, histo), opt);
  1011.    }
  1013. } // class RH1Painter
  1015. export { RH1Painter };