1. PImage img;
2. img = loadImage("image.jpg");
3. img.resize(img.width/8, img.height/8);
4. size(img.width, img.height);
5. image(img, 0, 0);

thanks,

  it just means doing simple resize !?

What if we want to resize the image by averaging the sixty four pixels colour values? What does this mean? 

Is there any idea how to reduce the image size by averaging the sixty four pixels colour values? Please advice. Any idea will help me to understand this query!

So this is homework? I was perplex at your " what does this mean " questions...
The idea is to split the image in several square regions of sides of 8 pixels.
For each region, of total 64 pixels, you average the color (beware: average each channel! There are recent threads on the topic), that would make the color of the destination pixel.
The destination is 64 times smaller (8 times on each side), each of its pixels being computed from the original with this averaging method.

yourimg.loadPixels();

You should also doublecheck what is exactly your homework assignment, because "preserving only the upper left pixel from each block" sounds to me like something different than "averaging the sixty four pixels colour values".

The former is by the way a lot faster and easier, because all you would need is a destination image 8 times as small and then go with big steps through the original image copying only 1/64th of the pixel information (without averaging anything).

Thanks guys,

Yes, actually it is a coursework. And I did a lot research but couldn’t find anything about averaging pixels color. So I did not have any idea what does that mean and still do not know how to do it.

I understand that I should take control over each pixel and pixel’s color one by one. And it has to be done by nested loop. how should I average the pixels color?

 Im not a good programmer yet, so please treat me kindly when the taking is about code 

Yes amnon.owed

they are different ways, and my question now is how to average the 64 pixels of color.

There are actually quite a lot of resources and forum threads on pixel-related topics.

Here is an example that resizes an image based on a factor and averaging pixels colors.

mouseX determines the factor (which is shown next to the mouse cursor). Click the mouse to see the actual size of the resized image. The resizeImage() function starts from the small output image and then for each pixel gets the relevant segment from the original image, which is then averaged via the averageColor() function.

Code Example

1. PImage img = loadImage("http://funnypicturesimages.com/images/image/storm-at-sea-02.jpg");
2. PImage avg;
3.  
4. void setup() {
5.   size(img.width*2, img.height);
6.   textSize(20);
7. }
8.  
9. void draw() {
10.   background(0);
11.   image(img, 0, 0);
12.   int factor = max(1, 1 + mouseX / 20);
13.   avg = resizeImage(img, factor);
14.   if (!mousePressed) { image(avg, width/2, 0, width/2, height); } else { image(avg, width/2, 0); }
15.   text(factor + "", mouseX + 10, mouseY + 10);
16. }
17.  
18. PImage resizeImage(PImage in, int factor) {
19.   PImage out = createImage(in.width/factor, in.height/factor, RGB);
20.   for (int y=0; y<out.height; y++) {
21.     for (int x=0; x<out.width; x++) {
22.       PImage segment = in.get(x*factor, y*factor, factor, factor);
23.       color c = averageColor(segment);
24.       int index = x + y * out.width;
25.       out.pixels[index] = c;
26.     }
27.   }
28.   return out;
29. }
30.  
31. color averageColor(PImage in) {
32.   int r = 0, g = 0, b = 0;
33.   for (int i=0; i<in.pixels.length; i++) {
34.     color c = in.pixels[i];
35.     int rPixel = (c >> 16)&0xff;
36.     int gPixel = (c >> 8)&0xff;
37.     int bPixel = (c)&0xff;
38.     r += rPixel;
39.     g += gPixel;
40.     b += bPixel;
41.   }
42.   r /= in.pixels.length;
43.   g /= in.pixels.length;
44.   b /= in.pixels.length;
45.   return color(r, g, b);
46. }

Thank you very much, I was looking for such an example, I have problem finding processing examples. The name “processing” is not special like other programming languages such as Java Delphi and etc.

 

just to add my two cents worth: what you are trying to do is integer downsampling (as it's not 8.5 times smaller, or 5.3 times smaller but an exact integer amount) and as you said, you can either just take a single pixel or average all the pixels in the 8x8 pixel block. the difference between averaging and picking up just one pixels is the latter will give you aliasing (which is bad). this you should look up on wikipedia as aliasing is not something easily explained, but it's really worth understanding if you work with images. 

Thank you guys for your guides.