moving background up

Programming Questions

sebastiako

in Programming Questions • 7 months ago

Hi , I have a question related to the worlfram cellular automata that comes with processing in the examples folder.

That program works in this way:

It generates line per line the image going from up to down, when it arrives to the bottom of the sketch it restarts with a new random set of rules.

What i need is to adapt this code to a specific behaivor:

instead of restarting a new ca with new rules when it arrives to the bottom i need that it continue generating the same cellular automata with the same rules. I need that when it arrives to the bottom all the image (background) can move up to the first line in the top of the window and then continue generating the patterns until it arrives again to the bottom and again it moves up the image to the first line and then it continue generating the pattern .... and i need to repeat this process infinitely.

How can i achive this? any idea how to move the background image up?

cheers

Replies(4)

PhiLho

Re: moving background up

7 months ago

A good way, I think, is to use loadPixels(), then to copy the pixels (one by one, or using arrayCopy, probably simpler somehow and faster) by shifting them by one row (ie. by width value).
Something like:
arrayCopy(pixels, width, pixels, 0, pixels.length - width);
Don't forget updatePixels().

amnon.owed

Re: moving background up

7 months ago

Now it just continues infinitely with the same ruleset. Once it reaches the bottom of the sketch, it continues from the first line again. Took out all the unnecessary code and shortened it where possible. Comment out line 15's background() call to see the old image be overwritten.

Adapted Code

CA ca;
void setup() {
size(640, 360, P2D);
ca = new CA( new int[] { 0, 1, 0, 1, 1, 0, 1, 0 } );
background(0);
noStroke();
}
void draw() {
ca.render();
ca.generate();
if (ca.finished()) {
background(0);
ca.restart();
}
}
class CA {
int[] cells, rules;
int generation, scl;
CA(int[] r) {
rules = r;
scl = 1;
cells = new int[width/scl];
cells[cells.length/2] = 1;
}
void restart() {
generation = 0;
}
void generate() {
int[] nextgen = new int[cells.length];
for (int i = 1; i < cells.length-1; i++) {
int left = cells[i-1];
int me = cells[i];
int right = cells[i+1];
nextgen[i] = rules(left, me, right);
}
cells = (int[]) nextgen.clone();
generation++;
}
void render() {
for (int i = 0; i < cells.length; i++) {
fill(cells[i] == 1 ? 255 : 0);
rect(i*scl, generation*scl, scl, scl);
}
}
int rules (int a, int b, int c) {
if (a == 1 && b == 1 && c == 1) return rules[0];
if (a == 1 && b == 1 && c == 0) return rules[1];
if (a == 1 && b == 0 && c == 1) return rules[2];
if (a == 1 && b == 0 && c == 0) return rules[3];
if (a == 0 && b == 1 && c == 1) return rules[4];
if (a == 0 && b == 1 && c == 0) return rules[5];
if (a == 0 && b == 0 && c == 1) return rules[6];
if (a == 0 && b == 0 && c == 0) return rules[7];
return 0;
}
boolean finished() {
return generation > height/scl;
}
}

GoToLoop

Re: moving background up

7 months ago

Modded version using boolean instead of int:

/**
 * Cellular Automata (v3.5)
 * mod Ammon.Owed & GoToLoop (2013/Mar)
 *
 * http://forum.processing.org/topic/moving-background-up
 */

final static color BG = 0, FG = -1;
final static byte  FPS = 100;
final static boolean isSmooth = false;

CA ca;

void setup() {
  size(800, 360);
  frameRate(FPS);
  noStroke();
  background(BG);

  if (isSmooth)    smooth();
  else           noSmooth();

  ca = new CA();
}

void draw() {
  if ( ca.isFinished() )   ca.restart();

  ca.render();
  ca.generate();

  frame.setTitle
    ( "Cellular Automata  ---  FPS: " + round(frameRate) );
}

void keyPressed() {
  if (key == ' ') {
    ca.restart();
    background(BG);
  }

  else mousePressed();
}

void mousePressed() {
  if (looping)    noLoop();
  else            loop();
}

class CA {
  final boolean[] rules = { 
    false, true, false, true, true, false, true, false
  };

  boolean[] cells;
  final short len;

  short generation;
  final static byte scl = 1;

  CA() {
    cells = new boolean[width/scl];
    len = (short) cells.length;
    cells[len >> 1] = true;
  }

  void restart() {
    generation = 0;
  }

  void generate() {
    boolean[] nextgen = new boolean[len];

    for ( int i = 1, ii = len-1; i != ii; 
      nextgen[i] = 
      whichRule( cells[i-1], cells[i], cells[++i]) );

    cells = nextgen;
    ++generation;
  }

  void render() {
    for ( int i = 0; i != len; i++ ) {
      fill(cells[i] ? FG : BG);
      rect(i*scl, generation*scl, scl, scl);
    }
  }

  boolean whichRule(boolean a, boolean b, boolean c) {
    if (a) {
      if (b & c)    return rules[0];
      if (b & !c)   return rules[1];
      if (!b & c)   return rules[2];

      return rules[3];
    }

    if (b & c)      return rules[4];
    if (b & !c)     return rules[5];
    if (!b & c)     return rules[6];

    return rules[7];
  }

  boolean isFinished() {
    return generation > height/scl;
  }
}

PhiLho

Re: moving background up

7 months ago

Nice, but not answering exactly the original question.
It needs only to inject my suggestion to make it work, though:

/**
* Cellular Automata (v3.5)
* mod Ammon.Owed & GoToLoop (2013/Mar)
*
* http://forum.processing.org/topic/moving-background-up
*/
final color BG = 0, FG = -1;
final int FPS = 100;
final boolean isSmooth = false;
CA ca;
void setup() {
size(800, 360);
frameRate(FPS);
noStroke();
background(BG);
if (isSmooth) smooth();
else noSmooth();
ca = new CA();
}
void draw() {
ca.render();
ca.generate();
frame.setTitle
( "Cellular Automata --- FPS: " + round(frameRate) );
}
void keyPressed() {
if (key == ' ') {
ca.restart();
background(BG);
}
else mousePressed();
}
void mousePressed() {
if (looping) noLoop();
else loop();
}
class CA {
final boolean[] rules = {
false, true, false, true, true, false, true, false
};
boolean[] cells;
final int len;
int generation;
boolean bottom;
final static int scl = 1;
CA() {
cells = new boolean[width/scl];
len = cells.length;
cells[len / 2] = true;
}
void generate() {
boolean[] nextgen = new boolean[len];
for ( int i = 1, ii = len-1; i != ii;
nextgen[i] =
whichRule( cells[i-1], cells[i], cells[++i]) );
cells = nextgen;
if (bottom) {
loadPixels();
arrayCopy(pixels, width, pixels, 0, pixels.length - width);
updatePixels();
} else {
if (generation >= height / scl - 1) {
bottom = true;
} else {
generation++;
}
}
}
void render() {
for ( int i = 0; i != len; i++ ) {
fill(cells[i] ? FG : BG);
rect(i*scl, generation*scl, scl, scl);
}
}
boolean whichRule(boolean a, boolean b, boolean c) {
if ( a && b && c) return rules[0];
if ( a && b && !c) return rules[1];
if ( a && !b && c) return rules[2];
if ( a && !b && !c) return rules[3];
if (!a && b && c) return rules[4];
if (!a && b && !c) return rules[5];
if (!a && !b && c) return rules[6];
if (!a && !b && !c) return rules[7];
return false; // Never called, mandatory by Java rules!
}
void restart() {
generation = 0;
}
}

Top Reply