One visual idea a day
Switch branches/tags
Nothing to show
Clone or download
Latest commit bddcb04 Dec 12, 2018
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
_layouts layout Jan 4, 2018
assets/css Update style.css May 4, 2018
s041 day 41 Feb 10, 2018
s042 day 44 Feb 13, 2018
s043 day 43 (and some older fixes) Feb 12, 2018
s044 Merge branch 'master' of https://github.com/villares/sketch-a-day Feb 13, 2018
s045 day 47 Feb 17, 2018
s045b day 50 Feb 19, 2018
s046 day 47 Feb 17, 2018
s047 smaller GIF Feb 17, 2018
s048 day 48! Feb 18, 2018
s049 day 50 Feb 19, 2018
s050 50 comments Feb 19, 2018
s051 51 fix Feb 22, 2018
s052 day 53 (& 52 refactor) Feb 22, 2018
s053 comments and promissing a new arrow def will come… Feb 22, 2018
s054 day 54, readme Feb 23, 2018
s055 head comment 55 Feb 27, 2018
s056 Day 57 Feb 26, 2018
s057 Day 57 Feb 26, 2018
s058 58 head comment Mar 1, 2018
s059 59 small fixes Mar 1, 2018
s060 small adjustments Mar 2, 2018
s061 Merge branch 'master' of https://github.com/villares/sketch-a-day Mar 3, 2018
s062 62 gif! Mar 3, 2018
s063 gig 63! Mar 5, 2018
s064 gif 64 Mar 6, 2018
s065 say 66 Mar 8, 2018
s066 say 66 Mar 8, 2018
s067 day 68 Mar 10, 2018
s068 fixed 68's comments! Mar 10, 2018
s069 fixing comments Mar 11, 2018
s070 71 Mar 13, 2018
s071 71 Mar 13, 2018
s072 say 73 Mar 14, 2018
s073 comments Mar 14, 2018
s074 frameRate() should not be inside draw()!!! Mar 25, 2018
s075 frameRate() should not be inside draw()!!! Mar 25, 2018
s076 frameRate() should not be inside draw()!!! Mar 25, 2018
s077 frameRate() should not be inside draw()!!! Mar 25, 2018
s078 frameRate() should not be inside draw()!!! Mar 25, 2018
s079 frameRate() should not be inside draw()!!! Mar 25, 2018
s080 frameRate() should not be inside draw()!!! Mar 25, 2018
s081 frameRate() should not be inside draw()!!! Mar 25, 2018
s082 small fixes Mar 26, 2018
s083 small fixes Mar 26, 2018
s084 small fixes Mar 26, 2018
s085 gif 85! Mar 27, 2018
s086 day 86 Mar 28, 2018
s087 clean up Mar 30, 2018
s088 renamed circles & squares Mar 30, 2018
s089 rectMode() comment Mar 30, 2018
s090 day 90 Apr 1, 2018
s091 segond clean up Apr 2, 2018
s092 useless list() Apr 6, 2018
s093 useless list() Apr 6, 2018
s094 useless list() Apr 6, 2018
s095 day 95 Apr 6, 2018
s096 Day 96 Apr 6, 2018
s097 day 98 Apr 8, 2018
s098 day 99 Apr 9, 2018
s099 day 100 Apr 10, 2018
s100 day 100 Apr 10, 2018
s101 day 102! hexagrid Apr 13, 2018
s102 day 103 Apr 14, 2018
s103 update 103 Apr 14, 2018
s104 Update s104.pyde Apr 15, 2018
s105 day 105 gif Apr 15, 2018
s106 ups! wrong folder Apr 30, 2018
s107 comments Apr 18, 2018
s108 day 108 Apr 18, 2018
s109 ups... rename 109 Apr 19, 2018
s110 day 110 & 111 Apr 21, 2018
s111 day 110 & 111 Apr 21, 2018
s112 day 112 Apr 23, 2018
s113 day 114 Apr 25, 2018
s114 day 114 Apr 25, 2018
s115 fix 115 & day 116 Apr 27, 2018
s116 fix 115 & day 116 Apr 27, 2018
s117 day 118 Apr 29, 2018
s118 day 119 Apr 30, 2018
s119 ups! wrong folder Apr 30, 2018
s120 [::-1] -> reversed() May 1, 2018
s121 cleanup May 4, 2018
s122 cleanup May 4, 2018
s122_revisited 160 Jun 10, 2018
s123 Day 123 May 4, 2018
s124 day 124 May 5, 2018
s125 125b! May 6, 2018
s126 comments May 9, 2018
s127 comments May 9, 2018
s128 Day 128 May 9, 2018
s129 ups May 11, 2018
s130 day 131 May 12, 2018
s131 131 May 12, 2018
s132 133 May 14, 2018
s133 Update s133.pyde May 15, 2018
s134 Add files via upload May 15, 2018
s135 134 & 135 May 15, 2018
s136 day 136 May 16, 2018
s137 137 readme May 18, 2018
s138 138 & 139 date fix May 20, 2018
s139 readme corrections (missing s137!) May 20, 2018
s140 140 gif off May 23, 2018
s140_s141_s142 ops, wrong name May 23, 2018
s141 140 gif off May 23, 2018
s142 142 May 22, 2018
s143 143 May 24, 2018
s144 144 May 25, 2018
s145 cleanup 145 May 26, 2018
s146 coisas velhas sobrando May 26, 2018
s147 147 May 27, 2018
s148 148 May 28, 2018
s149 149b May 29, 2018
s149b smaller GIF May 29, 2018
s150 150 May 31, 2018
s151 correct date Jun 1, 2018
s152 remove noLoop() debug Jun 1, 2018
s153 153 Jun 2, 2018
s154 155 Jun 5, 2018
s155 157 Jun 7, 2018
s156 156 Jun 6, 2018
s157 157 Jun 7, 2018
s158 158b Jun 8, 2018
s159 smaller gif 159 Jun 10, 2018
s160 160 Jun 10, 2018
s161 161 eye Jun 11, 2018
s161_plus_gif_exporter 163 Jun 12, 2018
s162 162 Jun 11, 2018
s163 163 Jun 12, 2018
s164 164 & 165 mov & png Jun 14, 2018
s165 164 & 165 mov & png Jun 14, 2018
s166 166 Jun 15, 2018
s166_py 166 fix Jun 15, 2018
s167 pontos & boxes -> points Jun 17, 2018
s167_py pontos & boxes -> points Jun 17, 2018
s167_slower readme 167 Jun 16, 2018
s168 pontos & boxes -> points Jun 17, 2018
s169 169 Jun 17, 2018
s170 170 Jun 18, 2018
s171 day & comments Jun 26, 2018
s171_py day & comments Jun 26, 2018
s172 day & comments Jun 26, 2018
s172b readme Jun 23, 2018
s173 day & comments Jun 26, 2018
s174 Update s174.pyde Oct 1, 2018
s175 day & comments Jun 26, 2018
s176 day & comments Jun 26, 2018
s177 fixing readme 177 178 180 Jul 4, 2018
s177_gif 177 e 178 Jun 25, 2018
s178 fixing readme 177 178 180 Jul 4, 2018
s179 179 Jun 26, 2018
s180 comments Jul 4, 2018
s180101 comments Jan 5, 2018
s180102 49.... Feb 19, 2018
s180103 comments Jan 5, 2018
s180104 comments Jan 5, 2018
s180105 placement Jan 6, 2018
s180106 cleanup Jan 8, 2018
s180107 cleanup Jan 8, 2018
s180108 type_ & Manoloide Jan 9, 2018
s180108_liveEdu Update PlatonicSolids.py Jan 9, 2018
s180109 c! Jan 11, 2018
s180110 180110 Jan 11, 2018
s180111 day 12 Jan 12, 2018
s180112 sketch 13 Jan 13, 2018
s181 183 Jul 1, 2018
s182 183 Jul 1, 2018
s183 184 Jul 2, 2018
s184 185 Jul 3, 2018
s185 185 Jul 3, 2018
s186 186 & 187 Jul 5, 2018
s186gif 186gif Jul 5, 2018
s187 188 cleanup Jul 6, 2018
s188 188 cleanup Jul 6, 2018
s189 189 Jul 7, 2018
s190 190 Jul 7, 2018
s191 191 Jul 9, 2018
s192 192 Jul 9, 2018
s193 lighter 193 Jul 11, 2018
s194 194 Jul 11, 2018
s195 196 Jul 13, 2018
s196 196 revised! Jul 13, 2018
s197 197 Jul 14, 2018
s198 198 b Jul 15, 2018
s199 199 Jul 17, 2018
s200 200 Jul 18, 2018
s201 readme 201\ Jul 19, 2018
s202 202 & 203 Jul 20, 2018
s203 203 pngs Jul 21, 2018
s204 204 comment Jul 22, 2018
s205 205 & 205b Jul 22, 2018
s205b 205 & 205b Jul 22, 2018
s206 206 Jul 24, 2018
s207 207 date Jul 26, 2018
s208 208 Jul 26, 2018
s208b 208b Jul 27, 2018
s209 209 update Jul 27, 2018
s210 210 cleanup Jul 28, 2018
s211 211 conceptual reframe (similar visual result) Jul 29, 2018
s212 212 fix comment Jul 30, 2018
s213 213 Jul 30, 2018
s214 fixing dates Aug 3, 2018
s215 fixing dates Aug 3, 2018
s216 216 cleanup Aug 3, 2018
s217 217 Aug 4, 2018
s218 218 revert Aug 5, 2018
s219 220 Aug 6, 2018
s220 220 date Aug 7, 2018
s221 221 gif & seed Aug 7, 2018
s222 222 gif fix Aug 8, 2018
s223 223 Aug 9, 2018
s224 cleanup & comments Aug 11, 2018
s225 225 readme Aug 11, 2018
s226 226 Aug 12, 2018
s227 227 Aug 13, 2018
s228 228 Aug 15, 2018
s229 ooops Aug 16, 2018
s230 230 Aug 16, 2018
s231 readme Aug 20, 2018
s232 232 Aug 19, 2018
s233 233 recover! Aug 21, 2018
s234 234 Aug 21, 2018
s235 235 Aug 22, 2018
s236 237 Aug 24, 2018
s237 237 Aug 24, 2018
s238 238 Aug 25, 2018
s239 239 Aug 25, 2018
s240 240 Aug 27, 2018
s241 241 Aug 28, 2018
s241_simplified 241 Oct 10, 2018
s242 update readme Sep 14, 2018
s243 243 Sep 16, 2018
s244 244 png Sep 14, 2018
s245 reverted 244 to original code Sep 14, 2018
s246 246 doc Sep 14, 2018
s247 updated dates and readme Sep 15, 2018
s248 updated dates and readme Sep 15, 2018
s249 updated dates and readme Sep 15, 2018
s250 updated dates and readme Sep 15, 2018
s251 updated dates and readme Sep 15, 2018
s252 updated dates and readme Sep 15, 2018
s253 updated dates and readme Sep 15, 2018
s254 updated dates and readme Sep 15, 2018
s255 updated dates and readme Sep 15, 2018
s256 updated dates and readme Sep 15, 2018
s257 updated dates and readme Sep 15, 2018
s258 updated dates and readme Sep 15, 2018
s259 date and number comment fix Sep 17, 2018
s260 date and number comment fix Sep 17, 2018
s261 261 Sep 17, 2018
s262 s262 Sep 17, 2018
s263 Add files via upload Sep 18, 2018
s264 264 Sep 19, 2018
s265 265 & 266 Sep 22, 2018
s266 265 & 266 Sep 22, 2018
s267 267 Sep 22, 2018
s268 268 randint Sep 25, 2018
s268_pygame size(width, height) Sep 25, 2018
s269 272 Sep 28, 2018
s269_pygame 272 Sep 28, 2018
s270 270 Sep 26, 2018
s271 271 refactor Sep 30, 2018
s271b 271 refactor Sep 30, 2018
s272 Update s272.pyde Oct 28, 2018
s273 273 font option Sep 29, 2018
s274 274 cleanup Sep 30, 2018
s275 275 Sep 30, 2018
s276 276 Oct 2, 2018
s277 277 Oct 3, 2018
s278 278 Oct 3, 2018
s279 279 Oct 4, 2018
s280 fix date Oct 8, 2018
s281 fix date Oct 8, 2018
s282 282 283 Oct 10, 2018
s283 282 283 Oct 10, 2018
s284 date Oct 11, 2018
s285 285 no save Oct 13, 2018
s285_order one more step into the face problem Oct 23, 2018
s286 286 cleanup Oct 13, 2018
s287 287 cleanup Oct 13, 2018
s288 smaller 288 gif Oct 15, 2018
s289 289 Oct 15, 2018
s290 290 & 291 background Oct 17, 2018
s291 290 & 291 background Oct 17, 2018
s292 292 Oct 17, 2018
s293 293 Oct 18, 2018
s294 294 gif Oct 21, 2018
s295 295 cleanup2 Oct 21, 2018
s296 296 Oct 22, 2018
s297 Update s297/s297.pyde Oct 22, 2018
s298 Update s298/s298.pyde Oct 27, 2018
s299 299 Oct 27, 2018
s300 300 Oct 27, 2018
s301 301 Oct 27, 2018
s302 302 Oct 28, 2018
s303 303 Oct 29, 2018
s304 304 gif Oct 31, 2018
s305 305 png & readme Oct 31, 2018
s306 cleanup Nov 3, 2018
s307 cleanup Nov 4, 2018
s308 cleanup Nov 4, 2018
s309 cleanup Nov 4, 2018
s310 smaller gifs Nov 8, 2018
s311 311 & 312 Nov 6, 2018
s312 311 & 312 Nov 6, 2018
s313 Update s313/s313.pyde Nov 8, 2018
s314 314 Nov 8, 2018
s315 315 Nov 9, 2018
s316 Update s316/s316.pyde Nov 12, 2018
s317 Update s317/s317.pyde Nov 12, 2018
s318 318 update Nov 13, 2018
s319 Add files via upload Nov 17, 2018
s320 319 320 Nov 15, 2018
s321 321 Nov 16, 2018
s322 s322 Nov 17, 2018
s323 Rename s323b.pyde to s323.pyde Nov 19, 2018
s324 Create s324.png Nov 20, 2018
s325 s325 Nov 20, 2018
s326 Create s326.png Nov 23, 2018
s327 Create s327.png Nov 23, 2018
s328 328 ups Nov 23, 2018
s329 329 Nov 24, 2018
s330 330 Nov 24, 2018
s331 331a Nov 26, 2018
s332 332 Nov 27, 2018
s333 333 Nov 28, 2018
s334 334 Nov 28, 2018
s335 335 Nov 30, 2018
s336 updates Dec 2, 2018
s337 comments 337 & 338 Dec 2, 2018
s338 338 Dec 2, 2018
s339 339 Dec 3, 2018
s340 readme Dec 7, 2018
s341 readme Dec 7, 2018
s342 342 Dec 7, 2018
s343 readme Dec 7, 2018
s344 readme Dec 8, 2018
s345 s345 Dec 10, 2018
s346 recover_346 Dec 12, 2018
s347 s347 Dec 12, 2018
s348 s348 Dec 12, 2018
sketch_180113a smaller! Jan 13, 2018
sketch_180114a day 14 Jan 14, 2018
sketch_180115a readme image day 16 Jan 16, 2018
sketch_180116a day17 Jan 17, 2018
sketch_180117a comments 18 Jan 18, 2018
sketch_180118a 20a improvement... Jan 21, 2018
sketch_180119a 20 B! Jan 20, 2018
sketch_180120a day 20a... Jan 21, 2018
sketch_180120b 20a improvement... Jan 21, 2018
sketch_180121b better credit to Peter "Hacking Math" Farell pointing to GitHub repo Jan 22, 2018
sketch_180123b day 24 Jan 25, 2018
sketch_180124b comment Jan 25, 2018
sketch_180125c coments day 25 Jan 26, 2018
sketch_180126c day 26 Jan 26, 2018
sketch_180127c save frame Jan 27, 2018
sketch_180128c removed enumerate() Jan 28, 2018
sketch_180129c save frame update Jan 30, 2018
sketch_180130c day 30 Jan 31, 2018
sketch_180131c day 32 Feb 1, 2018
sketch_180201c day 32 Feb 1, 2018
sketch_180202c day 33 Feb 2, 2018
sketch_180202campus day 33 Feb 2, 2018
sketch_180203c day 34 Feb 4, 2018
sketch_180204b Update sketch_180204b.pyde Feb 6, 2018
sketch_180205b Update sketch_180205b.pyde Feb 6, 2018
sketch_180206a day 37 Feb 6, 2018
sketch_180208d intro comments Feb 10, 2018
sketch_180208e intro comments Feb 10, 2018
sketch_180209a day 43 (and some older fixes) Feb 12, 2018
.gitignore 141+142+143 May 23, 2018
README.md 345 Dec 11, 2018
_config.yml layout Jan 4, 2018

