I have built, and got working, a polar graphic plotter. The machine uses a processing sketch, which scans from left to right, top to bottom, on an image, (much like an old CRT scans an image). The data is churned out onto an arduino which plots the image.
it currently producesdiamond images: I use Gimp, to manually rotate the image through 135 degrees. The "top left" of the image,  actually becomes the bottom point of the image.



I want to produce "square" not "diamond" images, while maintaining the 45 degree line passes (as a necessity, due to the way the plotter works)

Heres a vid should you be interested!
http://www.youtube.com/watch?feature=player_embedded&v=5SB8V-LM_NM

does anyone have any suggestions for scanning an image at 45 degrees, rather than left to right.

I suppose instead of looping around, adding 1 to x every time, i could add 1 to both X and Y, simultaneously, but would need to keep track of the "edge" of the image, as each pass will be of a different length.
Is there a function for detecting the edge of an image?

suggestions greatly appreciated!
cheers

Ol

Hi there all. I am currently using the following lines of code, to extract greyscale values from pixels in an image:

 color c = get(x, y);
 float greyscalein = brightness(c);

i have moved my project (a plotter, of sorts) onto working colour. therefore i would like to extract colour values instead.

Ideally in CMYK, but i'm sure it could be converted if it is in a different format.
i presume i need to change the "brightness" bit to something else, except what i really want is not to see what hue the pixel is, but rather, on 3 passes, HOW MUCH C, how much M and how much Y is on the pixel

any suggestions?

many thanks

Ol

The code below, does exactly as i want in terms of processing the image, and converting it into a stream of values.
however i want it to
1) wait for an initial "ready" command from the ardunio
2) wait for a "ready" command from the arduino in between each and every number transmission.

the arduino is processing the numbers physically, and therefore takes time.

I have used "300" as my ready command because the sketch is dealing in shades between 0 and 255. I figure it it one less thing to worry about if i dont start chucking ascii in there too.
My "commands" can be 300, 301, 302 etc.

I THINK i have narrowed down the lines which need attention to lines 17 and 33. I pressume i need a "serial Event" void in there? but i am dont know what to do with it. All the tutorials i have read and watched (of which there are many) do different things with it, none of which i understand properly. I presume what is required here depends on the context?

Many thanks

Ol

1. import processing.serial.* ;
2. Serial myPort;
3. int ready = 300; // greyscale is 0-255. decided to use 300+ as commands, to prevent from mixing ascii with numbers.
4. PImage img1;
5. int cellSize = 10; // size of cells into which the image is split, larger size = less cells
6. int squareSize = 300; // size of the working frame
   
7. float greyscale;
8. void setup() {
9.   size(squareSize, squareSize);
10.   println(Serial.list());
11.   String portName = Serial.list()[0];
12.   myPort = new Serial(this, portName, 9600);
13.   print("Port: ");
14.   println(myPort);
15.   myPort.clear();
16.   myPort.read();
17.   myPort.bufferUntil(ready); // ********this is SUPPOSED to wait for a "ready" signal from the arduino (sent on button press) It doesn’t, obviosuy
    
18. }
19. void draw() {
20.   background(0);
21.   img1 = loadImage("grad.jpg"); // image, 300 x 300
22.   imageMode(CENTER);
23.   image(img1, (squareSize/2), (squareSize/2)); // draws the image
24.   for (int y = 0; y < squareSize; y = y + cellSize ) {
25.     // "carrige return" instruction from processing to the arduino will go in here (probably)
26.     for (int x = 0; x < squareSize; x = x + cellSize) {
27.       color c = get(x + cellSize/2, y + cellSize/2);
28.       float greyscale = brightness(c);  // Sets 'greyscale' to 255-0
29.       println(greyscale); //show the greyscale
30.       myPort.write(c);    // send it to the arduino
31.       myPort.clear();     // clear the port
32.       delay (300);        // delay for easy reading
33.       myPort.bufferUntil(ready); // ***** this is SUPPOSED to WAIT until the arduino replies that it is ready.
34.     }
35.   }
36. }
37. void serialEvent (Serial myPort) {
38.   myPort.read(); // ******* Not really sure what is needed here., or if serial Event is needed at all?
39. }

The code is supposed to reference an image, return a greyscale value for a pixel (in this case 5 pixels in and then return the greyscale for the 15th pixel, then 25th, etc)

