My first Processing project: I'm porting an ActionScript experiment ( http://www.gskinner.com/blog/archives/2005/01/varicoseg_exper.html ) to Processing. The AS code ( http://www.gskinner.com/blog/archives/2005/01/source_code_var.html ) recursively spawns MovieClips (a Vein class that inherits from MovieClip) to draw the veins. In Flash each MovieClip functions like an encapsulated canvas. This makes it quite easy to task each instance of the vein class with drawing itself within its canvas.

Here's my immediate dilemma: If you take a gander at the AS experiment, you'll see that the entire canvas rotates and translates. This is achieved by creating a parent MovieClip within which all of the vein MovieClips are nested.

Does Processing have a similar ability (independent sub-canvases)? Based on my limited knowledge of Processing, I understand that if I were to translate a bunch of lines without clear()ing the sketch, they would just smear the canvas. But if I clear() the sketch on each frame, then I have to redraw the entire vein structure, which would greatly complicate the code.

Am I just trying to cram an AS square into a Processing circle?

Given the visual created by the AS experiment, how would you approach it in Processing?

Quote:


i think this is just your assumption. they draw to stage as far as i know, otherwise it would be pretty inefficent ...

to do something similar in processing, set up a class for the vein object, add a draw() function to it, create a loop inside PApplet.draw() that calles each vein instance. i think that's the best way to do it. see a similar question here:

http://processing.org/discourse/yabb_beta/YaBB.cgi?board=Syntax;action=display;num=1186358380

F

Quote:


that's what pushMatrix() and popMatrix() are for.

Quote:


that's a pretty special behavior. you can store these settings in a couple of variables.

Quote:


jep.

a way to do that is to let every object have it's own PGraphics. these are extending PImage, so you can use 'em with image() (see example).
be aware that PGraphics might be a little memory hungry, so creating thousands of objects is not recommended.
... and you have to give the PGraphics a fixed size.

F

Code:

// fjenett 20070824

// using a different approach here:
// i have one master vein class that generates vein-pieces.
// these inherit from vein and generate the sub-vein-pieces.

Vein vein;

void setup ()
{
    size(500, 500);
    vein = new Vein( this );
    frameRate( 20 );
    smooth();
    xx = width / 2.0;
    yy = height / 2.0;
}

float xx, yy;
float antifraction = 0.08;

void draw ()
{
    background( 0xEE220000 );
    
    // move camera to the main veins position
    xx += ((-vein.position.x+width /2)-xx)*antifraction;
    yy += ((-vein.position.y+height/2)-yy)*antifraction;
    translate(xx, yy);
    
    // instead of registerDraw(), to be able to see stackOverFlow errors .. 
    vein.draw();
}

public class Vein
{
    Point2D position;
    float angle;
    Vector pieces;
    float strokeWeight = 8;
    int strokeColor = 0xFFFF0000;

    float birthRate;
    float growRate;
    
    Vein () {}

    Vein ( PApplet _p )
    {
	  //_p. registerDraw( this );
	  init( new Point2D( width/2, height/2 ), random(2) );
	  growRate = 3.0;
	  birthRate = 1.005;
    }

    void init ( Point2D _sp, float _a )
    {
	  position = _sp;
	  angle = _a;
	  pieces = new Vector();
    }
    
    float DEG_2_RAD = PI/180.0;

    public void add ()
    {
	  Point2D nextPosition = position;
	  int cnt = (int)random( 0, birthRate );
	  if ( is_master ) cnt++;
	  for ( int i=0; i<cnt; i++ )
	  {
		float thickness = is_master ? strokeWeight : strokeWeight*0.9;
		float seed = thickness;
		float length = random(growRate)+seed+2;
		angle += DEG_2_RAD * ( random(seed*10) - seed*5 );
		float _x = length * cos(angle);
		float _y = length * sin(angle);
		Point2D endPoint = new Point2D( position.x+_x, position.y+_y );
		if ( i==0 )
		    nextPosition = new Point2D( endPoint.x, endPoint.y );
		pieces.add( new VeinPiece( position, endPoint, thickness, is_master ? strokeColor : dim(strokeColor), angle, this ) );
	  }
	  position = nextPosition;
    }
    
    int dim ( int col )
    {
	  int a = (col >> 24) & 0xFF;
	  int r = (col >> 16) & 0xFF;
	  int g = (col >> 8) & 0xFF;
	  int b = col & 0xFF;
	  r-=20; if ( r < 100 ) r = 100;
	  b+=8; if ( b > 180 ) b = 180;
	  return (a << 24) + (r << 16) + (g << 8) + b;
    }
    
    boolean is_master = true;
    public void draw ()
    {
	  if ( is_master ) add();
	  for ( int i=0; i<pieces.size(); i++ ) ((VeinPiece)pieces.get(i)).draw();   
    }
}

class VeinPiece
extends Vein
{
    Point2D start, end;
    int canGrow;
    
    Vein parent;
    
    VeinPiece () {}
    VeinPiece ( PApplet _p ) {}

    VeinPiece ( Point2D _s, Point2D _e, float _st, int _sc, float _a, Vein _p )
    {
	  start = _s; 
	  end = _e; 
	  strokeWeight = _st; 
	  strokeColor = _sc;
	  
	  parent = _p;
	  
	  birthRate = 1.1;
	  growRate  = 5;
	  
	  is_master = false;
	  canGrow = (int)random(20);
	  
	  init(_e,_a);
    }

    void draw ()
    {
	  if ( canGrow > 0 ) { super.add(); canGrow--; }
	  super.draw();
	  
	  stroke( strokeColor );
	  strokeWeight( strokeWeight );
	  line( start.x, start.y, end.x, end.y );
	  
	  if ( strokeWeight < 0.05 ) { parent.pieces.remove(this); return; }
	  strokeWeight -= 0.03;
    }
}

class Point2D
{
    float x, y;
    Point2D ( float _x, float _y ) { 
	  x = _x; 
	  y = _y; 
    }
}