Extrude.java

Go to the documentation of this file.

 
package eu.mihosoft.vrl.v3d;
 
import java.util.ArrayList;
import com.piro.bezier.BezierPath;
import eu.mihosoft.vrl.v3d.Transform;
import eu.mihosoft.vrl.v3d.svg.*;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
 
//import javax.vecmath.Vector3d;
 
import eu.mihosoft.vrl.v3d.ext.org.poly2tri.PolygonUtil;
import eu.mihosoft.vrl.v3d.ext.quickhull3d.HullUtil;
 
// TODO: Auto-generated Javadoc
public class Extrude {
    private static IExtrusion extrusionEngine = new IExtrusion() {
        public CSG points(Vector3d dir, List<Vector3d> points) {
 
            List<Vector3d> newList = new ArrayList<>(points);
 
            return extrude(dir, Polygon.fromPoints(toCCW(newList)));
        }
 
        public CSG extrude(Vector3d dir, Polygon polygon1) {
 
            return monotoneExtrude(dir, polygon1);
        }
 
        private CSG monotoneExtrude(Vector3d dir, Polygon polygon1) {
            List<Polygon> newPolygons = new ArrayList<>();
            CSG extrude;
            //polygon1=polygon1.flipped();
            newPolygons.addAll(PolygonUtil.concaveToConvex(polygon1.flipped()));
            Polygon polygon2 = polygon1.translated(dir);
 
            int numvertices = polygon1.vertices.size();
            for (int i = 0; i < numvertices; i++) {
 
                int nexti = (i + 1) % numvertices;
 
                Vector3d bottomV1 = polygon1.vertices.get(i).pos;
                Vector3d topV1 = polygon2.vertices.get(i).pos;
                Vector3d bottomV2 = polygon1.vertices.get(nexti).pos;
                Vector3d topV2 = polygon2.vertices.get(nexti).pos;
 
                List<Vector3d> pPoints = Arrays.asList(bottomV2, topV2, topV1, bottomV1);
 
                newPolygons.add(Polygon.fromPoints(pPoints, polygon1.getStorage()));
 
            }
 
            polygon2 = polygon2.flipped();
            List<Polygon> topPolygons = PolygonUtil.concaveToConvex(polygon2.flipped());
 
            newPolygons.addAll(topPolygons);
            extrude = CSG.fromPolygons(newPolygons);
 
            return extrude;
        }
 
        @Override
        public CSG extrude(Vector3d dir, List<Vector3d> points) {
            return points(dir, points);
        }
    };
 
    private Extrude() {
        throw new AssertionError("Don't instantiate me!", null);
    }
 
    public static CSG polygons(Polygon polygon1, Number zDistance) {
        return polygons(polygon1, polygon1.transformed(new Transform().movez(zDistance)));
    }
 
    public static CSG polygons(Polygon polygon1, Polygon polygon2) {
        // if(!isCCW(polygon1)) {
        // polygon1=Polygon.fromPoints(toCCW(polygon1.getPoints()));
        // }
        // if(!isCCW(polygon2)) {
        // polygon2=Polygon.fromPoints(toCCW(polygon2.getPoints()));
        // }
 
        List<Polygon> newPolygons = new ArrayList<>();
        CSG extrude;
        newPolygons.addAll(PolygonUtil.concaveToConvex(polygon1.flipped()));
        if (polygon1.vertices.size() != polygon2.vertices.size()) {
            throw new RuntimeException("These polygons do not match");
        }
 
        int numvertices = polygon1.vertices.size();
        for (int i = 0; i < numvertices; i++) {
 
            int nexti = (i + 1) % numvertices;
 
            Vector3d bottomV1 = polygon1.vertices.get(i).pos;
            Vector3d topV1 = polygon2.vertices.get(i).pos;
            Vector3d bottomV2 = polygon1.vertices.get(nexti).pos;
            Vector3d topV2 = polygon2.vertices.get(nexti).pos;
 
            List<Vector3d> pPoints = Arrays.asList(bottomV2, topV2, topV1, bottomV1);
 
            newPolygons.add(Polygon.fromPoints(pPoints, polygon1.getStorage()));
 
        }
 
        polygon2 = polygon2.flipped();
        List<Polygon> topPolygons = PolygonUtil.concaveToConvex(polygon2.flipped());
 
        newPolygons.addAll(topPolygons);
        extrude = CSG.fromPolygons(newPolygons);
 
        return extrude;
    }
 
