CSG.java

Go to the documentation of this file.

/*
 * CSG.java
 *
 * Copyright 2014-2014 Michael Hoffer info@michaelhoffer.de. All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY Michael Hoffer info@michaelhoffer.de "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL Michael Hoffer info@michaelhoffer.de OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of Michael Hoffer
 * info@michaelhoffer.de.
 */
package eu.mihosoft.vrl.v3d;
 
import eu.mihosoft.vrl.v3d.ext.org.poly2tri.PolygonUtil;
import eu.mihosoft.vrl.v3d.ext.quickhull3d.HullUtil;
import eu.mihosoft.vrl.v3d.parametrics.CSGDatabase;
import eu.mihosoft.vrl.v3d.parametrics.IParametric;
import eu.mihosoft.vrl.v3d.parametrics.IRegenerate;
import eu.mihosoft.vrl.v3d.parametrics.LengthParameter;
import eu.mihosoft.vrl.v3d.parametrics.Parameter;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
import com.neuronrobotics.interaction.CadInteractionEvent;
 
import javafx.scene.paint.Color;
import javafx.scene.paint.PhongMaterial;
import javafx.scene.shape.CullFace;
import javafx.scene.shape.DrawMode;
import javafx.scene.shape.MeshView;
import javafx.scene.transform.Affine;
 
@SuppressWarnings("restriction")
public class CSG implements IuserAPI {
    private static IDebug3dProvider providerOf3d = null;
    private static int numFacesInOffset = 15;
 
    private List<Polygon> polygons;
 
    private static OptType defaultOptType = OptType.CSG_BOUND;
 
    private OptType optType = null;
 
    private PropertyStorage str;
    private PropertyStorage assembly;
 
    private MeshView current;
 
    private static Color defaultcolor = Color.web("#007956");
 
    private Color color = getDefaultColor();
 
    private Affine manipulator;
    private Bounds bounds;
    public static final int INDEX_OF_PARAMETRIC_DEFAULT = 0;
    public static final int INDEX_OF_PARAMETRIC_LOWER = 1;
    public static final int INDEX_OF_PARAMETRIC_UPPER = 2;
    private ArrayList<String> groovyFileLines = new ArrayList<>();
    private PrepForManufacturing manufactuing = null;
    private HashMap<String, IParametric> mapOfparametrics = null;
    private IRegenerate regenerate = null;
    private boolean markForRegeneration = false;
    private String name = "";
    private ArrayList<Transform> slicePlanes = null;
    private ArrayList<String> exportFormats = null;
    private ArrayList<Transform> datumReferences = null;
    private boolean triangulated;
    private static boolean needsDegeneratesPruned=false;
    private static boolean useStackTraces = true;
 
    private static ICSGProgress progressMoniter = new ICSGProgress() {
        @Override
        public void progressUpdate(int currentIndex, int finalIndex, String type, CSG intermediateShape) {
            System.out.println(type + "ing " + currentIndex + " of " + finalIndex);
        }
    };
 
    public CSG() {
        setStorage(new PropertyStorage());
 
        if (useStackTraces) {
            // This is the trace for where this csg was created
            addStackTrace(new Exception());
        }
    }
 
    public CSG addDatumReference(Transform t) {
        if (getDatumReferences() == null)
            setDatumReferences(new ArrayList<Transform>());
        getDatumReferences().add(t);
        return this;
    }
 
    public CSG prepForManufacturing() {
        if (getManufacturing() == null)
            return this;
        CSG ret = getManufacturing().prep(this);
        if (ret == null)
            return null;
        ret.setName(getName());
        ret.setColor(getColor());
        ret.slicePlanes = slicePlanes;
        ret.mapOfparametrics = mapOfparametrics;
        ret.exportFormats = exportFormats;
        return ret;
    }
 
    public Color getColor() {
        return color;
    }
 
    public CSG setColor(Color color) {
        this.color = color;
        if (current != null) {
            PhongMaterial m = new PhongMaterial(getColor());
            current.setMaterial(m);
        }
        return this;
    }
 
    public CSG setTemporaryColor(Color color) {
        if (current != null) {
            PhongMaterial m = new PhongMaterial(color);
            current.setMaterial(m);
        }
        return this;
    }
 
    public CSG setManipulator(Affine manipulator) {
        if (manipulator == null)
            return this;
        Affine old = manipulator;
        this.manipulator = manipulator;
        if (current != null) {
            current.getTransforms().clear();
            current.getTransforms().add(manipulator);
        }
        return this;
    }
 
    public MeshView getMesh() {
        if (current != null)
            return current;
        current = newMesh();
        return current;
    }
 
    public MeshView newMesh() {
 
        MeshContainer meshContainer = toJavaFXMesh(null);
 
        MeshView current = meshContainer.getAsMeshViews().get(0);
 
        PhongMaterial m = new PhongMaterial(getColor());
        current.setMaterial(m);
 
        boolean hasManipulator = getManipulator() != null;
        boolean hasAssembly = getAssemblyStorage().getValue("AssembleAffine") != Optional.empty();
 
        if (hasManipulator || hasAssembly)
            current.getTransforms().clear();
 
        if (hasManipulator)
            current.getTransforms().add(getManipulator());
        if (hasAssembly)
            current.getTransforms().add((Affine) getAssemblyStorage().getValue("AssembleAffine").get());
 
        current.setCullFace(CullFace.NONE);
        if (isWireFrame())
            current.setDrawMode(DrawMode.LINE);
        else
            current.setDrawMode(DrawMode.FILL);
        return current;
    }
 
    public CSG toZMin(CSG target) {
        return this.transformed(new Transform().translateZ(-target.getBounds().getMin().z));
    }
 
    public CSG toZMax(CSG target) {
        return this.transformed(new Transform().translateZ(-target.getBounds().getMax().z));
    }
 
    public CSG toXMin(CSG target) {
        return this.transformed(new Transform().translateX(-target.getBounds().getMin().x));
    }
 
    public CSG toXMax(CSG target) {
        return this.transformed(new Transform().translateX(-target.getBounds().getMax().x));
    }
 
    public CSG toYMin(CSG target) {
        return this.transformed(new Transform().translateY(-target.getBounds().getMin().y));
    }
 
    public CSG toYMax(CSG target) {
        return this.transformed(new Transform().translateY(-target.getBounds().getMax().y));
    }
 
    public CSG toZMin() {
        return toZMin(this);
    }
 
    public CSG toZMax() {
        return toZMax(this);
    }
 
    public CSG toXMin() {
        return toXMin(this);
    }
 
    public CSG toXMax() {
        return toXMax(this);
    }
 
    public CSG toYMin() {
        return toYMin(this);
    }
 
    public CSG toYMax() {
        return toYMax(this);
    }
 
    public CSG move(Number x, Number y, Number z) {
        return transformed(new Transform().translate(x.doubleValue(), y.doubleValue(), z.doubleValue()));
    }
 
    public CSG move(Vertex v) {
        return transformed(new Transform().translate(v.getX(), v.getY(), v.getZ()));
    }
 
    public CSG move(Vector3d v) {
        return transformed(new Transform().translate(v.x, v.y, v.z));
    }
 
    public CSG move(Number[] posVector) {
        return move(posVector[0], posVector[1], posVector[2]);
    }
 
    // Helper/wrapper functions for movement
    public CSG movey(Number howFarToMove) {
        return this.transformed(Transform.unity().translateY(howFarToMove.doubleValue()));
    }
 
    public CSG movez(Number howFarToMove) {
        return this.transformed(Transform.unity().translateZ(howFarToMove.doubleValue()));
    }
 
