toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/volume/MeshVoxelizer.java

@@ -0,0 +1,216 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.volume;
+
+import toxi.geom.AABB;
+import toxi.geom.Triangle3D;
+import toxi.geom.Vec3D;
+import toxi.geom.mesh.Mesh3D;
+import toxi.math.MathUtils;
+import toxi.math.ScaleMap;
+
+/**
+ *
+ * @author tux
+ */
+public class MeshVoxelizer {
+
+    /**
+     *
+     */
+    protected VolumetricSpace volume;
+
+    /**
+     *
+     */
+    protected int wallThickness = 0;
+
+    /**
+     *
+     * @param res
+     */
+    public MeshVoxelizer(int res) {
+        this(res, res, res);
+    }
+
+    /**
+     *
+     * @param resX
+     * @param resY
+     * @param resZ
+     */
+    public MeshVoxelizer(int resX, int resY, int resZ) {
+        volume = new VolumetricHashMap(new Vec3D(1, 1, 1), resX, resY, resZ,
+                0.1f);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public MeshVoxelizer clear() {
+        volume.clear();
+        return this;
+    }
+
+    /**
+     * @return the volume
+     */
+    public VolumetricSpace getVolume() {
+        return volume;
+    }
+
+    /**
+     * @return the wallThickness
+     */
+    public int getWallThickness() {
+        return wallThickness;
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param iso
+     */
+    protected void setVoxelAt(int x, int y, int z, float iso) {
+        int mix = MathUtils.max(x - wallThickness, 0);
+        int miy = MathUtils.max(y - wallThickness, 0);
+        int miz = MathUtils.max(z - wallThickness, 0);
+        int max = MathUtils.min(x + wallThickness, volume.resX1);
+        int may = MathUtils.min(y + wallThickness, volume.resY1);
+        int maz = MathUtils.min(z + wallThickness, volume.resZ1);
+        for (z = miz; z <= maz; z++) {
+            for (y = miy; y <= may; y++) {
+                for (x = mix; x <= max; x++) {
+                    volume.setVoxelAt(x, y, z, iso);
+                }
+            }
+        }
+    }
+
+    /**
+     * @param wallThickness
+     *            the wallThickness to set
+     * @return 
+     */
+    public MeshVoxelizer setWallThickness(int wallThickness) {
+        this.wallThickness = wallThickness;
+        return this;
+    }
+
+    private VolumetricSpace solidifyVolume(VolumetricSpaceArray volume) {
+        for (int z = 0; z < volume.resZ; z++) {
+            for (int y = 0; y < volume.resY; y++) {
+                boolean isFilled = false;
+                int startX = 0;
+                for (int x = 0; x < volume.resX; x++) {
+                    float val = volume.getVoxelAt(x, y, z);
+                    if (val > 0) {
+                        if (!isFilled) {
+                            startX = x;
+                            isFilled = true;
+                        } else {
+                            for (int i = startX; i <= x; i++) {
+                                volume.setVoxelAt(i, y, z, 1);
+                            }
+                            isFilled = false;
+                        }
+                    }
+                }
+            }
+        }
+        return volume;
+    }
+
+    /**
+     *
+     * @param mesh
+     * @return
+     */
+    public VolumetricSpace voxelizeMesh(Mesh3D mesh) {
+        return voxelizeMesh(mesh, 1f);
+    }
+
+    /**
+     *
+     * @param mesh
+     * @param iso
+     * @return
+     */
+    public VolumetricSpace voxelizeMesh(Mesh3D mesh, float iso) {
+        AABB box = mesh.getBoundingBox();
+        Vec3D bmin = box.getMin();
+        Vec3D bmax = box.getMax();
+        ScaleMap wx = new ScaleMap(bmin.x, bmax.x, 1, volume.resX - 2);
+        ScaleMap wy = new ScaleMap(bmin.y, bmax.y, 1, volume.resY - 2);
+        ScaleMap wz = new ScaleMap(bmin.z, bmax.z, 1, volume.resZ - 2);
+        ScaleMap gx = new ScaleMap(1, volume.resX - 2, bmin.x, bmax.x);
+        ScaleMap gy = new ScaleMap(1, volume.resY - 2, bmin.y, bmax.y);
+        ScaleMap gz = new ScaleMap(1, volume.resZ - 2, bmin.z, bmax.z);
+        volume.setScale(box.getExtent().scale(2f));
+        Triangle3D tri = new Triangle3D();
+        AABB voxel = new AABB(new Vec3D(), volume.voxelSize.scale(0.5f));
+        mesh.getFaces().stream().map((f) -> {
+            tri.a = f.a;
+            return f;
+        }).map((f) -> {
+            tri.b = f.b;
+            return f;
+        }).map((f) -> {
+            tri.c = f.c;
+            return f;
+        }).map((_item) -> tri.getBoundingBox()).forEach((bounds) -> {
+            Vec3D min = bounds.getMin();
+            Vec3D max = bounds.getMax();
+            min = new Vec3D((int) wx.getClippedValueFor(min.x),
+                    (int) wy.getClippedValueFor(min.y),
+                    (int) wz.getClippedValueFor(min.z));
+            max = new Vec3D((int) wx.getClippedValueFor(max.x),
+                    (int) wy.getClippedValueFor(max.y),
+                    (int) wz.getClippedValueFor(max.z));
+            for (int z = (int) min.z; z <= max.z; z++) {
+                for (int y = (int) min.y; y <= max.y; y++) {
+                    for (int x = (int) min.x; x <= max.x; x++) {
+                        if (x < volume.resX1 && y < volume.resY1
+                                && z < volume.resZ1) {
+                            voxel.set((float) gx.getClippedValueFor(x),
+                                    (float) gy.getClippedValueFor(y),
+                                    (float) gz.getClippedValueFor(z));
+                            if (voxel.intersectsTriangle(tri)) {
+                                setVoxelAt(x, y, z, iso);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        return volume;
+    }
+}

data/src/toxi/volume/MultiplyBrush.java

@@ -0,0 +1,20 @@
+package toxi.volume;
+
+/**
+ *
+ * @author tux
+ */
+public class MultiplyBrush implements BrushMode {
+
+    /**
+     *
+     * @param orig
+     * @param brush
+     * @return
+     */
+    @Override
+    public final float apply(float orig, float brush) {
+        return orig * brush;
+    }
+
+}

data/src/toxi/volume/PeakBrush.java

@@ -0,0 +1,21 @@
+package toxi.volume;
+
+import toxi.math.MathUtils;
+
+/**
+ *
+ * @author tux
+ */
+public class PeakBrush implements BrushMode {
+
+    /**
+     *
+     * @param orig
+     * @param brush
+     * @return
+     */
+    @Override
+    public final float apply(float orig, float brush) {
+        return MathUtils.max(orig, brush);
+    }
+}

data/src/toxi/volume/ReplaceBrush.java

@@ -0,0 +1,19 @@
+package toxi.volume;
+
+/**
+ *
+ * @author tux
+ */
+public class ReplaceBrush implements BrushMode {
+
+    /**
+     *
+     * @param orig
+     * @param brush
+     * @return
+     */
+    @Override
+    public final float apply(float orig, float brush) {
+        return brush;
+    }
+}

data/src/toxi/volume/RoundBrush.java

@@ -0,0 +1,113 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.volume;
+
+import java.util.logging.Level;
+
+import toxi.math.MathUtils;
+
+/**
+ *
+ * @author tux
+ */
+public class RoundBrush extends VolumetricBrush {
+
+    protected float radius,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    radSquared;
+
+    /**
+     * Creates a new spherical brush to work on the given volume.
+     * 
+     * @param volume
+     *            VolumetricSpaceArray instance
+     * @param radius
+     *            radius in world units
+     */
+    public RoundBrush(VolumetricSpace volume, float radius) {
+        super(volume);
+        setSize(radius);
+    }
+
+    /**
+     *
+     * @param cx
+     * @param cy
+     * @param cz
+     * @param density
+     */
+    @Override
+    public void drawAtGridPos(float cx, float cy, float cz, float density) {
+        int minX = MathUtils.max(Math.round(cx - cellRadiusX), 0);
+        int minY = MathUtils.max(Math.round(cy - cellRadiusY), 0);
+        int minZ = MathUtils.max(Math.round(cz - cellRadiusZ), 0);
+        int maxX = MathUtils.min(Math.round(cx + cellRadiusX), volume.resX);
+        int maxY = MathUtils.min(Math.round(cy + cellRadiusY), volume.resY);
+        int maxZ = MathUtils.min(Math.round(cz + cellRadiusZ), volume.resZ);
+        for (int z = minZ; z < maxZ; z++) {
+            float dz = (z - cz) * stretchZ;
+            dz *= dz;
+            for (int y = minY; y < maxY; y++) {
+                float dyz = (y - cy) * stretchY;
+                dyz = dyz * dyz + dz;
+                for (int x = minX; x < maxX; x++) {
+                    float dx = x - cx;
+                    float d = (float) Math.sqrt(dx * dx + dyz);
+                    if (d <= cellRadiusX) {
+                        float cellVal = (1 - d / cellRadiusX) * density;
+                        updateVoxel(x, y, z, cellVal);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @param radius
+     */
+    @Override
+    public final void setSize(float radius) {
+        this.radius = radius;
+        this.cellRadiusX = (int) (radius / volume.scale.x * volume.resX + 1);
+        this.cellRadiusY = (int) (radius / volume.scale.y * volume.resY + 1);
+        this.cellRadiusZ = (int) (radius / volume.scale.z * volume.resZ + 1);
+        stretchY = (float) cellRadiusX / cellRadiusY;
+        stretchZ = (float) cellRadiusX / cellRadiusZ;
+        if (logger.isLoggable(Level.FINE)) {
+            logger.log(Level.FINE, "new brush size: {0}", radius);
+        }
+    }
+}

data/src/toxi/volume/VolumetricBrush.java

@@ -0,0 +1,160 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.volume;
+
+import java.util.logging.Logger;
+
+import toxi.geom.Vec3D;
+import toxi.math.MathUtils;
+
+/**
+ *
+ * @author tux
+ */
+public abstract class VolumetricBrush {
+
+    /**
+     *
+     */
+    protected static final Logger logger = Logger
+            .getLogger(VolumetricBrush.class.getName());
+
+    /**
+     *
+     */
+    public static final BrushMode MODE_ADDITIVE = new AdditiveBrush();
+
+    /**
+     *
+     */
+    public static final BrushMode MODE_MULTIPLY = new MultiplyBrush();
+
+    /**
+     *
+     */
+    public static final BrushMode MODE_REPLACE = new ReplaceBrush();
+
+    /**
+     *
+     */
+    public static final BrushMode MODE_PEAK = new PeakBrush();
+
+    /**
+     *
+     */
+    protected VolumetricSpace volume;
+    protected int cellRadiusX,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    cellRadiusY,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    cellRadiusZ;
+    protected float stretchY,
+
+    /**
+     *
+     */
+    stretchZ;
+
+    /**
+     *
+     */
+    protected BrushMode brushMode = MODE_ADDITIVE;
+
+    /**
+     *
+     * @param volume
+     */
+    public VolumetricBrush(VolumetricSpace volume) {
+        this.volume = volume;
+    }
+
+    /**
+     *
+     * @param pos
+     * @param density
+     */
+    public void drawAtAbsolutePos(Vec3D pos, float density) {
+        float cx = MathUtils.clip((pos.x + volume.halfScale.x) / volume.scale.x
+                * volume.resX1, 0, volume.resX1);
+        float cy = MathUtils.clip((pos.y + volume.halfScale.y) / volume.scale.y
+                * volume.resY1, 0, volume.resY1);
+        float cz = MathUtils.clip((pos.z + volume.halfScale.z) / volume.scale.z
+                * volume.resZ1, 0, volume.resZ1);
+        drawAtGridPos(cx, cy, cz, density);
+    }
+
+    /**
+     *
+     * @param cx
+     * @param cy
+     * @param cz
+     * @param density
+     */
+    public abstract void drawAtGridPos(float cx, float cy, float cz,
+            float density);
+
+    /**
+     *
+     * @param mode
+     */
+    public void setMode(BrushMode mode) {
+        brushMode = mode;
+    }
+
+    /**
+     *
+     * @param radius
+     */
+    public abstract void setSize(float radius);
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param cellVal
+     */
+    protected final void updateVoxel(int x, int y, int z, float cellVal) {
+        int idx = volume.getIndexFor(x, y, z);
+        volume.setVoxelAt(idx, brushMode.apply(volume.getVoxelAt(idx), cellVal));
+    }
+}