toxiclibs 0.4.0 → 0.8.0

data/src/toxi/geom/BezierCurve3D.java

@@ -0,0 +1,148 @@
+package toxi.geom;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Standard multi-segment bezier curve implementation with optional automatic
+ * handle alignment between segments. Also provides curve tangent calculation
+ * feature. Can be used to create closed curves. Usage of this class is very
+ * similar to {@link Spline3D}.
+ */
+public class BezierCurve3D {
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @param c
+     * @param d
+     * @param t
+     * @return
+     */
+    public static Vec3D computePointInSegment(Vec3D a, Vec3D b, Vec3D c,
+            Vec3D d, float t) {
+        float it = 1.0f - t;
+        float it2 = it * it;
+        float t2 = t * t;
+        return a.scale(it2 * it).addSelf(b.scale(3 * t * it2))
+                .addSelf(c.scale(3 * t2 * it)).addSelf(d.scale(t2 * t));
+    }
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @param c
+     * @param d
+     * @param t
+     * @return
+     */
+    public static Vec3D computeTangentInSegment(Vec3D a, Vec3D b, Vec3D c,
+            Vec3D d, float t) {
+        float t2 = t * t;
+        float x = (3 * t2 * (-a.x + 3 * b.x - 3 * c.x + d.x) + 6 * t
+                * (a.x - 2 * b.x + c.x) + 3 * (-a.x + b.x));
+        float y = (3 * t2 * (-a.y + 3 * b.y - 3 * c.y + d.y) + 6 * t
+                * (a.y - 2 * b.y + c.y) + 3 * (-a.y + b.y));
+        float z = (3 * t2 * (-a.z + 3 * b.z - 3 * c.z + d.z) + 6 * t
+                * (a.z - 2 * b.z + c.z) + 3 * (-a.z + b.z));
+        return new Vec3D(x, y, z).normalize();
+    }
+
+    private final List<Vec3D> points;
+
+    /**
+     *
+     */
+    public BezierCurve3D() {
+        points = new ArrayList<Vec3D>();
+    }
+
+    /**
+     *
+     * @param points
+     */
+    public BezierCurve3D(List<Vec3D> points) {
+        this.points = points;
+    }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public BezierCurve3D add(Vec3D p) {
+        points.add(p);
+        return this;
+    }
+
+    /**
+     *
+     */
+    public void alignAllHandles() {
+        for (int i = 0, num = points.size() - 1; i < num; i += 3) {
+            alignHandlesForPoint(i);
+        }
+    }
+
+    /**
+     *
+     * @param id
+     */
+    public void alignHandlesForPoint(int id) {
+        if (id < points.size() - 1) {
+            Vec3D c;
+            if (id == 0 && isClosed()) {
+                c = points.get(points.size() - 2);
+            } else {
+                c = points.get(id - 1);
+            }
+            Vec3D d = points.get(id);
+            Vec3D e = points.get(id + 1);
+            Vec3D cd = d.sub(c);
+            Vec3D de = e.sub(d);
+            Vec3D cd2 = cd.interpolateTo(de, 0.5f);
+            c.set(d.sub(cd2));
+            e.set(d.add(de.interpolateToSelf(cd, 0.5f)));
+        } else {
+            throw new IllegalArgumentException("invalid point index");
+        }
+    }
+
+    /**
+     * @return true, if the curve is closed. I.e. the first and last control
+     *         point coincide.
+     */
+    public boolean isClosed() {
+        return points.get(0).equals(points.get(points.size() - 1));
+    }
+
+    /**
+     * Computes a list of intermediate curve points for all segments. For each
+     * curve segment the given number of points will be produced.
+     * 
+     * @param res
+     *            number of points per segment
+     * @return list of Vec3Ds
+     */
+    public LineStrip3D toLineStrip3D(int res) {
+        LineStrip3D strip = new LineStrip3D();
+        int i = 0;
+        int maxRes = res;
+        for (int num = points.size(); i < num - 3; i += 3) {
+            Vec3D a = points.get(i);
+            Vec3D b = points.get(i + 1);
+            Vec3D c = points.get(i + 2);
+            Vec3D d = points.get(i + 3);
+            if (i + 3 > num - 3) {
+                maxRes++;
+            }
+            for (int t = 0; t < maxRes; t++) {
+                strip.add(computePointInSegment(a, b, c, d, (float) t / res));
+            }
+        }
+        return strip;
+    }
+
+}

