toxiclibs 0.4.0 → 0.8.0

data/src/toxi/geom/mesh/subdiv/TriSubdivision.java

@@ -0,0 +1,51 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+package toxi.geom.mesh.subdiv;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import toxi.geom.Vec3D;
+import toxi.geom.mesh.WingedEdge;
+
+/**
+ * This subdivision strategy splits an edge in four equal parts using three
+ * split points at 25%, 50% and 75% of the edge.
+ */
+public class TriSubdivision extends SubdivisionStrategy {
+
+    @Override
+    public List<Vec3D> computeSplitPoints(WingedEdge edge) {
+        List<Vec3D> mid = new ArrayList<>(3);
+        mid.add(edge.a.interpolateTo(edge.b, 0.25f));
+        mid.add(edge.a.interpolateTo(edge.b, 0.5f));
+        mid.add(edge.a.interpolateTo(edge.b, 0.75f));
+        return mid;
+    }
+
+}

data/src/toxi/geom/mesh2d/DelaunayTriangle.java

@@ -0,0 +1,222 @@
+package toxi.geom.mesh2d;
+
+/*
+ * Copyright (c) 2007 by L. Paul Chew.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+import toxi.util.datatypes.ArraySet;
+
+/**
+ * A DelaunayTriangle is an immutable Set of exactly three Pnts.
+ * 
+ * All Set operations are available. Individual vertices can be accessed via
+ * iterator() and also via triangle.get(index).
+ * 
+ * Note that, even if two triangles have the same vertex set, they are
+ * *different* triangles. Methods equals() and hashCode() are consistent with
+ * this rule.
+ * 
+ * @author Paul Chew
+ * 
+ *         Created December 2007. Replaced general simplices with geometric
+ *         triangle.
+ * 
+ */
+public class DelaunayTriangle extends ArraySet<DelaunayVertex> {
+
+    private int idNumber; // The id number
+    private DelaunayVertex circumcenter = null; // The triangle's circumcenter
+
+    private static int idGenerator = 0; // Used to create id numbers
+
+    /**
+     *
+     */
+    public static boolean moreInfo = false; // True if more info in toString
+
+    /**
+     * @param collection
+     *            a Collection holding the Simplex vertices
+     * @throws IllegalArgumentException
+     *             if there are not three distinct vertices
+     */
+    public DelaunayTriangle(Collection<? extends DelaunayVertex> collection) {
+        super(collection);
+        idNumber = idGenerator++;
+        if (this.size() != 3) {
+            throw new IllegalArgumentException(
+                    "DelaunayTriangle must have 3 vertices");
+        }
+    }
+
+    /**
+     * @param vertices
+     *            the vertices of the DelaunayTriangle.
+     * @throws IllegalArgumentException
+     *             if there are not three distinct vertices
+     */
+    public DelaunayTriangle(DelaunayVertex... vertices) {
+        this(Arrays.asList(vertices));
+    }
+
+    /**
+     *
+     * @param vertex
+     * @return
+     */
+    @Override
+    public boolean add(DelaunayVertex vertex) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     *
+     * @param o
+     * @return
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (o instanceof DelaunayTriangle){
+        return (this == o);
+        }
+        return false;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 53 * hash + this.idNumber;
+        return hash;
+    }
+
+    /**
+     * Report the facet opposite vertex.
+     * 
+     * @param vertex
+     *            a vertex of this DelaunayTriangle
+     * @return the facet opposite vertex
+     * @throws IllegalArgumentException
+     *             if the vertex is not in triangle
+     */
+    public ArraySet<DelaunayVertex> facetOpposite(DelaunayVertex vertex) {
+        ArraySet<DelaunayVertex> facet = new ArraySet<>(this);
+        if (!facet.remove(vertex)) {
+            throw new IllegalArgumentException("Vertex not in triangle");
+        }
+        return facet;
+    }
+
+    /**
+     * @return the triangle's circumcenter
+     */
+    public DelaunayVertex getCircumcenter() {
+        if (circumcenter == null) {
+            circumcenter = DelaunayVertex.circumcenter(this
+                    .toArray(new DelaunayVertex[0]));
+        }
+        return circumcenter;
+    }
+
+    /**
+     * Get arbitrary vertex of this triangle, but not any of the bad vertices.
+     * 
+     * @param badVertices
+     *            one or more bad vertices
+     * @return a vertex of this triangle, but not one of the bad vertices
+     * @throws NoSuchElementException
+     *             if no vertex found
+     */
+    public DelaunayVertex getVertexButNot(DelaunayVertex... badVertices) {
+        Collection<DelaunayVertex> bad = Arrays.asList(badVertices);
+        for (DelaunayVertex v : this) {
+            if (!bad.contains(v)) {
+                return v;
+            }
+        }
+        throw new NoSuchElementException("No vertex found");
+    }
+
+    /**
+     * True iff triangles are neighbors. Two triangles are neighbors if they
+     * share a facet.
+     * 
+     * @param triangle
+     *            the other DelaunayTriangle
+     * @return true iff this DelaunayTriangle is a neighbor of triangle
+     */
+    public boolean isNeighbor(DelaunayTriangle triangle) {
+        int count = 0;
+        count = this.stream().filter((vertex) -> (!triangle.contains(vertex))).map((_item) -> 1).reduce(count, Integer::sum);
+        return count == 1;
+    }
+
+    /* The following two methods ensure that all triangles are different. */
+
+    /**
+     *
+     * @return
+     */
+    
+
+    @Override
+    public Iterator<DelaunayVertex> iterator() {
+        return new Iterator<DelaunayVertex>() {
+
+            private final Iterator<DelaunayVertex> it = DelaunayTriangle.super
+                    .iterator();
+
+            @Override
+            public boolean hasNext() {
+                return it.hasNext();
+            }
+
+            @Override
+            public DelaunayVertex next() {
+                return it.next();
+            }
+
+            @Override
+            public void remove() {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        if (!moreInfo) {
+            return "DelaunayTriangle" + idNumber;
+        }
+        return "DelaunayTriangle" + idNumber + super.toString();
+    }
+
+}

data/src/toxi/geom/mesh2d/DelaunayTriangulation.java

@@ -0,0 +1,327 @@
+package toxi.geom.mesh2d;
+
+/*
+ * Copyright (c) 2005, 2007 by L. Paul Chew.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+
+import toxi.util.datatypes.UndirectedGraph;
+
+/**
+ * A 2D Delaunay DelaunayTriangulation (DT) with incremental site insertion.
+ *
+ * This is not the fastest way to build a DT, but it's a reasonable way to build
+ * a DT incrementally and it makes a nice interactive display. There are several
+ * O(n log n) methods, but they require that the sites are all known initially.
+ *
+ * A DelaunayTriangulation is a Set of Triangles. A DelaunayTriangulation is
+ * unmodifiable as a Set; the only way to change it is to add sites (via
+ * delaunayPlace).
+ *
+ * @author Paul Chew
+ *
+ * Created July 2005. Derived from an earlier, messier version.
+ *
+ * Modified November 2007. Rewrote to use AbstractSet as parent class and to use
+ * the UndirectedGraph class internally. Tried to make the DT algorithm clearer
+ * by explicitly creating a cavity. Added code needed to find a Voronoi cell.
+ *
+ * @author Karsten Schmidt
+ *
+ * Ported to use toxiclibs classes (June 2010).
+ */
+public class DelaunayTriangulation extends AbstractSet<DelaunayTriangle> {
+
+    private DelaunayTriangle mostRecent = null;
+
+    private final UndirectedGraph<DelaunayTriangle> triGraph;
+
+    /**
+     * All sites must fall within the initial triangle.
+     *
+     * @param triangle the initial triangle
+     */
+    public DelaunayTriangulation(DelaunayTriangle triangle) {
+        triGraph = new UndirectedGraph<>();
+        triGraph.add(triangle);
+        mostRecent = triangle;
+    }
+
+    /**
+     * True iff triangle is a member of this triangulation. This method isn't
+     * required by AbstractSet, but it improves efficiency.
+     *
+     * @param triangle the object to check for membership
+     * @return
+     */
+    @Override
+    public boolean contains(Object triangle) {
+        return triGraph.getNodes().contains(triangle);
+    }
+
+    /**
+     * Place a new site into the DT. Nothing happens if the site matches an
+     * existing DT vertex.
+     *
+     * @param site the new DelaunayVertex
+     * @throws IllegalArgumentException if site does not lie in any triangle
+     */
+    public void delaunayPlace(DelaunayVertex site) {
+        // Uses straightforward scheme rather than best asymptotic time
+        // Locate containing triangle
+        DelaunayTriangle triangle = locate(site);
+        // Give up if no containing triangle or if site is already in DT
+        if (triangle == null) {
+            throw new IllegalArgumentException("No containing triangle");
+        }
+        if (triangle.contains(site)) {
+            return;
+        }
+        // Determine the cavity and update the triangulation
+        Set<DelaunayTriangle> cavity = getCavity(site, triangle);
+        mostRecent = update(site, cavity);
+    }
+
+    /**
+     * Determine the cavity caused by site.
+     *
+     * @param site the site causing the cavity
+     * @param triangle the triangle containing site
+     * @return set of all triangles that have site in their circumcircle
+     */
+    private Set<DelaunayTriangle> getCavity(DelaunayVertex site,
+            DelaunayTriangle triangle) {
+        Set<DelaunayTriangle> encroached = new HashSet<>();
+        Queue<DelaunayTriangle> toBeChecked = new LinkedList<>();
+        Set<DelaunayTriangle> marked = new HashSet<>();
+        toBeChecked.add(triangle);
+        marked.add(triangle);
+        while (!toBeChecked.isEmpty()) {
+            triangle = toBeChecked.remove();
+            if (site.vsCircumcircle(triangle.toArray(new DelaunayVertex[0])) == 1) {
+                // Site outside triangle => triangle not in cavity
+                continue;
+            }
+            encroached.add(triangle);
+            // Check the neighbors
+            for (DelaunayTriangle neighbor : triGraph
+                    .getConnectedNodesFor(triangle)) {
+                if (marked.contains(neighbor)) {
+                    continue;
+                }
+                marked.add(neighbor);
+                toBeChecked.add(neighbor);
+            }
+        }
+        return encroached;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public Iterator<DelaunayTriangle> iterator() {
+        return triGraph.getNodes().iterator();
+    }
+
+    /**
+     * Locate the triangle with point inside it or on its boundary.
+     *
+     * @param point the point to locate
+     * @return the triangle that holds point; null if no such triangle
+     */
+    public DelaunayTriangle locate(DelaunayVertex point) {
+        DelaunayTriangle triangle = mostRecent;
+        if (!this.contains(triangle)) {
+            triangle = null;
+        }
+
+        // Try a directed walk (this works fine in 2D, but can fail in 3D)
+        Set<DelaunayTriangle> visited = new HashSet<>();
+        while (triangle != null) {
+            if (visited.contains(triangle)) { // This should never happen
+                System.out.println("Warning: Caught in a locate loop");
+                break;
+            }
+            visited.add(triangle);
+            // Corner opposite point
+            DelaunayVertex corner = point.isOutside(triangle
+                    .toArray(new DelaunayVertex[0]));
+            if (corner == null) {
+                return triangle;
+            }
+            triangle = this.neighborOpposite(corner, triangle);
+        }
+        // No luck; try brute force
+        System.out.println("Warning: Checking all triangles for " + point);
+        for (DelaunayTriangle tri : this) {
+            if (point.isOutside(tri.toArray(new DelaunayVertex[0])) == null) {
+                return tri;
+            }
+        }
+        // No such triangle
+        System.out.println("Warning: No triangle holds " + point);
+        return null;
+    }
+
+    /**
+     * Report neighbor opposite the given vertex of triangle.
+     *
+     * @param site a vertex of triangle
+     * @param triangle we want the neighbor of this triangle
+     * @return the neighbor opposite site in triangle; null if none
+     * @throws IllegalArgumentException if site is not in this triangle
+     */
+    public DelaunayTriangle neighborOpposite(DelaunayVertex site,
+            DelaunayTriangle triangle) {
+        if (!triangle.contains(site)) {
+            throw new IllegalArgumentException("Bad vertex; not in triangle");
+        }
+        for (DelaunayTriangle neighbor : triGraph
+                .getConnectedNodesFor(triangle)) {
+            if (!neighbor.contains(site)) {
+                return neighbor;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Return the set of triangles adjacent to triangle.
+     *
+     * @param triangle the triangle to check
+     * @return the neighbors of triangle
+     */
+    public Set<DelaunayTriangle> neighbors(DelaunayTriangle triangle) {
+        return triGraph.getConnectedNodesFor(triangle);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int size() {
+        return triGraph.getNodes().size();
+    }
+
+    /**
+     * Report triangles surrounding site in order (cw or ccw).
+     *
+     * @param site we want the surrounding triangles for this site
+     * @param triangle a "starting" triangle that has site as a vertex
+     * @return all triangles surrounding site in order (cw or ccw)
+     * @throws IllegalArgumentException if site is not in triangle
+     */
+    public List<DelaunayTriangle> surroundingTriangles(DelaunayVertex site,
+            DelaunayTriangle triangle) {
+        if (!triangle.contains(site)) {
+            throw new IllegalArgumentException("Site not in triangle");
+        }
+        List<DelaunayTriangle> list = new ArrayList<>();
+        DelaunayTriangle start = triangle;
+        DelaunayVertex guide = triangle.getVertexButNot(site); // Affects cw or
+        // ccw
+        while (true) {
+            list.add(triangle);
+            DelaunayTriangle previous = triangle;
+            triangle = this.neighborOpposite(guide, triangle); // Next triangle
+            guide = previous.getVertexButNot(site, guide); // Update guide
+            if (triangle == start) {
+                break;
+            }
+        }
+        return list;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        return "DelaunayTriangulation with " + size() + " triangles";
+    }
+
+    /**
+     * Update the triangulation by removing the cavity triangles and then
+     * filling the cavity with new triangles.
+     *
+     * @param site the site that created the cavity
+     * @param cavity the triangles with site in their circumcircle
+     * @return one of the new triangles
+     */
+    private DelaunayTriangle update(DelaunayVertex site,
+            Set<DelaunayTriangle> cavity) {
+        Set<Set<DelaunayVertex>> boundary = new HashSet<>();
+        Set<DelaunayTriangle> theTriangles = new HashSet<>();
+
+        // Find boundary facets and adjacent triangles
+        cavity.stream().map((DelaunayTriangle triangle) -> {
+            theTriangles.addAll(neighbors(triangle));
+            return triangle;
+        }).forEach((DelaunayTriangle triangle) -> {
+            triangle.stream().map((vertex) -> triangle.facetOpposite(vertex)).forEach((facet) -> {
+                if (boundary.contains(facet)) {
+                    boundary.remove(facet);
+                } else {
+                    boundary.add(facet);
+                }
+            });
+        });
+        theTriangles.removeAll(cavity); // Adj triangles only
+        // Remove the cavity triangles from the triangulation
+        cavity.stream().forEach((DelaunayTriangle triangle) -> {
+            triGraph.remove(triangle);
+        });
+
+        // Build each new triangle and add it to the triangulation
+        Set<DelaunayTriangle> newTriangles = new HashSet<>();
+        boundary.stream().map((vertices) -> {
+            vertices.add(site);
+            return vertices;
+        }).map((vertices) -> new DelaunayTriangle(vertices)).map((tri) -> {
+            triGraph.add(tri);
+            return tri;
+        }).forEach((tri) -> {
+            newTriangles.add(tri);
+        });
+
+        // Update the graph links for each new triangle
+        theTriangles.addAll(newTriangles); // Adj triangle + new triangles
+        for (DelaunayTriangle triangle : newTriangles) {
+            for (DelaunayTriangle other : theTriangles) {
+                if (triangle.isNeighbor(other)) {
+                    triGraph.connect(triangle, other);
+                }
+            }
+        }
+
+        // Return one of the new triangles
+        return newTriangles.iterator().next();
+    }
+}