    public static ArrayList<CSG> polygons(eu.mihosoft.vrl.v3d.Polygon polygon1, ArrayList<Transform> transforms) {
        if (transforms.size() == 1)
            transforms.add(0, new Transform());
        polygon1 = Polygon.fromPoints(toCCW(polygon1.getPoints()));
        if (transforms.size() < 2) {
            transforms.add(0, new Transform());
        }
        ArrayList<CSG> parts = new ArrayList<>();
        Transform transform = new Transform();
        // transform.rotY(90);
        for (int i = 0; i < transforms.size() - 1; i++) {
            CSG tmp = polygons(polygon1.transformed(transform).transformed(transforms.get(i)),
                    polygon1.transformed(transform).transformed(transforms.get(i + 1)));
            parts.add(tmp);
        }
        return parts;
 
    }
 
    public static ArrayList<CSG> polygons(eu.mihosoft.vrl.v3d.Polygon polygon1, Transform... transformparts) {
 
        return polygons(polygon1, (ArrayList<Transform>) Arrays.asList(transformparts));
 
    }
 
    public static CSG points(Vector3d dir, List<Vector3d> points) {
 
        return getExtrusionEngine().extrude(dir, points);
    }
 
    public static CSG points(Vector3d dir, Vector3d... points) {
 
        return points(dir, Arrays.asList(points));
    }
 
    public static List<Vector3d> toCCW(List<Vector3d> points) {
 
        List<Vector3d> result = new ArrayList<>(points);
 
        if (!isCCW(Polygon.fromPoints(result))) {
            Collections.reverse(result);
        }
 
        return result;
    }
 
    static List<Vector3d> toCW(List<Vector3d> points) {
 
        List<Vector3d> result = new ArrayList<>(points);
 
        if (isCCW(Polygon.fromPoints(result))) {
            Collections.reverse(result);
        }
 
        return result;
    }
 
    public static boolean isCCW(Polygon polygon) {
 
        // thanks to Sepp Reiter for explaining me the algorithm!
 
        if (polygon.vertices.size() < 3) {
            throw new IllegalArgumentException("Only polygons with at least 3 vertices are supported!");
        }
 
        // search highest left vertex
        int highestLeftVertexIndex = 0;
        Vertex highestLeftVertex = polygon.vertices.get(0);
        for (int i = 0; i < polygon.vertices.size(); i++) {
            Vertex v = polygon.vertices.get(i);
 
            if (v.pos.y > highestLeftVertex.pos.y) {
                highestLeftVertex = v;
                highestLeftVertexIndex = i;
            } else if (v.pos.y == highestLeftVertex.pos.y && v.pos.x < highestLeftVertex.pos.x) {
                highestLeftVertex = v;
                highestLeftVertexIndex = i;
            }
        }
 
        // determine next and previous vertex indices
        int nextVertexIndex = (highestLeftVertexIndex + 1) % polygon.vertices.size();
        int prevVertexIndex = highestLeftVertexIndex - 1;
        if (prevVertexIndex < 0) {
            prevVertexIndex = polygon.vertices.size() - 1;
        }
        Vertex nextVertex = polygon.vertices.get(nextVertexIndex);
        Vertex prevVertex = polygon.vertices.get(prevVertexIndex);
 
        // edge 1
        double a1 = normalizedX(highestLeftVertex.pos, nextVertex.pos);
 
        // edge 2
        double a2 = normalizedX(highestLeftVertex.pos, prevVertex.pos);
 
        // select vertex with lowest x value
        int selectedVIndex;
 
        if (a2 > a1) {
            selectedVIndex = nextVertexIndex;
        } else {
            selectedVIndex = prevVertexIndex;
        }
 
        if (selectedVIndex == 0 && highestLeftVertexIndex == polygon.vertices.size() - 1) {
            selectedVIndex = polygon.vertices.size();
        }
 
        if (highestLeftVertexIndex == 0 && selectedVIndex == polygon.vertices.size() - 1) {
            highestLeftVertexIndex = polygon.vertices.size();
        }
 
        // indicates whether edge points from highestLeftVertexIndex towards
        // the sel index (ccw)
        return selectedVIndex > highestLeftVertexIndex;
 
    }
 
    private static double normalizedX(Vector3d v1, Vector3d v2) {
        Vector3d v2MinusV1 = v2.minus(v1);
 
        return v2MinusV1.dividedBy(v2MinusV1.magnitude()).times(Vector3d.X_ONE).x;
    }
 
