toxiclibs 0.4.0 → 0.8.0

data/src/toxi/geom/LineStrip2D.java

@@ -0,0 +1,430 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.xml.bind.annotation.XmlElement;
+
+import toxi.geom.Line2D.LineIntersection;
+import toxi.geom.Line2D.LineIntersection.Type;
+import toxi.math.MathUtils;
+
+/**
+ *
+ * @author tux
+ */
+public class LineStrip2D implements Iterable<Vec2D> {
+
+    /**
+     *
+     */
+    @XmlElement(name = "v")
+    protected List<Vec2D> vertices = new ArrayList<>();
+
+    /**
+     *
+     */
+    protected float[] arcLenIndex;
+
+    /**
+     *
+     */
+    public LineStrip2D() {
+    }
+
+    /**
+     *
+     * @param vertices
+     */
+    public LineStrip2D(Collection<? extends Vec2D> vertices) {
+        this.vertices = new ArrayList<>(vertices);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    public LineStrip2D add(float x, float y) {
+        vertices.add(new Vec2D(x, y));
+        return this;
+    }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public LineStrip2D add(ReadonlyVec2D p) {
+        vertices.add(p.copy());
+        return this;
+    }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public LineStrip2D add(Vec2D p) {
+        vertices.add(p);
+        return this;
+    }
+
+    /**
+     * Returns the vertex at the given index. This function follows Python
+     * convention, in that if the index is negative, it is considered relative
+     * to the list end. Therefore the vertex at index -1 is the last vertex in
+     * the list.
+     * 
+     * @param i
+     *            index
+     * @return vertex
+     */
+    public Vec2D get(int i) {
+        if (i < 0) {
+            i += vertices.size();
+        }
+        return vertices.get(i);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public Circle getBoundingCircle() {
+        return Circle.newBoundingCircle(vertices);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public Rect getBounds() {
+        return Rect.getBoundingRect(vertices);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public Vec2D getCentroid() {
+        int num = vertices.size();
+        if (num > 0) {
+            Vec2D centroid = new Vec2D();
+            vertices.stream().forEach((v) -> {
+                centroid.addSelf(v);
+            });
+            return centroid.scaleSelf(1f / num);
+        }
+        return null;
+    }
+
+    /**
+     * Computes a list of points along the spline which are uniformly separated
+     * by the given step distance.
+     * 
+     * @param step
+     * @return point list
+     */
+    public List<Vec2D> getDecimatedVertices(float step) {
+        return getDecimatedVertices(step, true);
+    }
+
+    /**
+     * Computes a list of points along the spline which are close to uniformly
+     * separated by the given step distance. The uniform distribution is only an
+     * approximation and is based on the estimated arc length of the polyline.
+     * The distance between returned points might vary in places, especially if
+     * there're sharp angles between line segments.
+     * 
+     * @param step
+     * @param doAddFinalVertex
+     *            true, if the last vertex computed should be added regardless
+     *            of its distance.
+     * @return point list
+     */
+    public List<Vec2D> getDecimatedVertices(float step, boolean doAddFinalVertex) {
+        ArrayList<Vec2D> uniform = new ArrayList<>();
+        if (vertices.size() < 3) {
+            if (vertices.size() == 2) {
+                new Line2D(vertices.get(0), vertices.get(1)).splitIntoSegments(
+                        uniform, step, true);
+                if (!doAddFinalVertex) {
+                    uniform.remove(uniform.size() - 1);
+                }
+            } else {
+                return null;
+            }
+        }
+        float arcLen = getLength();
+        if (arcLen > 0) {
+            double delta = step / arcLen;
+            int currIdx = 0;
+            for (double t = 0; t < 1.0; t += delta) {
+                double currT = t * arcLen;
+                while (currT >= arcLenIndex[currIdx]) {
+                    currIdx++;
+                }
+                ReadonlyVec2D p = vertices.get(currIdx - 1);
+                ReadonlyVec2D q = vertices.get(currIdx);
+                float frac = (float) ((currT - arcLenIndex[currIdx - 1]) / (arcLenIndex[currIdx] - arcLenIndex[currIdx - 1]));
+                Vec2D i = p.interpolateTo(q, frac);
+                uniform.add(i);
+            }
+            if (doAddFinalVertex) {
+                uniform.add(vertices.get(vertices.size() - 1).copy());
+            }
+        }
+        return uniform;
+    }
+
+    /**
+     * Returns a list of {@link Line2D} segments representing the segments
+     * between the vertices of this strip.
+     * 
+     * @return list of lines
+     */
+    public List<Line2D> getEdges() {
+        int num = vertices.size();
+        List<Line2D> edges = new ArrayList<>(num - 1);
+        for (int i = 1; i < num; i++) {
+            edges.add(new Line2D(vertices.get(i - 1), vertices.get(i)));
+        }
+        return edges;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float getLength() {
+        if (arcLenIndex == null
+                || (arcLenIndex != null && arcLenIndex.length != vertices
+                        .size())) {
+            arcLenIndex = new float[vertices.size()];
+        }
+        float arcLen = 0;
+        for (int i = 1; i < arcLenIndex.length; i++) {
+            ReadonlyVec2D p = vertices.get(i - 1);
+            ReadonlyVec2D q = vertices.get(i);
+            arcLen += p.distanceTo(q);
+            arcLenIndex[i] = arcLen;
+        }
+        return arcLen;
+    }
+
+    /**
+     * Computes point at position t, where t is the normalized position along
+     * the strip. If t&lt;0 then the first vertex of the strip is returned. If
+     * t&gt;=1.0 the last vertex is returned. If the strip contains less than 2
+     * vertices, this method returns null.
+     * 
+     * @param t
+     * @return
+     */
+    public Vec2D getPointAt(float t) {
+        int num = vertices.size();
+        if (num > 1) {
+            if (t <= 0.0) {
+                return vertices.get(0);
+            } else if (t >= 1.0) {
+                return vertices.get(num - 1);
+            }
+            float totalLength = this.getLength();
+            double offp = 0, offq = 0;
+            for (int i = 1; i < num; i++) {
+                Vec2D p = vertices.get(i - 1);
+                Vec2D q = vertices.get(i);
+                offq += q.distanceTo(p) / totalLength;
+                if (offp <= t && offq >= t) {
+                    return p.interpolateTo(q, (float) MathUtils.mapInterval(t,
+                            offp, offq, 0.0, 1.0));
+                }
+                offp = offq;
+            }
+        }
+        return null;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public List<Line2D> getSegments() {
+        final int num = vertices.size();
+        List<Line2D> segments = new ArrayList<>(num - 1);
+        for (int i = 1; i < num; i++) {
+            segments.add(new Line2D(vertices.get(i - 1), vertices.get(i)));
+        }
+        return segments;
+    }
+
+    /**
+     * @return the vertices
+     */
+    public List<Vec2D> getVertices() {
+        return vertices;
+    }
+
+    /**
+     *
+     * @param line
+     * @return
+     */
+    public LineIntersection intersectLine(Line2D line) {
+        Line2D l = new Line2D(new Vec2D(), new Vec2D());
+        for (int i = 1, num = vertices.size(); i < num; i++) {
+            l.set(vertices.get(i - 1), vertices.get(i));
+            LineIntersection isec = l.intersectLine(line);
+            if (isec.getType() == Type.INTERSECTING
+                    || isec.getType() == Type.COINCIDENT) {
+                return isec;
+            }
+        }
+        return null;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public Iterator<Vec2D> iterator() {
+        return vertices.iterator();
+    }
+
+    /**
+     *
+     * @param theta
+     * @return
+     */
+    public LineStrip2D rotate(float theta) {
+        vertices.stream().forEach((v) -> {
+            v.rotate(theta);
+        });
+        return this;
+    }
+
+    /**
+     *
+     * @param scale
+     * @return
+     */
+    public LineStrip2D scale(float scale) {
+        return scale(scale, scale);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    public LineStrip2D scale(float x, float y) {
+        vertices.stream().forEach((v) -> {
+            v.scaleSelf(x, y);
+        });
+        return this;
+    }
+
+    /**
+     *
+     * @param scale
+     * @return
+     */
+    public LineStrip2D scale(ReadonlyVec2D scale) {
+        return scale(scale.x(), scale.y());
+    }
+
+    /**
+     *
+     * @param scale
+     * @return
+     */
+    public LineStrip2D scaleSize(float scale) {
+        return scaleSize(scale, scale);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    public LineStrip2D scaleSize(float x, float y) {
+        Vec2D centroid = getCentroid();
+        vertices.stream().forEach((v) -> {
+            v.subSelf(centroid).scaleSelf(x, y).addSelf(centroid);
+        });
+        return this;
+    }
+
+    /**
+     *
+     * @param scale
+     * @return
+     */
+    public LineStrip2D scaleSize(ReadonlyVec2D scale) {
+        return scaleSize(scale.x(), scale.y());
+    }
+
+    /**
+     * @param vertices
+     *            the vertices to set
+     */
+    public void setVertices(List<Vec2D> vertices) {
+        this.vertices = vertices;
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    public LineStrip2D translate(float x, float y) {
+        vertices.stream().forEach((v) -> {
+            v.addSelf(x, y);
+        });
+        return this;
+    }
+
+    /**
+     *
+     * @param offset
+     * @return
+     */
+    public LineStrip2D translate(ReadonlyVec2D offset) {
+        return translate(offset.x(), offset.y());
+    }
+}

data/src/toxi/geom/LineStrip3D.java

@@ -0,0 +1,230 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.xml.bind.annotation.XmlElement;
+
+/**
+ *
+ * @author tux
+ */
+public class LineStrip3D implements Iterable<Vec3D> {
+
+    /**
+     *
+     */
+    @XmlElement(name = "v")
+    protected List<Vec3D> vertices = new ArrayList<>();
+
+    /**
+     *
+     */
+    protected float[] arcLenIndex;
+
+    /**
+     *
+     */
+    public LineStrip3D() {
+    }
+
+    /**
+     *
+     * @param vertices
+     */
+    public LineStrip3D(Collection<? extends Vec3D> vertices) {
+        this.vertices = new ArrayList<>(vertices);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @return
+     */
+    public LineStrip3D add(float x, float y, float z) {
+        vertices.add(new Vec3D(x, y, z));
+        return this;
+    }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public LineStrip3D add(ReadonlyVec3D p) {
+        vertices.add(p.copy());
+        return this;
+    }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public LineStrip3D add(Vec3D p) {
+        vertices.add(p);
+        return this;
+    }
+
+    /**
+     * Returns the vertex at the given index. This function follows Python
+     * convention, in that if the index is negative, it is considered relative
+     * to the list end. Therefore the vertex at index -1 is the last vertex in
+     * the list.
+     * 
+     * @param i
+     *            index
+     * @return vertex
+     */
+    public Vec3D get(int i) {
+        if (i < 0) {
+            i += vertices.size();
+        }
+        return vertices.get(i);
+    }
+
+    /**
+     * Computes a list of points along the spline which are uniformly separated
+     * by the given step distance.
+     * 
+     * @param step
+     * @return point list
+     */
+    public List<Vec3D> getDecimatedVertices(float step) {
+        return getDecimatedVertices(step, true);
+    }
+
+    /**
+     * Computes a list of points along the spline which are close to uniformly
+     * separated by the given step distance. The uniform distribution is only an
+     * approximation and is based on the estimated arc length of the polyline.
+     * The distance between returned points might vary in places, especially if
+     * there're sharp angles between line segments.
+     * 
+     * @param step
+     * @param doAddFinalVertex
+     *            true, if the last vertex computed should be added regardless
+     *            of its distance.
+     * @return point list
+     */
+    public List<Vec3D> getDecimatedVertices(float step, boolean doAddFinalVertex) {
+        ArrayList<Vec3D> uniform = new ArrayList<>();
+        if (vertices.size() < 3) {
+            if (vertices.size() == 2) {
+                new Line3D(vertices.get(0), vertices.get(1)).splitIntoSegments(
+                        uniform, step, true);
+                if (!doAddFinalVertex) {
+                    uniform.remove(uniform.size() - 1);
+                }
+            } else {
+                return null;
+            }
+        }
+        float arcLen = getEstimatedArcLength();
+        double delta = (double) step / arcLen;
+        int currIdx = 0;
+        for (double t = 0; t < 1.0; t += delta) {
+            double currT = t * arcLen;
+            while (currT >= arcLenIndex[currIdx]) {
+                currIdx++;
+            }
+            ReadonlyVec3D p = vertices.get(currIdx - 1);
+            ReadonlyVec3D q = vertices.get(currIdx);
+            float frac = (float) ((currT - arcLenIndex[currIdx - 1]) / (arcLenIndex[currIdx] - arcLenIndex[currIdx - 1]));
+            Vec3D i = p.interpolateTo(q, frac);
+            uniform.add(i);
+        }
+        if (doAddFinalVertex) {
+            uniform.add(vertices.get(vertices.size() - 1).copy());
+        }
+        return uniform;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float getEstimatedArcLength() {
+        if (arcLenIndex == null
+                || (arcLenIndex != null && arcLenIndex.length != vertices
+                        .size())) {
+            arcLenIndex = new float[vertices.size()];
+        }
+        float arcLen = 0;
+        for (int i = 1; i < arcLenIndex.length; i++) {
+            ReadonlyVec3D p = vertices.get(i - 1);
+            ReadonlyVec3D q = vertices.get(i);
+            arcLen += p.distanceTo(q);
+            arcLenIndex[i] = arcLen;
+        }
+        return arcLen;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public List<Line3D> getSegments() {
+        final int num = vertices.size();
+        List<Line3D> segments = new ArrayList<>(num - 1);
+        for (int i = 1; i < num; i++) {
+            segments.add(new Line3D(vertices.get(i - 1), vertices.get(i)));
+        }
+        return segments;
+    }
+
+    /**
+     * @return the vertices
+     */
+    public List<Vec3D> getVertices() {
+        return vertices;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public Iterator<Vec3D> iterator() {
+        return vertices.iterator();
+    }
+
+    /**
+     * @param vertices
+     *            the vertices to set
+     */
+    public void setVertices(List<Vec3D> vertices) {
+        this.vertices = vertices;
+    }
+}