Mixing active and static modes??? please help

Core Library Questions

miles.tone

Mixing active and static modes??? please help

in Core Library Questions • 2 years ago

Hi there,

Im a beginner with processing and really want to sink my teeth into it, im having a problem with the sketch im using,im trying to use the x y data from the color tracking within the particle class afterwards.

I think im close to getting it working but ive got stuck as im being told that im mixing active and static modes

Really need some help with this and it will be huuuugely appreciated.

Heres the code:

/**
* Color Tracking
* by Justin Brooks
*
*
* based on original code:
* Brightness Tracking
* by Golan Levin.
*
* Tracks the tracks pixel closest in color to specified color.
*/
boolean lines = false;
/*
gravity toggle
toggle this by pressing 'g'
*/
boolean gravity = true;
/* Particle count */
int particleCount = 500;
/* Particle array */
Particle[] particles = new Particle[particleCount+1];
import processing.video.*;
Capture video;
void setup() {
size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height, 30);
noStroke();
smooth();
colorMode(RGB, 400);
/* Frame rate is 30 */
frameRate(30);
/* The fill color is set to black (0) for the boundaries (drawn as a quad) */
fill (0);
coordx = new Particle (colorX);
coordy = new Particle (colorY);
/* We loop through our particle count and initialize each */
for (int x = particleCount; x >= 0; x--) {
particles[x] = new Particle();
}
}
void draw() {
if (video.available()) {
video.read();
background(0);
/* The stroke color is set to white for the border. */
stroke (400);
/* The border; it is 10 pixels from all sides */
quad (10,10,10,height-10,width-10,height-10,width-10,10);
/* All of our particles are looped through, and updated */
for (int i = particleCount; i >= 0; i--) {
Particle particle = (Particle) particles[i];
particle.update(i);
}
int colorX = 0; // X-coordinate of the closest in color video pixel
int colorY = 0; // Y-coordinate of the closest in color video pixel
float closestColor = 10000; //we set this to be abritrarily large, once program runs, the first pixel it scans will be set to this value
// Search for the closest in color pixel: For each row of pixels in the video image and
// for each pixel in the yth row, compute each pixel's index in the video
video.loadPixels();
int index = 0;
for (int ay = 0; ay < video.height; ay++) {
for (int ax = 0; ax < video.width; ax++) {
// Get the color stored in the pixel
color pixelValue = video.pixels[index];
// Determine the color of the pixel
float colorProximity = abs(red(pixelValue)-0)+abs(green(pixelValue)-255)+abs(blue(pixelValue)-0);
// If that value is closer in color value than any previous, then store the
// color proximity of that pixel, as well as its (x,y) location
if (colorProximity < closestColor) {
closestColor = colorProximity;
closestColor=closestColor-10; //thoguht behind this is that it once it "locks" on to an object of color, it wont let go unless something a good bit better (closer in color) comes along
colorY = ay;
colorX = ax;
}
index++;
}
}
// Draw a large, yellow circle at the brightest pixel
fill(255, 204, 0, 128);
ellipse(colorX, colorY, 200, 200);
}
}
class Particle {
/*
Global class variables
These are kept track of, and aren't lost when the class particle is finished operating.
*/
/* the x and y are our coordinates for each particles */
Particle () {
float coordx;
float coordy;
mx = coordx;
my = coordy;
}
}
float x;
float y;
/* vx and vy are the velocities along each axis the particles are traveling */
float vx;
float vy;
/* Particle initialization. We define the beginning properties of each particle here. */
Particle() {
x = random(10,width-10);
y = random(10,height-10);
}
/* These are called everytime we check with the other particle's distances */
float getx() {
return x;
}
float gety() {
return y;
}
void update(int num) {
/* Friction is simulated here */
vx *= 0.84;
vy *= 0.84;
/* Here, every particle is looped through and checked to see if they're close enough to have effect on the current particle. */
for (int i = particleCount; i >= 0; i--) {
/* Check to see if the particle we're checking isn't the current particle. */
if (i != num) {
/* drawthis boolean is initialized. it determines whether the particle is close enough to the other particles for relationship lines to be drawn, assuming it's enabled */
boolean drawthis = false;
/*
Integers are used to keep track of the shade for each particle
The red shade shows opposition
The blue shade shows attraction
*/
float redshade = 20;
float blueshade = 500;
/* We set our particle */
Particle particle = (Particle) particles[i];
/* The x and y coordinates of the particle is found, so we can compare distances with our current particle. */
float tx = particle.getx();
float ty = particle.gety();
/* The radius or distance between both particles are determined */
float radius = dist(x,y,tx,ty);
/* Is the radius small enough for the particle to have an effect on our current one? */
if (radius < 35) {
/* We've the determine that the particle is close enough for relationship lines, so we set drawthis to true. */
drawthis = true;
/* If so, we proceed to calculate the angle. */
float angle = atan2(y-ty,x-tx);
/* Is the radius close enough to be deflected? */
if (radius < 30) {
/* Is relationship lines toggled? */
if (lines) {
/*
Redshade is increased by the distance * 5. The distance is multiplied by 10 because our radius will be within 40 pixels,
30 * 13.33... is 400
We invert it so it gets redder as the particle approaches the current particle, rather than vice versa.
*/
redshade = 13 * (30 - radius);
}
/*
Here, we calculate a coordinate at a angle opposite of the direction where the other particle is.
0.07 is the strength of the particle's opposition, while (40 - radius) is how much it is effected, according to how close it is.
*/
vx += (30 - radius) * 0.07 * cos(angle);
vy += (30 - radius) * 0.07 * sin(angle);
}
/*
Here we see if the particle is within 25 and 35 pixels of the current particle
(we already know that the particle is under 35 pixels distance, since this if statement is nested
in if (radius < 35), so rechecking is unnecessary
*/
if (radius > 25) {
/* check to see if relationship lines are toggled */
if (lines) {
/* The blue shade, between 0 and 400, is used to show how much each particle is attracted */
blueshade = 40 * (35 - radius);
}
/* This does the opposite of the other check. It pulls the particle towards the other. */
vx -= (25 - radius) * 0.005 * cos(angle);
vy -= (25 - radius) * 0.005 * sin(angle);
}
}
/* Check to see if relationship lines are enabled */
if (lines) {
/* Check to see if the two particles are close enough. */
if (drawthis) {
/* Set the stroke color */
stroke (redshade, 10, blueshade);
/* draw the line */
line(x,y,tx,ty);
}
}
}
}
/* Check to see if the user is clicking */
if (mousePressed) {
/* The cursor's x and y coordinates. */
float tx = mx;
float ty = my;
/* the distance between the cursor and particle */
float radius = dist(x,y,tx,ty);
if (radius < 100) {
/* Calculate the angle between the particle and the cursor. */
float angle = atan2(ty-y,tx-x);
/* Are we left-clicking or not? */
if (mouseButton == LEFT) {
/* If left, then the particles are deflected */
vx -= radius * 0.07 * cos(angle);
vy -= radius * 0.07 * sin(angle);
/* The stroke color is red */
stroke(radius * 4,0,0);
}
else {
/* If right, the particles are attracted. */
vx += radius * 0.07 * cos(angle);
vy += radius * 0.07 * sin(angle);
/* The stroke color is blue */
stroke(0,0,radius * 4);
}
/* If line relationships are enabled, the lines are drawn. */
if (lines) line (x,y,tx,ty);
}
}
/* Previox x and y coordinates are set, for drawing the trail */
int px = (int)x;
int py = (int)y;
/* Our particle's coordinates are updated. */
x += vx;
y += vy;
/* Gravity is applied. */
if (gravity == true) vy += 2;
/* Border collisions */
if (x > width-11) {
/* Reverse the velocity if towards wall */
if (abs(vx) == vx) vx *= -1.0;
/* The particle is placed back at the wall */
x = width-11;
}
if (x < 11) {
if (abs(vx) != vx) vx *= -1.0;
x = 11;
}
if (y < 11) {
if (abs(vy) != vy) vy *= -1.0;
y = 11;
}
if (y > height-11) {
if (abs(vy) == vy) vy *= -1.0;
vx *= 0.6;
y = height-11;
}
/* if relationship lines are disabled */
if (!lines) {
/* The stroke color is set to white */
stroke (400);
/* The particle is drawn */
line(px,py,int(x),int(y));
}
}
}
/* User presses a key */
void keyPressed() {
/* if they press g */
if (key == 'g' || key == 'G') {
/* we toggle gravity */
if (gravity) gravity = false;
else gravity = true;
}
/* otherwise */
else {
/* we toggle line relationships */
if (lines) lines = false;
else lines = true;
}
}

Many Thanks

Miles

Replies(20)

velvetkev..

