KochSnowflake.java

packagecom.thealgorithms.others;

importjava.awt.BasicStroke;
importjava.awt.Color;
importjava.awt.Graphics2D;
importjava.awt.image.BufferedImage;
importjava.io.File;
importjava.io.IOException;
importjava.util.ArrayList;
importjava.util.List;
importjavax.imageio.ImageIO;

/**
 * The Koch snowflake is a fractal curve and one of the earliest fractals to
 * have been described. The Koch snowflake can be built up iteratively, in a
 * sequence of stages. The first stage is an equilateral triangle, and each
 * successive stage is formed by adding outward bends to each side of the
 * previous stage, making smaller equilateral triangles. This can be achieved
 * through the following steps for each line: 1. divide the line segment into
 * three segments of equal length. 2. draw an equilateral triangle that has the
 * middle segment from step 1 as its base and points outward. 3. remove the line
 * segment that is the base of the triangle from step 2. (description adapted
 * from https://en.wikipedia.org/wiki/Koch_snowflake ) (for a more detailed
 * explanation and an implementation in the Processing language, see
 * https://natureofcode.com/book/chapter-8-fractals/
 * #84-the-koch-curve-and-the-arraylist-technique ).
 */
publicfinalclassKochSnowflake {
privateKochSnowflake() {
 }

publicstaticvoidmain(String[] args) {
// Test Iterate-method
ArrayList<Vector2> vectors = newArrayList<Vector2>();
vectors.add(newVector2(0, 0));
vectors.add(newVector2(1, 0));
ArrayList<Vector2> result = iterate(vectors, 1);

assertresult.get(0).x == 0;
assertresult.get(0).y == 0;

assertresult.get(1).x == 1. / 3;
assertresult.get(1).y == 0;

assertresult.get(2).x == 1. / 2;
assertresult.get(2).y == Math.sin(Math.PI / 3) / 3;

assertresult.get(3).x == 2. / 3;
assertresult.get(3).y == 0;

assertresult.get(4).x == 1;
assertresult.get(4).y == 0;

// Test GetKochSnowflake-method
intimageWidth = 600;
doubleoffsetX = imageWidth / 10.;
doubleoffsetY = imageWidth / 3.7;
BufferedImageimage = getKochSnowflake(imageWidth, 5);

// The background should be white
assertimage.getRGB(0, 0) == newColor(255, 255, 255).getRGB();

// The snowflake is drawn in black and this is the position of the first vector
assertimage.getRGB((int) offsetX, (int) offsetY) == newColor(0, 0, 0).getRGB();

// Save image
try {
ImageIO.write(image, "png", newFile("KochSnowflake.png"));
 } catch (IOExceptione) {
e.printStackTrace();
 }
 }

/**
 * Go through the number of iterations determined by the argument "steps".
 * Be careful with high values (above 5) since the time to calculate
 * increases exponentially.
 *
 * @param initialVectors The vectors composing the shape to which the
 * algorithm is applied.
 * @param steps The number of iterations.
 * @return The transformed vectors after the iteration-steps.
 */
publicstaticArrayList<Vector2> iterate(ArrayList<Vector2> initialVectors, intsteps) {
ArrayList<Vector2> vectors = initialVectors;
for (inti = 0; i < steps; i++) {
vectors = iterationStep(vectors);
 }

returnvectors;
 }

/**
 * Method to render the Koch snowflake to a image.
 *
 * @param imageWidth The width of the rendered image.
 * @param steps The number of iterations.
 * @return The image of the rendered Koch snowflake.
 */
publicstaticBufferedImagegetKochSnowflake(intimageWidth, intsteps) {
if (imageWidth <= 0) {
thrownewIllegalArgumentException("imageWidth should be greater than zero");
 }

doubleoffsetX = imageWidth / 10.;
doubleoffsetY = imageWidth / 3.7;
Vector2vector1 = newVector2(offsetX, offsetY);
Vector2vector2 = newVector2(imageWidth / 2.0, Math.sin(Math.PI / 3.0) * imageWidth * 0.8 + offsetY);
Vector2vector3 = newVector2(imageWidth - offsetX, offsetY);
ArrayList<Vector2> initialVectors = newArrayList<Vector2>();
initialVectors.add(vector1);
initialVectors.add(vector2);
initialVectors.add(vector3);
initialVectors.add(vector1);
ArrayList<Vector2> vectors = iterate(initialVectors, steps);
returngetImage(vectors, imageWidth, imageWidth);
 }

/**
 * Loops through each pair of adjacent vectors. Each line between two
 * adjacent vectors is divided into 4 segments by adding 3 additional
 * vectors in-between the original two vectors. The vector in the middle is
 * constructed through a 60 degree rotation so it is bent outwards.
 *
 * @param vectors The vectors composing the shape to which the algorithm is
 * applied.
 * @return The transformed vectors after the iteration-step.
 */
privatestaticArrayList<Vector2> iterationStep(List<Vector2> vectors) {
ArrayList<Vector2> newVectors = newArrayList<Vector2>();
for (inti = 0; i < vectors.size() - 1; i++) {
Vector2startVector = vectors.get(i);
Vector2endVector = vectors.get(i + 1);
newVectors.add(startVector);
Vector2differenceVector = endVector.subtract(startVector).multiply(1. / 3);
newVectors.add(startVector.add(differenceVector));
newVectors.add(startVector.add(differenceVector).add(differenceVector.rotate(60)));
newVectors.add(startVector.add(differenceVector.multiply(2)));
 }

newVectors.add(vectors.get(vectors.size() - 1));
returnnewVectors;
 }

/**
 * Utility-method to render the Koch snowflake to an image.
 *
 * @param vectors The vectors defining the edges to be rendered.
 * @param imageWidth The width of the rendered image.
 * @param imageHeight The height of the rendered image.
 * @return The image of the rendered edges.
 */
privatestaticBufferedImagegetImage(ArrayList<Vector2> vectors, intimageWidth, intimageHeight) {
BufferedImageimage = newBufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB);
Graphics2Dg2d = image.createGraphics();

// Set the background white
g2d.setBackground(Color.WHITE);
g2d.fillRect(0, 0, imageWidth, imageHeight);

// Draw the edges
g2d.setColor(Color.BLACK);
BasicStrokebs = newBasicStroke(1);
g2d.setStroke(bs);
for (inti = 0; i < vectors.size() - 1; i++) {
intx1 = (int) vectors.get(i).x;
inty1 = (int) vectors.get(i).y;
intx2 = (int) vectors.get(i + 1).x;
inty2 = (int) vectors.get(i + 1).y;

g2d.drawLine(x1, y1, x2, y2);
 }

returnimage;
 }

