Alexandre B A Villares


sketch-a-day

one visual idea a day


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


s367

s367

367: code [Py.Processing]


s366

s366

366: code [Py.Processing]


s365

s365

365: code [Py.Processing]


s364

s364

364: code [Py.Processing]


s363

s363

363: code [Py.Processing]


s362

s362

362: code [Py.Processing]


s361

s361

361: code [Py.Processing]


s360

s360

360: code [Py.Processing]


s359

s359

359: code [Py.Processing]


s358

s358

358: code [Py.Processing]

… in preparation for something…


s357

s357

357: code [Py.Processing]

Back to ideas from 322…


s356

s356

356: code [Py.Processing]


s355

s355

355: code [Py.Processing]


s354

s354

354: code [Py.Processing]


s353

s353

353: code [Py.Processing]


s352

s352

352: code [Py.Processing]


s351

s351

351: code [Py.Processing]


s350

s350

350: code [Py.Processing]


s349

s349

349: code [Py.Processing]


s348

s348

348: code [Py.Processing]


s347

s347

347: code [Py.Processing]


s346

s346

346: code [Py.Processing]


s345

s345

345: code [Py.Processing]


s344

s344

344: code [Py.Processing]


s343

s343

343: code [Py.Processing]


s342

s342

342: code [Py.Processing]


s341

s341

341: code [Py.Processing]


s340

s340

340: code [Py.Processing]


s339

s339

339: code [Py.Processing]


s338

s338 338: code [Py.Processing]


s337

s337

337: code [Py.Processing]


s336

s336

336: code [Py.Processing]


s335

s335

335: code [Py.Processing]


s334

s334

334: code [Py.Processing]


s333

s333

333: code [Py.Processing]


s332

s332

332: code [Py.Processing]


s331

s331

331: code [Py.Processing]


s330

s330

330: code [Py.Processing]


s329

s329

329: code [Py.Processing]


s328

s328

328: code [Py.Processing]


s327

s327

327: code [Py.Processing]


s326

s326

326: code [Py.Processing]


s325

s325

325: code [Py.Processing]


s324

s324

324: code [Py.Processing]


s323

s323

323: code [Py.Processing]


s322

s322

322: code [Py.Processing]


s321

s321

321: code [Py.Processing]


s320

s320

320: code [Py.Processing]


s319

s319

319: code [Py.Processing]


s318

s318

318: code [Py.Processing]


s317

s317

317: code [Py.Processing]


s316

s316

316: code [Py.Processing]

A 3D take on 314


s315

s315

315: GIF code [Py.Processing]

Horizontaly connected 314


s314

s314

314: code [Py.Processing]

Isolating elements from 313


s313

s313

313: code [Py.Processing]


s312

s312

312: code [Py.Processing]


s311

s311

311: code [Py.Processing]


s310

s310

310: code [Py.Processing]


s309

s309

309: code [Py.Processing]


s308

s308

308: code [Py.Processing]


s307

s307

307: code [Py.Processing]


s306

s306

306: code [Py.Processing]


s305

s305

305: code [Py.Processing]


s304

s304

304: code [Py.Processing]


s303

s303

303: code [Py.Processing]


s302

s302

302: code [Py.Processing]

Hatches parallel to opposed sides.


s301

s301

301: code [Py.Processing]

Tried to supress some vertices from the hatch grid.


s300

s300

300: code [Py.Processing]

Cross hatch and, a simplified “cell” polygon drawing and selective non-random verticies (if pos % 3 == 0)


s299

s299

299: code [Py.Processing]

Inclined hatches


s298

s298

298: code [Py.Processing]

First hatch attempt on a random “cell” grid. Each cell has 4 “node” vertices


s297

s297

297: code [Py.Processing]

Changed my internal point grid to “pixels”


s296

s296

296: code [Py.Processing]

Demo of how the “inside poly” test works from from my lines intersecting poly function.


s295

s295

295: code [Py.Processing]

Testing if a point is inside a poly to make a grid/retucule. Advancing from my lines intersecting poly function.


s294

s294

294: code [Py.Processing]

Playing with my code for lines intersecting polygons.


s293

s293

293: code [Py.Processing]

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

s292

292: code [Py.Processing]


s291

s291

291: code [Py.Processing]


s290

s290

290: code [Py.Processing]


s289

s289

289: code [Py.Processing]

True arcs and lines


s288

s288

288: code [Py.Processing]

Ellipse arcs


s287

s287

