I'm desperately and unsuccessfully trying to compute Delaunay triangulation from a 3D point cloud. It's a thing that many people have been trying to tackle for years (the same question has been asked over a dozen times on this forum: here, here, also here, here again...) but that has never found a proper solution.

To the best of my knowledge, there are 4 libraries capable of computing Delaunay triangulation:

• Mesh by Lee Byron
• iGeo by Satoru Sugihara
• Hemesh (WBlut)
• Toxiclibs by Karsten Schmidt

However:

• Mesh only works in 2 dimensions (+ is flawed)
• iGeo has not been ported yet to Processing 3
• Voronoi & DelaunayTriangulation classes from Toxiclibs do not support 3D

It seems therefore the only solution lies in the Hemesh library.

GOAL

I would like to transform the colors of a painting into a 3D mesh via Delaunay triangulation. It's a relatively widespread technique that media artist Quayola (among others) has been brilliantly using for years.

PROBLEMS (hard to explain in english)

• Instead of displaying a single 3D terrain (like in the pictures above) from a cloud of 3D points, the Hemesh library seems to compute multiple polyhedrons (like diamonds with cavities).
• There is a threshold (triangulation.getAlphaTriangles(threshold)) to limit the amount of surrounding points to connect to, but that very threshold prevents from connecting to neighboring points that are far.

As a result, this painting from John William Waterhouse:

(some dude getting hit on at a pool party)

is tranformed to this:

