semiotic 2.0.3 → 3.0.0-beta.1

package/ai/dist/src/components/svg/SvgHelper.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupBarMark = exports.drawAreaConnector = exports.arcTweener = void 0;
+exports.linearRibbon = linearRibbon;
+const d3_shape_1 = require("d3-shape");
+const d3_interpolate_1 = require("d3-interpolate");
+const emptyObjectReturnFn = () => ({});
+const twoPI = Math.PI * 2;
+const dedupeRibbonPoints = (weight = 1) => (p, c) => {
+    const l = p[p.length - 1];
+    if (!l ||
+        Math.round(l.x / weight) !== Math.round(c.x / weight) ||
+        Math.round(l.y / weight) !== Math.round(c.y / weight)) {
+        p.push(c);
+    }
+    return p;
+};
+const arcTweener = (oldProps, newProps) => {
+    const innerRadiusInterpolator = (0, d3_interpolate_1.interpolateNumber)(oldProps.innerRadius, newProps.innerRadius);
+    const outerRadiusInterpolator = (0, d3_interpolate_1.interpolateNumber)(oldProps.outerRadius, newProps.outerRadius);
+    const startAngleInterpolator = (0, d3_interpolate_1.interpolateNumber)(oldProps.startAngle, newProps.startAngle);
+    const endAngleInterpolator = (0, d3_interpolate_1.interpolateNumber)(oldProps.endAngle, newProps.endAngle);
+    return (t) => {
+        const sliceGenerator = (0, d3_shape_1.arc)()
+            .innerRadius(innerRadiusInterpolator(t))
+            .outerRadius(outerRadiusInterpolator(t));
+        return sliceGenerator({
+            startAngle: startAngleInterpolator(t),
+            endAngle: endAngleInterpolator(t)
+        });
+    };
+};
+exports.arcTweener = arcTweener;
+const drawAreaConnector = ({ x1, x2, y1, y2, sizeX1, sizeY1, sizeX2, sizeY2 }) => {
+    return `M${x1},${y1}L${x2},${y2}L${x2 + sizeX2},${y2 + sizeY2}L${x1 + sizeX1},${y1 + sizeY1}Z`;
+};
+exports.drawAreaConnector = drawAreaConnector;
+const groupBarMark = ({ bins, binMax, relativeBuckets, columnWidth, projection, adjustedSize, summaryI, summary, summaryStyle, type }) => {
+    const mappedBins = [];
+    const mappedPoints = [];
+    const actualMax = (relativeBuckets && relativeBuckets[summary.name]) || binMax;
+    const summaryElementStylingFn = type.elementStyleFn || emptyObjectReturnFn;
+    const barPadding = type.padding || 0;
+    bins.forEach((d, i) => {
+        const opacity = d.value / actualMax;
+        const additionalStyle = summaryElementStylingFn(d.value, opacity, d.pieces);
+        const finalStyle = type.type === "heatmap"
+            ? { opacity: opacity, fill: summaryStyle.fill, ...additionalStyle }
+            : { ...summaryStyle, ...additionalStyle };
+        const thickness = Math.max(1, d.y1 - barPadding * 2);
+        const finalColumnWidth = type.type === "heatmap" ? columnWidth : columnWidth * opacity;
+        let yProp = d.y + barPadding;
+        let xProp = type.type === "heatmap" || type.flip
+            ? -columnWidth / 2
+            : columnWidth / 2 - finalColumnWidth;
+        let height = thickness;
+        let width = finalColumnWidth;
+        let xOffset = type.type === "heatmap" ? finalColumnWidth / 2 : finalColumnWidth;
+        let yOffset = d.y1 / 2;
+        if (projection === "horizontal") {
+            yProp =
+                type.type === "heatmap"
+                    ? -columnWidth / 2
+                    : type.flip
+                        ? -columnWidth / 2
+                        : columnWidth / 2 - finalColumnWidth;
+            xProp = d.y - d.y1 + barPadding;
+            height = finalColumnWidth;
+            width = thickness;
+            yOffset =
+                type.type === "heatmap" ? finalColumnWidth / 2 : finalColumnWidth;
+            xOffset = d.y1 / 2;
+        }
+        else if (projection === "radial") {
+            const arcGenerator = (0, d3_shape_1.arc)()
+                .innerRadius(d.y / 2)
+                .outerRadius((d.y + d.y1) / 2);
+            const angle = summary.pct - summary.pct_padding;
+            let startAngle = summary.pct_middle - summary.pct_padding;
+            let endAngle = type.type === "heatmap"
+                ? startAngle + angle
+                : startAngle + angle * opacity;
+            startAngle *= twoPI;
+            endAngle *= twoPI;
+            const arcAdjustX = adjustedSize[0] / 2;
+            const arcAdjustY = adjustedSize[1] / 2;
+            const arcTranslate = `translate(${arcAdjustX},${arcAdjustY})`;
+            const arcCenter = arcGenerator.centroid({ startAngle, endAngle });
+            mappedPoints.push({
+                key: summary.name,
+                value: d.value,
+                pieces: d.pieces.map((p) => p.piece),
+                label: "Heatmap",
+                x: arcCenter[0] + arcAdjustX,
+                y: arcCenter[1] + arcAdjustY
+            });
+            mappedBins.push({
+                markType: "path",
+                transform: arcTranslate,
+                key: `groupIcon-${summaryI}-${i}`,
+                d: arcGenerator({ startAngle, endAngle }),
+                style: finalStyle
+            });
+        }
+        if (projection !== "radial") {
+            mappedPoints.push({
+                key: summary.name,
+                value: d.value,
+                pieces: d.pieces.map((p) => p.piece),
+                label: "Heatmap",
+                x: xProp + xOffset,
+                y: yProp + yOffset
+            });
+            mappedBins.push({
+                markType: "rect",
+                key: `groupIcon-${summaryI}-${i}`,
+                x: xProp,
+                y: yProp,
+                height: height,
+                width: width,
+                style: finalStyle
+            });
+        }
+    });
+    return { marks: mappedBins, points: mappedPoints };
+};
+exports.groupBarMark = groupBarMark;
+// FROM d3-svg-ribbon
+function linearRibbon() {
+    const _lineConstructor = (0, d3_shape_1.line)();
+    let _xAccessor = function (d) {
+        return d.x;
+    };
+    let _yAccessor = function (d) {
+        return d.y;
+    };
+    let _rAccessor = function (d) {
+        return d.r;
+    };
+    let _interpolator = d3_shape_1.curveLinearClosed;
+    function _ribbon(pathData) {
+        if (pathData.multiple) {
+            const original_r = _rAccessor;
+            const parallelTotal = pathData.multiple.reduce((p, c) => p + c.weight, 0);
+            _rAccessor = () => parallelTotal;
+            const totalPoints = buildRibbon(pathData.points);
+            let currentPoints = totalPoints
+                .filter((d) => d.direction === "forward")
+                .reduce(dedupeRibbonPoints(), []);
+            const allRibbons = [];
+            pathData.multiple.forEach((siblingPath, siblingI) => {
+                _rAccessor = () => siblingPath.weight;
+                const currentRibbon = buildRibbon(currentPoints);
+                allRibbons.push(currentRibbon);
+                const nextSibling = pathData.multiple[siblingI + 1];
+                if (nextSibling) {
+                    const currentLeftSide = currentRibbon
+                        .reverse()
+                        .filter((d) => d.direction === "back")
+                        .reduce(dedupeRibbonPoints(), []);
+                    _rAccessor = () => nextSibling.weight;
+                    const leftHandInflatedRibbon = buildRibbon(currentLeftSide);
+                    currentPoints = leftHandInflatedRibbon
+                        .reverse()
+                        .filter((d) => d.direction === "back")
+                        .reduce(dedupeRibbonPoints(), []);
+                }
+            });
+            _rAccessor = original_r;
+            return allRibbons.map((d) => _lineConstructor.x(_xAccessor).y(_yAccessor).curve(_interpolator)(d));
+        }
+        const bothPoints = buildRibbon(pathData).reduce(dedupeRibbonPoints(), []);
+        return _lineConstructor.x(_xAccessor).y(_yAccessor).curve(_interpolator)(bothPoints);
+    }
+    _ribbon.x = function (_value) {
+        if (!arguments.length)
+            return _xAccessor;
+        _xAccessor = _value;
+        return _ribbon;
+    };
+    _ribbon.y = function (_value) {
+        if (!arguments.length)
+            return _yAccessor;
+        _yAccessor = _value;
+        return _ribbon;
+    };
+    _ribbon.r = function (_value) {
+        if (!arguments.length)
+            return _rAccessor;
+        _rAccessor = _value;
+        return _ribbon;
+    };
+    _ribbon.interpolate = function (_value) {
+        if (!arguments.length)
+            return _interpolator;
+        _interpolator = _value;
+        return _ribbon;
+    };
+    return _ribbon;
+    function offsetEdge(d) {
+        const diffX = _yAccessor(d.target) - _yAccessor(d.source);
+        const diffY = _xAccessor(d.target) - _xAccessor(d.source);
+        const angle0 = Math.atan2(diffY, diffX) + Math.PI / 2;
+        const angle1 = angle0 + Math.PI * 0.5;
+        const angle2 = angle0 + Math.PI * 0.5;
+        const x1 = _xAccessor(d.source) + _rAccessor(d.source) * Math.cos(angle1);
+        const y1 = _yAccessor(d.source) - _rAccessor(d.source) * Math.sin(angle1);
+        const x2 = _xAccessor(d.target) + _rAccessor(d.target) * Math.cos(angle2);
+        const y2 = _yAccessor(d.target) - _rAccessor(d.target) * Math.sin(angle2);
+        return { x1: x1, y1: y1, x2: x2, y2: y2 };
+    }
+    function buildRibbon(points) {
+        const bothCode = [];
+        let x = 0;
+        let transformedPoints = { x1: 0, y1: 0, x2: 0, y2: 0 };
+        while (x < points.length) {
+            if (x !== points.length - 1) {
+                transformedPoints = offsetEdge({
+                    source: points[x],
+                    target: points[x + 1]
+                });
+                const p1 = {
+                    x: transformedPoints.x1,
+                    y: transformedPoints.y1,
+                    direction: "forward"
+                };
+                const p2 = {
+                    x: transformedPoints.x2,
+                    y: transformedPoints.y2,
+                    direction: "forward"
+                };
+                bothCode.push(p1, p2);
+                if (bothCode.length > 3) {
+                    const l = bothCode.length - 1;
+                    const lineA = { a: bothCode[l - 3], b: bothCode[l - 2] };
+                    const lineB = { a: bothCode[l - 1], b: bothCode[l] };
+                    const intersect = findIntersect(lineA.a.x, lineA.a.y, lineA.b.x, lineA.b.y, lineB.a.x, lineB.a.y, lineB.b.x, lineB.b.y);
+                    if (intersect.found === true) {
+                        lineA.b.x = intersect.x;
+                        lineA.b.y = intersect.y;
+                        lineB.a.x = intersect.x;
+                        lineB.a.y = intersect.y;
+                    }
+                }
+            }
+            x++;
+        }
+        x--;
+        //Back
+        while (x >= 0) {
+            if (x !== 0) {
+                transformedPoints = offsetEdge({
+                    source: points[x],
+                    target: points[x - 1]
+                });
+                const p1 = {
+                    x: transformedPoints.x1,
+                    y: transformedPoints.y1,
+                    direction: "back"
+                };
+                const p2 = {
+                    x: transformedPoints.x2,
+                    y: transformedPoints.y2,
+                    direction: "back"
+                };
+                bothCode.push(p1, p2);
+                if (bothCode.length > 3) {
+                    const l = bothCode.length - 1;
+                    const lineA = { a: bothCode[l - 3], b: bothCode[l - 2] };
+                    const lineB = { a: bothCode[l - 1], b: bothCode[l] };
+                    const intersect = findIntersect(lineA.a.x, lineA.a.y, lineA.b.x, lineA.b.y, lineB.a.x, lineB.a.y, lineB.b.x, lineB.b.y);
+                    if (intersect.found === true) {
+                        lineA.b.x = intersect.x;
+                        lineA.b.y = intersect.y;
+                        lineB.a.x = intersect.x;
+                        lineB.a.y = intersect.y;
+                    }
+                }
+            }
+            x--;
+        }
+        return bothCode;
+    }
+    function findIntersect(l1x1, l1y1, l1x2, l1y2, l2x1, l2y1, l2x2, l2y2) {
+        let a, b;
+        const result = {
+            x: null,
+            y: null,
+            found: false
+        };
+        const d = (l2y2 - l2y1) * (l1x2 - l1x1) - (l2x2 - l2x1) * (l1y2 - l1y1);
+        if (d === 0) {
+            return result;
+        }
+        a = l1y1 - l2y1;
+        b = l1x1 - l2x1;
+        const n1 = (l2x2 - l2x1) * a - (l2y2 - l2y1) * b;
+        const n2 = (l1x2 - l1x1) * a - (l1y2 - l1y1) * b;
+        a = n1 / d;
+        b = n2 / d;
+        result.x = l1x1 + a * (l1x2 - l1x1);
+        result.y = l1y1 + a * (l1y2 - l1y1);
+        if (a > 0 && a < 1 && b > 0 && b < 1) {
+            result.found = true;
+        }
+        return result;
+    }
+}

