Now I want to use this values to set the pixels colors of a RGB LED strip.

The problem is that when I separate and read (at the processing console) de values of the color for each pixel, I get almost all my pixels with 0 for red... But the squares drawn in the screen seems OK, only the values I try to save to the matrix for latter use that seems odd.

Below is my code ( with thanks to bourdonprince and GoToLoop):

import processing.video.*;
Capture webcam;

import processing.serial.*;
Serial myPort;

float[][] rx;
float[][] gx;
float[][] bx;

void setup() {
  size(440, 320);

  String portName = Serial.list()[0];
  myPort = new Serial(this, portName, 9600);

  rx = new float[16][15];
  gx = new float[16][15];
  bx = new float[16][15];

  webcam = new Capture(this, 320, 240);  
  //String[] devices = Capture.list();
  //println(devices);
  webcam.start();
}

void draw() {

  if (webcam.available() == true) {
    webcam.read();
    image(webcam, 0, 0, width, height);
    saveFrame("/data/image.jpg");
  }

  delay(100);

  PImage img = loadImage("image.jpg");
  int detail = 30; // tamanho do quadrado

  int count_i = 0;
  int count_j = 0;


  for (int j=0; j< height; j+=detail) {
    
    count_i = 0;

    for (int i=0; i < width; i+=detail) {
      PImage newImg = img.get(i, j, detail, detail);
      noStroke();
      color cor = extractColorFromImage(newImg);
      fill(cor);
      rx[count_i][count_i]= red(cor);
      gx[count_i][count_j]= green(cor);
      bx[count_i][count_j]= blue(cor);

      count_i++;
    }
    count_j++;
  }


  for (int i=0; i<15; i++)
  {
    for (int j=0; j<11; j++)
    {
      println((i) + "," + (j) + "," + int( rx[i][j] )+ "," + int (gx[i][j]) + "," + int (bx[i][j]));
      //delay(100);
      myPort.write((i) + "," + (j) + "," + int( rx[i][j] )+ "," + int (gx[i][j]) + "," + int (bx[i][j])  + "\n");
      delay(50);
    }
  }

  delay(2000);
}



//função para extrair a cor média em um recorte
color extractColorFromImage(PImage img) {
  img.loadPixels();
  color r = 0, g = 0, b = 0;

  for (final color c : img.pixels) {
    r += c >> 020 & 0xFF;
    g += c >> 010 & 0xFF;
    b += c        & 0xFF;
  }

  r /= img.pixels.length;
  g /= img.pixels.length;
  b /= img.pixels.length;

  return color(r, g, b);
}

But I have found a major difference in performance between using a multidimensional array and 3 one dimension arrays.

I had been allocating the array as such:

float floatArray = new float[4800 * 6000][3];

That little line of code took about 5-10 seconds to allocate on my Windows 7, i7 processor with 16gb ram.

But writing it as this takes only milliseconds to allocate:

float floatArrayR = new float[4800 * 6000];
float floatArrayG = new float[4800 * 6000];
float floatArrayB = new float[4800 * 6000];

I remember reading many years ago that different os's handle multidimensional arrays differently and one should not assume how the members are ordered. I can't imagine how the java virtual machine handles multidimensional arrays to make them so much slower than one dimension arrays. Allocation time from 5-10 seconds to milliseconds? Whats going on there? The multidimensional array also slowed garbage collection so much it was performance issue. Not so with the one dimension array.

To make the question simple, let's say I want to get the color of the center pixel of a video feed and fill a rectangle the size of the window to this particular color. To mitigate the flickering of this colored rectangle which will naturally occur from the video, I would like to average, say, the color of the last 60 frames of the video and always have the rectangle displaying that averaged color.

What would be an approach to making this happen?

I'm currently trying to combine two processing sketches (BackgroundRemove and Blobdetection) to do the following with a webcam aimed at a street:

1. Get videocapture and turn the original image fully green
2. Compare every new frame with the original background image

3. Only show the changed pixels (as a result the canvas is fully green but only moving objects are shown).