(all the shapes are "closed" (P3 connected to P1) but it shouldn't be that way)

With a higher threshold:

(Between two layers of polyhedrons)

QUESTIONS

• How can I avoid this behavior (if possible) ?
• Do you know another library that could compute Delaunay triangulations in 3D space ?
• Is there another way to achieve what I'm trying to do here (3D terrain from point cloud) ?

Important parts of the code (it's in Python but PLEASE DO NOT MOVE THIS QUESTION TO PYTHON MODE):

setup()

threshold = 35
render = WB_Render(this)
for p in points:
        new_points = WB_Point(p.x, p.y, p.z)
        list.append(new_points)
triangulation = WB_Triangulate.alphaTriangulate3D(list)
triangles = triangulation.getAlphaTriangles(threshold)

draw()

noStroke()
for i in range(0, len(triangles), 3):
    render.drawTriangle(liste[triangles[i]], liste[triangles[i+1]], liste[triangles[i+2]])

Thank you

import processing.sound.*;

// Declare the processing sound variables 
SoundFile sample;
Amplitude rms;

// Declare a scaling factor
float scale=1;

// Declare a smooth factor
float smooth_factor=0.25;

// Used for smoothing
float sum;

PImage img;       // The source image
int cellsize = 2; // Dimensions of each cell in the grid
int columns, rows;   // Number of columns and rows in our system

public void setup() {
  size(800, 1000, P3D); 
  //fullScreen(P3D);
  img = loadImage("...");  // Load the image
  columns = img.width / cellsize;  // Calculate # of columns
  rows = img.height / cellsize;  // Calculate # of rows

    //Load and play a soundfile and loop it
    sample = new SoundFile(this, "...");
    sample.loop();

    // Create and patch the rms tracker
    rms = new Amplitude(this);
    rms.input(sample);

}

void draw() {
  background(255,0,255);
  // Begin loop for columns
  for ( int i = 0; i < columns; i++) {
    // Begin loop for rows
    for ( int j = 0; j < rows; j++) {
      int x = i*cellsize + cellsize/2;  // x position
      int y = j*cellsize + cellsize/2;  // y position
      int loc = x + y*img.width;  // Pixel array location
      color c = img.pixels[loc];  // Grab the color
      // Calculate a z position as a function of mouseX and pixel brightness
      //float z = width/2 * brightness(img.pixels[loc]) - 20.0;
        float rms_scaled=sum*width/10 * brightness(img.pixels[loc]) - 20.0;

     // smooth the rms data by smoothing factor
    sum += (rms.analyze() - sum) * smooth_factor;  

    // rms.analyze() return a value between 0 and 1. It's
    // scaled to height/2 and then multiplied by a scale factor


      // Translate to the location, set fill and stroke, and draw the rect
      pushMatrix();
      //translate(x + 300, y + 250, rms_scaled);
      translate(x + 200, y + 200, rms_scaled);
      fill(c, 204);
      noStroke();
      rectMode(CENTER);
      rect(0, 0, cellsize, cellsize);
      popMatrix();
    }
  }
}

/** * Brightness Tracking * by Golan Levin. * * Tracks the brightest pixel in a live video signal. */

PImage bg;
int y;
import processing.video.*;

Capture video;

void setup() {
  size(640, 480);
  video = new Capture(this, width, height);
  video.start();  
  bg = loadImage("02.jpg");
  noStroke();
  smooth();
}

void draw() {

  if (video.available()) {
    video.read();
    background(bg);
    image(video, 0, 0, 20, 20); 
    int brightestX = 0; 
    int brightestY = 0; 
    float brightestValue = 0;
    video.loadPixels();
    int index = 0;
    for (int y = 0; y < video.height; y++) {
      for (int x = 0; x < video.width; x++) {
        int pixelValue = video.pixels[index];
        float pixelBrightness = brightness(pixelValue);

        if (pixelBrightness > brightestValue) {
          brightestValue = pixelBrightness;
          brightestY = y;
          brightestX = x;
        }
        index++;
      }

    }
    fill(255, 204, 0, 80);
    ellipse(brightestX, brightestY, 250, 250);

  }
}

http://cpetry.github.io/NormalMap-Online/

I man, I don't know how that is called, 3D texture? How can I obtain something like this? Even a simple example :)

Any reference or link will be appreciated, thank you

I have my first processing sketch running with no errors but I cannot get an image from the webcam.

import hypermedia.video.*;
import java.awt.Rectangle;

OpenCV opencv;

// contrast/brightness values
int contrast_value    = 0;
int brightness_value  = 0;



void setup() {

    size( 320, 240 );

    opencv = new OpenCV( this );
    opencv.capture( width, height );                   // open video stream
    opencv.cascade( OpenCV.CASCADE_FRONTALFACE_ALT );  // load detection description, here-> front face detection : "haarcascade_frontalface_alt.xml"


    // print usage
    println( "Drag mouse on X-axis inside this sketch window to change contrast" );
    println( "Drag mouse on Y-axis inside this sketch window to change brightness" );

}


public void stop() {
    opencv.stop();
    super.stop();
}



void draw() {

    // grab a new frame
    // and convert to gray
    opencv.read();
    opencv.convert( GRAY );
    opencv.contrast( contrast_value );
    opencv.brightness( brightness_value );

    // proceed detection
    Rectangle[] faces = opencv.detect( 1.2, 2, OpenCV.HAAR_DO_CANNY_PRUNING, 40, 40 );

    // display the image
    image( opencv.image(), 0, 0 );

    // draw face area(s)
    noFill();
    stroke(255,0,0);
    for( int i=0; i<faces.length; i++ ) {
        rect( faces[i].x, faces[i].y, faces[i].width, faces[i].height ); 
    }
}



/**
 * Changes contrast/brigthness values
 */
void mouseDragged() {
    contrast_value   = (int) map( mouseX, 0, width, -128, 128 );
    brightness_value = (int) map( mouseY, 0, width, -128, 128 );
}

The programme is supposed to display an image, detect a face and draw a rectangle around the face. I am using windows 7 with a USB webcam. I have tried a couple of versions of processing and both are the same.

Any ideas of where to look first?

Thanks Paul

I'm trying to create an effect like the image above which I have done by crudely exporting a frame then loading it and blending it - which isn't very memory/processor efficient. I'm wanting to know what the best way producing this effect would be with the pixel array. ie - how to store the pixels[] of a single frame.

thanks.

import processing.video.*;


PImage test, test2;
float FPS;
int count;
int mod;
int rand;


Capture video;

void setup() {
  size(640, 420, P2D);
  video = new Capture(this, 640, 360, 30);
  video.start();

}

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

void draw() {
  FPS = frameRate;
  count = ceil(millis()/1000);
  mod = count % 5;

  background(245, 238, 96);

  image(video, 0, 0, 640, 420);

  loadPixels();
  for (int i = 0; i < pixels.length; i++) {

    float b = brightness(pixels[i]);
    if (b > 97) {
      pixels[i] = color (255);
    } else {
      pixels[i] = color (245, 238, 96);
    }
  }

  updatePixels();
  textSize(16);
  fill(0);
  text(FPS, 50, 50);
  text(count, 50, 75);
  text(mod, 50, 100);
  text(mouseX, 50, 125);


}

color bg;


colorMode(RGB, 255, 255, 255); //default
bg = color( 0, 169, 255 );
background(bg);
println(hue(bg) +", "+ saturation(bg) +", "+ brightness(bg)); //outputs 141.83333, 255.0, 255.0
println(red(bg) +", "+ green(bg) +", "+ blue(bg)); //outputs 0.0, 169.0, 255.0


colorMode(HSB, 360, 100, 100);
bg = color( 200, 100, 100 );
background(bg);
println(hue(bg) +", "+ saturation(bg) +", "+ brightness(bg)); //outputs 200.23529, 100.0, 100.0
println(red(bg) +", "+ green(bg) +", "+ blue(bg)); //outputs 0.0, 66.27451, 100.0

It can be boiled down to:

colorMode(HSB, _anything_, 100, 100);
println(hue(color(200, 100, 100))); //outputs 200.23529

According to my colour picker, (R0, G169, B255) = (H200, S100, B100), so why don't they output the same values?

I'm manipulating the hue of various colours and am finding this inaccuracy, er, challenging.

☺

I've been reading through every 'convert Processing into P5' document I can get a hold of, and I still can't figure out how to translate PVector's (processing) into p5.vector syntax.

Beneath is code in Processing (working). Beneath that is my code for p5 (not working) I'm pretty sure it's my Vector syntax that is out of wack. Can someone please provide direction? Saying that, there might be other things wrong, and I'm open to suggestions.

PROCESSING:

PImage img;
ArrayList pts;


void setup() {
  img = loadImage("ASKEW A.jpg");

    size(500, 500, P3D);

  pts = new ArrayList();
  findPoints();
}

void draw () {
  background(255);


for (int i = pts.size()-1; i >= 0; i --){
      PVector pt = (PVector)pts.get(i);

      fill(pt.z);

      noStroke();

      stroke(0, 30);
      for (int j = pts.size()-1; j >= 0; j --){
      if(i>1){  
        PVector pt2 = (PVector)pts.get(j);
        if (pt.dist(pt2) < 20){

          int r = 10;
          float x = r * tan(radians(i*(360.0/ (mouseX * tan(3)) )));
          float y = r * sin(radians(i*(360.0/ (mouseY*  tan(3)) )));

          int r1 = 2;
          float x1 = r1 * tan(radians(i*(360.0 / (mouseX* tan(3)))));
          float y1 = r1 * sin(radians(i*(360.0 / (mouseY* tan(3)))));


          stroke(0, 30);
          line(pt.x + x, pt.y + y, 
          pt2.x + x1, pt2.y + y1);
        }
      }
    }
  }
}

void findPoints(){

  img.loadPixels();
  for (int i = img.width-1; i >= 0; i -= 3){
    for (int j = img.height; j >=0; j -= 3){

      color c = img.get(i, j);
      if (brightness(c) < 255){
        pts.add(new PVector(i, j, brightness(c)));
      }
    }
  }
}

p5 :

var img;
var pts = [];
var i, j;


function setup() {

  createCanvas(500, 500);

    img = loadImage("ASKEW A.jpg");
    findPoints();
    }


function draw () {
  background(255);

for (i = pts.length()-1; i >= 0; i --){
      var pt = new p5.Vector.pts.get(i);
      fill(pt.z);

      noStroke();

      stroke(0, 30);
      for (j = pts.length()-1; j >= 0; j --){
      if(i>1){  
        var pt2 = new p5.Vector.pts.get(j);
        if (pt.dist(pt2) < 20){

          var r = 20;
          var x = r * tan(radians(i*(360.0/ (mouseX) )));
          var y = r * sin(radians(i*(360.0/ (mouseY) )));

          var r1 = 2;
          var x1 = r1 * tan(radians(i*(360.0 / (mouseX))));
          var y1 = r1 * sin(radians(i*(360.0 / (mouseY))));


          stroke(0, 30);
          line(pt.x + x, pt.y, 
          pt2.x + x1, pt2.y + y1);
        }
      }
    }
  }
}


function findPoints(){

  img.loadPixels();
  for (var i = img.width-1; i >= 0; i -= 3){
    for (var j = img.height; j >=0; j -= 3){

      var c = img.get(i, j);
      if (brightness(c) < 255){
        pts.push(new p5.Vector(i, j, brightness(c)));
      }
    }
  }
}

import processing.video.*;//importa la biblioteca de video

Capture cam1;
Capture cam2;
//Capture cam3;para agregar mas camaras

void setup() {
  size(640, 480);

  String[] cameras = Capture.list();
  //if de seguridad
  if (cameras.length == 0) {
    println("There are no cameras available for capture.");
    exit();
  } else {
    println("Available cameras:");
  }
  for (int i = 0; i < cameras.length; i++) {
    println(cameras[i]);
  }

  // The camera can be initialized directly using an 
  // element from the array returned by list():
  cam1 = new Capture(this, cameras[14]);
  cam2 = new Capture(this, cameras[1]);
//metodo para comenzar las camaras
  cam1.start();
  cam2.start();
//carga de pixeles y pixeles de las camaras
  loadPixels();
  cam1.loadPixels();
  cam2.loadPixels();
}

void draw() {
  if (cam1.available() == true) {
    cam1.read();
  }

  if (cam2.available() == true) {
    cam2.read();
  }
//recorrer los pixeles de las camaras
  for (int y = 0; y<height; y++)
    {
      for (int x = 0; x<width; x++)
      {        
        int loc = x+y*width;
      //color pixelactual = pixels[loc];
      float treshold = mouseX;

      color fondo = color(0,0,0);

      float bright1 = brightness(cam1.pixels[loc]);
      float bright2 = brightness(cam2.pixels[loc]);

      if(bright1>treshold)
      {
        pixels[loc]=fondo;
      }
    }
  }
  updatePixels();
}

https://www.openprocessing.org/sketch/441474

into p5.js?

https://www.openprocessing.org/sketch/441671

Code :

import peasy.*;
import peasy.org.apache.commons.math.*;
import peasy.org.apache.commons.math.geometry.*;
PeasyCam camera;
PImage img;

void setup() {
  size(800, 800, P3D);
  ambientLight(255, 255, 255, 0, 0, 0);
  img = loadImage("download.jpg");
  camera = new PeasyCam(this, img.width/2, img.height/2, 0, 1000);
  img.loadPixels();
}
void draw() {
  background(0);
  for (int i=0; i<img.pixels.length; i++) {
    color c = img.pixels[i];
    float b = map(brightness(c), 0, 255, -100, 100);
    fill(c);
    noStroke();
    int x = i%(img.width);
    int y = (i-x)/img.width;
    translate(x, y, b);
    box(1);
    translate(-x, -y, -b);
  }
}

i want to generate objects (ellipse) on a typo of an Image (pic.png).

Sadly, the code doesnt work and the objects on the entire screen. Thanks for HELP!!!!
Heres the Code:

    ArrayList <PVector> circles = new ArrayList <PVector> ();
    float diameter;
    PImage typo;

    void setup() {
      background(255);
      size(500, 500);
      colorMode(RGB, 100, 100, 100);
      noStroke();
      smooth();
      typo = loadImage("pic.png");
    }

    void draw() {

      addCircle();
      for (int i=0; i<circles.size(); i++) {
        PVector p = circles.get(i);
        fill(i % 360, 100, 100);
        ellipse(p.x, p.y, p.z, p.z);
      }
    }

    void addCircle() {
      diameter=random(10, 40);
      PVector c = randomVector();
      int tries = 1000000;
      color pixel;

      pixel = typo.get((int)c.x, (int)c.y);

      while (overlap(c) && tries > 0) {
        c = randomVector();
        tries--;
      }

      if (!overlap(c) && brightness(pixel)>0) {
        circles.add(c);
      } else {
        addCircle();
      }
    }

    PVector randomVector() {
      return new PVector(random(width), random(height), diameter);
    }

    boolean overlap(PVector c) {
      for (PVector p : circles) {
        if ((dist(c.x, c.y, p.x, p.y) < (c.z + p.z)*0.5)) {
          return true;
        }
      }
      return false;
    }

I've followed the instructions in the histogram example but I get into trouble when I want to move the histogram to different coordinates, here's the script I've created in accordance with the histogram example that's on the processing page :

PImage object;

size(1000,500);

background(0);

object=loadImage("og.jpg");

image(object,0,0);

int [] hist = new int[256];

for (int i = 0; i< object.width; i++){

for (int j = 0; j< object.height; j++){

int bright = int (brightness(get(i,j)));

hist[bright]++;

}

}

int histMax = max(hist);

stroke(255);

for (int i = 0; i< object.width; i +=2){

int which = int(map(i,0, object.width,0,255));

int y = int (map(hist[which], 0, histMax,object.height,0));

line(i,object.height,i,y);

}

import processing.video.*;
import g4p_controls.*;
import java.awt.Font;
import gab.opencv.*;


OpenCV opencv;

PFont f;     

boolean filterT=false;


Capture cam;

GButton btnFilterT;

int n = 1;

void setup() {
  size(1024, 768); 

  f = createFont("Arial", 48, true);

  btnFilterT = new GButton(this, 740, 50, 140, 20);
  btnFilterT.setText("On");
  btnFilterT.setLocalColorScheme(GCScheme.GREEN_SCHEME);

  cam = new Capture(this, 640, 480);
  cam.start();
}


void draw() {

  if (cam.available() == true) {
    cam.read();
  }


  pushMatrix();
  scale(-1, 1);
  image(cam.get(), -width, 0, width, height);
  popMatrix();  

  opencv = new OpenCV(this, cam);
  opencv.loadImage(cam);


  if (filterT==true) {
    opencv.brightness((int)map(mouseX, 0, width, -255, 255));
    image(opencv.getOutput(),0, 0, width, height);
  }
}

public void handleButtonEvents(GButton button, GEvent event) {

  if (button == btnFilterT) {
    filterT=true;
  }
}

I have two problems:

if I press the T button to start the brightness and contrast in gray, the screen flips over and becomes no mirror.

how can I have brightness and contrast with the mirror video?

how can I have the brightness and contrast of the webcam color?

thank you

I'm trying to build a new image, capturing only part that interests me from another, I used this base to begin with: https://processing.org/tutorials/pixels/

I am in doubt as to the image below, the part where it seems "rainbow", would I use the function (hue), or (r, g, b) individually to capture?

And what about the circled part (very badly done, sorry) more in the middle, would have to use the function (brightness), since it is kind of "brightness" in the image?

Thanks any hint, below is the sample code, and the image as template.

Thank you,

    PImage source;       
    PImage destination;  
    float threshold = 0;

    void setup() {
      size(400, 300);
      source = loadImage("Img01.jpg"); 
      source.resize(400, 300); 
      destination = createImage(source.width, source.height, RGB);
    }

    void draw() {  
      //threshold = 127;
      threshold = 70;

      source.loadPixels();
      destination.loadPixels();

      for (int x = 0; x < source.width; x++) {
        for (int y = 0; y < source.height; y++ ) {
          int loc = x + y*source.width;
          if (brightness(source.pixels[loc]) > threshold) {
          //if (hue(source.pixels[loc]) > threshold) {
            //destination.pixels[loc]  = source.pixels[loc];  // White
            destination.pixels[loc]  = source.pixels[loc];
          }
        }
      }

      destination.updatePixels();
      image(destination,0,0);
      //image(source,0,0);
    }

    void keyPressed(){
      if (key == 'A' || key == 'a')
        threshold = threshold + 10;

      if (key == 'D' || key == 'd')
        threshold = threshold - 10;

      println(threshold);  
    }

    import processing.video.*;
    import java.awt.Frame;
    import java.awt.Image;
    import java.text.*;

    Capture cam;
    Letter[][] drops;
    int dropsLength;
    PImage prevFrame;
    int sWidth = 1280;
    int sHeight = 720;

    String inputString = "Įsivaizduokime pasaulį, kur visi viską žino tiksliai, ir niekada neklysta. Niekam nekiltų abejoių, koks bus rytoj oras, kaip išsaugoti tirpstačius ledynus, ar koks visatos dydis. Žvelgiant į krentantį kamuoliuką kiekvienas galėtų pasakyti: -  O šito kamuoliuko kritimo greitis 6,325 m/s. -  Tikrai taip - atsakytų kitas. Ir viskas, daugiau nebebūtų jokių diskusijų, ieškojimų, matavimų. Su absoliučiu žinojimu gyvenimas taptų nebeįdomus, monotoniškas, tokiu atveju net progresas neįmanomas. Kai pradedu taip galvoti, džiaugiuosi nežinojimu, diskusijų galimybe, tiesos ieškojimu. Klaida suvokiama kaip neišvengiamas procesas teisybės ieškojime leidžia drąsiai žengti į praktikos sritį, nebijoti suklysti, o neteisingus procesus paversti progresu, žingsneliu link tikslo. Menininkas nebėra tas genijus, kuris turi sukurti kažką naujo, tarsi nežemiško, keičiančio visą mūsų suvokimą. Jo praktikos esmė eksperimentuoti ir klysti, organizuoti jau esamomis reikšmėmis ir kurti nau";
    char[] inputLetters;
    int dupStrings = 3;   //times to dublicate text
    int k = 800;
    float threshold = 50;

    void settings() {
      size(1280, 720);
    }
    void setup() {
      String[] cameras = Capture.list();

      drops = new Letter[dupStrings][inputString.length()];  //[inputString.length()]; 

      int wspace = 50;
      inputLetters = new char[inputString.length()]; 
      splitString();


      // first row hight
      int addLineHeight = 30;                                                       
      for (int i = 0; i < dupStrings; i++) {     
            for (int j = 0; j < inputLetters.length; j++) {   
                 if  (inputLetters[j] < k + wspace ){
                   Letter testLetter = new Letter(inputLetters[j]);
                   testLetter.x = wspace;
                   testLetter.y = addLineHeight;
                   drops[i][j] = testLetter;
                   wspace += 10;   //spaces between letters

                   // new row
                   if (wspace >= sWidth) {   
                                wspace = 10;
                               addLineHeight += 40; } // space between 

                    }
                           else {
                               addLineHeight += 50;
                                }
                                                                  }
                                               }
    // cam conect//

      if (cameras.length == 0) {
        println("There are no cameras available...");
        size(400, 400);
        exit();
      }
      else {
        cam = new Capture(this, sWidth, sHeight);
        cam.start();
        cam.loadPixels();
        prevFrame = createImage(cam.width, cam.height, RGB);

        size(sWidth, sHeight);
      }
      dropsLength = inputString.length();
    }

    void captureEvent(Capture cam) {
      // Save previous frame for motion detection!!
      prevFrame.copy(cam, 0, 0, cam.width, cam.height, 0, 0, cam.width, cam.height); 
      // Before we read the new frame, we always save the previous frame for comparison!```
      prevFrame.updatePixels();  // Read image from the camera
      cam.read();
    }


    void splitString() { 

      for (int i = 0; i < inputString.length() ; i++) {
        inputLetters[i] = inputString.charAt(i);
      }
    }

    void draw() {

        loadPixels();
      cam.loadPixels();
      prevFrame.loadPixels();
        // Begin loop to walk through every pixel
      for (int x = 0; x < cam.width; x ++ ) {
        for (int y = 0; y < cam.height; y ++ ) {

          int loc = x + y*cam.width;            // Step 1, what is the 1D pixel location
          color current = cam.pixels[loc];      // Step 2, what is the current color
          color previous = prevFrame.pixels[loc]; // Step 3, what is the previous color

          // Step 4, compare colors (previous vs. current)
          float r1 = red(current); 
          float g1 = green(current); 
          float b1 = blue(current);
          float r2 = red(previous); 
          float g2 = green(previous); 
          float b2 = blue(previous);
          float diff = dist(r1, g1, b1, r2, g2, b2);

          // Step 5, How different are the colors?
          // If the color at that pixel has changed, then there is motion at that pixel.
          if (diff > threshold) { 
            // If motion, display black
            pixels[loc] = color(0);
          } else {
            // If not, display white
            pixels[loc] = color(255);
          }
        }
      }

       //Responding to the brightness/color of the screen
       for (int i = 0; i < dupStrings; i++) {
        for (int j = 0; j < dropsLength; j++) {

          if (drops[i][j].y < sHeight && drops[i][j].y > 0) {   
           int loc = drops[i][j].x + ((drops[i][j].y)-1)*sWidth;                                           
           float bright = brightness(cam.pixels[loc]);                                                                                                                                                          
            if (bright > threshold) {   
              drops[i][j].dropLetter();
              drops[i][j].upSpeed = 1;
            }
            else {                                                                            
              if (drops[i][j].y > threshold) {
                int aboveLoc = loc = drops[i][j].x + ((drops[i][j].y)-1)*sWidth;
                float aboveBright = brightness(cam.pixels[aboveLoc]);
                if (aboveBright < threshold) {                                              
                  drops[i][j].liftLetter();
                  drops[i][j].upSpeed = drops[i][j].upSpeed * 5;                           
                }
              }
            }
          }
          else {
            drops[i][j].dropLetter(); 
          }

          drops[i][j].drawLetter();
          cam.updatePixels();
        }
      }
    }

    class Letter {
      int x;
      int y; 
      int m;
      char textLetter;
      int upSpeed;
      int alpha = 150;
      Letter(char inputText) {
        x = 100;
        y = 100;
        textLetter = inputText;
        textSize(16);
        upSpeed = 1;
      }
      void drawLetter() {
       // if ( m < 1) {
        fill(150, 150, 150 , alpha);                 
        text(textLetter, x, y);

      }

      void letterFade() {
        alpha -= 5;
        if(alpha <= 0) {
          y = int(random(-350, 0));
          alpha = 255; 
        }
      }


      void dropLetter() {
      //  y++;                         
        if (y > 730) {
          letterFade();
        }
      }

      void liftLetter() {
        int newY = y - upSpeed;       
        if (newY >= 0) {
          y = newY;
        }
        else {
          y = 0;
        }
      }
    }

void setup()
{  
  size(1200, 500);
  RSlider = new Slider (150, 350, "R");
  GSlider = new Slider (150, 400, "G");
  BSlider = new Slider (150, 450, "B");
  HSlider = new Slider (450, 350, "H");
  SSlider = new Slider (450, 400, "S");
  VSlider = new Slider (450, 450, "V");

  RSlider.lock();
  GSlider.lock();
  BSlider.lock();
  HSlider.lock();
  SSlider.lock();
  VSlider.lock();
}

void draw()
{ 
  background (255);
  colorMode(RGB, 255);
  fill(0, 0, 0);
  rect(0, 300, width, height-300);
  RSlider.display();
  GSlider.display();
  BSlider.display();
  HSlider.display();
  SSlider.display();
  VSlider.display();
  if (mouseX>0&&mouseX<=150+180) {
    float rs = map(RSlider.x, RSlider.rctx, 180, 0, 255);  
    float bs = map(BSlider.x, BSlider.rctx, 180, 0, 255); 
    float gs = map(GSlider.x, GSlider.rctx, 180, 0, 255);
    fill(rs, gs, bs);
    rect(0, 0, width, height-200);
  }
  if (mouseX>330&&mouseX<width) {
    colorMode(HSB, 255);
    HSlider.x=(int)hue(filler);
    SSlider.x=(int)saturation(filler);
    VSlider.x=(int)brightness(filler);
    float hs = map(HSlider.x, HSlider.rctx, 180, 0, 255);  
    float ss = map(SSlider.x, SSlider.rctx, 180, 0, 255); 
    float vs = map(VSlider.x, VSlider.rctx, 180, 0, 255); 
    fill(hs, ss, vs);
    rect(0, 0, width, height-200);
  }
}

void mousePressed()
{
  RSlider.unlock();
  GSlider.unlock();
  BSlider.unlock();
  HSlider.unlock();
  SSlider.unlock();
  VSlider.unlock();
}
void mouseDragged()
{
  RSlider.drag();
  GSlider.drag();
  BSlider.drag();
  HSlider.drag();
  SSlider.drag();
  VSlider.drag();
}
void mouseReleased()
{
  RSlider.lock();
  GSlider.lock();
  BSlider.lock();
  HSlider.lock();
  SSlider.lock();
  VSlider.lock();
}
class Slider 
{ 
  //  Slider mySlider ; // ?????????????????????????????????????
  PFont f;
  float x, y, 
  w=180, h = 10, 
  rctx;
  String text;
  boolean locked ;

  Slider (int x, int y, String text  ) {
    rctx=x;
    this.x = x ;
    this.y = y ;
    locked = true ;
    this.text=text;
    f = createFont(text, 20, true);
    textFont(f);
  }

  void lock () 
  {
    locked = true ;
  }

  void unlock ()
  {
    if (mouseX>=x-(w/2) && 
      mouseX<= x+(w/2) &&
      mouseY>= (y)-(h/2) &&
      mouseY<= (y)+(h/2))
      locked = false;
  }

  void drag() 
  {
    if (!locked)
    {
      x=mouseX;
    }
  }

  void display()
  { 
    x=constrain (x, rctx, rctx+w);
    fill(200, 200, 200);
    rect(rctx, y, 180, 10);
    ellipse(x, y+5, 20, 20);
    text(text, rctx-40, y+12 );
  }//method
  //
}// class

I'm fairly new to programming and I'm currently having some trouble using the pixels[] array. I've written a small formula which works on paper, but requires singular pixel's X and Y coordinates to work.

In essence, I'm trying to gather all pixels X and Y-coordinates and weigh them according to their darkness.

Extracting the average brightness (and reversing it) works just fine:

loadPixels(); for (int i = 0; i < pixels.length; i++) { bri += map(brightness(pixels[i]), 0, 100, 1, 0); } updatePixels();

But when I try to get the X-coordinate and weigh it using this method...

for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { pix += (x + 1) * map(brightness(pixels[i]), 0, 100, 1, 0); } updatePixels(); }

It only works with the first X-line of pixels, and even then, it outputs either 0s or other numbers I can't place.

I suspect that I'd have to write something around x + y * width, but I can't quite wrap my head around it.

To summarise: I need every pixel's X and Y-coordinates and that same pixel's brightness.

Thank you for reading! Please post your thoughts; and if I'm missing something extremely obvious as per usual, please point it out!

im quite fresh in the processing world and no native speaker so please be gentle :)

