toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/sim/dla/DLA.java

@@ -0,0 +1,497 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.sim.dla;
+
+import java.io.BufferedWriter;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import toxi.geom.PointOctree;
+import toxi.geom.Vec3D;
+import toxi.math.MathUtils;
+
+/**
+ *
+ * @author tux
+ */
+public class DLA {
+
+    /**
+     *
+     */
+    protected static final Logger logger = Logger
+            .getLogger(DLA.class.getName());
+
+    /**
+     *
+     */
+    protected int numParticles;
+
+    /**
+     *
+     */
+    protected DLAParticle currParticle;
+    protected PointOctree octree,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    octreeGuides;
+
+    /**
+     *
+     */
+    protected Vec3D currCurvePoint;
+
+    /**
+     *
+     */
+    protected Vec3D dirCurvePoint;
+    protected Vec3D minBounds,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    maxBounds;
+
+    /**
+     *
+     */
+    protected DLAGuideLines guidelines;
+
+    /**
+     *
+     */
+    protected ArrayList<DLASegment> activeSegments = new ArrayList<>();
+
+    /**
+     *
+     */
+    protected List<DLAEventListener> listeners = new ArrayList<>();
+
+    /**
+     *
+     */
+    protected int numActiveSegments = 0;
+
+    /**
+     *
+     */
+    protected DLAConfiguration config;
+
+    /**
+     *
+     * @param size
+     */
+    public DLA(float size) {
+        octree = createOctree(new Vec3D(-0.5f, -0.5f, -0.5f).scale(size), size);
+        octreeGuides = createOctree(new Vec3D(-0.5f, -0.5f, -0.5f).scale(size),
+                size);
+        minBounds = Vec3D.MAX_VALUE.copy();
+        maxBounds = Vec3D.NEG_MAX_VALUE.copy();
+    }
+
+    /**
+     *
+     * @param size
+     * @param config
+     * @param guides
+     */
+    public DLA(float size, DLAConfiguration config, DLAGuideLines guides) {
+        this(size);
+        this.config = config;
+        if (guides != null) {
+            this.guidelines = guides;
+            parseGuidelines();
+            updateCurvePoint();
+        }
+    }
+
+    /**
+     *
+     * @param l
+     * @return
+     */
+    public DLA addListener(DLAEventListener l) {
+        listeners.add(l);
+        logger.log(Level.INFO, "adding listener: {0}", l);
+        return this;
+    }
+
+    /**
+     *
+     * @param p
+     */
+    public void addParticle(Vec3D p) {
+        if (octree.addPoint(p.copy())) {
+            numParticles++;
+            minBounds.minSelf(p);
+            maxBounds.maxSelf(p);
+            if (listeners != null) {
+                for (DLAEventListener l : listeners) {
+                    l.dlaNewParticleAdded(this, p);
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @param p
+     * @param target
+     */
+    protected void alignAttachedParticle(DLAParticle p, Vec3D target) {
+        Vec3D d = p.sub(target).normalize();
+        d.interpolateToSelf(dirCurvePoint, config.getCurveAlign());
+        d.scaleSelf(config.getGrowthScale());
+        d.normalizeTo(config.getParticleRadius());
+        p.set(target).addSelf(d);
+    }
+
+    /**
+     * Checks if the given particle is close to an existing one or a curve. If
+     * so, the particle is attached based on the current DLA parameters and the
+     * method return true.
+     * 
+     * @param p
+     * @return true, if particle attached.
+     */
+    protected boolean checkParticle(DLAParticle p) {
+        List<Vec3D> parts = octree
+                .getPointsWithinSphere(p, config.snapDistance);
+        float stickiness = config.getStickiness();
+        if (parts != null) {
+            float minDist = Integer.MAX_VALUE;
+            Vec3D found = null;
+            for (Vec3D pp : parts) {
+                float d = pp.distanceToSquared(p);
+                if (d < minDist) {
+                    minDist = d;
+                    found = pp;
+                }
+            }
+            if (minDist < config.getSnapDistanceSquared()
+                    && Math.random() < stickiness) {
+                alignAttachedParticle(p, found);
+                addParticle(p);
+                return true;
+            }
+        }
+        if (p.sub(currCurvePoint).magSquared() < config
+                .getCurveAttachDistanceSquared()) {
+            parts = octreeGuides.getPointsWithinSphere(p,
+                    config.getCurveAttachDistance());
+            if (parts != null) {
+                for (int i = parts.size(); i > 0; i--) {
+                    if (Math.random() < stickiness) {
+                        addParticle(p);
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     *
+     */
+    public void clear() {
+        octree.empty();
+        octreeGuides.empty();
+        reset();
+    }
+
+    /**
+     *
+     * @param origin
+     * @param size
+     * @return
+     */
+    protected final PointOctree createOctree(Vec3D origin, float size) {
+        return new PointOctree(origin, size);
+    }
+
+    /**
+     * @return the config
+     */
+    public DLAConfiguration getConfig() {
+        return config;
+    }
+
+    /**
+     * @return the currCurvePoint
+     */
+    public Vec3D getCurrentCurvePoint() {
+        return currCurvePoint;
+    }
+
+    /**
+     * @return the currParticle
+     */
+    public DLAParticle getCurrentParticle() {
+        return currParticle;
+    }
+
+    /**
+     * @return the guidelines
+     */
+    public DLAGuideLines getGuidelines() {
+        return guidelines;
+    }
+
+    /**
+     * @return the octreeGuides
+     */
+    public PointOctree getGuideOctree() {
+        return octreeGuides;
+    }
+
+    /**
+     * @return the numActiveSegments
+     */
+    public int getNumActiveSegments() {
+        return numActiveSegments;
+    }
+
+    /**
+     * @return the numParticles
+     */
+    public int getNumParticles() {
+        return numParticles;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public PointOctree getParticleOctree() {
+        return octree;
+    }
+
+    /**
+     * @return the octree
+     */
+    public List<Vec3D> getParticles() {
+        return octree.getPoints();
+    }
+
+    /**
+     *
+     */
+    protected final void parseGuidelines() {
+        guidelines.reset();
+        octreeGuides.empty();
+        while (!guidelines.isComplete()) {
+            double density = config.getGuideLineDensity();
+            guidelines.updatePoint(density);
+            Vec3D p = guidelines.getPoint();
+            octreeGuides.addPoint(p);
+        }
+        guidelines.reset();
+    }
+
+    /**
+     *
+     * @param l
+     * @return
+     */
+    public DLA removeListener(DLAEventListener l) {
+        listeners.remove(l);
+        logger.log(Level.INFO, "removing listener: {0}", l);
+        return this;
+    }
+
+    /**
+     *
+     */
+    public void reset() {
+        guidelines.reset();
+        updateCurvePoint();
+    }
+
+    /**
+     *
+     * @param fname
+     * @param isCentered
+     */
+    public void save(String fname, boolean isCentered) {
+        List<Vec3D> parts = octree.getPoints();
+        if (parts != null) {
+            Vec3D origin = minBounds.add(maxBounds).scaleSelf(0.5f);
+            logger.log(Level.INFO, "bounds: {0} -> {1} offset origin: {2}", new Object[]{minBounds, maxBounds, origin});
+                try (RandomAccessFile file = new RandomAccessFile(fname, "rw"); FileChannel channel = file.getChannel()) {
+                    int size = parts.size() * 4 * 3;
+                    MappedByteBuffer buffer = channel.map(
+                            FileChannel.MapMode.READ_WRITE, 0, size);
+                    if (isCentered) {
+                        for (Vec3D p : parts) {
+                            p = p.sub(origin);
+                            buffer.putFloat(p.x);
+                            buffer.putFloat(p.y);
+                            buffer.putFloat(p.z);
+                        }
+                    } else {
+                        for (Vec3D p : parts) {
+                            buffer.putFloat(p.x);
+                            buffer.putFloat(p.y);
+                            buffer.putFloat(p.z);
+                        }
+                    }
+                    buffer.force();
+                } catch (FileNotFoundException ex) {
+                Logger.getLogger(DLA.class.getName()).log(Level.SEVERE, null, ex);
+            } catch (IOException ex) {
+                Logger.getLogger(DLA.class.getName()).log(Level.SEVERE, null, ex);
+            }
+                logger.log(Level.INFO, "written {0} particles to {1}", new Object[]{parts.size(), fname});
+        }
+    }
+
+    /**
+     *
+     * @param fname
+     * @param isCentered
+     */
+    public void saveAsText(String fname, boolean isCentered) {
+        List<Vec3D> particles = octree.getPoints();
+        if (particles != null) {
+            Vec3D origin = minBounds.add(maxBounds).scaleSelf(0.5f);
+            logger.log(Level.INFO, "bounds: {0} -> {1} offset origin: {2}", new Object[]{minBounds, maxBounds, origin});
+                try (BufferedWriter out = new BufferedWriter(new FileWriter(fname))) {
+                for (Vec3D p : octree.getPoints()) {
+                    StringBuilder sb = new StringBuilder(36);
+                    sb.append(p.x).append(',').append(p.y).append(',')
+                            .append(p.z).append("\n");
+                    out.write(sb.toString());
+                }
+                } catch (IOException ex) {
+                Logger.getLogger(DLA.class.getName()).log(Level.SEVERE, null, ex);
+            }
+                logger.log(Level.INFO, "written {0} particles to {1}", new Object[]{particles.size(), fname});
+        }
+    }
+
+    /**
+     * @param config
+     *            the config to set
+     */
+    public void setConfig(DLAConfiguration config) {
+        this.config = config;
+    }
+
+    /**
+     * @param guidelines
+     *            the guidelines to set
+     */
+    public void setGuidelines(DLAGuideLines guidelines) {
+        this.guidelines = guidelines;
+        parseGuidelines();
+        updateCurvePoint();
+    }
+
+    /**
+     *
+     */
+    public void update() {
+        if (currParticle == null) {
+            Vec3D spawnPos = Vec3D.randomVector();
+            spawnPos = currCurvePoint.add(spawnPos.scale(MathUtils
+                    .random(config.getSpawnRadius())));
+            currParticle = new DLAParticle(spawnPos, config.getEscapeRadius(),
+                    config.getParticleSpeed(), config.getSearchSpeed());
+        }
+        currParticle.update(currCurvePoint);
+        if (checkParticle(currParticle)) {
+            currParticle = null;
+            updateCurvePoint();
+        }
+    }
+
+    /**
+     *
+     * @param numIterations
+     */
+    public void update(int numIterations) {
+        for (int i = 0; i < numIterations; i++) {
+            update();
+        }
+    }
+
+    /**
+     *
+     */
+    protected final void updateCurvePoint() {
+        if (Math.random() < config.getContinuousGrowthRatio()
+                && numActiveSegments > 0) {
+            DLASegment segment = activeSegments.get((int) (config
+                    .getContinuousGrowthCoeff() * (numActiveSegments - 1)));
+            float currT = MathUtils.random(1f);
+            dirCurvePoint = segment.getDirectionAt(currT);
+            currCurvePoint = segment.a.add(dirCurvePoint.scale(segment
+                    .getLength() * currT));
+        } else {
+            DLASegment s = guidelines.updatePoint(config.getCurveSpeed());
+            if (!activeSegments.contains(s)) {
+                activeSegments.add(s);
+                numActiveSegments++;
+                if (listeners != null) {
+                    for (DLAEventListener l : listeners) {
+                        l.dlaSegmentSwitched(this, s);
+                    }
+                }
+            }
+            currCurvePoint = guidelines.getPoint();
+            dirCurvePoint = guidelines.getDirection();
+        }
+        if (guidelines.isComplete()) {
+            guidelines.reset();
+            if (listeners != null) {
+                for (DLAEventListener l : listeners) {
+                    l.dlaAllSegmentsProcessed(this);
+                }
+            }
+        }
+    }
+}