    public CSG movex(Number howFarToMove) {
        return this.transformed(Transform.unity().translateX(howFarToMove.doubleValue()));
    }
 
    public CSG moveToCenterX() {
        return this.movex(-this.getCenterX());
    }
 
    public CSG moveToCenterY() {
        return this.movey(-this.getCenterY());
    }
 
    public CSG moveToCenterZ() {
        return this.movez(-this.getCenterZ());
    }
 
    public CSG moveToCenter() {
        return this.movex(-this.getCenterX()).movey(-this.getCenterY()).movez(-this.getCenterZ());
    }
 
    public ArrayList<CSG> move(ArrayList<Transform> p) {
        ArrayList<CSG> bits = new ArrayList<CSG>();
        for (Transform t : p) {
            bits.add(this.clone());
        }
        return move(bits, p);
    }
 
    public static ArrayList<CSG> move(ArrayList<CSG> slice, ArrayList<Transform> p) {
        ArrayList<CSG> s = new ArrayList<CSG>();
        // s.add(slice.get(0));
        for (int i = 0; i < slice.size() && i < p.size(); i++) {
            s.add(slice.get(i).transformed(p.get(i)));
        }
        return s;
    }
 
    // Helper/wrapper functions for movement
    public CSG mirrory() {
        return this.scaley(-1);
    }
 
    public CSG mirrorz() {
        return this.scalez(-1);
    }
 
    public CSG mirrorx() {
        return this.scalex(-1);
    }
 
    public CSG rot(Number x, Number y, Number z) {
        return rotx(x.doubleValue()).roty(y.doubleValue()).rotz(z.doubleValue());
    }
 
    public CSG rot(Number[] posVector) {
        return rot(posVector[0], posVector[1], posVector[2]);
    }
 
    // Rotation function, rotates the object
    public CSG rotz(Number degreesToRotate) {
        return this.transformed(new Transform().rotZ(degreesToRotate.doubleValue()));
    }
 
    public CSG roty(Number degreesToRotate) {
        return this.transformed(new Transform().rotY(degreesToRotate.doubleValue()));
    }
 
    public CSG rotx(Number degreesToRotate) {
        return this.transformed(new Transform().rotX(degreesToRotate.doubleValue()));
    }
 
    // Scale function, scales the object
    public CSG scalez(Number scaleValue) {
        return this.transformed(new Transform().scaleZ(scaleValue.doubleValue()));
    }
 
    public CSG scaley(Number scaleValue) {
        return this.transformed(new Transform().scaleY(scaleValue.doubleValue()));
    }
 
    public CSG scalex(Number scaleValue) {
        return this.transformed(new Transform().scaleX(scaleValue.doubleValue()));
    }
 
    public CSG scale(Number scaleValue) {
        return this.transformed(new Transform().scale(scaleValue.doubleValue()));
    }
 
    public static CSG fromPolygons(List<Polygon> polygons) {
 
        CSG csg = new CSG();
        csg.setPolygons(polygons);
        return csg;
    }
 
    public static CSG fromPolygons(Polygon... polygons) {
        return fromPolygons(Arrays.asList(polygons));
    }
 
    public static CSG fromPolygons(PropertyStorage storage, List<Polygon> polygons) {
 
        CSG csg = new CSG();
        csg.setPolygons(polygons);
 
        csg.setStorage(storage);
 
        for (Polygon polygon : polygons) {
            polygon.setStorage(storage);
        }
        return csg;
    }
 
    public static CSG fromPolygons(PropertyStorage storage, Polygon... polygons) {
        return fromPolygons(storage, Arrays.asList(polygons));
    }
 
    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#clone()
     */
    @Override
    public CSG clone() {
        CSG csg = new CSG();
 
        csg.setOptType(this.getOptType());
 
        Stream<Polygon> polygonStream;
 
//      if (getPolygons().size() > 200) {
//          polygonStream = getPolygons().parallelStream();
//      } else {
//          polygonStream =getPolygons().stream();
//      }
        polygonStream=getPolygons().stream();
        csg.setPolygons(polygonStream.map((Polygon p) -> p!=null?p.clone():null).filter(p-> p!=null).collect(Collectors.toList()));
 
        return csg.historySync(this);
    }
 
    public List<Polygon> getPolygons() {
        return polygons;
    }
 
    public CSG optimization(OptType type) {
        this.setOptType(type);
        return this;
    }
 
    public CSG union(CSG csg) {
//      triangulate();
//      csg.triangulate();
        switch (getOptType()) {
        case CSG_BOUND:
            return _unionCSGBoundsOpt(csg).historySync(this).historySync(csg);
        case POLYGON_BOUND:
            return _unionPolygonBoundsOpt(csg).historySync(this).historySync(csg);
        default:
            // return _unionIntersectOpt(csg);
            return _unionNoOpt(csg).historySync(this).historySync(csg);
        }
    }
 
    public CSG dumbUnion(CSG csg) {
        boolean tri = triangulated&&csg.triangulated;
        CSG result = this.clone();
        CSG other = csg.clone();
 
        result.getPolygons().addAll(other.getPolygons());
        bounds = null;
        result.triangulated = tri;
        return result.historySync(other);
    }
 
    public CSG union(List<CSG> csgs) {
//      ArrayList<Polygon> incomingPolys = new ArrayList<>();
//      for(int i=0;i<csgs.size();i++) {
//          incomingPolys.addAll(csgs.get(i).getPolygons());
//      }
//      //System.out.println("Node list A");
//      Node a = new Node(this.clone().getPolygons());
//      //System.out.println("Node list B");
//      Node b = new Node(incomingPolys);
//      //System.out.println("a.clipTo(b)");
//      a.clipTo(b);
//      //System.out.println("b.clipTo(a)");
//      b.clipTo(a);
//      //System.out.println("b.invert();");
//      b.invert();
//      //System.out.println("b.clipTo(a);");
//      b.clipTo(a);
//      //System.out.println("b.invert();");
//      b.invert();
//      //System.out.println("a.build(b.allPolygons());");
//      a.build(b.allPolygons());
//      //System.out.println("CSG.fromPolygons(a.allPolygons()).optimization(getOptType())");
//      return CSG.fromPolygons(a.allPolygons()).optimization(getOptType());
 
        CSG result = this;
 
        for (int i = 0; i < csgs.size(); i++) {
            CSG csg = csgs.get(i);
            result = result.union(csg);
            if (Thread.interrupted())
                break;
            progressMoniter.progressUpdate(i, csgs.size(), "Union", result);
        }
 
        return result;
    }
 
    public CSG union(CSG... csgs) {
        return union(Arrays.asList(csgs));
    }
 
    public CSG hull() {
 
        return HullUtil.hull(this, getStorage()).historySync(this);
    }
 
    public static CSG unionAll(CSG... csgs) {
        return unionAll(Arrays.asList(csgs));
    }
 
    public static CSG unionAll(List<CSG> csgs) {
        CSG first = csgs.get(0);
        return first.union(csgs.stream().skip(1).collect(Collectors.toList()));
    }
 
    public static CSG hullAll(CSG... csgs) {
        return hullAll(Arrays.asList(csgs));
    }
 
    public static CSG hullAll(List<CSG> csgs) {
        // CSG first = csgs.remove(0);
        return HullUtil.hull(csgs);// first.hull(csgs);
    }
 
