Processing Forum

Screen name:
robarelli

robarelli's Profile

5 Posts

2 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

Running more than 2 webcams simultaneously

[0 Replies]
- 30-Aug-2012 05:22 PM
- Forum: Core Library Questions
in Processing 2.0+ is there a limit to the number of webcams you can run at the same time? I have 4 webcams that I am switching between, however when I try to start them, only a max of 2 light up.
1. import processing.video.*;
  
  Capture[] cams;
  int selectedIndex;
  int timer;
  
  void setup(){
  size(500, 500);
  println(Capture.list());
  
  int totalCams = Capture.list().length;
  cams = new Capture[totalCams];
  for(int i = 0; i < cams.length; i++){
      cams[i] = new Capture(this, 640, 480, Capture.list()[i], 30);
      cams[i].start();
  }
  selectedIndex = 0;
  timer = millis();
  }
  
  void draw(){
  int time = millis() - timer;
  if(time > 5000){
      updateIndex();
  }
  if(cams[selectedIndex].available() == true){
      cams[selectedIndex].read();
      image(cams[selectedIndex], 0, 0);
  }
  }
  
  void updateIndex(){
  selectedIndex++;
  if(selectedIndex > cams.length - 1)
      selectedIndex = 0;
  timer = millis();
  }
I know that I could stop the current cam and then start the next cam, but it will lag a big before the next cam shows up. So my idea was to have them all running and then I can switch to them without any switching delay. Is there a limit to the number of simultaneous cameras playing at once? If so, is there a better way to approach switching between multiple webcams seamlessly?

Memory leak getting buffer image with OpenGL in Processing 2.0+?

[2 Replies]
- 30-Aug-2012 03:04 PM
- Forum: Core Library Questions
I have came across an issue trying to draw to a buffer and then immediately grabbing its image and displaying it. However when I get the PImage of the buffer, the framerate and computer resources gradually decrease until my computer essentially becomes unusable. I am on OSX Snow Leopard, here is my code:
1. PGraphics pg;
  PImage pgImg;
  
  int w = 500;
  int h = 500;
  
  void setup(){
  size(w, h, OPENGL);
  pg = createGraphics(w, h);
  }
  
  void draw(){
  // drawing in the buffer doesnt need to be done
  // the issue is still evident without it
  pg.beginDraw();
  pg.fill(255, 0, 0);
  pg.rect(0, 0, w, h);
  pg.endDraw();
2. // Issue only happens when the image is grabbed from pg
  pgImg = pg.get(0, 0, pg.width, pg.height);
  
  image(pgImg, 0, 0);
  println(frameRate);
  }
If I draw the the buffer pg directly instead of grabbing its PImage, then it works fine. However the reason why I need to grab the PImage instead of drawing the buffer directly into image() is because I need to apply an alpha mask to it before its displayed (I left that out to isolate the issue). It also works fine when I remove OpenGL, however OpenGL is required for my project. Is this an ongoing issue with Processing 2.0+ or is there a way I can achieve this without it leaking?

Wrong device resolutions listed in Capture class?

[1 Reply]
- 21-Aug-2012 12:32 AM
- Forum: Core Library Questions
I am using Processing 2.0 on mac and am trying to run a HD webcam (Logitech c910, 1080p capable) with the Capture class. However it looks like it is taking the max resolution from the built in iSight camera since it won't let me instantiate the external webcam with a resolution greater than 640x480. My code is:
1. import processing.video.*;
  
  Capture cap;
  
  void setup(){
  size(1920, 1080);
  cap = new Capture(this, 1920, 1080, "Logitech HD Webcam C910", 30);
  cap.start();
  }
  
  void draw(){
  if(cap.available() == true){
  cap.read();
  image(cap, 0, 0);
  }
  }