    public static IExtrusion getExtrusionEngine() {
        return extrusionEngine;
    }
 
    public static void setExtrusionEngine(IExtrusion extrusionEngine) {
        Extrude.extrusionEngine = extrusionEngine;
    }
 
    public static CSG byPath(List<List<Vector3d>> points, double height) {
 
        return byPath(points, height, 200);
 
    }
 
    public static CSG byPath(List<List<Vector3d>> points, double height, int resolution) {
        ArrayList<Transform> trPath = pathToTransforms(points, resolution);
        ArrayList<Vector3d> finalPath = new ArrayList<>();
        for (Transform tr : trPath) {
            javax.vecmath.Vector3d t1 = new javax.vecmath.Vector3d();
            tr.getInternalMatrix().get(t1);
            Vector3d finalPoint = new Vector3d(t1.x, t1.y, 0);
            finalPath.add(finalPoint);
        }
        // showEdges(finalPath,(double)0.0,javafx.scene.paint.Color.RED)
        // println "Path size = " +finalPath.size()
        // List<Polygon> p = Polygon.fromConcavePoints(finalPath)
        // for(Polygon pl:p)
        // BowlerStudioController.getBowlerStudio()addObject(pl,null)
        // return new Cube(height).toCSG()
        return Extrude.points(new Vector3d(0, 0, height), finalPath);
    }
 
    public static ArrayList<Transform> pathToTransforms(List<List<Vector3d>> points, int resolution) {
 
        Vector3d start = points.get(0).get(0);
        String pathStringA = "M " + start.x + "," + start.y;
        String pathStringB = pathStringA;
 
        for (List<Vector3d> sections : points) {
            if (sections.size() == 4) {
                Vector3d controlA = sections.get(1);
                Vector3d controlB = sections.get(2);
                Vector3d endPoint = sections.get(3);
                /*
                 * ArrayList<Double> controlA = (ArrayList<Double>)
                 * Arrays.asList(sections.get(1).x - start.get(0), sections.get(1).y -
                 * start.get(1), sections.get(1).z - start.get(2));
                 * 
                 * ArrayList<Double> controlB = (ArrayList<Double>)
                 * Arrays.asList(sections.get(2).x - start.get(0), sections.get(2).y -
                 * start.get(1), sections.get(2).z - start.get(2)); ; ArrayList<Double> endPoint
                 * = (ArrayList<Double>) Arrays.asList(sections.get(3).x - start.get(0),
                 * sections.get(3).y - start.get(1), sections.get(3).z - start.get(2)); ;
                 */
 
                pathStringA += ("C " + controlA.x + "," + controlA.y + " " + controlB.x + "," + controlB.y + " "
                        + endPoint.x + "," + endPoint.y + "\n");
                pathStringB += ("C " + controlA.x + "," + controlA.z + " " + controlB.x + "," + controlB.z + " "
                        + endPoint.x + "," + endPoint.z + "\n");
                // start.set(0, sections.get(3).x);
                // start.set(1, sections.get(3).y);
                // start.set(2,sections.get(3).z);
 
            } else if (sections.size() == 1) {
 
                pathStringA += "L " + (double) sections.get(0).x + "," + (double) sections.get(0).y + "\n";
                pathStringB += "L " + (double) sections.get(0).x + "," + (double) sections.get(0).z + "\n";
                // start.set(0, sections.get(0).x);
                // start.set(1, sections.get(0).y);
                // start.set(2, sections.get(0).z);
            }
        }
        // println "A string = " +pathStringA
        // println "B String = " +pathStringB
        BezierPath path = new BezierPath();
        path.parsePathString(pathStringA);
        BezierPath path2 = new BezierPath();
        path2.parsePathString(pathStringB);
 
        return bezierToTransforms(path, path2, resolution, null, null);
    }
 
    public static ArrayList<CSG> moveAlongProfile(CSG object, List<List<Vector3d>> points, int resolution) {
 
        return Extrude.move(object, pathToTransforms(points, resolution));
    }
 
    public static ArrayList<Transform> bezierToTransforms(Vector3d controlA, Vector3d controlB, Vector3d endPoint,
            int iterations) {
        BezierPath path = new BezierPath();
        path.parsePathString("C " + controlA.x + "," + controlA.y + " " + controlB.x + "," + controlB.y + " "
                + endPoint.x + "," + endPoint.y);
        BezierPath path2 = new BezierPath();
        path2.parsePathString("C " + controlA.x + "," + controlA.z + " " + controlB.x + "," + controlB.z + " "
                + endPoint.x + "," + endPoint.z);
 
        return bezierToTransforms(path, path2, iterations, controlA, controlB);
    }
 
