toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/geom/Sphere.java

@@ -0,0 +1,224 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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 javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+
+import toxi.geom.mesh.Mesh3D;
+import toxi.geom.mesh.SphereFunction;
+import toxi.geom.mesh.SurfaceMeshBuilder;
+
+/**
+ *
+ * @author tux
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+public class Sphere extends Vec3D implements Shape3D {
+
+    /**
+     * Earth's mean radius in km
+     * (http://en.wikipedia.org/wiki/Earth_radius#Mean_radii)
+     */
+    public static final float EARTH_RADIUS = (float) ((2 * 6378.1370 + 6356.752314245) / 3.0);
+
+    /**
+     *
+     */
+    @XmlAttribute(required = true)
+    public float radius;
+
+    /**
+     *
+     */
+    public Sphere() {
+        this(new Vec3D(), 1);
+    }
+
+    /**
+     *
+     * @param radius
+     */
+    public Sphere(float radius) {
+        this(new Vec3D(), radius);
+    }
+
+    /**
+     *
+     * @param v
+     * @param r
+     */
+    public Sphere(ReadonlyVec3D v, float r) {
+        super(v);
+        radius = r;
+    }
+
+    /**
+     *
+     * @param s
+     */
+    public Sphere(Sphere s) {
+        this(s, s.radius);
+    }
+
+    @Override
+    public boolean containsPoint(ReadonlyVec3D p) {
+        float d = this.sub(p).magSquared();
+        return (d <= radius * radius);
+    }
+
+    /**
+     * Alternative to {@link SphereIntersectorReflector}. Computes primary &
+     * secondary intersection points of this sphere with the given ray. If no
+     * intersection is found the method returns null. In all other cases, the
+     * returned array will contain the distance to the primary intersection
+     * point (i.e. the closest in the direction of the ray) as its first index
+     * and the other one as its second. If any of distance values is negative,
+     * the intersection point lies in the opposite ray direction (might be
+     * useful to know). To get the actual intersection point coordinates, simply
+     * pass the returned values to {@link Ray3D#getPointAtDistance(float)}.
+     * 
+     * @param ray
+     * @return 2-element float array of intersection points or null if ray
+     *         doesn't intersect sphere at all.
+     */
+    public float[] intersectRay(Ray3D ray) {
+        float[] result = null;
+        ReadonlyVec3D q = ray.sub(this);
+        float distSquared = q.magSquared();
+        float v = -q.dot(ray.getDirection());
+        float d = radius * radius - (distSquared - v * v);
+        if (d >= 0.0) {
+            d = (float) Math.sqrt(d);
+            float a = v + d;
+            float b = v - d;
+            if (!(a < 0 && b < 0)) {
+                if (a > 0 && b > 0) {
+                    if (a > b) {
+                        float t = a;
+                        a = b;
+                        b = t;
+                    }
+                } else {
+                    if (b > 0) {
+                        float t = a;
+                        a = b;
+                        b = t;
+                    }
+                }
+            }
+            result = new float[] {
+                    a, b
+            };
+        }
+        return result;
+    }
+
+    /**
+     * Considers the current vector as centre of a collision sphere with radius
+     * r and checks if the triangle abc intersects with this sphere. The Vec3D p
+     * The point on abc closest to the sphere center is returned via the
+     * supplied result vector argument.
+     * 
+     * @param t
+     *            triangle to check for intersection
+     * @param result
+     *            a non-null vector for storing the result
+     * @return true, if sphere intersects triangle ABC
+     */
+    public boolean intersectSphereTriangle(Triangle3D t, Vec3D result) {
+        // Find Vec3D P on triangle ABC closest to sphere center
+        result.set(t.closestPointOnSurface(this));
+
+        // Sphere and triangle intersect if the (squared) distance from sphere
+        // center to Vec3D p is less than the (squared) sphere radius
+        ReadonlyVec3D v = result.sub(this);
+        return v.magSquared() <= radius * radius;
+    }
+
+    /**
+     * Computes the surface distance on this sphere between two points given as
+     * lon/lat coordinates. The x component of each vector needs to contain the
+     * longitude and the y component the latitude (both in radians).
+     * 
+     * Algorithm from: http://www.csgnetwork.com/gpsdistcalc.html
+     * 
+     * @param p
+     * @param q
+     * @return distance on the sphere surface
+     */
+    public double surfaceDistanceBetween(Vec2D p, Vec2D q) {
+        double t1 = Math.sin(p.y) * Math.sin(q.y);
+        double t2 = Math.cos(p.y) * Math.cos(q.y);
+        double t3 = Math.cos(p.x - q.x);
+        double t4 = t2 * t3;
+        double t5 = t1 + t4;
+        double dist = Math.atan(-t5 / Math.sqrt(-t5 * t5 + 1)) + 2
+                * Math.atan(1);
+        if (Double.isNaN(dist)) {
+            dist = 0;
+        } else {
+            dist *= radius;
+        }
+        return dist;
+    }
+
+    /**
+     * Calculates the normal vector on the sphere in the direction of the
+     * current point.
+     * 
+     * @param q
+     * @return a unit normal vector to the tangent plane of the ellipsoid in the
+     *         point.
+     */
+    public Vec3D tangentPlaneNormalAt(ReadonlyVec3D q) {
+        return q.sub(this).normalize();
+    }
+
+    /**
+     *
+     * @param res
+     * @return
+     */
+    public Mesh3D toMesh(int res) {
+        return toMesh(null, res);
+    }
+
+    /**
+     *
+     * @param mesh
+     * @param res
+     * @return
+     */
+    public Mesh3D toMesh(Mesh3D mesh, int res) {
+        SurfaceMeshBuilder builder = new SurfaceMeshBuilder(new SphereFunction(
+                this));
+        return builder.createMesh(mesh, res, 1);
+    }
+}

