Image representation methods. Bitmap graphic method of a black-and-white image.
-
Upload
lizbeth-copeland -
Category
Documents
-
view
227 -
download
1
Transcript of Image representation methods. Bitmap graphic method of a black-and-white image.
Image representation methods
Bitmap graphic method of a black-and-white image
Representation of color pixels
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)
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.
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.
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.
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
PPM file structure
A ppm file consists of two components:– ppm header– packed image data
PPM file structure
Example of a .ppm header for a color imageP6# This is a comment600 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.
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.
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
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 comment1024 814# So is this255
Items of useful information in this header include:P - this is a .ppm file5 - this is a .ppm file containing a grayscale PGM
(as opposed to color “P6”) image1024 - the number of columns of pixels in each row
of the image814 - the number of rows of pixels in the image255 - the maximum brightness value for a pixel
Processing Heterogeneous Input Files
Comment linesLines 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 255Or they could be specified as follows:P5 1024 814 255
Or they could be specified as follows:P5#1024# This is a comment814 255
Processing Heterogeneous Input Files
Unfortunately life is rarely nice and simple and this program won't work if the .ppm header looks likeP6# comment768# another
Reading .ppm headers with fgets() and sscanf()
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()
So if the .ppm header is nice and simple like:P6 768 1024 255the 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 */2021 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()
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 <stdio.h>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);
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;}
Building a .ppm file
/* create the ppm imagevoid 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; }}
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);}
The .ppm fileYou 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
The image
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
*/
Example 2
#include <stdio.h> #include <stdlib.h> #include <assert.h> #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 */
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);
}
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++; } }
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
The image