draw/TGraphPolarPainter.mjs

  1. import { settings, gStyle, create, BIT, clTPaveText, kTitle } from '../core.mjs';
  2. import { scaleLinear, pointer as d3_pointer } from '../d3.mjs';
  3. import { DrawOptions, buildSvgCurve, makeTranslate } from '../base/BasePainter.mjs';
  4. import { ObjectPainter, getElementMainPainter } from '../base/ObjectPainter.mjs';
  5. import { TPavePainter, kPosTitle } from '../hist/TPavePainter.mjs';
  6. import { ensureTCanvas } from '../gpad/TCanvasPainter.mjs';
  7. import { TooltipHandler } from '../gpad/TFramePainter.mjs';
  8. import { assignContextMenu, kNoReorder } from '../gui/menu.mjs';
  10. const kNoTitle = BIT(17);
  12. /**
  13.  * @summary Painter for TGraphPolargram objects.
  14.  *
  15.  * @private */
  17. class TGraphPolargramPainter extends ObjectPainter {
  19.    /** @summary Create painter
  20.      * @param {object|string} dom - DOM element for drawing or element id
  21.      * @param {object} polargram - object to draw */
  22.    constructor(dom, polargram, opt) {
  23.       super(dom, polargram, opt);
  24.       this.$polargram = true; // indicate that this is polargram
  25.       this.zoom_rmin = this.zoom_rmax = 0;
  26.       this.t0 = 0;
  27.       this.mult = 1;
  28.       this.decodeOptions(opt);
  29.    }
  31.    /** @summary Returns true if fixed coordinates are configured */
  32.    isNormalAngles() {
  33.       const polar = this.getObject();
  34.       return polar?.fRadian || polar?.fGrad || polar?.fDegree;
  35.    }
  37.    /** @summary Decode draw options */
  38.    decodeOptions(opt) {
  39.       const d = new DrawOptions(opt);
  41.       if (!this.options)
  42.          this.options = {};
  44.       Object.assign(this.options, {
  45.          rdot: d.check('RDOT'),
  46.          rangle: d.check('RANGLE', true) ? d.partAsInt() : 0,
  47.          NoLabels: d.check('N'),
  48.          OrthoLabels: d.check('O')
  49.       });
  51.       this.storeDrawOpt(opt);
  52.    }
  54.    /** @summary Set angles range displayed by the polargram */
  55.    setAnglesRange(tmin, tmax, set_obj) {
  56.       if (tmin >= tmax)
  57.          tmax = tmin + 1;
  58.       if (set_obj) {
  59.          const polar = this.getObject();
  60.          polar.fRwtmin = tmin;
  61.          polar.fRwtmax = tmax;
  62.       }
  63.       this.t0 = tmin;
  64.       this.mult = 2*Math.PI/(tmax - tmin);
  65.    }
  67.    /** @summary Translate coordinates */
  68.    translate(input_angle, radius, keep_float) {
  69.       // recalculate angle
  70.       const angle = (input_angle - this.t0) * this.mult;
  71.       let rx = this.r(radius),
  72.           ry = rx/this.szx*this.szy,
  73.           grx = rx * Math.cos(-angle),
  74.           gry = ry * Math.sin(-angle);
  76.       if (!keep_float) {
  77.          grx = Math.round(grx);
  78.          gry = Math.round(gry);
  79.          rx = Math.round(rx);
  80.          ry = Math.round(ry);
  81.       }
  82.       return { grx, gry, rx, ry };
  83.    }
  85.    /** @summary format label for radius ticks */
  86.    format(radius) {
  87.       if (radius === Math.round(radius)) return radius.toString();
  88.       if (this.ndig > 10) return radius.toExponential(4);
  89.       return radius.toFixed((this.ndig > 0) ? this.ndig : 0);
  90.    }
  92.    /** @summary Convert axis values to text */
  93.    axisAsText(axis, value) {
  94.       if (axis === 'r') {
  95.          if (value === Math.round(value))
  96.             return value.toString();
  97.          if (this.ndig > 10)
  98.             return value.toExponential(4);
  99.          return value.toFixed(this.ndig+2);
  100.       }
  102.       value *= 180/Math.PI;
  103.       return (value === Math.round(value)) ? value.toString() : value.toFixed(1);
  104.    }
  106.    /** @summary Returns coordinate of frame - without using frame itself */
  107.    getFrameRect() {
  108.       const pp = this.getPadPainter(),
  109.             pad = pp.getRootPad(true),
  110.             w = pp.getPadWidth(),
  111.             h = pp.getPadHeight(),
  112.             rect = {};
  114.       if (pad) {
  115.          rect.szx = Math.round(Math.max(0.1, 0.5 - Math.max(pad.fLeftMargin, pad.fRightMargin))*w);
  116.          rect.szy = Math.round(Math.max(0.1, 0.5 - Math.max(pad.fBottomMargin, pad.fTopMargin))*h);
  117.       } else {
  118.          rect.szx = Math.round(0.5*w);
  119.          rect.szy = Math.round(0.5*h);
  120.       }
  122.       rect.width = 2 * rect.szx;
  123.       rect.height = 2 * rect.szy;
  124.       rect.x = Math.round(w / 2 - rect.szx);
  125.       rect.y = Math.round(h / 2 - rect.szy);
  127.       rect.hint_delta_x = rect.szx;
  128.       rect.hint_delta_y = rect.szy;
  130.       rect.transform = makeTranslate(rect.x, rect.y) || '';
  132.       return rect;
  133.    }
  135.    /** @summary Process mouse event */
  136.    mouseEvent(kind, evnt) {
  137. //      const layer = this.getLayerSvg('primitives_layer'),
  138. //            interactive = layer.select('.interactive_ellipse');
  139. //      if (interactive.empty()) return;
  141.       let pnt = null;
  143.       if (kind !== 'leave') {
  144.          const pos = d3_pointer(evnt, this.draw_g.node());
  145.          pnt = { x: pos[0], y: pos[1], touch: false };
  146.       }
  147.       this.processFrameTooltipEvent(pnt);
  148.    }
  150.    /** @summary Process mouse wheel event */
  151.    mouseWheel(evnt) {
  152.       evnt.stopPropagation();
  153.       evnt.preventDefault();
  155.       this.processFrameTooltipEvent(null); // remove all tooltips
  157.       const polar = this.getObject();
  158.       if (!polar) return;
  160.       let delta = evnt.wheelDelta ? -evnt.wheelDelta : (evnt.deltaY || evnt.detail);
  161.       if (!delta) return;
  163.       delta = (delta < 0) ? -0.2 : 0.2;
  165.       let rmin = this.scale_rmin, rmax = this.scale_rmax;
  166.       const range = rmax - rmin;
  168.       // rmin -= delta*range;
  169.       rmax += delta*range;
  171.       if ((rmin < polar.fRwrmin) || (rmax > polar.fRwrmax))
  172.          rmin = rmax = 0;
  174.       if ((this.zoom_rmin !== rmin) || (this.zoom_rmax !== rmax)) {
  175.          this.zoom_rmin = rmin;
  176.          this.zoom_rmax = rmax;
  177.          this.redrawPad();
  178.       }
  179.    }
  181.    /** @summary Process mouse double click event */
  182.    mouseDoubleClick() {
  183.       if (this.zoom_rmin || this.zoom_rmax) {
  184.          this.zoom_rmin = this.zoom_rmax = 0;
  185.          this.redrawPad();
  186.       }
  187.    }
  189.    /** @summary Draw polargram polar labels */
  190.    async drawPolarLabels(polar, nmajor) {
  191.       const fontsize = Math.round(polar.fPolarTextSize * this.szy * 2);
  193.       return this.startTextDrawingAsync(polar.fPolarLabelFont, fontsize)
  194.                  .then(() => {
  195.          const lbls = (nmajor === 8) ? ['0', '#frac{#pi}{4}', '#frac{#pi}{2}', '#frac{3#pi}{4}', '#pi', '#frac{5#pi}{4}', '#frac{3#pi}{2}', '#frac{7#pi}{4}'] : ['0', '#frac{2#pi}{3}', '#frac{4#pi}{3}'],
  196.                aligns = [12, 11, 21, 31, 32, 33, 23, 13];
  198.          for (let n = 0; n < nmajor; ++n) {
  199.             const angle = -n*2*Math.PI/nmajor;
  200.             this.draw_g.append('svg:path')
  201.                .attr('d', `M0,0L${Math.round(this.szx*Math.cos(angle))},${Math.round(this.szy*Math.sin(angle))}`)
  202.                .call(this.lineatt.func);
  204.             let align = 12, rotate = 0;
  206.             if (this.options.OrthoLabels) {
  207.                rotate = -n/nmajor*360;
  208.                if ((rotate > -271) && (rotate < -91)) {
  209.                   align = 32; rotate += 180;
  210.                }
  211.             } else {
  212.                const aindx = Math.round(16 - angle/Math.PI*4) % 8; // index in align table, here absolute angle is important
  213.                align = aligns[aindx];
  214.             }
  216.             this.drawText({ align, rotate,
  217.                            x: Math.round((this.szx + fontsize)*Math.cos(angle)),
  218.                            y: Math.round((this.szy + fontsize/this.szx*this.szy)*(Math.sin(angle))),
  219.                            text: lbls[n],
  220.                            color: this.getColor(polar.fPolarLabelColor), latex: 1 });
  221.          }
  223.          return this.finishTextDrawing();
  224.       });
  225.    }
  227.    /** @summary Redraw polargram */
  228.    async redraw() {
  229.       if (!this.isMainPainter())
  230.          return;
  232.       const polar = this.getObject(),
  233.             rect = this.getPadPainter().getFrameRect();
  235.       this.createG();
  237.       makeTranslate(this.draw_g, Math.round(rect.x + rect.width/2), Math.round(rect.y + rect.height/2));
  238.       this.szx = rect.szx;
  239.       this.szy = rect.szy;
  241.       this.scale_rmin = polar.fRwrmin;
  242.       this.scale_rmax = polar.fRwrmax;
  243.       if (this.zoom_rmin !== this.zoom_rmax) {
  244.          this.scale_rmin = this.zoom_rmin;
  245.          this.scale_rmax = this.zoom_rmax;
  246.       }
  248.       this.r = scaleLinear().domain([this.scale_rmin, this.scale_rmax]).range([0, this.szx]);
  250.       if (polar.fRadian) {
  251.          polar.fRwtmin = 0; polar.fRwtmax = 2*Math.PI;
  252.       } else if (polar.fDegree) {
  253.          polar.fRwtmin = 0; polar.fRwtmax = 360;
  254.       } else if (polar.fGrad) {
  255.          polar.fRwtmin = 0; polar.fRwtmax = 200;
  256.       }
  258.       this.setAnglesRange(polar.fRwtmin, polar.fRwtmax);
  260.       const ticks = this.r.ticks(5);
  261.       let nminor = Math.floor((polar.fNdivRad % 10000) / 100),
  262.           nmajor = polar.fNdivPol % 100;
  263.       if (nmajor !== 3)
  264.          nmajor = 8;
  266.       this.createAttLine({ attr: polar });
  267.       if (!this.gridatt)
  268.          this.gridatt = this.createAttLine({ color: polar.fLineColor, style: 2, width: 1, std: false });
  270.       const range = Math.abs(polar.fRwrmax - polar.fRwrmin);
  271.       this.ndig = (range <= 0) ? -3 : Math.round(Math.log10(ticks.length / range));
  273.       // verify that all radius labels are unique
  274.       let lbls = [], indx = 0;
  275.       while (indx<ticks.length) {
  276.          const lbl = this.format(ticks[indx]);
  277.          if (lbls.indexOf(lbl) >= 0) {
  278.             if (++this.ndig>10) break;
  279.             lbls = []; indx = 0; continue;
  280.           }
  281.          lbls.push(lbl);
  282.          indx++;
  283.       }
  285.       let exclude_last = false;
  286.       const pointer_events = this.isBatchMode() ? null : 'visibleFill';
  288.       if ((ticks[ticks.length - 1] < polar.fRwrmax) && (this.zoom_rmin === this.zoom_rmax)) {
  289.          ticks.push(polar.fRwrmax);
  290.          exclude_last = true;
  291.       }
  293.       return this.startTextDrawingAsync(polar.fRadialLabelFont, Math.round(polar.fRadialTextSize * this.szy * 2)).then(() => {
  294.          const axis_angle = - (this.options.rangle || polar.fAxisAngle) / 180 * Math.PI,
  295.                ca = Math.cos(axis_angle),
  296.                sa = Math.sin(axis_angle);
  297.          for (let n = 0; n < ticks.length; ++n) {
  298.             let rx = this.r(ticks[n]),
  299.                 ry = rx / this.szx * this.szy;
  300.             this.draw_g.append('ellipse')
  301.                .attr('cx', 0)
  302.                .attr('cy', 0)
  303.                .attr('rx', Math.round(rx))
  304.                .attr('ry', Math.round(ry))
  305.                .style('fill', 'none')
  306.                .style('pointer-events', pointer_events)
  307.                .call(this.lineatt.func);
  309.             if ((n < ticks.length - 1) || !exclude_last) {
  310.                const halign = ca > 0.7 ? 1 : (ca > 0 ? 3 : (ca > -0.7 ? 1 : 3)),
  311.                      valign = Math.abs(ca) < 0.7 ? 1 : 3;
  312.                this.drawText({ align: 10 * halign + valign,
  313.                                x: Math.round(rx*ca),
  314.                                y: Math.round(ry*sa),
  315.                                text: this.format(ticks[n]),
  316.                                color: this.getColor(polar.fRadialLabelColor), latex: 0 });
  317.                if (this.options.rdot) {
  318.                   this.draw_g.append('ellipse')
  319.                      .attr('cx', Math.round(rx * ca))
  320.                      .attr('cy', Math.round(ry * sa))
  321.                      .attr('rx', 3)
  322.                      .attr('ry', 3)
  323.                      .style('fill', 'red');
  324.                }
  325.             }
  327.             if ((nminor > 1) && ((n < ticks.length - 1) || !exclude_last)) {
  328.                const dr = (ticks[1] - ticks[0]) / nminor;
  329.                for (let nn = 1; nn < nminor; ++nn) {
  330.                   const gridr = ticks[n] + dr*nn;
  331.                   if (gridr > this.scale_rmax) break;
  332.                   rx = this.r(gridr);
  333.                   ry = rx / this.szx * this.szy;
  334.                   this.draw_g.append('ellipse')
  335.                      .attr('cx', 0)
  336.                      .attr('cy', 0)
  337.                      .attr('rx', Math.round(rx))
  338.                      .attr('ry', Math.round(ry))
  339.                      .style('fill', 'none')
  340.                      .style('pointer-events', pointer_events)
  341.                      .call(this.gridatt.func);
  342.                }
  343.             }
  344.          }
  346.          if (ca < 0.999) {
  347.             this.draw_g.append('path')
  348.                 .attr('d', `M0,0L${Math.round(this.szx*ca)},${Math.round(this.szy*sa)}`)
  349.                 .style('pointer-events', pointer_events)
  350.                 .call(this.lineatt.func);
  351.          }
  353.          return this.finishTextDrawing();
  354.       }).then(() => {
  355.          return this.options.NoLabels ? true : this.drawPolarLabels(polar, nmajor);
  356.       }).then(() => {
  357.          nminor = Math.floor((polar.fNdivPol % 10000) / 100);
  359.          if (nminor > 1) {
  360.             for (let n = 0; n < nmajor * nminor; ++n) {
  361.                if (n % nminor === 0) continue;
  362.                const angle = -n*2*Math.PI/nmajor/nminor;
  363.                this.draw_g.append('svg:path')
  364.                    .attr('d', `M0,0L${Math.round(this.szx*Math.cos(angle))},${Math.round(this.szy*Math.sin(angle))}`)
  365.                    .call(this.gridatt.func);
  366.             }
  367.          }
  369.          if (this.isBatchMode())
  370.             return;
  372.          TooltipHandler.assign(this);
  374.          assignContextMenu(this, kNoReorder);
  376.          this.assignZoomHandler(this.draw_g);
  377.       });
  378.    }
  380.    /** @summary Fill TGraphPolargram context menu */
  381.    fillContextMenuItems(menu) {
  382.       const pp = this.getObject();
  383.       menu.sub('Axis range');
  384.       menu.addchk(pp.fRadian, 'Radian', flag => { pp.fRadian = flag; pp.fDegree = pp.fGrad = false; this.interactiveRedraw('pad', flag ? 'exec:SetToRadian()' : 'exec:SetTwoPi()'); }, 'Handle data angles as radian range 0..2*Pi');
  385.       menu.addchk(pp.fDegree, 'Degree', flag => { pp.fDegree = flag; pp.fRadian = pp.fGrad = false; this.interactiveRedraw('pad', flag ? 'exec:SetToDegree()' : 'exec:SetTwoPi()'); }, 'Handle data angles as degree range 0..360');
  386.       menu.addchk(pp.fGrad, 'Grad', flag => { pp.fGrad = flag; pp.fRadian = pp.fDegree = false; this.interactiveRedraw('pad', flag ? 'exec:SetToGrad()' : 'exec:SetTwoPi()'); }, 'Handle data angles as grad range 0..200');
  387.       menu.endsub();
  388.       menu.addSizeMenu('Axis angle', 0, 315, 45, this.options.rangle || pp.fAxisAngle, v => {
  389.          this.options.rangle = pp.fAxisAngle = v;
  390.          this.interactiveRedraw('pad', `exec:SetAxisAngle(${v})`);
  391.       });
  392.    }
  394.    /** @summary Assign zoom handler to element
  395.     * @private */
  396.    assignZoomHandler(elem) {
  397.       elem.on('mouseenter', evnt => this.mouseEvent('enter', evnt))
  398.           .on('mousemove', evnt => this.mouseEvent('move', evnt))
  399.           .on('mouseleave', evnt => this.mouseEvent('leave', evnt));
  401.       if (settings.Zooming)
  402.          elem.on('dblclick', evnt => this.mouseDoubleClick(evnt));
  404.       if (settings.Zooming && settings.ZoomWheel)
  405.          elem.on('wheel', evnt => this.mouseWheel(evnt));
  406.    }
  408.    /** @summary Draw TGraphPolargram */
  409.    static async draw(dom, polargram, opt) {
  410.       const main = getElementMainPainter(dom);
  411.       if (main) {
  412.          if (main.getObject() === polargram)
  413.             return main;
  414.          throw Error('Cannot superimpose TGraphPolargram with any other drawings');
  415.       }
  417.       const painter = new TGraphPolargramPainter(dom, polargram, opt);
  418.       return ensureTCanvas(painter, false).then(() => {
  419.          painter.setAsMainPainter();
  420.          return painter.redraw();
  421.       }).then(() => painter);
  422.    }
  424. } // class TGraphPolargramPainter
  427. /**
  428.  * @summary Painter for TGraphPolar objects.
  429.  *
  430.  * @private
  431.  */
  433. class TGraphPolarPainter extends ObjectPainter {
  435.    /** @summary Decode options for drawing TGraphPolar */
  436.    decodeOptions(opt) {
  437.       const d = new DrawOptions(opt || 'L');
  439.       if (!this.options)
  440.          this.options = {};
  442.       const rdot = d.check('RDOT'),
  443.             rangle = d.check('RANGLE', true) ? d.partAsInt() : 0;
  445.       Object.assign(this.options, {
  446.          mark: d.check('P'),
  447.          err: d.check('E'),
  448.          fill: d.check('F'),
  449.          line: d.check('L'),
  450.          curve: d.check('C'),
  451.          radian: d.check('R'),
  452.          degree: d.check('D'),
  453.          grad: d.check('G'),
  454.          Axis: d.check('N') ? 'N' : ''
  455.       });
  457.       if (d.check('O'))
  458.          this.options.Axis += 'O';
  459.       if (rdot)
  460.          this.options.Axis += '_rdot';
  461.       if (rangle)
  462.          this.options.Axis += `_rangle${rangle}`;
  464.       this.storeDrawOpt(opt);
  465.    }
  467.    /** @summary Update TGraphPolar with polargram */
  468.    updateObject(obj, opt) {
  469.       if (!this.matchObjectType(obj))
  470.          return false;
  472.       if (opt && (opt !== this.options.original))
  473.          this.decodeOptions(opt);
  475.       if (this._draw_axis && obj.fPolargram)
  476.          this.getMainPainter().updateObject(obj.fPolargram);
  478.       delete obj.fPolargram;
  479.       // copy all properties but not polargram
  480.       Object.assign(this.getObject(), obj);
  481.       return true;
  482.    }
  484.    /** @summary Redraw TGraphPolar */
  485.    redraw() {
  486.       return this.drawGraphPolar().then(() => this.updateTitle());
  487.    }
  489.    /** @summary Drawing TGraphPolar */
  490.    async drawGraphPolar() {
  491.       const graph = this.getObject(),
  492.             main = this.getMainPainter();
  494.       if (!graph || !main?.$polargram)
  495.          return;
  497.       if (this.options.mark)
  498.          this.createAttMarker({ attr: graph });
  499.       if (this.options.err || this.options.line || this.options.curve)
  500.          this.createAttLine({ attr: graph });
  501.       if (this.options.fill)
  502.          this.createAttFill({ attr: graph });
  504.       this.createG();
  506.       if (this._draw_axis && !main.isNormalAngles()) {
  507.          const has_err = graph.fEX?.length;
  508.          let rwtmin = graph.fX[0],
  509.              rwtmax = graph.fX[0];
  510.          for (let n = 0; n < graph.fNpoints; ++n) {
  511.             rwtmin = Math.min(rwtmin, graph.fX[n] - (has_err ? graph.fEX[n] : 0));
  512.             rwtmax = Math.max(rwtmax, graph.fX[n] + (has_err ? graph.fEX[n] : 0));
  513.          }
  514.          rwtmax += (rwtmax - rwtmin) / graph.fNpoints;
  515.          main.setAnglesRange(rwtmin, rwtmax, true);
  516.       }
  518.       this.draw_g.attr('transform', main.draw_g.attr('transform'));
  520.       let mpath = '', epath = '';
  521.       const bins = [], pointer_events = this.isBatchMode() ? null : 'visibleFill';
  523.       for (let n = 0; n < graph.fNpoints; ++n) {
  524.          if (graph.fY[n] > main.scale_rmax)
  525.             continue;
  527.          if (this.options.err) {
  528.             const p1 = main.translate(graph.fX[n], graph.fY[n] - graph.fEY[n]),
  529.                   p2 = main.translate(graph.fX[n], graph.fY[n] + graph.fEY[n]),
  530.                   p3 = main.translate(graph.fX[n] + graph.fEX[n], graph.fY[n]),
  531.                   p4 = main.translate(graph.fX[n] - graph.fEX[n], graph.fY[n]);
  533.             epath += `M${p1.grx},${p1.gry}L${p2.grx},${p2.gry}` +
  534.                      `M${p3.grx},${p3.gry}A${p4.rx},${p4.ry},0,0,1,${p4.grx},${p4.gry}`;
  535.          }
  537.          const pos = main.translate(graph.fX[n], graph.fY[n]);
  539.          if (this.options.mark)
  540.             mpath += this.markeratt.create(pos.grx, pos.gry);
  542.          if (this.options.curve || this.options.line || this.options.fill)
  543.             bins.push(pos);
  544.       }
  546.       if ((this.options.fill || this.options.line) && bins.length) {
  547.          const lpath = buildSvgCurve(bins, { line: true });
  548.          if (this.options.fill) {
  549.             this.draw_g.append('svg:path')
  550.                 .attr('d', lpath + 'Z')
  551.                 .style('pointer-events', pointer_events)
  552.                 .call(this.fillatt.func);
  553.          }
  555.          if (this.options.line) {
  556.             this.draw_g.append('svg:path')
  557.                 .attr('d', lpath)
  558.                 .style('fill', 'none')
  559.                 .style('pointer-events', pointer_events)
  560.                 .call(this.lineatt.func);
  561.          }
  562.       }
  564.       if (this.options.curve && bins.length) {
  565.          this.draw_g.append('svg:path')
  566.                  .attr('d', buildSvgCurve(bins))
  567.                  .style('fill', 'none')
  568.                  .style('pointer-events', pointer_events)
  569.                  .call(this.lineatt.func);
  570.       }
  572.       if (epath) {
  573.          this.draw_g.append('svg:path')
  574.              .attr('d', epath)
  575.              .style('fill', 'none')
  576.              .style('pointer-events', pointer_events)
  577.              .call(this.lineatt.func);
  578.       }
  580.       if (mpath) {
  581.          this.draw_g.append('svg:path')
  582.                .attr('d', mpath)
  583.                .style('pointer-events', pointer_events)
  584.                .call(this.markeratt.func);
  585.       }
  587.       if (!this.isBatchMode()) {
  588.          assignContextMenu(this, kNoReorder);
  589.          main.assignZoomHandler(this.draw_g);
  590.       }
  591.    }
  593.    /** @summary Create polargram object */
  594.    createPolargram(gr) {
  595.       if (!gr.fPolargram) {
  596.          gr.fPolargram = create('TGraphPolargram');
  597.          if (this.options.radian)
  598.             gr.fPolargram.fRadian = true;
  599.          else if (this.options.degree)
  600.             gr.fPolargram.fDegree = true;
  601.          else if (this.options.grad)
  602.             gr.fPolargram.fGrad = true;
  603.       }
  605.       let rmin = gr.fY[0] || 0, rmax = rmin;
  606.       const has_err = gr.fEY?.length;
  607.       for (let n = 0; n < gr.fNpoints; ++n) {
  608.          rmin = Math.min(rmin, gr.fY[n] - (has_err ? gr.fEY[n] : 0));
  609.          rmax = Math.max(rmax, gr.fY[n] + (has_err ? gr.fEY[n] : 0));
  610.       }
  612.       gr.fPolargram.fRwrmin = rmin - (rmax-rmin)*0.1;
  613.       gr.fPolargram.fRwrmax = rmax + (rmax-rmin)*0.1;
  615.       return gr.fPolargram;
  616.    }
  618.    /** @summary Provide tooltip at specified point */
  619.    extractTooltip(pnt) {
  620.       if (!pnt) return null;
  622.       const graph = this.getObject(),
  623.             main = this.getMainPainter();
  624.       let best_dist2 = 1e10, bestindx = -1, bestpos = null;
  626.       for (let n = 0; n < graph.fNpoints; ++n) {
  627.          const pos = main.translate(graph.fX[n], graph.fY[n]),
  628.                dist2 = (pos.grx - pnt.x)**2 + (pos.gry - pnt.y)**2;
  629.          if (dist2 < best_dist2) {
  630.             best_dist2 = dist2;
  631.             bestindx = n;
  632.             bestpos = pos;
  633.          }
  634.       }
  636.       let match_distance = 5;
  637.       if (this.markeratt?.used)
  638.          match_distance = this.markeratt.getFullSize();
  640.       if (Math.sqrt(best_dist2) > match_distance)
  641.          return null;
  643.       const res = {
  644.          name: this.getObject().fName, title: this.getObject().fTitle,
  645.          x: bestpos.grx, y: bestpos.gry,
  646.          color1: (this.markeratt?.used ? this.markeratt.color : undefined) ?? (this.fillatt?.used ? this.fillatt.color : undefined) ?? this.lineatt?.color,
  647.          exact: Math.sqrt(best_dist2) < 4,
  648.          lines: [this.getObjectHint()],
  649.          binindx: bestindx,
  650.          menu_dist: match_distance,
  651.          radius: match_distance
  652.       };
  654.       res.lines.push(`r = ${main.axisAsText('r', graph.fY[bestindx])}`,
  655.                      `phi = ${main.axisAsText('phi', graph.fX[bestindx])}`);
  657.       if (graph.fEY && graph.fEY[bestindx])
  658.          res.lines.push(`error r = ${main.axisAsText('r', graph.fEY[bestindx])}`);
  660.       if (graph.fEX && graph.fEX[bestindx])
  661.          res.lines.push(`error phi = ${main.axisAsText('phi', graph.fEX[bestindx])}`);
  663.       return res;
  664.    }
  666.    /** @summary Only redraw histogram title
  667.      * @return {Promise} with painter */
  668.    async updateTitle() {
  669.       // case when histogram drawn over other histogram (same option)
  670.       if (!this._draw_axis)
  671.          return this;
  673.       const tpainter = this.getPadPainter()?.findPainterFor(null, kTitle, clTPaveText),
  674.             pt = tpainter?.getObject();
  676.       if (!tpainter || !pt)
  677.          return this;
  679.       const gr = this.getObject(),
  680.             draw_title = !gr.TestBit(kNoTitle) && (gStyle.fOptTitle > 0);
  682.       pt.Clear();
  683.       if (draw_title) pt.AddText(gr.fTitle);
  684.       return tpainter.redraw().then(() => this);
  685.    }
  688.    /** @summary Draw histogram title
  689.      * @return {Promise} with painter */
  690.    async drawTitle() {
  691.       // case when histogram drawn over other histogram (same option)
  692.       if (!this._draw_axis)
  693.          return this;
  695.       const gr = this.getObject(),
  696.             st = gStyle,
  697.             draw_title = !gr.TestBit(kNoTitle) && (st.fOptTitle > 0),
  698.             pp = this.getPadPainter();
  700.       let pt = pp.findInPrimitives(kTitle, clTPaveText);
  702.       if (pt) {
  703.          pt.Clear();
  704.          if (draw_title)
  705.             pt.AddText(gr.fTitle);
  706.          return this;
  707.       }
  709.       pt = create(clTPaveText);
  710.       Object.assign(pt, { fName: kTitle, fFillColor: st.fTitleColor, fFillStyle: st.fTitleStyle, fBorderSize: st.fTitleBorderSize,
  711.                            fTextFont: st.fTitleFont, fTextSize: st.fTitleFontSize, fTextColor: st.fTitleTextColor, fTextAlign: 22 });
  713.       if (draw_title)
  714.          pt.AddText(gr.fTitle);
  715.       return TPavePainter.draw(pp, pt, kPosTitle)
  716.                          .then(p => { p?.setSecondaryId(this, kTitle); return this; });
  717.    }
  719.    /** @summary Show tooltip */
  720.    showTooltip(hint) {
  721.       let ttcircle = this.draw_g?.selectChild('.tooltip_bin');
  723.       if (!hint || !this.draw_g) {
  724.          ttcircle?.remove();
  725.          return;
  726.       }
  728.       if (ttcircle.empty()) {
  729.          ttcircle = this.draw_g.append('svg:ellipse')
  730.                              .attr('class', 'tooltip_bin')
  731.                              .style('pointer-events', 'none');
  732.       }
  734.       hint.changed = ttcircle.property('current_bin') !== hint.binindx;
  736.       if (hint.changed) {
  737.          ttcircle.attr('cx', hint.x)
  738.                .attr('cy', hint.y)
  739.                .attr('rx', Math.round(hint.radius))
  740.                .attr('ry', Math.round(hint.radius))
  741.                .style('fill', 'none')
  742.                .style('stroke', hint.color1)
  743.                .property('current_bin', hint.binindx);
  744.       }
  745.    }
  747.    /** @summary Process tooltip event */
  748.    processTooltipEvent(pnt) {
  749.       const hint = this.extractTooltip(pnt);
  750.       if (!pnt || !pnt.disabled)
  751.          this.showTooltip(hint);
  752.       return hint;
  753.    }
  755.    /** @summary Draw TGraphPolar */
  756.    static async draw(dom, graph, opt) {
  757.       const painter = new TGraphPolarPainter(dom, graph, opt);
  758.       painter.decodeOptions(opt);
  760.       const main = painter.getMainPainter();
  761.       if (main && !main.$polargram) {
  762.          console.error('Cannot superimpose TGraphPolar with plain histograms');
  763.          return null;
  764.       }
  766.       let pr = Promise.resolve(null);
  767.       if (!main) {
  768.          // indicate that axis defined by this graph
  769.          painter._draw_axis = true;
  770.          pr = TGraphPolargramPainter.draw(dom, painter.createPolargram(graph), painter.options.Axis);
  771.       }
  773.       return pr.then(gram_painter => {
  774.          gram_painter?.setSecondaryId(painter, 'polargram');
  775.          painter.addToPadPrimitives();
  776.          return painter.drawGraphPolar();
  777.       }).then(() => painter.drawTitle());
  778.    }
  780. } // class TGraphPolarPainter
  782. export { TGraphPolargramPainter, TGraphPolarPainter };