4. Use blobdetection to draw rectangles around each moving object.

For this I'm trying to combine the two scripts listed at the end of this post. The BackgroundRemove comes from http://learningprocessing.com/examples/chp16/example-16-12-BackgroundRemove The Blobdetection comes from http://www.v3ga.net/processing/BlobDetection/index-page-home.html

Both scripts seperately work fine, but I've been working for days to combine them and I can't seem to get it working. I think the solution would be to replace the video input in the Blob detection with the canvas input, but I can't figure out how to do that (or how to fix this otherwise).

Would anyone be able to help me here? Thanks!

sorry, the Code tags don't seem to work correctly. For a better view, here are the code Gists: https://gist.github.com/Thomvdm/fd4c412b6bb66a264728b1816c9b5a10 https://gist.github.com/Thomvdm/21d6e9d3df86e288cb8e36fd41bcaf29

| | | | | | |

// Example 16-12: Simple background removal

// Click the mouse to memorize a current background image
import processing.video.*;

// Variable for capture device
Capture video;

// Saved background
PImage backgroundImage;

// How different must a pixel be to be a foreground pixel
float threshold = 30;

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

  video = new Capture(this, width, height);


  video.start();
  // Create an empty image the same size as the video
  backgroundImage = createImage(video.width, video.height, RGB);
}

void captureEvent(Capture video) {
  // Read image from the camera
  video.read();
}

void draw() {
  // We are looking at the video's pixels, the memorized backgroundImage's pixels, as well as accessing the display pixels. 
  // So we must loadPixels() for all!
  loadPixels();
  video.loadPixels(); 
  backgroundImage.loadPixels();

  // Begin loop to walk through every pixel
  for (int x = 0; x < video.width; x ++ ) {
    for (int y = 0; y < video.height; y ++ ) {
      int loc = x + y*video.width; // Step 1, what is the 1D pixel location
      color fgColor = video.pixels[loc]; // Step 2, what is the foreground color

      // Step 3, what is the background color
      color bgColor = backgroundImage.pixels[loc];

      // Step 4, compare the foreground and background color
      float r1 = red(fgColor);
      float g1 = green(fgColor);
      float b1 = blue(fgColor);
      float r2 = red(bgColor);
      float g2 = green(bgColor);
      float b2 = blue(bgColor);
      float diff = dist(r1, g1, b1, r2, g2, b2);

      // Step 5, Is the foreground color different from the background color
      if (diff > threshold) {
        // If so, display the foreground color
        pixels[loc] = fgColor;
      } else {
        // If not, display green
        pixels[loc] = color(0, 255, 0); // We could choose to replace the background pixels with something other than the color green!
      }
    }
  }
  updatePixels();
}

void mousePressed() {
  // Copying the current frame of video into the backgroundImage object
  // Note copy takes 5 arguments:
  // The source image
  // x, y, width, and height of region to be copied from the source
  // x, y, width, and height of copy destination
  backgroundImage.copy(video, 0, 0, video.width, video.height, 0, 0, video.width, video.height);
  backgroundImage.updatePixels();
}














// - Super Fast Blur v1.1 by Mario Klingemann <http://incubator.quasimondo.com>;
// - BlobDetection library

import processing.video.*;
import blobDetection.*;

Capture cam;
BlobDetection theBlobDetection;
PImage img;
boolean newFrame=false;

// ==================================================
// setup()
// ==================================================
void setup()
{
    // Size of applet
    size(640, 480);
    // Capture
    cam = new Capture(this, 640, 480, 30);
        // Comment the following line if you use Processing 1.5
        cam.start();

    // BlobDetection
    // img which will be sent to detection (a smaller copy of the cam frame);
    img = new PImage(80,60); 
    theBlobDetection = new BlobDetection(img.width, img.height);
    theBlobDetection.setPosDiscrimination(true);
    theBlobDetection.setThreshold(0.2f); // will detect bright areas whose luminosity > 0.2f;
}

