Creating Chaos with Perlin Noise

ChaosCircles1 of 3

ChaosCircles2-of-3

ChaosCircles3-of-3
I modified my pattern program to take input from the mouse’s X and Y positions to cause changes in color and circle location. Through this project, I learned a bit about how to use Perlin noise, as well as how to scale it so that the mouse’s movement has greatest effect on the visual output. I suppose the next step would be to implement Perlin noise on a larger scale to create some sort of natural pattern.

//Copyright Miranda Jacoby 2014

//A big thanks to Matt for helping me figure out how to use perlin noise!
//A big thanks to Golan for helping me figure out how to scale perlin noise!

//***How This Program Works***
//The closer the mouse is to the bottom right corner, 
//the more chaotic the colors get.

//number of circles
float cnum = 30;
//circle x and y coordinates
float cx = noise(frameCount*0.1);//20;
float cy = noise(frameCount*0.2);//20;
//circle width and height
float cw = 50;
float ch = 50;
//circle offsetx and offsety
float offsetx = 25;
float offsety = 25;

void setup () {
 size (600, 600) ;
 //background(130, 108, 245);
}

void draw () {
  background(255);
  //offsetx = offsetx + random(-10, 10);
  //offsety = offsety + random(-10, 10);
  for (int i=0; i<cnum; i++) {
    cx = 50*i;
        for (int j=0; j<cnum; j++) {
          cy = 50*j;
          
          float mouseInfluenceX = map(mouseX, 0,width, 0,1); // 0...1
          mouseInfluenceX = pow(mouseInfluenceX, 4); //noise scaled down by power of 4
          mouseInfluenceX = mouseInfluenceX * width; //noise scaled back to window sizw
          
          float mouseInfluenceY = map(mouseY, 0,height, 0,1); // 0...1
          mouseInfluenceY = pow(mouseInfluenceY, 4); //noise scaled down by power of 4
          mouseInfluenceY = mouseInfluenceY * height; //noise scaled back to window size
          
          float noisex = (noise(cx, cy, frameCount*0.1)-0.5)*mouseInfluenceX; // -0.5 makes it so that noise is centered on zero.
          float noisey = (noise(cx, cy, frameCount*0.5)-0.5)*mouseInfluenceY;
          float cx2 = cx+ noisex;
          float cy2 = cy+ noisey;
          fill(random(i,i+j),random(400-mouseX,401),random(400-mouseY,401), 25);  
          //The above line adapts code found in yousufali.n's Mouse Position & color Behavior with circles,
          //which can be found at https://openprocessing.orgsketch/84991.
          //float noiseVal = noise((mouseX+i)*noiseScale, mouseY*noiseScale);
          ellipse(cx2, cy2, cw, ch);
          ellipse(cx2, cy2, cw + offsetx, ch + offsety);
          ellipse(cx2, cy2, cw + offsetx*2, ch + offsety*2); //Tile-like
        
    }
  }
}

Pattern Production

patternScreenShot

I decided to create a tile-like pattern once I’d realized that I could overlap colors to create new ones by using the fourth parameter of fill(), which modifies opacity/transparency. The overall aesthetic reminds me of the tile work one would expect to find at the bottom of a fountain. I think this project gave me a firm understanding of the visual capabilities of nested for-loops (although I shudder to think what a nested-nested-nested for-loop would look like).

//Miranda Jacoby
//EMS Interactivity Section A
//majacoby@andrew.cmu.edu
//Copyright Miranda Jacoby 2014

int cx = 20;
int cy = 20;
int cw = 50;
int ch = 50;
int offsetx = 25;
int offsety = 25;

void setup () {
 size (800, 800) ;
 //background(130, 108, 245);
}

