Bee Eee Blog

Here is a little nice bit of code to get text to jump out at you no matter what the background.  Outlined text is especially useful when putting text on an image and don’t have control of the background contrast. Basically it draws a black boarder with a while fill.

// prepare to draw text

StringFormat sf = new StringFormat();

sf.Alignment = StringAlignment.Center;

sf.LineAlignment = StringAlignment.Center;// draw the text to a path

System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();

path.AddString(text, Font.FontFamily, 0, 14.0f, fillRect, sf);

// fill in the outline

g.FillPath(Brushes.White, path);

// draw the outline

g.DrawPath(new Pen(Color.Black,2.0f) , path);

public static ImageArray LoadTiff(String Image_Path)
{
    ImageArray arr = null;
    unsafe
    {
        UInt32 w = 0;
        UInt32 h = 0;
        uint samples = 3;
        uint bits = 8;
        int i, j, ptr, lptr;

        int tif = TIFFOpen(Image_Path, "r");

        if (0 != tif)
        {
            TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, ref w);
            TIFFGetField(tif, TIFFTAG_IMAGELENGTH, ref h);
            TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, ref bits);
            TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, ref samples);
            arr = new ImageArray((int)w, (int)h);

            // make sure we get all of the data.
            if (bits == 16)
            {
                UInt32 size = w;
                ushort* raster = (ushort *)_TIFFmalloc((uint)(size * sizeof(ushort) * samples));
                // read in all of the lines
                for (j = 0; j < h; j++)
                {
                    TIFFReadScanline(tif, (byte *)raster, j, 0);
                    // copy line into data
                    for (i = 0, ptr=0; i < w; i++, ptr+=(int)samples)
                    {
                        if (samples == 3)
                        {
                            arr.Data[i + j * w].SetPixel(raster[i], raster[i + 1], raster[i + 2]);
                        }
                        else
                        {
                            ushort val = raster[i + samples - 1];
                            arr.Data[i + j * w].SetPixel(val,val,val);
                        }
                    }
                }

                _TIFFfree((byte *)raster);
            }
            else
            {
                // anything beside 16 bit
                UInt32 size = h * w;
                byte *raster = _TIFFmalloc( size );
                int val = TIFFReadRGBAImage(tif, w, h, raster, 0);
                // copy image data into a bitmap
                if (val != 0)
                {
                    for (j = 0, ptr = 0, lptr=0; j < h; j++)
                    {
                        for (i = 0; i < w; i++, ptr+=4, ptr++)
                        {
                            arr.Data[ptr].SetPixel((ushort)raster[lptr], (ushort)raster[lptr + 1], (ushort)raster[lptr + 2]);
                        } // for i
                    } // for j
                } // if val

                _TIFFfree(raster);
            }
            TIFFClose(tif);
        } // if tif
    } // unsafe

    return arr;
}

Tiff files are interesting.  They are like the all inclusive file format.  It is an extremely flexible file format that allows for many types of pixel formats that other image formats couldn’t possibly handle.  For instance 16 bits per channel or sample in the Tiff lingo.  Event the possibility of 4 or 5 samples per pixel.  If you wanted you could have a Red, Green, Blue, IR, Alpha channel.  Although software would have a difficult time displaying the image.  Anyway I digress — tiff being somewhat flexible is also some what difficult to manage, this is where libtiff comes in handy.  It handles most of this for us.