Re: Mixing active and static modes??? please help

2 years ago

You've got an extra right curly bracket at line 103, which Processing reads as the end of that block; the rest of the class ends up on its own, and won't work. That should sort the active/static issue.

Hope that helps.

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

Thank you, thats awesome,

now i just need to sort out the naming, it says that itcant find the coordx and coordy starting in setup()

Sincerely

Miles

theprof

Re: Mixing active and static modes??? please help

2 years ago

Could you describe what you are trying to do? coordx and coordy are not defined anywhere above setup.

velvetkev..

Re: Mixing active and static modes??? please help

2 years ago

Um, OK, sorry, there are a few different issues going on here, not just naming. This seems like a big, complicated example if you haven't done any object oriented programming before- the Particle class has a lot of stuff going on. Not trying to put you down but I would suggest stripping the Particle class right back: for example, can you write a class that just follows the brightest pixel? Once you've got that you can start adding additional stuff and interactions between particles and so on.

edit to add: It's probably also worth starting with just one or two particles, before putting them into an array as that adds an extra layer of complexity.

If you haven't done so, have a look at the Objects tutorial from the Processing site.

If you have specific questions I'll try and help, but there's too much going on there to be able to sort it out without rewriting a lot of your code.

Hope that helps.

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

Ah ok, thanks

yeah im used to max/msp so i had been going about it by putting parts together, but that doesnt work in processing.

I had this which worked as a sketch but not quite as i need it to.

The circle is tracking the closest pixel to pure green and im trying to use the x y tracking data to act as the mouse in the particle class, is that not possible with a couple of adaptations to the code? seen as both parts work simultaniously

sorry for sounding stubborn, im just running out of time for this.

obviously if it isnt possible then i will get stripping.

/**
* Color Tracking
* by Justin Brooks
*
*
* based on original code:
* Brightness Tracking
* by Golan Levin.
*
* Tracks the tracks pixel closest in color to specified color.
*/
boolean lines = false;
/*
gravity toggle
toggle this by pressing 'g'
*/
boolean gravity = true;
/* Particle count */
int particleCount = 500;
/* Particle array */
Particle[] particles = new Particle[particleCount+1];
import processing.video.*;
Capture video;
void setup() {
size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height, 30);
noStroke();
smooth();
colorMode(RGB, 400);
/* Frame rate is 30 */
frameRate(30);
/* The fill color is set to black (0) for the boundaries (drawn as a quad) */
fill (0);
/* We loop through our particle count and initialize each */
for (int x = particleCount; x >= 0; x--) {
particles[x] = new Particle();
}
}
void draw() {
if (video.available()) {
video.read();
background(0);
/* The stroke color is set to white for the border. */
stroke (400);
/* The border; it is 10 pixels from all sides */
quad (10,10,10,height-10,width-10,height-10,width-10,10);
/* All of our particles are looped through, and updated */
for (int i = particleCount; i >= 0; i--) {
Particle particle = (Particle) particles[i];
particle.update(i);
}
int colorX = 0; // X-coordinate of the closest in color video pixel
int colorY = 0; // Y-coordinate of the closest in color video pixel
float closestColor = 10000; //we set this to be abritrarily large, once program runs, the first pixel it scans will be set to this value
// Search for the closest in color pixel: For each row of pixels in the video image and
// for each pixel in the yth row, compute each pixel's index in the video
video.loadPixels();
int index = 0;
for (int ay = 0; ay < video.height; ay++) {
for (int ax = 0; ax < video.width; ax++) {
// Get the color stored in the pixel
color pixelValue = video.pixels[index];
// Determine the color of the pixel
float colorProximity = abs(red(pixelValue)-0)+abs(green(pixelValue)-255)+abs(blue(pixelValue)-0);
// If that value is closer in color value than any previous, then store the
// color proximity of that pixel, as well as its (x,y) location
if (colorProximity < closestColor) {
closestColor = colorProximity;
closestColor=closestColor-10; //thoguht behind this is that it once it "locks" on to an object of color, it wont let go unless something a good bit better (closer in color) comes along
colorY = ay;
colorX = ax;
}
index++;
}
}
// Draw a large, yellow circle at the brightest pixel
fill(255, 204, 0, 128);
ellipse(colorX, colorY, 200, 200);
}
}
class Particle {
/*
Global class variables
These are kept track of, and aren't lost when the class particle is finished operating.
*/
/* the x and y are our coordinates for each particles */
float x;
float y;
/* vx and vy are the velocities along each axis the particles are traveling */
float vx;
float vy;
/* Particle initialization. We define the beginning properties of each particle here. */
Particle() {
x = random(10,width-10);
y = random(10,height-10);
}
/* These are called everytime we check with the other particle's distances */
float getx() {
return x;
}
float gety() {
return y;
}
void update(int num) {
/* Friction is simulated here */
vx *= 0.84;
vy *= 0.84;
/* Here, every particle is looped through and checked to see if they're close enough to have effect on the current particle. */
for (int i = particleCount; i >= 0; i--) {
/* Check to see if the particle we're checking isn't the current particle. */
if (i != num) {
/* drawthis boolean is initialized. it determines whether the particle is close enough to the other particles for relationship lines to be drawn, assuming it's enabled */
boolean drawthis = false;
/*
Integers are used to keep track of the shade for each particle
The red shade shows opposition
The blue shade shows attraction
*/
float redshade = 20;
float blueshade = 500;
/* We set our particle */
Particle particle = (Particle) particles[i];
/* The x and y coordinates of the particle is found, so we can compare distances with our current particle. */
float tx = particle.getx();
float ty = particle.gety();
/* The radius or distance between both particles are determined */
float radius = dist(x,y,tx,ty);
/* Is the radius small enough for the particle to have an effect on our current one? */
if (radius < 35) {
/* We've the determine that the particle is close enough for relationship lines, so we set drawthis to true. */
drawthis = true;
/* If so, we proceed to calculate the angle. */
float angle = atan2(y-ty,x-tx);
/* Is the radius close enough to be deflected? */
if (radius < 30) {
/* Is relationship lines toggled? */
if (lines) {
/*
Redshade is increased by the distance * 5. The distance is multiplied by 10 because our radius will be within 40 pixels,
30 * 13.33... is 400
We invert it so it gets redder as the particle approaches the current particle, rather than vice versa.
*/
redshade = 13 * (30 - radius);
}
/*
Here, we calculate a coordinate at a angle opposite of the direction where the other particle is.
0.07 is the strength of the particle's opposition, while (40 - radius) is how much it is effected, according to how close it is.
*/
vx += (30 - radius) * 0.07 * cos(angle);
vy += (30 - radius) * 0.07 * sin(angle);
}
/*
Here we see if the particle is within 25 and 35 pixels of the current particle
(we already know that the particle is under 35 pixels distance, since this if statement is nested
in if (radius < 35), so rechecking is unnecessary
*/
if (radius > 25) {
/* check to see if relationship lines are toggled */
if (lines) {
/* The blue shade, between 0 and 400, is used to show how much each particle is attracted */
blueshade = 40 * (35 - radius);
}
/* This does the opposite of the other check. It pulls the particle towards the other. */
vx -= (25 - radius) * 0.005 * cos(angle);
vy -= (25 - radius) * 0.005 * sin(angle);
}
}
/* Check to see if relationship lines are enabled */
if (lines) {
/* Check to see if the two particles are close enough. */
if (drawthis) {
/* Set the stroke color */
stroke (redshade, 10, blueshade);
/* draw the line */
line(x,y,tx,ty);
}
}
}
}
/* Check to see if the user is clicking */
if (mousePressed) {
/* The cursor's x and y coordinates. */
float tx = mouseX;
float ty = mouseY;
/* the distance between the cursor and particle */
float radius = dist(x,y,tx,ty);
if (radius < 100) {
/* Calculate the angle between the particle and the cursor. */
float angle = atan2(ty-y,tx-x);
/* Are we left-clicking or not? */
if (mouseButton == LEFT) {
/* If left, then the particles are deflected */
vx -= radius * 0.07 * cos(angle);
vy -= radius * 0.07 * sin(angle);
/* The stroke color is red */
stroke(radius * 4,0,0);
}
else {
/* If right, the particles are attracted. */
vx += radius * 0.07 * cos(angle);
vy += radius * 0.07 * sin(angle);
/* The stroke color is blue */
stroke(0,0,radius * 4);
}
/* If line relationships are enabled, the lines are drawn. */
if (lines) line (x,y,tx,ty);
}
}
/* Previox x and y coordinates are set, for drawing the trail */
int px = (int)x;
int py = (int)y;
/* Our particle's coordinates are updated. */
x += vx;
y += vy;
/* Gravity is applied. */
if (gravity == true) vy += 2;
/* Border collisions */
if (x > width-11) {
/* Reverse the velocity if towards wall */
if (abs(vx) == vx) vx *= -1.0;
/* The particle is placed back at the wall */
x = width-11;
}
if (x < 11) {
if (abs(vx) != vx) vx *= -1.0;
x = 11;
}
if (y < 11) {
if (abs(vy) != vy) vy *= -1.0;
y = 11;
}
if (y > height-11) {
if (abs(vy) == vy) vy *= -1.0;
vx *= 0.6;
y = height-11;
}
/* if relationship lines are disabled */
if (!lines) {
/* The stroke color is set to white */
stroke (400);
/* The particle is drawn */
line(px,py,int(x),int(y));
}
}
}
/* User presses a key */
void keyPressed() {
/* if they press g */
if (key == 'g' || key == 'G') {
/* we toggle gravity */
if (gravity) gravity = false;
else gravity = true;
}
/* otherwise */
else {
/* we toggle line relationships */
if (lines) lines = false;
else lines = true;
}
}