// ==================================================
// captureEvent()
// ==================================================
void captureEvent(Capture cam)
{
    cam.read();
    newFrame = true;
}

// ==================================================
// draw()
// ==================================================
void draw()
{
    if (newFrame)
    {
        newFrame=false;
        image(cam,0,0,width,height);
        img.copy(cam, 0, 0, cam.width, cam.height, 
                0, 0, img.width, img.height);
        fastblur(img, 2);
        theBlobDetection.computeBlobs(img.pixels);
        drawBlobsAndEdges(true,true);
    }
}

// ==================================================
// drawBlobsAndEdges()
// ==================================================
void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges)
{
    noFill();
    Blob b;
    EdgeVertex eA,eB;
    for (int n=0 ; n<theBlobDetection.getBlobNb() ; n++)
    {
        b=theBlobDetection.getBlob(n);
        if (b!=null)
        {
    print("Blob #: ");
    println(n);
    print("X Coord of center: ");
    println(b.x);
print("Y Coord of center: ");
println(b.y);
            // Edges
            if (drawEdges)
            {
                strokeWeight(3);
                stroke(0,255,0);
                for (int m=0;m<b.getEdgeNb();m++)
                {
                    eA = b.getEdgeVertexA(m);
                    eB = b.getEdgeVertexB(m);
                    if (eA !=null && eB !=null)
                        line(
                            eA.x*width, eA.y*height, 
                            eB.x*width, eB.y*height
                            );
                }
            }

            // Blobs
            if (drawBlobs)
            {
                strokeWeight(1);
                stroke(255,0,0);
                rect(
                    b.xMin*width,b.yMin*height,
                    b.w*width,b.h*height
                    );

            }

        }

      }
}

// ==================================================
// Super Fast Blur v1.1
// by Mario Klingemann 
// <http://incubator.quasimondo.com>;
// ==================================================
void fastblur(PImage img,int radius)
{
 if (radius<1){
    return;
  }
  int w=img.width;
  int h=img.height;
  int wm=w-1;
  int hm=h-1;
  int wh=w*h;
  int div=radius+radius+1;
  int r[]=new int[wh];
  int g[]=new int[wh];
  int b[]=new int[wh];
  int rsum,gsum,bsum,x,y,i,p,p1,p2,yp,yi,yw;
  int vmin[] = new int[max(w,h)];
  int vmax[] = new int[max(w,h)];
  int[] pix=img.pixels;
  int dv[]=new int[256*div];
  for (i=0;i<256*div;i++){
    dv[i]=(i/div);
  }

  yw=yi=0;

  for (y=0;y<h;y++){
    rsum=gsum=bsum=0;
    for(i=-radius;i<=radius;i++){
      p=pix[yi+min(wm,max(i,0))];
      rsum+=(p & 0xff0000)>>16;
      gsum+=(p & 0x00ff00)>>8;
      bsum+= p & 0x0000ff;
    }
    for (x=0;x<w;x++){

      r[yi]=dv[rsum];
      g[yi]=dv[gsum];
      b[yi]=dv[bsum];

      if(y==0){
        vmin[x]=min(x+radius+1,wm);
        vmax[x]=max(x-radius,0);
      }
      p1=pix[yw+vmin[x]];
      p2=pix[yw+vmax[x]];

      rsum+=((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
      gsum+=((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;
      bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
      yi++;
    }
    yw+=w;
  }

  for (x=0;x<w;x++){
    rsum=gsum=bsum=0;
    yp=-radius*w;
    for(i=-radius;i<=radius;i++){
      yi=max(0,yp)+x;
      rsum+=r[yi];
      gsum+=g[yi];
      bsum+=b[yi];
      yp+=w;
    }
    yi=x;
    for (y=0;y<h;y++){
      pix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
      if(x==0){
        vmin[y]=min(y+radius+1,hm)*w;
        vmax[y]=max(y-radius,0)*w;
      }
      p1=x+vmin[y];
      p2=x+vmax[y];

      rsum+=r[p1]-r[p2];
      gsum+=g[p1]-g[p2];
      bsum+=b[p1]-b[p2];

      yi+=w;
    }
  }

}`

import processing.video.*; int cols, rows; Capture cam;

void setup() {

//displays it full screen size (displayWidth, displayHeight);

cols = width;
rows = height; //30 fps is default so bellow won't change anything cam = new Capture(this, width, height, 30);

// Start capturing the images from the camera cam.start();

frameRate(30); background(0); }

void draw() { if(cam.available()) { //reads fresh-est pixels from camera cam.read(); cam.loadPixels(); loadPixels(); // Loop through every pixel. ++i is equivalent to i = i + 1. //for (int i=0; i<cam.pixels.length; i++) {

// Begin loop for columns(using width)
for (int i = 0; i < cols;i++) {
  // Begin loop for rows(using length)
  for (int j = 0; j < rows;j++) {

    // Where are we, pixel-wise? (cam.width - i - 1) means x-coordinate of the pixel mirrored
    int loc = (cam.width - i - 1) + j*cam.width;  // Reversing x to mirror the image

    if (brightness(cam.pixels[loc]) > 253) {
      pixels[loc] = color(255);       
    }

 float red = red(pixels[loc]);
 float green = green(pixels[loc]);
 float blue = blue(pixels[loc]);

 blue = blue - 5;
 if(blue < 0) blue = 0;

 red = red - 5;
 if(red < 0) red = 0;

 green = green - 5;
 if(green < 0) green = 0;

 pixels[loc] = color(red, green, blue);

} 

}

updatePixels();

} }

PImage[] pic, difference;
int levels = 3;

void setup(){

  size(displayWidth, displayHeight);
  background(0);

  //setup image arrays

  pic = new PImage[levels + 1];
  difference = new PImage[levels];

  //load image to be analyzed
  pic[0] = loadImage("swamptrees.jpg");
  pic[0].loadPixels();

  //setup individual color variables
  float r, g, b;

  //blur each image and find the diffence from previous level of blur
  for (int i = 0 ; i < levels ; i ++){

    //create and blur this level
    pic[i + 1] = createImage(pic[0].width, pic[0].height, RGB);
    pic[i + 1] = pic[0].get();
    pic[i + 1].filter(BLUR, pow(2, i));
    pic[i + 1].loadPixels();

    //create and calculate the difference
    difference[i] = createImage(pic[0].width, pic[0].height, RGB);
    difference[i].loadPixels();

    for (int j = 0 ; j < pic[0].pixels.length ; j++){

      r = abs(red(pic[i].pixels[j] - red(pic[i + 1].pixels[j])));
      g = abs(green(pic[i].pixels[j] - green(pic[i + 1].pixels[j])));
      b = abs(blue(pic[i].pixels[j] - blue(pic[i + 1].pixels[j])));

      difference[i].pixels[j] = color(r, g, b);

    }

  }

  pic[0].updatePixels();

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

    pic[i + 1].updatePixels();
    difference[i].updatePixels();

  }

}

void draw(){

  image(pic[0], 0, 0, width/4, height/4);

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

    image(pic[i + 1], 0, (height / 4) * (i + 1), width / 4, (height / 4) * (i + 2));
    image(difference[i + 1], width / 4, (height / 4) * (i + 1), width / 2, (height / 4) * (i + 2));

  }

}

I’m projecting a sketch in which, the mouse pointer can change the colors of an image by moving over.

I am using the following code to draw one pixel colour for every 10x10 pixel area.

size(700, 450);
PImage img = loadImage("image.jpg");
//noStroke();
int detail = 10;

for (int i=0; i<width; i+=detail) {
  for (int j=0; j<height; j+=detail) {
    color c = img.get(i, j);
    fill(c);
    rect(i, j, detail, detail);
  }
}

My question is, how can I instead of reading one pixel's value and draw it in the area of 10x10, to get the average of all pixels from the 10x10 area of the original image, and draw the value on the same 10x10 rect?

Thanks - I also attach a sketch, maybe is helps!

PImage img;       // The source image
color c;
int r;
int g;
int b;
int loc;

void setup() {
  size(564, 424);
  img = loadImage("ring.jpg"); // Load the image
image(img,0,0);
  loadPixels();
}

void draw() {

  updatePixels();


  // Begin loop for columns
  for (int i = 0; i < img.width; i++ ) {
    // Begin loop for rows
    for (int j = 0; j < img.height; j++ ) {


    //focus on an algorithm to slowly update the RGB values
    if(r<255){r=r+10;}else {r=0;}
     if(b<255){b=b+10;}else {b=0;}
     if(g<255){g=g+10;}else {g=0;}

    // print("R:");println(r);
     //print("G:");println(r);
     //print("B:");println(r);

      loc = (int)random(236139);     

     //loc=i+j*img.width;      

    /*  if(loc<239135)
      {
      loc++;       }
      else{loc=0;}*/

      c = color(r,g,b);

      pixels[loc]=c;       
      //println(loc);

      }//j
  }//i


}

I've stripped down some code I'm working on to figure out what's breaking, but even in this VERY bare bones version, everything breaks. At this point I'm simply trying to cycle through each pixel and report red green and blue values. Any help would be greatly appreciated as I have no idea what I'm doing incorrectly.

code below

PImage source;
int loc;
float r;
float g;
float b;
float lumin;
color c;

void setup(){
 source = loadImage("sheet_face.jpg","jpg");
 size(564,848,P2D); 
 float threshold = .7;

 source.loadPixels();

 image(source,0,0);

 for(int y = 0; y < source.height; y++){
  for(int x = 0; x < source.width; x++){
   loc = y*width+x;
   c = source.pixels[loc];
   r = red(c);
   g = green(c);
   b = blue(c);
   println("red value is "+r);
   println("green value is "+g);
   println("blue value is "+b);
   lumin = (r+g+b)/765;
   println("lumin value is "+lumin);
  }
 }
 source.updatePixels();
}

For my project (https://forum.processing.org/two/discussion/comment/60203) I have 4 x 4 objects. I use an array to define the 16 objects, but somehow it seems easier if I could use indexes that refer to the row and colum each object is in.

Someting like this: object11, object12, object13, object14 object21, object22, object23, ...

Is this easy doable? If yes, how?

Thank you ;-)

import processing.video.*;

Capture cam;

PImage camR;
PImage camG;
PImage camB;

void setup() {
  size(640, 480);
  colorMode(RGB,255);
  frameRate(1);
  String[] cameras = Capture.list();

  if (cameras == null) {
    println("Failed to retrieve the list of available cameras, will try the default...");
    cam = new Capture(this, 640, 480);
  } 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():
    cam = new Capture(this, cameras[0]);
    // Or, the settings can be defined based on the text in the list
    //cam = new Capture(this, 640, 480, "Built-in iSight", 30);

    // Start capturing the images from the camera
    cam.start();
  }
}

void draw() {
  if (cam.available() == true) {
    cam.read();
  }
  camR = cam;
  camG = cam;
  camB = cam;
  cam.loadPixels();
  camR.loadPixels();
  camG.loadPixels();
  camB.loadPixels();

  for (int i = 0; i < cam.width*cam.height; i++){

    camR.pixels[i] = color(red(cam.pixels[i]));
    camG.pixels[i] = color(green(cam.pixels[i]));
    camB.pixels[i] = color(blue(cam.pixels[i]));
  }
  cam.updatePixels();
  camR.updatePixels();
  camG.updatePixels();
  camB.updatePixels();
  image(cam,0,0,200,150);
  image(camR,200,0,200,150);
  image(camG,200,150,200,150);
  image(camB,200,300,200,150);

}

I'm expecting to see the full RGB image when I run image(cam...), but I end up just getting the greyscale RED channel. The "camG" and "camB" are also displaying the red channel.

I imagine it will go something like this

PImage myImage = loadImage("apples.jpg");
image(myImage, 0, 0);

loadPixels();
get () green pixel
change green pixel to  x pixel
get () white pixel
change white pixel to  y pixel
updatePixels();

I am a bit confuse on how to proceed between loadPixels(); and updatePixels(); if it the right way, any help will be appreciated.

    color c1 = color(255,255,0);

and I want to be able to modify the R value of this variable without having to rewrite it (then NOT something like c1 = color(100,255,0)).

Any idea?

Thank you p.

I need to access the individual RGB values of color. Anybody know what they're called?

Thanks.

I threw together the following program to demonstrate what I mean.

PImage originalImage, newImage;
String oldName = "input.jpeg", newName = "newImage.jpeg";

void setup() {
  originalImage = loadImage(oldName);

  printPixels(originalImage, oldName);
  makeNewImage(newName);
  printPixels(loadImage(newName), newName);
}

private void printPixels(PImage _image, String _name) {
  println(" === Pixels: " + _name + " === ");

  // Print only 15 pixels, just to keep things simple.
  for (int i = 0; i < 15; i++) {
    println(red(_image.pixels[i]) + " : " + green(_image.pixels[i]) + " : " + blue(_image.pixels[i]));
  }
  println();
}

private void makeNewImage(String _name) {
  // Create new image
  newImage = createImage(originalImage.width, originalImage.height, RGB); 
  // Copy the original image over
  newImage = originalImage.get();
  // Save new image
  newImage.save(_name);
}

All this program does is receive an image "input.jpeg", and save an identical copy of it called "newImage.jpeg". Easy enough, right? Well, here is what it outputs when it reads the pixel RGB values:

 === Pixels: input.jpeg === 
226.0 : 234.0 : 237.0
226.0 : 234.0 : 237.0
226.0 : 234.0 : 237.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
223.0 : 231.0 : 234.0
222.0 : 230.0 : 233.0
220.0 : 228.0 : 231.0
220.0 : 228.0 : 231.0
221.0 : 229.0 : 232.0
222.0 : 230.0 : 233.0

 === Pixels: newImage.jpeg === 
226.0 : 234.0 : 237.0
226.0 : 234.0 : 237.0
226.0 : 234.0 : 237.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
225.0 : 233.0 : 236.0
224.0 : 232.0 : 235.0
223.0 : 231.0 : 234.0
221.0 : 229.0 : 232.0
220.0 : 228.0 : 231.0
219.0 : 227.0 : 230.0
220.0 : 228.0 : 231.0
222.0 : 230.0 : 233.0

Look at the second last pixel data. Can anyone explain why the RGB values sometimes differ? Is there a better way to import and save images? Should I use a different picture format?

Thanks in advance, - Sono

Why colors are negatives? What are these strange values?

These are common questions, often seen in the forum.

Colors, in Processing, are stored actually in simple Java ints, 32-bit values. The color pseudo-type is actually replaced by Processing with int when generating Java code before compilation.

This type has a width of 32 bits, which is perfect as we can put 4 channels of 8 bits each inside. 8 bits allow a range of of values from 0 to 255 (included). The 4 channels are alpha (opacity), red, green, blue, the whole being often abbreviated as ARGB.

Low value of color channel means "low intensity", darkness. High value means "high intensity", lightness. So if all channels are 0, we have black; if they are all at 255, we have white.
Alpha channel is different: 0 means low opacity, fully transparent, while 255 means high opacity, normal opaque color.

In Java, numbers are always signed. In computing, negative numbers are marked by setting the highest bit to 1. So, opaque colors, the most common kind, the default if no opacity is given, is 0xFF = 255, the high bit is set to 1, the color value is negative.
Hence the answer to the first question...

The strange values are the result of combining all the values of the channels.
Let's take a simple yellowish color. Alpha is 255 (opaque), red is 250, green is 230 and blue is, say, 20. These values are 0xFF, 0xFA, 0xE6 and 0x14.
Combined to make an int, it gives 0xFFFAE614, ie. -334316. Hence a strange number, not very easy to decipher.

Note that Processing uses a special notation (not in the Java language) for color literals: the previous color can be written #FAE614 (no alpha in this notation). It is equivalent to 0xFFFAE614 or to a call to the color() function: color(240, 130, 20);

If you want to print out color values, eg. for debugging, you have to use the hex() function:

color c = color(240, 130, 20);
background(c);
println(c);
println(hex(c));

How do I get the color components?

The easiest way is to use red(), green(), blue() and alpha() functions. They return a floating point number. Also of interest are hue(), saturation() and brightness() for HSB mode.
But these functions are rather slow, because Processing takes the current colorMode() into account.

It is faster to use bitwise operations to get the components as integers between 0 and 255 (inclusive):

color c = color(240, 130, 20);
int alpha = (c >> 24) & 0xFF;
int red   = (c >> 16) & 0xFF;
int green = (c >> 8)  & 0xFF;
int blue  =  c        & 0xFF;
println(alpha + " " + red + " " + green + " " + blue);

The idea is to shift the relevant bits to the right until they are at the lower position, then to mask them with 'and' to isolate them.

Likewise, you can build a color this way, although it is easier to use color() for that (which is, again, slower because of colorMode).

color c2 = (alpha << 24) | (red << 16) | (green << 8) | blue;
println(hex(c2));

My code looks like this so far:

  float light = 1;

  for(int y = 0;y < img.height; y = y + 1){
    for(int x = 0;x < img.width; x = x + 1){
      color getColor = img.get(x, y);{

      float newRed = red(getColor)*light*0;
      float newGreen = green(getColor)*light*0;
      float newBlue = blue(getColor)*light*2;

      color newColor = color(newRed, newGreen, newBlue);


      set(x, y, newColor);
    }
  }
  }
}

Thanks.

I would like that someone explain me this code cuz i don't understand what's correspond of sumr, why a ' k ' .... Thx to reply me

1) Read image, loadpixels. 2) convert rgb data to hsv data in pixels array 3) update pixels 4) validate hsv data ranges in pixels array 5) save file

Once I've started my program I read the file, convert to HSV/HSB, and show the resulting bizarre image on screen via image(). Just to be sure I was doing it right, I wrote a routine to convert the HSV/HSB data in the pixels array back to RGB. I can go back and forth flawlessly.

Before saving the image to disk using the PImage.save(), I run a validate routine to check on the ranges of all the HSV values in the pixels array. The output from that is as follows:

HSV validation: hue range=** 0 to 359** Saturation range= **0 to 94**  Brightness range= **7 to 100**

This is what I expect to see so I save the file and end the session.

I restart the program and load that newly saved image. Displaying the image it does display correctly, that is as a weird image - which is no surprise as the image data is being interpreted as 0-255 RGB values.

However, when I run my validate routine against the values in the pixels array, it returns the following.

   HSV validation: hue range= **0 to 746** Saturation range= **0 to 127**  Brightness range= **0 to 127**

The values in this new pixels array have changed substantially yet I have done nothing to the data between the time I saved it and opened it. Further when I attempt to convert the HSB values back to RGB the result is garbage and all kinds of "range out of bounds" error messages that I incorporated into my conversion utilities.

I am guessing that there is some sort of behind the scenes processing that is going on with respect to what Processing is doing when it is reading and writing the pixels array. OR... a thought that has crossed my mind is that the PImage.save does not save the contents of the pixels array but instead relies on saving an RGB version of what appears on screen.

So, perhaps my question should be this: how can I insure that the contents of the pixels array is what is being saved?

PS - the reason I suspect that Processing is at fault is because I have to lie in order to do HSB. RGB values are all in the 0-255 range associated with 8 bits per channel of storage. In order to save the HSB data, whose range is 360,100,100, I use only 7 bits for S and B, and 10 bits for H.

Any light that anyone can shed on this would be immensely appreciated. Thanks.