    public CSG hull(List<CSG> csgs) {
 
        CSG csgsUnion = new CSG();
        // csgsUnion.setStorage(storage);
        csgsUnion.optType = optType;
        csgsUnion.setPolygons(this.clone().getPolygons());
 
        csgs.stream().forEach((csg) -> {
            csgsUnion.getPolygons().addAll(csg.clone().getPolygons());
            csgsUnion.historySync(csg);
        });
 
        csgsUnion.getPolygons().forEach(p -> p.setStorage(getStorage()));
        bounds = null;
        return csgsUnion.hull();
 
        // CSG csgsUnion = this;
        //
        // for (CSG csg : csgs) {
        // csgsUnion = csgsUnion.union(csg);
        // }
        //
        // return csgsUnion.hull();
    }
 
    public CSG hull(CSG... csgs) {
 
        return hull(Arrays.asList(csgs));
    }
 
    private CSG _unionCSGBoundsOpt(CSG csg) {
        // System.err.println("WARNING: using " + CSG.OptType.NONE
        // + " since other optimization types missing for union operation.");
        return _unionIntersectOpt(csg);
    }
 
    private CSG _unionPolygonBoundsOpt(CSG csg) {
        List<Polygon> inner = new ArrayList<>();
        List<Polygon> outer = new ArrayList<>();
 
        Bounds b = csg.getBounds();
 
        this.getPolygons().stream().forEach((p) -> {
            if (b.intersects(p.getBounds())) {
                inner.add(p);
            } else {
                outer.add(p);
            }
        });
 
        List<Polygon> allPolygons = new ArrayList<>();
 
        if (!inner.isEmpty()) {
            CSG innerCSG = CSG.fromPolygons(inner);
 
            allPolygons.addAll(outer);
            allPolygons.addAll(innerCSG._unionNoOpt(csg).getPolygons());
        } else {
            allPolygons.addAll(this.getPolygons());
            allPolygons.addAll(csg.getPolygons());
        }
        bounds = null;
        CSG back = CSG.fromPolygons(allPolygons).optimization(getOptType());
        if (getName().length() != 0 && csg.getName().length() != 0) {
            back.setName(name + " unioned to " + csg.getName());
        }
        return back;
    }
 
    private CSG _unionIntersectOpt(CSG csg) {
        boolean intersects = false;
 
        Bounds bounds = csg.getBounds();
 
        for (Polygon p : getPolygons()) {
            if (bounds.intersects(p.getBounds())) {
                intersects = true;
                break;
            }
        }
 
        List<Polygon> allPolygons = new ArrayList<>();
 
        if (intersects) {
            return _unionNoOpt(csg);
        } else {
            allPolygons.addAll(this.getPolygons());
            allPolygons.addAll(csg.getPolygons());
        }
        CSG back = CSG.fromPolygons(allPolygons).optimization(getOptType());
        if (getName().length() != 0 && csg.getName().length() != 0) {
            back.setName(name + " unioned to " + csg.getName());
        }
        return back;
    }
 
    private CSG _unionNoOpt(CSG csg) {
        Node a = new Node(this.clone().getPolygons());
        Node b = new Node(csg.clone().getPolygons());
        a.clipTo(b);
        b.clipTo(a);
        b.invert();
        b.clipTo(a);
        b.invert();
        a.build(b.allPolygons());
        CSG back = CSG.fromPolygons(a.allPolygons()).optimization(getOptType());
        if (getName().length() != 0 && csg.getName().length() != 0) {
            back.setName(name + " unioned to " + csg.getName());
        }
        return back;
    }
 
    public CSG difference(List<CSG> csgs) {
 
        if (csgs.isEmpty()) {
            return this.clone();
        }
 
        CSG csgsUnion = csgs.get(0);
 
        for (int i = 1; i < csgs.size(); i++) {
            csgsUnion = csgsUnion.union(csgs.get(i));
            progressMoniter.progressUpdate(i, csgs.size(), "Difference", csgsUnion);
            csgsUnion.historySync(csgs.get(i));
            if (Thread.interrupted())
                break;
        }
 
        return difference(csgsUnion);
    }
 
    public CSG difference(CSG... csgs) {
 
        return difference(Arrays.asList(csgs));
    }
 
    public CSG difference(CSG csg) {
//      triangulate();
//      csg.triangulate();
        try {
            // Check to see if a CSG operation is attempting to difference with
            // no
            // polygons
            if (this.getPolygons().size() > 0 && csg.getPolygons().size() > 0) {
                switch (getOptType()) {
                case CSG_BOUND:
                    return _differenceCSGBoundsOpt(csg).historySync(this).historySync(csg);
                case POLYGON_BOUND:
                    return _differencePolygonBoundsOpt(csg).historySync(this).historySync(csg);
                default:
                    return _differenceNoOpt(csg).historySync(this).historySync(csg);
                }
            } else
                return this;
        } catch (Exception ex) {
            // ex.printStackTrace();
            try {
                // System.err.println("CSG difference failed, performing workaround");
                // ex.printStackTrace();
                CSG intersectingParts = csg.intersect(this);
 
                if (intersectingParts.getPolygons().size() > 0) {
                    switch (getOptType()) {
                    case CSG_BOUND:
                        return _differenceCSGBoundsOpt(intersectingParts).historySync(this)
                                .historySync(intersectingParts);
                    case POLYGON_BOUND:
                        return _differencePolygonBoundsOpt(intersectingParts).historySync(this)
                                .historySync(intersectingParts);
                    default:
                        return _differenceNoOpt(intersectingParts).historySync(this).historySync(intersectingParts);
                    }
                } else
                    return this;
            } catch (Exception e) {
                e.printStackTrace();
                return this;
            }
        }
 
    }
 
    private CSG _differenceCSGBoundsOpt(CSG csg) {
        CSG b = csg;
 
        CSG a1 = this._differenceNoOpt(csg.getBounds().toCSG());
        CSG a2 = this.intersect(csg.getBounds().toCSG());
        CSG BACK = a2._differenceNoOpt(b)._unionIntersectOpt(a1).optimization(getOptType());
        if (getName().length() != 0 && csg.getName().length() != 0) {
            BACK.setName(csg.getName() + " differenced from " + name);
        }
        return BACK;
    }
 
    private CSG _differencePolygonBoundsOpt(CSG csg) {
        List<Polygon> inner = new ArrayList<>();
        List<Polygon> outer = new ArrayList<>();
 
        Bounds bounds = csg.getBounds();
 
        this.getPolygons().stream().forEach((p) -> {
            if (bounds.intersects(p.getBounds())) {
                inner.add(p);
            } else {
                outer.add(p);
            }
        });
 
        CSG innerCSG = CSG.fromPolygons(inner);
 
        List<Polygon> allPolygons = new ArrayList<>();
        allPolygons.addAll(outer);
        allPolygons.addAll(innerCSG._differenceNoOpt(csg).getPolygons());
        CSG BACK = CSG.fromPolygons(allPolygons).optimization(getOptType());
        if (getName().length() != 0 && csg.getName().length() != 0) {
            BACK.setName(csg.getName() + " differenced from " + name);
        }
        return BACK;
    }
 
    private CSG _differenceNoOpt(CSG csg) {
 
        Node a = new Node(this.clone().getPolygons());
        Node b = new Node(csg.clone().getPolygons());
 
        a.invert();
        a.clipTo(b);
        b.clipTo(a);
        b.invert();
        b.clipTo(a);
        b.invert();
        a.build(b.allPolygons());
        a.invert();
 
        CSG csgA = CSG.fromPolygons(a.allPolygons()).optimization(getOptType());
        if (getName().length() != 0 && csg.getName().length() != 0) {
            csgA.setName(csg.getName() + " differenced from " + name);
        }
        return csgA;
    }
 