/**
 * Inner class to handle the vector calculations.
 */
privatestaticclassVector2 {

doublex;
doubley;

Vector2(doublex, doubley) {
this.x = x;
this.y = y;
 }

@Override
publicStringtoString() {
returnString.format("[%f, %f]", this.x, this.y);
 }

/**
 * Vector addition
 *
 * @param vector The vector to be added.
 * @return The sum-vector.
 */
publicVector2add(Vector2vector) {
doublex = this.x + vector.x;
doubley = this.y + vector.y;
returnnewVector2(x, y);
 }

/**
 * Vector subtraction
 *
 * @param vector The vector to be subtracted.
 * @return The difference-vector.
 */
publicVector2subtract(Vector2vector) {
doublex = this.x - vector.x;
doubley = this.y - vector.y;
returnnewVector2(x, y);
 }

/**
 * Vector scalar multiplication
 *
 * @param scalar The factor by which to multiply the vector.
 * @return The scaled vector.
 */
publicVector2multiply(doublescalar) {
doublex = this.x * scalar;
doubley = this.y * scalar;
returnnewVector2(x, y);
 }

/**
 * Vector rotation (see https://en.wikipedia.org/wiki/Rotation_matrix)
 *
 * @param angleInDegrees The angle by which to rotate the vector.
 * @return The rotated vector.
 */
publicVector2rotate(doubleangleInDegrees) {
doubleradians = angleInDegrees * Math.PI / 180;
doubleca = Math.cos(radians);
doublesa = Math.sin(radians);
doublex = ca * this.x - sa * this.y;
doubley = sa * this.x + ca * this.y;
returnnewVector2(x, y);
 }
 }
}