Processing Class Balls

Script for very simplistic bouncing mechanics & using classes

 

Untitled-1.jpg

int number = 20;
int a = number-1;
int i;
Ball[] balls;
int rad=20;

 

void setup()
{
background (255);
size(500, 500);
noStroke();
fill(0);
balls = new Ball [number];

 

for (i = 0; i < number; i++)
{
balls[i] = new Ball(random(0, height), random(0, width), rad, rad, random(-2, 2), random(-2, 2), i, balls );
}
}

 

 

void draw()
{
background (0);
for (Ball bal : balls) {
bal.update();
bal.bounce();
bal.display();
}
}

class Ball
{
float b;
float c;
int sizex;
int sizey;
float incrementx;
float incrementy;
int id;
Ball[] others;

 

Ball(float btemp, float ctemp, int sizextemp, int sizeytemp, float incrementxtemp, float incrementytemp, int idtemp, Ball[] otherstemp)
{
b=btemp;
c=ctemp;
sizex=sizextemp;
sizey=sizeytemp;
incrementx=incrementxtemp;
incrementy=incrementytemp;
id=idtemp;
others=otherstemp;
}

void update()
{

if (b > width || b < 0)
{
incrementx=-incrementx;
}

if (c > height || c < 0)
{
incrementy=-incrementy;
}

b += incrementx; //add incrementX to posX
c += incrementy; //posY
}

void display()
{
fill(255);
ellipse(b, c, rad, rad);
}

void bounce()
{
int j;
for (j=id; j<number; j++)
{
float db= others[j].b – b;
float dc= others[j].c – c;
float distance = sqrt(db*db + dc*dc);
float minDist = others[j].sizex/2 + sizex/2;
if (distance < minDist)
{
incrementx =- incrementx;
others[j].incrementx =- others[j].incrementx;
incrementy =- incrementy;
others[j].incrementy =- others[j].incrementy;
b += incrementx;
others[j].b += others[j].incrementx;
c += incrementy;
others[j].c += others[j].incrementy;
}
}
}
}

Gothic-inspired Vaults

Process:

Sketches A3 

Sketches 2 A3

Selected Patterns A3

Spherical A3 (ornament)

Script:

GH Scripts A3

Script Diagram

Vault variations:

Vault Patterns1

Vault Patterns2

Vault Variations1

Vault Variations2

Architectural Renderings:

Top View

Visual 1

Visual2

Visual3

Simple Section

Booklets:

Process Renderings:

Process Renderings A4

Patterns:

Patterns Booklet A4

Ribs:

6ribs9ribs10ribs

Vaults:

6 vault9 vault10 vault

A System for Constrained Aggregation

Rule-Based Component Aggregation with Constrained Rotation, Reflective Symmetry and Collision Detection | September-October 2017

This project resulted in the development of a geometrically general but compositionally constrained system for component aggregation in the Rhinoceros 3D / Python environment. Components and connection points are defined as blocks in Rhinoceros, and parameters for aggregation rules, rotation constraints and levels of symmetry are given as Python variables.

Random Populations and Notations

sticks 2A 1.jpg

sticks 2A 2.jpg

 

Random Populations

boxes 1.jpg

boxes 3.jpg

Studies

2,4,8,16 it.jpg
Tree recursion – 2, 4, 8, 16 iterations
symm larger matrix.png
Reflectional symmetry

 

Iterative Cursor Growth

 

Koch snowflake 3D (finally!)

With some (a lot) of help from different tutorials and Pablo and Annie, I finally have a Python script producing the famous fractal “the Koch Curve”, in the 3D version, namely the Koch Snowflake. At last!! (even though the result is not as important as the process, it is certainly nice to rest one’s eyes upon it. This image is unfortunatelly rasterized. And, one really need to zoom in on the tetrahedra in the last generations)

Weekly Update

I’ve been keeping a personal process documentation on Google Docs and forgot to update myself here (whoops). I’ll upload some of the recent parts of it:

07.10

I figured out I’d try out the simple square origami tessellation. Additional creases need to be created in order to shape it into the following:

Without the additional creases, it can still be quite flexible and can be bent into a spiral form with force, but it’s only manageable because of the paper material. The pattern texture is quite pleasing looking in my eyes, though.

08.10

I encountered another type of origami, called hyperbolic folding. The crease pattern tends to follow the shape of the paper. It will automatically become a fixed shape (they call it hypar form) when mountain and valley creases are applied. The diagonal creases are supposed to be the base/skeleton for the origami structure.

 

I came to the conclusion that this kind of origami is best used for structure and display (in architecture). I want to try out combining this and the square tessellation origami together, to see if the square pattern can be created into a structure of its own. I will need a bigger paper size for it. I would also need some Grasshopper help in order to recreate the model in the program as well…

Work progress together with assignment_02

Work progress together with assignment_02

Going deeper exploring simple platonic/archimedean solids having them as a frame/lattice structure in which different kind of geometry can be created. Trying to find/define the rules for creating continous space and/or different geometry.

Learned how to create tilling patterns, morphing definition, mesh relaxation in kangaroo and some aggregations with Fox plugin, trying to combine aggregations with a mesh relaxation.

jpg

Voisnis_assignment_02 (2)