I havent yet bothered to build the "go to next line" or a "next pixel please" part into my arduino.  I am just trying to get it to provide a series of numbers at present, then i will build on it.
the image (grad.jpg) is currently just a gradation from black to white, not that that matters i suppose

I think the first one (number), gets through (the arduino makes a suitable movement) but then it stops.
i do not get the value for the shade printed on the black box at the base of the processing window, as requested in line 34.

can anyone please tell me how to i make lines 30, through to 35 loop until the end of the image is reached?
I presume I cant just stick them in a loop, as they are already in a serialEvent void?

1. 
   
2. import processing.serial.* ;
3. Serial myPort;
4. boolean firstContact = false;
5. PImage img1;
6. int cellSize = 10; // size of cells into which the image is split, larger size = less cells
7. int squareSize = 300; // size of the image square (double horizontally to allow for processed image)
8. int x = 0;
9. int y = 0;
10. void setup() {
11.   println(Serial.list());
12.   String portName = Serial.list()[0];
13.   myPort = new Serial(this, portName, 9600);  
14.   myPort.bufferUntil('A');// waiting on response from arduino
15.   size(squareSize, squareSize); // frame is 500 x 500
16.   img1 = loadImage("grad.jpg"); //  image, 300 x 300
17.   imageMode(CENTER);
18. }
19. void draw() {
20.   image(img1, 150, 150); // draws the image
21. }
22. void serialEvent(Serial myPort) {
23.   int inByte = myPort.read();
24.   if (firstContact == false) {
25.     if (inByte == 'A') {
26.       myPort.clear();          // clear the serial port buffer
27.       firstContact = true;     // you've had first contact from the microcontroller
28.       myPort.write('A');       // ask for more
29.     }
30.     else {
31.       for (int x = 0; x < squareSize; x = x + cellSize ) {
32.         for (int y = 0; y < squareSize; y = y + cellSize) {
33.           color c = get(x + cellSize/2, y + cellSize/2);
34.           println(c);
35.           myPort.write(c);
36.           }
37.       }
38.     }
39.   }
40. }

Good evening All.

I've literally started playing with processing this evening (2 hours or so) so please excuse me if my questions are REALLY stupid.

I am making a polargraphic plotter using an arduino (the physical arduino side of it i have working fine) and am venturing into the world of processing to process the images i wish to plot, into workable serial data (which i will then push into the arduino, or at least, thats the plan)

Because of the way a polargraphic plotter works, i have decided to rotate the image 45 degrees left, and centre it on a frame bigger than it needs.

this "setup" part of the sketch works fine, and gives the result i want.

I then want to process the image into much larger "pixels", which will then be used to proved lower resolution greyscale data.
i initially tried just to resize the image, but it wasnt very successful, and i want the option of controlling how the pixels are averaged in the future, so i am going for the effect shown in the "get()" tutorial:


I want to scan down the image, which is 300 x 300 px, and fill squares 10 px by 10 px, with the colour of the underlying image (at this time, i am just taking the pixel in the middle of each 10 x 10 square)
When i run the sketch, the image i have loaded loads briefly in the background, but is then overlaid by 30 x 30 squares of flat grey.

can anyone point out what i have done wrong, i am currently bashing at trial and error and not really getting anywhere.

here is my sketch:

1. PImage img1;
2. 
   
3. int x = 0;
4. int y = 0;
5. void setup() {
6.   size(500, 500); // frame is 500 x 500
7.   pushMatrix();
8.   // Make a new instance of a PImage by loading an image file
9.   img1 = loadImage("STRS.jpg"); // stormtrooper image, 300 x 300
10.   translate(250, 250); // moves pivot to keep central
11.   rotate(radians(315)); // rotates 45 degrees ACW
12.   imageMode(CENTER);
13.   image(img1, 0, 0); // draws the image
14. }
15. void draw() {
16.   for (int x = 0; x < 500; x = x + 10 ) {
17.     for (int y = 0; y < 500; y = y + 10) {
18.       color c = get(x + 5, y + 5);
19.       fill(c);
20.       stroke(100); // bounded by a box, dark grey
21.       rect(x, y, x + 10, y + 10);
22.     }
23.   }
24. }

Hope someone can help, and that i haven’t done something embarrassingly stupid.

Thanks

Olly