Polygon.java

Go to the documentation of this file.

 
package eu.mihosoft.vrl.v3d;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import eu.mihosoft.vrl.v3d.ext.org.poly2tri.PolygonUtil;
 
// TODO: Auto-generated Javadoc
public final class Polygon {
 
    public final List<Vertex> vertices;
    private PropertyStorage shared;
    public final Plane plane;
    
 
    void setStorage(PropertyStorage storage) {
        this.shared = storage;
    }
 
    public static List<Polygon> fromConcavePoints(Vector3d... points) {
        Polygon p = fromPoints(points);
 
        return PolygonUtil.concaveToConvex(p);
    }
 
    public static List<Polygon> fromConcavePoints(List<Vector3d> points) {
        Polygon p = fromPoints(points);
 
        return PolygonUtil.concaveToConvex(p);
    }
 
    public Polygon(List<Vertex> vertices, PropertyStorage shared, boolean allowDegenerate) {
        this.vertices = pruneDuplicatePoints(vertices);
        this.shared = shared;
        this.plane = Plane.createFromPoints(
                vertices.get(0).pos,
                vertices.get(1).pos,
                vertices.get(2).pos);
        validateAndInit(allowDegenerate);
    }
    public Polygon(List<Vertex> vertices, PropertyStorage shared) {
        this(vertices,shared,true);
    }
    public Polygon(List<Vertex> vertices) {
        this.vertices = pruneDuplicatePoints(vertices);
        this.plane = Plane.createFromPoints(
                vertices.get(0).pos,
                vertices.get(1).pos,
                vertices.get(2).pos);
        validateAndInit(true);
    }
    public static List<Vertex> pruneDuplicatePoints(List<Vertex> incoming) {
        return incoming;
//      ArrayList<Vertex> newPoints = new ArrayList<Vertex>();
//      for (int i = 0; i < incoming.size(); i++) {
//          Vertex v = incoming.get(i);
//          boolean duplicate = false;
//          for (Vertex vx : newPoints) {
//              if (vx.pos.test(v.pos,  1.0e-4)) {
//                  duplicate = true;
//              }
//          }
//          if (!duplicate) {
//              newPoints.add(v);
//          }
//
//      }
//      try {
//          return newPoints;
//      } catch (java.lang.IndexOutOfBoundsException ex) {
//          return null;
//      }
    }
    private void validateAndInit( boolean allowDegenerate) {
        for (Vertex v : vertices) {
            v.normal = plane.normal;
        }
        setDegenerate(true);
        if (Vector3d.ZERO.equals(plane.normal)) {
            valid = false;
            throw new RuntimeException(
                    "Normal is zero! Probably, duplicate points have been specified!\n\n" + toStlString());
        }
 
        if (vertices.size() < 3) {
            throw new RuntimeException("Invalid polygon: at least 3 vertices expected, got: " + vertices.size());
        }
 
        Edge e = new Edge(vertices.get(0), vertices.get(1));
        for (int i = 2; i < vertices.size(); i++) {
            if (!e.colinear(vertices.get(i).pos)) {
                setDegenerate(false);
                return;
            }
        }
        if (!allowDegenerate) {
            // throw runtimeException;
            new RuntimeException("This polygon is colinear").printStackTrace();
        }
        
    }
    public Polygon(Vertex... vertices) {
        this(Arrays.asList(vertices));
    }
 
    /* (non-Javadoc)
     * @see java.lang.Object#clone()
     */
    @Override
    public Polygon clone() {
        List<Vertex> newVertices = new ArrayList<>();
        this.vertices.forEach((vertex) -> {
            newVertices.add(vertex.clone());
        });
        return new Polygon(newVertices, getStorage(),true);
    }
 
    public Polygon flip() {
        vertices.forEach((vertex) -> {
            vertex.flip();
        });
        Collections.reverse(vertices);
 
        plane.flip();
 
        return this;
    }
 
    public Polygon flipped() {
        return clone().flip();
    }
 
    public String toStlString() {
        return toStlString(new StringBuilder()).toString();
    }
 