data/src/toxi/geom/BooleanShapeBuilder.java

@@ -0,0 +1,185 @@
+package toxi.geom;
+
+import java.awt.Shape;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.PathIterator;
+import java.awt.geom.Rectangle2D;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author tux
+ */
+public class BooleanShapeBuilder {
+
+    /**
+     *
+     */
+    public enum Type {
+
+        /**
+         *
+         */
+        UNION,
+
+        /**
+         *
+         */
+        INTERSECTION,
+
+        /**
+         *
+         */
+        DIFFERENCE,
+
+        /**
+         *
+         */
+        XOR;
+    }
+
+    private int bezierRes;
+
+    private final Area area;
+    private final Type type;
+
+    /**
+     *
+     * @param type
+     */
+    public BooleanShapeBuilder(Type type) {
+        this(type, 8);
+    }
+
+    /**
+     *
+     * @param type
+     * @param bezierRes
+     */
+    public BooleanShapeBuilder(Type type, int bezierRes) {
+        this.type = type;
+        this.bezierRes = bezierRes;
+        area = new Area();
+    }
+
+    /**
+     *
+     * @param s
+     * @return
+     */
+    public BooleanShapeBuilder addShape(Shape2D s) {
+        return combineWithArea(new Area(convertToAWTShape(s)));
+    }
+
+    /**
+     *
+     * @param a
+     * @return
+     */
+    public BooleanShapeBuilder combineWithArea(Area a) {
+        switch (type) {
+            case UNION:
+                area.add(a);
+                break;
+            case INTERSECTION:
+                area.intersect(a);
+                break;
+            case DIFFERENCE:
+                area.subtract(a);
+                break;
+            case XOR:
+                area.exclusiveOr(a);
+                break;
+        }
+        return this;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public List<Polygon2D> computeShapes() {
+        List<Polygon2D> shapes = new ArrayList<Polygon2D>();
+        PathIterator i = area.getPathIterator(null);
+        float[] buf = new float[6];
+        Vec2D prev = new Vec2D();
+        Polygon2D s = null;
+        while (!i.isDone()) {
+            int id = i.currentSegment(buf);
+            switch (id) {
+                case PathIterator.SEG_MOVETO:
+                    s = new Polygon2D();
+                    shapes.add(s);
+                    prev.set(buf[0], buf[1]);
+                    s.add(prev.copy());
+                    break;
+                case PathIterator.SEG_LINETO:
+                    prev.set(buf[0], buf[1]);
+                    s.add(prev.copy());
+                    break;
+                case PathIterator.SEG_CUBICTO:
+                    Vec2D pa = new Vec2D(buf[0], buf[1]);
+                    Vec2D pb = new Vec2D(buf[2], buf[3]);
+                    Vec2D pc = new Vec2D(buf[4], buf[5]);
+                    for (int t = 0; t <= bezierRes; t++) {
+                        s.add(BezierCurve2D.computePointInSegment(prev, pa, pb,
+                                pc, (float) t / bezierRes));
+                    }
+                    prev.set(pc);
+                    break;
+                case PathIterator.SEG_CLOSE:
+                    break;
+                default:
+                    throw new UnsupportedOperationException(
+                            "Unsupported path segment type: " + id);
+            }
+            i.next();
+        }
+        return shapes;
+    }
+
+    private Shape convertToAWTShape(Shape2D s) {
+        if (s instanceof Rect) {
+            Rect r = (Rect) s;
+            return new Rectangle2D.Float(r.x, r.y, r.width, r.height);
+        }
+        if (s instanceof Triangle2D) {
+            Triangle2D t = (Triangle2D) s;
+            Path2D path = new Path2D.Float();
+            path.moveTo(t.a.x, t.a.y);
+            path.lineTo(t.b.x, t.b.y);
+            path.lineTo(t.c.x, t.c.y);
+            path.closePath();
+            return path;
+        }
+        if (s instanceof Ellipse) {
+            Ellipse e = (Ellipse) s;
+            Vec2D r = e.getRadii();
+            return new Ellipse2D.Float(e.x - r.x, e.y - r.y, r.x * 2, r.y * 2);
+        }
+        if (!(s instanceof Polygon2D)) {
+            s = s.toPolygon2D();
+        }
+        Polygon2D poly = (Polygon2D) s;
+        Path2D path = new Path2D.Float();
+        Vec2D p = poly.get(0);
+        path.moveTo(p.x, p.y);
+        for (int i = 1, num = poly.getNumVertices(); i < num; i++) {
+            p = poly.get(i);
+            path.lineTo(p.x, p.y);
+        }
+        path.closePath();
+        return path;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public Area getArea() {
+        return area;
+    }
+}

data/src/toxi/geom/BoxIntersector.java

@@ -0,0 +1,52 @@
+package toxi.geom;
+
+/**
+ *
+ * @author tux
+ */
+public class BoxIntersector implements Intersector3D {
+
+    private AABB box;
+    private final IsectData3D isec;
+
+    /**
+     *
+     * @param box
+     */
+    public BoxIntersector(AABB box) {
+        this.box = box;
+        this.isec = new IsectData3D();
+    }
+
+    /**
+     * @return the box
+     */
+    public AABB getBox() {
+        return box;
+    }
+
+    @Override
+    public IsectData3D getIntersectionData() {
+        return isec;
+    }
+
+    @Override
+    public boolean intersectsRay(Ray3D ray) {
+        final Vec3D pos = box.intersectsRay(ray, 0, Float.MAX_VALUE);
+        isec.pos = pos;
+        isec.isIntersection = pos != null;
+        if (isec.isIntersection) {
+            isec.normal = box.getNormalForPoint(pos);
+            isec.dist = ray.distanceTo(pos);
+        }
+        return isec.isIntersection;
+    }
+
+    /**
+     * @param box
+     *            the box to set
+     */
+    public void setBox(AABB box) {
+        this.box = box;
+    }
+}

data/src/toxi/geom/Circle.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.List;
+
+import toxi.math.MathUtils;
+
+/**
+ * This class overrides {@link Ellipse} to define a 2D circle and provides
+ * several utility methods for it, including factory methods to construct
+ * circles from points.
+ */
+public class Circle extends Ellipse {
+
+    /**
+     * Factory method to construct a circle which has the two given points lying
+     * on its perimeter. If the points are coincident, the circle will have a
+     * radius of zero.
+     * 
+     * @param p1
+     * @param p2
+     * @return new circle instance
+     */
+    public static Circle from2Points(Vec2D p1, Vec2D p2) {
+        Vec2D m = p1.interpolateTo(p2, 0.5f);
+        return new Circle(m, m.distanceTo(p1));
+    }
+
+    /**
+     * Factory method to construct a circle which has the three given points
+     * lying on its perimeter. The function returns null, if the 3 points are
+     * co-linear (in which case it's impossible to find a circle).
+     * 
+     * Based on CPP code by Paul Bourke:
+     * http://local.wasp.uwa.edu.au/~pbourke/geometry/circlefrom3/
+     * 
+     * @param p1
+     * @param p2
+     * @param p3
+     * @return new circle instance or null
+     */
+    public static Circle from3Points(Vec2D p1, Vec2D p2, Vec2D p3) {
+        Circle circle = null;
+        Vec2D deltaA = p2.sub(p1);
+        Vec2D deltaB = p3.sub(p2);
+        if (MathUtils.abs(deltaA.x) <= 0.0000001f
+                && MathUtils.abs(deltaB.y) <= 0.0000001f) {
+            Vec2D centroid = new Vec2D(p2.x + p3.x, p1.y + p2.y)
+                    .scaleSelf(0.5f);
+            float radius = centroid.distanceTo(p1);
+            circle = new Circle(centroid, radius);
+        } else {
+            float aSlope = deltaA.y / deltaA.x;
+            float bSlope = deltaB.y / deltaB.x;
+            if (MathUtils.abs(aSlope - bSlope) > 0.0000001f) {
+                float x = (aSlope * bSlope * (p1.y - p3.y) + bSlope
+                        * (p1.x + p2.x) - aSlope * (p2.x + p3.x))
+                        / (2 * (bSlope - aSlope));
+                float y = -(x - (p1.x + p2.x) / 2) / aSlope + (p1.y + p2.y) / 2;
+                Vec2D centroid = new Vec2D(x, y);
+                float radius = centroid.distanceTo(p1);
+                circle = new Circle(centroid, radius);
+            }
+        }
+        return circle;
+    }
+
+    /**
+     *
+     * @param vertices
+     * @return
+     */
+    public static Circle newBoundingCircle(List<Vec2D> vertices) {
+        Vec2D origin = new Vec2D();
+        float maxD = 0;
+        for (Vec2D v : vertices) {
+            origin.addSelf(v);
+        }
+        origin.scaleSelf(1f / vertices.size());
+        for (Vec2D v : vertices) {
+            float d = origin.distanceToSquared(v);
+            if (d > maxD) {
+                maxD = d;
+            }
+        }
+        return new Circle(origin, (float) Math.sqrt(maxD));
+    }
+
+    /**
+     *
+     */
+    public Circle() {
+        this(new Vec2D(), 1);
+    }
+
+    /**
+     *
+     * @param c
+     */
+    public Circle(Circle c) {
+        this(c, c.radius.x);
+    }
+
+    /**
+     *
+     * @param radius
+     */
+    public Circle(float radius) {
+        this(0, 0, radius);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param radius
+     */
+    public Circle(float x, float y, float radius) {
+        super(x, y, radius, radius);
+    }
+
+    /**
+     *
+     * @param origin
+     * @param radius
+     */
+    public Circle(ReadonlyVec2D origin, float radius) {
+        super(origin, radius);
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.geom.Ellipse#containsPoint(toxi.geom.Vec2D)
+     */
+    @Override
+    public boolean containsPoint(ReadonlyVec2D p) {
+        return distanceToSquared(p) <= radius.x * radius.x;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.geom.Ellipse#getCircumference()
+     */
+    @Override
+    public float getCircumference() {
+        return MathUtils.TWO_PI * radius.x;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float getRadius() {
+        return radius.x;
+    }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public Vec2D[] getTangentPoints(ReadonlyVec2D p) {
+        Vec2D m = interpolateTo(p, 0.5f);
+        return intersectsCircle(new Circle(m, m.distanceTo(p)));
+    }
+
+    /**
+     *
+     * @param c
+     * @return
+     */
+    public Vec2D[] intersectsCircle(Circle c) {
+        Vec2D[] res = null;
+        Vec2D delta = c.sub(this);
+        float d = delta.magnitude();
+        float r1 = radius.x;
+        float r2 = c.radius.x;
+        if (d <= r1 + r2 && d >= Math.abs(r1 - r2)) {
+            float a = (r1 * r1 - r2 * r2 + d * d) / (2.0f * d);
+            d = 1 / d;
+            Vec2D p = add(delta.scale(a * d));
+            float h = (float) Math.sqrt(r1 * r1 - a * a);
+            delta.perpendicular().scaleSelf(h * d);
+            Vec2D i1 = p.add(delta);
+            Vec2D i2 = p.sub(delta);
+            res = new Vec2D[] {
+                    i1, i2
+            };
+        }
+        return res;
+    }
+
+    /**
+     *
+     * @param r
+     * @return
+     */
+    public Circle setRadius(float r) {
+        super.setRadii(r, r);
+        return this;
+    }
+}