sketch-a-day

The polygons now are non-self-intersecting, and the hatches are kept inside :) White lines in the background are from discarded random polys that self-intersected.

s292

292: code [Py.Processing]

s291

291: code [Py.Processing]

s290

290: code [Py.Processing]

s289

289: code [Py.Processing]

True arcs and lines

s288

288: code [Py.Processing]

Ellipse arcs

s287

287: code [Py.Processing]

s286

286: code [Py.Processing]

s285

285: code [Py.Processing]

s284

284: code [Py.Processing]

s283

283: code [Py.Processing]

s282

282: code [Py.Processing]

First attempt at joining rectangular cells into bigger polygonal faces.

s281

281: code [Py.Processing]

s280

280: code [Py.Processing]

s279

279: code [Py.Processing]

s278

278: code [Py.Processing]

s277

277: code [Py.Processing]

s276

276: code [Py.Processing]

s275

275: code [Py.Processing]

s274

274: code [Py.Processing]

s273

273: code [Py.Processing]

This sorts a gliph sequence from lighter to darker

s272

272: code [Py.Processing]

s271

271: code [Py.Processing]

s270

270: code [Py.Processing]

s269

269: code [Py.Processing]

s268

268: code[Py.Processing] & code[Pygame]

s267

267: code [Py.Processing]

s266

266: code [Py.Processing]

s265

265: code [Py.Processing]

s264

264: code [Py.Processing]

s263

263: code [Py.Processing]

s262

262: code [Py.Processing]

s261

261: code [Py.Processing]

s260

260: code [Py.Processing]

s259

259: code [Py.Processing]

s258

258: code [Py.Processing]

s257

257: code [Py.Processing]

s256

256: code [Py.Processing]

s254

254: code [Py.Processing]

s253

253: code [Py.Processing]

s252

252: code [Py.Processing]

s251

251: code [Py.Processing]

s250

250: code [Py.Processing]

This was kind of a dead end. It's easy to rotate stuff with pushMatrix(), transtlate() and rotate(), but it doesn't work inside beginShape() as I found out the next day.

s249

249: code [Py.Processing]

s248

248: code [Py.Processing]

Animation

s247

247: code [Py.Processing]

s246

246: code [Py.Processing]

s245

245: code [Py.Processing]

s244

244: code [Py.Processing]

s243

243: code [Py.Processing]

s242

242: code [Py.Processing]

s241

241: code [Py.Processing]

s240

240: code [Py.Processing]

s239

239: code [Py.Processing]

s238

238: code [Py.Processing]

s237

237: code [Py.Processing]

s236

236: code [Py.Processing]

s235

235: code [Py.Processing]

s234

234: code [Py.Processing]

s233

233: code [Py.Processing]

s232

232: code [Py.Processing]

s231

231: code [Py.Processing]

s230

230: code [Py.Processing]

s229

229: code [Py.Processing]

s228

228: code [Py.Processing]

s227

227: code [Py.Processing]

s226

226: code [Py.Processing]

s225

225: code [Py.Processing]

Now (hollow) boxes, and a cutting-plane controlled by the keyboard.

s224

224: code [Py.Processing]

Tubes! Solid boxes hollowed in one of three directions.

s223

223: code [Py.Processing]

s222

222: code [Py.Processing]

s221

221: code [Py.Processing]

s220

220: code [Py.Processing]

s219

219: code [Py.Processing]

s218

218: code [Py.Processing]

s217

217: code [Py.Processing]

s216

216: code [Py.Processing]

s215

215: code [Py.Processing]

s214

214: code [Py.Processing]

s213

213: code [Py.Processing]

s212

212: code [Py.Processing]

s211

211: code [Py.Processing]

s210

210: code [Py.Processing]

s209

209: code [Py.Processing]

s208

208: code [Py.Processing]

s207

207: code [Py.Processing]

s206

206: code [Py.Processing]

s204

205b: code [Py.Processing]

Two layer version. Added rotateX(rot).

s204

205: code [Py.Processing]

One layer version, I'll use it to test some ideas another day.