    public CSG intersect(CSG csg) {
//      triangulate();
//      csg.triangulate();
        Node a = new Node(this.clone().getPolygons());
        Node b = new Node(csg.clone().getPolygons());
        a.invert();
        b.clipTo(a);
        b.invert();
        a.clipTo(b);
        b.clipTo(a);
        a.build(b.allPolygons());
        a.invert();
        CSG back = CSG.fromPolygons(a.allPolygons()).optimization(getOptType()).historySync(csg)
                .historySync(this);
        if (getName().length() != 0 && csg.getName().length() != 0) {
            back.setName(csg.getName() + " intersection with " + name);
        }
        return back;
    }
 
    public CSG intersect(List<CSG> csgs) {
 
        if (csgs.isEmpty()) {
            return this.clone();
        }
 
        CSG csgsUnion = csgs.get(0);
 
        for (int i = 1; i < csgs.size(); i++) {
            csgsUnion = csgsUnion.union(csgs.get(i));
            progressMoniter.progressUpdate(i, csgs.size(), "Intersect", csgsUnion);
            csgsUnion.historySync(csgs.get(i));
            if (Thread.interrupted())
                break;
        }
 
        return intersect(csgsUnion);
    }
 
    public CSG intersect(CSG... csgs) {
 
        return intersect(Arrays.asList(csgs));
    }
 
    public String toStlString() {
        StringBuilder sb = new StringBuilder();
        toStlString(sb);
        return sb.toString();
    }
 
    public StringBuilder toStlString(StringBuilder sb) {
        triangulate(false);
        try {
            sb.append("solid v3d.csg\n");
            this.getPolygons().stream().forEach((Polygon p) -> {
                p.toStlString(sb);
            });
            sb.append("endsolid v3d.csg\n");
            return sb;
        } catch (Throwable t) {
 
            t.printStackTrace();
            throw new RuntimeException("STL failed to build for " + name);
        }
    }
    public CSG triangulate() {
        return triangulate(false);
    }
    public CSG triangulate(boolean fix) {
        if(fix && needsDegeneratesPruned)
            triangulated=false;
        if(triangulated)
            return this;
        
        //System.out.println("CSG triangulating for " + name+"..");
        ArrayList<Polygon> toAdd = new ArrayList<Polygon>();
        ArrayList<Polygon> degenerates = new ArrayList<Polygon>();
        if (providerOf3d == null && Debug3dProvider.provider != null)
            providerOf3d = Debug3dProvider.provider;
        IDebug3dProvider start = Debug3dProvider.provider;
        Debug3dProvider.setProvider(null);
        try {
            Stream<Polygon> polygonStream;
            polygonStream =polygons.stream();
            // TODO this should work in paralell but throws immpossible NPE's instead.
//          if (getPolygons().size() > 200) {
//              polygonStream = polygons.parallelStream();
//          }
            polygonStream.forEach(p -> updatePolygons(toAdd, degenerates, p));
//          for (int i = 0; i < polygons.size(); i++) {
//              Polygon p = polygons.get(i);
//              updatePolygons(toAdd, degenerates, p);
//          }
            
            
            if(degenerates.size()>0) {
                //
                //Debug3dProvider.setProvider(providerOf3d);
    
                if(fix) {
                    Debug3dProvider.clearScreen();
                    Stream<Polygon> degenStreeam;
                    degenStreeam =polygons.stream(); // this operation is read-modify-write and can not be done in parallel
                    System.out.println("Found "+degenerates.size()+" degenerate triangles, Attempting to fix");
                    degenStreeam.forEach(p -> fixDegenerates(toAdd, p));
                }else {
                    needsDegeneratesPruned=true;
                    toAdd.addAll(degenerates);
                }
            }
            if (toAdd.size() > 0) {
                setPolygons(toAdd);
            }
            // now all polygons are definantly triangles
            triangulated=true;
        } catch (Throwable t) {
            t.printStackTrace();
            
        }
        Debug3dProvider.setProvider(start);
        return this;
    }
 
    private void fixDegenerates(ArrayList<Polygon> toAdd, Polygon p) {
        Debug3dProvider.clearScreen();
        Debug3dProvider.addObject(p);
        ArrayList<Vertex> degen =p.getDegeneratePoints();
        Edge longEdge = p.getLongEdge();
        ArrayList<Polygon> polygonsSharing = new ArrayList<Polygon>();
        ArrayList<Polygon> polygonsSharingFixed = new ArrayList<Polygon>();
 
        for(Polygon ptoA:toAdd) {
            ArrayList<Edge> edges = ptoA.edges(); 
            for(Edge e :edges) {
                if(e.equals(longEdge)) {
                    //System.out.println("Degenerate Mate Found!");
                    polygonsSharing.add(ptoA);
                    Debug3dProvider.addObject(ptoA);
                    // TODO inject the points into the found edge
                    // upstream reparirs to mesh generation made this code effectivly unreachable
                    // in  case that turns out to be false, pick up here
                    // the points in degen need to be inserted into the matching polygons
                    // both list of points should be right hand, but since they are other polygons, 
                    // that may not be the case, so sorting needs to take place
                    ArrayList<Vertex> newpoints = new ArrayList<Vertex>();
                    for(Vertex v:ptoA.vertices) {
                        newpoints.add(v);
                        if(e.isThisPointOneOfMine(v)) {
                            for(Vertex v2:degen)
                                newpoints.add(v2);
                        }
                    }
                    Polygon e2 = new Polygon(newpoints, ptoA.getStorage());
                    try {
                        List<Polygon> t = PolygonUtil.concaveToConvex(e2);
                        for(Polygon poly :t) {
                            if(!poly.isDegenerate()) {
                                polygonsSharingFixed.add(poly);
                            }
                        
                        }
                    }catch(Exception ex) {
                        ex.printStackTrace();
                        // retriangulation failed, ok, whatever man, moving on...
                    }
                }
            }
        }
        if(polygonsSharing.size()==0) {
            //System.out.println("Error! Degenerate triangle does not share edge with any triangle");
        }
        if(polygonsSharingFixed.size()>0) {
            toAdd.removeAll(polygonsSharing);
            toAdd.addAll(polygonsSharingFixed);
        }
    }
 
    private void updatePolygons(ArrayList<Polygon> toAdd, ArrayList<Polygon> degenerates, Polygon p) {
        //p=PolygonUtil.pruneDuplicatePoints(p);
        if(p==null)
            return;
//      if(p.isDegenerate()) {
//          degenerates.add(p);
//          return;
//      }
            
        if (p.vertices.size() == 3) {
            toAdd.add(p);
        }else{
            // System.out.println("Fixing error in STL " + name + " polygon# " + i + "
            // number of vertices " + p.vertices.size());
            try {
                List<Polygon> triangles = PolygonUtil.concaveToConvex(p,true);
                for(Polygon poly :triangles) {
                    if(poly.isDegenerate()) {
                        degenerates.add(poly);
                    }else
                        toAdd.add(poly);
                }
            } catch (Throwable ex) {
                Debug3dProvider.setProvider(providerOf3d);
                ex.printStackTrace();
                Debug3dProvider.clearScreen();
                Debug3dProvider.addObject(p);
                try {
                    List<Polygon> triangles = PolygonUtil.concaveToConvex(p,true);
                    toAdd.addAll(triangles);
                }catch(java.lang.IllegalStateException ise) {
                    ise.printStackTrace();
                }
                Debug3dProvider.setProvider(null);
            }
 
        }
    }
 
    public CSG color(Color c) {
        getStorage().set("material:color", "" + c.getRed() + " " + c.getGreen() + " " + c.getBlue());
 
        return this;
    }
 