The first step is to add using System.Runtime.InteropServices; to you module. Then add the stubs for the libtiff functions as follows:

    static class TiffHandler
    {
        [DllImport("libtiff3.dll")]
        private static extern int TIFFOpen(String image_path, String opts);
        [DllImport("libtiff3.dll")]
        private static extern void TIFFClose(int handle);
        [DllImport("libtiff3.dll")]
        private static extern void TIFFGetField(int handle, uint property, ref UInt32 value );
        [DllImport("libtiff3.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        private static extern int TIFFSetField(int handle, uint property, uint value);
        [DllImport("libtiff3.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
        private static extern int TIFFSetField(int handle, uint property, string value);
        [DllImport("libtiff3.dll")]
        private unsafe static extern int TIFFReadRGBAImage(int handle, UInt32 width, UInt32 height, byte *raster, int Unkown);
        [DllImport("libtiff3.dll")]
        private unsafe static extern int TIFFReadEncodedStrip(int handle, int strip, byte* buf, int size);
        [DllImport("libtiff3.dll")]
        private unsafe static extern byte* _TIFFmalloc(UInt32 size);
        [DllImport("libtiff3.dll")]
        private unsafe static extern void _TIFFfree(byte* pointer);
        [DllImport("libtiff3.dll")]
        private unsafe static extern void TIFFWriteEncodedStrip(int handle, int offset, byte* buffer, int size);
        [DllImport("libtiff3.dll")]
        private static extern uint TIFFScanlineSize(int handle);
        [DllImport("libtiff3.dll")]
        private static extern int TIFFDefaultStripSize(int handle, int size);
        [DllImport("libtiff3.dll")]
        private unsafe static extern int TIFFWriteScanline(int handle, byte* buffer, int row, int sample);
        [DllImport("libtiff3.dll")]
        private unsafe static extern int TIFFReadScanline(int handle, byte* data, int row, int sample);

Next we add the constants. I’m not going to add them all there are thousands of them but here is an example of the ones that are used in writting a tiff. If you want more look in the libtiff header files. It seems like it’s in tiff.h

        const uint TIFFTAG_IMAGEWIDTH = 256;	/* image width in pixels */
        const uint TIFFTAG_IMAGELENGTH	= 257;	/* image height in pixels */
        const uint TIFFTAG_BITSPERSAMPLE = 258;	/* bits per channel (sample) */
        const uint TIFFTAG_SAMPLESPERPIXEL = 277;	/* samples per pixel */
        const uint TIFFTAG_COMPRESSION	= 259;	/* data compression technique */
        const uint COMPRESSION_DEFLATE	= 32946;	/* Deflate compression */
        const uint PHOTOMETRIC_RGB = 2;	/* RGB color model */
        const uint TIFFTAG_PLANARCONFIG = 284;	/* storage organization */
        const uint PLANARCONFIG_CONTIG	= 1;	/* single image plane */

And then the code to write out the image to a file:

        public static unsafe void SaveTiff(string fileName, ImageArray array)
        {
            int tif = TIFFOpen(fileName, "w");
            int Samples = 3;

            TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, (uint)array.Width);
            TIFFSetField(tif, TIFFTAG_IMAGELENGTH, (uint)array.Height);
            TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
            TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
            TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
            TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 16);
            TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, (uint)Samples);
            TIFFSetField(tif, TIFFTAG_ARTIST, "Bee Eee Inventions, LLC");

            int cnt = array.Width * array.Height;
            int size = (cnt * Samples * sizeof(ushort));
            ushort* buffer;

            buffer = (ushort*)_TIFFmalloc((uint)size);

            // We set the strip size of the file to be size of one row of pixels
            //int RowSize = TIFFDefaultStripSize(tif, array.Width*3);

            // copy data into buffer
            int i,pos,ptr=0;
            for (i = 0, pos = 0; i < cnt; i++, pos += Samples, ptr++)
            {
                buffer[pos] =  (ushort)(array.Data[ptr].r);
                buffer[pos + 1] = (ushort)(array.Data[ptr].g);
                buffer[pos + 2] = (ushort)(array.Data[ptr].b);
            }

            // Write the information to the file
            TIFFWriteEncodedStrip(tif, 0, (byte *)buffer, size);

            TIFFClose(tif);

            _TIFFfree((byte *)buffer);
        }

Enjoy. Next article I’ll show you how to read some tiff files. Opening all tiff files could be difficult. :)

“…Oh how beautiful upon the mountains are the feet of him that bringeth good tiding, that is the founder of peace, yea, even the Lord, who has redeemed his people; yea, him who has granted salvation unto his people…” Mosiah 15:18

“…being filled with compassion towards the children of men; standing betwixt [me] and justice; having broken the bands of death, taken upon himself [my] iniquity and [my] transgressions, having redeemed [me], and satisfied the demands of justice.” – Mosiah 15:9

He lives.  I testify of it.  I’ve felt His heavenward pull, His encouragement all my days!  I stand as a witness of Jesus Christ and of his love.  Follow where He leads for He only leads to happiness.  Beginning steps may be painful, but  always, always, his ways lead to happiness.