Many Thanks

Miles

PhiLho

Re: Mixing active and static modes??? please help

2 years ago

I move this topic to Core libraries as it involves Capture (lot of people just cannot run your code as it needs a webcam).
I deleted the duplicate topic you created as it got no answers (except mine) and it was more imprecise than this one.

velvetkev..

Re: Mixing active and static modes??? please help

2 years ago

OK, having something working is an excellent place to start. I've not looked at your colour tracking, but getting the attractor to follow the mouse seems reasonable. I've just changed a couple of things, and I put my comments IN CAPS so you can see what I've done:

/**
* Color Tracking
* by Justin Brooks
*
*
* based on original code:
* Brightness Tracking
* by Golan Levin.
*
* Tracks the tracks pixel closest in color to specified color.
*/
boolean lines = false;
/*
gravity toggle
toggle this by pressing 'g'
*/
boolean gravity = false;
/* Particle count */
int particleCount = 500;
/* Particle array */
Particle[] particles = new Particle[particleCount+1];
//DECLARE THESE HERE SO THEY'RE ACCESSIBLE GLOBALLY
int colorX = 0; // X-coordinate of the closest in color video pixel
int colorY = 0; // Y-coordinate of the closest in color video pixel
import processing.video.*;
Capture video;
void setup() {
size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height, 30);
noStroke();
smooth();
colorMode(RGB, 400);
/* Frame rate is 30 */
frameRate(30);
/* The fill color is set to black (0) for the boundaries (drawn as a quad) */
fill (0);
/* We loop through our particle count and initialize each */
for (int x = particleCount; x >= 0; x--) {
particles[x] = new Particle();
}
}
void draw() {
if (video.available()) {
video.read();
background(0);
/* The stroke color is set to white for the border. */
stroke (400);
/* The border; it is 10 pixels from all sides */
quad (10,10,10,height-10,width-10,height-10,width-10,10);
/* All of our particles are looped through, and updated */
for (int i = particleCount; i >= 0; i--) {
Particle particle = (Particle) particles[i];
particle.update(i);
}
//REMOVE THE INTS SINCE WE INITIALISED THEM BEFORE SETUP
colorX = 0; // X-coordinate of the closest in color video pixel
colorY = 0; // Y-coordinate of the closest in color video pixel
float closestColor = 10000; //we set this to be abritrarily large, once program runs, the first pixel it scans will be set to this value
// Search for the closest in color pixel: For each row of pixels in the video image and
// for each pixel in the yth row, compute each pixel's index in the video
video.loadPixels();
int index = 0;
for (int ay = 0; ay < video.height; ay++) {
for (int ax = 0; ax < video.width; ax++) {
// Get the color stored in the pixel
color pixelValue = video.pixels[index];
// Determine the color of the pixel
float colorProximity = abs(red(pixelValue)-0)+abs(green(pixelValue)-255)+abs(blue(pixelValue)-0);
// If that value is closer in color value than any previous, then store the
// color proximity of that pixel, as well as its (x,y) location
if (colorProximity < closestColor) {
closestColor = colorProximity;
closestColor=closestColor-10; //thoguht behind this is that it once it "locks" on to an object of color, it wont let go unless something a good bit better (closer in color) comes along
colorY = ay;
colorX = ax;
}
index++;
}
}
// Draw a large, yellow circle at the brightest pixel
fill(255, 204, 0, 128);
ellipse(colorX, colorY, 200, 200);
}
}
class Particle {
/*
Global class variables
These are kept track of, and aren't lost when the class particle is finished operating.
*/
/* the x and y are our coordinates for each particles */
float x;
float y;
/* vx and vy are the velocities along each axis the particles are traveling */
float vx;
float vy;
/* Particle initialization. We define the beginning properties of each particle here. */
Particle() {
x = random(10,width-10);
y = random(10,height-10);
}
/* These are called everytime we check with the other particle's distances */
float getx() {
return x;
}
float gety() {
return y;
}
void update(int num) {
/* Friction is simulated here */
vx *= 0.84;
vy *= 0.84;
/* Here, every particle is looped through and checked to see if they're close enough to have effect on the current particle. */
for (int i = particleCount; i >= 0; i--) {
/* Check to see if the particle we're checking isn't the current particle. */
if (i != num) {
/* drawthis boolean is initialized. it determines whether the particle is close enough to the other particles for relationship lines to be drawn, assuming it's enabled */
boolean drawthis = false;
/*
Integers are used to keep track of the shade for each particle
The red shade shows opposition
The blue shade shows attraction
*/
float redshade = 20;
float blueshade = 500;
/* We set our particle */
Particle particle = (Particle) particles[i];
/* The x and y coordinates of the particle is found, so we can compare distances with our current particle. */
float tx = particle.getx();
float ty = particle.gety();
/* The radius or distance between both particles are determined */
float radius = dist(x,y,tx,ty);
/* Is the radius small enough for the particle to have an effect on our current one? */
if (radius < 35) {
/* We've the determine that the particle is close enough for relationship lines, so we set drawthis to true. */
drawthis = true;
/* If so, we proceed to calculate the angle. */
float angle = atan2(y-ty,x-tx);
/* Is the radius close enough to be deflected? */
if (radius < 30) {
/* Is relationship lines toggled? */
if (lines) {
/*
Redshade is increased by the distance * 5. The distance is multiplied by 10 because our radius will be within 40 pixels,
30 * 13.33... is 400
We invert it so it gets redder as the particle approaches the current particle, rather than vice versa.
*/
redshade = 13 * (30 - radius);
}
/*
Here, we calculate a coordinate at a angle opposite of the direction where the other particle is.
0.07 is the strength of the particle's opposition, while (40 - radius) is how much it is effected, according to how close it is.
*/
vx += (30 - radius) * 0.07 * cos(angle);
vy += (30 - radius) * 0.07 * sin(angle);
}
/*
Here we see if the particle is within 25 and 35 pixels of the current particle
(we already know that the particle is under 35 pixels distance, since this if statement is nested
in if (radius < 35), so rechecking is unnecessary
*/
if (radius > 25) {
/* check to see if relationship lines are toggled */
if (lines) {
/* The blue shade, between 0 and 400, is used to show how much each particle is attracted */
blueshade = 40 * (35 - radius);
}
/* This does the opposite of the other check. It pulls the particle towards the other. */
vx -= (25 - radius) * 0.005 * cos(angle);
vy -= (25 - radius) * 0.005 * sin(angle);
}
}
/* Check to see if relationship lines are enabled */
if (lines) {
/* Check to see if the two particles are close enough. */
if (drawthis) {
/* Set the stroke color */
stroke (redshade, 10, blueshade);
/* draw the line */
line(x,y,tx,ty);
}
}
}
}
/* Check to see if the user is clicking */
if (mousePressed) {
/* The cursor's x and y coordinates. */
//CHANGE FROM MOUSE COORDINATES TO colorX and colorY WHICH DEFINE THE ELLIPSE'S LOCATION ABOVE (IN DRAW)
float tx = colorX;
float ty = colorY;
/* the distance between the cursor and particle */
float radius = dist(x,y,tx,ty);
if (radius < 100) {
/* Calculate the angle between the particle and the cursor. */
float angle = atan2(ty-y,tx-x);
/* Are we left-clicking or not? */
if (mouseButton == LEFT) {
/* If left, then the particles are deflected */
vx -= radius * 0.07 * cos(angle);
vy -= radius * 0.07 * sin(angle);
/* The stroke color is red */
stroke(radius * 4,0,0);
}
else {
/* If right, the particles are attracted. */
vx += radius * 0.07 * cos(angle);
vy += radius * 0.07 * sin(angle);
/* The stroke color is blue */
stroke(0,0,radius * 4);
}
/* If line relationships are enabled, the lines are drawn. */
if (lines) line (x,y,tx,ty);
}
}
/* Previox x and y coordinates are set, for drawing the trail */
int px = (int)x;
int py = (int)y;
/* Our particle's coordinates are updated. */
x += vx;
y += vy;
/* Gravity is applied. */
if (gravity == true) vy += 2;
/* Border collisions */
if (x > width-11) {
/* Reverse the velocity if towards wall */
if (abs(vx) == vx) vx *= -1.0;
/* The particle is placed back at the wall */
x = width-11;
}
if (x < 11) {
if (abs(vx) != vx) vx *= -1.0;
x = 11;
}
if (y < 11) {
if (abs(vy) != vy) vy *= -1.0;
y = 11;
}
if (y > height-11) {
if (abs(vy) == vy) vy *= -1.0;
vx *= 0.6;
y = height-11;
}
/* if relationship lines are disabled */
if (!lines) {
/* The stroke color is set to white */
stroke (400);
/* The particle is drawn */
line(px,py,int(x),int(y));
}
}
}
/* User presses a key */
void keyPressed() {
/* if they press g */
if (key == 'g' || key == 'G') {
/* we toggle gravity */
if (gravity) gravity = false;
else gravity = true;
}
/* otherwise */
else {
/* we toggle line relationships */
if (lines) lines = false;
else lines = true;
}
}