README.md


sketch-a-day

one visual idea a day [on GitHub!]

Hi! I'm Alexandre Villares, let's see if I can make one small program (sketch) a day. I'm working mostly with Python (Processing Python Mode) and sometimes Processing Java Mode and P5JS (JavaScript) or other stuff.

If you enjoy this, be a patreon or make a donation here

Feel free to contact me regarding licenses to use my work, teaching opportunities, consulting or other projects.


s346

346: code [Py.Processing]


s345

345: code [Py.Processing]


s344

344: code [Py.Processing]


s343

343: code [Py.Processing]


s342

342: code [Py.Processing]


s341

341: code [Py.Processing]


s340

340: code [Py.Processing]


s339

339: code [Py.Processing]


s338 338: code [Py.Processing]


s337

337: code [Py.Processing]


s336

336: code [Py.Processing]


s335

335: code [Py.Processing]


s334

334: code [Py.Processing]


s333

333: code [Py.Processing]


s332

332: code [Py.Processing]


s331

331: code [Py.Processing]


s330

330: code [Py.Processing]


s329

329: code [Py.Processing]


s328

328: code [Py.Processing]


s327

327: code [Py.Processing]


s326

326: code [Py.Processing]


s325

325: code [Py.Processing]


s324

324: code [Py.Processing]


