toxiclibs 0.4.0 → 0.8.0

data/src/toxi/geom/Axis3D.java

@@ -0,0 +1,116 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * An immutable origin + axis in 3D-Space.
+ */
+public class Axis3D {
+
+    /**
+     * Creates a new x-Axis3D object from the world origin.
+     * @return 
+     */
+    public static final Axis3D xAxis() {
+        return new Axis3D(Vec3D.X_AXIS);
+    }
+
+    /**
+     * Creates a new y-Axis3D object from the world origin.
+     * @return 
+     */
+    public static final Axis3D yAxis() {
+        return new Axis3D(Vec3D.Y_AXIS);
+    }
+
+    /**
+     * Creates a new z-Axis3D object from the world origin.
+     * @return 
+     */
+    public static final Axis3D zAxis() {
+        return new Axis3D(Vec3D.Z_AXIS);
+    }
+
+    /**
+     *
+     */
+    public final ReadonlyVec3D origin;
+
+    /**
+     *
+     */
+    public final ReadonlyVec3D dir;
+
+    /**
+     * Creates a new z-Axis3D object from the world origin.
+     */
+    public Axis3D() {
+        this(Vec3D.Z_AXIS);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    public Axis3D(float x, float y, float z) {
+        this(new Vec3D(x, y, z));
+    }
+
+    /**
+     *
+     * @param ray
+     */
+    public Axis3D(Ray3D ray) {
+        this(ray, ray.getDirection());
+    }
+
+    /**
+     * Creates a new Axis3D from the world origin in the given direction.
+     * 
+     * @param dir
+     *            direction vector
+     */
+    public Axis3D(ReadonlyVec3D dir) {
+        this(new Vec3D(), dir);
+    }
+
+    /**
+     * Creates a new Axis3D from the given origin and direction.
+     * 
+     * @param o
+     *            origin
+     * @param dir
+     *            direction
+     */
+    public Axis3D(ReadonlyVec3D o, ReadonlyVec3D dir) {
+        this.origin = o;
+        this.dir = dir.getNormalized();
+    }
+}

data/src/toxi/geom/AxisAlignedCylinder.java

@@ -0,0 +1,163 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ *
+ * @author tux
+ */
+public abstract class AxisAlignedCylinder implements Shape3D {
+
+    /**
+     *
+     */
+    protected Vec3D pos;
+
+    /**
+     *
+     */
+    protected float radius;
+
+    /**
+     *
+     */
+    protected float radiusSquared;
+
+    /**
+     *
+     */
+    protected float length;
+
+    /**
+     *
+     * @param pos
+     * @param radius
+     * @param length
+     */
+    protected AxisAlignedCylinder(ReadonlyVec3D pos, float radius, float length) {
+        this.pos = pos.copy();
+        setRadius(radius);
+        setLength(length);
+    }
+
+    /**
+     * Checks if the given point is inside the cylinder.
+     * 
+     * @param p
+     * @return true, if inside
+     */
+    public abstract boolean containsPoint(ReadonlyVec3D p);
+
+    /**
+     * @return the length
+     */
+    public float getLength() {
+        return length;
+    }
+
+    /**
+     * @return the cylinder's orientation axis
+     */
+    public abstract Vec3D.Axis getMajorAxis();
+
+    /**
+     * Returns the cylinder's position (centroid).
+     * 
+     * @return the pos
+     */
+    public Vec3D getPosition() {
+        return pos.copy();
+    }
+
+    /**
+     * @return the cylinder radius
+     */
+    public float getRadius() {
+        return radius;
+    }
+
+    /**
+     * @param length
+     *            the length to set
+     */
+    public final void setLength(float length) {
+        this.length = length;
+    }
+
+    /**
+     * @param pos
+     *            the pos to set
+     */
+    public void setPosition(Vec3D pos) {
+        this.pos.set(pos);
+    }
+
+    /**
+     * @param radius
+     */
+    public final void setRadius(float radius) {
+        this.radius = radius;
+        this.radiusSquared = radius * radius;
+    }
+
+    /**
+     * Builds a TriangleMesh representation of the cylinder at a default
+     * resolution 30 degrees.
+     * 
+     * @return mesh instance
+     */
+    public Mesh3D toMesh() {
+        return toMesh(12, 0);
+    }
+
+    /**
+     * Builds a TriangleMesh representation of the cylinder using the given
+     * number of steps and start angle offset.
+     * 
+     * @param steps
+     * @param thetaOffset
+     * @return mesh
+     */
+    public Mesh3D toMesh(int steps, float thetaOffset) {
+        return toMesh(null, steps, thetaOffset);
+    }
+
+    /**
+     *
+     * @param mesh
+     * @param steps
+     * @param thetaOffset
+     * @return
+     */
+    public Mesh3D toMesh(Mesh3D mesh, int steps, float thetaOffset) {
+        return new Cone(pos, getMajorAxis().getVector(), radius, radius, length)
+                .toMesh(mesh, steps, thetaOffset, true, true);
+    }
+}

data/src/toxi/geom/BernsteinPolynomial.java

@@ -0,0 +1,94 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * Helper class for the spline3d classes in this package. Used to compute
+ * subdivision points of the curve.
+ */
+public class BernsteinPolynomial {
+
+    public float[] b0,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    b1,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    b2,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    b3;
+
+    /**
+     *
+     */
+    public int resolution;
+
+    /**
+     * @param res
+     *            number of subdivision steps between each control point of the
+     *            spline3d
+     */
+    public BernsteinPolynomial(int res) {
+        resolution = res;
+        b0 = new float[res];
+        b1 = new float[res];
+        b2 = new float[res];
+        b3 = new float[res];
+        float t = 0;
+        float dt = 1.0f / (resolution - 1);
+        for (int i = 0; i < resolution; i++) {
+            float t1 = 1 - t;
+            float t12 = t1 * t1;
+            float t2 = t * t;
+            b0[i] = t1 * t12;
+            b1[i] = 3 * t * t12;
+            b2[i] = 3 * t2 * t1;
+            b3[i] = t * t2;
+            t += dt;
+        }
+    }
+}

data/src/toxi/geom/BezierCurve2D.java

@@ -0,0 +1,159 @@
+package toxi.geom;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Standard multi-segment bezier curve implementation with optional automatic
+ * handle alignment between segments. Can be used to create closed curves which
+ * can then be converted into {@link Polygon2D} instances. Also provides curve
+ * tangent calculation feature. Usage of this class is very similar to
+ * {@link Spline2D}.
+ */
+public class BezierCurve2D {
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @param c
+     * @param d
+     * @param t
+     * @return
+     */
+    public static Vec2D computePointInSegment(Vec2D a, Vec2D b, Vec2D c,
+            Vec2D 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 Vec2D computeTangentInSegment(Vec2D a, Vec2D b, Vec2D c,
+            Vec2D 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));
+        return new Vec2D(x, y).normalize();
+    }
+
+    private final List<Vec2D> points;
+
+    /**
+     *
+     */
+    public BezierCurve2D() {
+        points = new ArrayList<Vec2D>();
+    }
+
+    /**
+     *
+     * @param points
+     */
+    public BezierCurve2D(List<Vec2D> points) {
+        this.points = points;
+    }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public BezierCurve2D add(Vec2D 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) {
+            Vec2D c;
+            if (id == 0 && isClosed()) {
+                c = points.get(points.size() - 2);
+            } else {
+                c = points.get(id - 1);
+            }
+            Vec2D d = points.get(id);
+            Vec2D e = points.get(id + 1);
+            Vec2D cd = d.sub(c);
+            Vec2D de = e.sub(d);
+            Vec2D 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 Vec2Ds
+     */
+    public LineStrip2D toLineStrip2D(int res) {
+        LineStrip2D strip = new LineStrip2D();
+        int i = 0;
+        int maxRes = res;
+        for (int num = points.size(); i < num - 3; i += 3) {
+            Vec2D a = points.get(i);
+            Vec2D b = points.get(i + 1);
+            Vec2D c = points.get(i + 2);
+            Vec2D 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;
+    }
+
+    /**
+     *
+     * @param res
+     * @return
+     */
+    public Polygon2D toPolygon2D(int res) {
+        Polygon2D poly = new Polygon2D(toLineStrip2D(res).getVertices());
+        if (isClosed()) {
+            poly.vertices.remove(poly.vertices.get(poly.vertices.size() - 1));
+        }
+        return poly;
+    }
+}