1. Image representation methods

2. Bitmap graphic method of a black-and-white image

3. Representation of color pixels

4. Representation of image data Images (e.g. digital photos) consist of a rectanglular array of discrete picture elements called pixels. An image consisting of 200 pixels rows of 300 pixels per row contains 200 x 300 = 60,000 individual pixels. The Portable PixMap (.ppm) format is a particularly simple way used to encode a rectangular image (picture) as an uncompressed data file. The.ppm file can be viewed with a number of tools, including xv and gimp. Other well-known image formats include JPEG (.jpg), TIFF (.tif), and PNG (.png)

5. Types of Images We will use.ppm files to represent two types of images A.ppm image file contains the representation of an image (like a.jpg or.gif file) and can be in one of several different formats for an image. The PPM (Portable PixMap) format is used to represent images that contain color. A PGM (Portable GrayMap) format is used for grayscale images. The format of the file can be determined by the first two bytes. The code “P5” indicates that this is a PGM file, the code “P6” indicates this is a PPM file.

6. Types of Images Grayscale images – correspond to black / white photographs – each pixel consists of 1 byte which should be represented as unsigned char – a value of 0 is solid black – a value of 255 is bright white – intermediate are "gray" values of increasing brightness.

7. Types of Images Color images – correspond to color photographs – each pixel consists of 3 bytes with each byte represented as an unsigned char – this format is called RGB. three bytes represent the red component green component blue component – when red == green == blue a grayscale "color" is produced. – (255, 255, 255) is bright white.

8. Images Colors are additive (255, 255, 0) = red + green = bright yellow (255, 0, 255) = red + blue = magenta (purple) (0, 255, 255) = green + blue = cyan (turquoise) (255, 255, 255) = red + green + blue = white

9. PPM file structure A ppm file consists of two components: – ppm header – packed image data

10. PPM file structure Example of a.ppm header for a color image P6 # This is a comment 600 400 255 – The P6 indicates this is a color image (P5 means grayscale) – The width of the image is 600 pixels – The height of the image is 400 pixels – The 255 is the maximum value of a pixel – Following the 255 is a \n (0x0a) character.

11. PPM file structure The image data – The red component of the upper left pixel must immediately follow the new line. – For the image described earlier, there must be a total of 3 x 600 x 400 = 72,000 bytes of data.

12. As we have seen, the header of a.ppm file contains mixed input data. While scanf() provides a handy way to process input files consisting of only numeric data, the handling of mixed input can be more difficult. Processing Heterogeneous Input Files

13. The following is an example of the header for a PGM file: P5 # CREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) # This is another comment 1024 814 # So is this 255 Items of useful information in this header include: P - this is a.ppm file 5 - this is a.ppm file containing a grayscale PGM (as opposed to color “P6”) image 1024 - the number of columns of pixels in each row of the image 814 - the number of rows of pixels in the image 255 - the maximum brightness value for a pixel Processing Heterogeneous Input Files

14. Comment lines Lines beginning with # are comments. Any number (including 0) of comment lines may be present. It is possible for all the useful values to appear on one line: P5 1024 814 255 Or they could be specified as follows: P5 1024 814 255 Or they could be specified as follows: P5 # 1024 # This is a comment 814 255 Processing Heterogeneous Input Files

15. Unfortunately life is rarely nice and simple and this program won't work if the.ppm header looks like P6 # comment 768 # another Reading.ppm headers with fgets() and sscanf()

16. Because of the arbitrary location and number of comment lines there is no good way to read the data using scanf(). A better approach is to use a combination of fgets() and the sscanf() function. The sscanf() function operates in a manner similar to fscanf() but instead of consuming data from a file it will consume data from a memory resident buffer. Like fscanf() it returns the number of items it successfully consumed from the buffer. Reading.ppm headers with fgets() and sscanf()

