Tarbell's #003 A fully working, albeit very slowly.

Process sketches commits.
Hodgin's #003 A partially working.
Process sketches need docstring updates.

Author: tildebyte

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

@@ -46,9 +46,9 @@ void setup()
   background(bgColor);
   smooth();
   colorMode(RGB, 255);
-  ellipseMode(CENTER_RADIUS);
+  ellipseMode(RADIUS);
   noStroke();
-  framerate(30);
+  frameRate(30);
   createCircles();
 }
 
@@ -273,7 +273,7 @@ class Circle
         vertex(x - xd*.75 + random(-1.0,1.0), y - yd*.75 + random(-1.0,1.0));
         vertex(circle[i].x, circle[i].y);
         endShape();
-        //line (x, y, circle[i].x, circle[i].y);
+        line (x, y, circle[i].x, circle[i].y);
       }
     }
     noStroke();

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

@@ -13,6 +13,7 @@
 """
 from disc import Disc
 
+
 # Object array.
 discs = []
 num = 100
@@ -50,3 +51,18 @@ def draw():
         disc.drawSelf()
         disc.render(discs)
         disc.renderPxRiders()
+
+def boundsCheck(x, y, pad):
+    constrainedX = constrain(x, -pad, width + pad)
+    constrainedY = constrain(y, -pad, height + pad)
+    if constrainedX != x:
+        if x < 0:
+            return False
+        else:
+            x = True
+    if constrainedY != y:
+        if y < 0:
+            y = height + pad * 2
+        else:
+            y = -pad
+    return x, y

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

@@ -1,6 +1,5 @@
 from pxrider import PxRider
 
-
 # Disc object.
 class Disc(object):
     def __init__(self, index, x, y, velocityX, velocityY, destRadius):
@@ -60,17 +59,18 @@ def move(self):
         # Add velocity to position.
         self.x += self.velocityX
         self.y += self.velocityY
-        bound = width + self.radius * 2
+        boundWidth = width + self.radius * 2
+        boundHeight = height + self.radius * 2
 
         # Bound check.
         if self.x + self.radius < 0:
-            self.x += bound
+            self.x += boundWidth
         if self.x - self.radius > width:
-            self.x -= bound
+            self.x -= boundWidth
         if self.y + self.radius < 0:
-            self.y += bound
+            self.y += boundHeight
         if self.y - self.radius > width:
-            self.y -= bound
+            self.y -= boundHeight
 
         # Increase to destination radius.
         if self.radius < self.destRadius:

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

@@ -1,6 +1,5 @@
 # Pixel Rider object.
 class PxRider(object):
-
     def __init__(self):
         self.theta = random(TAU)
         self.deltaV = 0.0
@@ -18,30 +17,32 @@ def move(self, x, y, radius):
         # Draw.
         px = x + radius * cos(self.theta)
         py = y + radius * sin(self.theta)
-        # color = get(px, py)
-        loadPixels()
-        color = pixels[int(px) + int(py) * height]
-        if brightness(color) > 48:
-            self.glowpoint(px, py)
+        screenColor = get(int(px), int(py))
+        # loadPixels()
+        # screenColor = pixels[int(py) * this.width + int(px)]
+        if brightness(screenColor) > 48:
+            PxRider.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):
+    @classmethod
+    def glowpoint(cls, 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)
+                PxRider.tpoint(px + i, py + j, '#FFFFFF', a)
+
+    @classmethod
+    def tpoint(cls, x, y, myColor, trans):
+        # Place translucent point.
+        screenColor = get(int(x), int(y))
+        # loadPixels()
+        # screenColor = pixels[int(y) * this.width + int(x)]
+        r = red(screenColor) + (red(myColor) - red(screenColor)) * trans
+        g = green(screenColor) + (green(myColor) - green(screenColor)) * trans
+        b = blue(screenColor) + (blue(myColor) - blue(screenColor)) * trans
+        stroke(color(r, g, b))
+        point(x, y)

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

@@ -21,9 +21,10 @@ circles = None
 
 def setup():
     size(800, 600)
-    circles = [Circle(random(width), height / NumCircles * i,
+    circles = [Circle(i, random(width), height / NumCircles * i,
                       (random(1, 6)) * 10, random(-1.0, 1.0),
-                      random(-1.0, 1.0), i) for i in range(NumCircles)]
+                      random(-1.0, 1.0))
+               for i in range(NumCircles)]
     strokeWeight(0.5)
     ellipseMode(CENTER)
     background(255)
@@ -35,5 +36,5 @@ def draw():
     for circle in circles:
         circle.update(circles)
         circle.move()
-        circle.makepoint()
+        circle.drawSelf()
     noFill()

Whitney Artport - (Software) Structures/#003/A/Number_003_A/circle.py

@@ -1,12 +1,12 @@
 class Circle(object):
     '''A circle object'''
 
-    def __init__(self, centerX, centerY, radius, xspeed, yspeed, index):
-        self.centerX = centerX
-        self.centerY = centerY
+    def __init__(self, index, x, y, radius, xspeed, yspeed):
+        self.index = index
+        self.x = x
+        self.y = y
         self.radius = radius
         self.rSqr = self.radius**2
-        self.index = index
         self.xspeed = xspeed
         self.yspeed = yspeed
 
@@ -15,36 +15,49 @@ def update(self, circles):
             if circle.index != self.index:
                 self.intersect(circle)
 
-    def makepoint(self):
+    def drawSelf(self):
         stroke(0)
-        point(self.centerX, self.centerY)
+        point(self.x, self.y)
 
     def move(self):
-        self.centerX += self.xspeed
-        self.centerY += self.yspeed
-        if self.xspeed > 0 and self.centerX > width + self.radius:
-                self.centerX = -self.radius
-        elif self.centerX < -self.radius:
-                self.centerX = width + self.radius
-        if self.yspeed > 0 and self.centerY > height + self.radius:
-                self.centerY = -self.radius
-        elif self.centerY < -self.radius:
-                self.centerY = height + self.radius
+        self.x += self.xspeed
+        self.y += self.yspeed
+        if self.xspeed > 0 and self.x > width + self.radius:
+            self.x = -self.radius
+        elif self.x < -self.radius:
+            self.x = width + self.radius
+        if self.yspeed > 0 and self.y > height + self.radius:
+            self.y = -self.radius
+        elif self.y < -self.radius:
+            self.y = height + self.radius
 
     def intersect(self, other):
-        dx = self.centerX - other.centerX
-        dy = self.centerY - other.centerY
-        dSqr = dx**2 + dy**2
-        diameter = sqrt(dSqr)
-        if diameter > self.radius + other.radius or diameter < abs(self.radius - other.radius):
-            return  # no solution
-        a = (self.rSqr - other.rSqr + dSqr) / (2 * diameter)
-        h = sqrt(self.rSqr - a**2)
-        x2 = self.centerX + a * (other.centerX - self.centerX) / diameter
-        y2 = self.centerY + a * (other.centerY - self.centerY) / diameter
-        paX = x2 + h * (other.centerY - self.centerY) / diameter
-        paY = y2 - h * (other.centerX - self.centerX) / diameter
-        pbX = x2 - h * (other.centerY - self.centerY) / diameter
-        pbY = y2 + h * (other.centerX - self.centerX) / diameter
-        stroke(255 - dist(paX, paY, pbX, pbY) * 4)
-        line(paX, paY, pbX, pbY)
+        distance = dist(self.x, self.y, other.x, other.y)
+        if (distance > self.radius + other.radius
+                or distance < abs(self.radius - other.radius)):
+            return  # No solution.
+        a = (self.rSqr - other.rSqr + distance**2) / (2 * distance)
+        hyp = sqrt(self.rSqr - a**2)
+        midpointX = Circle.calc2(self.x, '+', a, Circle.calc1(other.x, self.x, distance))
+        midpointY = Circle.calc2(self.y, '+', a, Circle.calc1(other.y, self.y, distance))
+        pointAX = Circle.calc2(midpointX, '+', hyp, Circle.calc1(other.y, self.y, distance))
+        pointAY = Circle.calc2(midpointY, '-', hyp, Circle.calc1(other.x, self.x, distance))
+        pointBX = Circle.calc2(midpointX, '-', hyp, Circle.calc1(other.y, self.y, distance))
+        pointBY = Circle.calc2(midpointY, '+', hyp, Circle.calc1(other.x, self.x, distance))
+        Circle.renderIntersect(midpointX, midpointY, pointAX, pointAY, pointBX, pointBY)
+
+    @classmethod
+    def renderIntersect(cls, midpointX, midpointY, pointAX, pointAY, pointBX, pointBY):
+        stroke(255 - dist(pointAX, pointAY, pointBX, pointBY) * 4)
+        line(pointAX, pointAY, pointBX, pointBY)
+
+    @classmethod
+    def calc1(cls, first, second, distance):
+        return (first - second) / distance
+
+    @classmethod
+    def calc2(cls, first, operation, second, function):
+        if operation == '+':
+            return first + second * function
+        elif operation == '-':
+            return first - second * function

Whitney Artport - (Software) Structures/#003/Process/s3_process_1/s3_process_1.pde

@@ -4,8 +4,10 @@
 // Modified by Casey Reas
 
 
+
 Circle circleA, circleB;
 
+
 void setup()
 {
   size( 300, 300 );

Whitney Artport - (Software) Structures/#003/Process/s3_process_1/s3_process_1.pyde

@@ -11,7 +11,7 @@ circleB = None
 
 
 def setup():
-    size(300, 300)
+    size(800, 800)
     frameRate(30)
     circleA = Circle(150, 150, 50)
     circleB = Circle(150, 150, 60)
@@ -52,10 +52,10 @@ def intersect(circleA, circleB):
     pointAY = calc2(midpointY, '-', hyp, calc1(circleB.x, circleA.x, distance))
     pointBX = calc2(midpointX, '-', hyp, calc1(circleB.y, circleA.y, distance))
     pointBY = calc2(midpointY, '+', hyp, calc1(circleB.x, circleA.x, distance))
-    render(midpointX, midpointY, pointAX, pointAY, pointBX, pointBY)
+    renderIntersect(midpointX, midpointY, pointAX, pointAY, pointBX, pointBY)
 
 
-def render(midpointX, midpointY, pointAX, pointAY, pointBX, pointBY):
+def renderIntersect(midpointX, midpointY, pointAX, pointAY, pointBX, pointBY):
     fill(0)
     rect(midpointX, midpointY, 5, 5)
     ellipse(pointAX, pointAY, 10, 10)