Tarbell Number 3 now 100% more runnable; Java version complete.

Author: tildebyte

Whitney Artport - (Software) Structures/#003/A/Interpretation/Number_003_A_Tarbell/Number_003_A_Tarbell.pde

@@ -20,9 +20,11 @@ Disc[] discs;
 // initialization
 void setup()
 {
-    size(500, 500);
+    size(500, 500, P2D);
+    colorMode(RGB,255);
     ellipseMode(RADIUS);
     background(0);
+    frameRate(30);
 
     // make some discs
     discs = new Disc[num];
@@ -95,7 +97,7 @@ class Disc
     }
 
     void drawSelf() {
-        stroke(128, 50);
+        stroke(0, 50);
         noFill();
         ellipse(x, y, r, r);
     }
@@ -176,7 +178,6 @@ class Disc
         PxRider() {
             t = random(TAU);
             vt = 0.0;
-            mycharge = 64.0;
         }
 
         void move(float x, float y, float r) {
@@ -193,14 +194,14 @@ class Disc
             // draw
             float px = x + r * cos(t);
             float py = y + r * sin(t);
-            // color c = get(int(px),int(py));
-            loadPixels();
-            color c = pixels[int(px) + int(py) * height];
+            color c = get(int(px),int(py));
+//            loadPixels();
+//            color c = pixels[int(px) + int(py) * height];
             if (brightness(c) > 48) {
                 glowpoint(px, py);
                 mycharge = 164;
             } else {
-                stroke(int(mycharge));
+                stroke(mycharge);
                 point(px, py);
                 mycharge *= 0.98;
             }
@@ -227,9 +228,9 @@ void tpoint(int x1, int y1, color myc, float a)
     int r, g, b;
     color c;
 
-    // c = get(x1, y1);
-    loadPixels();
-    c = pixels[x1 + y1 * height];
+    c = get(x1, y1);
+//    loadPixels();
+//    c = pixels[x1 + y1 * height];
 
     r = int(red(c) + (red(myc) - red(c)) * a);
     g = int(green(c) + (green(myc) - green(c)) * a);

Whitney Artport - (Software) Structures/#003/A/Interpretation/Number_003_A_Tarbell/Number_003_A_Tarbell.pyde

@@ -11,33 +11,34 @@
 
     Port to Processing.py/Processing 2.0 by Ben Alkov 16 June 2014
 """
+from disc import Disc
+
 num = 100
-time = 0
 
 # Object array.
-# Disc[] discs
+discs = []
 
 
 # Initialization.
 def setup():
     size(500, 500)
     colorMode(RGB, 255)
-    ellipseMode(CENTER_RADIUS)
+    ellipseMode(RADIUS)
     background(0)
+    frameRate(30)
 
     # Make some discs.
-    discs = Disc[num]
     # Arrange in anti - collapsing circle.
-    for i in range(numi):
-        fx = 0.4 * width * cos(TWO_PI * i / num)
-        fy = 0.4 * width * sin(TWO_PI * i / num)
+    for i in range(num):
+        fx = 0.4 * width * cos(TAU * i / num)
+        fy = 0.4 * width * sin(TAU * i / num)
         x = random(width / 2) + fx
         y = random(width / 2) + fy
         r = 5 + random(45)
         bt = 1
         if random(100) < 50:
             bt = -1
-        discs[i] = Disc(i, x, y, bt * fx / 1000.0, bt * fy / 1000.0, r)
+        discs.append(Disc(i, x, y, bt * fx / 1000.0, bt * fy / 1000.0, r))
 
 
 # Main.
@@ -50,22 +51,3 @@ def draw():
         disc.drawSelf()
         disc.render(discs)
         disc.renderPxRiders()
-
-
-# Methods.
-def glowpoint(px, py):
-    for i in range(-2, 3):
-        for j in range(-2, 3):
-            a = (0.8 - i**2 * 0.1) - j**2 * 0.1
-            tpoint(px + i, py + j, '#FFFFFF', a)
-
-
-def tpoint(x1, y1, myc, a):
-    # Place translucent point.
-    c = get(x1, y1)
-    r = red(c) + (red(myc) - red(c)) * a
-    g = green(c) + (green(myc) - green(c)) * a
-    b = blue(c) + (blue(myc) - blue(c)) * a
-    nc = color(r, g, b)
-    stroke(nc)
-    point(x1, y1)

Whitney Artport - (Software) Structures/#003/A/Interpretation/Number_003_A_Tarbell/disc.py

@@ -1,24 +1,27 @@
+from pxrider import PxRider
+
+
 # Disc object.
 class Disc(object):
     def __init__(self, index, centerX, centerY, vx, vy, destinationRadius):
         # Identifier.
-        self.id = index
+        self.index = index
 
         # Position.
         self.centerX = centerX
         self.centerY = centerY
 
         # Velocity.
-        vx = vx
-        vy = vy
+        self.vx = vx
+        self.vy = vy
 
         # Radius.
         self.destinationRadius = destinationRadius
         self.radius = 0
 
         # Create pixel riders.
         maxRiders = 40
-        pxRiders = [PxRider() for _ in range(maxRiders)]
+        self.pxRiders = [PxRider() for _ in range(maxRiders)]
 
     def drawSelf(self):
         stroke(0, 50)
@@ -55,9 +58,9 @@ def render(self, discs):
 
     def move(self):
         # Add velocity to position.
-        self.centerX += vx
-        self.centerY += vy
-        bound = width + self.radius + self.radius
+        self.centerX += self.vx
+        self.centerY += self.vy
+        bound = width + self.radius * 2
 
         # Bound check.
         if self.centerX + self.radius < 0:
@@ -74,5 +77,5 @@ def move(self):
             self.radius += 0.1
 
     def renderPxRiders(self):
-        for pxRider in pxRiders:
+        for pxRider in self.pxRiders:
             pxRider.move(self.centerX, self.centerY, self.radius)

Whitney Artport - (Software) Structures/#003/A/Interpretation/Number_003_A_Tarbell/pxrider.py

@@ -6,6 +6,7 @@ def __init__(self):
         self.deltaV = 0.0
         self.charge = 0
 
+    # Methods.
     def move(self, x, y, radius):
         # Add velocity to theta.
         self.theta = (self.theta + self.deltaV + PI) % TAU - PI
@@ -18,11 +19,30 @@ def move(self, x, y, radius):
         # Draw.
         px = x + radius * cos(self.theta)
         py = y + radius * sin(self.theta)
-        color = get(px, py)
+        # color = get(px, py)
+        loadPixels()
+        color = pixels[int(px) + int(py) * height]
         if brightness(color) > 48:
-            glowpoint(px, py)
+            self.glowpoint(px, py)
             self.charge = 164
         else:
             stroke(self.charge)
             point(px, py)
             self.charge *= 0.98
+
+    def tpoint(x, y, myColor, trans):
+        # Place translucent point.
+        # color = get(x, y)
+        loadPixels()
+        color = pixels[x + y * height]
+        r = red(color) + (red(myColor) - red(color)) * trans
+        g = green(color) + (green(myColor) - green(color)) * trans
+        b = blue(color) + (blue(myColor) - blue(color)) * trans
+        stroke(color(r, g, b))
+        point(x, y)
+
+    def glowpoint(px, py):
+        for i in range(-2, 3):
+            for j in range(-2, 3):
+                a = (0.8 - i**2 * 0.1) - j**2 * 0.1
+                self.tpoint(px + i, py + j, '#FFFFFF', a)