    public StringBuilder toObjString(StringBuilder sb) {
        triangulate(true);
        sb.append("# Group").append("\n");
        sb.append("g v3d.csg\n");
        sb.append("o " + (name == null || name.length() == 0 ? "CSG Export" : getName()) + "\n");
        class PolygonStruct {
 
            PropertyStorage storage;
            List<Integer> indices;
            String materialName;
 
            public PolygonStruct(PropertyStorage storage, List<Integer> indices, String materialName) {
                this.storage = storage;
                this.indices = indices;
                this.materialName = materialName;
            }
        }
 
        List<Vertex> vertices = new ArrayList<>();
        List<PolygonStruct> indices = new ArrayList<>();
 
        sb.append("\n# Vertices\n");
 
        for (Polygon p : getPolygons()) {
            List<Integer> polyIndices = new ArrayList<>();
 
            p.vertices.stream().forEach((v) -> {
                if (!vertices.contains(v)) {
                    vertices.add(v);
                    v.toObjString(sb);
                    polyIndices.add(vertices.size());
                } else {
                    polyIndices.add(vertices.indexOf(v) + 1);
                }
            });
            indices.add(new PolygonStruct(getStorage(), polyIndices, " "));
 
        }
        HashMap<Vertex, Integer> mapping = new HashMap<Vertex, Integer>();
        HashMap<Transform, Vertex> mappingTF = new HashMap<>();
        if (datumReferences != null) {
            int startingIndex = vertices.size() + 1;
            sb.append("\n# Reference Datum").append("\n");
            for (Transform t : datumReferences) {
                Vertex v = new Vertex(new Vector3d(0, 0, 0), new Vector3d(0, 0, 1)).transform(t);
                Vertex v1 = new Vertex(new Vector3d(0, 0, 1), new Vector3d(0, 0, 1)).transform(t);
                mapping.put(v, startingIndex++);
                mapping.put(v1, startingIndex++);
                mappingTF.put(t, v);
                v.toObjString(sb);
                v1.toObjString(sb);
            }
            sb.append("\n# Datum Lines").append("\n");
            for (Transform t : mappingTF.keySet()) {
                Vertex key = mappingTF.get(t);
                Integer obj = mapping.get(key);
                sb.append("\nl ").append(obj + " ").append(obj + 1).append("\n");
            }
        }
 
        sb.append("\n# Faces").append("\n");
 
        for (PolygonStruct ps : indices) {
            // we triangulate the polygon to ensure
            // compatibility with 3d printer software
            List<Integer> pVerts = ps.indices;
            if (pVerts.size() != 3)
                throw new RuntimeException(name + " can not be exported until triangulated");
            int index1 = pVerts.get(0);
            for (int i = 0; i < pVerts.size() - 2; i++) {
                int index2 = pVerts.get(i + 1);
                int index3 = pVerts.get(i + 2);
 
                sb.append("f ").append(index1).append(" ").append(index2).append(" ").append(index3).append("\n");
            }
        }
 
        sb.append("\n# End Group v3d.csg").append("\n");
 
        return sb;
    }
 
    public String toObjString() {
        StringBuilder sb = new StringBuilder();
        return toObjString(sb).toString();
    }
 
    public CSG weighted(WeightFunction f) {
        return new Modifier(f).modified(this);
    }
 
    public CSG transformed(Transform transform) {
 
        if (getPolygons().isEmpty()) {
            return clone();
        }
 
        List<Polygon> newpolygons = this.getPolygons().stream().map(p -> p.transformed(transform))
                .collect(Collectors.toList());
 
        CSG csg = CSG.fromPolygons(newpolygons).optimization(getOptType());
 
        // csg.setStorage(storage);
 
        if (getName().length() != 0) {
            csg.setName(name + " transformed by[" + transform + "]");
        }
 
        return csg.historySync(this);
    }
 
    // TODO finish experiment (20.7.2014)
    public MeshContainer toJavaFXMesh(CadInteractionEvent interact) {
 
        return toJavaFXMeshSimple(interact);
 
        // TODO test obj approach with multiple materials
        // try {
        // ObjImporter importer = new ObjImporter(toObj());
        //
        // List<Mesh> meshes = new ArrayList<>(importer.getMeshCollection());
        // return new MeshContainer(getBounds().getMin(), getBounds().getMax(),
        // meshes, new ArrayList<>(importer.getMaterialCollection()));
        // } catch (IOException ex) {
        // Logger.getLogger(CSG.class.getName()).log(Level.SEVERE, null, ex);
        // }
        // // we have no backup strategy for broken streams :(
        // return null;
    }
 
    public MeshContainer toJavaFXMeshSimple(CadInteractionEvent interact) {
 
        return CSGtoJavafx.meshFromPolygon(getPolygons());
    }
 
    public Bounds getBounds() {
        if (bounds != null)
            return bounds;
        if (getPolygons().isEmpty()) {
            bounds = new Bounds(Vector3d.ZERO, Vector3d.ZERO);
            return bounds;
        }
 
        double minX = Double.POSITIVE_INFINITY;
        double minY = Double.POSITIVE_INFINITY;
        double minZ = Double.POSITIVE_INFINITY;
 
        double maxX = Double.NEGATIVE_INFINITY;
        double maxY = Double.NEGATIVE_INFINITY;
        double maxZ = Double.NEGATIVE_INFINITY;
 
        for (Polygon p : getPolygons()) {
 
            for (int i = 0; i < p.vertices.size(); i++) {
 
                Vertex vert = p.vertices.get(i);
 
                if (vert.pos.x < minX) {
                    minX = vert.pos.x;
                }
                if (vert.pos.y < minY) {
                    minY = vert.pos.y;
                }
                if (vert.pos.z < minZ) {
                    minZ = vert.pos.z;
                }
 
                if (vert.pos.x > maxX) {
                    maxX = vert.pos.x;
                }
                if (vert.pos.y > maxY) {
                    maxY = vert.pos.y;
                }
                if (vert.pos.z > maxZ) {
                    maxZ = vert.pos.z;
                }
 
            } // end for vertices
 
        } // end for polygon
 
        bounds = new Bounds(new Vector3d(minX, minY, minZ), new Vector3d(maxX, maxY, maxZ));
        return bounds;
    }
 
    public Vector3d getCenter() {
        return new Vector3d(getCenterX(), getCenterY(), getCenterZ());
    }
 
    public double getCenterX() {
        return ((getMinX() / 2) + (getMaxX() / 2));
    }
 
    public double getCenterY() {
        return ((getMinY() / 2) + (getMaxY() / 2));
    }
 
    public double getCenterZ() {
        return ((getMinZ() / 2) + (getMaxZ() / 2));
    }
 
    public double getMaxX() {
        return getBounds().getMax().x;
    }
 
    public double getMaxY() {
        return getBounds().getMax().y;
    }
 
    public double getMaxZ() {
        return getBounds().getMax().z;
    }
 
    public double getMinX() {
        return getBounds().getMin().x;
    }
 
    public double getMinY() {
        return getBounds().getMin().y;
    }
 
    public double getMinZ() {
        return getBounds().getMin().z;
    }
 
    public double getTotalX() {
        return (-this.getMinX() + this.getMaxX());
    }
 
    public double getTotalY() {
        return (-this.getMinY() + this.getMaxY());
    }
 
    public double getTotalZ() {
        return (-this.getMinZ() + this.getMaxZ());
    }
 
    private OptType getOptType() {
        return optType != null ? optType : defaultOptType;
    }
 
    public static void setDefaultOptType(OptType optType) {
        defaultOptType = optType;
    }
 