There's only three points where I've changed/added anything.

Hope that helps

Cheers

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

Thank you so much

that is just what im trying to do

i should be able to use the same process so it can have a threshold for the color tracking which can act as the right mouse click

cheers

Miles

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

Hi there, thanks again for your help,

Ive managed to use osc now to export the xy data, but really i need to export the amount of attracted particles,

Im not really too sure if there is any point where this number exists within the code

/**
* Color Tracking
* by Justin Brooks
*
*
* based on original code:
* Brightness Tracking
* by Golan Levin.
*
* Tracks the tracks pixel closest in color to specified color.
*/
boolean lines = false;
/*
gravity toggle
toggle this by pressing 'g'
*/
boolean gravity = false;
boolean rightclick = false;
/* Particle count */
int particleCount = 500;
int pcounter = 0;
/* Particle array */
Particle[] particles = new Particle[particleCount+1];
//DECLARE THESE HERE SO THEY'RE ACCESSIBLE GLOBALLY
int colorX = 0; // X-coordinate of the closest in color video pixel
int colorY = 0; // Y-coordinate of the closest in color video pixel
import oscP5.*;
import netP5.*;
OscP5 oscP5;
NetAddress myRemoteLocation;
import processing.video.*;
Capture video;
void setup() {
size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height, 30);
noStroke();
smooth();
colorMode(RGB, 400);
/* Frame rate is 30 */
frameRate(30);
/* The fill color is set to black (0) for the boundaries (drawn as a quad) */
fill (0);
oscP5 = new OscP5(this,7474);
myRemoteLocation = new NetAddress("127.0.0.1",7474);
/* We loop through our particle count and initialize each */
for (int x = particleCount; x >= 0; x--) {
particles[x] = new Particle();
}
}
void draw() {
if (video.available()) {
video.read();
background(0);
/* The stroke color is set to white for the border. */
stroke (400);
/* The border; it is 10 pixels from all sides */
quad (10,10,10,height-10,width-10,height-10,width-10,10);
/* All of our particles are looped through, and updated */
for (int i = particleCount; i >= 0; i--) {
Particle particle = (Particle) particles[i];
particle.update(i);
}
//REMOVE THE INTS SINCE WE INITIALISED THEM BEFORE SETUP
colorX = 0; // X-coordinate of the closest in color video pixel
colorY = 0; // Y-coordinate of the closest in color video pixel
float closestColor = 10000; //we set this to be abritrarily large, once program runs, the first pixel it scans will be set to this value
// Search for the closest in color pixel: For each row of pixels in the video image and
// for each pixel in the yth row, compute each pixel's index in the video
video.loadPixels();
int index = 0;
for (int ay = 0; ay < video.height; ay++) {
for (int ax = 0; ax < video.width; ax++) {
// Get the color stored in the pixel
color pixelValue = video.pixels[index];
// Determine the color of the pixel
float colorProximity = abs(red(pixelValue)-0)+abs(green(pixelValue)-255)+abs(blue(pixelValue)-0);
// If that value is closer in color value than any previous, then store the
// color proximity of that pixel, as well as its (x,y) location
if (colorProximity < closestColor) {
closestColor = colorProximity;
closestColor=closestColor-10; //thoguht behind this is that it once it "locks" on to an object of color, it wont let go unless something a good bit better (closer in color) comes along
colorY = ay;
colorX = ax;
rightclick = true;
}
index++;
}
}
OscMessage myMessage = new OscMessage("/test");
myMessage.add((float)colorX);
myMessage.add(1. - (float)colorY);
myMessage.add(2. - (float)pcounter);
/* send the message */
oscP5.send(myMessage, myRemoteLocation);
// Draw a large, yellow circle at the brightest pixel
fill(255, 204, 0, 128);
ellipse(colorX, colorY, 200, 200);
}
}
class Particle {
/*
Global class variables
These are kept track of, and aren't lost when the class particle is finished operating.
*/
/* the x and y are our coordinates for each particles */
float x;
float y;
/* vx and vy are the velocities along each axis the particles are traveling */
float vx;
float vy;
/* Particle initialization. We define the beginning properties of each particle here. */
Particle() {
x = random(10,width-10);
y = random(10,height-10);
}
/* These are called everytime we check with the other particle's distances */
float getx() {
return x;
}
float gety() {
return y;
}
void update(int num) {
/* Friction is simulated here */
vx *= 0.84;
vy *= 0.84;
/* Here, every particle is looped through and checked to see if they're close enough to have effect on the current particle. */
for (int i = particleCount; i >= 0; i--) {
/* Check to see if the particle we're checking isn't the current particle. */
if (i != num) {
/* drawthis boolean is initialized. it determines whether the particle is close enough to the other particles for relationship lines to be drawn, assuming it's enabled */
boolean drawthis = false;
/*
Integers are used to keep track of the shade for each particle
The red shade shows opposition
The blue shade shows attraction
*/
float redshade = 20;
float blueshade = 500;
/* We set our particle */
Particle particle = (Particle) particles[i];
/* The x and y coordinates of the particle is found, so we can compare distances with our current particle. */
float tx = particle.getx();
float ty = particle.gety();
/* The radius or distance between both particles are determined */
float radius = dist(x,y,tx,ty);
/* Is the radius small enough for the particle to have an effect on our current one? */
if (radius < 35) {
/* We've the determine that the particle is close enough for relationship lines, so we set drawthis to true. */
drawthis = true;
/* If so, we proceed to calculate the angle. */
float angle = atan2(y-ty,x-tx);
/* Is the radius close enough to be deflected? */
if (radius < 30) {
/* Is relationship lines toggled? */
if (lines) {
/*
Redshade is increased by the distance * 5. The distance is multiplied by 10 because our radius will be within 40 pixels,
30 * 13.33... is 400
We invert it so it gets redder as the particle approaches the current particle, rather than vice versa.
*/
redshade = 13 * (30 - radius);
}
/*
Here, we calculate a coordinate at a angle opposite of the direction where the other particle is.
0.07 is the strength of the particle's opposition, while (40 - radius) is how much it is effected, according to how close it is.
*/
vx += (30 - radius) * 0.07 * cos(angle);
vy += (30 - radius) * 0.07 * sin(angle);
}
/*
Here we see if the particle is within 25 and 35 pixels of the current particle
(we already know that the particle is under 35 pixels distance, since this if statement is nested
in if (radius < 35), so rechecking is unnecessary
*/
if (radius > 25) {
/* check to see if relationship lines are toggled */
if (lines) {
/* The blue shade, between 0 and 400, is used to show how much each particle is attracted */
blueshade = 40 * (35 - radius);
}
/* This does the opposite of the other check. It pulls the particle towards the other. */
vx -= (25 - radius) * 0.005 * cos(angle);
vy -= (25 - radius) * 0.005 * sin(angle);
}
}
/* Check to see if relationship lines are enabled */
if (lines) {
/* Check to see if the two particles are close enough. */
if (drawthis) {
/* Set the stroke color */
stroke (redshade, 10, blueshade);
/* draw the line */
line(x,y,tx,ty);
}
}
}
}
/* Check to see if the user is clicking */
if (rightclick = true) {
/* The cursor's x and y coordinates. */
//CHANGE FROM MOUSE COORDINATES TO colorX and colorY WHICH DEFINE THE ELLIPSE'S LOCATION ABOVE (IN DRAW)
float tx = colorX;
float ty = colorY;
/* the distance between the cursor and particle */
float radius = dist(x,y,tx,ty);
if (radius < 100) {
/* Calculate the angle between the particle and the cursor. */
float angle = atan2(ty-y,tx-x);
/* Are we left-clicking or not? */
if (mouseButton == LEFT) {
/* If left, then the particles are deflected */
vx -= radius * 0.07 * cos(angle);
vy -= radius * 0.07 * sin(angle);
/* The stroke color is red */
stroke(radius * 4,0,0);
}
else {
/* If right, the particles are attracted. */
vx += radius * 0.07 * cos(angle);
vy += radius * 0.07 * sin(angle);
/* The stroke color is blue */
stroke(0,0,radius * 4);
}
/* If line relationships are enabled, the lines are drawn. */
if (lines) line (x,y,tx,ty);
}
}
/* Previox x and y coordinates are set, for drawing the trail */
int px = (int)x;
int py = (int)y;
/* Our particle's coordinates are updated. */
x += vx;
y += vy;
/* Gravity is applied. */
if (gravity == true) vy += 2;
/* Border collisions */
if (x > width-11) {
/* Reverse the velocity if towards wall */
if (abs(vx) == vx) vx *= -1.0;
/* The particle is placed back at the wall */
x = width-11;
}
if (x < 11) {
if (abs(vx) != vx) vx *= -1.0;
x = 11;
}
if (y < 11) {
if (abs(vy) != vy) vy *= -1.0;
y = 11;
}
if (y > height-11) {
if (abs(vy) == vy) vy *= -1.0;
vx *= 0.6;
y = height-11;
}
/* if relationship lines are disabled */
if (!lines) {
/* The stroke color is set to white */
stroke (400);
/* The particle is drawn */
line(px,py,int(x),int(y));
}
}
}
/* User presses a key */
void keyPressed() {
/* if they press g */
if (key == 'g' || key == 'G') {
/* we toggle gravity */
if (gravity) gravity = false;
else gravity = true;
}
/* otherwise */
else {
/* we toggle line relationships */
if (lines) lines = false;
else lines = true;
}
}