s323

323: code [Py.Processing]


s322

322: code [Py.Processing]


s321

321: code [Py.Processing]


s320

320: code [Py.Processing]


s319

319: code [Py.Processing]


s318

318: code [Py.Processing]


s317

317: code [Py.Processing]


s316

316: code [Py.Processing]

A 3D take on 314


s315

315: GIF code [Py.Processing]

Horizontaly connected 314


s314

314: code [Py.Processing]

Isolating elements from 313


s313

313: code [Py.Processing]


s312

312: code [Py.Processing]


s311

311: code [Py.Processing]


s310

310: code [Py.Processing]


s309

309: code [Py.Processing]


s308

308: code [Py.Processing]


s307

307: code [Py.Processing]


s306

306: code [Py.Processing]


s305

305: code [Py.Processing]


s304

304: code [Py.Processing]


s303

303: code [Py.Processing]


s302

302: code [Py.Processing]

Hatches parallel to opposed sides.


s301

301: code [Py.Processing]

Tried to supress some vertices from the hatch grid.


s300

300: code [Py.Processing]

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


s299

299: code [Py.Processing]

Inclined hatches


s298

298: code [Py.Processing]

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


s297

297: code [Py.Processing]

Changed my internal point grid to "pixels"


s296

296: code [Py.Processing]

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


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

294: code [Py.Processing]

Playing with my code for lines intersecting polygons.


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

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/s111.gif)

111: [code](https://github.com/villares/sketch-a-day/tree/master/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

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)