but direct to the Point:

Im would like to know is there any possibilty to get an defined Z axis output of every pixel ? with the code below (copied from shiffman) i can get an matrix out of the kinect so is there any possibility to map every single pixel and send it to an arduino ?

        import org.openkinect.freenect2.*;
        import org.openkinect.processing.*; //<>//

        Kinect2 kinect2;

        void setup() {
          size(32, 16, P2D);
          kinect2 = new Kinect2(this);
          kinect2.initVideo();
          kinect2.initDepth();
        }


        void draw() {
          background(0);

    PImage img = kinect2.getDepthImage();
    //image(img, 0, 0);

    for (int x = 0; x < img.width; x++); {
    for (int y = 0; y < img.height; x++);{
    int index = x +y * img.widht;
    float b = brightness (img.pixels[index]);
    float z = map(b, 0, 255, 250, -250);
    fill(255-b);
    pushMatrix();
    translate( x, y, z);
    rect( 0, 0,skip/2,skip/2);
    popMatrix();
        }
      }
    }

import processing.video.*;

Capture video;



void setup() {
  size(640, 480);
  pixelDensity(1);
  frameRate(60);
  String[] cameras = Capture.list();
  printArray(cameras);
  video = new Capture(this, cameras[1]);
  video.start();
}

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



void draw() {

  video.loadPixels();
  image(video, 0, 0);
  grid();
}

