toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/geom/MatrixSizeException.java

@@ -0,0 +1,58 @@
+/*
+ * $RCSfile$
+ *
+ * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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 General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ * $Revision: 127 $
+ * $Date: 2008-02-28 20:18:51 +0000 (Thu, 28 Feb 2008) $
+ * $State$
+ */
+
+package toxi.geom;
+
+/**
+ * Indicates that an operation cannot be completed properly because of a
+ * mismatch in the sizes of object attributes.
+ */
+public class MatrixSizeException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Create the exception object with default values.
+     */
+    public MatrixSizeException() {
+    }
+
+    /**
+     * Create the exception object that outputs a message.
+     * 
+     * @param str
+     *            the message string to be output.
+     */
+    public MatrixSizeException(String str) {
+        super(str);
+    }
+
+}

data/src/toxi/geom/OctreeVisitor.java

@@ -0,0 +1,44 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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 interface is the core part of the visitor pattern application for
+ * {@link PointOctree}s. It can be used to apply a procedure to all tree nodes
+ * when passed to {@link PointOctree#applyVisitor(OctreeVisitor)}.
+ */
+public interface OctreeVisitor {
+
+    /**
+     * Applies the procedure defined by an implementation of this interface to
+     * the given tree node.
+     * 
+     * @param node
+     */
+    void visitNode(PointOctree node);
+}

data/src/toxi/geom/Origin3D.java

@@ -0,0 +1,148 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.Vec3D.Axis;
+
+/**
+ * This class defines an origin and set of axis vectors for a 3D cartesian
+ * coordinate system.
+ */
+public class Origin3D {
+
+    /**
+     *
+     */
+    public ReadonlyVec3D origin;
+    public ReadonlyVec3D xAxis,
+
+    /**
+     *
+     */
+    yAxis,
+
+    /**
+     *
+     */
+    zAxis;
+
+    /**
+     * Creates a new origin at the world origin using the standard XYZ axes
+     */
+    public Origin3D() {
+        this(new Vec3D());
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    public Origin3D(float x, float y, float z) {
+        this(new Vec3D(x, y, z));
+    }
+
+    /**
+     *
+     * @param mat
+     */
+    public Origin3D(Matrix4x4 mat) {
+        this.origin = mat.applyToSelf(new Vec3D());
+        this.xAxis = mat.applyTo(Vec3D.X_AXIS).subSelf(origin).normalize();
+        this.yAxis = mat.applyTo(Vec3D.Y_AXIS).subSelf(origin).normalize();
+        zAxis = xAxis.crossInto(yAxis, new Vec3D());
+    }
+
+    /**
+     * Creates a new origin at the given origin using the standard XYZ axes
+     * 
+     * @param o
+     *            origin
+     */
+    public Origin3D(Vec3D o) {
+        origin = o;
+        xAxis = Vec3D.X_AXIS;
+        yAxis = Vec3D.Y_AXIS;
+        zAxis = Vec3D.Z_AXIS;
+    }
+
+    /**
+     * Attempts to create a cartesian coordinate system with the given point as
+     * its origin and the direction as its Z-axis. In cases when two of the
+     * direction vector components are equal, the constructor will throw an
+     * {@link IllegalArgumentException}.
+     * 
+     * @param o
+     *            origin of the coordinate system
+     * @param dir
+     *            z-axis
+     */
+    public Origin3D(Vec3D o, Vec3D dir) {
+        this.origin = o;
+        this.zAxis = dir.getNormalized();
+        Vec3D av = null;
+        Axis a = zAxis.getClosestAxis();
+        if (a == Vec3D.Axis.X) {
+            av = Vec3D.Axis.Z.getVector().getInverted();
+        } else if (a == Vec3D.Axis.Y) {
+            av = Vec3D.Axis.Z.getVector().getInverted();
+        } else if (a == Vec3D.Axis.Z) {
+            av = Vec3D.Axis.X.getVector().getInverted();
+        }
+        if (av == null) {
+            throw new IllegalArgumentException(
+                    "can't create a coordinate system for direction: " + dir);
+        }
+        xAxis = av.cross(dir).normalize();
+        yAxis = xAxis.cross(zAxis).normalize();
+
+    }
+
+    /**
+     * @param o
+     *            origin of the coordinate system
+     * @param x
+     *            x-direction of the coordinate system
+     * @param y
+     *            y-direction of the coordinate system
+     * @throws IllegalArgumentException
+     *             if x and y vectors are not orthogonal
+     */
+    public Origin3D(Vec3D o, Vec3D x, Vec3D y) throws IllegalArgumentException {
+        origin = o;
+        xAxis = x;
+        yAxis = y;
+        xAxis.getNormalized();
+        yAxis.getNormalized();
+        if (Math.abs(xAxis.dot(yAxis)) > 0.0001) {
+            throw new IllegalArgumentException("Axis vectors aren't orthogonal");
+        }
+        zAxis = xAxis.crossInto(yAxis, new Vec3D());
+    }
+}

data/src/toxi/geom/Plane.java

@@ -0,0 +1,293 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.XmlElement;
+
+import toxi.geom.mesh.Mesh3D;
+import toxi.geom.mesh.TriangleMesh;
+import toxi.math.MathUtils;
+
+/**
+ * Class to describe and work with infinite generic 3D planes. Useful for
+ * intersection problems and classifying points.
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+public class Plane extends Vec3D implements Shape3D {
+
+    /**
+     * Classifier constant for {@link Plane#classifyPoint(ReadonlyVec3D, float)}
+     */
+    public enum Classifier {
+
+        /**
+         *
+         */
+        FRONT,
+
+        /**
+         *
+         */
+        BACK,
+
+        /**
+         *
+         */
+        ON_PLANE;
+    }
+
+    /**
+     *
+     */
+    public static final Plane XY = new Plane(new Vec3D(), Vec3D.Z_AXIS);
+
+    /**
+     *
+     */
+    public static final Plane XZ = new Plane(new Vec3D(), Vec3D.Y_AXIS);
+
+    /**
+     *
+     */
+    public static final Plane YZ = new Plane(new Vec3D(), Vec3D.X_AXIS);
+
+    /**
+     *
+     */
+    @XmlElement(required = true)
+    public Vec3D normal;
+
+    /**
+     *
+     */
+    public Plane() {
+        super();
+        normal = Vec3D.Y_AXIS.copy();
+    }
+
+    /**
+     *
+     * @param origin
+     * @param norm
+     */
+    public Plane(ReadonlyVec3D origin, ReadonlyVec3D norm) {
+        super(origin);
+        normal = norm.getNormalized();
+    }
+
+    /**
+     *
+     * @param t
+     */
+    public Plane(Triangle3D t) {
+        this(t.computeCentroid(), t.computeNormal());
+    }
+
+    /**
+     * Classifies the relative position of the given point to the plane using
+     * the given tolerance.
+     * 
+     * @param p
+     * @param tolerance
+     * @return One of the 3 classification types: FRONT, BACK, ON_PLANE
+     */
+    public Classifier classifyPoint(ReadonlyVec3D p, float tolerance) {
+        float d = this.sub(p).normalize().dot(normal);
+        if (d < -tolerance) {
+            return Classifier.FRONT;
+        } else if (d > tolerance) {
+            return Classifier.BACK;
+        }
+        return Classifier.ON_PLANE;
+    }
+
+    @Override
+    public boolean containsPoint(ReadonlyVec3D p) {
+        return classifyPoint(p, MathUtils.EPS) == Classifier.ON_PLANE;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float getDCoeff() {
+        return this.dot(normal);
+    }
+
+    /**
+     * Calculates distance from the plane to point P.
+     * 
+     * @param p
+     * @return distance
+     */
+    public float getDistanceToPoint(Vec3D p) {
+        float sn = -normal.dot(p.sub(this));
+        float sd = normal.magSquared();
+        Vec3D isec = p.add(normal.scale(sn / sd));
+        return isec.distanceTo(p);
+    }
+
+    /**
+     * Calculates the intersection point between plane and ray (line).
+     * 
+     * @param r
+     * @return intersection point or null if ray doesn't intersect plane
+     */
+    public ReadonlyVec3D getIntersectionWithRay(Ray3D r) {
+        float denom = normal.dot(r.getDirection());
+        if (denom > MathUtils.EPS) {
+            float u = normal.dot(this.sub(r)) / denom;
+            return r.getPointAtDistance(u);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public Vec3D getProjectedPoint(Vec3D p) {
+        Vec3D dir;
+        if (normal.dot(sub(p)) < 0) {
+            dir = normal.getInverted();
+        } else {
+            dir = normal;
+        }
+        Vec3D proj = new Ray3D(p, dir)
+                .getPointAtDistance(getDistanceToPoint(p));
+        return proj;
+    }
+
+    /**
+     * Calculates the distance of the vector to the given plane in the specified
+     * direction. A plane is specified by a 3D point and a normal vector
+     * perpendicular to the plane. Normalized directional vectors expected (for
+     * rayDir and planeNormal).
+     * 
+     * @param ray
+     *            intersection ray
+     * @return distance to plane in world units, -1 if no intersection.
+     */
+    public float intersectRayDistance(Ray3D ray) {
+        float d = -normal.dot(this);
+        float numer = normal.dot(ray) + d;
+        float denom = normal.dot(ray.dir);
+
+        // normal is orthogonal to vector, cant intersect
+        if (MathUtils.abs(denom) < MathUtils.EPS) {
+            return -1;
+        }
+
+        return -(numer / denom);
+    }
+
+    /**
+     * Computes the intersection ray between this plane and the given one. If
+     * the planes are parallel or coincident the method returns null. If the
+     * planes are intersecting, the returned {@link Ray3D} will start at a point
+     * lying on both planes and point along the infinite intersection line
+     * between them.
+     * 
+     * Code ported from:
+     * http://forums.create.msdn.com/forums/p/39074/234178.aspx#234178
+     * 
+     * @param plane
+     *            intersection partner
+     * @return intersection ray or null
+     */
+    public Ray3D intersectsPlane(Plane plane) {
+        float d = getDCoeff();
+        float d2 = plane.getDCoeff();
+
+        if (normal.equalsWithTolerance(plane.normal, 0.0001f) || d == d2) {
+            return null;
+        }
+
+        float offDiagonal = normal.dot(plane.normal);
+        double det = 1.0 / (1 - offDiagonal * offDiagonal);
+        double a = (d - d2 * offDiagonal) * det;
+        double b = (d2 - d * offDiagonal) * det;
+        Vec3D anchor = normal.scale((float) a).addSelf(
+                plane.normal.scale((float) b));
+        Vec3D dir = normal.cross(plane.normal);
+
+        return new Ray3D(anchor, dir);
+    }
+
+    /**
+     * Creates a TriangleMesh representation of the plane as a finite, squared
+     * quad of the requested size, centred around the current plane point.
+     * 
+     * @param size
+     *            desired edge length
+     * @return mesh
+     */
+    public Mesh3D toMesh(float size) {
+        return toMesh(null, size);
+    }
+
+    /**
+     *
+     * @param mesh
+     * @param size
+     * @return
+     */
+    public Mesh3D toMesh(Mesh3D mesh, float size) {
+        if (mesh == null) {
+            mesh = new TriangleMesh("plane", 4, 2);
+        }
+        ReadonlyVec3D p = equalsWithTolerance(Vec3D.ZERO, 0.01f) ? add(0.01f,
+                0.01f, 0.01f) : this;
+        size *= 0.5f;
+        Vec3D n = p.cross(normal).normalizeTo(size);
+        Vec3D m = n.cross(normal).normalizeTo(size);
+        Vec3D a = this.add(n).addSelf(m);
+        Vec3D b = this.add(n).subSelf(m);
+        Vec3D c = this.sub(n).subSelf(m);
+        Vec3D d = this.sub(n).addSelf(m);
+        mesh.addFace(a, d, b, null, null, null, null);
+        mesh.addFace(b, d, c, null, null, null, null);
+        return mesh;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("origin: ").append(super.toString()).append(" norm: ")
+                .append(normal.toString());
+        return sb.toString();
+    }
+}