Day 123

s123/gif_exporter.py

@@ -0,0 +1,43 @@
+"""
+Alexandre B A Villares http://abav.lugaralgum.com - GPL v3 
+
+A helper for the Processing gifAnimation library (https://github.com/jordanorelli)
+ported to Processing 3 by 01010101 (https://github.com/01010101)
+Download the library from https://github.com/01010101/GifAnimation/archive/master.zip
+This helper was inspired by an example by Art Simon https://github.com/APCSPrinciples/AnimatedGIF/
+
+Put  at the start of your sketch:
+   add_library('gifAnimation')
+   from gif_exporter import gif_export
+and at the end of draw():
+    gif_export(GifMaker)
+"""
+
+def gif_export(GifMaker,             # gets a reference to the library
+               filename="exported",  # .gif will be added
+               repeat=0,             # 0 makes it an "endless" animation
+               quality=100,          # quality range 0 - 255
+               delay=170,            # this is quick
+               frames=0):            # 0 will stop on keyPressed or frameCount >= 100000
+    global gifExporter
+    try:
+        gifExporter
+    except NameError:
+        gifExporter = GifMaker(this, filename + ".gif")
+        gifExporter.setRepeat(repeat)
+        gifExporter.setQuality(quality)
+        gifExporter.setDelay(delay)
+        gif_export._frame = frameCount
+        print("gif start")
+
+    gifExporter.addFrame()
+
+    if (frames == 0 and keyPressed or frameCount - gif_export._frame >= 100000) \
+            or (frames != 0 and frameCount - gif_export._frame >= frames):
+        gifExporter.finish()
+        background(255)
+        print("gif saved")
+        del(gifExporter)
+        return False
+    else:
+        return True