void grid() {
  int square = 0;
  int nr = 20;
  int[] avg = new int[width * height];
  background(255, 0, 0);
  loadPixels();
  if (width % nr == 0 & height % nr == 0) {
    for (int s1 = 0; s1 < height; s1 += height/nr) {
      for (int s2 = 0; s2 < width; s2 += width/nr) {

        for (int x = 0; x < width/nr; x++) {
          for (int y = 0; y < height/nr; y++) {
            square = (x + y * width) + s1 * width + s2;
            avg[square] = int(brightness(get(x + s2, y + s1 * width)));
            pixels[square] = color(avg[square]);
          }
        }

      }
    }
    updatePixels();
  }
}

END

when i run this code it only shows me a black screen. I already tried the same code with just slightly changed for() loops

void grid() {
  int[] avg = new int[width*height]; 
  loadPixels();
  for (int x = 0; x < width; x++) {
    for (int y = 0; y < height; y++) {
      avg[x+y*width] = int(brightness(get(x,y)));
      pixels[x+y*width] = color(avg[x+y*width]);
    }
  }
  updatePixels();
}

and it worked 100% correct, so I assume the problem must be in the for() loops or how i used the variables s1 and s2, but I just can not find the mistake. Thanks in advance.

~sLucas

Analyzing readings for brightness(rgb) has me wondering why brightness(color(200,200,0)) == brightness(color(200,0,0))