s204

204: code [Py.Processing]

At each cycle, it starts on the next node.

s203

203: code [Py.Processing]

A big one, animated the maze generation process.

s202

202: code [Py.Processing]

A bigger one

s201

201: code [Py.Processing]

s200

200: code [Py.Processing]

s199

199: code [Py.Processing]

s198

198: code [Py.Processing]

s197

197: code [Py.Processing]

s196

196: code [Py.Processing]

s195

195: code [Py.Processing]

s194

194: code [Py.Processing]

s193

193: code [Py.Processing]

s192

192: code [Py.Processing]

s191

191: code [Py.Processing]

s190

190: code [Py.Processing]

s189

189: code [Py.Processing]

s188

188: code [Py.Processing]

s187

187: code [Py.Processing]

s186gif

s186

186: code [Py.Processing]

s185

185: code [Processing Java]

s184

184: code [Processing Java]

s183

183: code [Processing Java]

s182

182: code [Processing Java]

s181

181: code [Processing Java]

s180

    def set_nbs(self):
        self.nbs, self.unvisited_nbs = [], []
        for node in Node.nodes:
            if node != self and dist(node.x, node.y, node.z,
                                     self.x, self.y, self.z) <= Node.spacing * 1.1:
                self.nbs.append(node)
                self.unvisited_nbs.append(node)

s180b

if node != self and dist(node.x, node.y, node.z,
                         self.x, self.y, self.z) <= Node.spacing * 1.5:

180: code [Py.Processing]

s179COLOR

s179PB

179: code [Py.Processing]

s178

178: code [Py.Processing]

s177

177: code [Py.Processing]

s176

176: code [Py.Processing]

s175

175: code [Py.Processing]

s174

174: code [Py.Processing]

s173

173: code [Py.Processing]

s172

172: code [Py.Processing]

s171

171:Java code[Processing Java] & Python code [Py.Processing]

s170

170:code [Py.Processing]

s169

169:code [Py.Processing]

Now same Z lines can form floors.

s168

168:code [Py.Processing]

No random movement in Z so no line connections between different (Z) levels. Comparing lines with different Zs to create translucent 'walls'.

s167

167: Java code [Processing Java] & Python code [Py.Processing]

s166

166: code [Py.Processing]

s165

165: code [Py.Processing]

s164

164: code [Py.Processing]

s163

163: code [Py.Processing]

