Hi there,

Im trying to make a program that makes a 16x16 matrix from a selected part of my capturing webcam. After that the program "pixelates" it and gets the average color.
Output:" [0] -1479261 / [1] 207713 / [2] 278041 ..."

I seperate the average color array to three seprerate arrays (R+G+B). Now I want to print the RGB-Values from these arrays (red [255] / green [255] / blue [255]).

But I'm only getting strange values printed.
Output:" [I@4c9d22fc / [I@6063f5af / [I@4296e599 ").

Can you tell me how to print the three arrays after each other (red [0] / green [0] / blue[0]; red [1] / green [1] / blue [1];...red [255] / green [255] / blue [255]) to match them if their are even right?

1. int xposp = 0;
2. int yposp = 0;
   
   
3. //evtl ausklammern falls andere version funktioniert
   
4. //int farbevar = 0;
   
   
5. int colorwert = 0;
   
   
   
6. // Maus-Positons Variablen / 4x x,y
   
7. int[] pointed = new int[8];
   
   
8. //Video Import
9. import processing.video.*;
10. Capture cam;
    
11. 
    
12. void setup (){
    
13.       size (1280, 960, P2D);
    
14. 
    
15.     // Variable Kameraliste
    
16.     String[] cameras = Capture.list();
    
17.    
    
18.     // Kameraliste erstellen
    
19.     if (cameras.length == 0) {
    
20.         println("There are no cameras available for capture.");
    
21.         exit();
    
22.     }
    
23.     else {
    
24.         //println("Available cameras:");
    
25.         for (int i = 0; i < cameras.length; i++) {
    
26.         //println(cameras[i]);
    
27.     }
    
28.    
    
29.     // Kamera initalisieren und wiedergeben
    
30.     // Im Array aus Liste --> list():
    
31.     cam = new Capture(this, cameras[37]);
    
32.     cam.start();    
    
33.   }
    
34. 
    
35. }
    
36. 
    
37. // Bekomme Mausposition
    
38. void mousePressed(){
    
39.      xposp = mouseX;
    
40.      yposp = mouseY;
    
41.    
    
42.    // Setzte Mauspositionswerte in Array
    
43.     if (pointed[0] == 0) {
    
44.       pointed[0] = xposp;
    
45.       pointed[1] = yposp;
    
46.     }
    
47.     else if (pointed[2] == 0 ) {
    
48.       pointed[2] = xposp;
    
49.       pointed[3] = yposp;
    
50.     }
    
51.     else if (pointed[4] == 0 ) {
    
52.       pointed[4] = xposp;
    
53.       pointed[5] = yposp;
    
54.     }
    
55.     else{
    
56.       pointed[6] = xposp;
    
57.       pointed[7] = yposp;      
    
58.     } 
    
59. }
    
60. 
    
