toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/geom/CircleIntersector.java

@@ -0,0 +1,85 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * This class handles Circle-Ray2D intersections by implementing the
+ * {@link Intersector2D} interface.
+ * 
+ */
+public class CircleIntersector implements Intersector2D {
+
+    private final IsectData2D isec = new IsectData2D();
+    private Circle circle;
+
+    /**
+     *
+     * @param circle
+     */
+    public CircleIntersector(Circle circle) {
+        this.circle = circle;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public Circle getCircle() {
+        return circle;
+    }
+
+    @Override
+    public IsectData2D getIntersectionData() {
+        return isec;
+    }
+
+    @Override
+    public boolean intersectsRay(Ray2D ray) {
+        isec.clear();
+        Vec2D q = circle.sub(ray);
+        float distSquared = q.magSquared();
+        float v = q.dot(ray.getDirection());
+        float r = circle.getRadius();
+        float d = r * r - (distSquared - v * v);
+        if (d >= 0.0) {
+            isec.isIntersection = true;
+            isec.dist = v - (float) Math.sqrt(d);
+            isec.pos = ray.getPointAtDistance(isec.dist);
+            isec.normal = isec.pos.sub(circle).normalize();
+        }
+        return isec.isIntersection;
+    }
+
+    /**
+     *
+     * @param circle
+     */
+    public void setCircle(Circle circle) {
+        this.circle = circle;
+    }
+}

data/src/toxi/geom/Cone.java

@@ -0,0 +1,150 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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 toxi.geom.mesh.Mesh3D;
+import toxi.geom.mesh.TriangleMesh;
+import toxi.math.MathUtils;
+
+/**
+ * A geometric definition of a cone (and cylinder as a special case) with
+ * support for mesh creation/representation. The class is currently still
+ * incomplete in that it doesn't provide any other features than the
+ * construction of a cone shaped mesh.
+ */
+public class Cone extends Vec3D {
+
+    /**
+     *
+     */
+    public Vec3D dir;
+
+    /**
+     *
+     */
+    public float radiusSouth;
+
+    /**
+     *
+     */
+    public float radiusNorth;
+
+    /**
+     *
+     */
+    public float length;
+
+    /**
+     * Constructs a new cone instance.
+     * 
+     * @param pos
+     *            centre position
+     * @param dir
+     *            direction
+     * @param rNorth
+     *            radius on the side in the forward direction
+     * @param rSouth
+     *            radius on the side in the opposite direction
+     * @param len
+     *            length of the cone
+     */
+    public Cone(ReadonlyVec3D pos, ReadonlyVec3D dir, float rNorth,
+            float rSouth, float len) {
+        super(pos);
+        this.dir = dir.getNormalized();
+        this.radiusNorth = rNorth;
+        this.radiusSouth = rSouth;
+        this.length = len;
+    }
+
+    /**
+     *
+     * @param steps
+     * @return
+     */
+    public Mesh3D toMesh(int steps) {
+        return toMesh(steps, 0);
+    }
+
+    /**
+     *
+     * @param steps
+     * @param thetaOffset
+     * @return
+     */
+    public Mesh3D toMesh(int steps, float thetaOffset) {
+        return toMesh(null, steps, thetaOffset, true, true);
+    }
+
+    /**
+     *
+     * @param mesh
+     * @param steps
+     * @param thetaOffset
+     * @param topClosed
+     * @param bottomClosed
+     * @return
+     */
+    public Mesh3D toMesh(Mesh3D mesh, int steps, float thetaOffset,
+            boolean topClosed, boolean bottomClosed) {
+        ReadonlyVec3D c = this.add(0.01f, 0.01f, 0.01f);
+        ReadonlyVec3D n = c.cross(dir.getNormalized()).normalize();
+        Vec3D halfAxis = dir.scale(length * 0.5f);
+        Vec3D p = sub(halfAxis);
+        Vec3D q = add(halfAxis);
+        Vec3D[] south = new Vec3D[steps];
+        Vec3D[] north = new Vec3D[steps];
+        float phi = MathUtils.TWO_PI / steps;
+        for (int i = 0; i < steps; i++) {
+            float theta = i * phi + thetaOffset;
+            ReadonlyVec3D nr = n.getRotatedAroundAxis(dir, theta);
+            south[i] = nr.scale(radiusSouth).addSelf(p);
+            north[i] = nr.scale(radiusNorth).addSelf(q);
+        }
+        int numV = steps * 2 + 2;
+        int numF = steps * 2 + (topClosed ? steps : 0)
+                + (bottomClosed ? steps : 0);
+        if (mesh == null) {
+            mesh = new TriangleMesh("cone", numV, numF);
+        }
+        for (int i = 0, j = 1; i < steps; i++, j++) {
+            if (j == steps) {
+                j = 0;
+            }
+            mesh.addFace(south[i], north[i], south[j], null, null, null, null);
+            mesh.addFace(south[j], north[i], north[j], null, null, null, null);
+            if (bottomClosed) {
+                mesh.addFace(p, south[i], south[j], null, null, null, null);
+            }
+            if (topClosed) {
+                mesh.addFace(north[i], q, north[j], null, null, null, null);
+            }
+        }
+        return mesh;
+    }
+}

data/src/toxi/geom/ConvexPolygonClipper.java

@@ -0,0 +1,136 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.List;
+
+/**
+ * A more generic version of the Sutherland-Hodgeman algorithm to limit 2D
+ * polygons to convex clipping regions. Uses the clipping region's centroid and
+ * {@link Line2D#classifyPoint(ReadonlyVec2D)} to identify if an edge needs to
+ * be clipped or not.
+ * 
+ * More information: http://en.wikipedia.org/wiki/Sutherland-Hodgman_algorithm
+ * 
+ * @see SutherlandHodgemanClipper
+ * @since 0021
+ */
+public class ConvexPolygonClipper implements PolygonClipper2D {
+
+    /**
+     *
+     */
+    protected Polygon2D bounds;
+
+    /**
+     *
+     */
+    protected Vec2D boundsCentroid;
+
+    /**
+     *
+     * @param bounds
+     */
+    public ConvexPolygonClipper(Polygon2D bounds) {
+        setBounds(bounds);
+    }
+
+    @Override
+    public Polygon2D clipPolygon(Polygon2D poly) {
+        List<Vec2D> points = new ArrayList<>(poly.vertices);
+        List<Vec2D> clipped = new ArrayList<>();
+        points.add(points.get(0));
+        for (Line2D clipEdge : bounds.getEdges()) {
+            clipped.clear();
+            float sign = clipEdge.classifyPoint(boundsCentroid);
+            for (int i = 0, num = points.size() - 1; i < num; i++) {
+                Vec2D p = points.get(i);
+                Vec2D q = points.get(i + 1);
+                if (clipEdge.classifyPoint(p) == sign) {
+                    if (clipEdge.classifyPoint(q) == sign) {
+                        clipped.add(q.copy());
+                    } else {
+                        clipped.add(getClippedPosOnEdge(clipEdge, p, q));
+                    }
+                    continue;
+                }
+                if (clipEdge.classifyPoint(q) == sign) {
+                    clipped.add(getClippedPosOnEdge(clipEdge, p, q));
+                    clipped.add(q.copy());
+                }
+            }
+            if (clipped.size() > 0
+                    && clipped.get(0) != clipped.get(clipped.size() - 1)) {
+                clipped.add(clipped.get(0));
+            }
+            List<Vec2D> t = points;
+            points = clipped;
+            clipped = t;
+        }
+        return new Polygon2D(points).removeDuplicates(0.001f);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public Polygon2D getBounds() {
+        return bounds;
+    }
+
+    /**
+     *
+     * @param clipEdge
+     * @param p
+     * @param q
+     * @return
+     */
+    protected Vec2D getClippedPosOnEdge(Line2D clipEdge, Vec2D p, Vec2D q) {
+        return clipEdge.intersectLine(new Line2D(p, q)).getPos();
+    }
+
+    /**
+     *
+     * @param list
+     * @param q
+     * @return
+     */
+    protected boolean isKnownVertex(List<Vec2D> list, Vec2D q) {
+        return list.stream().anyMatch((p) -> (p.equalsWithTolerance(q, 0.001f)));
+    }
+
+    /**
+     *
+     * @param bounds
+     */
+    public final void setBounds(Polygon2D bounds) {
+        this.bounds = bounds;
+        this.boundsCentroid = bounds.getCentroid();
+    }
+}

data/src/toxi/geom/CoordinateExtractor.java

@@ -0,0 +1,16 @@
+package toxi.geom;
+
+/**
+ *
+ * @author tux
+ * @param <T>
+ */
+public interface CoordinateExtractor<T> {
+
+    /**
+     *
+     * @param obj
+     * @return
+     */
+    public float coordinate(T obj);
+}

data/src/toxi/geom/Ellipse.java

@@ -0,0 +1,250 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.List;
+
+import toxi.math.MathUtils;
+import toxi.util.datatypes.BiasedFloatRange;
+
+/**
+ * This class defines a 2D ellipse and provides several utility methods for it.
+ */
+public class Ellipse extends Vec2D implements Shape2D {
+
+    /**
+     *
+     */
+    public static int DEFAULT_RES = 20;
+
+    /**
+     *
+     */
+    protected Vec2D radius = new Vec2D();
+
+    /**
+     *
+     */
+    protected float focus;
+
+    /**
+     *
+     */
+    public Ellipse() {
+        this(0, 0, 1);
+
+    }
+
+    /**
+     *
+     * @param rx
+     * @param ry
+     */
+    public Ellipse(float rx, float ry) {
+        this(0, 0, rx, ry);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param r
+     */
+    public Ellipse(float x, float y, float r) {
+        this(x, y, r, r);
+
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param rx
+     * @param ry
+     */
+    public Ellipse(float x, float y, float rx, float ry) {
+        super(x, y);
+        setRadii(rx, ry);
+    }
+
+    /**
+     *
+     * @param v
+     * @param r
+     */
+    public Ellipse(ReadonlyVec2D v, float r) {
+        this(v.x(), v.y(), r, r);
+    }
+
+    /**
+     *
+     * @param v
+     * @param r
+     */
+    public Ellipse(ReadonlyVec2D v, ReadonlyVec2D r) {
+        this(v.x(), v.y(), r.x(), r.y());
+    }
+
+    @Override
+    public boolean containsPoint(ReadonlyVec2D p) {
+        Vec2D[] foci = getFoci();
+        return p.distanceTo(foci[0]) + p.distanceTo(foci[1]) < 2 * MathUtils
+                .max(radius.x, radius.y);
+    }
+
+    /**
+     * Computes the area covered by the ellipse.
+     * 
+     * @return area
+     */
+    @Override
+    public float getArea() {
+        return MathUtils.PI * radius.x * radius.y;
+    }
+
+    @Override
+    public Circle getBoundingCircle() {
+        return new Circle(x, y, MathUtils.max(radius.x, radius.y));
+    }
+
+    /**
+     * Returns the ellipse's bounding rect.
+     * 
+     * @return bounding rect
+     * @see toxi.geom.Shape2D#getBounds()
+     */
+    @Override
+    public Rect getBounds() {
+        return new Rect(sub(radius), add(radius));
+    }
+
+    /**
+     * Computes the approximate circumference of the ellipse, using this
+     * equation: <code>2 * PI * sqrt(1/2 * (rx*rx+ry*ry))</code>.
+     * 
+     * The precise value is an infinite series elliptical integral, but the
+     * approximation comes sufficiently close. See Wikipedia for more details:
+     * 
+     * http://en.wikipedia.org/wiki/Ellipse
+     * 
+     * @return circumference
+     */
+    @Override
+    public float getCircumference() {
+        // wikipedia solution:
+        // return (float) (MathUtils.PI * (3 * (radius.x + radius.y) - Math
+        // .sqrt((3 * radius.x + radius.y) * (radius.x + 3 * radius.y))));
+        return (float) Math.sqrt(0.5 * radius.magSquared()) * MathUtils.TWO_PI;
+    }
+
+    @Override
+    public List<Line2D> getEdges() {
+        return toPolygon2D().getEdges();
+    }
+
+    /**
+     * @return the focus
+     */
+    public Vec2D[] getFoci() {
+        Vec2D[] foci = new Vec2D[2];
+        if (radius.x > radius.y) {
+            foci[0] = sub(focus, 0);
+            foci[1] = add(focus, 0);
+        } else {
+            foci[0] = sub(0, focus);
+            foci[1] = add(0, focus);
+        }
+        return foci;
+    }
+
+    /**
+     * @return the 2 radii of the ellipse as a Vec2D
+     */
+    public Vec2D getRadii() {
+        return radius.copy();
+    }
+
+    /**
+     * Creates a random point within the ellipse using a
+     * {@link BiasedFloatRange} to create a more uniform distribution.
+     * 
+     * @return Vec2D
+     */
+    @Override
+    public Vec2D getRandomPoint() {
+        float theta = MathUtils.random(MathUtils.TWO_PI);
+        BiasedFloatRange rnd = new BiasedFloatRange(0f, 1f, 1f, MathUtils.SQRT2);
+        return Vec2D.fromTheta(theta).scaleSelf(radius.scale(rnd.pickRandom()))
+                .addSelf(this);
+    }
+
+    /**
+     * Sets the radii of the ellipse to the new values.
+     * 
+     * @param rx
+     * @param ry
+     * @return itself
+     */
+    public final Ellipse setRadii(float rx, float ry) {
+        radius.set(rx, ry);
+        focus = radius.magnitude();
+        return this;
+    }
+
+    /**
+     * Sets the radii of the ellipse to the values given by the vector.
+     * 
+     * @param r
+     * @return itself
+     */
+    public Ellipse setRadii(ReadonlyVec3D r) {
+        return setRadii(r.x(), r.y());
+    }
+
+    @Override
+    public Polygon2D toPolygon2D() {
+        return toPolygon2D(DEFAULT_RES);
+    }
+
+    /**
+     * Creates a {@link Polygon2D} instance of the ellipse sampling it at the
+     * given resolution.
+     * 
+     * @param res
+     *            number of steps
+     * @return ellipse as polygon
+     */
+    public Polygon2D toPolygon2D(int res) {
+        Polygon2D poly = new Polygon2D();
+        float step = MathUtils.TWO_PI / res;
+        for (int i = 0; i < res; i++) {
+            poly.add(Vec2D.fromTheta(i * step).scaleSelf(radius).addSelf(this));
+        }
+        return poly;
+    }
+}