Structure of Image

Question

using java and jna I call a fonction : trace(potrace_ bitmap_s)

struct potrace_bitmap_s { 
int w, h; 
int dy; /* scanline offset in words */
potrace_word *map; /* pixel data, dy*h words */
};
typedef struct potrace_bitmap_s potrace_bitmap_t;

w, h: are width and height of a bitmap

in doc of library a found this

Here, potrace_word is an unsigned integer type defined in potracelib.h. It is usually equal to a native machine word (i.e., 32 bits on a 32-bit architecture). In the following explanation, we assume that the type potrace_word holds N bits.

A bitmap of dimensions w*h is divided, bottom to top, into h horizontal scanlines. Each scanline is divided, left to right, into blocks of N pixels. Each such block of N pixels is stored as a single potrace_word, with the leftmost pixels of the block corresponding to the most significant bit of the word, and the rightmost pixel of the block corresponding to the least significant bit of the word. Pixels that are “on” (or “black” or “foreground”) are represented by bit value 1. Pixels that are “off” (of “white” or “background”) are represented by bit value 0. If the number of bits in a scanline is not divisible by N, then the rightmost word of the scanline is padded on the right with zeros. The data for scanline 0 (the bottom-most scanline) begins at map[0]. The data for scanline 1 begins at map[dy]. The data for scanline 2 begins at map[2*dy], and so forth. Note that dy can be either positive or negative, depending on how an application wishes to lay out the image data in memory.

but I not understood how I can represente in java map.

public class Potrace_bitmap_t extends Structure{
    int w, h; /* width and height, in pixels */
    int dy; /* scanline offset in words */
    map ??; /* pixel data, dy*h words */
}

Answer 1

This is a pretty standard way of storing a 2 color image, like what you get from a fax-encoded tiff. The "map" is supposed to be an array of unsigned 32 bit integers. I don't think Java lets you declare uint32, but it doesn't really matter in this case, since all you care about is the bits.

Declare "Map" as an array of integers. To make this into an image, you can examine the bits in the array one at a time. If bit 0 (I am assuming an Intel machine) of the first int in the array is a "1", then the pixel in the lower left corner of the image should be set to black. If it is a "0", set that pixel to white. Each int will give you 32 pixels. If the width of the image is not divisible by 32, you will need to skip ahead. This is what "map[2*dy]" is telling you.

So, if the image width is 55 for example, you set 32 pixels with map[0], then set 23 pixels with map[1], then begin with the next line of the image (the one next to the bottom) at the first bit of map[2]. (dy for an image 55 pixels wide would be 2, assuming 32 bit integers)

Do this in a loop, bottom of the image to the height value.