toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/geom/mesh2d/Voronoi.java

@@ -0,0 +1,149 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.mesh2d;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import toxi.geom.Polygon2D;
+import toxi.geom.Triangle2D;
+import toxi.geom.Vec2D;
+
+/**
+ *
+ * @author tux
+ */
+public class Voronoi {
+
+    /**
+     *
+     */
+    public static float DEFAULT_SIZE = 10000;
+
+    /**
+     *
+     */
+    protected DelaunayTriangulation delaunay;
+
+    /**
+     *
+     */
+    protected DelaunayTriangle initialTriangle;
+
+    /**
+     *
+     */
+    protected List<Vec2D> sites = new ArrayList<>();
+
+    /**
+     *
+     */
+    public Voronoi() {
+        this(DEFAULT_SIZE);
+    }
+
+    /**
+     *
+     * @param size
+     */
+    public Voronoi(float size) {
+        initialTriangle = new DelaunayTriangle(
+                new DelaunayVertex(-size, -size), new DelaunayVertex(size,
+                        -size), new DelaunayVertex(0, size));
+        this.delaunay = new DelaunayTriangulation(initialTriangle);
+    }
+
+    /**
+     *
+     * @param p
+     */
+    public void addPoint(Vec2D p) {
+        sites.add(p.copy());
+        delaunay.delaunayPlace(new DelaunayVertex(p.x, p.y));
+    }
+
+    /**
+     *
+     * @param points
+     */
+    public void addPoints(Collection<? extends Vec2D> points) {
+        points.stream().forEach((p) -> {
+            addPoint(p);
+        });
+    }
+
+    /**
+     *
+     * @return
+     */
+    public List<Polygon2D> getRegions() {
+        List<Polygon2D> regions = new LinkedList<>();
+        HashSet<DelaunayVertex> done = new HashSet<>(
+                initialTriangle);
+        delaunay.stream().forEach((DelaunayTriangle triangle) -> {
+            triangle.stream().filter((site) -> !(done.contains(site))).map((site) -> {
+                done.add(site);
+                return site;
+            }).map((site) -> delaunay.surroundingTriangles(
+                    site, triangle)).map((List<DelaunayTriangle> list) -> {
+                        Polygon2D poly = new Polygon2D();
+                        list.stream().map((tri) -> tri.getCircumcenter()).forEach((circumeter) -> {
+                            poly.add(new Vec2D((float) circumeter.coord(0),
+                                    (float) circumeter.coord(1)));
+                });
+                        return poly;
+                    }).forEach((poly) -> {
+                        regions.add(poly);
+                    });
+        });
+        return regions;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public List<Vec2D> getSites() {
+        return sites;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public List<Triangle2D> getTriangles() {
+        List<Triangle2D> tris = new ArrayList<>();
+        for (DelaunayTriangle t : delaunay) {
+            tris.add(new Triangle2D(t.get(0).toVec2D(), t.get(1).toVec2D(), t
+                    .get(2).toVec2D()));
+        }
+        return tris;
+    }
+}

data/src/toxi/geom/nurbs/BasicNurbsCurve.java

@@ -0,0 +1,210 @@
+/*
+ * jgeom: Geometry Library fo Java
+ * 
+ * Copyright (C) 2005  Samuel Gerber
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program 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 for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package toxi.geom.nurbs;
+
+import toxi.geom.Polygon2D;
+import toxi.geom.Vec3D;
+import toxi.geom.Vec4D;
+
+/**
+ * A Basic implementation of a NurbsCurve.
+ * 
+ * @author sg
+ * @version 1.0
+ */
+public class BasicNurbsCurve implements NurbsCurve, Cloneable {
+
+    private Vec4D[] cpoly;
+    private KnotVector uKnots;
+
+    /**
+     * Create a Nurbs Curve from the given Controlpoints, Knots and degree.<br>
+     * [TODO Validate Input, part of it is done by creating the KnotVector]
+     * 
+     * @param cps
+     *            Array of Controlpoints
+     * @param uK
+     *            Knot values
+     * @param degree
+     *            Degree of the Nurbs Curve
+     */
+    public BasicNurbsCurve(Vec4D[] cps, float[] uK, int degree) {
+        this(cps, new KnotVector(uK, degree));
+    }
+
+    /**
+     * Generate a Nurbs from the given Controlpoints and the given Knotvector.<br>
+     * [TODO validate input]
+     * 
+     * @param cps
+     *            Array of Controlpoints
+     * @param uKnots
+     *            Knotvector of the Nurbs
+     */
+    public BasicNurbsCurve(Vec4D[] cps, KnotVector uKnots) {
+        cpoly = cps;
+        this.uKnots = uKnots;
+        if (uKnots.length() != uKnots.getDegree() + cpoly.length + 1) {
+            throw new IllegalArgumentException(
+                    "Nurbs Curve has wrong knot number");
+        }
+    }
+
+    @Override
+    public Vec4D[][] curveDerivCpts(int d, int r1, int r2) {
+
+        Vec4D[][] result = new Vec4D[d + 1][r2 - r1 + 1];
+
+        int degree = uKnots.getDegree();
+
+        // k=0 => control points
+        int r = r2 - r1;
+        for (int i = 0; i <= r; i++) {
+            result[0][i] = cpoly[i];
+        }
+
+        // k=1 => 1st derivative, k=2 => 2nd derivative, etc...
+        for (int k = 1; k <= d; k++) {
+            int tmp = degree - k + 1;
+            for (int i = 0; i <= (r - k); i++) {
+                Vec4D cw = new Vec4D(result[k - 1][i + 1]);
+                cw.subSelf(result[k - 1][i]);
+                cw.scaleSelf(tmp);
+                cw.scaleSelf(1 / (uKnots.get(r1 + i + degree + 1) - uKnots
+                        .get(r1 + i + k)));
+                result[k][i] = cw;
+            }
+        }
+        return result;
+    }
+
+    /**
+     *
+     * @param u
+     * @param grade
+     * @return
+     */
+    @Override
+    public Vec3D[] derivativesOnCurve(float u, int grade) {
+        return derivativesOnCurve(u, grade, new Vec3D[grade + 1]);
+    }
+
+    /**
+     *
+     * @param u
+     * @param grade
+     * @param derivs
+     * @return
+     */
+    @Override
+    public Vec3D[] derivativesOnCurve(float u, int grade, Vec3D[] derivs) {
+
+        int span = uKnots.findSpan(u);
+        int degree = uKnots.getDegree();
+
+        // TODO: compute derivatives also for NURBS
+        // currently supports only non-rational B-Splines
+        float derivVals[][] = uKnots.derivBasisFunctions(span, u, grade);
+
+        // Zero values
+        for (int k = (degree + 1); k <= grade; k++) {
+            derivs[k] = new Vec3D();
+        }
+
+        for (int k = 0; k <= grade; k++) {
+            Vec3D d = new Vec3D();
+            for (int j = 0; j <= degree; j++) {
+                Vec4D v = cpoly[(span - degree) + j];
+                float s = derivVals[k][j];
+                d.addSelf(v.x * s, v.y * s, v.z * s);
+            }
+            derivs[k] = d;
+        }
+        return derivs;
+    }
+
+    @Override
+    public Vec4D[] getControlPoints() {
+        return cpoly;
+    }
+
+    @Override
+    public int getDegree() {
+        return uKnots.getDegree();
+    }
+
+    @Override
+    public float[] getKnots() {
+        return uKnots.getArray();
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public KnotVector getKnotVector() {
+        return uKnots;
+    }
+
+    @Override
+    public Vec3D pointOnCurve(float u) {
+        return pointOnCurve(u, new Vec3D());
+    }
+
+    @Override
+    public Vec3D pointOnCurve(float u, Vec3D out) {
+        int span = uKnots.findSpan(u);
+        int degree = uKnots.getDegree();
+
+        // for periodic knot vectors the usable parameter range is
+        // span >= degree and span <= no control points (n+1)
+        if (span < degree) {
+            return out;
+        }
+
+        if (span > uKnots.getN()) {
+            return out;
+        }
+
+        double[] bf = uKnots.basisFunctions(span, u);
+        Vec4D cw = new Vec4D();
+        for (int i = 0; i <= degree; i++) {
+            cw.addSelf(cpoly[(span - degree) + i].getWeighted().scaleSelf(
+                    (float) bf[i]));
+        }
+        return cw.unweightInto(out);
+    }
+
+    /**
+     *
+     * @param res
+     * @return
+     */
+    @Override
+    public Polygon2D toPolygon2D(int res) {
+        float delta = 1f / (res - 1);
+        Polygon2D poly = new Polygon2D();
+        for (int i = 0; i < res; i++) {
+            poly.add(pointOnCurve(i * delta).to2DXY());
+        }
+        return poly;
+    }
+}

data/src/toxi/geom/nurbs/BasicNurbsSurface.java

@@ -0,0 +1,233 @@
+/*
+ * jgeom: Geometry Library fo Java
+ * 
+ * Copyright (C) 2005  Samuel Gerber
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program 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 for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package toxi.geom.nurbs;
+
+import toxi.geom.Vec3D;
+import toxi.geom.Vec4D;
+
+/**
+ * A Basic NurbsSurface implementation.
+ * 
+ * @author sg
+ * @version 1.2
+ */
+public class BasicNurbsSurface implements NurbsSurface {
+
+    private KnotVector uKnots;
+    private KnotVector vKnots;
+    private ControlNet cpnet;
+
+    // private List<TrimCurve> trimms = new LinkedList<TrimCurve>();
+
+    /**
+     * Create a Nurbs Surface from the given {@link ControlNet} and the knot
+     * values of degree p in u direction and of degree q in v direction.
+     * 
+     * @param cps
+     *            ControlNet of the Nurbs
+     * @param uK
+     *            Knot values in u direction
+     * @param vK
+     *            Knot values in v direction
+     * @param p
+     *            degree in u direction
+     * @param q
+     *            degree in v direction
+     */
+    public BasicNurbsSurface(ControlNet cps, float[] uK, float[] vK, int p,
+            int q) throws IllegalArgumentException {
+        this(cps, new KnotVector(uK, p), new KnotVector(vK, q));
+    }
+
+    /**
+     * Create a Nurbs form the Controlnet and the two Knot vectors.
+     * 
+     * @param net
+     *            Contorl net of Nurbs
+     * @param u
+     *            KnotVector in u direction
+     * @param v
+     *            KnotVector in v direction
+     */
+    public BasicNurbsSurface(ControlNet net, KnotVector u, KnotVector v)
+            throws IllegalArgumentException {
+        cpnet = net;
+        uKnots = u;
+        vKnots = v;
+        validate();
+    }
+
+    // public void addTrimCurve(TrimCurve tc) {
+    // trimms.add(tc);
+    // }
+
+    @Override
+    public ControlNet getControlNet() {
+        return cpnet;
+    }
+
+    // public List<TrimCurve> getTrimCurves() {
+    // return trimms;
+    // }
+
+    @Override
+    public int getUDegree() {
+        return uKnots.getDegree();
+    }
+
+    @Override
+    public float[] getUKnots() {
+        return uKnots.getArray();
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public KnotVector getUKnotVector() {
+        return uKnots;
+    }
+
+    @Override
+    public int getVDegree() {
+        return vKnots.getDegree();
+    }
+
+    @Override
+    public float[] getVKnots() {
+        return vKnots.getArray();
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public KnotVector getVKnotVector() {
+        return vKnots;
+    }
+
+    /**
+     *
+     * @param u
+     * @param v
+     * @return
+     */
+    @Override
+    public Vec3D pointOnSurface(double u, double v) {
+        return pointOnSurface((float) u, (float) v, new Vec3D());
+    }
+
+    @Override
+    public Vec3D pointOnSurface(float u, float v) {
+        return pointOnSurface(u, v, new Vec3D());
+    }
+
+    @Override
+    public Vec3D pointOnSurface(float u, float v, Vec3D out) {
+
+        // Piegl -> Algorithm A4.3 -> page 134
+
+        int uspan = uKnots.findSpan(u);
+        double[] bfu = uKnots.basisFunctions(uspan, u);
+
+        int vspan = vKnots.findSpan(v);
+        double[] bfv = vKnots.basisFunctions(vspan, v);
+
+        int p = uKnots.getDegree();
+        int q = vKnots.getDegree();
+        Vec4D[] tmp = new Vec4D[q + 1];
+        for (int l = 0; l <= q; l++) {
+            Vec4D pw = new Vec4D();
+            for (int k = 0; k <= p; k++) {
+                pw.addSelf(cpnet.get(uspan - p + k, vspan - q + l)
+                        .getWeighted().scaleSelf((float) bfu[k]));
+            }
+            tmp[l] = pw;
+        }
+        Vec4D sw = new Vec4D();
+        for (int l = 0; l <= q; l++) {
+            sw.addSelf(tmp[l].scaleSelf((float) bfv[l]));
+        }
+        return sw.unweightInto(out);
+    }
+
+    @Override
+    public Vec4D[][][][] surfaceDerivCpts(int d, int r1, int r2, int s1, int s2) {
+
+        Vec4D[][][][] result = new Vec4D[d + 1][d + 1][r2 - r1 + 1][s2 - s1 + 1];
+        int degreeU = uKnots.getDegree();
+        int degreeV = vKnots.getDegree();
+
+        int du = d < degreeU ? d : degreeU;
+        int dv = d < degreeV ? d : degreeV;
+        int r = r2 - r1;
+        int s = s2 - s1;
+        Vec4D[][] cps = cpnet.getControlPoints();
+        Vec4D[] ucps = new Vec4D[cpnet.uLength()];
+        for (int j = s1; j <= s2; j++) {
+            for (int idxu = 0; idxu < cpnet.uLength(); idxu++) {
+                ucps[idxu] = cps[idxu][j];
+            }
+            Vec4D[][] tmp = new BasicNurbsCurve(ucps, uKnots).curveDerivCpts(
+                    du, r1, r2);
+            for (int k = 0; k <= du; k++) {
+                final Vec4D[][] resk0 = result[k][0];
+                for (int i = 0; i <= (r - k); i++) {
+                    resk0[i][j - s1] = tmp[k][i];
+                }
+            }
+        }
+
+        for (int k = 0; k <= du; k++) {
+            final Vec4D[][] resk0 = result[k][0];
+            for (int i = 0; i <= (r - k); i++) {
+                final int length = resk0[i].length;
+                final Vec4D[] resk0i = resk0[i];
+                Vec4D[] vcps = new Vec4D[length];
+                System.arraycopy(resk0i, 0, vcps, 0, length);
+                final int dd = (d - k) < dv ? (d - k) : dv;
+                Vec4D[][] tmp = new BasicNurbsCurve(vcps, vKnots)
+                        .curveDerivCpts(dd, 0, s);
+                for (int l = 1; l <= dd; l++) {
+                    final Vec4D[] reskli = result[k][l][i];
+                    final Vec4D[] tmpL = tmp[l];
+                    for (int j = 0; j <= (s - 1); j++) {
+                        reskli[j] = tmpL[j];
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    private void validate() {
+        if (uKnots.length() != uKnots.getDegree() + cpnet.uLength() + 1) {
+            throw new IllegalArgumentException(
+                    "Nurbs Surface has wrong Knot number in u Direction");
+        }
+        if (vKnots.length() != vKnots.getDegree() + cpnet.vLength() + 1) {
+            throw new IllegalArgumentException(
+                    "Nurbs Surface has wrong Knot number in v Direction");
+        }
+
+    }
+}