data/src/toxi/geom/SphereIntersectorReflector.java

@@ -0,0 +1,196 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.math.MathUtils;
+
+/**
+ *
+ * @author tux
+ */
+public class SphereIntersectorReflector implements Intersector3D, Reflector3D {
+
+    /**
+     *
+     */
+    protected Sphere sphere;
+
+    /**
+     *
+     */
+    protected IsectData3D isectData;
+
+    protected ReadonlyVec3D reflectedDir,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    reflectedPos;
+
+    /**
+     *
+     */
+    protected float reflectTheta;
+
+    /**
+     *
+     * @param s
+     */
+    public SphereIntersectorReflector(Sphere s) {
+        sphere = s;
+        isectData = new IsectData3D();
+    }
+
+    /**
+     *
+     * @param o
+     * @param r
+     */
+    public SphereIntersectorReflector(Vec3D o, float r) {
+        this(new Sphere(o, r));
+    }
+
+    @Override
+    public IsectData3D getIntersectionData() {
+        return isectData;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.geom.Reflector3D#getReflectedRayPointAtDistance(float)
+     */
+    @Override
+    public ReadonlyVec3D getReflectedRayPointAtDistance(float dist) {
+        if (reflectedDir != null) {
+            return isectData.pos.add(reflectedDir.scale(dist));
+        } else {
+            return null;
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.geom.Reflector3D#getReflectionAngle()
+     */
+    @Override
+    public float getReflectionAngle() {
+        return reflectTheta;
+    }
+
+    /**
+     * @return the sphere
+     */
+    public Sphere getSphere() {
+        return sphere;
+    }
+
+    /**
+     * Calculates the distance of the vector to the given sphere in the
+     * specified direction. A sphere is defined by a 3D point and a radius.
+     * Normalized directional vectors expected.
+     * 
+     * @param ray
+     *            intersection ray
+     * @return distance to sphere in world units, -1 if no intersection.
+     */
+
+    public float intersectRayDistance(Ray3D ray) {
+        ReadonlyVec3D q = sphere.sub(ray);
+        float distSquared = q.magSquared();
+        float v = q.dot(ray.dir);
+        float d = sphere.radius * sphere.radius - (distSquared - v * v);
+
+        // If there was no intersection, return -1
+        if (d < 0.0) {
+            return -1;
+        }
+
+        // Return the distance to the [first] intersecting point
+        return v - (float) Math.sqrt(d);
+    }
+
+    @Override
+    public boolean intersectsRay(Ray3D ray) {
+        isectData.dist = intersectRayDistance(ray);
+        isectData.isIntersection = isectData.dist >= 0;
+        if (isectData.isIntersection) {
+            // get the intersection point
+            isectData.pos = ray.add(ray.getDirection().scale(isectData.dist));
+            // calculate the direction from our point to the intersection pos
+            isectData.dir = isectData.pos.sub(ray);
+            isectData.normal = sphere.tangentPlaneNormalAt(isectData.pos);
+        }
+        return isectData.isIntersection;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.geom.Reflector3D#reflectRay(toxi.geom.Vec3D, toxi.geom.Vec3D)
+     */
+    @Override
+    public Ray3D reflectRay(Ray3D ray) {
+        if (intersectsRay(ray)) {
+            // compute the normal vector of the sphere at the intersection
+            // position
+            // compute the reflection angle
+            reflectTheta = isectData.dir.angleBetween(isectData.normal, true)
+                    * 2 + MathUtils.PI;
+            // then form a perpendicular vector standing on the plane spanned by
+            // isectDir and sphereNormal
+            // this vector will be used to mirror the ray around the
+            // intersection point
+            Vec3D reflectNormal = isectData.dir.getNormalized()
+                    .cross(isectData.normal).normalize();
+            if (!reflectNormal.isZeroVector()) {
+                // compute the reflected ray direction
+                reflectedDir = isectData.dir.getNormalized().rotateAroundAxis(
+                        reflectNormal, reflectTheta);
+            } else {
+                reflectedDir = isectData.dir.getInverted();
+            }
+            return new Ray3D(isectData.pos, reflectedDir);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * @param sphere
+     *            the sphere to set
+     */
+    public void setSphere(Sphere sphere) {
+        this.sphere = sphere;
+    }
+}

data/src/toxi/geom/Spline2D.java

@@ -0,0 +1,349 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.Arrays;
+import java.util.List;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlTransient;
+
+/**
+ * <p>
+ * This is a generic 3D B-Spline class for curves of arbitrary length, control
+ * handles and patches are created and joined automatically as described here:
+ * <a
+ * href="http://www.ibiblio.org/e-notes/Splines/Bint.htm">ibiblio.org/e-notes/
+ * Splines/Bint.htm</a>
+ * </p>
+ * 
+ * <p>
+ * Thanks to a bug report by Aaron Meyers (http://universaloscillation.com) the
+ * {@linkplain #toLineStrip2D(int)} method has a slightly changed behaviour from
+ * version 0014 onwards. In earlier versions erroneous duplicate points would be
+ * added near each given control point, which lead to various weird results.
+ * </p>
+ * 
+ * <p>
+ * The new behaviour of the curve interpolation/computation is described in the
+ * docs for the {@linkplain #toLineStrip2D(int)} method below.
+ * </p>
+ * 
+ * @version 0014 Added user adjustable curve tightness control
+ * @version 0015 Added JAXB annotations and List support for dynamic building of
+ *          spline
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+public class Spline2D {
+
+    /**
+     *
+     */
+    public static final float DEFAULT_TIGHTNESS = 0.25f;
+
+    /**
+     *
+     */
+    public static final int DEFAULT_RES = 16;
+
+    /**
+     *
+     */
+    @XmlTransient
+    protected Vec2D[] points;
+
+    /**
+     *
+     */
+    @XmlElement(name = "p")
+    public List<Vec2D> pointList = new ArrayList<>();
+
+    /**
+     *
+     */
+    @XmlTransient
+    public BernsteinPolynomial bernstein;
+
+    /**
+     *
+     */
+    @XmlTransient
+    public Vec2D[] delta;
+
+    /**
+     *
+     */
+    @XmlTransient
+    public Vec2D[] coeffA;
+
+    /**
+     *
+     */
+    @XmlTransient
+    public float[] bi;
+
+    /**
+     *
+     */
+    @XmlAttribute
+    protected float tightness;
+
+    /**
+     *
+     */
+    @XmlTransient
+    protected float invTightness;
+
+    /**
+     * Constructs an empty spline container with default curve tightness. You
+     * need to populate the spline manually by using {@link #add(ReadonlyVec2D)}
+     * .
+     */
+    public Spline2D() {
+        setTightness(DEFAULT_TIGHTNESS);
+    }
+
+    /**
+     * @param rawPoints
+     *            list of control point vectors
+     */
+    public Spline2D(List<Vec2D> rawPoints) {
+        this(rawPoints, null, DEFAULT_TIGHTNESS);
+    }
+
+    /**
+     * @param rawPoints
+     *            list of control point vectors
+     * @param b
+     *            predefined Bernstein polynomial (good for reusing)
+     * @param tightness
+     *            default curve tightness used for the interpolated vertices
+     *            {@linkplain #setTightness(float)}
+     */
+    public Spline2D(List<Vec2D> rawPoints, BernsteinPolynomial b,
+            float tightness) {
+        pointList.addAll(rawPoints);
+        bernstein = b;
+        setTightness(tightness);
+    }
+
+    /**
+     * @param pointArray
+     *            array of control point vectors
+     */
+    public Spline2D(Vec2D[] pointArray) {
+        this(pointArray, null, DEFAULT_TIGHTNESS);
+    }
+
+    /**
+     * @param pointArray
+     *            array of control point vectors
+     * @param b
+     *            predefined Bernstein polynomial (good for reusing)
+     * @param tightness
+     *            default curve tightness used for the interpolated vertices
+     *            {@linkplain #setTightness(float)}
+     */
+    public Spline2D(Vec2D[] pointArray, BernsteinPolynomial b, float tightness) {
+        this(Arrays.asList(pointArray), b, tightness);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    public Spline2D add(float x, float y) {
+        return add(new Vec2D(x, y));
+    }
+
+    /**
+     * Adds a copy of the given point to the list of control points.
+     * 
+     * @param p
+     * @return itself
+     */
+    public Spline2D add(ReadonlyVec2D p) {
+        pointList.add(p.copy());
+        return this;
+    }
+
+    /**
+     *
+     */
+    protected void findCPoints() {
+        bi[1] = -tightness;
+        coeffA[1].set((points[2].x - points[0].x - delta[0].x) * tightness,
+                (points[2].y - points[0].y - delta[0].y) * tightness);
+        final int numP = getNumPoints();
+        for (int i = 2; i < numP - 1; i++) {
+            bi[i] = -1 / (invTightness + bi[i - 1]);
+            coeffA[i].set(
+                    -(points[i + 1].x - points[i - 1].x - coeffA[i - 1].x)
+                            * bi[i],
+                    -(points[i + 1].y - points[i - 1].y - coeffA[i - 1].y)
+                            * bi[i]);
+        }
+        for (int i = numP - 2; i > 0; i--) {
+            delta[i].set(coeffA[i].x + delta[i + 1].x * bi[i], coeffA[i].y
+                    + delta[i + 1].y * bi[i]);
+        }
+    }
+
+    /**
+     * Returns the number of control points.
+     * 
+     * @return the numP
+     */
+    public final int getNumPoints() {
+        return pointList.size();
+    }
+
+    /**
+     * @return the pointList
+     */
+    public List<Vec2D> getPointList() {
+        return pointList;
+    }
+
+    /**
+     * @see #setTightness(float)
+     * @return the spline3d tightness
+     * @since 0014 (rev.216)
+     */
+    public float getTightness() {
+        return tightness;
+    }
+
+    /**
+     * Overrides the current control points with the given list.
+     * 
+     * @param plist
+     *            the pointList to set
+     * @return itself
+     */
+    public Spline2D setPointList(List<Vec2D> plist) {
+        pointList.clear();
+        for (ReadonlyVec2D p : plist) {
+            pointList.add(p.copy());
+        }
+        return this;
+    }
+
+    /**
+     * Sets the tightness for future curve interpolation calls. Default value is
+     * 0.25. A value of 0.0 equals linear interpolation between the given curve
+     * input points. Curve behaviour for values outside the 0.0 .. 0.5 interval
+     * is unspecified and becomes increasingly less intuitive. Negative values
+     * are possible too and create interesting results (in some cases).
+     * 
+     * @param tightness
+     *            the tightness value used for the next call to
+     *            {@link #toLineStrip2D(int)}
+     * @return 
+     * @since 0014 (rev. 216)
+     */
+    public final Spline2D setTightness(float tightness) {
+        this.tightness = tightness;
+        this.invTightness = 1f / tightness;
+        return this;
+    }
+
+    /**
+     * <p>
+     * Computes all curve vertices based on the resolution/number of
+     * subdivisions requested. The higher, the more vertices are computed:
+     * </p>
+     * <p>
+     * <strong>(number of control points - 1) * resolution + 1</strong>
+     * </p>
+     * <p>
+     * Since version 0014 the automatic placement of the curve handles can also
+     * be manipulated via the {@linkplain #setTightness(float)} method.
+     * </p>
+     * 
+     * @param res
+     *            the number of vertices to be computed per segment between
+     *            original control points (incl. control point always at the
+     *            start of each segment)
+     * @return list of Vec2D vertices along the curve
+     */
+    public LineStrip2D toLineStrip2D(int res) {
+        updateCoefficients();
+        if (res < 1) {
+            res = 1;
+        }
+        res++;
+        if (bernstein == null || bernstein.resolution != res) {
+            bernstein = new BernsteinPolynomial(res);
+        }
+        findCPoints();
+        Vec2D deltaP = new Vec2D();
+        Vec2D deltaQ = new Vec2D();
+        res--;
+        LineStrip2D strip = new LineStrip2D();
+        for (int i = 0, numP = getNumPoints(); i < numP - 1; i++) {
+            Vec2D p = points[i];
+            Vec2D q = points[i + 1];
+            deltaP.set(delta[i]).addSelf(p);
+            deltaQ.set(q).subSelf(delta[i + 1]);
+            for (int k = 0; k < res; k++) {
+                float x = p.x * bernstein.b0[k] + deltaP.x * bernstein.b1[k]
+                        + deltaQ.x * bernstein.b2[k] + q.x * bernstein.b3[k];
+                float y = p.y * bernstein.b0[k] + deltaP.y * bernstein.b1[k]
+                        + deltaQ.y * bernstein.b2[k] + q.y * bernstein.b3[k];
+                strip.add(new Vec2D(x, y));
+            }
+        }
+        strip.add(points[points.length - 1].copy());
+        return strip;
+    }
+
+    /**
+     *
+     */
+    public void updateCoefficients() {
+        final int numP = getNumPoints();
+        if (points == null || (points != null && points.length != numP)) {
+            coeffA = new Vec2D[numP];
+            delta = new Vec2D[numP];
+            bi = new float[numP];
+            for (int i = 0; i < numP; i++) {
+                coeffA[i] = new Vec2D();
+                delta[i] = new Vec2D();
+            }
+        }
+        setTightness(tightness);
+        points = pointList.toArray(new Vec2D[numP]);
+    }
+}