287: code [Py.Processing]


s286

s286

286: code [Py.Processing]


s285

s285

285: code [Py.Processing]


s284

s284

284: code [Py.Processing]


s283

s283

283: code [Py.Processing]


s282

s282

282: code [Py.Processing]

First attempt at joining rectangular cells into bigger polygonal faces.


s281

s281

281: code [Py.Processing]


s280

s280

280: code [Py.Processing]


s279

s279

279: code [Py.Processing]


s278

s278

278: code [Py.Processing]


s277

s277

277: code [Py.Processing]


s276

s276

276: code [Py.Processing]


s275

s275

275: code [Py.Processing]


s274

s274

274: code [Py.Processing]


s273

s273

273: code [Py.Processing]

This sorts a gliph sequence from lighter to darker


s272

s272

272: code [Py.Processing]


s271

s271

271: code [Py.Processing]


s270

s270

270: code [Py.Processing]


s269

s269

269: code [Py.Processing]


s268

s268

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


s267

s267 267: code [Py.Processing]


s266

s266 266: code [Py.Processing]


s265

s265 265: code [Py.Processing]


s264

s264 264: code [Py.Processing]


s263

s263 263: code [Py.Processing]


s262

s262

262: code [Py.Processing]


s261

s261

261: code [Py.Processing]


s260

s260

260: code [Py.Processing]


s259

s259

259: code [Py.Processing]


s258

s258

258: code [Py.Processing]


s257

s257

257: code [Py.Processing]


s256

s256

256: code [Py.Processing]


s254

s254

254: code [Py.Processing]


s253

s253

253: code [Py.Processing]


s252

s252

252: code [Py.Processing]


s251

s251

251: code [Py.Processing]


s250

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

s249

249: code [Py.Processing]


s248

s248

248: code [Py.Processing]

Animation


s247

s247

247: code [Py.Processing]


s246

s246

246: code [Py.Processing]


s245

s245

245: code [Py.Processing]


s244

s244

244: code [Py.Processing]


s243

s243

243: code [Py.Processing]


s242

s242

242: code [Py.Processing]


s241

s241

241: code [Py.Processing]


s240

s240

240: code [Py.Processing]


s239

s239

239: code [Py.Processing]


s238

s238

238: code [Py.Processing]


s237

s237

237: code [Py.Processing]


s236

s236

236: code [Py.Processing]


s235

s235

235: code [Py.Processing]


s234

s234

234: code [Py.Processing]


s233

s233

233: code [Py.Processing]


s232

s232

232: code [Py.Processing]


s231

s231

231: code [Py.Processing]


s230

s230

230: code [Py.Processing]


s229

s229

229: code [Py.Processing]


s228

s228

228: code [Py.Processing]


s227

s227

227: code [Py.Processing]


s226

s226

226: code [Py.Processing]


s225

s225

225: code [Py.Processing]

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


s224

s224

224: code [Py.Processing]

Tubes! Solid boxes hollowed in one of three directions.


s223

s223

223: code [Py.Processing]


s222

s222

222: code [Py.Processing]


s221

s221

221: code [Py.Processing]


s220

s220

220: code [Py.Processing]


s219

s219

219: code [Py.Processing]


s218

s218

218: code [Py.Processing]


s217

s217

217: code [Py.Processing]


s216

s216

216: code [Py.Processing]


s215

s215

215: code [Py.Processing]


s214

s214

214: code [Py.Processing]


s213

s213

213: code [Py.Processing]


s212

s212

212: code [Py.Processing]


s211

s211

211: code [Py.Processing]


s210

s210

210: code [Py.Processing]


s209

s209

209: code [Py.Processing]


s208

s208

208: code [Py.Processing]


s207

s207

207: code [Py.Processing]


s206

s206

206: code [Py.Processing]


s204

s204

205b: code [Py.Processing]

Two layer version. Added rotateX(rot).


s204

s204

205: code [Py.Processing]

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


s204

s204

204: code [Py.Processing]

At each cycle, it starts on the next node.


s203

s203

203: code [Py.Processing]

A big one, animated the maze generation process.


s202

s202

202: code [Py.Processing]

A bigger one


s201

s201

201: code [Py.Processing]


s200

s200

200: code [Py.Processing]


s199

s199

199: code [Py.Processing]


s198

s198

198: code [Py.Processing]


s197

s197

197: code [Py.Processing]


s196

s196

196: code [Py.Processing]


s195

s195

195: code [Py.Processing]


s194

