- Complete refactor.

 - Works, but it seems as though it's drawing far too many lines. Also performance...

Author: tildebyte

nightSky/nightSky.pyde

@@ -1,82 +1,31 @@
 # http://patakk.tumblr.com / nightSky
 from point import Point
-# from line import Line
 
 
+SketchWidth = 700
+SketchHeight = 300
+Point.HalfWidth = SketchWidth / 2
+Point.HalfHeight = SketchHeight / 2
+Point.HalfDist = dist(0, 0, Point.HalfWidth, Point.HalfHeight)
+MagicNumber = dist(0, 0, 960, 540)
+NumPoints = (500.0 * Point.HalfDist / MagicNumber)
+Point.Limit = (160.0 * Point.HalfDist / MagicNumber)
 points = []
-lines = []
-NumPoints = 0
-Limit = 0
-HalfWidth = 0
-HalfHeight = 0
-HalfDist = 0
-I_Dont_Know_What_This_Is = dist(0, 0, 960, 540)
+
 
 def setup():
-    global points, HalfWidth, HalfHeight, HalfDist, NumPoints, Limit
-    size(700, 300)
+    global points
+    size(SketchWidth, SketchHeight)
     background(0)
     smooth()
     strokeWeight(0.8)
-    HalfWidth = width / 2
-    HalfHeight = height / 2
-    HalfDist = dist(0, 0, HalfWidth, HalfHeight)
-    NumPoints = (500.0 * HalfDist / I_Dont_Know_What_This_Is)
-    Limit = (160.0 * HalfDist / I_Dont_Know_What_This_Is)
-    # n = 0
-    # noiseSeed(5)
-    # randomSeed(1200)
-    # makePoint()
-    points = [makePoint() for _ in range(NumPoints)]
-    for point1 in points:
-        x1 = point1.startX
-        y1 = point1.startY
-        for point2 in points:
-            x2 = point2.startX
-            y2 = point2.startY
-            if dist(x1, y1, x2, y2) < Limit / 3:
-                lines.append(PVector(points.index(point1),
-                                     points.index(point2)))
-
-def makePoint():
-    while True:
-        randX = random(HalfWidth * 0.74) + random(40)
-        randY = random(HalfHeight * 0.84) + random(40)
-        angle = random(2 * PI)
-        startX = randX * cos(angle)
-        startY = randY * sin(angle)
-        dx = map(startX,
-                 0, HalfWidth, 0, 1.15)
-        dy = map(startY,
-                 0, HalfHeight, 0, 1.35)
-        prob = pow(2.72, -(dx**2 * 2 + dy**2 * 2))
-        if random(1) < prob:
-            return(Point(startX, startY))
+    points = [Point(index) for index in range(NumPoints)]
+    for _point in points:
+        _point.setLines(points)
 
 
 def draw():
     background(0)
-    translate(HalfWidth, HalfHeight)
+    translate(Point.HalfWidth, Point.HalfHeight)
     for _point in points:
-        _point.update(frameCount)
-    for _line in lines:
-        x1 = points[int(_line.x)].x
-        y1 = points[int(_line.x)].y
-        x2 = points[int(_line.y)].x
-        y2 = points[int(_line.y)].y
-        plusX = x1 + x2 / 2
-        plusY = y1 + y2 / 2
-        mouseWrapX = mouseX - HalfWidth
-        mouseWrapY = mouseY - HalfHeight
-        amp = (map(dist(plusX, plusY, 0, 0),
-                   0, HalfDist, 2, 8))
-        distance = (map(noise(plusX * 0.03, plusY * 0.03),
-                        0, 1, 5, Limit / 2))
-        if dist(plusX, plusY, mouseWrapX, mouseWrapY) < Limit:
-            distance = (distance * map(dist(plusX, plusY, mouseWrapX, mouseWrapY),
-                                       0, Limit, amp, 1))
-        if dist(x1, y1, x2, y2) < distance:
-            opacity = map(dist(x1, y1, x2, y2),
-                          0, distance, 85, 0)
-            stroke(255, opacity)
-            line(x1, y1, x2, y2)
+        _point.update(frameCount, points)

nightSky/point.py

@@ -1,7 +1,13 @@
 class Point(object):
-    def __init__(self, startX, startY):
-        self.startX = startX
-        self.startY = startY
+    HalfWidth = 0
+    HalfHeight = 0
+    HalfDist = 0
+    Limit = 0
+
+    def __init__(self, index):
+        self.index = index
+        self.startX = 0
+        self.startY = 0
         self.rnd = random(5, 30)
         self.diameter = map(self.rnd, 5, 30, 0.5, 2)
         if random(1) > 0.5:
@@ -11,8 +17,39 @@ def __init__(self, startX, startY):
         self.phi = random(360)
         self.x = 0
         self.y = 0
+        self.lines = []
+        self.makePoint()
+
+    def makePoint(self):
+        while True:
+            randX = random(Point.HalfWidth * 0.74) + random(40)
+            randY = random(Point.HalfHeight * 0.84) + random(40)
+            angle = random(2 * PI)
+            initX = randX * cos(angle)
+            initY = randY * sin(angle)
+            dx = map(initX,
+                     0, Point.HalfWidth, 0, 1.15)
+            dy = map(initY,
+                     0, Point.HalfHeight, 0, 1.35)
+            prob = pow(2.72, -(dx**2 * 2 + dy**2 * 2))
+            if random(1) < prob:
+                self.startX = initX
+                self.startY = initY
+                return
+
+    def setLines(self, others):
+        # for other in others:
+        #     if (self is not other
+        #             and dist(self.x, self.y, other.x, other.y) < Limit / 3):
+        #         lines.append(PVector(self.index,
+        #                              other.index))
+        thirdLimit = Point.Limit / 3
+        self.lines = [other.index
+                      for other in others
+                      if (self is not other
+                          and dist(self.x, self.y, other.x, other.y) < thirdLimit)]
 
-    def update(self, time):
+    def update(self, time, others):
         if self.rt:
             self.x = self._calc(self.startX, cos, time)
             self.y = self._calc(self.startY, sin, time)
@@ -22,7 +59,29 @@ def update(self, time):
         noStroke()
         fill(255)
         ellipse(self.x, self.y, self.diameter, self.diameter)
+        self.drawLines(others)
 
+    def drawLines(self, others):
+        halfLimit = Point.Limit / 2
+        for other in others:
+            if (self is not other
+                    and other.index in self.lines):
+                plusX = self.x + other.x * 0.5
+                plusY = self.y + other.y * 0.5
+                mouseWrapX = mouseX - Point.HalfWidth
+                mouseWrapY = mouseY - Point.HalfHeight
+                amp = (map(dist(plusX, plusY, 0, 0),
+                           0, Point.HalfDist, 2, 8))
+                distance = (map(noise(plusX * 0.03, plusY * 0.03),
+                                0, 1, 5, halfLimit))
+                if dist(plusX, plusY, mouseWrapX, mouseWrapY) < Point.Limit:
+                    distance = (distance * map(dist(plusX, plusY, mouseWrapX, mouseWrapY),
+                                               0, Point.Limit, amp, 1))
+                if dist(self.x, self.y, other.x, other.y) < distance:
+                    opacity = map(dist(self.x, self.y, other.x, other.y),
+                                  0, distance, 85, 0)
+                    stroke(255, opacity)
+                    line(self.x, self.y, other.x, other.y)
 
     def _calc(self, coord, func, time):
         return coord + self.rnd * func(radians(time * self.diameter + self.phi))