(#152 revisited in 3D :)

s162

162: code [Processing Java]

Perlin Noise "walker" + ?

s161

161: code [Processing Java]

Perlin Noise "walker" + eye

s160

160: code [Processing Java]

Interactive genetic algorithm

s159

159: code [Processing Java]

s158

158: code [Py.Processing]

s157

157: code [Py.Processing]

s156

156: code [Py.Processing]

s155

155: code [Py.Processing]

s154

154: code [Py.Processing]

s153

153: code [Py.Processing]

s152

152: code [Py.Processing]

s151

151: code [Py.Processing]

s150

150: code [Py.Processing]

s149b

149b: code [Py.Processing]

s149

149: code [Py.Processing]

s148

148: code [Py.Processing]

s147

147: code [Py.Processing]

s146

146: code [Py.Processing]

s145

145: code [Py.Processing]

s144

144: code [Py.Processing]

s143

143: code [Py.Processing]

s140 + s141 + s142

140 + 141 + 142 code [Py.Processing]

s142

142: code [Py.Processing]

s141

141: code [Py.Processing]

s140

s140: code [Py.Processing]

s139

s139: code [Py.Processing]

s138

138: code [Py.Processing]

Revisiting ideas of recursion from s071

Heavy animated GIF: s138.gif

s137

s137: code [Py.Processing]

PDF: diagram.pdf

s136

136: code [Py.Processing]

s135

135: code [Py.Processing]

s134

134: code [Py.Processing]

s133

133: code [Py.Processing]

s132

132: code [Py.Processing]

s131

131: code [Py.Processing]

s130

130: code [Py.Processing]

s129

129: code [Py.Processing]

Maybe I fixed it, I guess, not sure…

s128

128: code [Py.Processing]

BROKEN!

s127

127: code [Py.Processing]

s126

126: code [Py.Processing]

s125

125: code [Py.Processing]

s124

124: code [Py.Processing]

s123

123: code [Py.Processing]

s122

122: code [Py.Processing]

s121

121: code [Py.Processing]

s120

120: code [Py.Processing]

To be brutally honest, I had no idea that reversing the second random grid would bring me this result!

s119

119: code [Py.Processing]

s118

118: code [Py.Processing]

s117

117: code [Py.Processing]

s116

116: code [Py.Processing]

s115

115: code [Py.Processing]

s114

114: code [Py.Processing]

s113

113: code [Py.Processing]

s112

112: code [Py.Processing]

Hexagons!

```python def hexagon(x, y, r): with pushMatrix(): translate(x, y) beginShape() for i in range(6): vx = cos(i * TWO_PI /6) * r vy = sin(i * TWO_PI /6) * r vertex(vx, vy) endShape(CLOSE)


----

### s111

![s111](https://raw.githubusercontent.com/villares/sketch-a-day/main/2018/s111/s111.gif)

111: [code](https://github.com/villares/sketch-a-day/tree/master/2018/s111)  [[Py.Processing](https://villares.github.io/como-instalar-o-processing-modo-python/index-EN)]

Now I 'fixed' the rotation with propper pushMatrix() and translate()

```python
        with pushMatrix():
            translate(x0,y0)
            rotate(fs0)
            stroke(st0)
            equilateral(0, 0, fs0)
        with pushMatrix():
            translate(x1,y1)
            rotate(fs1)
            stroke(st1)
            equilateral(0, 0, fs1)
        with pushMatrix():
            translate(x2,y2)
            rotate(fs2)
            stroke(st2)
            equilateral(0, 0, fs2)

s110

110: code [Py.Processing]

Just added some rotations to mess things up. It's "wrong", but I like it!

        rotate(fs0)
        stroke(st0)
        equilateral(x0, y0, fs0)
        stroke(st1)
        rotate(fs1)
        equilateral(x1, y1, fs1)
        stroke(st2)
        rotate(fs2)
        equilateral(x2, y2, fs2)

s109

109: code [Py.Processing]

colorMode(HSB)
...
C = color(map(final_size,-63 , 63, 0, 255), 255, 255)

s108

108: code [Py.Processing]

colorMode(HSB)
...
C = color(map(abs(final_size), 0, 63, 0, 255), 255, 255)

s107

107: code [Py.Processing]

Inverting odd rows

  v = spac_size * 1.5
    h = spac_size * sqrt(3)
    for ix in range(-1, grid_elem + 1):
        for iy in range(-1, grid_elem + 1):
            if iy % 2:
                x = ix * h + h / 4
                es = elem_size
            else:
                x = ix * h - h / 4
                es = -elem_size
            y = iy * v
            for i in range(3):
                final_size = es * (i + 0.5)
                C = map(final_size, 0, 63, 0, 255)
                oX = rand_posi * random(-1, 1)
                oY = rand_posi * random(-1, 1)
                ELEMENTS.append((C, x + oX, y + oY, final_size))

s106

106: code [Py.Processing]

Lazy triangles

def equilateral(x, y, r):
    with pushMatrix():
        translate(x, y)
        triangle(-0.866 * r, -0.5 * r,
                  0.866 * r, -0.5 * r,
                  0.000 * r,  1.0 * r) 
                  # I know... 0 * r and 1 * r...

s105

105: code [Py.Processing]

Layers now have different "base" sizes (0.5, 1.5 and 2.5 times base size). Removed lines for now.

s104

104: code [Py.Processing]

Back to stroke variation

s103

103: code [Py.Processing]

Layers but only black strokes

    spac_size = width / (grid_elem + 1)
    v = spac_size * 1.5
    h = spac_size * sqrt(3)
    for ix in range(-1, grid_elem + 1):
        for iy in range(-1, grid_elem + 1):
            if iy % 2:
                x = ix * h + h / 4
            else:
                x = ix * h - h / 4
            y = iy * v
            for i in range(3):
                final_size = elem_size + rand_size * random(-1, 1)
                ELEMENTS.append((x, y, final_size))
    # three layers of elements            
    for i in range(3):
        offsetX = rand_posi * random(-1, 1)
        offsetY = rand_posi * random(-1, 1)
        for elem in ELEMENTS[i::3]:
            x, y, es = elem
            ellipse(x + offsetX, y + offsetY, es, es)

    for _ in range(grid_elem):
        x1, y1, es1 = rnd_choice(ELEMENTS)
        x2, y2, es2 = rnd_choice(ELEMENTS)
        line(x1, y1, x2, y2)

s102

102: code [Py.Processing]

    spac_size = width / (grid_elem + 1)
    v = spac_size * 1.5
    h = spac_size * sqrt(3)
    for ix in range(-1, grid_elem + 1):
        for iy in range(-1, grid_elem + 1):
            if iy % 2:
                x = ix * h + h / 4
            else:
                x = ix * h - h / 4
            y = iy * v
            final_size = elem_size + rand_size * random(-1, 1)
            offsetX = rand_posi * random(-1, 1)
            offsetY = rand_posi * random(-1, 1)
            C = map(final_size, 0, 63, 0, 255)
            ELEMENTS.append((C,
                             x + offsetX,
                             y + offsetY,
                             final_size
                             ))
    for elem in ELEMENTS:
        stroke1, x1, y1, es1 = elem
        ellipse(x1, y1, es1, es1)

    for _ in range(grid_elem):
        stroke1, x1, y1, es1 = rnd_choice(ELEMENTS)
        stroke2, x2, y2, es2 = rnd_choice(ELEMENTS)
        stroke(stroke2)
        line(x1, y1, x2, y2)

s101

101: code [Py.Processing]

    for _ in range(grid_elem * 2):        
        stroke1, x1, y1, es1 = rnd_choice(ELEMENTS)
        stroke(stroke1)
        ellipse(x1, y1, es1, es1)
        stroke2, x2, y2, es2 = rnd_choice(ELEMENTS)
        stroke(stroke2)
        # line
        ellipse(x2, y2, es2, es2)
        line(x1, y1, x2, y2)

s100

100: code [Py.Processing]

    spac_size = int(width / (grid_elem + 1))
    for _ in range(2):
        for x in range(spac_size / 2, width, spac_size): 
            for y in range(spac_size / 2, width, spac_size):
                final_size = elem_size + rand_size * random(-1, 1)
                offsetX = rand_posi * random(-1, 1)
                offsetY = rand_posi * random(-1, 1)
                C = map(final_size, 0, 63, 0, 255)
                ELEMENTS.append((C,
                                x + offsetX,
                                y + offsetY,
                                final_size
                                ))
    for stroke_c, x, y, el_size in ELEMENTS:
        stroke(stroke_c)
        ellipse(x, y, el_size, el_size)
    for _ in range(grid_elem):
        stroke_c, x1, y1, _ = rnd_choice(ELEMENTS)
        ________, x2, y2, _ = rnd_choice(ELEMENTS)
        stroke(stroke_c)
        line(x1, y1, x2, y2)

s099

099: code [Py.Processing]

    spac_size = int(width / (grid_elem + 1))
    for x in range(spac_size / 2, width, spac_size):  
        for y in range(spac_size / 2, width, spac_size): 
            final_size = elem_size + rand_size * random(-1, 1)
            offsetX = rand_posi * random(-1, 1)
            offsetY = rand_posi * random(-1, 1)
            GREY = map(final_size, 0, 63, 0, 255)
            stroke(GREY)
            ellipse(x + offsetX,  # desenha um círculo
                 y + offsetY,
                 final_size,
                 final_size)

s098

098: code [Py.Processing]

    spac_size = int(width / (grid_elem + 1))
    for x in range(spac_size / 2, width, spac_size):  
        for y in range(spac_size / 2, width, spac_size): 
            square_size = elem_size + rand_size * random(-1, 1)
            offsetX = rand_posi * random(-1, 1)
            offsetY = rand_posi * random(-1, 1)
            HUE = map(offsetX + offsetY, -128, 127, 0, 255)
            SAT = map(square_size, 0, 63, 0, 255)
            fill(HUE, SAT, 255, 200)
            rect(x + offsetX,  # desenha um quadrado
                 y + offsetY,
                 square_size,
                 square_size)

s097

097: code [Py.Processing]

    spac_size = int(width / (grid_elem + 1))
    for x in range(spac_size / 2, width, spac_size):
        for y in range(spac_size / 2, width, spac_size):
            # sorteia um tamanho (se o rand_size > 0)
            square_size = elem_size + rand_size * random(-1, 1)
            rect(x + rand_posi * random(-1, 1),  # desenha um quadrado
                 y + rand_posi * random(-1, 1),  
                 square_size,
                 square_size)

s096

096: code [Py.Processing]

More 'Inputs' helper changes (WASD & arrows for sliders). New GIF export helper actually works now! More lone nodes and edge creation changes...

s095

095: code [Py.Processing]

Complete rewrite of the 'Inputs' helper

# Ask user for Arduino port, uses slider if none is selected, use on `setup()`
global input
input = Input(Arduino)

# on `draw()`read analog pins 1, 2, 3, 4 or sliders
pot1 = input.analog(1)
pot2 = input.analog(2)
pot3 = input.analog(3)
pot4 = input.analog(4)

tilt = input.digital(13) # also triggered by [space bar]

# When on sliders, this draws them and checks mouse dragging / keystrokes
input.update()

s094

094: code [Py.Processing]

Connection 'rate' can be less than 1, prevents less than 2 nodes

s093

093: code [Py.Processing]

Nodes without connection are now removed

    COM_ARESTAS = set()  # para guardar pontos com aresta
    for aresta in Aresta.ARESTAS:
        if (aresta.p1 not in Ponto.SET) or (aresta.p2 not in Ponto.SET)\
                or (aresta.p1 is aresta.p2):  # arestas degeneradas
            Aresta.ARESTAS.remove(aresta)   # remove a aresta
        else:                # senão, tudo OK!
            aresta.desenha()  # desenha a linha
            aresta.puxa_empurra(TAM_ARESTA)  # altera a velocidade dos pontos
            # Adiciona ao conjunto de pontos com aresta
            COM_ARESTAS.update([aresta.p1, aresta.p2])
    Ponto.SET = COM_ARESTAS  # isto remove pontos sem nenhuma aresta

s092

092: code [Py.Processing]

Dynamic change of connection rate

if NUM_PONTOS * NUM_CONNECT > len(Aresta.ARESTAS):
        rnd_choice(list(Ponto.SET)).cria_arestas()
    elif NUM_PONTOS * NUM_CONNECT < len(Aresta.ARESTAS):
        Aresta.ARESTAS.remove(rnd_choice(Aresta.ARESTAS))

s091

091: code [Py.Processing]

Major rethink of my Arduino/Firmata code. I can now choose on start between sliders and potentiometers.

s090

090: code [Py.Processing]

Opaque strokes, no fill, randomized colours by column.

s089

089: code [Py.Processing]

X stroke now is translucent and grid elements have random colour inside grids.

s088

088: code [Py.Processing]

Filled rects, ellipses and losangles (without sktroke) and Xs

s087

087: code [Py.Processing]

No fill again, less colours. Variable/random number of elements per grid.

s086

086: code [Py.Processing]

Translucent fill & some stroke weight

s085

085: code [Py.Processing]

Some colour, and some crazy meddling with the Slider class...

s084

084: code [Py.Processing]

Make the grid's position/origin align based on the spacing size (super- grid)

s083

083: code [Py.Processing]

Xs and rotated rectangles

s082

082: code [Py.Processing]

Squares and ellipses

s081

081: code [Py.Processing]

Let's try some grids

s080

080: code [Py.Processing]

More arrows (black and white alternate by generation)

s079

079: code [Py.Processing]

Arrows (right black, left white)

s078

078: code [Py.Processing]

Color

s077

077: code [Py.Processing]

Random branch reduction is now less simmetric, and random seed changes on depth change.

s076

076: code [Py.Processing]

Stroke weight and some transparency

s075

075: code [Py.Processing]

... and slightly different parameters and recursion level control instead of lenght

s074

074: code [Py.Processing]

Adaptomg Shiffmans recusive Tree, with sliders or Pots...

s073

073: code [Py.Processing]

The code remains ugly :(

s072

072: code [Py.Processing]

Let's mix some arrows?

s071

071: code [Py.Processing]

Thicker and with a saturation slider (no more scale offset)

s070

070: code [Py.Processing]

Thicker and with a saturation slider (no more scale offset)

s069

069: code [Py.Processing]

Added rotation.

s068

068: code [Py.Processing]

... and with sliders (by Peter Farell)

s067

067: code [Py.Processing]

Something else.

s066

066: code [Py.Processing]

Arrow grid networks can be sized and placed...

s065

065: code [Py.Processing]

Arrow grid networks are now objects...

s064

064: code [Py.Processing]

Revisiting yet an older graph, adding arrows...

s063

063: code [Py.Processing]

Revisiting an older graph adding arrows...

s062

062: code [Py.Processing]

+ and - keys control the distange/range of targes in 0.5 * SPACING increments

s061

061: code [Py.Processing]

Sometimes we have multiple arrows now out of each node...But I reduced the range (distance) they can point to.

s060

060: code [Py.Processing]

Complete Object Oriented refactor...

s059

059: code [Py.Processing]

Back to a list of points, now every point of the grid has a node. Limited points_to random each.

s058

058: code [Py.Processing]

Now with some deepcopy of changeable imutable namedtuples (containing mutable lists), and some lerp()

s057

057: code [Py.Processing]

Revisited 54 and now I'm re-selecting random points_to nodes...

s056

056: code [Py.Processing]

Arrow grid moving in HSB colour space

s055

055: code [Py.Processing]

Grid revisited

s054

054: code [Py.Processing]

New arrows! With a "Tail" parameter...

s053

053: code [Py.Processing]

Big invisible refactor (no more point-grid to select from, now a list of possible X and Y positons to choose). On the visible side, fewer elements, and non-pointing elements redrawn in red on top.

s052

052: code [Py.Processing]

White lines first, black arrows on top.

s051

051: code [Py.Processing]

Points now on a grid.

s050

050: code [Py.Processing]

Arrows now...

s049

049: code [Py.Processing] Yet more graphs

s048

048: code [Py.Processing] Yet more graphs

s047

047: code [Py.Processing] Yet more graphs

s046

046: code [Py.Processing] Yet more graphs

s045

045: code [Py.Processing] Yet more graphs

s044

044: code [Py.Processing] More graphs

s043

043: code [Py.Processing] More graphs

s042

042: code [Py.Processing] Yet another interactive recursive thingy, the image on the right is shown with a key pressed

s041

041: code [Py.Processing] Yet another interactive recursive thingy, the image on the right is shown with a key pressed

040

040: sketch_180209a [Py.Processing] More recursion

039

039: sketch_180208e [Py.Processing] Manoloide inspired recursion

038

038: sketch_180208d [Py.Processing] Saskia Freeke inspired grid

037

037: sketch_180206b [Py.Processing] "Carnahacking is near!"

036

036: sketch_180205b [Py.Processing] Added some mouse disturbance

035

035: sketch_180204b [Py.Processing] Preparing for "Carnahacking"

034

034: sketch_180203c [Py.Processing] Like 33 but again with "w squared" circles

033

033: sketch_180202c [Py.Processing] Like 32 but again with lines

032

032: sketch_180201c [Py.Processing] Like 29 but with moving points after the gesture is done

031

031: sketch_180130c [Py.Processing] Like 29 but with moving points after the gesture is done

030

030: sketch_180130c [Py.Processing] Like 29 but with 3D and PeasyCam orbit...

29c

029: sketch_180129c [Py.Processing] Like 27 but with circles

28c

028: sketch_180128c [Py.Processing] Like 27 but on grayscale

27c

027: sketch_180127c [Py.Processing]YouTube

Saving a list of points to animate colour... Mouse speed changes recorded colour & strokeWeight()

26

026: sketch_180126c [Py.Processing] Mouse speed changing colour & strokeWeight()

25

025c: sketch_180125b [Py.Processing] Mouse speed changing strokeWeight()

24

024b: sketch_180124b [Py.Processing] Maybe tomorrow I'll try adding some sliders & movement to this graph ? [nah...]

23

023b: sketch_180123b [Py.Processing] Farrel's Sliders adding random displacement

022: missed :(

21b

021b: sketch_180121b [Py.Processing] Playing with Peter "Hacking Math Class" Farrel's Sliders!

20b

020b: sketch_180120b [Py.Processing] I was stuck on my DBN conversion sketch 20a, so this HSB shape play is 20b...

20a

020a: sketch_180120a [Py.Processing] Refactored the code generation, removed most of the repeated vertices... C D E G O R not nice yet…

19a

019: sketch_180119a [Py.Processing] DBN Letters: Now working on a new approach, generating vertex/Shape code, not there yet...

18a

018: sketch_180118a [Py.Processing] DBN Color font? Nah…

17a

017: sketch_180117a [Py.Processing] John Maeda's dbnletters.dbn code from Design by Numbers on Processing Python Mode

16a

016: 16a [Py.Processing] Converting some Typography code from Design by Numbers, almost there!

15a

015: sketch_180115a [Py.Processing] Converting some Typography code from Design by Numbers, first trials

14a

014: sketch_180114a [Py.Processing] Another 3D Graph

13a

013: s180113 [Py.Processing] 3D Graph

s180112

012: s180112 [Py.Processing] Another Graph Take

s180111

011: s180111 [Py.Processing] A Graph Take

s180110

010: s180110 [Py.Processing] More Manoloide inspired balls PNG (derived from a sketch by Manuel Gamboa Naon)

GIF

009: s180109 [Py.Processing] Balls for Manoloide GIF (derived from a sketch by Manuel Gamboa Naon)

GIF

008: s180108 [Py.Processing] Grid of Platonic Solids in Python Mode GIF

GIF

007: s180107 [Processing Java] Another grid of Platonic Solids in Java Mode GIF

GIF

006: s180106 [Processing Java] Grid of Platonic Solids in Java Mode GIF

005: s180105 [p5js] Line Tetrahedrons in p5*js - interactive

GIF

004: s180104 [Processing Java] Tetrahedrons in Java Mode- GIF

GIF

003: s180103 [Py.Processing] Tetrahedrons Python Mode- GIF

002: s180102 [Py.Processing] Many Stars 3D - YouTube

001: s180101[Py.Processing] Many Stars - YouTube (inspired by my own p5js Xmas & New Year card code)

2025 | 2024 | 2023 | 2022 | 2021 | 2020 | 2019 | 2018

The sketch-a-day project, images and code repository, by Alexandre B A Villares are licensed under Attribution-NonCommercial-NoDerivatives 4.0 International , except if marked/attributed otherwise in a file or code section. Please contact for licensing questions.

Files

2018.md

Latest commit

History

2018.md

File metadata and controls

sketch-a-day

one visual idea a day

s367

s366

s365

s364

s363

s362

s361

s360

s359

s358

s357

s356

s355

s354

s353

s352

s351

s350

s349

s348

s347

s346

s345

s344

s343

s342

s341

s340

s339

s338

s337

s336

s335

s334

s333

s332

s331

s330

s329

s328

s327

s326

s325

s324

s323

s322

s321

s320

s319

s318

s317

s316

s315

s314

s313

s312

s311

s310

s309

s308

s307

s306

s305

s304

s303

s302

s301

s300

s299

s298

s297

s296