s194

194: code [Py.Processing]


s193

s193

193: code [Py.Processing]


s192

s192

192: code [Py.Processing]


s191

s191

191: code [Py.Processing]


s190

s190

190: code [Py.Processing]


s189

s189

189: code [Py.Processing]


s188

s188

188: code [Py.Processing]


s187

s187

187: code [Py.Processing]


s186gif

s186gif

s186

s186

186: code [Py.Processing]


s185

s185

185: code [Processing Java]


s184

s184

184: code [Processing Java]


s183

s183

183: code [Processing Java]


s182

s182

182: code [Processing Java]


s181

s181

181: code [Processing Java]


s180

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

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

s179COLOR

s179PB

s179PB

179: code [Py.Processing]


s178

s178

178: code [Py.Processing]


s177

s177

177: code [Py.Processing]


s176

s176

176: code [Py.Processing]


s175

s175

175: code [Py.Processing]


s174

s174

174: code [Py.Processing]


s173

s173

173: code [Py.Processing]


s172

s172

172: code [Py.Processing]


s171

s171

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


s170

s170

170:code [Py.Processing]


s169

s169

169:code [Py.Processing]

Now same Z lines can form floors.


s168

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

s167

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


s166

s166

166: code [Py.Processing]


s165

s165

165: code [Py.Processing]


s164

s164

164: code [Py.Processing]


s163

s163

163: code [Py.Processing]

