Mass update

Yeah, so much for incremental

Author: tildebyte

3rd party/Class instance list example/Class instance list example.pyde

@@ -0,0 +1,28 @@
+"""
+Handles.
+
+Click and drag the white boxes to change their position.
+"""
+from handle import Handle
+
+
+def setup():
+    size(640, 360)
+    num = height / 15
+    hsize = 10
+    for i in range(num):
+        Handle(width / 2, 10 + i * 15, 50 - hsize / 2, 10)
+
+
+def draw():
+    background(153)
+    for h in Handle.handles:
+        h.update()
+        h.display()
+    fill(0)
+    rect(0, 0, width / 2, height)
+
+
+def mouseReleased():
+    for h in Handle.handles:
+        h.releaseEvent()

3rd party/Class instance list example/handle.py

@@ -0,0 +1,60 @@
+class Handle(object):
+
+    handles = []
+
+    def __init__(self, x, y, stretch, size):
+        self.x = x
+        self.y = y
+        self.stretch = stretch
+        self.size = size
+        self.boxX = self.x + self.stretch - self.size / 2
+        self.boxY = self.y - self.size / 2
+        self.over = False
+        self.press = False
+        self.locked = False
+        self.othersLocked = False
+        Handle.handles.append(self)
+
+    def update(self):
+        self.boxX = self.x + self.stretch
+        self.boxY = self.y - self.size / 2
+
+        self.othersLocked = False
+        for handle in Handle.handles:
+            if handle.locked:
+                self.othersLocked = True
+                break
+        if not self.othersLocked:
+            self.overEvent()
+            self.pressEvent()
+        if self.press:
+            self.stretch = constrain(mouseX - width / 2 - self.size / 2,
+                                     0, width / 2 - self.size - 1)
+
+    def overEvent(self):
+        self.over = overRect(self.boxX, self.boxY, self.size, self.size)
+
+    def pressEvent(self):
+        if self.over and mousePressed or self.locked:
+            self.press = True
+            self.locked = True
+        else:
+            self.press = False
+
+    def releaseEvent(self):
+        self.locked = False
+
+    def display(self):
+        line(self.x, self.y, self.x + self.stretch, self.y)
+        fill(255)
+        stroke(0)
+        rect(self.boxX, self.boxY, self.size, self.size)
+        if self.over or self.press:
+            line(self.boxX, self.boxY,
+                 self.boxX + self.size, self.boxY + self.size)
+            line(self.boxX, self.boxY + self.size,
+                 self.boxX + self.size, self.boxY)
+
+
+def overRect(x, y, width, height):
+    return x <= mouseX <= x + width and y <= mouseY <= y + height

Crawlers/Crawlers.pyde

@@ -0,0 +1,44 @@
+from crawler import Crawler
+
+# TODO:
+# - Get Width, Height from image.
+
+Width = 1024
+Height = 680
+HalfWidth = Width / 2.0
+HalfHeight = Height / 2.0
+Crawler.HalfWidth = HalfWidth
+Crawler.HalfHeight = HalfHeight
+NumCrawlers = 30
+
+
+def rightHanded():
+    # Fix flippin' coordinate system.
+    # Not the *same* as right-handed, but good enough.
+    # `-Z` comes out of the screen.
+    rotateX(TAU / 2)  # Positive `Y` up.
+    translate(HalfWidth, -HalfHeight, 0)  # Centered.
+
+
+def update():
+    for c in Crawler.instances:
+        c.imgColor = img.pixels[int((c.position.y * Width)) + int(c.position.x)]
+        c.update()
+
+
+def setup():
+    global img
+    size(Width, Height, P3D)
+    img = loadImage('_DSC5309.jpg')
+    img.loadPixels()
+    noStroke()
+    background(128)
+    colorMode(HSB, 360, 100, 100)
+    rightHanded()
+    for _ in range(NumCrawlers):
+        Crawler()
+
+
+def draw():
+    rightHanded()
+    update()

Crawlers/crawler.py