s123/inputs.py

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+from javax.swing import JOptionPane
+
+"""
+This will hpefully switch between Arduino (Firmata) variable input and
+nice sliders based on Peter Farell's Sliders htts://twitter.com/hackingmath
+https://github.com/hackingmath/python-sliders http://farrellpolymath.com/
+"""
+class Input:
+
+    def __init__(self, Arduino, slider_pins):
+        self.select_source(Arduino)
+        if self.source > 0:
+            self.arduino = Arduino(this, Arduino.list()[self.source], 57600)
+        else:
+            # start, end, default
+            A = Slider(0, 1023, 128)
+            B = Slider(0, 1023, 128)
+            C = Slider(0, 1023, 128)
+            D = Slider(0, 1023, 128)
+            A.position(40, height - 70)
+            B.position(40, height - 30)
+            C.position(width - 140, height - 70)
+            D.position(width - 140, height - 30)
+            a, b, c, d = slider_pins
+            self.sliders = {a: A, b: B, c: C, d: D}
+
+    def analog(self, pin):
+        if self.source:
+            return self.arduino.analogRead(pin)
+        else:
+            return self.sliders[pin].val
+
+    def update(self):
+        if not self.source:
+            for pin, slider in self.sliders.iteritems():
+                slider.update()
+
+    def keyPressed(self):
+        if key == 'a':
+            self.sliders[1].down = True
+        if key == 'd':
+            self.sliders[1].up = True
+        if key == 's':
+            self.sliders[2].down = True
+        if key == 'w':
+            self.sliders[2].up = True
+        if keyCode == LEFT:
+            self.sliders[3].down = True
+        if keyCode == RIGHT:
+            self.sliders[3].up = True
+        if keyCode == DOWN:
+            self.sliders[4].down = True
+        if keyCode == UP:
+            self.sliders[4].up = True
+
+    def keyReleased(self):
+        if key == 'a':
+            self.sliders[1].down = False
+        if key == 'd':
+            self.sliders[1].up = False
+        if key == 's':
+            self.sliders[2].down = False
+        if key == 'w':
+            self.sliders[2].up = False
+        if keyCode == LEFT:
+            self.sliders[3].down = False
+        if keyCode == RIGHT:
+            self.sliders[3].up = False
+        if keyCode == DOWN:
+            self.sliders[4].down = False
+        if keyCode == UP:
+            self.sliders[4].up = False
+
+    def digital(self, pin):
+        space_pressed = keyPressed and key == ' '
+        if self.source:
+            if pin == 13:
+                return self.arduino.digitalRead(13) or space_pressed
+            else:
+                return arduino.digitalRead(pin)
+        else:
+            return space_pressed
+
+    def select_source(self, Arduino):
+        # Input.Arduino = Arduino  # to make available on this module
+        port_list = [str(num) + ": " + port for num, port
+                     in enumerate(Arduino.list())]
+        if not port_list:
+            port_list.append(None)
+        self.source = option_pane("O seu Arduino está conectado?",
+                                  "Escolha a porta ou pressione Cancel\npara usar 'sliders':",
+                                  port_list,
+                                  -1)  # index for default option
+        self.help()
+
+    def help(self):
+        if self.source:
+            message = """   Teclas:
+            'h' para esta ajuda
+            'p' para salvar uma imagem
+            'g' para salvar um GIF
+            Tombe a lousa para lousa para limpar o desenho!"""
+        else:
+            message = """    Teclas:
+            'h' para esta ajuda
+            'p' para salvar uma imagem
+            'g' para salvar um GIF
+            'a' (-) ou 'd' (+) para o slider 1
+            's' (-) ou 'w' (+) para o slider 2
+             ←(-) ou  → (+) para o slider 3
+             ↓  (-) ou  ↑  (+) para o slider 4
+            [barra de espaço] para limpar o desenho"""
+        ok = JOptionPane.showMessageDialog(None, message)
+
+
+def option_pane(title, message, options, default=None, index_only=True):
+
+    if default == None:
+        default = options[0]
+    elif index_only:
+        default = options[default]
+
+    selection = JOptionPane.showInputDialog(
+        frame,
+        message,
+        title,
+        JOptionPane.INFORMATION_MESSAGE,
+        None,  # for Java null
+        options,
+        default)  # must be in options, otherwise 1st is shown
+    if selection:
+        if index_only:
+            return options.index(selection)
+        else:
+            return selection
+
+class Slider:
+
+    SLIDERS = []
+
+    def __init__(self, low, high, default):
+        '''slider has range from low to high
+        and is set to default'''
+        self.low = low
+        self.high = high
+        self.val = default
+        self.clicked = False
+        self.up, self.down = False, False
+        Slider.SLIDERS.append(self)
+
+    def position(self, x, y):
+        '''slider's position on screen'''
+        self.x = x
+        self.y = y
+        # the position of the rect you slide:
+        self.rectx = self.x + map(self.val, self.low, self.high, 0, 120)
+        self.recty = self.y - 10
+
+    def update(self):
+        '''updates the slider'''
+        pushStyle()
+        rectMode(CENTER)
+        # black translucid rect behind slider
+        fill(0, 100)
+        noStroke()
+        rect(self.x + 60, self.y, 130, 20)
+        # gray line behind slider
+        strokeWeight(4)
+        stroke(200)
+        line(self.x, self.y, self.x + 120, self.y)
+        # press mouse to move slider
+        if (self.x < mouseX < self.x + 120 and
+                self.y < mouseY < self.y + 20):
+            fill(250)
+            textSize(10)
+            text(str(int(self.val)), self.rectx, self.recty + 35)
+            if mousePressed:
+                self.rectx = mouseX
+        # key usage
+        if self.up:
+            self.rectx += 1
+        if self.down:
+            self.rectx -= 1
+        # constrain rectangle
+        self.rectx = constrain(self.rectx, self.x, self.x + 120)
+        # draw rectangle
+        strokeWeight(1)
+        fill(255)
+        rect(self.rectx, self.recty + 10, 10, 20)
+        self.val = map(self.rectx, self.x, self.x + 120, self.low, self.high)
+        popStyle()

s123/s123.pyde