I've worked with LEDs quite a bit and by experience and knowledge of additive light theory, rgb(200,200,0) generally produces twice the lumen output as rgb(200,0,0). In other words it's twice as bright because two color dies are illuminated instead of one. I'm pretty sure most modern color monitors also produce color with additive light theory.

My assumption when calling brightness(rgb) would have been

brightness(color(255,255,255)) = 255.0
brightness(color(255,255,0)) = 170.0
brightness(color(255,0,0)) = 85.0

Obviously I'm wrong with respect to working with Processing since all three of those = 255.0

So what's going on here? Is my confusion due to a misunderstanding of what brightness() represents? Or, are there behind the scene rules that Processing is accounting for to produce balanced output for LCD monitors? If so, what are they? And how are others managing color and brightness output when we intend to use LED displays for graphical output?

import processing.video.*;
Capture cam;
int x,y;

void setup (){
  size (640,480);
  frameRate (30);
  background (0);

  printArray (Capture.list()); //choose Webcam, change according the size!
 //cam = new Capture (this, 640,480, "Logitech QuickCam Express/Go",30);
  cam = new Capture (this, 640,480, "Integrated Camera",30);
  cam.start();
}

void draw (){

  if (cam.available()){
    cam.read();
    cam.loadPixels();
    float maxBri = 0.0;
    int theBrightPixel=0;
    for (int i=0; i<cam.pixels.length; i++){
      if(brightness(cam.pixels[i]) > maxBri){ //find the brightest
        maxBri = brightness (cam.pixels[i]);
        theBrightPixel =i; //store id of brightest pixel
      }
    }
   x= theBrightPixel % cam.width; //find x with modolo
   y= theBrightPixel /cam.width; //find y with int, row

}
   image (cam,0,0);
   fill (255,0,0);
   ellipse (x,y,20,20);
}