@@ -0,0 +1,41 @@
+
+class Crawler(object):
+
+    HalfWidth = 0
+    HalfHeight = 0
+    instances = []
+
+    def __init__(self):
+        self.position = self.rndPositionVector()
+        self.velocity = PVector(0, 0)
+        self.accel = PVector(0, 0)
+        self.color = color(0, 0, 100)
+        # This property keeps us from needing a global.
+        self.imgColor = self.color
+        self.instances.append(self)
+
+    def rndPositionVector(self):
+        x = int(random(-self.HalfWidth, self.HalfWidth))
+        y = int(random(-self.HalfHeight, self.HalfHeight))
+        return PVector(x, y)
+
+    def update(self):
+        # Image pixel's saturation becomes crawler's brightness.
+        self.color = color(0, 0, saturation(self.imgColor))
+        self.velocity = PVector.fromAngle(hue(self.imgColor))
+        # Thanks to Shiffman's NOC!
+        b = brightness(self.imgColor)
+        if b <= 50:
+            self.accel.add = b / -10
+        else:
+            self.accel.add = b / 10
+        self.velocity.add(self.accel)
+        self.position.add(self.velocity)
+        self.display()
+
+    def display(self):
+        fill(self.color)
+        # point(self.position.x, self.position.y)
+        # print('self.position.x = {0}, self.position.y = {1}'
+        #       .format(self.position.x, self.position.y))
+        ellipse(self.position.x, self.position.y, 2, 2)

Crawlers/data/Color-map-icon.png

@@ -0,0 +1,42 @@
+from square import Square
+
+
+baseRadius = 75.0
+angleDelta = 5.08
+radiusDelta = 1.618
+levels = 4
+
+
+def setup():
+    size(512, 512, P2D)
+    global halfWidth, halfHeight, baseSquare, baseLocation
+    noLoop()
+    rectMode(CENTER)
+    shapeMode(CENTER)
+    halfWidth = width / 2.0
+    halfHeight = height / 2.0
+    baseLocation = PVector(halfWidth, height - baseRadius)
+    baseSquare = Square(baseRadius, position=baseLocation)
+    baseSquare.display()
+
+
+# base = Square.squares[0]
+# odd indices are RH
+# even indices are LH
+def draw():
+    # Append two squares to the list each time through the loop
+    for i in range(1, levels):
+        Square(baseRadius / (radiusDelta * i),
+               PVector(Square.squares[i - 1].position.x,
+                       Square.squares[i - 1].position.y
+                       - Square.squares[i - 1].radius),
+               angleDelta * i)
+        Square(baseRadius / (radiusDelta * i),
+               PVector(Square.squares[i - 1].position.x,
+                       Square.squares[i - 1].position.y
+                       - Square.squares[i - 1].radius),
+               angleDelta * i)
+    for s in Square.squares:
+        print('Index: {0}, rotation: {1}'
+              .format(Square.squares.index(s), s.rotation))
+        s.display()

Crawlers/data/_DSC5309.jpg

@@ -0,0 +1,36 @@
+class Square(object):
+    ''' '''
+    squares = []
+
+    def __init__(self, radius=1, position=PVector(0, 0),
+                 rotation=0):
+        Square.squares.append(self)
+        self.radius = radius
+        self.dia = 2 * self.radius
+        self.shape = createShape()
+        self.position = position
+        if Square.squares.index(self) == 0:
+            self.color = color(0)  # black
+            self.rotation = rotation
+        elif Square.squares.index(self) % 2 != 0:
+            self.color = color(255, 0, 0)  # red
+            self.rotation = rotation
+        elif Square.squares.index(self) % 2 == 0:
+            self.color = color(0, 0, 255)  # blue
+            self.rotation = rotation
+        self.makeSelf()
+
+    def makeSelf(self):
+        self.shape.beginShape(QUADS)
+        self.shape.fill(self.color)
+        self.shape.noStroke()
+        self.shape.vertex(0, 0)
+        self.shape.vertex(self.dia, 0)
+        self.shape.vertex(self.dia, self.dia)
+        self.shape.vertex(0, self.dia)
+        self.shape.endShape(CLOSE)
+
+    def display(self):
+        resetMatrix()
+        rotate(radians(self.rotation))
+        shape(self.shape, self.position.x, self.position.y, self.dia, self.dia)

Crawlers/data/mischka.png