    public static ArrayList<Transform> bezierToTransforms(List<Vector3d> parts, int iterations) {
        // System.out.println("Bezier type "+parts.size());
        if (parts.size() == 3)
            return bezierToTransforms(parts.get(0), parts.get(1), parts.get(2), iterations);
        if (parts.size() == 2)
            return bezierToTransforms(parts.get(0), parts.get(0), parts.get(1), parts.get(1), iterations);
        if (parts.size() == 1)
            return bezierToTransforms(new Vector3d(0, 0, 0), new Vector3d(0, 0, 0), parts.get(0), parts.get(0),
                    iterations);
        return bezierToTransforms(parts.get(0), parts.get(1), parts.get(2), parts.get(3), iterations);
    }
 
    private Transform toTransform() {
 
        return null;
    }
 
    public static ArrayList<Transform> bezierToTransforms(BezierPath pathA, BezierPath pathB, int iterations,
            Vector3d controlA, Vector3d controlB) {
        double d = 1.0 / (double) iterations;
        ArrayList<Transform> p = new ArrayList<Transform>();
        Vector3d pointAStart = pathA.eval(0);
        Vector3d pointBStart = pathB.eval(0);
        double x = pointAStart.x, y = pointAStart.y, z = pointBStart.y;
        double lastx = x, lasty = y, lastz = z;
        // float min = (float) 0.0001;
        int startIndex = 0;
        if (controlA != null) {
            startIndex = 1;
            double ydiff = controlA.y - y;
            double zdiff = controlA.z - z;
            double xdiff = controlA.x - x;
            double rise = zdiff;
            double run = Math.sqrt((ydiff * ydiff) + (xdiff * xdiff));
            double rotz = 90 - Math.toDegrees(Math.atan2(xdiff, ydiff));
            // System.out.println("Rot z = "+rotz+" x="+xdiff+" y="+ydiff);
            double roty = Math.toDegrees(Math.atan2(rise, run));
            Transform t = new Transform();
            t.translateX(x);
            t.translateY(y);
            t.translateZ(z);
            t.rotZ(-rotz);
            t.rotY(roty);
            p.add(t);
        }
        Transform t;
        double ydiff;
        double zdiff;
        double xdiff;
        double rise;
        double run;
        double rotz;
        double roty;
        for (int i = startIndex; i < iterations - 1; i++) {
            float pathFunction = (float) (((float) i) / ((float) (iterations - 1)));
 
            Vector3d pointA = pathA.eval(pathFunction);
            Vector3d pointB = pathB.eval(pathFunction);
 
            x = pointA.x;
            y = pointA.y;
            z = pointB.y;
 
            t = new Transform();
            t.translateX(x);
            t.translateY(y);
            t.translateZ(z);
 
            Vector3d pointAEst = pathA.eval((float) (pathFunction + d));
            Vector3d pointBEst = pathB.eval((float) (pathFunction + d));
            double xest = pointAEst.x;
            double yest = pointAEst.y;
            double zest = pointBEst.y;
            ydiff = yest - y;
            zdiff = zest - z;
            xdiff = xest - x;
            // t.rotX(45-Math.toDegrees(Math.atan2(zdiff,ydiff)))
 
            rise = zdiff;
            run = Math.sqrt((ydiff * ydiff) + (xdiff * xdiff));
            rotz = 90 - Math.toDegrees(Math.atan2(xdiff, ydiff));
            // System.out.println("Rot z = "+rotz+" x="+xdiff+" y="+ydiff);
            roty = Math.toDegrees(Math.atan2(rise, run));
 
            t.rotZ(-rotz);
            t.rotY(roty);
            // if(i==0)
            // System.out.println( " Tr = "+x+" "+y+" "+z+" path = "+pathFunction);
            // println "z = "+rotz+" y = "+roty
            p.add(t);
            lastx = x;
            lasty = y;
            lastz = z;
        }
 
        Vector3d pointA = pathA.eval((float) 1);
        Vector3d pointB = pathB.eval((float) 1);
 
        x = pointA.x;
        y = pointA.y;
        z = pointB.y;
        t = new Transform();
        t.translateX(x);
        t.translateY(y);
        t.translateZ(z);
        if (controlB != null) {
            lastx = controlB.x;
            lasty = controlB.y;
            lastz = controlB.z;
        }
 
        ydiff = y - lasty;
        zdiff = z - lastz;
        xdiff = x - lastx;
 
        rise = zdiff;
        run = Math.sqrt((ydiff * ydiff) + (xdiff * xdiff));
        rotz = 90 - Math.toDegrees(Math.atan2(xdiff, ydiff));
        roty = Math.toDegrees(Math.atan2(rise, run));
 
        t.rotZ(-rotz);
        t.rotY(roty);
        p.add(t);
 
        return p;
    }
 
