toxiclibs 0.4.0 → 0.8.0

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

@@ -0,0 +1,120 @@
+/*
+ * 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;
+
+/**
+ * Interface for Nurbs Curves
+ * 
+ * @author sg
+ * @version 1.0
+ */
+public interface NurbsCurve {
+
+    /**
+     * Computes control points of dth derivative<br />
+     * Piegel, L. The Nurbs Book<br />
+     * Algorithm A3.3 -> Page 98<br />
+     * <br />
+     * 
+     * @param d
+     *            - dth derivative<br />
+     * @param r1
+     *            - from control point (0 for all control points)<br />
+     * @param r2
+     *            - to control point (n for all control points)<br />
+     * @return Vec4D[k][i] kth derivative, ith control point
+     */
+    public Vec4D[][] curveDerivCpts(int d, int r1, int r2);
+
+    /**
+     *
+     * @param u
+     * @param d
+     * @return
+     */
+    public abstract Vec3D[] derivativesOnCurve(float u, int d);
+
+    /**
+     *
+     * @param u
+     * @param d
+     * @param ders
+     * @return
+     */
+    public abstract Vec3D[] derivativesOnCurve(float u, int d, Vec3D[] ders);
+
+    /**
+     * Get the ControlPoints of this curve
+     * 
+     * @return the ordered ControlPoints
+     */
+    Vec4D[] getControlPoints();
+
+    /**
+     * Get the Degree of the curve
+     * 
+     * @return degree of curve
+     */
+    int getDegree();
+
+    /**
+     * Gets the Knot values of the Nurbs curve
+     * 
+     * @return knot values
+     */
+    float[] getKnots();
+
+    /**
+     *
+     * @return
+     */
+    KnotVector getKnotVector();
+
+    /**
+     * Calculate point on surface for the given u value
+     * 
+     * @param u
+     *            value to calculate point of
+     * @return calculated Point
+     */
+    Vec3D pointOnCurve(float u);
+
+    /**
+     * Calculate point on surface for the given u value
+     * 
+     * @param u
+     *            value to calculate point of
+     * @param out
+     *            Point to place result in
+     * @return 
+     */
+    Vec3D pointOnCurve(float u, Vec3D out);
+
+    /**
+     *
+     * @param res
+     * @return
+     */
+    Polygon2D toPolygon2D(int res);
+}

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