@@ -0,0 +1,157 @@
+# Alexandre B A Villares - https://abav.lugaralgum.com/sketch-a-day
+# inspired by a Processing implementation of Game of Life By Joan Soler-Adillon
+
+SKETCH_NAME = "s122b"  # 180502
+add_library('gifAnimation')
+from gif_exporter import *
+
+cellSize = 16  # Size of cells
+# How likely for a cell to be alive at start (in percentage)
+probabilityOfAliveAtStart = 20
+# Variables for timer
+interval = 150
+lastRecordedTime = 0
+pause = False  # Pause
+GIF_EXPORT = False
+
+
+def setup():
+    global input
+    global grid_w, grid_h
+    global cells  # Array of cells
+    global cellsBuffer  # Buffer while changing the others in the interations
+    size(500, 500)
+    colorMode(HSB)
+    strokeWeight(3)
+    background(0)
+    # Instantiate arrays
+    grid_w, grid_h = int(width / cellSize), int(height / cellSize)
+    cells = [[None] * grid_w for _ in range(grid_h)]
+    cellsBuffer = [[None] * grid_w for _ in range(grid_h)]
+    # This stroke will draw the background grid
+    noFill()  # stroke(48)
+    # Initialization of cells
+    for x in range(grid_w):
+        for y in range(grid_h):
+            state = random(100)
+            if state > probabilityOfAliveAtStart:
+                state = 0
+            else:
+                state = 1
+            cells[x][y] = state  # Save state of each cell
+
+def draw():
+    global lastRecordedTime
+    fill(0,30)
+    rect(0, 0, width, height)
+    # Draw grid
+    for x in range(grid_w):
+        for y in range(grid_h):
+            n = calc_neighbours(x, y)
+            if cells[x][y] == 1:
+                stroke((n*25 + frameCount) % 256, 255, 255)  # If alive
+            else:
+                noStroke()  # fill(dead)  # If dead
+            noFill()
+            pointy_hexagon(x * cellSize, y * cellSize, cellSize)
+    # Iterate if timer ticks
+    if millis() - lastRecordedTime > interval:
+        if not pause:
+            iteration()
+            lastRecordedTime = millis()
+        global GIF_EXPORT
+        if GIF_EXPORT:
+            GIF_EXPORT = gif_export(GifMaker,
+                                frames=100,
+                                filename=SKETCH_NAME)
+
+    # Create new cells manually on pause
+    if pause and mousePressed:
+        # Map and adef out of bound errors
+        xCellOver = int(map(mouseX, 0, width, 0, width / cellSize))
+        xCellOver = constrain(xCellOver, 0, width / cellSize - 1)
+        yCellOver = int(map(mouseY, 0, height, 0, height / cellSize))
+        yCellOver = constrain(yCellOver, 0, height / cellSize - 1)
+        # Check against cells in buffer
+        if cellsBuffer[xCellOver][yCellOver] == 1:  # Cell is alive
+            cells[xCellOver][yCellOver] = 0  # Kill
+        else:  # Cell is dead
+            cells[xCellOver][yCellOver] = 1  # Make alive
+    # And then save to buffer once mouse goes up
+    elif pause and not mousePressed:
+        # Save cells to buffer
+        # (so we opeate with one array keeping the other intact)
+        for x in range(grid_w):
+            for y in range(grid_h):
+                cellsBuffer[x][y] = cells[x][y]
+                
+
+def iteration():  # When the clock ticks
+    global n
+    # Save cells to buffer
+    # (so we opeate with one array keeping the other intact)
+    for x in range(grid_w):
+        for y in range(grid_h):
+            cellsBuffer[x][y] = cells[x][y]
+    # Visit each cell:
+    for x in range(grid_w):
+        for y in range(grid_h):
+            # And visit all the neighbours of each cell
+            n = calc_neighbours(x, y)
+            if cellsBuffer[x][y] == 1:
+                if n < 2 or n > 3:
+                    cells[x][y] = 0  # Die unless it has 2 or 3 neighbours
+            else:  # The cell is dead: make it live if necessary
+                if n == 3:
+                    cells[x][y] = 1  # Only if it has 3 neighbours
+
+def calc_neighbours(x, y):
+    neighbours = 0  # We'll count the neighbours
+    for xx in range(x - 1, x + 2):
+        for yy in range(y - 1, y + 2):
+                    # Make sure you are not out of bounds
+            if 0 <= xx < grid_w and 0 <= yy < grid_w:
+                # Make sure to check against self
+                if not (xx == x and yy == y):
+                    if cellsBuffer[xx][yy] == 1:
+                        # Check alive neighbours and count them
+                        neighbours = neighbours + 1
+    return neighbours
+
+def keyPressed():
+    global pause
+    if key == 'r' or key == 'R':
+        # Restart: reinitialization of cells
+        for x in range(grid_w):
+            for y in range(grid_h):
+                state = random(100)
+                if state > probabilityOfAliveAtStart:
+                    state = 0
+                else:
+                    state = 1
+                cells[x][y] = state  # Save state of each cell
+    if key == ' ':  # On/off of pause
+        pause = not pause
+    if (key == 'c' or key == 'C'):  # Clear all
+        for x in range(grid_w):
+            for y in range(grid_h):
+                cells[x][y] = 0  # Save all to zero
+    global GIF_EXPORT
+    if key == 'p':  # save PNG
+        saveFrame("####.png")
+    if key == 'g':  # save GIF
+        GIF_EXPORT = True
+
+def item_at_x_y(x, y, collenction, width_):
+    return collection[x + y * width_]
+
+def pointy_hexagon(x, y, r):
+    with pushMatrix():
+        translate(x, y)
+        rotate(radians(30))  # pointy, comment out for "flat_hexagon()"
+        beginShape()
+        for i in range(6):
+            sx = cos(i * TWO_PI / 6) * r
+            sy = sin(i * TWO_PI / 6) * r
+            vertex(sx, sy)
+        endShape(CLOSE)