(#152 revisited in 3D :)


s162

s162

162: code [Processing Java]

Perlin Noise “walker” + ?


s161

s161

161: code [Processing Java]

Perlin Noise “walker” + eye


s160

s160

160: code [Processing Java]

Interactive genetic algorithm


s159

s159

159: code [Processing Java]


s158

s158

158: code [Py.Processing]


s157

s157

157: code [Py.Processing]


s156

s156

156: code [Py.Processing]


s155

s155

155: code [Py.Processing]


s154

s154

154: code [Py.Processing]


s153

s153

153: code [Py.Processing]


s152

s152

152: code [Py.Processing]


s151

s151

151: code [Py.Processing]


s150

s150

150: code [Py.Processing]


s149b

s149b

149b: code [Py.Processing]


s149

s149

149: code [Py.Processing]


s148

s148

148: code [Py.Processing]


s147

s147

147: code [Py.Processing]


s146

s146

146: code [Py.Processing]


s145

s145

145: code [Py.Processing]


s144

s144

144: code [Py.Processing]


s143

s143

143: code [Py.Processing]


s140 + s141 + s142

s140 + s141 + s142

140 + 141 + 142 code [Py.Processing]


s142

s142

142: code [Py.Processing]


s141

s141

141: code [Py.Processing]


s140

s140

s140: code [Py.Processing]


s139

s139

s139: code [Py.Processing]


s138

s138

138: code [Py.Processing]

Revisiting ideas of recursion from s071

Heavy animated GIF: s138.gif


s137

s137

s137: code [Py.Processing]

PDF: diagram.pdf


s136

s136

136: code [Py.Processing]


s135

s135

135: code [Py.Processing]


s134

s134

134: code [Py.Processing]


s133

s133

133: code [Py.Processing]


s132

s132

132: code [Py.Processing]


s131

s131

131: code [Py.Processing]


s130

s130

130: code [Py.Processing]


s129

s129

129: code [Py.Processing]

Maybe I fixed it, I guess, not sure…


s128

s128

128: code [Py.Processing]

BROKEN!


s127

s127

127: code [Py.Processing]


s126

s126

126: code [Py.Processing]


s125

s125

125: code [Py.Processing]


s124

s124

124: code [Py.Processing]


s123

s123

123: code [Py.Processing]


s122

s122

122: code [Py.Processing]


s121

s121

121: code [Py.Processing]


s120

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

s119

119: code [Py.Processing]


s118

s118

118: code [Py.Processing]


s117

s117

117: code [Py.Processing]


s116

s116

116: code [Py.Processing]


s115

s115

115: code [Py.Processing]


s114

s114

114: code [Py.Processing]


s113

s113

113: code [Py.Processing]


s112

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

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

s109

109: code [Py.Processing]

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

s108

s108

108: code [Py.Processing]

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


s107

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

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

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

s104

104: code [Py.Processing]

Back to stroke variation


s103

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

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

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

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

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

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

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

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

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

s094

094: code [Py.Processing]

Connection ‘rate’ can be less than 1, prevents less than 2 nodes


s093

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

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

s091

091: code [Py.Processing]

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


s090

s090

090: code [Py.Processing]

Opaque strokes, no fill, randomized colours by column.


s089

s089

089: code [Py.Processing]

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


s088

s088

088: code [Py.Processing]

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


s087

s087

087: code [Py.Processing]

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


s086

s086

086: code [Py.Processing]

Translucent fill & some stroke weight


s085

s085

085: code [Py.Processing]

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


s084

s084

084: code [Py.Processing]

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


s083

s083

083: code [Py.Processing]

Xs and rotated rectangles


s082

s082

082: code [Py.Processing]

Squares and ellipses


s081

s081

081: code [Py.Processing]

Let’s try some grids


s080

s080

080: code [Py.Processing]

More arrows (black and white alternate by generation)


s079

s079

079: code [Py.Processing]

Arrows (right black, left white)


s078

s078

078: code [Py.Processing]

Color


s077

s077

077: code [Py.Processing]

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


s076

s076

076: code [Py.Processing]

Stroke weight and some transparency


s075

s075

075: code [Py.Processing]

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


s074

s074

074: code [Py.Processing]

Adaptomg Shiffmans recusive Tree, with sliders or Pots…


s073

s073

073: code [Py.Processing]

The code remains ugly :(


s072

s072

072: code [Py.Processing]

Let’s mix some arrows?


s071

s071

071: code [Py.Processing]

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


s070

s070

070: code [Py.Processing]

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


s069

s069

069: code [Py.Processing]

Added rotation.


s068

s068

068: code [Py.Processing]

… and with sliders (by Peter Farell)


s067

s067

067: code [Py.Processing]

Something else.


s066

s066

066: code [Py.Processing]

Arrow grid networks can be sized and placed…


s065

s065

065: code [Py.Processing]

Arrow grid networks are now objects…


s064

s064

064: code [Py.Processing]

Revisiting yet an older graph, adding arrows…


s063

s063

063: code [Py.Processing]

Revisiting an older graph adding arrows…


s062

s062

062: code [Py.Processing]

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


s061

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

s060

060: code [Py.Processing]

Complete Object Oriented refactor…


s059

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

s058

058: code [Py.Processing]

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


s057

s057

057: code [Py.Processing]

Revisited 54 and now I’m re-selecting random points_to nodes…


s056

s056

056: code [Py.Processing]

Arrow grid moving in HSB colour space


s055

s055

055: code [Py.Processing]

Grid revisited


s054

s054

054: code [Py.Processing]

New arrows! With a “Tail” parameter…


s053

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

s052

052: code [Py.Processing]

White lines first, black arrows on top.


s051

s051

051: code [Py.Processing]

Points now on a grid.


s050

s050

050: code [Py.Processing]

Arrows now…


s049

s049

049: code [Py.Processing] Yet more graphs


s048

s048

048: code [Py.Processing] Yet more graphs


s047

s047

047: code [Py.Processing] Yet more graphs


s046

s046

046: code [Py.Processing] Yet more graphs


s045

s045

045: code [Py.Processing] Yet more graphs


s044

s044

044: code [Py.Processing] More graphs


s043

s043

043: code [Py.Processing] More graphs


s042

s042

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


s041

s041

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


040

040

040

040

040: sketch_180209a [Py.Processing] More recursion


039

039

039: sketch_180208e [Py.Processing] Manoloide inspired recursion


038

038

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


037

037

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


036

036

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


035

035

035: sketch_180204b [Py.Processing] Preparing for “Carnahacking”


034

034

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


033

033

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


032

032

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


031

031

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


030

030

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


29c

29c

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


28c

28c

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


27c

27c

027: sketch_180127c [Py.Processing]YouTube

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


26

26

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


25

25

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


24

24

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


23

23

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


022: missed :(


21b

21b

021b: sketch_180121b [Py.Processing] Playing with Peter “Hacking Math Class” Farrel’s Sliders!


20b

20b

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

20a

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

19a

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


18a

18a

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


17a

17a

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


16a

16a

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


15a

15a

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


14a

14a

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


13a

13a

013: s180113 [Py.Processing] 3D Graph


s180112

s180112

012: s180112 [Py.Processing] Another Graph Take


s180111

s180111

011: s180111 [Py.Processing] A Graph Take


s180110

s180110

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


GIF

GIF

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


GIF

GIF

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


GIF

GIF

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


GIF

GIF

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


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


GIF

GIF

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


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)


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.