package.lib.tool.dividePath.js Maven / Gradle / Ivy
import { fromPoints } from '../core/bbox.js';
import BoundingRect from '../core/BoundingRect.js';
import Point from '../core/Point.js';
import { map } from '../core/util.js';
import Polygon from '../graphic/shape/Polygon.js';
import Rect from '../graphic/shape/Rect.js';
import Sector from '../graphic/shape/Sector.js';
import { pathToPolygons } from './convertPath.js';
import { clonePath } from './path.js';
function getDividingGrids(dimSize, rowDim, count) {
var rowSize = dimSize[rowDim];
var columnSize = dimSize[1 - rowDim];
var ratio = Math.abs(rowSize / columnSize);
var rowCount = Math.ceil(Math.sqrt(ratio * count));
var columnCount = Math.floor(count / rowCount);
if (columnCount === 0) {
columnCount = 1;
rowCount = count;
}
var grids = [];
for (var i = 0; i < rowCount; i++) {
grids.push(columnCount);
}
var currentCount = rowCount * columnCount;
var remained = count - currentCount;
if (remained > 0) {
for (var i = 0; i < remained; i++) {
grids[i % rowCount] += 1;
}
}
return grids;
}
function divideSector(sectorShape, count, outShapes) {
var r0 = sectorShape.r0;
var r = sectorShape.r;
var startAngle = sectorShape.startAngle;
var endAngle = sectorShape.endAngle;
var angle = Math.abs(endAngle - startAngle);
var arcLen = angle * r;
var deltaR = r - r0;
var isAngleRow = arcLen > Math.abs(deltaR);
var grids = getDividingGrids([arcLen, deltaR], isAngleRow ? 0 : 1, count);
var rowSize = (isAngleRow ? angle : deltaR) / grids.length;
for (var row = 0; row < grids.length; row++) {
var columnSize = (isAngleRow ? deltaR : angle) / grids[row];
for (var column = 0; column < grids[row]; column++) {
var newShape = {};
if (isAngleRow) {
newShape.startAngle = startAngle + rowSize * row;
newShape.endAngle = startAngle + rowSize * (row + 1);
newShape.r0 = r0 + columnSize * column;
newShape.r = r0 + columnSize * (column + 1);
}
else {
newShape.startAngle = startAngle + columnSize * column;
newShape.endAngle = startAngle + columnSize * (column + 1);
newShape.r0 = r0 + rowSize * row;
newShape.r = r0 + rowSize * (row + 1);
}
newShape.clockwise = sectorShape.clockwise;
newShape.cx = sectorShape.cx;
newShape.cy = sectorShape.cy;
outShapes.push(newShape);
}
}
}
function divideRect(rectShape, count, outShapes) {
var width = rectShape.width;
var height = rectShape.height;
var isHorizontalRow = width > height;
var grids = getDividingGrids([width, height], isHorizontalRow ? 0 : 1, count);
var rowSizeDim = isHorizontalRow ? 'width' : 'height';
var columnSizeDim = isHorizontalRow ? 'height' : 'width';
var rowDim = isHorizontalRow ? 'x' : 'y';
var columnDim = isHorizontalRow ? 'y' : 'x';
var rowSize = rectShape[rowSizeDim] / grids.length;
for (var row = 0; row < grids.length; row++) {
var columnSize = rectShape[columnSizeDim] / grids[row];
for (var column = 0; column < grids[row]; column++) {
var newShape = {};
newShape[rowDim] = row * rowSize;
newShape[columnDim] = column * columnSize;
newShape[rowSizeDim] = rowSize;
newShape[columnSizeDim] = columnSize;
newShape.x += rectShape.x;
newShape.y += rectShape.y;
outShapes.push(newShape);
}
}
}
function crossProduct2d(x1, y1, x2, y2) {
return x1 * y2 - x2 * y1;
}
function lineLineIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
var mx = a2x - a1x;
var my = a2y - a1y;
var nx = b2x - b1x;
var ny = b2y - b1y;
var nmCrossProduct = crossProduct2d(nx, ny, mx, my);
if (Math.abs(nmCrossProduct) < 1e-6) {
return null;
}
var b1a1x = a1x - b1x;
var b1a1y = a1y - b1y;
var p = crossProduct2d(b1a1x, b1a1y, nx, ny) / nmCrossProduct;
if (p < 0 || p > 1) {
return null;
}
return new Point(p * mx + a1x, p * my + a1y);
}
function projPtOnLine(pt, lineA, lineB) {
var dir = new Point();
Point.sub(dir, lineB, lineA);
dir.normalize();
var dir2 = new Point();
Point.sub(dir2, pt, lineA);
var len = dir2.dot(dir);
return len;
}
function addToPoly(poly, pt) {
var last = poly[poly.length - 1];
if (last && last[0] === pt[0] && last[1] === pt[1]) {
return;
}
poly.push(pt);
}
function splitPolygonByLine(points, lineA, lineB) {
var len = points.length;
var intersections = [];
for (var i = 0; i < len; i++) {
var p0 = points[i];
var p1 = points[(i + 1) % len];
var intersectionPt = lineLineIntersect(p0[0], p0[1], p1[0], p1[1], lineA.x, lineA.y, lineB.x, lineB.y);
if (intersectionPt) {
intersections.push({
projPt: projPtOnLine(intersectionPt, lineA, lineB),
pt: intersectionPt,
idx: i
});
}
}
if (intersections.length < 2) {
return [{ points: points }, { points: points }];
}
intersections.sort(function (a, b) {
return a.projPt - b.projPt;
});
var splitPt0 = intersections[0];
var splitPt1 = intersections[intersections.length - 1];
if (splitPt1.idx < splitPt0.idx) {
var tmp = splitPt0;
splitPt0 = splitPt1;
splitPt1 = tmp;
}
var splitPt0Arr = [splitPt0.pt.x, splitPt0.pt.y];
var splitPt1Arr = [splitPt1.pt.x, splitPt1.pt.y];
var newPolyA = [splitPt0Arr];
var newPolyB = [splitPt1Arr];
for (var i = splitPt0.idx + 1; i <= splitPt1.idx; i++) {
addToPoly(newPolyA, points[i].slice());
}
addToPoly(newPolyA, splitPt1Arr);
addToPoly(newPolyA, splitPt0Arr);
for (var i = splitPt1.idx + 1; i <= splitPt0.idx + len; i++) {
addToPoly(newPolyB, points[i % len].slice());
}
addToPoly(newPolyB, splitPt0Arr);
addToPoly(newPolyB, splitPt1Arr);
return [{
points: newPolyA
}, {
points: newPolyB
}];
}
function binaryDividePolygon(polygonShape) {
var points = polygonShape.points;
var min = [];
var max = [];
fromPoints(points, min, max);
var boundingRect = new BoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);
var width = boundingRect.width;
var height = boundingRect.height;
var x = boundingRect.x;
var y = boundingRect.y;
var pt0 = new Point();
var pt1 = new Point();
if (width > height) {
pt0.x = pt1.x = x + width / 2;
pt0.y = y;
pt1.y = y + height;
}
else {
pt0.y = pt1.y = y + height / 2;
pt0.x = x;
pt1.x = x + width;
}
return splitPolygonByLine(points, pt0, pt1);
}
function binaryDivideRecursive(divider, shape, count, out) {
if (count === 1) {
out.push(shape);
}
else {
var mid = Math.floor(count / 2);
var sub = divider(shape);
binaryDivideRecursive(divider, sub[0], mid, out);
binaryDivideRecursive(divider, sub[1], count - mid, out);
}
return out;
}
export function clone(path, count) {
var paths = [];
for (var i = 0; i < count; i++) {
paths.push(clonePath(path));
}
return paths;
}
function copyPathProps(source, target) {
target.setStyle(source.style);
target.z = source.z;
target.z2 = source.z2;
target.zlevel = source.zlevel;
}
function polygonConvert(points) {
var out = [];
for (var i = 0; i < points.length;) {
out.push([points[i++], points[i++]]);
}
return out;
}
export function split(path, count) {
var outShapes = [];
var shape = path.shape;
var OutShapeCtor;
switch (path.type) {
case 'rect':
divideRect(shape, count, outShapes);
OutShapeCtor = Rect;
break;
case 'sector':
divideSector(shape, count, outShapes);
OutShapeCtor = Sector;
break;
case 'circle':
divideSector({
r0: 0, r: shape.r, startAngle: 0, endAngle: Math.PI * 2,
cx: shape.cx, cy: shape.cy
}, count, outShapes);
OutShapeCtor = Sector;
break;
default:
var m = path.getComputedTransform();
var scale = m ? Math.sqrt(Math.max(m[0] * m[0] + m[1] * m[1], m[2] * m[2] + m[3] * m[3])) : 1;
var polygons = map(pathToPolygons(path.getUpdatedPathProxy(), scale), function (poly) { return polygonConvert(poly); });
var polygonCount = polygons.length;
if (polygonCount === 0) {
binaryDivideRecursive(binaryDividePolygon, {
points: polygons[0]
}, count, outShapes);
}
else if (polygonCount === count) {
for (var i = 0; i < polygonCount; i++) {
outShapes.push({
points: polygons[i]
});
}
}
else {
var totalArea_1 = 0;
var items = map(polygons, function (poly) {
var min = [];
var max = [];
fromPoints(poly, min, max);
var area = (max[1] - min[1]) * (max[0] - min[0]);
totalArea_1 += area;
return { poly: poly, area: area };
});
items.sort(function (a, b) { return b.area - a.area; });
var left = count;
for (var i = 0; i < polygonCount; i++) {
var item = items[i];
if (left <= 0) {
break;
}
var selfCount = i === polygonCount - 1
? left
: Math.ceil(item.area / totalArea_1 * count);
if (selfCount < 0) {
continue;
}
binaryDivideRecursive(binaryDividePolygon, {
points: item.poly
}, selfCount, outShapes);
left -= selfCount;
}
;
}
OutShapeCtor = Polygon;
break;
}
if (!OutShapeCtor) {
return clone(path, count);
}
var out = [];
for (var i = 0; i < outShapes.length; i++) {
var subPath = new OutShapeCtor();
subPath.setShape(outShapes[i]);
copyPathProps(path, subPath);
out.push(subPath);
}
return out;
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy