Thursday, 7 June 2012

final

This is my final application!

Stars
http://www.openprocessing.org/sketch/63533





My code

float [] x= new float[100];
float [] y= new float[100];
float [] a= new float[100];
float [] b= new float[100];
float [] xdot= new float[500];
float [] ydot= new float[500];

float r = random (-250,250);
float r2 = random (-250,250);
float r3 = random (-250,250);

float centerX= 250;
float centerY= 250;


void setup() {
  size (500, 500);

    int count = 0;
  while (count<500){
  xdot[count] = random (500);
  ydot[count] = random (500);
  count = count+1;
  }

    int i =0;

  while (i<100) {
  x[i] = 250;
  y[i] = 250;
  a[i] = r2;
  b[i] = r3;
    i=i+1;
  }
  }


void draw() {

  background(0);

    int count = 0;
  while (count<500){
  float R = random (0);
  float G = random (100, 150);
  float B= random (100, 200);
  fill (R, G, B);
  noStroke();
  ellipse (xdot[count], ydot[count], 1, 1);
  count = count+1;
  }

  float R = random (0);
  float G = random (100, 150);
  float B= random (100, 200);
  fill (R, G, B);
  noStroke();
  if (mousePressed == true) {
  float r = 5;

      int i =0;
    while (i<100) {
      x[i]= x[i] + ((mouseX-x[i]) / (5.0 + (i*5.0) ));
      y[i]= y[i] + ((mouseY-y[i]) / (5.0 + (i*5.0) ));

      i=i+1;
    }

    int newcirc = 0;
    int arms=7;
    centerX=centerX+((mouseX-centerX)/50.0);
    centerY=centerY+((mouseY-centerY)/50.0);

    while (newcirc<arms) {
      pushMatrix();
      translate(centerX, centerY);
      rotate((TWO_PI/arms)*newcirc);
      translate(-centerX, -centerY);

        i =0;
      while (i<100) {
        ellipse (x[i], y[i], r, r);
       
        i=i+1;
      }

      popMatrix();

      newcirc=newcirc+1;
      }

    ellipse(centerX, centerY, r, r);
  }


  else {

    float r = 5;
    float t = 5;
    int i =0;
    while (i<100) {
      x[i]= x[i] + ((mouseX-x[i]) / (5.0 + (i*5.0) ));
      y[i]= y[i] + ((mouseY-y[i]) / (5.0 + (i*5.0) ));

      i=i+1;
    }

      int newcirc = 0;
      int arms=7;
    while (newcirc<arms) {
      pushMatrix();
      translate(mouseX, mouseY);
      rotate((TWO_PI/arms)*newcirc);
      translate(-centerX, -centerY);

        i =0;
      while (i<100) {

        fill(R, G, B, t);
        ellipse (x[i], y[i], r, r);
        i=i+1;
      }

      popMatrix();

      newcirc=newcirc+1;
    }
    fill(R, G, B, t);
    ellipse(mouseX, mouseY, r, r);
  }
}

void mousePressed (){
  centerX=mouseX;
  centerY=mouseY;
}



Wednesday, 6 June 2012

Experimentation with the background

Using picture of space

some of the pictures I tried as well






Attempt to get stars on the background moving as well.
I know why this attempt failed. Because all the dots follow the mouse and then they all just stay right under the cursor overlapping each other, so they look as a one dot. But I jst didn't manage to figure out the way how to make them just chase the mouse all the time without going directly to the cursor and staying there.

Thursday, 24 May 2012

experimentation

I was jst sittting in front of my laptop, trying to learn and understand processing, so I was just playing around with position and size of the objectand suddenly made somethinng that i really like.
Even though it is not an interaction yet, i moved from the direct control onto the next stage.

mousePressed != true

mousePressed == true
http://www.openprocessing.org/sketch/62560

mirror
http://www.openprocessing.org/sketch/63609/check

double mirror
http://www.openprocessing.org/sketch/63611


chasing_the_mouse_blue_mouse_BETTER

http://www.openprocessing.org/sketch/63657
quite a cool thing=) fun to play with

Moving onto loops and arrays!!!

loops_an_arrays
http://www.openprocessing.org/sketch/63658/check
I like the crazy little star that I got and the way it moves, bt because of flashing it goves me headache. So I should probably get rid of it.

CURSOR_loops_and_arrays
http://www.openprocessing.org/sketch/63659/check
Now something is going on on the screen even if tghe button is not pressed




Thursday, 17 May 2012

My interactive application development

http://www.openprocessing.org/sketch/61774
First scetch

http://www.openprocessing.org/sketch/61911
Developed version. Now my string goes back to it's original position. Plus I made it more stulish

http://www.openprocessing.org/sketch/61912
Now I made my string move slower when it's pulled, but now it moves much slower

Friday, 11 May 2012

"The impossible game" Project 3 (Interactive mouse toy) inspiration





The first thing that came into my mind after reading the project 3 outline was "The impossible game". I know this is a game, not an interaction, but I think it's a great example of how really simple thing can be really interesting and fun to play with, which proves that something interesting and amazing doesn't mean something complex. I probably should tell a little bit about the game itself. "The impossible game" is an i-pod application. Basically the rules are you touch the screen at the right moment. When you touch the screen, the little cube jums over the obstacles and if you don't do it at the right moment it explodes and you start the level from the very begining.
Also what I love about this game is that the cube is supposed to jump to the beat, so the music is used to help to get the right moment

And just to show you what happens if you fail. http://www.youtube.com/watch?v=NCuM5M-DfPw

Monday, 30 April 2012

Final hand in

These picture represent the development wich I hv chosen as my final hand in. So I chose my final 8 images out of these. Here is also my final code.

 noise :  int ran = 0

 noise :  int ran =1

 noise :  int ran =2

 noise :  int ran =3

noise :  int ran =5
 noise :  int ran = 10

 noise :  int ran = 25

noise :  int ran =50
 noise :  int ran = 100

noise :  int ran = 200

int x = 55;
int y = 55;
int w1 = 10;
int w2 = -100;
int w2a = 100;
int h1 = -10;
int h2 = 10;
int h2a = -100;