@@ -0,0 +1,145 @@
+package toxi.geom.nurbs;
+
+import toxi.geom.Vec2D;
+import toxi.geom.Vec3D;
+import toxi.geom.mesh.Mesh3D;
+import toxi.geom.mesh.TriangleMesh;
+
+/**
+ *
+ * @author tux
+ */
+public class NurbsMeshCreator {
+
+    private NurbsSurface surf;
+    private Vec2D maxUV;
+
+    /**
+     *
+     * @param surf
+     */
+    public NurbsMeshCreator(NurbsSurface surf) {
+        this(surf, new Vec2D(1, 1));
+    }
+
+    /**
+     *
+     * @param surf
+     * @param maxUV
+     */
+    public NurbsMeshCreator(NurbsSurface surf, Vec2D maxUV) {
+        this.surf = surf;
+        this.maxUV = maxUV;
+    }
+
+    /**
+     *
+     * @param mesh
+     * @return
+     */
+    public Mesh3D createControlMesh(Mesh3D mesh) {
+        Vec3D[] prev = null;
+        if (mesh == null) {
+            mesh = new TriangleMesh();
+        }
+        int resU = surf.getControlNet().uLength();
+        int resV = surf.getControlNet().vLength();
+        Vec2D dUV = maxUV.scale(1f / resU, 1f / resV);
+        for (int u = 0; u < resU; u++) {
+            Vec3D[] curr = new Vec3D[resV + 1];
+            for (int v = 0; v < resV; v++) {
+                Vec3D vert = surf.getControlNet().get(u, v).to3D();
+                if (v > 0 && u > 0) {
+                    mesh.addFace(curr[v - 1], vert, prev[v - 1],
+                            dUV.scale(u, v - 1), dUV.scale(u, v),
+                            dUV.scale(u - 1, v - 1));
+                    mesh.addFace(vert, prev[v], prev[v - 1], dUV.scale(u, v),
+                            dUV.scale(u - 1, v), dUV.scale(u - 1, v - 1));
+                }
+                curr[v] = vert;
+            }
+            prev = curr;
+        }
+        mesh.computeVertexNormals();
+        return mesh;
+    }
+
+    /**
+     *
+     * @param mesh
+     * @param resU
+     * @param resV
+     * @param isClosed
+     * @return
+     */
+    public Mesh3D createMesh(Mesh3D mesh, int resU, int resV, boolean isClosed) {
+        final KnotVector knotU = surf.getUKnotVector();
+        final KnotVector knotV = surf.getVKnotVector();
+        double iresU = knotU.get(knotU.length() - 1) / resU;
+        double iresV = knotV.get(knotV.length() - 1) / resV;
+        Vec3D[] prev = null;
+        Vec3D[] first = null;
+        if (mesh == null) {
+            mesh = new TriangleMesh();
+        }
+        Vec2D dUV = maxUV.scale(1f / resU, 1f / resV);
+        for (int u = 0; u <= resU; u++) {
+            Vec3D[] curr = new Vec3D[resV + 1];
+            for (int v = 0; v <= resV; v++) {
+                Vec3D vert = null;
+                if (isClosed) {
+                    vert = u < resU ? surf.pointOnSurface(u * iresU, v * iresV)
+                            : first[v];
+                } else {
+                    vert = surf.pointOnSurface(u * iresU, v * iresV);
+                }
+                if (v > 0 && u > 0) {
+                    mesh.addFace(curr[v - 1], vert, prev[v - 1],
+                            dUV.scale(u, v - 1), dUV.scale(u, v),
+                            dUV.scale(u - 1, v - 1));
+                    mesh.addFace(vert, prev[v], prev[v - 1], dUV.scale(u, v),
+                            dUV.scale(u - 1, v), dUV.scale(u - 1, v - 1));
+                }
+                curr[v] = vert;
+            }
+            prev = curr;
+            if (u == 0) {
+                first = curr;
+            }
+        }
+        mesh.computeVertexNormals();
+        return mesh;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public NurbsSurface getSurface() {
+        return surf;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public Vec2D getUVScale() {
+        return maxUV;
+    }
+
+    /**
+     *
+     * @param surf
+     */
+    public void setSurface(NurbsSurface surf) {
+        this.surf = surf;
+    }
+
+    /**
+     *
+     * @param maxUV
+     */
+    public void setUVScale(Vec2D maxUV) {
+        this.maxUV = maxUV;
+    }
+}

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

@@ -0,0 +1,147 @@
+/*
+ * 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;
+
+/**
+ * Interface for Nurbs Surfaces.
+ * 
+ * @author sg
+ * @version 1.2
+ */
+public interface NurbsSurface {
+
+    /**
+     * Get the Contol points of the NurbsSurface
+     * 
+     * @return ControlNet of the Nurbs
+     */
+    ControlNet getControlNet();
+
+    /**
+     * Get a List of all TrimCurves asociated with this Nurbs Surface
+     * 
+     * @return List of TrimCurves
+     */
+    // List<TrimCurve> getTrimCurves();
+
+    /**
+     * Get the degree in u direction
+     * 
+     * @return degree in u direction
+     */
+    int getUDegree();
+
+    /**
+     * Get the knot values in u direction
+     * 
+     * @return knot values in u direction
+     */
+    float[] getUKnots();
+
+    /**
+     *
+     * @return
+     */
+    public abstract KnotVector getUKnotVector();
+
+    /**
+     * Get the degree in v direction
+     * 
+     * @return degree in v direction
+     */
+    int getVDegree();
+
+    /**
+     * Get the knot values in v direction
+     * 
+     * @return knot values in v direction
+     */
+    float[] getVKnots();
+
+    /**
+     *
+     * @return
+     */
+    public abstract KnotVector getVKnotVector();
+
+    /**
+     *
+     * @param u
+     * @param v
+     * @return
+     */
+    public abstract Vec3D pointOnSurface(double u, double v);
+
+    /**
+     * Calculate point on surface for the given u and v values
+     * 
+     * @param u
+     *            u value to caculate point from
+     * @param v
+     *            v value to caculate point from
+     * @return calculated point
+     */
+    Vec3D pointOnSurface(float u, float v);
+
+    /**
+     * Add a TrimCurve to this Nurbs Surface
+     * 
+     * @param tc
+     *            TrimCurve to add.
+     */
+    // void addTrimCurve(TrimCurve tc);
+
+    /**
+     * Calculate point on surface for the given u and v values
+     * 
+     * @param u
+     *            u value to caculate point from
+     * @param v
+     *            v value to caculate point from
+     * @param out
+     *            point to place result in.
+     * @return 
+     */
+    Vec3D pointOnSurface(float u, float v, Vec3D out);
+
+    /**
+     * Computes control points of dth derivative<br />
+     * Piegel, L. The Nurbs Book, Algorithm A3.7 -> Page 114<br />
+     * 
+     * @param d
+     *            - dth derivative (0<=k+l<=d)<br />
+     * @param r1
+     *            - from control point (u direction; 0 for all control points)<br />
+     * @param r2
+     *            - to control point (u direction; n for all control points)<br />
+     * @param s1
+     *            - from control point (v direction; 0 for all control points)<br />
+     * @param s2
+     *            - to control point (v direction; n for all control points)<br />
+     * @return ControlPoint4f[k][l][i][j] i,jth control point, differentiated k
+     *         times<br />
+     *         with respect to u and l times with respect to v
+     */
+    public Vec4D[][][][] surfaceDerivCpts(int d, int r1, int r2, int s1, int s2);
+
+}

data/src/toxi/image/util/Filter8bit.java

@@ -0,0 +1,331 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.image.util;
+
+import processing.core.PImage;
+
+/**
+ * Filter8bit is a collection of non-destructive, threadsafe filters for
+ * grayscale images in Processing PImage format. All filters are implemented as
+ * static methods so no instance is needed.
+ * 
+ * @version 0.1
+ */
+public class Filter8bit {
+
+    private static int[] koff;
+
+    private static int prevKernelSize = -1;
+
+    private static int prevWidth = -1;
+
+    /**
+     *
+     * @param pix
+     * @param width
+     * @param height
+     * @param kernelSize
+     * @param filterConst
+     * @return
+     */
+    public static int[] adaptiveThreshold(int[] pix, int width, int height,
+            int kernelSize, int filterConst) {
+        int maxIdx = pix.length;
+        int[] dest = new int[maxIdx];
+        int kl = kernelSize * kernelSize;
+        int ck = kernelSize >> 1;
+        if (kl != prevKernelSize || width != prevWidth) {
+            System.out.println("recalc threshold filter kernel");
+            koff = new int[kl];
+            prevKernelSize = kl;
+            prevWidth = width;
+            for (int k = 0, off = -width * ck - ck; k < kl; k++) {
+                koff[k] = off;
+                if ((k % kernelSize) == kernelSize - 1) {
+                    off += width - kernelSize + 1;
+                } else {
+                    off++;
+                }
+            }
+        }
+        for (int i = 0; i < maxIdx; i++) {
+            int mean = 0;
+            for (int k = 0; k < kl; k++) {
+                int idx = i + koff[k];
+                if (idx >= 0 && idx < maxIdx) {
+                    mean += pix[idx] & 0xff;
+                }
+            }
+            mean = (mean / kl) - filterConst;
+            if ((pix[i] & 0xff) > mean) {
+                dest[i] = 0xff0000ff;
+            } else {
+                dest[i] = 0xff000000;
+            }
+        }
+        return dest;
+    }
+
+    /**
+     * Non-destructively applies an adaptive thresholding filter to the passed
+     * in image (grayscale only). Filter8bit only uses data stored in the blue
+     * channel of the image (lowest 8 bit).
+     * 
+     * @param img
+     *            image to be filtered
+     * @param ks
+     *            kernel size
+     * @param c
+     *            constant integer value to be subtracted from kernel result
+     * @return filtered version of the image (with alpha channel set to full
+     *         opacity)
+     */
+
+    public static PImage adaptiveThreshold(PImage img, int ks, int c) {
+        PImage img2 = new PImage(img.width, img.height);
+        img2.format = img.format;
+        img2.pixels = adaptiveThreshold(img.pixels, img.width, img.height, ks,
+                c);
+        return img2;
+    }
+
+    /**
+     * @param pixels
+     * @param width
+     * @param height
+     * @param isInverted
+     * @return filtered pixel array
+     */
+    public static int[] erodePixels(int[] pixels, int width, int height,
+            boolean isInverted) {
+        int currIdx = 0;
+        int maxIdx = pixels.length;
+        int[] out = new int[maxIdx];
+
+        if (isInverted) {
+            // dilation (grow light areas)
+            while (currIdx < maxIdx) {
+                int currRowIdx = currIdx;
+                int maxRowIdx = currIdx + width;
+                while (currIdx < maxRowIdx) {
+                    int colOrig, colOut;
+                    colOrig = colOut = pixels[currIdx];
+                    int idxLeft = currIdx - 1;
+                    int idxRight = currIdx + 1;
+                    int idxUp = currIdx - width;
+                    int idxDown = currIdx + width;
+                    if (idxLeft < currRowIdx) {
+                        idxLeft = currIdx;
+                    }
+                    if (idxRight >= maxRowIdx) {
+                        idxRight = currIdx;
+                    }
+                    if (idxUp < 0) {
+                        idxUp = 0;
+                    }
+                    if (idxDown >= maxIdx) {
+                        idxDown = currIdx;
+                    }
+
+                    int colUp = pixels[idxUp];
+                    int colLeft = pixels[idxLeft];
+                    int colDown = pixels[idxDown];
+                    int colRight = pixels[idxRight];
+
+                    // compute luminance
+                    int currLum = colOrig & 0xff;
+                    int lumLeft = colLeft & 0xff;
+                    int lumRight = colRight & 0xff;
+                    int lumUp = colUp & 0xff;
+                    int lumDown = colDown & 0xff;
+
+                    if (lumLeft > currLum) {
+                        colOut = colLeft;
+                        currLum = lumLeft;
+                    }
+                    if (lumRight > currLum) {
+                        colOut = colRight;
+                        currLum = lumRight;
+                    }
+                    if (lumUp > currLum) {
+                        colOut = colUp;
+                        currLum = lumUp;
+                    }
+                    if (lumDown > currLum) {
+                        colOut = colDown;
+                        currLum = lumDown;
+                    }
+                    out[currIdx++] = colOut;
+                }
+            }
+        } else {
+            // erode (grow dark areas)
+            while (currIdx < maxIdx) {
+                int currRowIdx = currIdx;
+                int maxRowIdx = currIdx + width;
+                while (currIdx < maxRowIdx) {
+                    int colOrig, colOut;
+                    colOrig = colOut = pixels[currIdx];
+                    int idxLeft = currIdx - 1;
+                    int idxRight = currIdx + 1;
+                    int idxUp = currIdx - width;
+                    int idxDown = currIdx + width;
+                    if (idxLeft < currRowIdx) {
+                        idxLeft = currIdx;
+                    }
+                    if (idxRight >= maxRowIdx) {
+                        idxRight = currIdx;
+                    }
+                    if (idxUp < 0) {
+                        idxUp = 0;
+                    }
+                    if (idxDown >= maxIdx) {
+                        idxDown = currIdx;
+                    }
+
+                    int colUp = pixels[idxUp];
+                    int colLeft = pixels[idxLeft];
+                    int colDown = pixels[idxDown];
+                    int colRight = pixels[idxRight];
+
+                    // compute luminance
+                    int currLum = colOrig & 0xff;
+                    int lumLeft = colLeft & 0xff;
+                    int lumRight = colRight & 0xff;
+                    int lumUp = colUp & 0xff;
+                    int lumDown = colDown & 0xff;
+
+                    if (lumLeft < currLum) {
+                        colOut = colLeft;
+                        currLum = lumLeft;
+                    }
+                    if (lumRight < currLum) {
+                        colOut = colRight;
+                        currLum = lumRight;
+                    }
+                    if (lumUp < currLum) {
+                        colOut = colUp;
+                        currLum = lumUp;
+                    }
+                    if (lumDown < currLum) {
+                        colOut = colDown;
+                        currLum = lumDown;
+                    }
+                    out[currIdx++] = colOut;
+                }
+            }
+        }
+        return out;
+    }
+
+    /**
+     * @param img
+     * @param isInverted
+     * @return filtered result as new image
+     */
+    public static PImage erodePixels(PImage img, boolean isInverted) {
+        PImage img2 = new PImage(img.width, img.height);
+        img2.format = img.format;
+        img2.pixels = erodePixels(img.pixels, img.width, img.height, isInverted);
+        return img2;
+    }
+
+    /**
+     *
+     * @param srcpix
+     * @param lolim
+     * @param uplim
+     * @return
+     */
+    public static int[] stretchLevels(int[] srcpix, int lolim, int uplim) {
+        int min = srcpix[0] & 0xff;
+        int max = srcpix[0] & 0xff;
+        int src_rgb;
+        int result;
+        float quotient = 0;
+
+        int[] dest = new int[srcpix.length];
+
+        // Find the max and min values
+        for (int i = 0; i < srcpix.length; i++) {
+            src_rgb = srcpix[i] & 0xff;
+            if (src_rgb < min) {
+                min = src_rgb;
+            } else if (src_rgb > max) {
+                max = src_rgb;
+            }
+        }
+        quotient = (((float) (uplim - lolim)) / ((float) (max - min)));
+        // Calculate the output values
+        for (int i = 0; i < srcpix.length; i++) {
+            src_rgb = srcpix[i] & 0xff;
+            result = (int) ((src_rgb - min) * quotient) + lolim;
+            if (result > 255) {
+                result = 255;
+            } else if (result < 0) {
+                result = 0;
+            }
+            dest[i] = 0xff000000 | result;
+        }
+        return dest;
+    }
+
+    /**
+     * Non-destructively stretches levels of an 8bit grayscale image
+     * 
+     * @param img
+     *            Image to be level stretched
+     * @param uplim
+     *            The upper limit for the values to be stretched between
+     * @param lolim
+     *            The lower limit for the values to be stretched between
+     * @return filtered version of the image (with alpha channel set to full
+     *         opacity)
+     */
+
+    public static PImage stretchLevels(PImage img, int lolim, int uplim) {
+        PImage img2 = new PImage(img.width, img.height);
+        img2.format = img.format;
+        img2.pixels = stretchLevels(img.pixels, lolim, uplim);
+        return img2;
+    }
+
+    /**
+     *
+     * @param pix
+     * @param threshold
+     * @return
+     */
+    public static int[] threshold(int[] pix, int threshold) {
+        int[] dest = new int[pix.length];
+        for (int i = 0; i < pix.length; i++) {
+            dest[i] = (pix[i] & 0xff) > threshold ? 0xff0000ff : 0xff000000;
+        }
+        return dest;
+    }
+}