Regards

Miles

velvetkev..

Re: Mixing active and static modes??? please help

2 years ago

OK, the number of affected particles isn't there as such but since you're already testing whether the particle is affected it's simple to add a counter. I've added it in below; again, my additions are commented in caps. Only four or five lines,

/**
* Color Tracking
* by Justin Brooks
*
*
* based on original code:
* Brightness Tracking
* by Golan Levin.
*
* Tracks the tracks pixel closest in color to specified color.
*/
boolean lines = false;
/*
gravity toggle
toggle this by pressing 'g'
*/
boolean gravity = false;
boolean rightclick = false;
/* Particle count */
int particleCount = 500;
int pcounter = 0;
/* Particle array */
Particle[] particles = new Particle[particleCount+1];
//DECLARE THESE HERE SO THEY'RE ACCESSIBLE GLOBALLY
int colorX = 0; // X-coordinate of the closest in color video pixel
int colorY = 0; // Y-coordinate of the closest in color video pixel
import oscP5.*;
import netP5.*;
OscP5 oscP5;
NetAddress myRemoteLocation;
import processing.video.*;
Capture video;
int affectedCount=0;//DECLARE HERE SO ACCESSIBLE EVERYWHERE
void setup() {
size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height, 30);
noStroke();
smooth();
colorMode(RGB, 400);
/* Frame rate is 30 */
frameRate(30);
/* The fill color is set to black (0) for the boundaries (drawn as a quad) */
fill (0);
oscP5 = new OscP5(this,7474);
myRemoteLocation = new NetAddress("127.0.0.1",7474);
/* We loop through our particle count and initialize each */
for (int x = particleCount; x >= 0; x--) {
particles[x] = new Particle();
}
}
void draw() {
if (video.available()) {
video.read();
background(0);
affectedCount=0;//RESET COUNTER AT THE START OF EACH FRAME
/* The stroke color is set to white for the border. */
stroke (400);
/* The border; it is 10 pixels from all sides */
quad (10,10,10,height-10,width-10,height-10,width-10,10);
/* All of our particles are looped through, and updated */
for (int i = particleCount; i >= 0; i--) {
Particle particle = (Particle) particles[i];
particle.update(i);
}
//REMOVE THE INTS SINCE WE INITIALISED THEM BEFORE SETUP
colorX = 0; // X-coordinate of the closest in color video pixel
colorY = 0; // Y-coordinate of the closest in color video pixel
float closestColor = 10000; //we set this to be abritrarily large, once program runs, the first pixel it scans will be set to this value
// Search for the closest in color pixel: For each row of pixels in the video image and
// for each pixel in the yth row, compute each pixel's index in the video
video.loadPixels();
int index = 0;
for (int ay = 0; ay < video.height; ay++) {
for (int ax = 0; ax < video.width; ax++) {
// Get the color stored in the pixel
color pixelValue = video.pixels[index];
// Determine the color of the pixel
float colorProximity = abs(red(pixelValue)-0)+abs(green(pixelValue)-255)+abs(blue(pixelValue)-0);
// If that value is closer in color value than any previous, then store the
// color proximity of that pixel, as well as its (x,y) location
if (colorProximity < closestColor) {
closestColor = colorProximity;
closestColor=closestColor-10; //thoguht behind this is that it once it "locks" on to an object of color, it wont let go unless something a good bit better (closer in color) comes along
colorY = ay;
colorX = ax;
rightclick = true;
}
index++;
}
}
println(affectedCount);//DO WHATEVER WITH THIS
OscMessage myMessage = new OscMessage("/test");
myMessage.add((float)colorX);
myMessage.add(1. - (float)colorY);
myMessage.add(2. - (float)pcounter);
/* send the message */
oscP5.send(myMessage, myRemoteLocation);
// Draw a large, yellow circle at the brightest pixel
fill(255, 204, 0, 128);
ellipse(colorX, colorY, 200, 200);
}
}
class Particle {
/*
Global class variables
These are kept track of, and aren't lost when the class particle is finished operating.
*/
/* the x and y are our coordinates for each particles */
float x;
float y;
/* vx and vy are the velocities along each axis the particles are traveling */
float vx;
float vy;
/* Particle initialization. We define the beginning properties of each particle here. */
Particle() {
x = random(10,width-10);
y = random(10,height-10);
}
/* These are called everytime we check with the other particle's distances */
float getx() {
return x;
}
float gety() {
return y;
}
void update(int num) {
/* Friction is simulated here */
vx *= 0.84;
vy *= 0.84;
/* Here, every particle is looped through and checked to see if they're close enough to have effect on the current particle. */
for (int i = particleCount; i >= 0; i--) {
/* Check to see if the particle we're checking isn't the current particle. */
if (i != num) {
/* drawthis boolean is initialized. it determines whether the particle is close enough to the other particles for relationship lines to be drawn, assuming it's enabled */
boolean drawthis = false;
/*
Integers are used to keep track of the shade for each particle
The red shade shows opposition
The blue shade shows attraction
*/
float redshade = 20;
float blueshade = 500;
/* We set our particle */
Particle particle = (Particle) particles[i];
/* The x and y coordinates of the particle is found, so we can compare distances with our current particle. */
float tx = particle.getx();
float ty = particle.gety();
/* The radius or distance between both particles are determined */
float radius = dist(x,y,tx,ty);
/* Is the radius small enough for the particle to have an effect on our current one? */
if (radius < 35) {
/* We've the determine that the particle is close enough for relationship lines, so we set drawthis to true. */
drawthis = true;
/* If so, we proceed to calculate the angle. */
float angle = atan2(y-ty,x-tx);
/* Is the radius close enough to be deflected? */
if (radius < 30) {
/* Is relationship lines toggled? */
if (lines) {
/*
Redshade is increased by the distance * 5. The distance is multiplied by 10 because our radius will be within 40 pixels,
30 * 13.33... is 400
We invert it so it gets redder as the particle approaches the current particle, rather than vice versa.
*/
redshade = 13 * (30 - radius);
}
/*
Here, we calculate a coordinate at a angle opposite of the direction where the other particle is.
0.07 is the strength of the particle's opposition, while (40 - radius) is how much it is effected, according to how close it is.
*/
vx += (30 - radius) * 0.07 * cos(angle);
vy += (30 - radius) * 0.07 * sin(angle);
}
/*
Here we see if the particle is within 25 and 35 pixels of the current particle
(we already know that the particle is under 35 pixels distance, since this if statement is nested
in if (radius < 35), so rechecking is unnecessary
*/
if (radius > 25) {
/* check to see if relationship lines are toggled */
if (lines) {
/* The blue shade, between 0 and 400, is used to show how much each particle is attracted */
blueshade = 40 * (35 - radius);
}
/* This does the opposite of the other check. It pulls the particle towards the other. */
vx -= (25 - radius) * 0.005 * cos(angle);
vy -= (25 - radius) * 0.005 * sin(angle);
}
}
/* Check to see if relationship lines are enabled */
if (lines) {
/* Check to see if the two particles are close enough. */
if (drawthis) {
/* Set the stroke color */
stroke (redshade, 10, blueshade);
/* draw the line */
line(x,y,tx,ty);
}
}
}
}
/* Check to see if the user is clicking */
if (rightclick = true) {
/* The cursor's x and y coordinates. */
//CHANGE FROM MOUSE COORDINATES TO colorX and colorY WHICH DEFINE THE ELLIPSE'S LOCATION ABOVE (IN DRAW)
float tx = colorX;
float ty = colorY;
/* the distance between the cursor and particle */
float radius = dist(x,y,tx,ty);
if (radius < 100) { //THIS IS THE TEST OF WHETHER THE PARTICLE IS AFFECTED
affectedCount++; // IF IT IS, INCREASE THE COUNTER
/* Calculate the angle between the particle and the cursor. */
float angle = atan2(ty-y,tx-x);
/* Are we left-clicking or not? */
if (mouseButton == LEFT) {
/* If left, then the particles are deflected */
vx -= radius * 0.07 * cos(angle);
vy -= radius * 0.07 * sin(angle);
/* The stroke color is red */
stroke(radius * 4,0,0);
}
else {
/* If right, the particles are attracted. */
vx += radius * 0.07 * cos(angle);
vy += radius * 0.07 * sin(angle);
/* The stroke color is blue */
stroke(0,0,radius * 4);
}
/* If line relationships are enabled, the lines are drawn. */
if (lines) line (x,y,tx,ty);
}
}
/* Previox x and y coordinates are set, for drawing the trail */
int px = (int)x;
int py = (int)y;
/* Our particle's coordinates are updated. */
x += vx;
y += vy;
/* Gravity is applied. */
if (gravity == true) vy += 2;
/* Border collisions */
if (x > width-11) {
/* Reverse the velocity if towards wall */
if (abs(vx) == vx) vx *= -1.0;
/* The particle is placed back at the wall */
x = width-11;
}
if (x < 11) {
if (abs(vx) != vx) vx *= -1.0;
x = 11;
}
if (y < 11) {
if (abs(vy) != vy) vy *= -1.0;
y = 11;
}
if (y > height-11) {
if (abs(vy) == vy) vy *= -1.0;
vx *= 0.6;
y = height-11;
}
/* if relationship lines are disabled */
if (!lines) {
/* The stroke color is set to white */
stroke (400);
/* The particle is drawn */
line(px,py,int(x),int(y));
}
}
}
/* User presses a key */
void keyPressed() {
/* if they press g */
if (key == 'g' || key == 'G') {
/* we toggle gravity */
if (gravity) gravity = false;
else gravity = true;
}
/* otherwise */
else {
/* we toggle line relationships */
if (lines) lines = false;
else lines = true;
}
}

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