void setup()
{
  size(1020, 1020);
     
  background(255);
   stroke(0);
  int i=0;
 
 
  while (i<200)
  {
    int xoffset = i*85;
   
    int j=0;
   
   
    while(j<100)
    {
      int yoffset = j*85;
     
      float r = 255-j*i*2;
      float g = 255-j*i*2;
      float b = 255;
      fill (r, g, b);
     
       /*
       float r = random(77,170);
      float g = random(21,135);
      float b = random(12,77);
      fill (r, g, b);
      */
     
     
      /*color from = color(77, 21, 12);
      color to = color(170, 135, 77);
      color interA = lerpColor(from, to, random(0.0, 1.0));
      fill(interA);*/
     
     
     
      int ran  = 0;

       float r1 = random(-ran,+ran);
       float r2 = random(-ran,+ran);

      strokeWeight(random(1,1));
        
      beginShape();
      vertex(xoffset + x  +r1  , y + yoffset+h1  +r2  );//1
      vertex(xoffset + x+w1+(w2/2)-(w2a/2)  +r1  , yoffset+ y+h1+h2/2-(h2a/2)  +r2  );//2
     
      r1 = random(-ran,+ran);
      r2 = random(-ran,+ran);
      vertex(xoffset + x+w1  +r1  , y+yoffset+random(-ran,+ran)  +r2  );//3
      vertex(xoffset + x+w1+w2  +r1  , y+yoffset+random(-ran,+ran)  +r2  );//4
     
      r1 = random(-ran,+ran);
      r2 = random(-ran,+ran);
     
      vertex(xoffset + x+w1+(w2/2)+(w2a/2)  +r1  , y+h1+h2/2-(h2a/2)+yoffset+random(-ran,+ran)  +r2  );//5
      vertex(xoffset + x+w1*2+w2  +r1  , y+h1+yoffset+random(-ran,+ran)  +r2  );//6
     
      r1 = random(-ran,+ran);
      r2 = random(-ran,+ran);
     
      vertex(xoffset + x+w1*2+w2  +r1  , y+h1+h2+yoffset+random(-ran,+ran)  +r2  );//7
      vertex(xoffset + x+w1+(w2/2)+(w2a/2)  +r1  , y+h1+h2/2+(h2a/2)+yoffset +random(-ran,+ran)  +r2  );//8
     
      r1 = random(-ran,+ran);
      r2 = random(-ran,+ran);
     
      vertex(xoffset + x+w1+w2  +r1  , y+h1*2+h2 +yoffset+random(-ran,+ran)  +r2  );//9
      vertex(xoffset + x+w1  +r1  , y+h1*2+h2 +yoffset+random(-ran,+ran)  +r2  );//10
     
      r1 = random(-ran,+ran);
      r2 = random(-ran,+ran);
     
      vertex(xoffset + x+w1+(w2/2)-(w2a/2)  +r1  , y+h1+h2/2+(h2a/2) +yoffset+random(-ran,+ran)  +r2  );//11
      vertex(xoffset + x  +r1  , y+h1+h2 +yoffset+random(-ran,+ran)  +r2  );//12
      endShape(CLOSE);
        
      /*beginShape();
      vertex(xoffset + x+random(-ran,+ran), y + yoffset+h1+random(-ran,+ran));//1
      vertex(xoffset + x+w1+(w2/2)-(w2a/2)+random(-ran,+ran), yoffset+ y+h1+h2/2-(h2a/2)+random(-ran,+ran));//2
     
      vertex(xoffset + x+w1+random(-ran,+ran), y+yoffset+random(-ran,+ran));//3
      vertex(xoffset + x+w1+w2+random(-ran,+ran), y+yoffset+random(-ran,+ran));//4
     
      vertex(xoffset + x+w1+(w2/2)+(w2a/2)+random(-ran,+ran), y+h1+h2/2-(h2a/2)+yoffset+random(-ran,+ran));//5
      vertex(xoffset + x+w1*2+w2+random(-ran,+ran), y+h1+yoffset+random(-ran,+ran));//6
     
      vertex(xoffset + x+w1*2+w2+random(-ran,+ran), y+h1+h2+yoffset+random(-ran,+ran));//7
      vertex(xoffset + x+w1+(w2/2)+(w2a/2)+random(-ran,+ran), y+h1+h2/2+(h2a/2)+yoffset +random(-ran,+ran));//8
     
      vertex(xoffset + x+w1+w2+random(-ran,+ran), y+h1*2+h2 +yoffset+random(-ran,+ran));//9
      vertex(xoffset + x+w1+random(-ran,+ran), y+h1*2+h2 +yoffset+random(-ran,+ran) );//10
     
      vertex(xoffset + x+w1+(w2/2)-(w2a/2)+random(-ran,+ran), y+h1+h2/2+(h2a/2) +yoffset+random(-ran,+ran) );//11
      vertex(xoffset + x+random(-ran,+ran), y+h1+h2 +yoffset+random(-ran,+ran));//12
      endShape(CLOSE);*/
     
     
     
      /*beginShape();
      vertex(xoffset + x, y + yoffset+h1);//1
      vertex(xoffset + x+w1+(w2/2)-(w2a/2), yoffset+ y+h1+h2/2-(h2a/2));//2
     
      vertex(xoffset + x+w1, y+yoffset);//3
      vertex(xoffset + x+w1+w2, y+yoffset);//4
     
      vertex(xoffset + x+w1+(w2/2)+(w2a/2), y+h1+h2/2-(h2a/2)+yoffset);//5
      vertex(xoffset + x+w1*2+w2, y+h1+yoffset);//6
     
      vertex(xoffset + x+w1*2+w2, y+h1+h2+yoffset);//7
      vertex(xoffset + x+w1+(w2/2)+(w2a/2), y+h1+h2/2+(h2a/2)+yoffset );//8
     
      vertex(xoffset + x+w1+w2, y+h1*2+h2 +yoffset);//9
      vertex(xoffset + x+w1, y+h1*2+h2 +yoffset );//10
     
      vertex(xoffset + x+w1+(w2/2)-(w2a/2), y+h1+h2/2+(h2a/2) +yoffset );//11
      vertex(xoffset + x, y+h1+h2 +yoffset);//12
      endShape(CLOSE);*/
     
     
      smooth();
     
      j=j+1;
    }

    i=i+1;
  }
 
}

void draw()
{
 
}

void mousePressed (){
  save (selectOutput()+".png");
}

Stroke changing

While choosing my final I was choosing between these images and the ones which became my final hand in. I think this development is quite strong and really did have a potential to become my final. Changing a strokeweight is very simple, but it provides an amazing result. I really like how on the last couple of images the negative space makes up new shapes and it completely ruins the structure but at the same time kin of gives a feeling of a new structure apearing on the picture, even though it is still quite noisy.

 noise :  int ran = 0

 noise :  int ran = 10

 noise :  int ran = 20

 noise :  int ran =25

 noise :  int ran =30

 noise :  int ran =35

 noise :  int ran = 40

 noise :  int ran =45

 noise :  int ran = 50

 noise :  int ran =55

noise :  int ran = 60

noise :  int ran = 100

Lerp color function

While working on my project I learned how to use a lerp color function and I find it pretty cool and useful, so I just wanted to have a piece of coding for this so I could always look at my blog and refresh in mind how it works.


color from = color(77, 21, 12);
      color to = color(170, 135, 77);
      color interA = lerpColor(from, to, random(0.0, 1.0));
      fill(interA);

More experimentation with shapes and colors

I have done some more experimentation with shape and color. I quite like the very bottom picture. The color matching pleases my eyes. However green crosses and blue background is the worst color choice. Hurts eyes and looks bad too.