path: root/Wrapper/FreeImage.NET/cs/Samples/Sample 11 - Using the FreeImageBitmap class/MainForm.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using FreeImageAPI;
using FreeImageAPI.Metadata;
using FreeImageAPI.Plugins;

namespace Sample11
{
	public partial class MainForm : Form
	{
		public MainForm()
		{
			InitializeComponent();
		}

		[STAThread]
		static void Main()
		{
			// Capture messages generated by FreeImage
			FreeImageEngine.Message += new OutputMessageFunction(FreeImageEngine_Message);

			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);
			Application.Run(new MainForm());
		}

		static void FreeImageEngine_Message(FREE_IMAGE_FORMAT fif, string message)
		{
			// Display the message
			// FreeImage continues code executing when all
			// addes subscribers of 'Message' finished returned.
			MessageBox.Show(message, "FreeImage-Message", MessageBoxButtons.OK, MessageBoxIcon.Information);
		}

		// The FreeImageBitmap this sample will work with.
		FreeImageBitmap bitmap = null;

		// Replaces the current bitmap with the given one.
		private void ReplaceBitmap(FreeImageBitmap newBitmap)
		{
			// Checks whether the bitmap is usable
			if (newBitmap == null || newBitmap.IsDisposed)
			{
				MessageBox.Show(
					"Unexpected error.",
					"Error",
					MessageBoxButtons.OK,
					MessageBoxIcon.Error);
			}

			// Check whether the image type of the new bitmap is 'FIT_BITMAP'.
			// If not convert to 'FIT_BITMAP'.
			if (newBitmap.ImageType != FREE_IMAGE_TYPE.FIT_BITMAP)
			{
				if (!newBitmap.ConvertType(FREE_IMAGE_TYPE.FIT_BITMAP, true))
				{
					MessageBox.Show(
						"Error converting bitmap to standard type.",
						"Error",
						MessageBoxButtons.OK,
						MessageBoxIcon.Error);
					return;
				}
			}

			// Dispose the old bitmap only in case it exists and
			// the old instance is another than the new one.
			if ((bitmap != null) && !object.ReferenceEquals(bitmap, newBitmap))
			{
				bitmap.Dispose();
			}
			// Dispose the picturebox's bitmap in case it exists.
			if (pictureBox.Image != null)
			{
				pictureBox.Image.Dispose();
			}

			// Set the new bitmap.
			pictureBox.Image = (Bitmap)(bitmap = newBitmap);

			// Update gui.
			UpdateBitmapInformations();
			UpdateFrameSelection();
		}

		// Get bitmap properties and display them in the gui.
		private void UpdateBitmapInformations()
		{
			if (Bitmap)
			{
				// Get width
				lWidth.Text = String.Format("Width: {0}", bitmap.Width);
				// Get Height
				lHeight.Text = String.Format("Height: {0}", bitmap.Height);
				// Get color depth
				lBpp.Text = String.Format("Bpp: {0}", bitmap.ColorDepth);
				// Get number of metadata
				ImageMetadata mData = bitmap.Metadata;
				mData.HideEmptyModels = true;
				int mCnt = 0;
				foreach (MetadataModel model in mData.List)
				{
					mCnt += model.Count;
				}
				lMetadataCount.Text = String.Format("Metadata: {0}", mCnt);
				// Get image comment
				lComment.Text = String.Format("Image-comment: {0}", bitmap.Comment != null ? bitmap.Comment : String.Empty);
				// Get the number of real colors in the image
				lColors.Text = String.Format("Colors: {0}", bitmap.UniqueColors);
			}
			else
			{
				// Reset all values
				lWidth.Text = String.Format("Width: {0}", 0);
				lHeight.Text = String.Format("Height: {0}", 0);
				lBpp.Text = String.Format("Bpp: {0}", 0);
				lMetadataCount.Text = String.Format("Metadata: {0}", 0);
				lComment.Text = String.Format("Image-comment: {0}", String.Empty);
				lColors.Text = String.Format("Colors: {0}", 0);
			}
		}

		// Update combobox for frame selection.
		private void UpdateFrameSelection()
		{
			cbSelectFrame.Items.Clear();
			if (Bitmap)
			{
				// Get number of frames in the bitmap
				if (bitmap.FrameCount > 1)
				{
					// Add an entry for each frame to the combobox
					for (int i = 0; i < bitmap.FrameCount; i++)
					{
						cbSelectFrame.Items.Add(String.Format("Frame {0}", i + 1));
					}
				}
			}
		}