61. void draw() {
    
62.     cursor(CROSS);
    
63.    
    
64.     // Gebe Mausklickwerte aus
    
65.     //println(pointed);
    
66. 
    
67.    
    
68.     // Kamera ausgeben
    
69.     if (cam.available() == true) {
    
70.       cam.read();
    
71.     }
    
72.     image(cam, 0, 0);
    
73.    
    
74.     // Variabele für Startposition Bricks
    
75.     int firstpixelx = 0;
    
76.     int firstpixely = 0;
    
77.     // Variable eine Brickgröße
    
78.     int bricky = 0;
    
79.     int brickx = 0;
    
80.    
    
81.     int langex = 0;
    
82.     int langey = 0;
    
83.    
    
84.     // Nach Markieren wird längere X-Kante wird ausgewählt
    
85.     if (pointed[6] - pointed[0] >= pointed[4] - pointed[2]) {
    
86.         langex = pointed[6] - pointed[0];
    
87.         }
    
88.     else { langex = pointed[4] - pointed[2];
    
89.         }
    
90.        
    
91.     // Nach Markieren wird längere Y-Kante wird ausgewählt
    
92.     if (pointed[3] - pointed[1] >= pointed[5] - pointed[7]) {
    
93.         langey = pointed[3] - pointed[1];
    
94.     }     
    
95.     else { langey = pointed[5] - pointed[7];
    
96.     }   
    
97.    
    
98.     // mittlerer Abstand erster Pixel von links
    
99.     // mittlerer Abstand erster Pixel von oben
    
100.     firstpixelx = (langex / 32) + pointed[2];
     
101.     firstpixely = (langey / 32) + pointed[1];
     
102. 
     
103.     // Errechnung Brickgröße x + y
     
104.     brickx = (langex / 16);
     
105.     bricky = (langey / 16);
     
106. 
     
107.    
     
108.     //println(firstpixelx + "," + firstpixely + "/" + brickx + "," + bricky);
     
109.    
     
110.     int[] pixelpx = new int[256]; 
     
111.     int[] pixelpy = new int[256];
     
112. 
     
113.     int kx = 0;
     
114.     int ky = 0;
     
115.     int i = 0;
     
116. 
     
117.     while (ky <= 15) {
     
118.         while (kx <= 15) {
     
119.               pixelpx[i] = firstpixelx + (brickx * kx);
     
120.               pixelpy[i] = firstpixely + (bricky * ky);
     
121.               i = i+1;
     
122.               kx = kx + 1;
     
123.         }
     
124.    
     
125.     kx = 0;
     
126.     ky = ky + 1;
     
127.     }
     
128.     //println(pixelpx);
     
129.    
     
130.     color aktcolor = get(pointed[0], pointed[1]);
     
131.     //println(aktcolor);
     
132.    
     
133.     /*
     
134.     color aktcolor = get(pixelpx, pixelpy);
     
135.     println(aktcolor);
     
136.     */
     
137.    
     
138. 
     
139. // Farbwert genauer bestimmen   
     
140.     // Variable Farbsumme
     
141.     int colorsum = 0;
     
142.     // Variable Farbmittelwert
     
143.     int[] colormittel = new int [256];
     
144.    
     
145.     // Hilfsvariable um Pixel drumrum zu erstellen
     
146.     int[] bx = new int[2];
     
147.     int[] by = new int[2];
     
148.     int k = 0;
     
149.    
     
150.     i = 0;
     
151.    
     
152.     // Nehme Mittelpunkt des Arrays und schreibe jeweils 10px drumrum
     
153.     // Hole Farbewerte und bilde den Mittelwert der Farbe
     
154.     while (i <= 255) {
     
155.       k = 0;
     
156.       colorsum = 0;
     
157.       bx[k] = pixelpx [i] - (brickx/2) + 10;
     
158.       by[k] = pixelpy [i] - (bricky/2) + 10;
     
159.       k = k + 1;
     
160.       bx[k] = pixelpx [i] + (brickx/2) - 10;
     
161.       by[k] = pixelpy [i] + (bricky/2) - 10;
     
162.       ky = by[0];
     
163.           while ( ky <= by [1] ) {
     
164.               kx = bx [0];           
     
165. 
     
166.               while (kx <= bx[1]) {
     
167.                   color colorwert = get(kx,ky);
     
168.                   colorsum = colorsum + colorwert;
     
169.                   kx = kx + 1;
     
170.               }   
     
171.           ky = ky + 1;
     
172.           }
     
173.       colormittel[i] = colorsum / ((bx[1]-bx[0]) * (by[1]-by[0]));
     
174.       i = i + 1;
     
175.   } 
     
176.     //println(colormittel);
     
177.    
     
178.    
     
179.     //Wandelt colormittel in RGB-Output um
     
180.     int ii = 0;
     
181.     int[] red = new int [256];
     
182.     int[] green = new int [256];
     
183.     int[] blue = new int [256];
     
184.    
     
185.     while (ii <= 255) {
     
186.         color c = color(colormittel[ii]);
     
187. 
     
188.         red [ii] = (c >> 16) & 0xFF;
     
189.         green [ii] = (c >> 8) & 0xFF;
     
190.         blue [ii] = c & 0xFF;   
     
191.        
     
192.         ii = ii +1;
     
193.     }
194. 
     
195.     println(red + "/" + green + "/" + blue);
196. }