void draw () {
  
  for (int i=0; i<17; i++) {
    cx = 50*i;
        for (int j=0; j<17; j++) {
          cy = 50*j;
          
          //fill(150, 25); //smoother? what is the difference of calling fill here?
            //fill(150, 30, 255, 50);    //pattern with color
          fill(105, 0, 0, 25);
          ellipse(cx, cy, cw, ch);
          //pattern withuot color
         // fill(150, 50);
               //fill(42, 208, 165, 50); //mixing colors with transparency
          fill(0, 225, 0, 25);
          ellipse(cx, cy, cw + offsetx, ch + offsety);
          //ellipse(cx, cy, cw + offsetx/2, ch + offsety/2); //More complex
          fill(0, 0, 255, 25);
          ellipse(cx, cy, cw + offsetx*2, ch + offsety*2); //Tile-like
        
    }
  }
}
void mousePressed(){
 println("mousepressed"); 
  saveFrame();
}

CSB — Looking Outwards 3 — Generativity

Looking Outwards — Generative Software, BioPoetics, Materials

 

SCIgen

Each time SCIgen runs, it generates fake natural language in the form of a new computer science research papers. It has both utilitarian and critical uses, in that it can be used specifically to test the submission standards of journals and its existence as an open tool represents a broader critique of  It was developed in 2005 as a source of “amusement” by a group of graduate students in the PDOS (Parallel and Distributed Operating Systems) group in MIT’s computer science department. Generate your own paper here! You can customize the authors’ names as well.

 

The Xenotext

xenotext

Poet & bioartist Christian Bök’s Xenotext is the first example of a poem and system for generating poetics being implanted in a non-human biological substrate. It’s worth quoting his own explanation in full, as it explains the process more succinctly than I could:

“When translated into a gene and then integrated into the cell, my poem [in the form of a sequence of engineered DNA]  is going to constitute a set of instructions, all of which cause [sic] [an extremophile bacterium] to manufacture a viable, benign protein in response—a protein that, according to my original, chemical alphabet, is itself yet another text. I am, in effect, engineering a life-form so that it becomes not only a durable archive for storing a poem, but also an operant machine for writing a poem” – Christian Bök

XP13-3 (xenotext protein)

 

4D Printing

A collaboration between MIT (Skylar Tibbits of MIT’s SJET lab gave the TED talk), Autodesk, and Stratsys , 4D Printing is a project in which 3D printed structures are designed to autonomously change their conformations in specific ways over time. Though rudimentary at this point in time, the biomimetic possibilities of 4D printing are fascinating. Below is a video that demonstrates one such structure, which self-folds much like proteins do. The morphogenetic process that gives rise to the tertiary structure of proteins is both complex and crucial to the proper functioning of proteins, the structures they make up, and the organism at large. For instance, the conversion of healthy proteins into prions or mis-folded proteins, is thought to cause transmissible spongiform encephalopathies including “Mad Cow Disease.”

4D Printing: Self-Folding Protein from Skylar Tibbits on Vimeo.

BLINK

I happily did this project with Will Taylor link -./wht/09/10/assignment-03-blink/

Looking Outwards: Generative and Algorithmic Arts

depth-10 quadtree + depth-3 voronoi tree from postspectacular on Vimeo.

This render was created by merging together two algorithmic structures. It was created algorithmically, nothing was done by hand. I thought it was incredible how knowledge and mastery of these data structures made it possible for them to be used as a medium to create visuals like these.

page96-1

This excerpt from Artist and Computer contains many great examples of Manfred Mohr’s generative artwork, and discusses Mohr’s ideas about art and machines. Mohr’s work is interesting to me because there is a distinct aesthetic of Mohr’s work. Mohr works in a very abstracted way (using code to make rules) where the ‘artist’s hand’ is not necessarily seen in the work, but he is still able to create these stylized algorithms unique only to him.

Big-Eye Trevally from flight404 on Vimeo.

Big-Eye Trevally simulates the physics of thousands of fish in a group. I found this project very interesting because it’s a good example of playing around with algorithms directly from nature. With most generative art, the algorithm is created by the artist. In simulations such as those in Big-Eye Trevally, the algorithm is appropriated from nature itself.
This project made me very curious about algorithms and simulation. An artist can create an algorithm, and the computer can act as the simulator. In nature, the algorithms are the basic laws of physics, but what is the simulator? What makes these laws “go”? Generative art may be able to explore such ideas.

P5.JS Face

My sketch converts an image to ellipses, but purposefully reads the pixels of the jpeg file incorrectly. It’s kind of hard to see the face, but it’s in there somewhere.

Face