Using LIbTiff to convert a monochrome tiff to 1 bit bitmap

Ok no worries. I am not familliar with the LibTiff data, but I assume the 24 bit pixel data is either one of the two 24 Bit formats

24 Bit RGB [8-8-8] Big Endian
16 Bit RGB + Alpha RGBA [5-6-5-8] Big Endian

Being as there is no TIFFGetA call in your snippet, I am going to assume the format is RGB Big endian 24 bit, please correct me if this is not the case.

For simplicities sake, I would start off with a boolean array for the bitmap data (can cover packing later on)

that is:

bool *data = (bool*) new bool[Width * Height]; // assuming width and height are valid

I am going to use "pix" to represent a 32 bit integer which will hold the TIFF pixel data (as I do not know exactly how it comes from the file, you should be able to translate this into your code)

that is:

unsigned __int32 pix; // or just int as long as your compiler treats it as four bytes long

in the pix variable the data should be stored as follows (remember I have assumed big endian, you will need to correct me if i am wrong)

0xABGR < Note that even though you aren't using the alpha channel, there will still be *something* stored there, even if it is junk

Bits 0-7 Alpha, (probably 0xFF for your 24 bit pixel data), [extraction: pix & 0xFF]
Bits 8-15 Blue,             [extraction: (pix >> 8) & 0xFF]
Bits 16-23 Green,       [extraction: (pix >> 16) & 0xFF]
Bits 24-31 Red,           [extraction: (pix >> 24) & 0xFF]

The first order of business is to check for *any* colour in the current TIFF pixel, to assign a "1" to the bitmap data and "0" if there is no colour data (all zero). You can tune this how you like to pick out transparent colour keying, or for using black as a transparent colour.

ie:

if( ((pix >> 8) & 0xFF) || /* NOTE: I ignored the alpha for your case, as it is unused */
    ((pix >> 16) & 0xFF) ||
    ((pix >> 24) & 0xFF))
{
   // put a 1 in the array ie data[some index] = 1
}
else
{
   // put a 0 in the array ie data[some index] = 0
}

Then you need to pack the bool array into a byte array to pass it to either CreateBitmap or any other creation function, as very few (if any) will accept boolean arrays

Pseudocode:

Loop Index through array in 8s

   Current byte = 0

   Loop n from 0 to 7
       Current byte &= byte(data[index + n]) << n
   Next n

Next Index

The inner loop of that algorithm effectively does this:

Assuming the next 8 pixels are 1, 1, 0, 0, 1, 0, 1, 0

n       Current Byte      data [...]       byte(data[...])   shifted by n          ANDed

0         00000000             1               00000001      00000001           00000001
1         00000001             1               00000001      00000010           00000011
2         00000011             0               00000000      00000000           00000011
3         00000011             0               00000000      00000000           00000011
4         00000011             1               00000001      00010000           00010011
5         00010011             0               00000000      00000000           00010011
6         00010011             1               00000001      01000000           01010011
7         01010011             0               00000000      00000000           01010011


That alrogithm will pack the booleans together in groups of 8, this should then leave you with an array of bytes with which to build a bitmap. I'll leave it up to you to work out the rest (left over bits, different pixel formats etc...)

Don't forget to delete any temporary memory usage before you return and let me know how you get on.

Excuse the ASCII