I was working with an android sample code accessing the camera and I notice it is lagging. Is that normal? I am using 5.0.1. and processing 3.0.2 on a Galaxy VI (no emulator). I am hopping to quantify color segments in the screen but the videos seems to skip frames. It feels like is playing one frame every 2 or 3 seconds instead of the desirable 30 fps that you get running in java mode (using an external camera - and not this specific example). Is there anything I could do to have better video rates?

Cheers,

Kf

import android.os.Environment;
import ketai.camera.*;


KetaiCamera cam;

void settings() {
  fullScreen();
}

void setup() {
  orientation(LANDSCAPE);
  imageMode(CENTER);
  textSize(45);  
}
void draw() {  
  if(cam != null && cam.isStarted()){
     image(cam, width/2, height/2, width, height);    
     text("Number of cams \n" +
      cam.getNumberOfCameras(),  0, 0, width/2-100, height/2);

    cam.loadPixels();
    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 index = 0;
    for (int y = 0; y < cam.height; y++) {
      for (int x = 0; x < cam.width; x++) {
        // Get the color stored in the pixel
        int pixelValue = cam.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) {
          brightestValue = pixelBrightness;
          brightestY = y;
          brightestX = x;
        }
        index++;
      }
    }
    // Draw a large, yellow circle at the brightest pixel
    fill(255, 204, 0, 128);
    ellipse(brightestX, brightestY, 200, 200);       
  }
  else
    {
      background(128);
      text("Waiting for camera....touch to activate", 100, height/2);
    }
}