    public StringBuilder toStlString(StringBuilder sb) {
 
        if (this.vertices.size() == 3) {
 
            // TODO: improve the triangulation?
            //
            // STL requires triangular polygons.
            // If our polygon has more vertices, create
            // multiple triangles:
            String firstVertexStl = this.vertices.get(0).toStlString();
            for (int i = 0; i < this.vertices.size() - 2; i++) {
                sb.
                        append("  facet normal ").append(
                                this.plane.normal.toStlString()).append("\n").
                        append("    outer loop\n").
                        append("      ").append(firstVertexStl).append("\n").
                        append("      ");
                this.vertices.get(i + 1).toStlString(sb).append("\n").
                        append("      ");
                this.vertices.get(i + 2).toStlString(sb).append("\n").
                        append("    endloop\n").
                        append("  endfacet\n");
            }
        }else {
            throw new RuntimeException("Polygon must be a triangle before STL can be made "+vertices.size());
        }
 
        return sb;
    }
 
    public Polygon translate(Vector3d v) {
        vertices.forEach((vertex) -> {
            vertex.pos = vertex.pos.plus(v);
        });
 
        Vector3d a = this.vertices.get(0).pos;
        Vector3d b = this.vertices.get(1).pos;
        Vector3d c = this.vertices.get(2).pos;
 
        this.plane.normal = b.minus(a).cross(c.minus(a));
 
        return this;
    }
 
    public Polygon translated(Vector3d v) {
        return clone().translate(v);
    }
 
    public Polygon transform(Transform transform) {
 
        this.vertices.stream().forEach(
                (v) -> {
                    v.transform(transform);
                }
        );
 
        Vector3d a = this.vertices.get(0).pos;
        Vector3d b = this.vertices.get(1).pos;
        Vector3d c = this.vertices.get(2).pos;
 
        this.plane.normal = b.minus(a).cross(c.minus(a)).normalized();
        this.plane.dist = this.plane.normal.dot(a);
 
        if (transform.isMirror()) {
            // the transformation includes mirroring. flip polygon
            flip();
 
        }
        return this;
    }
 
    public Polygon transformed(Transform transform) {
        return clone().transform(transform);
    }
 
    public static Polygon fromPoints(List<Vector3d> points,
            PropertyStorage shared) {
        return fromPoints(points, shared, null,true);
    }
 
    public static Polygon fromPoints(List<Vector3d> points) {
        return fromPoints(points, new PropertyStorage(), null,true);
    }
 
    public static Polygon fromPoints(Vector3d... points) {
        return fromPoints(Arrays.asList(points), new PropertyStorage(), null,true);
    }
    public static Polygon fromPointsAllowDegenerate(List<Vector3d> vertices2) {
        return fromPoints(vertices2, new PropertyStorage(), null, true);
    }
    private static Polygon fromPoints(
            List<Vector3d> points, PropertyStorage shared, Plane plane, boolean allowDegenerate) {
 
        Vector3d normal
                = (plane != null) ? plane.normal.clone() : new Vector3d(0, 0, 0);
 
        List<Vertex> vertices = new ArrayList<>();
 
        for (Vector3d p : points) {
            Vector3d vec = p.clone();
            Vertex vertex = new Vertex(vec, normal);
            vertices.add(vertex);
        }
 
        return new Polygon(vertices, shared,allowDegenerate);
    }
 
