Hi,
I’m trying to adapt this code (from Daniel Shiffman). It uses an image to generate a flow field, then draw lines following the field. The issue I’m having (I think) is in void borders() in the Vehicle class. When the vehicle wraps around, it is generating vertical and horizontal lines. I believe it has something to do with how I am drawing the lines using beginShape() and vertices. However, I am not sure of how to fix this. Any ideas are greatly appreciated. Thanks in advance.
`// The Nature of Code
// Daniel Shiffman
// http://natureofcode.com
// Flow Field Following
// Via Reynolds: http://www.red3d.com/cwr/steer/FlowFollow.html
// Using this variable to decide whether to draw all the stuff
boolean debug = true;
PImage img;
// Flowfield object
FlowField flowfield;
// An ArrayList of vehicles
ArrayList<Vehicle> vehicles;
void setup() {
size(1040, 789);
img = loadImage("hillshade2.jpg");
//tint(255,100);
// Make a new flow field with "resolution" of 16
flowfield = new FlowField(20);
vehicles = new ArrayList<Vehicle>();
// Make a whole bunch of vehicles with random maxspeed and maxforce values
for (int i = 0; i < 120; i++) {
vehicles.add(new Vehicle(new PVector(random(width), random(height)), random(2, 5), random(0.1, 0.5)));
}
}
void draw() {
background(255);
image(img,0,0);
// Display the flowfield in "debug" mode
if (debug) flowfield.display();
// Tell all the vehicles to follow the flow field
for (Vehicle v : vehicles) {
v.follow(flowfield);
v.run();
}
// Instructions
fill(0);
text("Hit space bar to toggle debugging lines.\nClick the mouse to generate a new flow field.",10,height-20);
}
void keyPressed() {
if (key == ' ') {
debug = !debug;
}
}
// Make a new flowfield
void mousePressed() {
flowfield.init();
}
class FlowField {
// A flow field is a two dimensional array of PVectors
PVector[][] field;
int cols, rows; // Columns and Rows
int resolution; // How large is each "cell" of the flow field
float vmag = 2;
FlowField(int r) {
resolution = r;
// Determine the number of columns and rows based on sketch's width and height
cols = width/resolution;
rows = height/resolution;
field = new PVector[cols][rows];
init();
}
void init() {
// Reseed noise so we get a new flow field every time
loadPixels();
for (int i = 0; i < cols; i++) {
for (int j = 0; j < rows; j++) {
int x = i*resolution;
int y = j*resolution;
int c = img.pixels[x + y*img.width];
// Map brightness to an angle
float theta = map(brightness(c),0,255,0,PI/2);
// Polar to cartesian coordinate transformation to get x and y components of the vector
field[i][j] = PVector.fromAngle(theta);
// Map magnitude to an angle (how fast is the desired velocity in the flow field)
float m = map(brightness(c),0,255,0.3,1);
field[i][j].mult(m * vmag);
}
}
}
// Draw every vector
void display() {
for (int i = 0; i < cols; i++) {
for (int j = 0; j < rows; j++) {
drawVector(field[i][j],i*resolution,j*resolution,resolution-2);
}
}
}
// Renders a vector object 'v' as an arrow and a location 'x,y'
void drawVector(PVector v, float x, float y, float scayl) {
pushMatrix();
float arrowsize = 4;
// Translate to location to render vector
translate(x,y);
strokeWeight(1);
stroke(255);
// Call vector heading function to get direction (note that pointing up is a heading of 0) and rotate
rotate(v.heading());
// Calculate length of vector & scale it to be bigger or smaller if necessary
float len = v.mag()*scayl;
// Draw three lines to make an arrow (draw pointing up since we've rotate to the proper direction)
line(0,0,len,0);
line(len,0,len-arrowsize,+arrowsize/2);
line(len,0,len-arrowsize,-arrowsize/2);
popMatrix();
}
PVector lookup(PVector lookup) {
int column = int(constrain(lookup.x/resolution,0,cols-1));
int row = int(constrain(lookup.y/resolution,0,rows-1));
return field[column][row].get();
}
}
class Vehicle {
ArrayList<PVector> history = new ArrayList<PVector>();
// The usual stuff
PVector location;
PVector velocity;
PVector acceleration;
float r;
float maxforce; // Maximum steering force
float maxspeed; // Maximum speed
Vehicle(PVector l, float ms, float mf) {
location = l.get();
r = 3.0;
maxspeed = ms;
maxforce = mf;
acceleration = new PVector(0,0);
velocity = new PVector(0,0);
history = new ArrayList<PVector>();
}
void run() {
update();
borders();
display();
}
// Implementing Reynolds' flow field following algorithm
// http://www.red3d.com/cwr/steer/FlowFollow.html
void follow(FlowField flow) {
// What is the vector at that spot in the flow field?
PVector desired = flow.lookup(location);
// Scale it up by maxspeed
desired.mult(maxspeed);
// Steering is desired minus velocity
PVector steer = PVector.sub(desired, velocity);
steer.limit(maxforce); // Limit to maximum steering force
applyForce(steer);
}
void applyForce(PVector force) {
// We could add mass here if we want A = F / M
acceleration.add(force);
}
// Method to update location
void update() {
PVector prev = new PVector (location.x,location.y);
history.add(prev);
// Update velocity
velocity.add(acceleration);
// Limit speed
velocity.limit(maxspeed);
location.add(velocity);
// Reset accelertion to 0 each cycle
acceleration.mult(0);
}
void display() {
beginShape();
float tr = 300;
for (int i = 0; i<history.size(); i++){
PVector prev = history.get(i);
stroke(0,tr);
noFill();
vertex(prev.x,prev.y);
tr -= .5;
}
endShape();
}
// Wraparound
void borders() {
if (location.x < -r) location.x = width+r;
if (location.y < -r) location.y = height+r;
if (location.x > width+r) location.x = -r;
if (location.y > height+r) location.y = -r;
}