void onCameraPreviewEvent()
{
  cam.read();
}

// start/stop camera preview by tapping the screen
void mousePressed()
{
  //HACK: Instantiate camera once we are in the sketch itself
  if(cam == null)
      cam = new KetaiCamera(this, 640, 480, 24);

  if (cam.isStarted())
  {
    cam.stop();
  }
  else
    cam.start();
}
void keyPressed() {
  if(cam == null)
    return;

  if (key == CODED) {
    if (keyCode == MENU) {
      if (cam.isFlashEnabled())
        cam.disableFlash();
      else
        cam.enableFlash();
    }
  }
}

import processing.pdf.*;
import processing.serial.*;


Serial myPort;  // Create object from Serial class

int layers=24;

int switches;

byte[] temp = new byte[4];


PImage[] source = new PImage[layers+1];      // Source image
PImage destination;  // Destination image

void setup() {
  size(732, 732);

  myPort = new Serial(this, "/dev/tty.usbmodem621", 9600);


for(int n=0;n<layers+1;n++){
  source[n] = loadImage("layer"+n+".jpg"); 
} 
  // The destination image is created as a blank image the same size as the source.
  destination = createImage(source[0].width, source[0].height, RGB);


  set();
}

void draw() {  
  background(255);

  if ( myPort.available() > 0) {  // If data is available,

    switches = Integer.parseInt(myPort.readString());
    println(switches);
    if(switches==-9294){
    beginRecord(PDF,"output.pdf");
    destination=source[24];
    image(destination,0,0);
    set();
    print();
    }else{
        loop();
    beginRecord(PDF,"output.pdf");
    display();
    textSize(26);
    fill(0);
    text(switches,width-150,height-30);
    print();
    }
  }  
  /*switches=55;*/  
  display();

}