    public void setOptType(OptType optType) {
        this.optType = optType;
    }
 
    public void setPolygons(List<Polygon> polygons) {
        bounds = null;
        triangulated=false;
        this.polygons = polygons;
    }
 
    public static enum OptType {
 
        CSG_BOUND,
 
        POLYGON_BOUND,
 
        NONE
    }
 
    @Deprecated
    public ArrayList<CSG> minovsky(CSG travelingShape) {
        System.out.println("Hail Zeon!");
        return minkowski(travelingShape);
    }
 
    public ArrayList<CSG> mink(CSG travelingShape) {
        return minkowski(travelingShape);
    }
 
    public ArrayList<CSG> minkowskiHullShape(CSG travelingShape) {
        ArrayList<CSG> bits = new ArrayList<>();
        for (Polygon p : this.getPolygons()) {
            List<Vector3d> plist = new ArrayList<>();
            for (Vertex v : p.vertices) {
                CSG newSHape = travelingShape.move(v);
                for (Polygon np : newSHape.getPolygons()) {
                    for (Vertex nv : np.vertices) {
                        plist.add(nv.pos);
                    }
                }
            }
            bits.add(HullUtil.hull(plist));
        }
        return bits;
    }
 
    public ArrayList<CSG> minkowski(CSG travelingShape) {
        HashMap<Vertex, CSG> map = new HashMap<>();
        for (Polygon p : travelingShape.getPolygons()) {
            for (Vertex v : p.vertices) {
                if (map.get(v) == null)// use hashmap to avoid duplicate locations
                    map.put(v, this.move(v));
            }
        }
        return new ArrayList<CSG>(map.values());
    }
 
    public CSG minkowskiDifference(CSG itemToDifference, CSG minkowskiObject) {
        CSG intersection = this.intersect(itemToDifference);
 
        ArrayList<CSG> csgDiff = intersection.minkowskiHullShape(minkowskiObject);
        CSG result = this;
        for (int i = 0; i < csgDiff.size(); i++) {
            result = result.difference(csgDiff.get(i));
            progressMoniter.progressUpdate(i, csgDiff.size(), "Minkowski difference", result);
        }
        return result;
    }
 
    public CSG minkowskiDifference(CSG itemToDifference, double tolerance) {
        double shellThickness = Math.abs(tolerance);
        if (shellThickness < 0.001)
            return this;
        return minkowskiDifference(itemToDifference, new Sphere(shellThickness / 2.0, 8, 4).toCSG());
    }
 
    public CSG toolOffset(Number sn) {
        double shellThickness = sn.doubleValue();
        boolean cut = shellThickness < 0;
        shellThickness = Math.abs(shellThickness);
        if (shellThickness < 0.001)
            return this;
        double z = shellThickness;
        if (z > this.getTotalZ() / 2)
            z = this.getTotalZ() / 2;
        CSG printNozzel = new Sphere(z / 2.0, 8, 4).toCSG();
 
        if (cut) {
            ArrayList<CSG> mikObjs = minkowski(printNozzel);
            CSG remaining = this;
            for (CSG bit : mikObjs) {
                remaining = remaining.intersect(bit);
            }
            return remaining;
        }
        return union(minkowskiHullShape(printNozzel));
    }
 
    private int getNumFacesForOffsets() {
        return getNumfacesinoffset();
    }
 
    public CSG makeKeepaway(Number sn) {
        double shellThickness = sn.doubleValue();
 
        double x = Math.abs(this.getBounds().getMax().x) + Math.abs(this.getBounds().getMin().x);
        double y = Math.abs(this.getBounds().getMax().y) + Math.abs(this.getBounds().getMin().y);
 
        double z = Math.abs(this.getBounds().getMax().z) + Math.abs(this.getBounds().getMin().z);
 
        double xtol = (x + shellThickness) / x;
        double ytol = (y + shellThickness) / y;
        double ztol = (z + shellThickness) / z;
 
        double xPer = -(Math.abs(this.getBounds().getMax().x) - Math.abs(this.getBounds().getMin().x)) / x;
        double yPer = -(Math.abs(this.getBounds().getMax().y) - Math.abs(this.getBounds().getMin().y)) / y;
        double zPer = -(Math.abs(this.getBounds().getMax().z) - Math.abs(this.getBounds().getMin().z)) / z;
 
        // println " Keep away x = "+y+" new = "+ytol
        return this.transformed(new Transform().scale(xtol, ytol, ztol))
                .transformed(new Transform().translateX(shellThickness * xPer))
                .transformed(new Transform().translateY(shellThickness * yPer))
                .transformed(new Transform().translateZ(shellThickness * zPer)).historySync(this);
 
    }
 
    public Affine getManipulator() {
        if (manipulator == null)
            manipulator = new Affine();
        return manipulator;
    }
 
    public CSG addCreationEventStackTraceList(ArrayList<Exception> incoming) {
        for (Exception ex : incoming) {
            addStackTrace(ex);
 
        }
        return this;
    }
 
    private void addStackTrace(Exception creationEventStackTrace2) {
        for (StackTraceElement el : creationEventStackTrace2.getStackTrace()) {
            try {
                if (!el.getFileName().endsWith(".java") && el.getLineNumber() > 0) {
                    boolean dupLine = false;
                    String thisline = el.getFileName() + ":" + el.getLineNumber();
                    for (String s : groovyFileLines) {
                        if (s.contentEquals(thisline)) {
                            dupLine = true;
                            // System.err.println("Dupe: "+thisline);
                            break;
                        }
                    }
                    if (dupLine == false) {
                        groovyFileLines.add(thisline);
                        // System.err.println("Line: "+thisline);
                        // for(String s:groovyFileLines){
                        // //System.err.println("\t\t "+s);
                        // creationEventStackTrace2.printStackTrace();
                        // }
                    }
                }
            } catch (NullPointerException ex) {
 
            }
        }
    }
 
    public CSG historySync(CSG dyingCSG) {
        if (useStackTraces) {
            this.addCreationEventStringList(dyingCSG.getCreationEventStackTraceList());
        }
        Set<String> params = dyingCSG.getParameters();
        for (String param : params) {
            boolean existing = false;
            for (String s : this.getParameters()) {
                if (s.contentEquals(param))
                    existing = true;
            }
            if (!existing) {
                Parameter vals = CSGDatabase.get(param);
                if (vals != null)
                    this.setParameter(vals, dyingCSG.getMapOfparametrics().get(param));
            }
        }
        this.setColor(dyingCSG.getColor());
        if (getName().length() == 0)
            setName(dyingCSG.getName());
        return this;
    }
 
    public CSG addCreationEventStringList(ArrayList<String> incoming) {
        if (useStackTraces)
            for (String s : incoming) {
                addCreationEventString(s);
            }
 
        return this;
    }
 
    public CSG addCreationEventString(String thisline) {
        if (useStackTraces) {
            boolean dupLine = false;
            for (String s : groovyFileLines) {
                if (s.contentEquals(thisline)) {
                    dupLine = true;
                    break;
                }
            }
            if (!dupLine) {
                groovyFileLines.add(thisline);
            }
        }
 
        return this;
    }
 
    public ArrayList<String> getCreationEventStackTraceList() {
        return groovyFileLines;
    }
 
    public CSG prepMfg() {
        return prepForManufacturing();
    }
 
    public PrepForManufacturing getManufacturing() {
        return manufactuing;
    }
 
    public PrepForManufacturing getMfg() {
        return getManufacturing();
    }
 
    public CSG setMfg(PrepForManufacturing manufactuing) {
        return setManufacturing(manufactuing);
    }
 
