Locating the brightest spot on webcam

Core Library Questions

zshahab2

Locating the brightest spot on webcam

in Core Library Questions • 2 years ago

Hi, I'm working on some code to find the brightest spot on a webcam so that I can trace a double pendulum and plot its position vs time and then angle vs angle.

I've gotten the program to locate the brightest pixel through code found somewhere on the forums (but that is unreliable because it keeps moving around), I don't understand how to extend it so that it tells me the brightest chunk. Rather than finding the brightest pixel, it should find the brightest 5x5 for instance.

Here's what I have:

import processing.video.*;

Capture video;

lightPoint point1;

lightPoint point2;

int DATA_SIZE = 120;

float theta1;

float theta2;

float[] angle1 = new float[DATA_SIZE];

float[] angle2 = new float[DATA_SIZE];

void setup() {

size(1280, 480);

video = new Capture(this, 640, 480, 30);

smooth();

frameRate(28);

//noiseDetail(2);

//noiseSeed(System.currentTimeMillis());

//Create a light point to visualise from the class lightPoint

point1 = new lightPoint(0.0, 0.0, 0);

point2 = new lightPoint(0.0, 0.0, 0);

}

void draw() {

if (video.available()) {

video.read();

background(255);

fill(#005599);

image(video, 0, 0, 640, 480); // Draw the webcam video onto the screen

fill(100,0,0);

text(angle1[DATA_SIZE-1]*180/3.14159, 660, 20);

fill(0,100,0);

text(angle2[DATA_SIZE-1]*180/3.14159, 660, 40);

int brightestX = 0; // X-coordinate of the brightest video pixel

int brightestY = 0; // Y-coordinate of the brightest video pixel

float brightestValue = 0; // Brightness of the brightest video pixel

int nextbrightestX = 0 ; // all values to help track the 2nd brightest points in the area.

int nextbrightestY = 0 ;

float nextbrightestValue = 0 ;

// Search for the brightest 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;

int radius = 180 ;// closest placement of 2 different brightest spots.

for (int y = 0; y < video.height; y++) {

for (int x = 0; x < video.width; x++) {

// Get the color stored in the pixel

int pixelValue = video.pixels[index];

// Determine the brightness of the pixel

float pixelBrightness = brightness(pixelValue);

// If that value is brighter than any previous, then store the

// brightness of that pixel, as well as its (x,y) location

if ((pixelBrightness > brightestValue) && (distance(x, brightestX, y, brightestY) > radius))

{

brightestValue = pixelBrightness;

brightestY = y;

brightestX = x;

point1.x = brightestX;

point1.y = brightestY;

}

else if ((pixelBrightness > nextbrightestValue) && (distance(x, brightestX, y, brightestY) > radius))

{

nextbrightestValue = pixelBrightness;

nextbrightestY = y;

nextbrightestX = x;

point2.x = nextbrightestX;

point2.y = nextbrightestY;

}

index++;

}

fill(100,0,0);

ellipse(320, 300, 17, 17);

fill(0,100,0);

ellipse(320, 400, 17, 17);

theta1=abs( atan( (point1.x-320) / (point1.y-300) ));

theta2=abs( atan( (point2.x-320) / (point2.y-400) ));

// Display the lightPoint objects

fill(100,0,0);

point1.display();

fill(0,100,0);

point2.display();

for (int i = 1; i < DATA_SIZE; i++)

{

stroke(100,0,0);

line((i * 5) + 640, (float)((angle1[i - 1]*100))+200, (i + 1) * 5 + 640, (float)(angle1[i]*100)+200);

angle1[i - 1] = angle1[i];

stroke(0,100,0);

line((i * 5) + 640, (float)(angle2[i - 1]*100)+200, (i + 1) * 5 + 640, (float)(angle2[i]*100)+200);

angle2[i - 1] = angle2[i];

println(i) ;

}

angle1[DATA_SIZE - 1] = theta1;

angle2[DATA_SIZE - 1] = theta2;

}

float[] values = new float[width];

float distance(int xval, int xvalo, int yval, int yvalo)

{

return (sqrt ( ((float)(xval) - (float)(xvalo))*((float)(xval) - (float)(xvalo)) + ((float)(yval) - (float)(yvalo))* ((float)(yval) - (float)(yvalo)) ) ) ;

}

class lightPoint {

float x = 0.0; // X-coordinate of the brightest video pixel

float y = 0.0; // Y-coordinate of the brightest video pixel

// float brightestValue = 0; // Brightness of the brightest video pixel

boolean selected = false;

int index;

lightPoint(float xpos, float ypos, int num) {

x = xpos;

y = ypos;

index = num;

selected = false;

}

void display() {

//fill(204,102,0);

ellipse(x, y, 17, 17);

}

Replies(8)

miles.tone

Re: Locating the brightest spot on webcam

2 years ago

Possibly try reducing the amount of pixels actually seen by the tracking part by changing: video = new Capture() within setup and then later within draw you can recall it as you have done in draw to get the full image back.

Peace

clankill3r

Re: Locating the brightest spot on webcam

2 years ago

you could also use a blobscanner library.

This one is great, http://sites.google.com/site/blobscanner/

cedrickie..

Re: Locating the brightest spot on webcam

2 years ago

this code works as well. simply loop through all pixels and find the brightes one.

import processing.video.*;
 
Capture videocam;
// tracking Position
int xpos = 0;
int ypos = 0;
 
void setup () {
  size (320, 240);
  videocam = new Capture (this, width, height, 24);
  noFill ();
  strokeWeight (2);
  stroke (255, 0, 102);
}
 
void draw () {
  background (255);
 
  float maxCol = 0;
  if (videocam.available ()) {
    videocam.read ();
  }
 
  // für jeden Pixel in Breite des Sketches
  for (int i=0; i < width; i++) {
    for (int j=0; j < height; j++) {
      // lies den Farbwert für jeden Pixel aus
      color c = videocam.get (i, j);
      // Wenn heller als aktuelles Maximum
      // -> ersetze Tracking-Koordinaten
      if (brightness (c) > maxCol) {
        maxCol = brightness (c);
        xpos = i;
        ypos = j;
      }
    }
  }
  // Zeichne Bild und TrackingBox
  image (videocam, 0, 0);
  rect (xpos-2, ypos-2, 5, 5);
}

zshahab2

Re: Locating the brightest spot on webcam

2 years ago

thanks for all the great replies!

@cedrickiefer I tried the code you posted and it worked great for one point, so did mine. But when you try to locate two bright points, as in the case for a double pendulum, then it gets messy. Here's what I got for two points (Theres a bit of additional stuff that I started adding but then I decided I should just post it). But you'll notice that the points keep jumping around. I need the points to be following one pendulum each rather than jumping between each other...

import processing.video.*;
Capture videocam;
// tracking Position
int xpos = 0;
int ypos = 0;
int xpos2 = 0;
int ypos2 = 0;
int radius = 100; // closest placement of two different bright spots
float theta1;
float theta2;
int DATA_SIZE = 120;
float[] angle1 = new float[DATA_SIZE];
float[] angle2 = new float[DATA_SIZE];
float distance(int xval, int xvalo, int yval, int yvalo) {
return (sqrt ( ((float)(xval) - (float)(xvalo))*((float)(xval) - (float)(xvalo)) + ((float)(yval) - (float)(yvalo))* ((float)(yval) - (float)(yvalo)) ) ) ;
}
void setup () {
size (640, 480);
videocam = new Capture (this, width, height, 24);
noFill ();
strokeWeight (2);
stroke (255, 0, 102);
}
void draw () {
background (255);
float maxCol = 0;
float maxCol2 = 0;
if (videocam.available ()) {
videocam.read ();
}
image(videocam, 0, 0, 640, 480);
fill (100,0,0);
text(angle1[DATA_SIZE-1]*180/3.14159, 660, 20);
fill(0,100,0);
text(angle2[DATA_SIZE-1]*180/3.14159, 660, 40);
// run through picture
for (int i=0; i < width; i++) {
for (int j=0; j < height; j++) {
// lies den Farbwert für jeden Pixel aus
color c = videocam.get (i, j);
// find maximum bright, set that
if (brightness (c) > maxCol && (distance(i, xpos, j, ypos) > radius)) {
maxCol2 = maxCol;
xpos2 = xpos;
ypos2 = ypos;
maxCol = brightness (c);
xpos = i;
ypos = j;
}
}
}
// display rectangles on the brigthtest point
image (videocam, 0, 0);
rect (xpos, ypos, 5, 5);
rect (xpos2, ypos2, 15, 15);
}

cedrickie..

Re: Re: Locating the brightest spot on webcam

2 years ago

yes, the code only works for one spot. thats true...

zshahab2

Re: Locating the brightest spot on webcam

2 years ago

I was thinking of attacking this using the method used to blur pictures. For loops within for loops. I just can't get the syntax right. I think my code might make it easier to see what I mean. I'm also looking into the blobs like clankill3r said. I downloaded the package and placed it where it belongs, but I still don't seem to have the package in processing...

import processing.video.*;
Capture video;
lightPoint point1;
lightPoint point2;
int DATA_SIZE = 120;
float theta1;
float theta2;
float[] angle1 = new float[DATA_SIZE];
float[] angle2 = new float[DATA_SIZE];
void setup() {
size(1280, 480);
video = new Capture(this, 640, 480, 30);
smooth();
frameRate(28);
//noiseDetail(2);
//noiseSeed(System.currentTimeMillis());
//Create a light point to visualise from the class lightPoint
point1 = new lightPoint(0.0, 0.0, 0);
point2 = new lightPoint(0.0, 0.0, 0);
}
void draw() {
if (video.available()) {
video.read();
background(255);
fill(#005599);
image(video, 0, 0, 640, 480); // Draw the webcam video onto the screen
fill(100,0,0);
text(angle1[DATA_SIZE-1]*180/3.14159, 660, 20);
fill(0,100,0);
text(angle2[DATA_SIZE-1]*180/3.14159, 660, 40);
int brightestX = 0; // X-coordinate of the brightest video pixel
int brightestY = 0; // Y-coordinate of the brightest video pixel
float brightestValue = 0; // Brightness of the brightest video pixel
int nextbrightestX = 0 ; // all values to help track the 2nd brightest points in the area.
int nextbrightestY = 0 ;
float nextbrightestValue = 0 ;
// Search for the brightest 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;
int radius = 100 ;// closest placement of 2 different brightest spots.
float v = 1.0/9.0;
float [][] kernel = { { v, v, v },
{ v, v, v },
{ v, v, v } };
for (int y = 1; y < video.height-1; y++) {
for (int x = 1; x < video.width-1; x++) {
float sum = 0;
for (int ky = 01; ky <=1; ky++) {
for (int kx = -1; kx <= 1; kx++) {
//Calculate the adjacent pixel fo rthis kernel point
int pos = (y+ky)*video.width + (x + kx);
float val = brightness(video.pixels[pos]);
sum += kernel[ky+1][kx+1] * val;
}
// Get the color stored in the pixel
int pixelValue = video.pixels[index];
// Determine the brightness of the pixel
float pixelBrightness = brightness(pixelValue);
// If that value is brighter than any previous, then store the
// brightness of that pixel, as well as its (x,y) location
if ((pixelBrightness > brightestValue) && (distance(x, brightestX, y, brightestY) > radius))
{
brightestValue = pixelBrightness;
brightestY = y;
brightestX = x;
point1.x = brightestX;
point1.y = brightestY;
}
else if ((pixelBrightness > nextbrightestValue) && (distance(x, brightestX, y, brightestY) > radius))
{
nextbrightestValue = pixelBrightness;
nextbrightestY = y;
nextbrightestX = x;
point2.x = nextbrightestX;
point2.y = nextbrightestY;
}
}
index++;
}
}
fill(100,0,0);
ellipse(320, 300, 17, 17);
fill(0,100,0);
ellipse(320, 400, 17, 17);
theta1=abs( atan( (point1.x-320) / (point1.y-300) ));
theta2=abs( atan( (point2.x-320) / (point2.y-400) ));
// Display the lightPoint objects
fill(100,0,0);
point1.display();
fill(0,100,0);
point2.display();
for (int i = 1; i < DATA_SIZE; i++)
{
stroke(100,0,0);
line((i * 5) + 640, (float)((angle1[i - 1]*100))+200, (i + 1) * 5 + 640, (float)(angle1[i]*100)+200);
angle1[i - 1] = angle1[i];
stroke(0,100,0);
line((i * 5) + 640, (float)(angle2[i - 1]*100)+200, (i + 1) * 5 + 640, (float)(angle2[i]*100)+200);
angle2[i - 1] = angle2[i];
println(i) ;
}
angle1[DATA_SIZE - 1] = theta1;
angle2[DATA_SIZE - 1] = theta2;
}
}
float[] values = new float[width];
float distance(int xval, int xvalo, int yval, int yvalo)
{
return (sqrt ( ((float)(xval) - (float)(xvalo))*((float)(xval) - (float)(xvalo)) + ((float)(yval) - (float)(yvalo))* ((float)(yval) - (float)(yvalo)) ) ) ;
}
class lightPoint {
float x = 0.0; // X-coordinate of the brightest video pixel
float y = 0.0; // Y-coordinate of the brightest video pixel
// float brightestValue = 0; // Brightness of the brightest video pixel
boolean selected = false;
int index;
lightPoint(float xpos, float ypos, int num) {
x = xpos;
y = ypos;
index = num;
selected = false;
}
void display() {
//fill(204,102,0);
ellipse(x, y, 17, 17);
}
}
class lightPoint {
float x = 0.0; // X-coordinate of the brightest video pixel
float y = 0.0; // Y-coordinate of the brightest video pixel
// float brightestValue = 0; // Brightness of the brightest video pixel
boolean selected = false;
int index;
lightPoint(float xpos, float ypos, int num) {
x = xpos;
y = ypos;
index = num;
selected = false;
}
void display() {
//fill(204,102,0);
ellipse(x, y, 17, 17);
}
}

Jesse Sco..

Re: Re: Locating the brightest spot on webcam

2 years ago

You mean you can't get the Library to recognize?

Have you looked at this page: http://wiki.processing.org/w/How_to_Install_a_Contributed_Library ??

Have you restarted Processing ?

zshahab2

Re: Locating the brightest spot on webcam

2 years ago

I got the library to recognize, but it's not working. Blobs are too hard to recognize and it just can't follow a pendulum that is moving pretty fast. I'm convinced that it has to be done using the brightest pixel (or group of), I just can't write a program that is able to follow two different bright points. Here's an updated version of code trying to detect the brightest square of 9 pixels. It works a bit better searching for just one pixel. I tried increasing the size of the box being searched by changing my for loop parameters but I got an ArrayIndexOutOfBoundsException: -641. Don't know how to resolve that in this case.. I tried increasing the size of the array but no luck!

import processing.video.*;
Capture video;
lightPoint point1;
lightPoint point2;
int DATA_SIZE = 120;
float theta1;
float theta2;
float[] angle1 = new float[DATA_SIZE];
float[] angle2 = new float[DATA_SIZE];
void setup() {
size(1280, 480);
video = new Capture(this, 640, 480, 30);
smooth();
frameRate(28);
//noiseDetail(2);
//noiseSeed(System.currentTimeMillis());
//Create a light point to visualise from the class lightPoint
point1 = new lightPoint(0.0, 0.0, 0);
point2 = new lightPoint(0.0, 0.0, 0);
}
void draw() {
if (video.available()) {
video.read();
background(255);
fill(#005599);
image(video, 0, 0, 640, 480); // Draw the webcam video onto the screen
fill(100,0,0);
text(angle1[DATA_SIZE-1]*180/3.14159, 660, 20);
fill(0,100,0);
text(angle2[DATA_SIZE-1]*180/3.14159, 660, 40);
int brightestX = 0; // X-coordinate of the brightest video pixel
int brightestY = 0; // Y-coordinate of the brightest video pixel
float brightestValue = 0; // Brightness of the brightest video pixel
int nextbrightestX = 0 ; // all values to help track the 2nd brightest points in the area.
int nextbrightestY = 0 ;
float nextbrightestValue = 0 ;
// Search for the brightest 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;
int radius = 100 ;// closest placement of 2 different brightest spots.
float v = 1.0/9.0;
float [][] kernel = { { v, v, v },
{ v, v, v },
{ v, v, v } }; //added two more rows and 2 more columns to cover more area
for (int y = 1; y < video.height-1; y++) {
for (int x = 1; x < video.width-1; x++) {
float sum = 0;
for (int ky = -1; ky <=1; ky++) { // i changed the -1 to -2 and the 1 to 2 in order to increase the size
for (int kx = -1; kx <= 1; kx++) { // same as above
//Calculate the adjacent pixel for this kernel point
int pos = (y+ky)*video.width + (x + kx);
float val = brightness(video.pixels[pos]);
sum += kernel[ky+1][kx+1] * val;
if ((sum > brightestValue) && (distance(x, brightestX, y, brightestY) > radius)) {
brightestValue = sum;
brightestY = y;
brightestX = x;
point1.x = brightestX;
point1.y = brightestY;
}
else if ((sum > nextbrightestValue) && (distance(x, brightestX, y, brightestY) > radius)) {
nextbrightestValue = sum;
nextbrightestY = y;
nextbrightestX = x;
point2.x = nextbrightestX;
point2.y = nextbrightestY;
}
}
index++;
}
}
}
fill(100,0,0);
ellipse(320, 300, 17, 17);
fill(0,100,0);
ellipse(320, 400, 17, 17);
theta1=abs( atan( (point1.x-320) / (point1.y-300) ));
theta2=abs( atan( (point2.x-320) / (point2.y-400) ));
// Display the lightPoint objects
fill(100,0,0);
point1.display();
fill(0,100,0);
point2.display();
for (int i = 1; i < DATA_SIZE; i++)
{
stroke(100,0,0);
line((i * 5) + 640, (float)((angle1[i - 1]*100))+200, (i + 1) * 5 + 640, (float)(angle1[i]*100)+200);
angle1[i - 1] = angle1[i];
stroke(0,100,0);
line((i * 5) + 640, (float)(angle2[i - 1]*100)+200, (i + 1) * 5 + 640, (float)(angle2[i]*100)+200);
angle2[i - 1] = angle2[i];
println(i) ;
}
angle1[DATA_SIZE - 1] = theta1;
angle2[DATA_SIZE - 1] = theta2;
}
}
float[] values = new float[width];
float distance(int xval, int xvalo, int yval, int yvalo)
{
return (sqrt ( ((float)(xval) - (float)(xvalo))*((float)(xval) - (float)(xvalo)) + ((float)(yval) - (float)(yvalo))* ((float)(yval) - (float)(yvalo)) ) ) ;
}
class lightPoint {
float x = 0.0; // X-coordinate of the brightest video pixel
float y = 0.0; // Y-coordinate of the brightest video pixel
// float brightestValue = 0; // Brightness of the brightest video pixel
boolean selected = false;
int index;
lightPoint(float xpos, float ypos, int num) {
x = xpos;
y = ypos;
index = num;
selected = false;
}
void display() {
//fill(204,102,0);
ellipse(x, y, 17, 17);
}
}

Top Reply