GV

GeezerVison

The World Wide Web, restored to 800 pixels of glory.

Home|About|Gaming cabinet|Archives|How it works|Starter sites

On this site

  • Sign in
  • ActionsCI/CD and automation
  • CodespacesCloud development environments
  • All Features
  • Documentation
  • Training
  • Certifications
  • Build with Copilot
  • Customize Copilot
  • Integrations
  • Trending repos
  • GitHub Sponsors
  • Developer articles
  • Enterprises

This view

  • Original page
  • New address

GeezerVison is showing github.com — JavaScript/Recursive/KochSnowflake.js at master · hackingstaar/JavaScript

Expand file tree

/

KochSnowflake.js

Copy path
More file actions
More file actions

Latest commit

 

History

History
History
118 lines (109 loc) · 3.76 KB
/

KochSnowflake.js

Copy path

File metadata and controls

118 lines (109 loc) · 3.76 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
/**
* 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).
*/
/** Class to handle the vector calculations. */
export class Vector2 {
constructor(x, y) {
this.x = x
this.y = y
}
/**
* Vector addition
*
* @param vector The vector to be added.
* @returns The sum-vector.
*/
add(vector) {
const x = this.x + vector.x
const y = this.y + vector.y
return new Vector2(x, y)
}
/**
* Vector subtraction
*
* @param vector The vector to be subtracted.
* @returns The difference-vector.
*/
subtract(vector) {
const x = this.x - vector.x
const y = this.y - vector.y
return new Vector2(x, y)
}
/**
* Vector scalar multiplication
*
* @param scalar The factor by which to multiply the vector.
* @returns The scaled vector.
*/
multiply(scalar) {
const x = this.x * scalar
const y = this.y * scalar
return new Vector2(x, y)
}
/**
* Vector rotation (see https://en.wikipedia.org/wiki/Rotation_matrix)
*
* @param angleInDegrees The angle by which to rotate the vector.
* @returns The rotated vector.
*/
rotate(angleInDegrees) {
const radians = (angleInDegrees * Math.PI) / 180
const ca = Math.cos(radians)
const sa = Math.sin(radians)
const x = ca * this.x - sa * this.y
const y = sa * this.x + ca * this.y
return new Vector2(x, y)
}
}
/**
* 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.
* @returns The transformed vectors after the iteration-steps.
*/
export function iterate(initialVectors, steps) {
let vectors = initialVectors
for (let i = 0; i < steps; i++) {
vectors = iterationStep(vectors)
}
return vectors
}
/**
* 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.
* @returns The transformed vectors after the iteration-step.
*/
function iterationStep(vectors) {
const newVectors = []
for (let i = 0; i < vectors.length - 1; i++) {
const startVector = vectors[i]
const endVector = vectors[i + 1]
newVectors.push(startVector)
const differenceVector = endVector.subtract(startVector).multiply(1 / 3)
newVectors.push(startVector.add(differenceVector))
newVectors.push(
startVector.add(differenceVector).add(differenceVector.rotate(60))
)
newVectors.push(startVector.add(differenceVector.multiply(2)))
}
newVectors.push(vectors[vectors.length - 1])
return newVectors
}
You are visitor 01402520 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.