    public CSG setManufacturing(PrepForManufacturing manufactuing) {
        this.manufactuing = manufactuing;
        return this;
    }
 
    @Deprecated
    public PrepForManufacturing getManufactuing() {
        return getManufacturing();
    }
 
    @Deprecated
    public CSG setManufactuing(PrepForManufacturing manufactuing) {
        return setManufacturing(manufactuing);
    }
 
    public CSG setParameter(Parameter w, IParametric function) {
        if (w == null)
            return this;
        if (CSGDatabase.get(w.getName()) == null)
            CSGDatabase.set(w.getName(), w);
        if (getMapOfparametrics().get(w.getName()) == null)
            getMapOfparametrics().put(w.getName(), function);
        return this;
    }
 
    public CSG setParameter(Parameter w) {
        setParameter(w, new IParametric() {
            @Override
            public CSG change(CSG oldCSG, String parameterKey, Long newValue) {
                if (parameterKey.contentEquals(w.getName()))
                    CSGDatabase.get(w.getName()).setValue(newValue);
                return oldCSG;
            }
        });
        return this;
    }
 
    public CSG setParameter(String key, double defaultValue, double upperBound, double lowerBound,
            IParametric function) {
        ArrayList<Double> vals = new ArrayList<Double>();
        vals.add(upperBound);
        vals.add(lowerBound);
        setParameter(new LengthParameter(key, defaultValue, vals), function);
        return this;
    }
 
    public CSG setParameterIfNull(String key) {
        if (getMapOfparametrics().get(key) == null)
            getMapOfparametrics().put(key, new IParametric() {
 
                @Override
                public CSG change(CSG oldCSG, String parameterKey, Long newValue) {
                    CSGDatabase.get(key).setValue(newValue);
                    return oldCSG;
                }
            });
        return this;
    }
 
    public Set<String> getParameters() {
 
        return getMapOfparametrics().keySet();
    }
 
    public CSG setParameterNewValue(String key, double newValue) {
        IParametric function = getMapOfparametrics().get(key);
        if (function != null)
            return function.change(this, key, new Long((long) (newValue * 1000))).setManipulator(this.getManipulator())
                    .setColor(this.getColor());
        return this;
    }
 
    public CSG setRegenerate(IRegenerate function) {
        regenerate = function;
        return this;
    }
 
    public CSG regenerate() {
        this.markForRegeneration = false;
        if (regenerate == null)
            return this;
        CSG regenerate2 = regenerate.regenerate(this);
        if (regenerate2 != null)
            return regenerate2.setManipulator(this.getManipulator()).setColor(this.getColor());
        return this;
    }
 
    public HashMap<String, IParametric> getMapOfparametrics() {
        if (mapOfparametrics == null) {
            mapOfparametrics = new HashMap<>();
        }
        return mapOfparametrics;
    }
 
    public boolean isMarkedForRegeneration() {
        return markForRegeneration;
    }
 
    public void markForRegeneration() {
        this.markForRegeneration = true;
    }
 
    public boolean touching(CSG incoming) {
        // Fast bounding box overlap check, quick fail if not intersecting
        // bounding boxes
        if (this.getMaxX() > incoming.getMinX() && this.getMinX() < incoming.getMaxX()
                && this.getMaxY() > incoming.getMinY() && this.getMinY() < incoming.getMaxY()
                && this.getMaxZ() > incoming.getMinZ() && this.getMinZ() < incoming.getMaxZ()) {
            // Run a full intersection
            CSG inter = this.intersect(incoming);
            if (inter.getPolygons().size() > 0) {
                // intersection success
                return true;
            }
        }
        return false;
    }
 
    public static ICSGProgress getProgressMoniter() {
        return progressMoniter;
    }
 
    public static void setProgressMoniter(ICSGProgress progressMoniter) {
        CSG.progressMoniter = progressMoniter;
    }
 
    public static Color getDefaultColor() {
        return defaultcolor;
    }
 
    public static void setDefaultColor(Color defaultcolor) {
        CSG.defaultcolor = defaultcolor;
    }
 
    public CSG getBoundingBox() {
        return new Cube((-this.getMinX() + this.getMaxX()), (-this.getMinY() + this.getMaxY()),
                (-this.getMinZ() + this.getMaxZ())).toCSG().toXMax().movex(this.getMaxX()).toYMax()
                        .movey(this.getMaxY()).toZMax().movez(this.getMaxZ());
    }
 
    public String getName() {
        return name;
    }
 
    public CSG setName(String name) {
        this.name = name;
        return this;
    }
 
    @Override
    public String toString() {
        if (name == null)
            return getColor().toString();
        return getName() + " " + getColor().toString();
    }
 
    public ArrayList<Transform> getSlicePlanes() {
        return slicePlanes;
    }
 
    public void addSlicePlane(Transform slicePlane) {
        if (slicePlanes == null)
            slicePlanes = new ArrayList<>();
        this.slicePlanes.add(slicePlane);
 
    }
 
    public ArrayList<String> getExportFormats() {
        return exportFormats;
    }
 
    public void clearExportFormats() {
        if (exportFormats != null)
            exportFormats.clear();
    }
 
    public void addExportFormat(String exportFormat) {
        if (this.exportFormats == null)
            this.exportFormats = new ArrayList<>();
        for (String f : exportFormats) {
            if (f.toLowerCase().contains(exportFormat.toLowerCase())) {
                return;
            }
        }
        this.exportFormats.add(exportFormat.toLowerCase());
    }
 
    public static int getNumfacesinoffset() {
        return getNumFacesInOffset();
    }
 
    public static int getNumFacesInOffset() {
        return numFacesInOffset;
    }
 
    public static void setNumFacesInOffset(int numFacesInOffset) {
        CSG.numFacesInOffset = numFacesInOffset;
    }
 
    public static boolean isUseStackTraces() {
        return useStackTraces;
    }
 
    public static void setUseStackTraces(boolean useStackTraces) {
        CSG.useStackTraces = useStackTraces;
    }
 
    public ArrayList<Transform> getDatumReferences() {
        return datumReferences;
    }
 
    private void setDatumReferences(ArrayList<Transform> datumReferences) {
        this.datumReferences = datumReferences;
    }
 
    public PropertyStorage getStorage() {
        return str;
    }
 
    public void setStorage(PropertyStorage storage) {
        this.str = storage;
    }
 
