diff options
Diffstat (limited to 'src/libnoiseforjava/module/Voronoi.java')
| -rw-r--r-- | src/libnoiseforjava/module/Voronoi.java | 283 |
1 files changed, 283 insertions, 0 deletions
diff --git a/src/libnoiseforjava/module/Voronoi.java b/src/libnoiseforjava/module/Voronoi.java new file mode 100644 index 0000000..79776c1 --- /dev/null +++ b/src/libnoiseforjava/module/Voronoi.java @@ -0,0 +1,283 @@ +/*
+ * Copyright (C) 2003, 2004 Jason Bevins (original libnoise code)
+ * Copyright 2010 Thomas J. Hodge (java port of libnoise)
+ *
+ * This file is part of libnoiseforjava.
+ *
+ * libnoiseforjava is a Java port of the C++ library libnoise, which may be found at
+ * http://libnoise.sourceforge.net/. libnoise was developed by Jason Bevins, who may be
+ * contacted at [email protected] (for great email, take off every 'zig').
+ * Porting to Java was done by Thomas Hodge, who may be contacted at
+ * [email protected] (remove every 'zag').
+ *
+ * libnoiseforjava 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 3 of the License, or (at your option) any later version.
+ *
+ * libnoiseforjava 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
+ * libnoiseforjava. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package libnoiseforjava.module;
+
+import libnoiseforjava.NoiseGen;
+
+public class Voronoi extends ModuleBase
+{
+
+ /// Noise module that outputs Voronoi cells.
+ ///
+ /// In mathematics, a <i>Voronoi cell</i> is a region containing all the
+ /// points that are closer to a specific <i>seed point</i> than to any
+ /// other seed point. These cells mesh with one another, producing
+ /// polygon-like formations.
+ ///
+ /// By default, this noise module randomly places a seed point within
+ /// each unit cube. By modifying the <i>frequency</i> of the seed points,
+ /// an application can change the distance between seed points. The
+ /// higher the frequency, the closer together this noise module places
+ /// the seed points, which reduces the size of the cells. To specify the
+ /// frequency of the cells, call the setFrequency() method.
+ ///
+ /// This noise module assigns each Voronoi cell with a random constant
+ /// value from a coherent-noise function. The <i>displacement value</i>
+ /// controls the range of random values to assign to each cell. The
+ /// range of random values is +/- the displacement value. Call the
+ /// setDisplacement() method to specify the displacement value.
+ ///
+ /// To modify the random positions of the seed points, call the SetSeed()
+ /// method.
+ ///
+ /// This noise module can optionally add the distance from the nearest
+ /// seed to the output value. To enable this feature, call the
+ /// enableDistance() method. This causes the points in the Voronoi cells
+ /// to increase in value the further away that point is from the nearest
+ /// seed point.
+ ///
+ /// Voronoi cells are often used to generate cracked-mud terrain
+ /// formations or crystal-like textures
+ ///
+ /// This noise module requires no source modules.
+
+
+ /// Default displacement to apply to each cell for the
+ /// Voronoi noise module.
+ final static double DEFAULT_VORONOI_DISPLACEMENT = 1.0;
+
+ /// Default frequency of the seed points for the Voronoi
+ /// noise module.
+ final static double DEFAULT_VORONOI_FREQUENCY = 1.0;
+
+ /// Default seed of the noise function for the Voronoi
+ /// noise module.
+ final static int DEFAULT_VORONOI_SEED = 0;
+
+ private static final double SQRT_3 = 1.7320508075688772935;
+
+
+ /// Scale of the random displacement to apply to each Voronoi cell.
+ double displacement;
+
+ /// Determines if the distance from the nearest seed point is applied to
+ /// the output value.
+ boolean enableDistance;
+
+ /// Frequency of the seed points.
+ double frequency;
+
+ /// Seed value used by the coherent-noise function to determine the
+ /// positions of the seed points.
+ int seed;
+
+
+ public Voronoi ()
+ {
+ super(0);
+ displacement = DEFAULT_VORONOI_DISPLACEMENT;
+ enableDistance = false;
+ frequency = DEFAULT_VORONOI_FREQUENCY;
+ seed = DEFAULT_VORONOI_SEED;
+ }
+
+ public double getValue (double x, double y, double z)
+ {
+ // This method could be more efficient by caching the seed values. Fix
+ // later.
+
+ x *= frequency;
+ y *= frequency;
+ z *= frequency;
+
+ int xInt = (x > 0.0? (int)x: (int)x - 1);
+ int yInt = (y > 0.0? (int)y: (int)y - 1);
+ int zInt = (z > 0.0? (int)z: (int)z - 1);
+
+ double minDist = 2147483647.0;
+ double xCandidate = 0;
+ double yCandidate = 0;
+ double zCandidate = 0;
+
+ // Inside each unit cube, there is a seed point at a random position. Go
+ // through each of the nearby cubes until we find a cube with a seed point
+ // that is closest to the specified position.
+ for (int zCur = zInt - 2; zCur <= zInt + 2; zCur++)
+ {
+ for (int yCur = yInt - 2; yCur <= yInt + 2; yCur++)
+ {
+ for (int xCur = xInt - 2; xCur <= xInt + 2; xCur++)
+ {
+ // Calculate the position and distance to the seed point inside of
+ // this unit cube.
+ double xPos = xCur + NoiseGen.ValueNoise3D (xCur, yCur, zCur, seed);
+ double yPos = yCur + NoiseGen.ValueNoise3D (xCur, yCur, zCur, seed + 1);
+ double zPos = zCur + NoiseGen.ValueNoise3D (xCur, yCur, zCur, seed + 2);
+ double xDist = xPos - x;
+ double yDist = yPos - y;
+ double zDist = zPos - z;
+ double dist = xDist * xDist + yDist * yDist + zDist * zDist;
+
+ if (dist < minDist)
+ {
+ // This seed point is closer to any others found so far, so record
+ // this seed point.
+ minDist = dist;
+ xCandidate = xPos;
+ yCandidate = yPos;
+ zCandidate = zPos;
+ }
+ }
+ }
+ }
+
+ double value;
+ if (enableDistance)
+ {
+ // Determine the distance to the nearest seed point.
+ double xDist = xCandidate - x;
+ double yDist = yCandidate - y;
+ double zDist = zCandidate - z;
+ value = (Math.sqrt(xDist * xDist + yDist * yDist + zDist * zDist)
+ ) * SQRT_3 - 1.0;
+ } else {
+ value = 0.0;
+ }
+
+ // Return the calculated distance with the displacement value applied.
+ return value + (displacement * (double)NoiseGen.ValueNoise3D (
+ (int)(Math.floor (xCandidate)),
+ (int)(Math.floor (yCandidate)),
+ (int)(Math.floor (zCandidate)), seed));// added seed here, not in original
+ // but there isn't a working method
+ // without seed
+ }
+
+ /// Enables or disables applying the distance from the nearest seed
+ /// point to the output value.
+ ///
+ /// @param enable Specifies whether to apply the distance to the
+ /// output value or not.
+ ///
+ /// Applying the distance from the nearest seed point to the output
+ /// value causes the points in the Voronoi cells to increase in value
+ /// the further away that point is from the nearest seed point.
+ /// Setting this value to @a true (and setting the displacement to a
+ /// near-zero value) causes this noise module to generate cracked mud
+ /// formations.
+ public void enableDistance (boolean enable)
+ {
+ enableDistance = enable;
+ }
+
+ /// Returns the displacement value of the Voronoi cells.
+ ///
+ /// @returns The displacement value of the Voronoi cells.
+ ///
+ /// This noise module assigns each Voronoi cell with a random constant
+ /// value from a coherent-noise function. The <i>displacement
+ /// value</i> controls the range of random values to assign to each
+ /// cell. The range of random values is +/- the displacement value.
+ public double getDisplacement ()
+ {
+ return displacement;
+ }
+
+ /// Returns the frequency of the seed points.
+ ///
+ /// @returns The frequency of the seed points.
+ ///
+ /// The frequency determines the size of the Voronoi cells and the
+ /// distance between these cells.
+ public double GetFrequency ()
+ {
+ return frequency;
+ }
+
+ /// Returns the seed value used by the Voronoi cells
+ ///
+ /// @returns The seed value.
+ ///
+ /// The positions of the seed values are calculated by a
+ /// coherent-noise function. By modifying the seed value, the output
+ /// of that function changes.
+ public int getSeed ()
+ {
+ return seed;
+ }
+
+ /// Determines if the distance from the nearest seed point is applied
+ /// to the output value.
+ ///
+ /// @returns
+ /// - @a true if the distance is applied to the output value.
+ /// - @a false if not.
+ ///
+ /// Applying the distance from the nearest seed point to the output
+ /// value causes the points in the Voronoi cells to increase in value
+ /// the further away that point is from the nearest seed point.
+ public boolean IsDistanceEnabled ()
+ {
+ return enableDistance;
+ }
+
+ /// Sets the displacement value of the Voronoi cells.
+ ///
+ /// @param displacement The displacement value of the Voronoi cells.
+ ///
+ /// This noise module assigns each Voronoi cell with a random constant
+ /// value from a coherent-noise function. The <i>displacement
+ /// value</i> controls the range of random values to assign to each
+ /// cell. The range of random values is +/- the displacement value.
+ public void setDisplacement (double displacement)
+ {
+ this.displacement = displacement;
+ }
+
+ /// Sets the frequency of the seed points.
+ ///
+ /// @param frequency The frequency of the seed points.
+ ///
+ /// The frequency determines the size of the Voronoi cells and the
+ /// distance between these cells.
+ public void setFrequency (double frequency)
+ {
+ this.frequency = frequency;
+ }
+
+ /// Sets the seed value used by the Voronoi cells
+ ///
+ /// @param seed The seed value.
+ ///
+ /// The positions of the seed values are calculated by a
+ /// coherent-noise function. By modifying the seed value, the output
+ /// of that function changes.
+ public void setSeed (int seed)
+ {
+ this.seed = seed;
+ }
+
+}
|