Thank you,

Thats brilliant ive now got that adapting audio within Max/MSP through OSC

Ive been having troubles for a while attempting to create a colour threshold (line 96), to make click = true, for use later in the particle class (line 214)

/**
* Color Tracking
* by Justin Brooks
*
*
* based on original code:
* Brightness Tracking
* by Golan Levin.
*
* Tracks the tracks pixel closest in color to specified color.
*/
boolean lines = false;
/*
gravity toggle
toggle this by pressing 'g'
*/
boolean gravity = false;
boolean click = false;
/* Particle count */
int particleCount = 500;
int pcounter = 0;
/* Particle array */
Particle[] particles = new Particle[particleCount+1];
//DECLARE THESE HERE SO THEY'RE ACCESSIBLE GLOBALLY
int colorX = 0; // X-coordinate of the closest in color video pixel
int colorY = 0; // Y-coordinate of the closest in color video pixel
import oscP5.*;
import netP5.*;
OscP5 oscP5;
NetAddress myRemoteLocation;
import processing.video.*;
Capture video;
int affectedCount=0;//DECLARE HERE SO ACCESSIBLE EVERYWHERE
void setup() {
size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height, 30);
noStroke();
smooth();
colorMode(RGB, 400);
/* Frame rate is 30 */
frameRate(30);
/* The fill color is set to black (0) for the boundaries (drawn as a quad) */
fill (0);
oscP5 = new OscP5(this,7474);
myRemoteLocation = new NetAddress("127.0.0.1",7474);
/* We loop through our particle count and initialize each */
for (int x = particleCount; x >= 0; x--) {
particles[x] = new Particle();
}
}
void draw() {
if (video.available()) {
video.read();
background(0);
affectedCount=0;//RESET COUNTER AT THE START OF EACH FRAME
/* The stroke color is set to white for the border. */
stroke (400);
/* The border; it is 10 pixels from all sides */
quad (10,10,10,height-10,width-10,height-10,width-10,10);
/* All of our particles are looped through, and updated */
for (int i = particleCount; i >= 0; i--) {
Particle particle = (Particle) particles[i];
particle.update(i);
}
//REMOVE THE INTS SINCE WE INITIALISED THEM BEFORE SETUP
colorX = 0; // X-coordinate of the closest in color video pixel
colorY = 0; // Y-coordinate of the closest in color video pixel
float closestColor = 10000; //we set this to be abritrarily large, once program runs, the first pixel it scans will be set to this value
// Search for the closest in color pixel: For each row of pixels in the video image and
// for each pixel in the yth row, compute each pixel's index in the video
video.loadPixels();
int index = 0;
for (int ay = 0; ay < video.height; ay++) {
for (int ax = 0; ax < video.width; ax++) {
// Get the color stored in the pixel
color pixelValue = video.pixels[index];
// Determine the color of the pixel
float colorProximity = abs(red(pixelValue)-0)+abs(green(pixelValue)-255)+abs(blue(pixelValue)-0);
// If that value is closer in color value than any previous, then store the
// color proximity of that pixel, as well as its (x,y) location
if (colorProximity < closestColor) {
closestColor = colorProximity;
closestColor=closestColor-10; //thoguht behind this is that it once it "locks" on to an object of color, it wont let go unless something a good bit better (closer in color) comes along
colorY = ay;
colorX = ax;
}
index++;
}
}
println(affectedCount);//DO WHATEVER WITH THIS
OscMessage myMessage = new OscMessage("/test");
myMessage.add((float)colorX);
myMessage.add(1. - (float)colorY);
myMessage.add(2. - (int)affectedCount);
/* send the message */
oscP5.send(myMessage, myRemoteLocation);
// Draw a large, yellow circle at the brightest pixel
fill(255, 204, 0, 128);
ellipse(colorX, colorY, 200, 200);
}
}
class Particle {
/*
Global class variables
These are kept track of, and aren't lost when the class particle is finished operating.
*/
/* the x and y are our coordinates for each particles */
float x;
float y;
/* vx and vy are the velocities along each axis the particles are traveling */
float vx;
float vy;
/* Particle initialization. We define the beginning properties of each particle here. */
Particle() {
x = random(10,width-10);
y = random(10,height-10);
}
/* These are called everytime we check with the other particle's distances */
float getx() {
return x;
}
float gety() {
return y;
}
void update(int num) {
/* Friction is simulated here */
vx *= 0.84;
vy *= 0.84;
/* Here, every particle is looped through and checked to see if they're close enough to have effect on the current particle. */
for (int i = particleCount; i >= 0; i--) {
/* Check to see if the particle we're checking isn't the current particle. */
if (i != num) {
/* drawthis boolean is initialized. it determines whether the particle is close enough to the other particles for relationship lines to be drawn, assuming it's enabled */
boolean drawthis = false;
/*
Integers are used to keep track of the shade for each particle
The red shade shows opposition
The blue shade shows attraction
*/
float redshade = 20;
float blueshade = 500;
/* We set our particle */
Particle particle = (Particle) particles[i];
/* The x and y coordinates of the particle is found, so we can compare distances with our current particle. */
float tx = particle.getx();
float ty = particle.gety();
/* The radius or distance between both particles are determined */
float radius = dist(x,y,tx,ty);
/* Is the radius small enough for the particle to have an effect on our current one? */
if (radius < 35) {
/* We've the determine that the particle is close enough for relationship lines, so we set drawthis to true. */
drawthis = true;
/* If so, we proceed to calculate the angle. */
float angle = atan2(y-ty,x-tx);
/* Is the radius close enough to be deflected? */
if (radius < 30) {
/* Is relationship lines toggled? */
if (lines) {
/*
Redshade is increased by the distance * 5. The distance is multiplied by 10 because our radius will be within 40 pixels,
30 * 13.33... is 400
We invert it so it gets redder as the particle approaches the current particle, rather than vice versa.
*/
redshade = 13 * (30 - radius);
}
/*
Here, we calculate a coordinate at a angle opposite of the direction where the other particle is.
0.07 is the strength of the particle's opposition, while (40 - radius) is how much it is effected, according to how close it is.
*/
vx += (30 - radius) * 0.07 * cos(angle);
vy += (30 - radius) * 0.07 * sin(angle);
}
/*
Here we see if the particle is within 25 and 35 pixels of the current particle
(we already know that the particle is under 35 pixels distance, since this if statement is nested
in if (radius < 35), so rechecking is unnecessary
*/
if (radius > 25) {
/* check to see if relationship lines are toggled */
if (lines) {
/* The blue shade, between 0 and 400, is used to show how much each particle is attracted */
blueshade = 40 * (35 - radius);
}
/* This does the opposite of the other check. It pulls the particle towards the other. */
vx -= (25 - radius) * 0.005 * cos(angle);
vy -= (25 - radius) * 0.005 * sin(angle);
}
}
/* Check to see if relationship lines are enabled */
if (lines) {
/* Check to see if the two particles are close enough. */
if (drawthis) {
/* Set the stroke color */
stroke (redshade, 10, blueshade);
/* draw the line */
line(x,y,tx,ty);
}
}
}
}
/* Check to see if the user is clicking */
if (click = true) {
/* The cursor's x and y coordinates. */
//CHANGE FROM MOUSE COORDINATES TO colorX and colorY WHICH DEFINE THE ELLIPSE'S LOCATION ABOVE (IN DRAW)
float tx = colorX;
float ty = colorY;
/* the distance between the cursor and particle */
float radius = dist(x,y,tx,ty);
if (radius < 100) { //THIS IS THE TEST OF WHETHER THE PARTICLE IS AFFECTED
affectedCount++; // IF IT IS, INCREASE THE COUNTER
/* Calculate the angle between the particle and the cursor. */
float angle = atan2(ty-y,tx-x);
/* Are we left-clicking or not? */
if (mouseButton == LEFT) {
/* If left, then the particles are deflected */
vx -= radius * 0.07 * cos(angle);
vy -= radius * 0.07 * sin(angle);
/* The stroke color is red */
stroke(radius * 4,0,0);
}
else {
/* If right, the particles are attracted. */
vx += radius * 0.07 * cos(angle);
vy += radius * 0.07 * sin(angle);
/* The stroke color is blue */
stroke(0,0,radius * 4);
}
/* If line relationships are enabled, the lines are drawn. */
if (lines) line (x,y,tx,ty);
}
}
/* Previox x and y coordinates are set, for drawing the trail */
int px = (int)x;
int py = (int)y;
/* Our particle's coordinates are updated. */
x += vx;
y += vy;
/* Gravity is applied. */
if (gravity == true) vy += 2;
/* Border collisions */
if (x > width-11) {
/* Reverse the velocity if towards wall */
if (abs(vx) == vx) vx *= -1.0;
/* The particle is placed back at the wall */
x = width-11;
}
if (x < 11) {
if (abs(vx) != vx) vx *= -1.0;
x = 11;
}
if (y < 11) {
if (abs(vy) != vy) vy *= -1.0;
y = 11;
}
if (y > height-11) {
if (abs(vy) == vy) vy *= -1.0;
vx *= 0.6;
y = height-11;
}
/* if relationship lines are disabled */
if (!lines) {
/* The stroke color is set to white */
stroke (400);
/* The particle is drawn */
line(px,py,int(x),int(y));
}
}
}
/* User presses a key */
void keyPressed() {
/* if they press g */
if (key == 'g' || key == 'G') {
/* we toggle gravity */
if (gravity) gravity = false;
else gravity = true;
}
/* otherwise */
else {
/* we toggle line relationships */
if (lines) lines = false;
else lines = true;
}
}