    public Bounds getBounds() {
        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 (int i = 0; i < vertices.size(); i++) {
 
            Vertex vert = 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
 
        return new Bounds(
                new Vector3d(minX, minY, minZ),
                new Vector3d(maxX, maxY, maxZ));
    }
 
    public boolean contains(Vector3d p) {
        // taken from http://www.java-gaming.org/index.php?topic=26013.0
        // and http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
        double px = p.x;
        double py = p.y;
        boolean oddNodes = false;
        double x2 = vertices.get(vertices.size() - 1).pos.x;
        double y2 = vertices.get(vertices.size() - 1).pos.y;
        double x1, y1;
        for (int i = 0; i < vertices.size(); x2 = x1, y2 = y1, ++i) {
            x1 = vertices.get(i).pos.x;
            y1 = vertices.get(i).pos.y;
            if (((y1 < py) && (y2 >= py))
                    || (y1 >= py) && (y2 < py)) {
                if ((py - y1) / (y2 - y1)
                        * (x2 - x1) < (px - x1)) {
                    oddNodes = !oddNodes;
                }
            }
        }
        return oddNodes;
    }
    
    public boolean contains(Polygon p) {
        
        for (Vertex v : p.vertices) {
            if (!contains(v.pos)) {
                return false;
            }
        }
        
        return true;
    }
 
    public PropertyStorage getStorage() {
 
        if (shared == null) {
            shared = new PropertyStorage();
        }
 
        return shared;
    }
 
//  public Exception getCreationEventStackTrace() {
//      return creationEventStackTrace;
//  }
 
    public List<Vector3d> getPoints() {
        ArrayList<Vector3d> p =new ArrayList<>();
        for(Vertex v:vertices) {
            p.add(v.pos);
        }
        return p;
    }
    // Helper/wrapper functions for movement
    public Polygon movey(Number howFarToMove) {
        return this.transformed(Transform.unity().translateY(howFarToMove.doubleValue()));
    }
 
    public Polygon movez(Number howFarToMove) {
        return this.transformed(Transform.unity().translateZ(howFarToMove.doubleValue()));
    }
 
    public Polygon movex(Number howFarToMove) {
        return this.transformed(Transform.unity().translateX(howFarToMove.doubleValue()));
    }
 
    // Rotation function, rotates the object
    public Polygon rotz(Number degreesToRotate) {
        return this.transformed(new Transform().rotZ(degreesToRotate.doubleValue()));
    }
 
    public Polygon roty(Number degreesToRotate) {
        return this.transformed(new Transform().rotY(degreesToRotate.doubleValue()));
    }
 
    public Polygon rotx(Number degreesToRotate) {
        return this.transformed(new Transform().rotX(degreesToRotate.doubleValue()));
    }
 
    // Scale function, scales the object
    public Polygon scalez(Number scaleValue) {
        return this.transformed(new Transform().scaleZ(scaleValue.doubleValue()));
    }
 
    public Polygon scaley(Number scaleValue) {
        return this.transformed(new Transform().scaleY(scaleValue.doubleValue()));
    }
 
    public Polygon scalex(Number scaleValue) {
        return this.transformed(new Transform().scaleX(scaleValue.doubleValue()));
    }
 
    public Polygon scale(Number scaleValue) {
        return this.transformed(new Transform().scale(scaleValue.doubleValue()));
    }
 
    public boolean isValid() {
        return valid;
    }
 
    private boolean valid = true;
    private boolean degenerate=false;
 
 
    public void setDegenerate(boolean degenerate) {
        this.degenerate = degenerate;
    }
    public boolean isDegenerate() {
        
        return degenerate;
    }
    
    public ArrayList<Vertex> getDegeneratePoints() {
        ArrayList<Vertex> back = new ArrayList<Vertex>();
        if(!isDegenerate())
            return back;
        Edge longEdge = getLongEdge();
        for(int i=0;i<vertices.size();i++) {
            Vertex vertex = vertices.get(i);
            if(vertex!= longEdge.getP1()&& vertex!=longEdge.getP2() ) {
                back.add(vertex);
            }
        }
        if(back.size()==0)
            throw new RuntimeException("Failed to find the degenerate point in the polygon");
        return back;
    }
 
    public Edge getLongEdge() {
        if(!isDegenerate())
            return null;
        ArrayList<Edge> e =edges();
        Edge longEdge =e.get(0);
        for(int i=1;i<e.size();i++) {
            Edge edge = e.get(i);
            if(edge.length()>longEdge.length()) {
                longEdge=edge;
            }
        }
        return longEdge;
    }
 
    public ArrayList<Edge> edges() {
        ArrayList<Edge> e=new  ArrayList<Edge>();
        for(int i=0;i<vertices.size();i++) {
            int i1 = i;
            int i2=i+1;
            if(i2==vertices.size()) {
                i2=0;
            }
            e.add(new Edge(vertices.get(i1),vertices.get(i2)));
        }
        return e;
    }
 
 
}