Braitenberg code. Page 1

Transcription

1 // Processing source code : Braitenberg's Vehicles // Based on program written by william ngan <contact@metaphorical.net> // SensoryField class stub coded by Prof. Mateas and Mayhew Seavey in //...and slightly-further hackery added by Jason Alderman in // Press UP and DOWN arrows to increase number of Braitenberg vehicles. // Press number keys 1-5 to change the number of sources on the sensory field. // Press SPACE to toggle the PImage ground visible or invisible. Vehicle[] robots; SensoryField lightsground; boolean mousedown; PImage ground; boolean bounded = true; // vehicles run into world boundary (if true), // wrap around (if false) int numoflights = 2; int numofrobots = 2; float move_speed = PI/6; boolean groundisdrawn; void setup() { size( 300, 300 ); framerate( 30 ); ellipsemode( CENTER ); rectmode( CENTER ); nostroke(); groundisdrawn = false; // Don't draw the sensoryfield grounds // on the background. ground = new PImage( width, height ); robots = new Vehicle[10]; // Create an array of Braitenberg // Vehicles. for (int i=0; i<robots.length; i++) { robots[i] = new Vehicle( random(width), random(height), 0, 10, i ); lightsground = new SensoryField( width, height, 5); // Create a SensoryField... // Now that SensoryField is a class, you can make as many different // types as you wish. for (int i=0; i<numoflights; i++) { lightsground.addsource( new Source( random(10,width-10), random(10,height-10), 1.0, 100, i)); println("adding source "+ i + " to lights at " + lightsground.getsource(i).getlocation()); println("the size of the lightsground arraylist is "+lightsground.sources.size()); smooth(); updateground(); void draw() { background( 0 ); if(groundisdrawn) image( ground, 0, 0 ); fill( 255 ); for (int i=0; i<numoflights; i++) { Page 1