void set(){

destination.loadPixels();
  for (int x = 0; x < destination.width; x++) {
    for (int y = 0; y < destination.height; y++ ) {
      int loc = x + y*source[0].width;
      // Test the brightness against the threshold      
        destination.pixels[loc]  = color(255);  // White
    }
  }

}

void createimg(int n){

float threshold = 127;

  // We are going to look at both image's pixels
  source[n].loadPixels();
  destination.loadPixels();

  for (int x = 0; x < source[n].width; x++) {
    for (int y = 0; y < source[n].height; y++ ) {
      int loc = x + y*source[n].width;
      // Test the brightness against the threshold
      if (brightness(source[n].pixels[loc]) < threshold) {
        destination.pixels[loc]  = color(0);
      }
    }
  }

  // We changed the pixels in destination
  destination.updatePixels();

}

void display(){

  // Display the destination
  image(destination,0,0);
  set();
}

void loop(){

  for(int i = 0; i < layers; i++)
  {
    if(isBitOn(i, switches) && (switches != 0))
    {
    createimg(i);
    }
  }
}

boolean isBitOn(int bit, long value)
{
  long mask = 1;
  mask = mask << bit;
  if((value & mask)>0){
    return true;
  }else{
    return false;
  }
}

void print(){
endRecord();
saveFrame("img/test/bild-######.png");
open("printpdf.app");
}

When it stops, the error is "NumberFormatEcxeption: For input string:"xxxxx". Does anybody find the problem? Thanks for the help!

I'm writing a custom dithering algorithm based on: http://www.tannerhelland.com/4660/dithering-eleven-algorithms-source-code & https://github.com/dpiccone/dithering_algorithms. Somehow the pixels that are supposed to be white are not. It seems to be related to how processing handles colors or brightness. A workaround is commented out in the code, but i'd like to understand why this is happening.

PImage img;

float[][] errorDiffusion = {{1,0,1.0}};
float[][] floydSteinberg = {{-1, 1, 3.0/16}, {0, 1, 5.0/16}, {1, 0, 7.0/16}, {1, 1, 1.0/16}};
float[][] falseFloydSteinberg = {{0, -1, 3.0/8}, {1, 0, 3.0/8}, {1, 1, 2.0/8}};
float[][] atkinson = {{1, 0, 1.0/8}, {2, 0, 1.0/8}, {-1, 1, 1.0/8}, {0, 1, 1.0/8}, {1, 1, 1.0/8}, {0, 2, 1.0/8}};

void setup() {
  size(800, 800, JAVA2D);
  img = loadImage("mona.jpg");
  img = dither(img, falseFloydSteinberg);
  noStroke();
  noSmooth();
}

void draw() {
  background(255, 0, 0);
  image(img, 0, 0);

  color c = img.get(mouseX, mouseY);
  println(brightness(c));  
}

PImage dither(PImage inp, float[][] matrix) {
  PImage src = inp.copy();
  for (int x = 0; x < src.width; x++) {
    for (int y = 0; y < src.height; y++) {
      color oldpixel = src.get(x, y);
      color newpixel = findClosestColor(oldpixel);

      src.set(x, y, newpixel);

      float quant_error = brightness(oldpixel) - brightness(newpixel);

      for (int k=0; k<matrix.length; k++) {   
        int xi = int(x+matrix[k][0]);
        int yi = int(y+matrix[k][1]);       
        src.set(xi, yi, color(brightness(src.get(xi, yi)) + matrix[k][2]* quant_error));
      }
    }
  }
//doing a second pass gives a workaround  
/*
  for (int x = 0; x < src.width; x++) {
    for (int y = 0; y < src.height; y++) {
      color oldpixel = src.get(x, y);
      color newpixel = findClosestColor(oldpixel);
      src.set(x, y, newpixel);
    }
  }
*/
  return src;
}

color findClosestColor(color c) {
  color r;
  if (brightness(c) < 127) {
    r = color(0);
  } else {
    r = color(255);
  }
  return r;
}