    public static ArrayList<Transform> bezierToTransforms(Vector3d start, Vector3d controlA, Vector3d controlB,
            Vector3d endPoint, int iterations) {
        String startString = "M " + start.x + "," + start.y + "\n" + "C " + controlA.x + "," + controlA.y + " "
                + controlB.x + "," + controlB.y + " " + endPoint.x + "," + endPoint.y;
        String b = "M " + start.x + "," + start.z + "\n" + "C " + controlA.x + "," + controlA.z + " " + controlB.x + ","
                + controlB.z + " " + endPoint.x + "," + endPoint.z;
        // println "Start = "+startString
        BezierPath path = new BezierPath();
        path.parsePathString(startString);
        BezierPath path2 = new BezierPath();
        path2.parsePathString(b);
        // newParts.remove(parts.size()-1)
        // newParts.remove(0)
        // System.out.println("Parsing "+startString+" \nand\n"+b);
        return bezierToTransforms(path, path2, iterations, controlA, controlB);
    }
 
    public static ArrayList<CSG> revolve(CSG slice, double radius, int numSlices) {
        return revolve(slice, radius, 360.0, null, numSlices);
    }
 
    public static ArrayList<CSG> revolve(Polygon poly, int numSlices) {
        return revolve(poly, 0, numSlices);
    }
 
    public static ArrayList<CSG> revolve(Polygon poly, double radius, int numSlices) {
        ArrayList<CSG> parts = new ArrayList<CSG>();
        ArrayList<Polygon> slices = new ArrayList<Polygon>();
 
        for (int i = 0; i < numSlices; i++) {
            double angle = 360.0 / ((double) numSlices) * ((double) i);
            slices.add(poly.transformed(new Transform().movex(radius).roty(angle)));
        }
        for (int i = 0; i < slices.size(); i++) {
            int next = i + 1;
            if (next == slices.size())
                next = 0;
            // println "Extruding "+i+" to "+next
            parts.add(Extrude.polygons(slices.get(i), slices.get(next)));
        }
 
        return parts;
    }
 
    public static ArrayList<CSG> revolve(CSG slice, double radius, double archLen, int numSlices) {
        return revolve(slice, radius, archLen, null, numSlices);
    }
 
    public static ArrayList<CSG> revolve(CSG slice, double radius, double archLen, List<List<Vector3d>> points,
            int numSlices) {
        ArrayList<CSG> parts = new ArrayList<CSG>();
        double slices = (double) numSlices;
        double increment = archLen / slices;
        CSG slicePRofile = slice.movey(radius);
 
        for (double i = 0; i < (archLen + increment); i += increment) {
            parts.add(slicePRofile.rotz(i));
        }
        if (points != null) {
            ArrayList<Transform> pathtransforms = pathToTransforms(points, numSlices);
            for (int i = 0; i < parts.size(); i++) {
                CSG sweep = parts.get(i).transformed(pathtransforms.get(i));
                parts.set(i, sweep);
            }
        }
        for (int i = 0; i < parts.size() - 1; i++) {
 
            CSG sweep = CSG.hullAll(parts.get(i), parts.get(i + 1));
            parts.set(i, sweep);
        }
 
        return parts;
    }
 
    public static ArrayList<CSG> bezier(CSG slice, ArrayList<Double> controlA, ArrayList<Double> controlB,
            ArrayList<Double> endPoint, int numSlices) {
        ArrayList<CSG> parts = new ArrayList<CSG>();
 
        for (int i = 0; i < numSlices; i++) {
            parts.add(0, slice.clone());
        }
        return bezier(parts, controlA, controlB, endPoint);
    }
 
