When the button is pushed on the form, the project uses an OpenPictureDialog to select the grey scale bitmap. No error checking is incorporated in the code to make sure that the bitmap is in fact 8 bits and grey scale, and while the code will output results if the bitmap is incorrect, the results will be meaningless. Next both the bitmap and the HistCount array are passed to the histogram summing function which simply loops through the bitmap and counts the number of bytes at each intensity level by incrementing the array position corresponding to that intensity level as described above. Next, in order to display the Histogram as a bitmap the array is passed to a procedure named Histogram100. This routine expresses each total in the area as a percentage of the maximum value found so that when the Histogram graph is drawn each point lies between 0 and 100 on the bitmap. For example if 5000 was the maximum count for a certain intensity value, and another point had the count 2500, since 2500 is 50 percent of 5000 the histogram would plot the point 50 on the bitmap for the value 2500 in the histogram array. Note that the array is passed by reference (using the var keyword) so the actual values in the array are overwritten by the percentage value calculated before being passed to the graphing routine. The graphing routine uses standard pen plotting and line drawing functions of the Canvas to plot lines between each point on the Histogram based on the values in the array.
The C++ code from which the Delphi Histogram function was translated is below...For Delphi programmers unfamiliar with C++ this will look very enigmatic (everything is discussed on the C++ pages linked to on the index page below).
void Histogram(struct Image *IMAGE, int HISTCOUNT[])
{
int x, y, i, j;
for (i=0;i<=255;i++) HISTCOUNT[i] = 0;
for (y=0; y<IMAGE->Rows; y++)
{
for (x=0; x<IMAGE->Cols; x++)
{
j = *(IMAGE->Data+x+(long)y*IMAGE->Cols);
HISTCOUNT[j] = HISTCOUNT[j]+1;
}
}
}
The first line of code (the function header) refers to a structure (struct) which is an image and then declares a pointer to such an image structure, followed by the actual Histogram array being passed as a parameter to the function. This image declaration might be replaced in a Windows enviroment by HBITMAP, another kind of structure pointing to an image, in this case a standard bitmap. In Delphi a bitmap is simply declared as Bitmap : TBitmap which replaces the struct declaration in the C++ header.
Next the variables are declared as type 'integer' ('int' in C++) and you will notice that the declaration is backwards compared to what you are used to in Delphi. Next follows a for loop couting from 0 to 255 which simply zeros out each element in the Histogram array to prepare the array to do the count of the bytes in the bitmap. (See the page on C++ loops on the C++ index page).
This is followed by another loop where we actually being to loop through the bytes in the bitmap. Now in memory a bitmap is actually like a long string of bytes, but it is displayed as a two dimensional matrix. The height lies along the y axis and the width along the x axis. To loop through each byte in the bitmap we begin with a y loop from 0 to the height of the bitmap, and then on each hozizontal row, we do an x loop to extract each individual byte on that line. The actual address of the byte can be calculated as a linear value (the way it actually is in memory, by multiplying y (the height, which is indexed from zero) by the width of each row and then adding the value of x (also indexed by zero).
For example suppose that below we have the bytes in the bitmap. The base address of the bitmap is 1000. The offset is added onto this base address to get the address of each byte, and in the two dimensional matrix below these linear addresses are displayed as a matrix...
0 1 2 3
4 5 6 7
8 9
We want to find the actual address of byte 9. The base address is 1000. The length of the rows is 4. In the above example the first row is y = 0. For the byte numbered zero x (the horizontal position) has the value zero. (Remember that the indexes are zero based. To find the actual address of the byte numbered 9 we take 1000, the base address, and add on (y * 4) + x, which in this example gives us (2 * 4) + 1 which is equal to 9, so then the actual linear address of byte 9 is 1000 + 9 or 1009. (Byte 0 is equivalent to the base address 1000).
The Image structure in this C++ code has a field called 'rows' and so to loop through the rows in the bitmap from top to bottom the y loop begins at zero and counts up to Rows, incrementing y by 1 each time through the loop. At each line the x loop will then go one by one horizontally accross the line (and both x and y will be combined as described above to extract the actual linear address of each byte). The for loop appears as ' for (y=0; y<IMAGE->Rows; y++) '. IMAGE is a pointer to the bitmap data and the operator ' -> ' is the dereference operator and extracts the value for rows from within the image structure. (See the page on C++ pointers).
What follows is probably the most enigmatic line of code for Delphi programmers unfamiliar with C++. ' j = *(IMAGE->Data+x+(long)y*IMAGE->Cols); '. What we want to find out is what the value of the byte is at such and such an address (using y and x to determine the actual linear address). When we find out the byte contained at that address then, in the next line of code, we want to increment the value at that array position by one. J will hold the value of this byte and is used in the next line of code to index the array. Image->Data refers to the zero element of the bitmap (the first byte). We add x to this value and then we add y * Column width and we have the actual address of the byte. The keyword (long) is found wrapped in parentheses before the variable y and this means cast 'y' to a long. (Whenever you see a variable type in brackets before an instance of a variable it is a cast declaration. Assume b is a byte and we see (int)b - this means cast the byte b as an integer for the purposes of whatever calculation is taking place.) However what we have is an address, not the actual byte, a pointer to the byte in effect. So you see the whole equation is wrapped in parentheses and is preceded by an asterik which means 'dereference this pointer'. (See the page on pointers...) Therefore once the address is found the byte value it contains (points to) is stored in the variable j which is then used to index and increment the value contained in the array. To use the example matrix above, assume that byte 9 contained the value 126. The actual address of the byte would be calculated as 1009 and then this pointer would be dereferenced and the value it contains (126) would be assigned to j. Then position 126 in the array would be incremented by one, and the loops would continue.
This highlights one difference between C++ and Pascal. In the code example above an integer (type 'long' ) was the result of a mathematical calculation and then this integer was treated as a pointer and dereferenced to place a value in j. This is possible because C is loosely typed, not strongly like typed as Delphi is. You cannot dereference and integer directly in Delphi, nor can you assign an integer to a pointer (using a cast as in the C++ example above). However you can mimic this by using the function PTR which accepts an integer as an argument and returns a pointer. So assuming you have a pointer to a byte (we will call it 'pb') you could pass the results of the calculation above to the PTR function and it would pass the integer which resulted to the pointer without generating one of those 'type mismatch' compiler errors. You could continue to do manipulations of the integer, passing the result back to the pointer (as a substitute, for example, for using a 'pbytearray' to access a bitmap, as in the code sample below). So then what we would have would be pb := ptr(integer); where pb is a pointer and integer is either an integer or the result of some function returning an integer, which produces results similar to what you see happening in the C++ code above. Delphi would then require an additional step, that of dereferencing the pointer ( j := pb^; ) which would be dereferencing whatever address the integer represented and passing its contents to j. Using 'PTR' instead of pbytearray would allow a more direct translation of the C++ code segment, with the disadvantage in Delphi being that you would need two variables, one the integer which will be manipulated and one the pointer which will be dereferenced, since Delphi is strongly typed. The PTR function seems to be a way of doing an end run around the strict type checking of the compiler since all the function is going to do is go behind the compiler's back and place the integer value into the pointer location. You can also mimic C++ variable casting (casting a byte as an integer, for example) by using the 'Variant' variable, which does the same thing. Variants are not native to Pascal, but were introduced to mimic the loose type casting of languages like C++. A real Pascal purist would hate variants, since they violate the principle of strong type casting and checking done by the compiler, but even a purist couldn't find fault with the PTR function, since something like this is required, since the type casting in Delphi makes pointer use less flexible than in C++. However the disadvantage of a loose language like C++ is that you will really need to keep up on all those security patches, in particular due to those buffer over runs, not to mention all those bug patches. A strongly typed language is inherently more secure, and while fans of C++ constantly point out as its principle benefit that it is so loosely typed, and thus more flexible, this also makes the language less secure, and while one could argue that code can be as secure as a programmer wants to make it, people just aren't that good at considering every single possibility, as all those patches on C++ code testify, and making it secure makes great demands on programmers. You can also add onto this the fact that C++ is based on obsolete forty year old technology (although Pascal is just about as old) and consider the fact that Pascal was written as a response to the often unintelligible syntax of C, and there are other advantages to Delphi as well (a C++ programmer could probably read and decipher a program written in Delphi while a Delphi programmer would find a first encounter with C++ to be enigmatic and obscure, because C++ is enigmatic and obscure. Modern languages are not like this.) But I digress...
Now that we know what this C++ code does, we can translate it into Delphi, and the result is shown below...
procedure TForm1.Histogram(var Bitmap : TBitmap;
var Histcount : array of integer);
var
x, y, i, j : integer;
pb : pbytearray;
begin
For i := 0 to 255 do begin
HistCount[i] := 0;
end;
for y := 0 to Bitmap.height - 1 do begin
pb := Bitmap.scanline[y]; {get the base address for this row}
for x := 0 to Bitmap.width - 1 do begin {scan byte by byte horizontally}
j := pb[x];
{next Increment the pixel count in the histogram for this
pixel intensity, using j, the byte value as the index into
the array}
inc(HistCount[j]);
end;
end;
end;
In the above example an extra variable is declared in the Delphi version, a pointer to a byte array (pb : pbytearray}. On each turn through the y loop (the beginning of each new line in the virtual matrix) pb is set equal to the base address for that line. X is then indexed from zero and used to access the bytes accross that line one at a time (by adding x to the base address represented by 'pb' the pointer to the byte array). It is possible to access the bitmap using a pointer as well, as in the C++ code, and then dereferencing the pointer to get the byte value, but in this example I have stuck with the typical 'pbytearray' since it is what most people are familiar with...