package/ai/dist/src/components/svg/areaDrawing.js

@@ -0,0 +1,312 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexbinning = exports.contouring = void 0;
+exports.lineBounding = lineBounding;
+exports.heatmapping = heatmapping;
+exports.trendlining = trendlining;
+exports.shapeBounds = shapeBounds;
+const React = __importStar(require("react"));
+const d3_scale_1 = require("d3-scale");
+const regression_1 = __importDefault(require("regression"));
+const d3_shape_1 = require("d3-shape");
+// Re-export from new locations for backwards compatibility
+var contourLayout_1 = require("./contourLayout");
+Object.defineProperty(exports, "contouring", { enumerable: true, get: function () { return contourLayout_1.contouring; } });
+var hexbinLayout_1 = require("./hexbinLayout");
+Object.defineProperty(exports, "hexbinning", { enumerable: true, get: function () { return hexbinLayout_1.hexbinning; } });
+const generateLineBounds = (xydata, basedata, topBoundingAccessor, bottomBoundingAccessor) => {
+    const tops = xydata.map((d, i) => [
+        d[0],
+        d[1] + topBoundingAccessor(basedata[i])
+    ]);
+    const bottoms = xydata.map((d, i) => [
+        d[0],
+        d[1] - bottomBoundingAccessor(basedata[i])
+    ]);
+    return [...tops, ...bottoms.reverse()];
+};
+function lineBounding({ summaryType, data, defined }) {
+    let projectedSummaries = [];
+    if (!summaryType.type) {
+        summaryType = { type: summaryType };
+    }
+    const { boundingAccessor, topBoundingAccessor = boundingAccessor, bottomBoundingAccessor = boundingAccessor } = summaryType;
+    data.forEach((lineData) => {
+        const definedData = lineData._baseData.map(defined);
+        let currentBaseData = [];
+        let currentXYFC = [];
+        const boundingPieces = [
+            {
+                xyf: currentXYFC,
+                base: currentBaseData
+            }
+        ];
+        definedData.forEach((d, i) => {
+            if (d === true) {
+                currentBaseData.push(lineData._baseData[i]);
+                currentXYFC.push(lineData._xyfCoordinates[i]);
+            }
+            else if (definedData[i + 1]) {
+                currentBaseData = [];
+                currentXYFC = [];
+                boundingPieces.push({
+                    xyf: currentXYFC,
+                    base: currentBaseData
+                });
+            }
+        });
+        boundingPieces.forEach(({ xyf, base }) => {
+            const boundingProjectedSummary = {
+                data: lineData,
+                parentSummary: lineData,
+                _xyfCoordinates: generateLineBounds(xyf, base, topBoundingAccessor, bottomBoundingAccessor)
+            };
+            projectedSummaries = [...projectedSummaries, boundingProjectedSummary];
+        });
+    });
+    return projectedSummaries;
+}
+function heatmapping({ preprocess = true, processedData = false, summaryType: baseSummaryType, data: baseData, finalXExtent = [
+    Math.min(...baseData.coordinates.map((d) => d.x)),
+    Math.max(...baseData.coordinates.map((d) => d.x))
+], finalYExtent = [
+    Math.min(...baseData.coordinates.map((d) => d.y)),
+    Math.max(...baseData.coordinates.map((d) => d.y))
+], size, xScaleType = (0, d3_scale_1.scaleLinear)(), yScaleType = (0, d3_scale_1.scaleLinear)(), margin, styleFn, classFn, renderFn, chartSize }) {
+    if (processedData && baseData) {
+        return baseData.coordinates;
+    }
+    if (baseData.coordinates && !baseData._xyfCoordinates) {
+        baseData._xyfCoordinates = baseData.coordinates.map((d) => [d.x, d.y]);
+    }
+    const data = Array.isArray(baseData) ? baseData : [baseData];
+    let projectedSummaries = [];
+    let summaryType;
+    if (!baseSummaryType.type) {
+        summaryType = { type: summaryType };
+    }
+    else {
+        summaryType = baseSummaryType;
+    }
+    const { 
+    //    binGraphic = "square",
+    binValue = (d) => d.length, xBins = summaryType.yBins || 0.05, yBins = xBins, xCellPx = !summaryType.xBins && summaryType.xCellPx, yCellPx = !summaryType.yBins && summaryType.yCellPx, customMark, binMax } = summaryType;
+    const xBinPercent = xBins < 1 ? xBins : 1 / xBins;
+    const yBinPercent = yBins < 1 ? yBins : 1 / yBins;
+    const heatmapBinXScale = xScaleType.domain(finalXExtent).range([0, size[0]]);
+    const heatmapBinYScale = yScaleType.domain(finalYExtent).range([size[1], 0]);
+    const actualResolution = [
+        Math.ceil(((xCellPx && xCellPx / size[0]) || xBinPercent) * size[0] * 10) /
+            10,
+        Math.ceil(((yCellPx && yCellPx / size[1]) || yBinPercent) * size[1] * 10) /
+            10
+    ];
+    let maxValue = -Infinity;
+    data.forEach((heatmapData) => {
+        const grid = [];
+        const flatGrid = [];
+        let cell;
+        let gridColumn;
+        for (let i = 0; Math.ceil(i) < size[0]; i += actualResolution[0]) {
+            const x = heatmapBinXScale.invert(i);
+            const x1 = heatmapBinXScale.invert(i + actualResolution[0]);
+            gridColumn = [];
+            grid.push(gridColumn);
+            for (let j = 0; Math.ceil(j) < size[1]; j += actualResolution[1]) {
+                const y = heatmapBinYScale.invert(j);
+                const y1 = heatmapBinYScale.invert(j + actualResolution[1]);
+                cell = {
+                    gx: i,
+                    gy: j,
+                    gw: actualResolution[0],
+                    gh: actualResolution[1],
+                    x: (x + x1) / 2,
+                    y: (y + y1) / 2,
+                    binItems: [],
+                    value: 0,
+                    _xyfCoordinates: [
+                        [x, y],
+                        [x1, y],
+                        [x1, y1],
+                        [x, y1]
+                    ],
+                    parentSummary: heatmapData
+                };
+                gridColumn.push(cell);
+                flatGrid.push(cell);
+            }
+            gridColumn.push(cell);
+        }
+        grid.push(gridColumn);
+        heatmapData._xyfCoordinates.forEach((d, di) => {
+            const baseX = heatmapBinXScale(d[0]);
+            const baseY = heatmapBinYScale(d[1]);
+            const xCoordinate = Math.floor(baseX / actualResolution[0]);
+            const yCoordinate = Math.floor(baseY / actualResolution[1]);
+            if (grid[xCoordinate][yCoordinate]) {
+                grid[xCoordinate][yCoordinate].binItems.push(heatmapData.coordinates[di]);
+            }
+        });
+        flatGrid.forEach((d) => {
+            d.value = binValue(d.binItems);
+            maxValue = Math.max(maxValue, d.value);
+        });
+        flatGrid.forEach((d) => {
+            d.percent = d.value / maxValue;
+            d.customMark = customMark && (React.createElement("g", { transform: `translate(${d.gx},${d.gy})` }, customMark({
+                d,
+                margin,
+                styleFn,
+                classFn,
+                renderFn,
+                chartSize,
+                adjustedSize: size
+            })));
+        });
+        projectedSummaries = [...projectedSummaries, ...flatGrid];
+    });
+    if (binMax) {
+        binMax(maxValue);
+    }
+    if (preprocess) {
+        const preprocessedSummary = {
+            type: "heatmap",
+            processedData: true,
+            _baseData: [],
+            _xyfCoordinates: [],
+            data: [],
+            bounds: [],
+            x: 0,
+            y: 0,
+            coordinates: projectedSummaries,
+            binMax: maxValue
+        };
+        return preprocessedSummary;
+    }
+    return projectedSummaries;
+}
+function trendlining({ preprocess = false, summaryType: baseSummaryType, data: baseData, finalXExtent = [
+    Math.min(...baseData.coordinates.map((d) => d.x)),
+    Math.max(...baseData.coordinates.map((d) => d.x))
+], xScaleType = (0, d3_scale_1.scaleLinear)() }) {
+    if (preprocess) {
+        return baseData[0].coordinates;
+    }
+    let projectedSummaries = [];
+    let summaryType;
+    if (!baseSummaryType.type) {
+        summaryType = { type: summaryType };
+    }
+    else {
+        summaryType = baseSummaryType;
+    }
+    const { regressionType: baseRegressionType = "linear", order = 2, precision = 4, controlPoints = 20, curve = d3_shape_1.curveCardinal } = summaryType;
+    let regressionType = baseRegressionType;
+    if (finalXExtent[0] < 0 &&
+        (baseRegressionType === "logarithmic" ||
+            baseRegressionType === "power" ||
+            baseRegressionType === "exponential")) {
+        console.error(`Cannot use this ${baseRegressionType} regressionType type with value range that goes below 0, defaulting to linear`);
+        regressionType = "linear";
+    }
+    if (baseData.coordinates && !baseData._xyfCoordinates) {
+        baseData._xyfCoordinates = baseData.coordinates.map((d) => [d.x, d.y]);
+    }
+    const data = Array.isArray(baseData) ? baseData : [baseData];
+    const xScale = xScaleType.domain([0, 1]).range(finalXExtent);
+    projectedSummaries = [];
+    data.forEach((bdata) => {
+        const regressionLine = regression_1.default[regressionType](bdata._xyfCoordinates.map((d) => {
+            let x = d[0];
+            let y = d[1];
+            if (typeof x !== "number") {
+                x = x.getTime();
+            }
+            if (typeof y !== "number") {
+                y = y.getTime();
+            }
+            return [x, y];
+        }), {
+            order,
+            precision
+        });
+        const controlStep = 1 / controlPoints;
+        let steps = [0, 1];
+        if (regressionType !== "linear") {
+            steps = [];
+            for (let step = 0; step < 1 + controlStep; step += controlStep) {
+                steps.push(step);
+            }
+        }
+        const controlPointArray = [];
+        steps.forEach((controlPoint) => {
+            controlPointArray.push(regressionLine.predict(xScale(controlPoint)));
+        });
+        projectedSummaries.push({
+            centroid: false,
+            customMark: undefined,
+            data: bdata,
+            parentSummary: bdata,
+            value: regressionLine.string,
+            r2: regressionLine.r2,
+            curve,
+            _xyfCoordinates: controlPointArray
+        });
+    });
+    return projectedSummaries;
+}
+function shapeBounds(coordinates) {
+    let left = [Infinity, 0];
+    let right = [-Infinity, 0];
+    let top = [0, Infinity];
+    let bottom = [0, -Infinity];
+    coordinates.forEach((d) => {
+        left = d[0] < left[0] ? d : left;
+        right = d[0] > right[0] ? d : right;
+        bottom = d[1] > bottom[1] ? d : bottom;
+        top = d[1] < top[1] ? d : top;
+    });
+    return {
+        center: [(left[0] + right[0]) / 2, (top[1] + bottom[1]) / 2],
+        top,
+        left,
+        right,
+        bottom
+    };
+}