    public ArrayList<CSG> addTabs(Vector3d edgeDirection, CSG fastener) throws Exception {
 
        ArrayList<CSG> result = new ArrayList<CSG>();
        ArrayList<CSG> fasteners = new ArrayList<CSG>();
 
        // Apply cumulative transformation to the board
        Transform boardTrans = addTabsReorientation(edgeDirection);
        CSG boardTemp = this.transformed(boardTrans);
 
        // TODO: Here, find the polygon defined by the XY plane slice that is perhaps
        // 0.5mm into the +Y. Add tabs to THAT polygon's minX/maxX instead of part's
        // global minX/maxX.
 
        // Define the size of the tabs and the distance between tab cycles
        double tabSize = boardTemp.getMaxZ() * 2;
        double cycleSize = tabSize * 3;
 
        // Determine the minimum buffer space between the edge of the board and the tabs
        double minBuffer = boardTemp.getMaxZ();
 
        // Create a temporary CSG object for a single tab
        CSG tabTemp = new Cube(tabSize, boardTemp.getMaxZ(), boardTemp.getMaxZ()).toCSG();
 
        // Position the temporary tab object at the first tab location
        tabTemp = tabTemp.movex(tabTemp.getMaxX()).movey(-tabTemp.getMaxY() + boardTemp.getMinY())
                .movez(tabTemp.getMaxZ());
 
        // Position the temporary fastener hole object at an initial fastener hole
        // location that does not actually render (analogous to the first tab location,
        // but the first tab is not associated with a fastener)
        CSG fastenerHoleTemp = fastener.rotx(-90).movex(-tabSize).movey(0).movez(boardTemp.getMaxZ() / 2);
 
        // Calculate the number of full tab-space cycles to add, not including the first
        // tab (this is also the number of fastener objects to return)
        int iterNum = (int) Math.floor((boardTemp.getMaxX() - tabSize - minBuffer * 2) / cycleSize); // Round down to
                                                                                                        // ensure an
                                                                                                        // integer value
 
        // Calculate the clearance beyond the outermost tabs, equal on both sides and
        // never more than minBuffer
        double bufferVal = (boardTemp.getMaxX() - (tabSize + cycleSize * iterNum)) / 2;
 
        // Add the first tab if there is enough room, which due to not being paired with
        // a fastener is removed from the loop
        if (boardTemp.getTotalX() > tabSize + 2 * bufferVal) {
            boardTemp = boardTemp.union(tabTemp.movex(bufferVal));
        }
 
        // Add the desired number of tabs & fasteners at regular intervals
        for (int i = 1; i <= iterNum; i++) {
            double xVal = bufferVal + i * cycleSize;
            boardTemp = boardTemp.union(tabTemp.movex(xVal));
            fasteners.add(fastenerHoleTemp.movex(xVal).transformed(boardTrans.inverse()));
        }
 
        // Translate the boardTemp object back to its original position
        boardTemp = boardTemp.transformed(boardTrans.inverse());
 
        result.add(boardTemp);
        result.addAll(fasteners);
 
        return result;
    }
 
    private Transform addTabsReorientation(Vector3d edgeDirection) throws Exception {
        // Instantiate a new transformation which will capture cumulative
        // transformations being operated on the input board, to be reversed later
        Transform boardTrans = new Transform();
 
        // Determine orientation transformation, based on edgeDirection vector
        if (edgeDirection.equals(Vector3d.X_ONE)) {
            boardTrans = boardTrans.rotz(90);
        } else if (edgeDirection.equals(Vector3d.X_ONE.negated())) {
            boardTrans = boardTrans.rotz(-90);
        } else if (edgeDirection.equals(Vector3d.Y_ONE)) {
            boardTrans = boardTrans.rotz(180);
        } else if (edgeDirection.equals(Vector3d.Y_ONE.negated())) {
            // boardTrans = boardTrans; // original addTabs orientation, so no
            // transformation needed
        } else if (edgeDirection.equals(Vector3d.Z_ONE)) {
            boardTrans = boardTrans.rotx(-90);
        } else if (edgeDirection.equals(Vector3d.Z_ONE.negated())) {
            boardTrans = boardTrans.rotx(90);
        } else {
            throw new Exception(
                    "Invalid edge direction: edgeDirection must be a cartesian unit Vector3d object. Try Vector3d.Y_ONE.negated() - Current value: "
                            + edgeDirection.toString());
        }
 
        // Apply orientation transformation
        CSG boardTemp = this.transformed(boardTrans);
 
        // Translate the boardTemp object so that its minimum corner is at the origin,
        // adding to cumulative transformation
        boardTrans = boardTrans.movex(-boardTemp.getMinX()).movey(-boardTemp.getMinY()).movez(-boardTemp.getMinZ());
 
        // Apply translation transformation
        boardTemp = this.transformed(boardTrans);
 
        // If the board is larger in Z than in X, assume that the board is oriented into
        // the XY plane and rotate to flatten it onto the XY plane
        if (boardTemp.getTotalZ() > boardTemp.getTotalX()) {
            boardTrans = boardTrans.roty(-90).movez(boardTemp.getMaxX());
        }
        return boardTrans;
    }
 
    public ArrayList<CSG> addTabs(Vector3d edgeDirection, LengthParameter fastenerHoleDiameter) throws Exception {
 
        // Apply cumulative transformation to the board
        Transform boardTrans = addTabsReorientation(edgeDirection);
        CSG boardTemp = this.transformed(boardTrans);
 
        // Create a temporary CSG object for a single fastener hole
        double fastenerHoleRadius = fastenerHoleDiameter.getMM() / 2.0;
        double fastenerHoleDepth = boardTemp.getMaxZ();
        CSG fastenerHoleTemp = new Cylinder(fastenerHoleRadius, fastenerHoleDepth).toCSG();
        ArrayList<CSG> result = this.addTabs(edgeDirection, fastenerHoleTemp);
        return result;
    }
 
    CSG addAssemblyStep(int stepNumber, Transform explodedPose) {
        String key = "AssemblySteps";
        PropertyStorage incomingGetStorage = getAssemblyStorage();
        if (incomingGetStorage.getValue(key) == Optional.empty()) {
            HashMap<Integer, Transform> map = new HashMap<>();
            incomingGetStorage.set(key, map);
        }
        if (incomingGetStorage.getValue("MaxAssemblyStep") == Optional.empty()) {
            incomingGetStorage.set("MaxAssemblyStep", Integer.valueOf(stepNumber));
        }
        Integer max = (Integer) incomingGetStorage.getValue("MaxAssemblyStep").get();
        if (stepNumber > max.intValue()) {
            incomingGetStorage.set("MaxAssemblyStep", Integer.valueOf(stepNumber));
        }
        HashMap<Integer, Transform> map = (HashMap<Integer, Transform>) incomingGetStorage.getValue(key).get();
        map.put(stepNumber, explodedPose);
        if (incomingGetStorage.getValue("AssembleAffine") == Optional.empty())
            incomingGetStorage.set("AssembleAffine", new Affine());
        return this;
    }
 
    public PropertyStorage getAssemblyStorage() {
        if (assembly == null)
            assembly = new PropertyStorage();
        return assembly;
    }
 
    public boolean isWireFrame() {
        if (!getStorage().getValue("skeleton").isPresent())
            return false;
        return (boolean) getStorage().getValue("skeleton").get();
    }
 
    public void setIsWireFrame(boolean b) {
        getStorage().set("skeleton", b);
    }
 
    public void setPrintBedNumber(int index) {
        getStorage().set("printBedIndex", index);
    }
 
    public int getPrintBedIndex() {
        if (!getStorage().getValue("printBedIndex").isPresent())
            return 0;
        return (int) getStorage().getValue("printBedIndex").get();
    }
    public static CSG text(String text, double height, double fontSize) {
        return text( text,  height,  fontSize, "Arial");
    }
    public static CSG text(String text, double height) {
        return text( text,  height,  30);
    }
    public static CSG text(String text, double height, double fontSize, String fontType) {
        javafx.scene.text.Font font = new javafx.scene.text.Font(fontType,  fontSize);
        ArrayList<CSG> stuff = TextExtrude.text(height,text,font);
        CSG back =null;
        for(int i=0;i<stuff.size();i++) {
            if(back==null)
                back=stuff.get(i);
            else {
                back=back.dumbUnion(stuff.get(i));
            }
        }
        back=back.rotx(180)
                .toZMin();
        return back;
    }
    public static CSG textToSize(String text, double x, double y, double z) {
        CSG startText = CSG.text( text, z) ;
        double scalex = x/startText.getTotalX();
        double scaley = y/startText.getTotalY();
        return startText
                .scalex(scalex)
                .scaley(scaley)
                .toXMin();
    }
    
    
    
}