		// Returns true in case the variable 'bitmap'
		// is set and not disposed.
		private bool Bitmap
		{
			get { return ((bitmap != null) && (!bitmap.IsDisposed)); }
		}

		private void bLoadImage_Click(object sender, EventArgs e)
		{
			if (ofd.ShowDialog() == DialogResult.OK)
			{
				try
				{
					// Load the file using autodetection
					FreeImageBitmap fib = new FreeImageBitmap(ofd.FileName);
					// Rescale the image so that it fits the picturebox
					// Get the plugin that was used to load the bitmap
					FreeImagePlugin plug = PluginRepository.Plugin(fib.ImageFormat);
					lImageFormat.Text = String.Format("Image-format: {0}", plug.Format);
					// Replace the existing bitmap with the new one
					ReplaceBitmap(fib);
				}
				catch
				{
				}
			}
		}

		private void bSaveImage_Click(object sender, EventArgs e)
		{
			if (pictureBox.Image != null)
			{
				try
				{
					if (sfd.ShowDialog() == DialogResult.OK)
					{
						// Save the bitmap using autodetection
						using (FreeImageBitmap temp = new FreeImageBitmap(pictureBox.Image))
						{
							temp.Save(sfd.FileName);
						}
					}
				}
				catch
				{
				}
			}
		}

		private void bRotate_Click(object sender, EventArgs e)
		{
			if (Bitmap)
			{
				// Create a temporary rescaled bitmap
				using (FreeImageBitmap temp = bitmap.GetScaledInstance(
					pictureBox.DisplayRectangle.Width, pictureBox.DisplayRectangle.Height,
					FREE_IMAGE_FILTER.FILTER_CATMULLROM))
				{
					if (temp != null)
					{
						// Rotate the bitmap
						temp.Rotate((double)vRotate.Value);
						if (pictureBox.Image != null)
						{
							pictureBox.Image.Dispose();
						}
						// Display the result
						pictureBox.Image = (Bitmap)temp;
					}
				}
			}
		}

		private void bGreyscale_Click(object sender, EventArgs e)
		{
			if (Bitmap)
			{
				// Convert the bitmap to 8bpp and greyscale
				ReplaceBitmap(bitmap.GetColorConvertedInstance(
					FREE_IMAGE_COLOR_DEPTH.FICD_08_BPP |
					FREE_IMAGE_COLOR_DEPTH.FICD_FORCE_GREYSCALE));
			}
		}

		private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
		{
			ComboBox cb = sender as ComboBox;
			if ((cb != null) && (cb.Items.Count > 0))
			{
				if (Bitmap)
				{
					try
					{
						// Switch the selected frame
						bitmap.SelectActiveFrame(cb.SelectedIndex);
						ReplaceBitmap(bitmap);
					}
					catch (ArgumentOutOfRangeException)
					{
						MessageBox.Show("Error changing frame.", "Error");
					}
				}
			}
		}

		private void bAdjustGamma_Click(object sender, EventArgs e)
		{
			if (Bitmap)
			{
				// Adjust the gamma value
				bitmap.AdjustGamma((double)vGamma.Value);
				ReplaceBitmap(bitmap);
			}
		}

		private void bRedChannelOnly_Click(object sender, EventArgs e)
		{
			// Mask out green and blue
			SetColorChannels(0xFF, 0x00, 0x00);
		}

		private void bGreenChannel_Click(object sender, EventArgs e)
		{
			// Mask out red and blue
			SetColorChannels(0x00, 0xFF, 0x00);
		}

		private void bBlueChannel_Click(object sender, EventArgs e)
		{
			// Mask out red and green
			SetColorChannels(0x00, 0x00, 0xFF);
		}

		private void bAllChannels_Click(object sender, EventArgs e)
		{
			if (Bitmap)
			{
				// Restore the bitmap using the original
				ReplaceBitmap(bitmap);
			}
		}