2. /* Throws the following error:
3. Exception in thread "Animation Thread" java.lang.RuntimeException: The requested resolution of 1920x1080, 30/1fps is not supported by the selected capture device.
  Use one of the following resolutions instead:
  640x480, 5.00 fps (5/1)...
4. */
I am assuming its because of the built in iSight camera since its max recording resolution is 640x480, otherwise it could be a processing issue? Is there any way to go about solving this?

Thanks in advance!

Using Capture with Processing 2.0+ issues on Mac

[1 Reply]
- 17-Aug-2012 10:28 AM
- Forum: Core Library Questions
I am trying to use a webcam with Processing 2.0 using the Capture example provided on the website ( http://processing.org/reference/libraries/video/Capture.html), however it just returns a black image. I can even remove my webcams and it still won't even work with the built in iSight camera. There are no errors that can help me on the right path as to whats happening. However it does work using Processing 1.5.1 with the same code. I am on a Mac 64-bit Snow Leopard and have tried all 2.0 alpha versions. Any ideas on whats going on?

Example code I used from the website is below:
1. ```
import processing.video.*;
Capture myCapture;

void setup() 
{
  size(200, 200);
  myCapture = new Capture(this, width, height, 30);
}

void captureEvent(Capture myCapture) {
  myCapture.read();
}

void draw() {
  image(myCapture, 0, 0);
}
```

Pixel scanning of a moving arc

[1 Reply]
- 09-Jan-2012 01:12 AM
- Forum: Programming Questions
I am trying to build a kaleidoscope where a use can drag shapes into a circle canvas and whatever is in that canvas will be translated into the kaleidoscope output. An arc in the canvas will rotate and scan a 45 degree fragment of the canvas which will be used for the output. However I am stumped on an efficient algorithm to scan all the pixels in the arc without any slowdown. Does anyone have any input on how to scan the pixels in an arc area and translate them to another area without much slowdown?

Canvas canvas;

Palette palette;

Kaleidoscope kaleidoscope;

void setup(){

size(1240, 768, P2D);

//smooth();



canvas = new Canvas();

kaleidoscope = new Kaleidoscope();

palette = new Palette();

}

void draw(){

background(0);



canvas.display();

palette.display();

kaleidoscope.display();

}

///////////////////////////////////////////////////////////////////////////////////////////////

// Kaleidoscope - displays the translated mapping

///////////////////////////////////////////////////////////////////////////////////////////////

class Kaleidoscope extends Wedge {



float kDiameter = 500;

PVector location = new PVector(800, height/2);;

ArrayList slices = new ArrayList();

float angle;



Kaleidoscope(){



// construct the slices

for(int i = 0; i < 8; i++){

angle += radians(45);

}

}



void display(){

//fill(0,0,255);

noFill();

stroke(255);

ellipse(location.x, location.y, kDiameter, kDiameter);



// Display the mapped wedge

// experimental: just used to show that the pixel map can be transferred

// to a different location

if(canvas.wedge.wedgeMap.size() > 0){

int count = 0;

for(int i = 0; i < int(canvas.cDiameter/2); i++){

float j = canvas.wedge.leftAngle;

PVector lastP = new PVector(0,0);

while(j < canvas.wedge.rightAngle){

PVector p = new PVector(location.x+(i*cos(j)), location.y+(i*sin(j)));

int k = (int)(p.y*width+p.x);



fill((Integer)canvas.wedge.wedgeMap.get(count));

stroke((Integer)canvas.wedge.wedgeMap.get(count));

point(p.x, p.y);

endShape();



count++;

j += 0.01;

}

}

}

}

}

///////////////////////////////////////////////////////////////////////////////////////////////

// Wedge - the scanning arc

///////////////////////////////////////////////////////////////////////////////////////////////

class Wedge {



float leftAngle;

float rightAngle;

ArrayList<Integer> wedgeMap = new ArrayList<Integer>();



Wedge(){

leftAngle = 0;

rightAngle = PI/4;

}



void display(){

fill(255, 255, 0);

arc(canvas.location.x, canvas.location.y, canvas.cDiameter, canvas.cDiameter, leftAngle, rightAngle);

}



void scan(){

wedgeMap.clear();

int cRadius = (int)canvas.cDiameter/2;

PVector c = canvas.location;

// Begin live mapping

loadPixels();

for(int i = 0; i < cRadius; i++){

float j = leftAngle;

while(j < rightAngle){

PVector p = new PVector(c.x+(i*cos(j)), c.y+(i*sin(j)));

int k = (int)(p.y*width+p.x);

wedgeMap.add(pixels[k]);



j += 0.01;

}

}

updatePixels();

rotateWedge(0.01);

}



void rotateWedge(float rate){

rightAngle += rate;

leftAngle += rate;

}

}

///////////////////////////////////////////////////////////////////////////////////////////////

// Fruit - the things being used to drag into the canvas

///////////////////////////////////////////////////////////////////////////////////////////////

class Fruit {



HashMap fruits = new HashMap<String, PImage>();

PImage img;

PVector location;

float scaling;

boolean isSelected = false;



Fruit(String type, PVector location, float scaling){

fruits.put("apple", loadImage("processing.png"));

fruits.put("orange", loadImage("processing.png"));

img = (PImage) fruits.get(type);

this.location = location;

this.scaling = scaling;

}



Fruit(){

fruits.put("apple", loadImage("processing.png"));

fruits.put("orange", loadImage("processing.png"));

}



void display(){

pushMatrix();

if(isSelected) location = new PVector(mouseX, mouseY);

translate(location.x, location.y);

scale(scaling);

image(img, -img.width/2, -img.height/2);

popMatrix();

}

}

///////////////////////////////////////////////////////////////////////////////////////////////

// Canvas - where items will be dragged into and where the wedge scans

///////////////////////////////////////////////////////////////////////////////////////////////

class Canvas {



Wedge wedge = new Wedge();

PVector location = new PVector(250, height/2);

float cDiameter = 500;

HashMap<PVector, Integer> pixelMap = new HashMap<PVector, Integer>();



Canvas(){



}



void display(){

pushMatrix();

fill(255);

rect(300,500,50,50);

popMatrix();

fill(255, 0,0);

stroke(255, 0, 0);

ellipse(location.x, location.y, cDiameter, cDiameter);

//scan first so it doesnt pick up the display overlay color

wedge.scan();

wedge.display();

}



// Maps the entire canvas

void mapCanvas(){

float sqRadius=sq(cDiameter/2);

for(int x=-floor((cDiameter/2f)+location.x);x<=ceil((cDiameter/2f)+location.x);x++){

for(int y=-floor((cDiameter/2f)+location.x);y<=ceil((cDiameter/2f)+location.x);y++){

if(sq(x)+sq(y) <= sqRadius){

pixelMap.put(new PVector(x+location.x, y+location.y), get(round(x+location.x), round(y+location.y)));

}

}

}

}



}

///////////////////////////////////////////////////////////////////////////////////////////////

// Palette

///////////////////////////////////////////////////////////////////////////////////////////////

class Palette {



ArrayList<Fruit> fruits = new ArrayList<Fruit>();



Palette(){

fruits.add(new Fruit("apple", new PVector(150, 150), 0.5));

}



void display(){

((Fruit)fruits.get(0)).display();

}

}

///////////////////////////////////////////////////////////////////////////////////////////////

// Mouse Functions

///////////////////////////////////////////////////////////////////////////////////////////////

void mouseDragged() {



// Determine if the user has touched something in the palette

for(Fruit fruit : palette.fruits){

if(mouseX > fruit.location.x && mouseX < fruit.location.x + fruit.img.width &&

mouseY > fruit.location.y && mouseY < fruit.location.y + fruit.img.height){

fruit.isSelected = true;

}

}



}

void mouseReleased() {

for(Fruit fruit : palette.fruits){

fruit.isSelected = false;

}

//canvas.mapCanvas();

//canvas.wedge.scan();

}

Thanks in advance for any help :)

«Prev
Next »