Your a superstar, i definitely would miss my uni deadline if it wasn't for your help

Hail the beauties of forums and open source

Regards

Miles

velvetkev..

Re: Mixing active and static modes??? please help

2 years ago

I'm not sure I get you. Are you just looking for something like this?

if(colorX<=threshold){
doWhatWeDidForLeftClick();
} else {
doWhatWeDidForRightClick();
}

That would mean there is always attraction/repulsion, with no neutral state? Where are you getting the threshold value from?

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

im trying to have it so that if the green isnt green enough then the sketch looks as if its in a neutral state,

so when the green is registered as being green enough the particles will attract, if that makes sense.

ive been trying to put in this kind of threshold style thing at around line 94, as i was expecting to be able to use the green(pixelValue) as something to compare to my threshold of maybe 200.

a bit like this, but correct...

if(green(pixelValue)>200{

attract

}

else{

no click

}

cheers

Miles

velvetkev..

Re: Mixing active and static modes??? please help

2 years ago

OK, first declare a global boolean (true/false) before setup(), which will replace the mouseClick check:

boolean active=false;

Between line 95 and 96 add in a check, something like:

if(green(pixelValue)>200){
active=true;
}
else{
active=false;
}

We can then condense lines 215-240 into the following.

if (active = true) {
/* The cursor's x and y coordinates. */
//CHANGE FROM MOUSE COORDINATES TO colorX and colorY WHICH DEFINE THE ELLIPSE'S LOCATION ABOVE (IN DRAW)
float tx = colorX;
float ty = colorY;
/* the distance between the cursor and particle */
float radius = dist(x,y,tx,ty);
if (radius < 100) { //THIS IS THE TEST OF WHETHER THE PARTICLE IS AFFECTED
affectedCount++; // IF IT IS, INCREASE THE COUNTER
/* Calculate the angle between the particle and the cursor. */
float angle = atan2(ty-y,tx-x);
vx += radius * 0.07 * cos(angle);
vy += radius * 0.07 * sin(angle);
/* The stroke color is blue */
stroke(0,0,radius * 4);
}

I've not tested this but that should give you the right idea, I think.

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

Cheers for that, i think thats nearly it but

It doesnt seem to work, i think the sketch uses something else to initialize it but im not sure and I can't work it out,

this is the code i have at the moment:

/**
* Color Tracking
* by Justin Brooks
*
*
* based on original code:
* Brightness Tracking
* by Golan Levin.
*
* Tracks the tracks pixel closest in color to specified color.
*/
boolean lines = false;
boolean active = false;
/*
gravity toggle
toggle this by pressing 'g'
*/
boolean gravity = false;
/* Particle count */
int particleCount = 500;
int pcounter = 0;
/* Particle array */
Particle[] particles = new Particle[particleCount+1];
//DECLARE THESE HERE SO THEY'RE ACCESSIBLE GLOBALLY
int colorX = 0; // X-coordinate of the closest in color video pixel
int colorY = 0; // Y-coordinate of the closest in color video pixel
import oscP5.*;
import netP5.*;
OscP5 oscP5;
NetAddress myRemoteLocation;
import processing.video.*;
Capture video;
int affectedCount=0;//DECLARE HERE SO ACCESSIBLE EVERYWHERE
void setup() {
size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height, 30);
noStroke();
smooth();
colorMode(RGB, 400);
/* Frame rate is 30 */
frameRate(30);
/* The fill color is set to black (0) for the boundaries (drawn as a quad) */
fill (0);
oscP5 = new OscP5(this,7474);
myRemoteLocation = new NetAddress("127.0.0.1",7474);
/* We loop through our particle count and initialize each */
for (int x = particleCount; x >= 0; x--) {
particles[x] = new Particle();
}
}
void draw() {
if (video.available()) {
video.read();
background(0);
affectedCount=0;//RESET COUNTER AT THE START OF EACH FRAME
/* The stroke color is set to white for the border. */
stroke (400);
/* The border; it is 10 pixels from all sides */
quad (10,10,10,height-10,width-10,height-10,width-10,10);
/* All of our particles are looped through, and updated */
for (int i = particleCount; i >= 0; i--) {
Particle particle = (Particle) particles[i];
particle.update(i);
}
//REMOVE THE INTS SINCE WE INITIALISED THEM BEFORE SETUP
colorX = 0; // X-coordinate of the closest in color video pixel
colorY = 0; // Y-coordinate of the closest in color video pixel
float closestColor = 10000; //we set this to be abritrarily large, once program runs, the first pixel it scans will be set to this value
// Search for the closest in color pixel: For each row of pixels in the video image and
// for each pixel in the yth row, compute each pixel's index in the video
video.loadPixels();
int index = 0;
for (int ay = 0; ay < video.height; ay++) {
for (int ax = 0; ax < video.width; ax++) {
// Get the color stored in the pixel
color pixelValue = video.pixels[index];
// Determine the color of the pixel
float colorProximity = abs(red(pixelValue)-0)+abs(green(pixelValue)-255)+abs(blue(pixelValue)-0);
// If that value is closer in color value than any previous, then store the
// color proximity of that pixel, as well as its (x,y) location
if (green(pixelValue) > 200){
active = true;
}
else{
active = false;
}
if (colorProximity < closestColor) {
closestColor = colorProximity;
closestColor=closestColor-10; //thoguht behind this is that it once it "locks" on to an object of color, it wont let go unless something a good bit better (closer in color) comes along
colorY = ay;
colorX = ax;
}
index++;
}
}
println(affectedCount);//DO WHATEVER WITH THIS
OscMessage myMessage = new OscMessage("/test");
myMessage.add((float)colorX);
myMessage.add(1. - (float)colorY);
myMessage.add(2. - (int)affectedCount);
/* send the message */
oscP5.send(myMessage, myRemoteLocation);
// Draw a large, yellow circle at the brightest pixel
}
}
class Particle {
/*
Global class variables
These are kept track of, and aren't lost when the class particle is finished operating.
*/
/* the x and y are our coordinates for each particles */
float x;
float y;
/* vx and vy are the velocities along each axis the particles are traveling */
float vx;
float vy;
/* Particle initialization. We define the beginning properties of each particle here. */
Particle() {
x = random(10,width-10);
y = random(10,height-10);
}
/* These are called everytime we check with the other particle's distances */
float getx() {
return x;
}
float gety() {
return y;
}
void update(int num) {
/* Friction is simulated here */
vx *= 0.84;
vy *= 0.84;
/* Here, every particle is looped through and checked to see if they're close enough to have effect on the current particle. */
for (int i = particleCount; i >= 0; i--) {
/* Check to see if the particle we're checking isn't the current particle. */
if (i != num) {
/* drawthis boolean is initialized. it determines whether the particle is close enough to the other particles for relationship lines to be drawn, assuming it's enabled */
boolean drawthis = false;
/*
Integers are used to keep track of the shade for each particle
The red shade shows opposition
The blue shade shows attraction
*/
float redshade = 20;
float blueshade = 500;
/* We set our particle */
Particle particle = (Particle) particles[i];
/* The x and y coordinates of the particle is found, so we can compare distances with our current particle. */
float tx = particle.getx();
float ty = particle.gety();
/* The radius or distance between both particles are determined */
float radius = dist(x,y,tx,ty);
/* Is the radius small enough for the particle to have an effect on our current one? */
if (radius < 35) {
/* We've the determine that the particle is close enough for relationship lines, so we set drawthis to true. */
drawthis = true;
/* If so, we proceed to calculate the angle. */
float angle = atan2(y-ty,x-tx);
/* Is the radius close enough to be deflected? */
if (radius < 30) {
/* Is relationship lines toggled? */
if (lines) {
/*
Redshade is increased by the distance * 5. The distance is multiplied by 10 because our radius will be within 40 pixels,
30 * 13.33... is 400
We invert it so it gets redder as the particle approaches the current particle, rather than vice versa.
*/
redshade = 13 * (30 - radius);
}
/*
Here, we calculate a coordinate at a angle opposite of the direction where the other particle is.
0.07 is the strength of the particle's opposition, while (40 - radius) is how much it is effected, according to how close it is.
*/
vx += (30 - radius) * 0.07 * cos(angle);
vy += (30 - radius) * 0.07 * sin(angle);
}
/*
Here we see if the particle is within 25 and 35 pixels of the current particle
(we already know that the particle is under 35 pixels distance, since this if statement is nested
in if (radius < 35), so rechecking is unnecessary
*/
if (radius > 25) {
/* check to see if relationship lines are toggled */
if (lines) {
/* The blue shade, between 0 and 400, is used to show how much each particle is attracted */
blueshade = 40 * (35 - radius);
}
/* This does the opposite of the other check. It pulls the particle towards the other. */
vx -= (25 - radius) * 0.005 * cos(angle);
vy -= (25 - radius) * 0.005 * sin(angle);
}
}
/* Check to see if relationship lines are enabled */
if (lines) {
/* Check to see if the two particles are close enough. */
if (drawthis) {
/* Set the stroke color */
stroke (redshade, 10, blueshade);
/* draw the line */
line(x,y,tx,ty);
}
}
}
}
/* Check to see if the user is clicking */
if (active = true) {
/* The cursor's x and y coordinates. */
//CHANGE FROM MOUSE COORDINATES TO colorX and colorY WHICH DEFINE THE ELLIPSE'S LOCATION ABOVE (IN DRAW)
float tx = colorX;
float ty = colorY;
/* the distance between the cursor and particle */
float radius = dist(x,y,tx,ty);
if (radius < 100) { //THIS IS THE TEST OF WHETHER THE PARTICLE IS AFFECTED
affectedCount++; // IF IT IS, INCREASE THE COUNTER
/* Calculate the angle between the particle and the cursor. */
float angle = atan2(ty-y,tx-x);
/* Are we left-clicking or not? */
/* If right, the particles are attracted. */
vx += radius * 0.07 * cos(angle);
vy += radius * 0.07 * sin(angle);
/* The stroke color is blue */
stroke(0,0,radius * 4);
/* If line relationships are enabled, the lines are drawn. */
if (active = true) {
if (lines) line (x,y,tx,ty);
}
}
}
/* Previox x and y coordinates are set, for drawing the trail */
int px = (int)x;
int py = (int)y;
/* Our particle's coordinates are updated. */
x += vx;
y += vy;
/* Gravity is applied. */
if (gravity == true) vy += 2;
/* Border collisions */
if (x > width-11) {
/* Reverse the velocity if towards wall */
if (abs(vx) == vx) vx *= -1.0;
/* The particle is placed back at the wall */
x = width-11;
}
if (x < 11) {
if (abs(vx) != vx) vx *= -1.0;
x = 11;
}
if (y < 11) {
if (abs(vy) != vy) vy *= -1.0;
y = 11;
}
if (y > height-11) {
if (abs(vy) == vy) vy *= -1.0;
vx *= 0.6;
y = height-11;
}
/* if relationship lines are disabled */
if (!lines) {
/* The stroke color is set to white */
stroke (400);
/* The particle is drawn */
line(px,py,int(x),int(y));
}
}
}
/* User presses a key */
void keyPressed() {
/* if they press g */
if (key == 'g' || key == 'G') {
/* we toggle gravity */
if (gravity) gravity = false;
else gravity = true;
}
/* otherwise */
else {
/* we toggle line relationships */
if (lines) lines = false;
else lines = true;
}
}

Regards

Miles

velvetkev..

Re: Mixing active and static modes??? please help

2 years ago

Can you be more specific? I just tested your code and it did what I expected. The more information you give the easier it is for us to help.

Bear in mind that the method you're using to track the greenest pixel may not always give the result you expect: calling green() on a white pixel (255, 255, 255) will get a higher result than calling it on a green pixel, e.g.(0, 250, 0).

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

ye of course, sorry about that,

i did wonder if that might be the case seen as white is all colours,

ill be getting a green laser pen through the post soon and the background will be black, so hopefully there will be no issue,

im using quite cheap webcams at the moment, so the colours aren't hugely true, could this become a problem?

for me it seems to stay active, so it is always attracting particles,

is that not the same for you then?

thanks

Miles

velvetkev..

Re: Mixing active and static modes??? please help

2 years ago

Oh God, I'm such an idiot. The logic in lines 224 and 243 should be

if(active==true)

not

if(active=true)

That explains why that whole section isn't working. Er... sorry!

As for the colour tracking, it seems OK but it's hard to say. I have no idea about algorithms for colour tracking. You'll need to experiment with your equipment. I saw the other thread you posted asking about that- I'd recommend asking as specific a question as possible. Explain what isn't working, and maybe post or highlight the relevant section of the code separately, as to be quite frank it's not easy to read 300 odd lines of code.

Hope that helps.

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

Of course,
im a bit new to this all,
Yeah thanks for that, its now nearly working
the active true/false part seems to not work properly yet, i think its due to the way that the pixelValue is calculated,
its difficult to test this seen as when i print the values it slows everything down, im guessing its because its printing the value from each pixel 30 times a second(framerate).

miles.tone

Re: Re: Mixing active and static modes??? please help

2 years ago

Hey there,

Ive tried to stop littering the forums,

Ive put a new post up which i hope is a bit more direct and i would be very greatful if you could cast your wise eye over it

http://forum.processing.org/topic/bit-shifting-colour-color-tracking-with-threshold-for-help-needed

Cheers

Miles

Top Reply