		private void SetColorChannels(int redmask, int greenmask, int bluemask)
		{
			if (Bitmap)
			{
				// Create a temporary clone.
				using (FreeImageBitmap bitmap = (FreeImageBitmap)this.bitmap.Clone())
				{
					if (bitmap != null)
					{
						// Check whether the bitmap has a palette
						if (bitmap.HasPalette)
						{
							// Use the Palette class to handle the bitmap's
							// palette. A palette always consist of RGBQUADs.
							Palette palette = bitmap.Palette;
							// Apply the new values for all three color components.
							for (int i = 0; i < palette.Length; i++)
							{
								RGBQUAD rgbq = palette[i];

								rgbq.rgbRed = (byte)(rgbq.rgbRed & redmask);
								rgbq.rgbGreen = (byte)(rgbq.rgbGreen & greenmask);
								rgbq.rgbBlue = (byte)(rgbq.rgbBlue & bluemask);

								palette[i] = rgbq;
							}
						}
						// In case the bitmap has no palette it must have a color depth
						// of 16, 24 or 32. Each color depth needs a different wrapping
						// structure for the bitmaps data. These structures can be accessed
						// by using the foreach clause.
						else if (bitmap.ColorDepth == 16)
						{
							// Iterate over each scanline
							// For 16bpp use either Scanline<FI16RGB555> or Scanline<FI16RGB565>
							if (bitmap.IsRGB555)
							{
								foreach (Scanline<FI16RGB555> scanline in bitmap)
								{
									for (int x = 0; x < scanline.Length; x++)
									{
										FI16RGB555 pixel = scanline[x];
										pixel.Red = (byte)(pixel.Red & redmask);
										pixel.Green = (byte)(pixel.Green & greenmask);
										pixel.Blue = (byte)(pixel.Blue & bluemask);
										scanline[x] = pixel;
									}
								}
							}
							else if (bitmap.IsRGB565)
							{
								foreach (Scanline<FI16RGB565> scanline in bitmap)
								{
									for (int x = 0; x < scanline.Length; x++)
									{
										FI16RGB565 pixel = scanline[x];
										pixel.Red = (byte)(pixel.Red & redmask);
										pixel.Green = (byte)(pixel.Green & greenmask);
										pixel.Blue = (byte)(pixel.Blue & bluemask);
										scanline[x] = pixel;
									}
								}
							}
						}
						else if (bitmap.ColorDepth == 24)
						{
							// Iterate over each scanline
							// For 24bpp Scanline<RGBTRIPLE> must be used
							foreach (Scanline<RGBTRIPLE> scanline in bitmap)
							{
								for (int x = 0; x < scanline.Length; x++)
								{
									RGBTRIPLE pixel = scanline[x];
									pixel.rgbtRed = (byte)(pixel.rgbtRed & redmask);
									pixel.rgbtGreen = (byte)(pixel.rgbtGreen & greenmask);
									pixel.rgbtBlue = (byte)(pixel.rgbtBlue & bluemask);
									scanline[x] = pixel;
								}
							}
						}
						else if (bitmap.ColorDepth == 32)
						{
							// Iterate over each scanline
							// For 32bpp Scanline<RGBQUAD> must be used
							foreach (Scanline<RGBQUAD> scanline in bitmap)
							{
								for (int x = 0; x < scanline.Length; x++)
								{
									RGBQUAD pixel = scanline[x];
									pixel.rgbRed = (byte)(pixel.rgbRed & redmask);
									pixel.rgbGreen = (byte)(pixel.rgbGreen & greenmask);
									pixel.rgbBlue = (byte)(pixel.rgbBlue & bluemask);
									scanline[x] = pixel;
								}
							}
						}
						// Dispose only the picturebox's bitmap
						if (pictureBox.Image != null)
						{
							pictureBox.Image.Dispose();
						}
						pictureBox.Image = (Bitmap)bitmap;
					}
				}
			}
		}

		private void vRotate_Scroll(object sender, EventArgs e)
		{
			TrackBar bar = sender as TrackBar;
			if (bar != null)
			{
				lRotate.Text = bar.Value.ToString();
			}
		}

		private void nShowMetadata_Click(object sender, EventArgs e)
		{
			if (Bitmap)
			{
				MetaDataFrame mFrame = new MetaDataFrame();
				mFrame.Tag = bitmap.Metadata;
				mFrame.ShowDialog(this);
			}
		}
	}
}