Displaying 16-bit Images Using C#

Member 12116984 wrote:

where in the program row is being displayed as an image?

This is not the best code I write, but parts of it are working, and power will be shut down at my place in 10 minutes

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace ImageDraw
{
    public class DirectoryEntry
    {
        public ushort tag;
        public ushort type;
        public uint count;
        public uint valueOfOffset;
    }

    public class IFD
    {
        // tags
        //int NEW_SUBFILE_TYPE = 254;
        const ushort IMAGE_WIDTH = 256;
        const ushort IMAGE_LENGTH = 257;
        const ushort BITS_PER_SAMPLE = 258;
        //int COMPRESSION = 259;
        const ushort PHOTO_INTERP = 262;
        const int IMAGE_DESCRIPTION = 270;
        const ushort STRIP_OFFSETS = 273;
        //int ORIENTATION = 274;
        const ushort SAMPLES_PER_PIXEL = 277;
        const ushort ROWS_PER_STRIP = 278;
        const ushort STRIP_BYTE_COUNT = 279;
        //int X_RESOLUTION = 282;
        //int Y_RESOLUTION = 283;
        //int PLANAR_CONFIGURATION = 284;
        //int RESOLUTION_UNIT = 296;
        //int SOFTWARE = 305;
        //int DATE_TIME = 306;
        //int ARTEST = 315;
        //int HOST_COMPUTER = 316;
        //int PREDICTOR = 317;
        //int COLOR_MAP = 320;
        //int TILE_WIDTH = 322;
        //int SAMPLE_FORMAT = 339;
        //int JPEG_TABLES = 347;
        //int METAMORPH1 = 33628;
        //int METAMORPH2 = 33629;
        //int IPLAB = 34122;
        //int NIH_IMAGE_HDR = 43314;
        //int META_DATA_BYTE_COUNTS = 50838; // private tag registered with Adobe
        //int META_DATA = 50839; // private tag registered with Adobe
        
        ushort numberOfEntries;
        List<DirectoryEntry> listEntries;
        BinaryReader bReader;
        TiffDecoder tiffDec;
        List<uint> stripOffsets;
        List<uint> stripByteCounts;

        uint width;
        uint height;
        public uint samplesPerPixel;
        public uint bitsPerSample;
        uint rowsPerStrip;
        public uint photometricInterpretation;

        public List<byte> Pixels8 { get; set; }
        public List<byte> Pixels24 { get; set; } // 8 bits bit depth, 3 samples per pixel
        public List<ushort> Pixels16 { get; set; }
        public List<int> Pixels16Int { get; set; }

        public IFD(BinaryReader br, TiffDecoder tiff)
        {
            bReader = br;
            numberOfEntries = 0;
            tiffDec = tiff;
            listEntries = new List<DirectoryEntry>();
            stripOffsets = new List<uint>();
            stripByteCounts = new List<uint>();
            Pixels16 = new List<ushort>();
        }

        public void ReadIfdAndPixelData() 
        {
            numberOfEntries = bReader.ReadUInt16();
            listEntries.Capacity = numberOfEntries;
            ReadDirectoryEntries();
            InterpretDirectoryEntries();
            ReadPixelData();

            if (samplesPerPixel == 1 && bitsPerSample == 16)
            {
                tiffDec.Pixels16 = Pixels16;

                // Write pixel data to a raw file
                BinaryWriter bw = new 
                    BinaryWriter(new FileStream("C:\\Junk\\rawFile.raw", FileMode.Create));
                for (int i = 0; i < Pixels16.Count; ++i)
                {
                    bw.Write(Pixels16[i]);
                }
                bw.Close();
            }
            else
            {
                // TODO
            }
        }

        DirectoryEntry ReadNextDirectoryEntry()
        {
            DirectoryEntry de = new DirectoryEntry();
            de.tag = bReader.ReadUInt16();
            de.type = bReader.ReadUInt16();
            de.count = bReader.ReadUInt32();
            de.valueOfOffset = bReader.ReadUInt32();
            return de;
        }

        void ReadDirectoryEntries() {
            for (int i = 0; i < numberOfEntries; ++i) {
                DirectoryEntry de = ReadNextDirectoryEntry();
                listEntries.Add(de);
            }
        }

        void PopulateStripOffsets(DirectoryEntry de)
        {
            bReader.BaseStream.Seek(de.valueOfOffset, SeekOrigin.Begin);

            for (int i = 0; i < de.count; ++i)
            {
                uint offset = bReader.ReadUInt32();
                stripOffsets.Add(offset);
            }
        }

        void PopulateStripByteCounts(DirectoryEntry de)
        {
            bReader.BaseStream.Seek(de.valueOfOffset, SeekOrigin.Begin);

            for (int i = 0; i < de.count; ++i)
            {
                uint count = bReader.ReadUInt32();
                stripByteCounts.Add(count);
            }
        }

        void InterpretDirectoryEntries()
        {
            for (int i = 0; i < numberOfEntries; ++i) {
                InterpretDirectoryEntry(listEntries[i]);
            }
        }

        void ReadPixelData()
        {            
            double stripsPerImage = Math.Floor((height + rowsPerStrip - 1.0)/rowsPerStrip);
            uint lastStripNumberOfRows = (uint)(height - rowsPerStrip * ((int)(stripsPerImage) - 1));
            uint offset;
            ushort pixVal;

            if (samplesPerPixel == 1)
            {
                if (bitsPerSample == 16)
                {
                    Pixels16.Clear();

                    for (int i = 0; i < stripsPerImage - 1; ++i)
                    {
                        offset = stripOffsets[i];
                        bReader.BaseStream.Seek(offset, SeekOrigin.Begin);

                        for (int j = 0; j < rowsPerStrip * width; ++j)
                        {
                            pixVal = bReader.ReadUInt16();
                            Pixels16.Add(pixVal);
                        }
                    }

                    // Last strip
                    offset = stripOffsets[stripOffsets.Count - 1];
                    bReader.BaseStream.Seek(offset, SeekOrigin.Begin);
                    for (int j = 0; j < lastStripNumberOfRows * width; ++j)
                    {
                        pixVal = bReader.ReadUInt16();
                        Pixels16.Add(pixVal);
                    }

                    pixVal = 5;
                }
                else
                {
                    // TO DO
                }
            }
            else
            {
                // TO DO
            }
        }

        void InterpretDirectoryEntry(DirectoryEntry de) 
        {
            switch(de.tag) {
                case IMAGE_WIDTH:
                    width = de.valueOfOffset;
                    tiffDec.Width = width;
                    break;
                case IMAGE_LENGTH:
                    height = de.valueOfOffset;
                    tiffDec.Height = height;
                    break;
                case STRIP_OFFSETS:
                    PopulateStripOffsets(de);
                    break;
                case STRIP_BYTE_COUNT:
                    PopulateStripByteCounts(de);
                    break;
                case SAMPLES_PER_PIXEL:
                    samplesPerPixel = de.valueOfOffset;
                    break;
                case BITS_PER_SAMPLE:
                    bitsPerSample = de.valueOfOffset;
                    break;
                case ROWS_PER_STRIP:
                    rowsPerStrip = de.valueOfOffset;
                    break;
                case PHOTO_INTERP:
                    photometricInterpretation = de.valueOfOffset;
                    break;
                default:
                    break;
            }
        }
    }

    public class TiffDecoder
    {
       //constants
        //int UNSIGNED = 1;
        //int SIGNED = 2;
        //int FLOATING_POINT = 3;

        ////field types
        //int SHORT = 3;
        //int LONG = 4;

        // metadata types
        //int MAGIC_NUMBER = 0x494a494a;  // "IJIJ"
        //int INFO = 0x696e666f;  // "info" (Info image property)
        //int LABELS = 0x6c61626c;  // "labl" (slice labels)
        //int RANGES = 0x72616e67;  // "rang" (display ranges)
        //int LUTS = 0x6c757473;  // "luts" (channel LUTs)
        //int ROI = 0x726f6920;  // "roi " (ROI)
        //int OVERLAY = 0x6f766572;  // "over" (overlay)

        //private String directory;
        //private String name;
        //private String url;
        BinaryReader inFile;
        //protected bool debugMode;

        //String dInfo;
        //int ifdCount;
        //int[] metaDataCounts;
        //String tiffMetadata;
        //int photoInterp;

        String tiffFileName;
        bool littleEndian;
        IFD ifd;

        public TiffDecoder()
        {
        }

        public string FileName { get; set; }

        public uint Width { get; set; }

        public uint Height { get; set; }

        public List<ushort> Pixels16 { get;  set; }
                
        int ReadTiffFileHeader()
        {
            // Open 8-byte Image File Header at start of file.
            // Returns the offset in bytes to the first IFD or -1
            // if this is not a valid tiff file.
            int byteOrder = inFile.ReadInt16();
            if (byteOrder == 0x4949) // "II"
                littleEndian = true;
            else if (byteOrder == 0x4d4d) // "MM"
                littleEndian = false;
            else
            {
                // Does not look like a TIFF file
                inFile.Close();
                return -1;
            }
            int magicNumber = inFile.ReadInt16(); // 42
            int offset = inFile.ReadInt32();
            return offset;
        }

        public string TiffFileName
        {
            set
            {
                tiffFileName = value;
                inFile = new BinaryReader(File.Open(tiffFileName, FileMode.Open, FileAccess.Read));

                try
                {
                    int firstIfdOffset = ReadTiffFileHeader();
                    if (firstIfdOffset < 0)
                    {
                        inFile.Close();
                    }
                    if (firstIfdOffset > 0) {
                        inFile.BaseStream.Seek(firstIfdOffset, SeekOrigin.Begin);
                        ifd = new IFD(inFile, this);
                        ifd.ReadIfdAndPixelData();
                    }
                }
                catch
                {
                    // Nothing here
                }
                finally
                {
                    inFile.Close();
                }
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Windows.Forms;

// Program to display a 16-bit raw image file.
// Written by Amarnath S, Bangalore, India, December 2008.

namespace ImageDraw
{
	/// <summary>
	/// Summary description for Form1.
	/// 
	/// It is assumed that the pixels comprising the image are stored 
	/// from left to right, and top to bottom, as unsigned short values.
	/// It is also assumed that the width and height of the image are 
	/// identical, so that the image dimensions can be computed by just 
	/// using the square root function.
	/// The algorithm is briefly as follows:
	///  1. Read the raw image file and store the pixel values into an 
	///     ArrayList called pixel16.
	///  2. Create a bitmap of the required dimensions. Create the bitmap 
	///     with the pixel format of Format24bppRgb, and set the red, green 
	///     and blue colors to be identical, since the images are grayscale. 
	///     Scale the 16-bit grayscale interval of 0 - 65535 to an 8-bit 
	///     interval of 0 - 255, since each color is represented by 8 bits. 
	///     Use the BitmapData class to populate the bitmap pixel values 
	///     from the abovementioned pixel16 array list. Use LockBits and 
	///     UnlockBits appropriately. Display the image. It is also 
	///     possible to use SetPixel to set the values, but this method 
	///     is painfully slow compared to what is used here.	
	///  3. Override Paint to draw the image.
	///  
	///  Compile with the unsafe flag on.
	/// </summary>
	public class Form1 : System.Windows.Forms.Form
	{
		private System.Windows.Forms.Panel panelImage;
		private System.Windows.Forms.Button bnOpenImage;
	
		private  List<ushort> pixels16;  // To hold the pixel data
		Graphics g;                   // Graphics of the panel object
		uint      width, height;      // Dimensions of the bitmap
		Bitmap   bmp;                 // Bitmap object

        TiffDecoder tiff;

		/// <summary>
		/// Required designer variable.
		/// </summary>
		private System.ComponentModel.Container components = null;

		public Form1()
		{
			//
			// Required for Windows Form Designer support
			//
			InitializeComponent();

			//
			// TODO: Add any constructor code after InitializeComponent call
			//
			pixels16 = new List<ushort>();
			g = panelImage.CreateGraphics();
            tiff = new TiffDecoder();
		}

		/// <summary>
		/// Clean up any resources being used.
		/// </summary>
		protected override void Dispose( bool disposing )
		{
			if( disposing )
			{
				if (components != null) 
				{
					components.Dispose();
				}
			}
			base.Dispose( disposing );
		}

		#region Windows Form Designer generated code
		/// <summary>
		/// Required method for Designer support - do not modify
		/// the contents of this method with the code editor.
		/// </summary>
		private void InitializeComponent()
		{
            this.bnOpenImage = new System.Windows.Forms.Button();
            this.panelImage = new System.Windows.Forms.Panel();
            this.SuspendLayout();
            // 
            // bnOpenImage
            // 
            this.bnOpenImage.Location = new System.Drawing.Point(8, 8);
            this.bnOpenImage.Name = "bnOpenImage";
            this.bnOpenImage.Size = new System.Drawing.Size(88, 56);
            this.bnOpenImage.TabIndex = 0;
            this.bnOpenImage.Text = "Open Raw Image";
            this.bnOpenImage.Click += new System.EventHandler(this.bnOpenImage_Click);
            // 
            // panelImage
            // 
            this.panelImage.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None;
            this.panelImage.Location = new System.Drawing.Point(104, 8);
            this.panelImage.Name = "panelImage";
            this.panelImage.Size = new System.Drawing.Size(512, 512);
            this.panelImage.TabIndex = 2;
            // 
            // Form1
            // 
            this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
            this.ClientSize = new System.Drawing.Size(624, 530);
            this.Controls.Add(this.panelImage);
            this.Controls.Add(this.bnOpenImage);
            this.Name = "Form1";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Display 16-bit Raw Image Files";
            this.Closing += new System.ComponentModel.CancelEventHandler(this.Form1_Closing);
            this.Paint += new System.Windows.Forms.PaintEventHandler(this.Form1_Paint);
            this.ResumeLayout(false);

		}
		#endregion

		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main() 
		{
			Application.Run(new Form1());
		}

		// Open the Raw image file for reading.
		private void bnOpenImage_Click(object sender, System.EventArgs e)
		{
			pixels16.Clear();
			OpenFileDialog ofd = new OpenFileDialog();
			ofd.Filter = "TIFF Files(*.tif)|*.tif";
			ofd.ShowDialog();
			if( ofd.FileName.Length > 0 )
			{
                tiff.TiffFileName = ofd.FileName;
				//ReadImageFile(ofd.FileName);
                width = tiff.Width;
                height = tiff.Height;

                pixels16 = tiff.Pixels16;
				CreateBitmap();
				Invalidate();
			}
			ofd.Dispose();		
		}

		private void Form1_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
		{
			if( pixels16.Count > 0 )
				g.DrawImage(bmp, 0, 0);
		}

		private void Form1_Closing(object sender, System.ComponentModel.CancelEventArgs e)
		{
			bmp.Dispose();
			pixels16.Clear();
		}	

		// Read the image file, and populate the array list pixels16.
		private void ReadImageFile(string fileName)
		{
			BinaryReader br = new BinaryReader(File.Open(fileName, FileMode.Open));
			ushort pixShort;
			int i;
			long iTotalSize = br.BaseStream.Length;

			for( i = 0; i < iTotalSize; i += 2 )
			{
				pixShort = br.ReadUInt16(); 
				pixels16.Add(pixShort);
			}
			br.Close();
			width = (uint)(Math.Sqrt(pixels16.Count));
			height = width;
		}

		// Create the Bitmap object and populate its pixel data with the stored pixel values.
		private void CreateBitmap()
		{
			bmp = new Bitmap((int)width, (int)height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
			BitmapData bmd = bmp.LockBits(new Rectangle(0, 0, (int)width, (int)height),
				System.Drawing.Imaging.ImageLockMode.ReadOnly, bmp.PixelFormat);

			// This 'unsafe' part of the code populates the bitmap bmp with data stored in pixel16.
			// It does so using pointers, and therefore the need for 'unsafe'. 
			unsafe
			{
				int    pixelSize = 3;
				int    i, j, j1, i1;
				byte   b;
				ushort sVal;
				double lPixval;

				for (i = 0; i < bmd.Height; ++i)
				{
					byte* row = (byte*)bmd.Scan0 + (i * bmd.Stride);
					i1 = i * bmd.Height;

					for (j = 0; j < bmd.Width; ++j)
					{
						sVal        = (pixels16[i1 + j]);
						lPixval     = (sVal / 256.0); // Convert to a 256 value range
						if( lPixval > 255 ) lPixval = 255;
						if( lPixval < 0   ) lPixval = 0;
						b           = (byte)(lPixval);
						j1          = j * pixelSize;
						row[j1]     = b;            // Red
						row[j1 + 1] = b;            // Green
						row[j1 + 2] = b;            // Blue
					}
				}
			}            
			bmp.UnlockBits(bmd);
		}	
	}
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Windows.Forms;

namespace ImageDraw
{
	/// <summary>
	/// Summary description for Form1.
	/// 
	/// It is assumed that the pixels comprising the image are stored 
	/// from left to right, and top to bottom, as unsigned short values.
	/// It is also assumed that the width and height of the image are 
	/// identical, so that the image dimensions can be computed by just 
	/// using the square root function.
	/// The algorithm is briefly as follows:
	///  1. Read the raw image file and store the pixel values into an 
	///     ArrayList called pixel16.
	///  2. Create a bitmap of the required dimensions. Create the bitmap 
	///     with the pixel format of Format24bppRgb, and set the red, green 
	///     and blue colors to be identical, since the images are grayscale. 
	///     Scale the 16-bit grayscale interval of 0 - 65535 to an 8-bit 
	///     interval of 0 - 255, since each color is represented by 8 bits. 
	///     Use the BitmapData class to populate the bitmap pixel values 
	///     from the abovementioned pixel16 array list. Use LockBits and 
	///     UnlockBits appropriately. Display the image. It is also 
	///     possible to use SetPixel to set the values, but this method 
	///     is painfully slow compared to what is used here.	
	///  3. Override Paint to draw the image.
	///  
	///  Compile with the unsafe flag on.
	/// </summary>
	public class Form1 : System.Windows.Forms.Form
	{
		private System.Windows.Forms.Panel panelImage;
		private System.Windows.Forms.Button bnOpenImage;
	
		private  List<ushort> pixels16;  // To hold the pixel data
		Graphics g;                   // Graphics of the panel object
		uint      width, height;      // Dimensions of the bitmap
		Bitmap   bmp;                 // Bitmap object

        TiffDecoder tiff;
        private Button bnProcess;

		/// <summary>
		/// Required designer variable.
		/// </summary>
		private System.ComponentModel.Container components = null;

		public Form1()
		{
			//
			// Required for Windows Form Designer support
			//
			InitializeComponent();

			//
			// TODO: Add any constructor code after InitializeComponent call
			//
			pixels16 = new List<ushort>();
			g = panelImage.CreateGraphics();
            tiff = new TiffDecoder();
		}

		/// <summary>
		/// Clean up any resources being used.
		/// </summary>
		protected override void Dispose( bool disposing )
		{
			if( disposing )
			{
				if (components != null) 
				{
					components.Dispose();
				}
			}
			base.Dispose( disposing );
		}

		#region Windows Form Designer generated code
		/// <summary>
		/// Required method for Designer support - do not modify
		/// the contents of this method with the code editor.
		/// </summary>
		private void InitializeComponent()
		{
            this.bnOpenImage = new System.Windows.Forms.Button();
            this.panelImage = new System.Windows.Forms.Panel();
            this.bnProcess = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // bnOpenImage
            // 
            this.bnOpenImage.Location = new System.Drawing.Point(8, 8);
            this.bnOpenImage.Name = "bnOpenImage";
            this.bnOpenImage.Size = new System.Drawing.Size(88, 56);
            this.bnOpenImage.TabIndex = 0;
            this.bnOpenImage.Text = "Open TIFF Image";
            this.bnOpenImage.Click += new System.EventHandler(this.bnOpenImage_Click);
            // 
            // panelImage
            // 
            this.panelImage.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None;
            this.panelImage.Location = new System.Drawing.Point(104, 8);
            this.panelImage.Name = "panelImage";
            this.panelImage.Size = new System.Drawing.Size(512, 512);
            this.panelImage.TabIndex = 2;
            // 
            // bnProcess
            // 
            this.bnProcess.Location = new System.Drawing.Point(8, 70);
            this.bnProcess.Name = "bnProcess";
            this.bnProcess.Size = new System.Drawing.Size(88, 23);
            this.bnProcess.TabIndex = 3;
            this.bnProcess.Text = "Process";
            this.bnProcess.UseVisualStyleBackColor = true;
            this.bnProcess.Click += new System.EventHandler(this.bnProcess_Click);
            // 
            // Form1
            // 
            this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
            this.ClientSize = new System.Drawing.Size(624, 530);
            this.Controls.Add(this.bnProcess);
            this.Controls.Add(this.panelImage);
            this.Controls.Add(this.bnOpenImage);
            this.Name = "Form1";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Display 16-bit Raw Image Files";
            this.Closing += new System.ComponentModel.CancelEventHandler(this.Form1_Closing);
            this.Paint += new System.Windows.Forms.PaintEventHandler(this.Form1_Paint);
            this.ResumeLayout(false);

		}
		#endregion

		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main() 
		{
			Application.Run(new Form1());
		}

		// Open the Raw image file for reading.
		private void bnOpenImage_Click(object sender, System.EventArgs e)
		{
			pixels16.Clear();
			OpenFileDialog ofd = new OpenFileDialog();
			ofd.Filter = "TIFF Files(*.tif)|*.tif";
			ofd.ShowDialog();
			if( ofd.FileName.Length > 0 )
			{
                tiff.TiffFileName = ofd.FileName;
				//ReadImageFile(ofd.FileName);
                width = tiff.Width;
                height = tiff.Height;

                pixels16 = tiff.Pixels16;
				CreateBitmap();
				Invalidate();
			}
			ofd.Dispose();		
		}

		private void Form1_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
		{
			if( pixels16.Count > 0 )
				g.DrawImage(bmp, 0, 0);
		}

		private void Form1_Closing(object sender, System.ComponentModel.CancelEventArgs e)
		{
			bmp.Dispose();
			pixels16.Clear();
		}	

		// Read the image file, and populate the array list pixels16.
		private void ReadImageFile(string fileName)
		{
			BinaryReader br = new BinaryReader(File.Open(fileName, FileMode.Open));
			ushort pixShort;
			int i;
			long iTotalSize = br.BaseStream.Length;

			for( i = 0; i < iTotalSize; i += 2 )
			{
				pixShort = br.ReadUInt16(); 
				pixels16.Add(pixShort);
			}
			br.Close();
			width = (uint)(Math.Sqrt(pixels16.Count));
			height = width;
		}

		// Create the Bitmap object and populate its pixel data with the stored pixel values.
		private void CreateBitmap()
		{
			bmp = new Bitmap((int)width, (int)height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
			BitmapData bmd = bmp.LockBits(new Rectangle(0, 0, (int)width, (int)height),
				System.Drawing.Imaging.ImageLockMode.ReadOnly, bmp.PixelFormat);

			// This 'unsafe' part of the code populates the bitmap bmp with data stored in pixel16.
			// It does so using pointers, and therefore the need for 'unsafe'. 
			unsafe
			{
				int    pixelSize = 3;
				int    i, j, j1, i1;
				byte   b;
				ushort sVal;
				double lPixval;

				for (i = 0; i < bmd.Height; ++i)
				{
					byte* row = (byte*)bmd.Scan0 + (i * bmd.Stride);
					i1 = i * bmd.Width;

					for (j = 0; j < bmd.Width; ++j)
					{
						sVal        = (pixels16[i1 + j]);
						lPixval     = (sVal / 256.0); // Convert to a 256 value range
						if( lPixval > 255 ) lPixval = 255;
						if( lPixval < 0   ) lPixval = 0;
						b           = (byte)(lPixval);
						j1          = j * pixelSize;
						row[j1]     = b;            // Red
						row[j1 + 1] = b;            // Green
						row[j1 + 2] = b;            // Blue
					}
				}
			}            
			bmp.UnlockBits(bmd);
		}

        // Half the pixel values
        private void bnProcess_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < pixels16.Count; ++i)
            {
                pixels16[i] /= 2;
            }
            CreateBitmap();
            Invalidate();

        }	
	}
}

private void process_btn_Click(object sender, EventArgs e)
{
Algorithm a = new Algorithm(pixels16,width,height);
a.Set_D0_h1_h2_t_lambda_Iter(100, 1, 1, 1, 1,200);
a.Set_sigma(0.5);
a.PeronaMalik(ref pixels16, ref this.progressBar1);
CreateBitmap();
Invalidate();
}