2 lightsground.getsource(i).drawme(); for (int i=0; i<numofrobots; i++) { robots[i].moveme(); robots[i].drawme(); void keypressed() { if (key>='1' && key<='5') { numoflights = 5-('5'-key); updateground(); // updateground so that it adds or removes // the lights from the ArrayList! if (key==' '){ groundisdrawn= (!groundisdrawn); println("ground-drawn boolean is now: "+groundisdrawn); updateground(); // updateground so that it draws the PImage! // (or doesn't, when it shouldn't!) if (key==coded) { if (keycode==up) { numofrobots++; numofrobots = min( numofrobots, robots.length-1 ); else if (keycode==down) { numofrobots--; numofrobots = max( numofrobots, 1 ); void updateground() { float sum; int c; int px = 5; color cc; int temp; // if a keypress has changed the number of lights, then add or remove // sources from the arraylist of lightsground if(numoflights!=lightsground.sources.size()){ if(numoflights < lightsground.sources.size()){ // if the number of light sources has been decreased... temp = lightsground.sources.size() - numoflights; for(int i=0; i<temp; i++){ println("deleting source id "+(lightsground.sources.size()-1)); lightsground.deletesource(lightsground.sources.size()-1); else { // if the number of light sources has been increased... temp = numoflights - lightsground.sources.size(); for(int i=0; i<temp; i++){ println("adding source id "+lightsground.sources.size()); lightsground.addsource(new Source( random(10, width-10), random(10, height-10), 1.0, 100, lightsground.sources.size())); Page 2

3 lightsground.update(); if(groundisdrawn){ ground = new PImage( width, height); for (int i=0; i<width; i++ ) { for (int k=0; k<height; k++ ) { c = int(lightsground.get(i,k)); ground.set( i, k, color( c, min(200,c), c/8) ); // end for-loop (k) // end for-loop (i) // end if(groundisdrawn) // Vehicle class class Vehicle { float x, y, axle, half_axle, axlesq; float angle; // direction of the Vehicle float wheel_diff, wheel_average; // the difference and average of the wheels' rotating speed Wheel wa, wb; // two wheels Sensor sa, sb; // two sensors int id; Vehicle( float x, float y, float angle, float axle_length, int id ) { this.angle = angle; this.id = id; axle = axle_length; half_axle = axle/2; axlesq = axle*axle; ); ); wa = new Wheel( x+half_axle*cos(angle-half_pi), y+half_axle*sin(angle-half_pi), 10, 0 wb = new Wheel( x+half_axle*cos(angle+half_pi), y+half_axle*sin(angle+half_pi), 10, 0 sa = new Sensor( x+axle*cos(angle-half_pi/1.5), y+axle*sin(angle-half_pi/1.5) ); sb = new Sensor( x+axle*cos(angle+half_pi/1.5), y+axle*sin(angle+half_pi/1.5) ); void drawme() { fill(255,0,0); triangle( wa.x, wa.y, wb.x, wb.y, x+cos(angle)*axle*2.5, y+sin(angle)*axle*2.5 ); //fill(200,54,130); fill(102,102,51); wa.drawme(angle, 1); wb.drawme(angle-pi, -1); ellipse( x, y, axle*3, axle*3 ); Page 3

4 sa.drawme(); sb.drawme(); // Computes the sensory logic to set the wheel velocity. // Sensor output goes directly to wheel on same side void dosenselogic() { setaspeed(sa.getsense()); setbspeed(sb.getsense()); // Sensor output crossed to wheel on opposite side /* void dosenselogic() { setaspeed(sb.getsense()); setbspeed(sa.getsense()); */ // Each sensor goes to wheel on same side with an inhibitory connection /* void dosenselogic() { setaspeed(sa.getinversesense()); setbspeed(sb.getinversesense()); */ // Each sensor goes to wheel on opposite side with an inhibitory connection /* void dosenselogic() { setaspeed(sb.getinversesense()); setbspeed(sa.getinversesense()); */ // Sensors are hooked up to opposite motors, with threshhold sensing. /* void dosenselogic() { setaspeed(sb.getnonlinearsense()); setbspeed(sa.getnonlinearsense()); */ void moveme() { checkbounds(); dosenselogic(); // move wheel_diff = wa.d - wb.d; wheel_average = ( wa.d + wb.d ) / 2; angle += wheel_diff / axle; x += cos( angle ) * wheel_average; y += sin( angle ) * wheel_average; checkcollision(); // wheels move float ang = angle - HALF_PI; wa.x = x + half_axle * cos( ang ); wa.y = y + half_axle * sin( ang ); ang = angle + HALF_PI; wb.x = x + half_axle * cos( ang ); Page 4

5 wb.y = y + half_axle * sin( ang ); // sensors move ang = angle - HALF_PI/2; sa.x = x + axle * cos( ang ); sa.y = y + axle * sin( ang ); ang = angle + HALF_PI/2; sb.x = x + axle * cos( ang ); sb.y = y + axle * sin( ang ); void checkbounds() { if (bounded) { x = max( axle+5, min( width-axle-5, x ) ); y = max( axle+5, min( height-axle-5, y ) ); else { x = ( x<0 )? width+x : ((x>width)? x-width : x ); y = ( y<0 )? height+y : ((y>height)? y-height : y ); // If the above looks completely confusing to you, check out // void checkcollision() { float dx, dy, da; for (int i=0; i<numofrobots; i++) { if (i!=id) { // for all of the OTHER robots... // start calculating the distance between me and the other robot dx = x-robots[i].x; dy = y-robots[i].y; // if the distance sqrt(dx^2 + dy^2) is less than the axle size if (dx*dx + dy*dy<axlesq ) { da = atan2( dy, dx ); // calculate the angle from me to the other robot // then push me through t x = x + cos(da)*half_axle; y = y + sin(da)*half_axle; robots[i].x = robots[i].x + cos(da+pi)*half_axle; robots[i].y = robots[i].y + sin(da+pi)*half_axle; // void setaspeed( float ang_speed ) { wa.setspeed( ang_speed*move_speed ); void setbspeed( float ang_speed ) { wb.setspeed( ang_speed*move_speed ); void changeaspeed( float inc ) { wa.setspeedchange( inc ); void changebspeed( float inc ) { Page 5

6 wb.setspeedchange( inc ); class Wheel { float x, y; float ang_speed, radius; float angle; float d; Wheel( float x, float y, float radius, float ang_speed ) { this.radius = radius; this.ang_speed = ang_speed; angle = 0; d = ang_speed * radius; void setspeed( float ang_speed ) { this.ang_speed = ang_speed; d = ang_speed * radius; void setspeedchange( float inc ) { ang_speed += inc; d = ang_speed * radius; void drawme(float ainc, int dir) { angle += ang_speed; if (angle>two_pi) angle -= TWO_PI; float temp = sin(angle)*half_pi+ainc; ellipse( x+cos(temp)*10*dir, y+sin(temp)*10*dir, 20, 20 ); class Sensor { float x, y; float maxreading; float sense; Sensor( float x, float y ) { maxreading = 1; void setlocation( float x, float y ) { /* float getsense(boolean plus) { Page 6

7 float sum = red( ground.get( (int)x, (int)y ) )/255.0; sum = (plus)? sum : 1-sum; sense = (specialsense)? nonlinear( sum, maxreading ) : 1-sum; return sense; */ // This is an example of non-linear threshhold sensing. Returns 0 // until the normalized sensory value = 0.5, then returns a linear value // between 0.5 and 1. float getnonlinearsense() { // old code, reading from PImage ground, was: // float val = red( ground.get( (int)x, (int)y ) )/255.0; float val = lightsground.get( (int)x, (int)y )/255.0; if (val < 0.5) return 0; else return val; // Returns 0 when sensory value is maximum, 1 when it's minimum float getinversesense() { float val = lightsground.get( (int)x, (int)y )/255.0; sense = 1 - val; return sense; // Returns 1 when sensory value is maximum, 0 when it's minimum float getsense() { sense = lightsground.get( (int)x, (int)y )/255.0; return sense; void drawme() { fill(255); ellipse( x, y, 16, 16 ); fill(200*sense,0,0); ellipse( x, y, 7, 7 ); class Source { float x, y; float strength; // between 0 to 1 float max_radius; boolean dragging = true; int id; Source( float x, float y, float strength, float max_radius, int id ) { this.strength = strength; this.max_radius = max_radius; this.id = id; void setlocation( float x, float y ) { Page 7

8 String getlocation(){ return ""+this.x+","+this.y; void drawme() { checkcollision(); // dragging? if (mousedown && mousex>x-10 && mousex<x+10 && mousey>y-10 && mousey<y+10) { dragging = true; if (!mousedown) dragging = false; if (dragging) { x = mousex; y = mousey; ellipse(x, y, 10, 10 ); if(groundisdrawn == false){ //-- draw a circle of max radius around the source -- stroke(255,255,255,45); strokeweight(2); nofill(); ellipse(x, y, max_radius*2, max_radius*2); nostroke(); fill(255); //-- void checkcollision() { // see vehicle's checkcollision for an explanation of the math here... float dx, dy, da; //-- keep the Source on the screen if(x > width) x = width; if(x < 0) x = 0; if(y > height) y = height; if(y < 0) y = 0; //-- for (int i=0; i<numoflights; i++) { if (i!=id) { dx = x-lightsground.getsource(i).x; dy = y-lightsground.getsource(i).y; if (dx*dx + dy*dy<max_radius ) { da = atan2( dy, dx ); lightsground.getsource(i).x = lightsground.getsource(i).x + cos(da+pi)*5; lightsground.getsource(i).y = lightsground.getsource(i).y + sin(da+pi)*5; float getreading( float tx, float ty, boolean plus ) { Page 8

9 // This method calculates the field strength by measuring the distance of an arbitrary point from this source. float d = dist( tx, ty, x, y ); if (d >= max_radius) return ((plus)? 0 : 1); // Strength of source falls of linearly in distance (up to max_radius) from source // d = strength*(d/max_radius); // Strength of source falls off as a function of the cosine of distance (up to max_radius) from source d = 1-nonlinear( d, max_radius ); return ((plus)? 1-d : d ); // end Source // The function nonlinear(r, rmax) is used by several bits of code above, so it falls inside the main program. // Returns a value between 0 and 1 (assume r & rmax >= 0) // Returns 0 if r is >= rmax // Returns 1 if r = 0 float nonlinear(float r, float rmax) { float f = (rmax - Math.min(r, rmax)) / rmax; return *cos(f*PI); // SensoryField is a class that contains our 2D array of sensory values (instead of using a PImage). class SensoryField { float[][] field; // A 2D array of summed sensory values. The 2D array should be the same size as the processing window. int w; // The width of the field int h; // The height of the field ArrayList sources; // The list of sources that produce values for this SensoryField int pixelsize; // Determines the block size at which we sample the field. Change the value (in the constructor argument) // to increase the sample size. The bigger the value, the more pixelated the field, but the less // computational work it takes to update the field. SensoryField(int w, int h, int ps) { field = new float[w+100][h+100]; //...making a sensory field with 50 elements-worth // of buffer on each side, so that when a vehicle or source goes to the edge of the // screen, there aren't negative index values for the 2D array (something that // PImages don't care about, but arrays do!). this.w = w; this.h = h; sources = new ArrayList(); pixelsize = ps; // Get the sensory value at a specific point. float get(int x, int y){ return field[x+50][y+50]; // Add a source to the field. void addsource(source s) { sources.add(s); // Delete a source from the field. void deletesource(int j) { Page 9

10 sources.remove(j); // Get a source from the sources arraylist. Source getsource(int i){ return (Source)sources.get(i); // Update the field. For every point in the field, iterate over the sources to determine // the sensory value at each point. void update() { float sum; // We're going to iterate through the all of the elements of the sensory field, // but increment by the pixelsize in the both directions... for(int i = 0; i < w; i += pixelsize){ for(int k = 0; k < h; k += pixelsize){ // Now sum up the sensory readings for each source in the field... sum = 0; for(int m=0; m<sources.size(); m++){ sum += this.getsource(m).getreading(i,k,true); //...and now write that sum (or a maximum of 255) in each element of the field within each big "pixel." for(int p=0; p<pixelsize; p++) { for(int q=0; q<pixelsize; q++){ field[i+p+50][k+q+50] = min(sum*255, 255); // void mousepressed() { mousedown = true; void mousereleased() { mousedown = false; updateground(); Page 10