17. So if the.ppm header is nice and simple like: P6 768 1024 255 the following program would suffice to read it: 13 int main() 14 { 15 char id[3] = {0, 0, 0}; /* Will hold P5 or P6*/ 16 long vals[5]; /* The 3 ints */ 17 int count = 0; /* # of vals so far */ 19 char *buf = malloc(256); /* the line buffer */ 20 21 fgets(buf, 256, stdin); 22 id[0] = buf[0]; 23 id[1] = buf[1]; 24 count = sscanf(buf + 2, “%d %d %d”, 25 &vals[0], &vals[1], &vals[2]); 27 printf(“Got %d vals \n”, count); 28 printf(“%4d %4d %4d\n”, vals[0], vals[1],vals[2]); 29 } Reading.ppm headers with fgets() and sscanf()

18. Buliding a.ppm file / * image1.c */ /* Construct a solid color image of the specified color */ /* Input arguments */ /* width in pixels */ /* height in pixels */ /* red value */ /* green value */ /* blue value */ #include void make_ppm_header(int width, int len); void make_pixel (unsigned char r, unsigned char g, unsigned char b); void make_ppm_image(int width, int height, unsigned char r, unsigned char g, unsigned char b);

19. Buliding a.ppm file int main() { int width; int height; int count = 0; unsigned int red; unsigned int green; unsigned int blue; fscanf(stdin, "%d", &width); fscanf(stdin, "%d", &height); fscanf(stdin, "%d", &red); fscanf(stdin, "%d", &green); fscanf(stdin, "%d", &blue); make_ppm_header(width, height); make_ppm_image(width, height, red, green, blue); return 0; }

20. Building a.ppm file /* create the ppm image void make_ppm_image(int width, int height, unsigned char r, unsigned char g, unsigned char b) { int count = 0; int size = width * height; while (count < size) { make_pixel(r, g, b); count = count + 1; }

21. Buliding a.ppm file /* print void make_pixel(int r, int g, int b) { fprintf(stdout, “%c%c%c”, r, g, b); } /* print the ppm header */ void make_ppm_header(int width, int height) { fprintf(stdout, “P6\n”)’ fprintf(stdout, “%d %d %d\n”, width, height, 255); }

22. The.ppm file You can view the details of the file with the ls -l command. rlowe@joey7[102] ls -l pic1.ppm -rw------- 1 rlowe faculty 90015 Sep 14 20:35 pic1.ppm Note: size of file is 90015 15 (header length) 3 x 200 x 150 = 90000 (image data) 90015

23. The image

24. Example 2 /* CPSC 2100: redgreen.c This program creates a ppm file for a 600x400 box, that is red in the left half and green in the right half. The ppm image is written to the file specified on the command line, e.g. the program is initiated as:./redgreen output-filename which would create the PPM image file specified by output-filename */

25. Example 2 #include #include "rgb.h" int main(int argc, char *argv[]) { pixel_t *img; /* image array */ pixel_t *pixaddr = NULL; /* address of current pixel */ int rowNdx, colNdx; /* Row and column indices */ FILE *imageFP; /* PPM output file */

26. Example 2 /* Open the PPM output file */ if (argc != 2) { fprintf(stderr, "Usage:./redgreen output-filename\n"); exit(1); } imageFP = fopen(argv[1], "w"); assert(imageFP != NULL); img = (pixel_t *) malloc(sizeof(pixel_t) * 600 * 400); if(img == NULL) { fprintf(stderr, "Could not malloc memory for img. Exiting\n"); exit(2); }

27. Example 2 pixaddr = img; /* Write the ppm header */ fprintf(imageFP, "P6 600 400 255\n"); /* Write the pixel data */ for (rowNdx = 0; rowNdx < 400; rowNdx++) { for (colNdx = 0; colNdx < 600; colNdx++) { pixaddr->blue = 0; /* No blue in image */ if (colNdx < 300 ) { /* Left half of image */ pixaddr->red = 255; pixaddr->green = 0; } else { /* Right half of image */ pixaddr->red = 0; pixaddr->green = 255; } pixaddr++; }

28. Example 2 /* Write out the pixel */ fwrite(img, sizeof(pixel_t), 600 * 400, imageFP); /* release allocated memory */ free(img); return 0; } The code produces the following red-green image

29. The image