    public static ArrayList<CSG> bezier(ArrayList<CSG> s, ArrayList<Double> controlA, ArrayList<Double> controlB,
            ArrayList<Double> endPoint) {
        ArrayList<CSG> slice = moveBezier(s, controlA, controlB, endPoint);
 
        for (int i = 0; i < slice.size() - 1; i++) {
            // Polygon p1 =Slice.slice(slice.get(i), new Transform(), 0).get(0);
            // Polygon p2 =Slice.slice(slice.get(i+1), new Transform(), 0).get(0);
            // CSG sweep = polygons(p1, p2);
            CSG sweep = HullUtil.hull(slice.get(i), slice.get(i + 1));
 
            slice.set(i, sweep);
        }
        return slice;
    }
 
    public static ArrayList<CSG> hull(ArrayList<CSG> s, ArrayList<Transform> p) {
        ArrayList<CSG> slice = move(s, p);
        for (int i = 0; i < slice.size() - 1; i++) {
            // Polygon p1 =Slice.slice(slice.get(i), new Transform(), 0).get(0);
            // Polygon p2 =Slice.slice(slice.get(i+1), new Transform(), 0).get(0);
            // CSG sweep = polygons(p1, p2);
            CSG sweep = HullUtil.hull(slice.get(i), slice.get(i + 1));
 
            slice.set(i, sweep);
        }
        return slice;
    }
 
    public static ArrayList<CSG> hull(CSG c, ArrayList<Transform> p) {
        ArrayList<CSG> s = new ArrayList<>();
        for (int i = 0; i < p.size(); i++) {
            s.add(c.clone());
        }
        return hull(s, p);
    }
 
    public static ArrayList<CSG> linear(ArrayList<CSG> s, ArrayList<Double> endPoint) {
        ArrayList<Double> start = (ArrayList<Double>) Arrays.asList(0.0, 0.0, 0.0);
        return bezier(s, start, endPoint, endPoint);
    }
 
    public static ArrayList<CSG> linear(CSG s, ArrayList<Double> endPoint, int numSlices) {
        ArrayList<Double> start = (ArrayList<Double>) Arrays.asList(0.0, 0.0, 0.0);
 
        return bezier(s, start, endPoint, endPoint, numSlices);
    }
 
    public static ArrayList<CSG> move(ArrayList<CSG> slice, ArrayList<Transform> p) {
 
        return CSG.move(slice, p);
    }
 
    public static ArrayList<CSG> move(CSG slice, ArrayList<Transform> p) {
        return slice.move(p);
    }
 
    public static ArrayList<CSG> moveBezier(CSG slice, ArrayList<Double> controlA, ArrayList<Double> controlB,
            ArrayList<Double> endPoint, int numSlices) {
        ArrayList<Transform> p = bezierToTransforms(fromDouble(controlA), fromDouble(controlB), fromDouble(endPoint),
                numSlices);
 
        return move(slice, p);
    }
 
    public static ArrayList<CSG> moveBezier(ArrayList<CSG> slice, ArrayList<Double> controlA,
            ArrayList<Double> controlB, ArrayList<Double> endPoint) {
 
        int numSlices = slice.size();
        ArrayList<Transform> p = bezierToTransforms(fromDouble(controlA), fromDouble(controlB), fromDouble(endPoint),
                numSlices);
        return move(slice, p);
 
    }
 
    private static Vector3d fromDouble(ArrayList<Double> controlA) {
        return new Vector3d(controlA.get(0), controlA.get(1), controlA.get(2));
    }
 
    public static ArrayList<CSG> moveBezier(CSG slice, BezierPath pathA, int numSlices) {
        Vector3d pointA = pathA.eval((float) 1.0);
        String zpath = "C 0,0 " + pointA.x + "," + pointA.y + " " + pointA.x + "," + pointA.y;
        BezierPath pathB = new BezierPath();
        pathB.parsePathString(zpath);
 
        return moveBezier(slice, pathA, pathB, numSlices);
 
    }
 
    public static ArrayList<CSG> moveBezier(CSG slice, BezierPath pathA, BezierPath pathB, int iterations) {
 
        ArrayList<Transform> p = bezierToTransforms(pathA, pathB, iterations, null, null);
        return move(slice, p);
 
    }
 
    public static Polygon toCCW(Polygon concave) {
        if (!isCCW(concave)) {
            List<Vector3d> points = concave.getPoints();
            List<Vector3d> result = new ArrayList<>(points);
            Collections.reverse(result);
            return Polygon.fromPoints(result);
        }
        return concave;
    }
}