@@ -1,4 +1,4 @@
-# add_library('hype')
+#  add_library('hype')
 '''
 1. One hundred `HRect`
 2. Of randomly-selected size
@@ -16,22 +16,27 @@ Implementation by Ben Alkov 7-12 August 2014
 '''
 from hype.core.util import H
 from hype.extended.colorist import HColorField
-from hype.extended.drawable import HGroup
-from hype.extended.drawable import HRect
+from hype.extended.drawable import HGroup, HRect
+
+from gifAnimation import GifMaker, Gif
 
 import util
 
 from parentcallback import ParentCallback
 from rectcallback import RectCallback
 
+gifExport = GifMaker(this, "export.gif")
+
 
 def setup():
-    size(512, 512)
+    size(1080, 1080)
+    frameRate(24)
+    gifExport.setRepeat(0) # make it an "endless" animation
+    # gifExport.setTransparent(255, 255, 255)
     util.centerX = width / 2
     util.centerY = height / 2
-    frameRate(30)
     H.init(this).background(0xff595E6E)  # #595E6E
-    smooth()
+    # smooth()
     util.colorfield = (HColorField(width, height)
                        .addPoint(0, util.centerY, 0xff001CDD, 0.7)  # #001CDD
                        .addPoint(width, util.centerY, 0xff71BB00, 0.7)  # #71BB00
@@ -48,6 +53,8 @@ def setup():
 
 def draw():
     H.drawStage()
-    # saveFrame('C:/Users/IBM_ADMIN/Documents/frames/####.tif')
-    # if frameCount == 900:
-    #     exit()
+    gifExport.setDelay(41)
+    # gifExport.addFrame()
+    if frameCount == 480:
+        gifExport.finish()
+        exit()

LTree/LTree.pyde

@@ -16,7 +16,7 @@ def run(drawable):
         drawable.strokeWeight(2)\
                 .stroke(0xff000000, 196)\
                 .fill(0xff000000, 100)\
-                .size(random(22, 38))\
+                .size(random(int(width / 25), int(width / 16)))\
                 .rounding(2)\
                 .rotation(random(360))\
                 .loc(creationX, creationY)\

LTree/square.py

@@ -22,7 +22,7 @@ def positionOnOrbit():
     angle = random(TAU)
     # `randint` slightly offsets the position so we don't end up with the
     # visible HRects orbiting on *exact* circles.
-    radius = chooseOrbit() + randint(0, 22)
+    radius = chooseOrbit() + randint(0, int(width / 23))
     createX = centerX + (cos(angle) * radius)  # `angle` *must* be radians.
     createY = centerY + (sin(angle) * radius)  #
     return createX, createY
@@ -31,32 +31,34 @@ def positionOnOrbit():
 def chooseOrbit():
     '''
     Randomly choose an orbit, based on a set of weights.
+    The returns can be adjusted to account for a larger / smaller sketch size.
     '''
     chance = random(1)
     if chance < 0.18:
-        return 64
+        return width / 8
     elif chance < 0.50:
-        return 128
+        return width / 4
     elif chance < 0.78:
-        return 208
+        return width / 2.46
     elif chance < 1.0:
-        return 288
+        return width / 1.7777
 
 
 def applyRotation(obj, speed, tolerance):
     '''
-    Attach an HRotate to the given object, with speed `speed`.
+    Attach an HRotate to the given object, calling `avoidZero` to set the
+    speed (angular speed in degrees per draw()).
     '''
     HRotate(obj, avoidZero(speed, tolerance))
 
 
 # This is specifically used to avoid zero or synchronous rotation. We want all
-# visible HRects to *appear* to rotate in place.
+# visible HRects to *appear* to rotate "in place".
 def avoidZero(limit, tolerance):
     '''
-    Return a random value in the range from `-limit` to `limit - 1`, excluding
-    the inner range from `-tolerance` to `tolerance - 1` (and, logically, zero
-    as well).
+    Return a random value in the range from `-limit` to strictly less than
+    `limit`, excluding the inner range +/-`tolerance` (and, logically, zero as
+    well).
     '''
     value = random(-limit, limit)
     while -tolerance < value < tolerance: