ANCORA NOI

come faccio a discretizzare meglio i colori ??

import processing.serial.*;

import cc.arduino.*;

Arduino arduino;
int R=9;
int G=10;
int B=11;





/**
 * Color Sorting  
 * by Ben Fry. 
 * 
 * Example that sorts all colors from the incoming video
 * and arranges them into vertical bars.
 */
 
 
import processing.video.*;

Capture video;
boolean cheatScreen;

Tuple[] captureColors;
Tuple[] drawColors;
int[] bright;

// How many pixels to skip in either direction
int increment = 5;


public void setup() {
  
  size(800, 600, P3D);
  {
  //println(Arduino.list());
  arduino = new Arduino(this, Arduino.list()[1]); // v2
  //arduino = new Arduino(this, Arduino.list()[0], 57600); // v1

}

noCursor();
  // Uses the default video input, see the reference if this causes an error
  video = new Capture(this, 80, 60, 15);
  
  int count = (video.width * video.height) / (increment * increment);
  bright = new int[count];
  captureColors = new Tuple[count];
   drawColors = new Tuple[count];
  for (int i = 0; i < count; i++) {
    captureColors[i] = new Tuple();
    drawColors[i] = new Tuple(0.5, 0.5, 0.5);
  }
}


public void draw() {
  if (video.available()) {
    video.read();
    
    background(0);
    noStroke();
    
    

    int index = 0;
    for (int j = 0; j < video.height; j += increment) {
      for (int i = 0; i < video.width; i += increment) {
        int pixelColor = video.pixels[j*video.width + i];

        int R = (pixelColor >> 16) & 0xff;
        int G = (pixelColor >> 8) & 0xff;
        int B = pixelColor & 0xff;
        
        // Technically would be sqrt of the following, but no need to do
        // sqrt before comparing the elements since we're only ordering
        bright[index] = R*R + G*G + B*B;
        captureColors[index].set(R, G, B);
       

    
        index++;
        arduino.analogWrite(9,R);
    arduino.analogWrite(10,G);
    arduino.analogWrite(11,B);
  
    
 }
 
    }
    sort(index, bright, captureColors);

    beginShape(QUAD_STRIP);
    for (int i = 0; i < index; i++) {
      drawColors[i].target(captureColors[i], 0.1);
      drawColors[i].phil();

      float x = map(i, 0, index, 0, width);
      vertex(x, 0);
      vertex(x, height);
    }
    endShape();

    if (cheatScreen) {
      //image(video, 0, height - video.height);
      // Faster method of displaying pixels array on screen
      set(0, height - video.height, video);
    }
  }
    
}




public void keyPressed() {
  if (key == 'g') {
    saveFrame();
  } else if (key == 'c') {
    cheatScreen = !cheatScreen;
  }
  
}


// Functions to handle sorting the color data


void sort(int length, int[] a, Tuple[] stuff) {
  sortSub(a, stuff, 0, length - 1);
}


void sortSwap(int[] a, Tuple[] stuff, int i, int j) {
  int T = a[i];
  a[i] = a[j];
  a[j] = T;

  Tuple v = stuff[i];
  stuff[i] = stuff[j];
  stuff[j] = v;
}


void sortSub(int[] a, Tuple[] stuff, int lo0, int hi0) {
  int lo = lo0;
  int hi = hi0;
  int mid;

  if (hi0 > lo0) {
    mid = a[(lo0 + hi0) / 2];

    while (lo <= hi) {
      while ((lo < hi0) && (a[lo] < mid)) {
        ++lo;
      }
      while ((hi > lo0) && (a[hi] > mid)) {
        --hi;
      }
      if (lo <= hi) {
        sortSwap(a, stuff, lo, hi);
        ++lo;
        --hi;
      }
    }

    if (lo0 < hi)
      sortSub(a, stuff, lo0, hi);

    if (lo < hi0)
      sortSub(a, stuff, lo, hi0);
  }
}

grassie

Ciao

é un po dura capire cosa succede semplicemente dal codice senza mettersi a ricostruire il vostro circuito.

Ci spiegate un po meglio quale è il problema?

massimo