public byte[] Decode(PdfObject decodedObject, byte[] inputData, DecodeParameters decodeParameters)
{
FIBITMAP myImage = new FIBITMAP();
using (MemoryStream stream = new MemoryStream(inputData))
{
myImage = FreeImage.LoadFromStream(stream);
}
Bitmap bitmap = FreeImage.GetBitmap(myImage);
byte[] result;
if (decodedObject.ColorSpace == ColorSpace.Gray)
{
result = new byte[decodedObject.Width * decodedObject.Height];
for (int i = 0; i < decodedObject.Width; i++)
{
for (int j = 0; j < decodedObject.Height; j++)
{
Color pixel = bitmap.GetPixel(i, j);
int index = j * decodedObject.Width + i;
byte grayColor = (byte)(0.2126 * pixel.R + 0.7152 * pixel.G + 0.0722 * pixel.B);
result[index] = grayColor;
}
}
}
else
{
result = new byte[decodedObject.Width * decodedObject.Height * 3];
for (int i = 0; i < decodedObject.Width; i++)
{
for (int j = 0; j < decodedObject.Height; j++)
{
Color pixel = bitmap.GetPixel(i, j);
int index = j * decodedObject.Width + i;
result[index * 3] = pixel.R;
result[index * 3 + 1] = pixel.G;
result[index * 3 + 2] = pixel.B;
}
}
}
return(result);
}
protected Texture AllocateFromImageStream(Stream dataStream, ref ImageInformation info)
{
Texture texture = null;
FIBITMAP image = FIBITMAP.Zero;
try
{
image = FreeImage.LoadFromStream(dataStream);
// Write uncompressed data to temporary stream.
using (var memoryStream = new MemoryStream())
{
// Scale down larger images
int resizeWidth = MAX_TEXTURE_DIMENSION;
int resizeHeight = MAX_TEXTURE_DIMENSION;
if (_decodeWidth > 0)
{
resizeWidth = Math.Min(_decodeWidth, MAX_TEXTURE_DIMENSION);
}
if (_decodeHeight > 0)
{
resizeHeight = Math.Min(_decodeHeight, MAX_TEXTURE_DIMENSION);
}
image = ResizeImage(image, resizeWidth, resizeHeight);
FreeImage.SaveToStream(image, memoryStream, FREE_IMAGE_FORMAT.FIF_BMP);
Stream loadStream = memoryStream;
if (loadStream.Length == 0)
{
loadStream = dataStream;
ServiceRegistration.Get <ILogger>().Warn("TextureAssetCore: FreeImage was not able to save image as bitmap into MemoryStream. Using source stream as fallback.");
}
loadStream.Position = 0;
texture = Texture.FromStream(GraphicsDevice.Device, loadStream, (int)loadStream.Length, _decodeWidth, _decodeHeight, 1,
Usage.None, Format.A8R8G8B8, Pool.Default, Filter.None, Filter.None, 0, out info);
}
}
catch (Exception e)
{
ServiceRegistration.Get <ILogger>().Warn("TextureAssetCore: Error loading texture from stream using FreeImage", e);
}
finally
{
FreeImage.UnloadEx(ref image);
}
return(texture);
}
public void Save(FIBITMAP dib, string fileName)
{
// Store the bitmap back to disk
// TARGA_SAVE_RLE = 2
FreeImage.Save(FREE_IMAGE_FORMAT.FIF_TARGA, dib, fileName, FREE_IMAGE_SAVE_FLAGS.TARGA_SAVE_RLE);
// The bitmap was saved to disk but is still allocated in memory, so the handle has to be freed.
if (!dib.IsNull)
{
FreeImage.Unload(dib);
}
// Make sure to set the handle to null so that it is clear that the handle is not pointing to a bitmap.
dib.SetNull();
}
public GDIBitmap(string filename)
{
FreeImage img = new FreeImage(filename);
IntPtr deskDC = NativeMethods.GetDC(new IntPtr(0));
IntPtr destDC = NativeMethods.CreateCompatibleDC(deskDC);
IntPtr oldBmp = NativeMethods.SelectObject(destDC, _hBmp);
_hBmp = NativeMethods.CreateCompatibleBitmap(destDC, img.Width, img.Height);
img.PaintToDevice(destDC, 0, 0, img.Width, img.Height, 0, 0, 0, img.Height, 0);
NativeMethods.SelectObject(destDC, oldBmp);
NativeMethods.DeleteDC(deskDC);
NativeMethods.DeleteDC(destDC);
img.DisposeAndSetHandle(0);
}
private void Form1_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
{
IntPtr hdc = e.Graphics.GetHdc();
int r = SetStretchBltMode(hdc, 3 /* COLORONCOLOR */);
r = StretchDIBits(hdc,
0, 0, this.ClientSize.Width, this.ClientSize.Height,
0, 0, (int)FreeImage.GetWidth(this.fi), (int)FreeImage.GetHeight(this.fi),
FreeImage.GetBits(this.fi),
FreeImage.GetInfo(this.fi),
0 /* DIB_RGB_COLORS */, 0x00CC0020 /* SRCCOPY */);
e.Graphics.ReleaseHdc(hdc);
}
static void Main()
{
// Check if FreeImage.dll is available
if (!FreeImage.IsAvailable())
{
MessageBox.Show("FreeImage is not available. Aborting.", "Error");
}
// Add this class to the FreeImage-Message-Callback
FreeImage.Message += new OutputMessageFunction(FreeImage_Message);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
public void Example()
{
// Load the sample bitmap.
FIBITMAP dib = FreeImage.LoadEx("Sample.jpg");
// Check success
if (dib.IsNull)
{
Console.WriteLine("Sample.jpg could not be loaded. Aborting.");
return;
}
// Get the bitmaps ICC-Profile.
FIICCPROFILE icc = FreeImage.GetICCProfileEx(dib);
// Print the profiles address.
Console.WriteLine("The profiles memory-address is : 0x{0}", icc.DataPointer.ToString("X"));
// Print the profiles size
Console.WriteLine("The profiles size is : {0} bytes", icc.Size);
// Create data for a new profile.
byte[] data = new byte[256];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)i;
}
// Create the new profile
icc = new FIICCPROFILE(dib, data);
Console.WriteLine("The profiles memory-address is : 0x{0}", icc.DataPointer.ToString("X"));
Console.WriteLine("The profiles size is : {0} bytes", icc.Size);
// Create the new profile but only use the first 64 bytes
icc = new FIICCPROFILE(dib, data, 64);
Console.WriteLine("The profiles memory-address is : 0x{0}", icc.DataPointer.ToString("X"));
Console.WriteLine("The profiles size is : {0} bytes", icc.Size);
// CreateICCProfileEx(...) does the same as above
icc = FreeImage.CreateICCProfileEx(dib, data, 16);
Console.WriteLine("The profiles memory-address is : 0x{0}", icc.DataPointer.ToString("X"));
Console.WriteLine("The profiles size is : {0} bytes", icc.Size);
FreeImage.UnloadEx(ref dib);
}
public Task <IImageData> Convert(
MemoryStream s,
int bitDepth,
string rawType,
ImageMetaData metaData,
CancellationToken token = default)
{
return(Task.Run(() => {
using (MyStopWatch.Measure()) {
FIBITMAP img;
int left, top, imgWidth, imgHeight;
FREE_IMAGE_FORMAT format = FREE_IMAGE_FORMAT.FIF_RAW;
img = FreeImage.LoadFromStream(s, (FREE_IMAGE_LOAD_FLAGS)8, ref format);
FreeImage.GetMetadata(FREE_IMAGE_MDMODEL.FIMD_COMMENTS, img, "Raw.Frame.Width", out MetadataTag widthTag);
FreeImage.GetMetadata(FREE_IMAGE_MDMODEL.FIMD_COMMENTS, img, "Raw.Frame.Height", out MetadataTag heightTag);
FreeImage.GetMetadata(FREE_IMAGE_MDMODEL.FIMD_COMMENTS, img, "Raw.Frame.Left", out MetadataTag leftTag);
FreeImage.GetMetadata(FREE_IMAGE_MDMODEL.FIMD_COMMENTS, img, "Raw.Frame.Top", out MetadataTag topTag);
left = int.Parse(leftTag.ToString());
top = int.Parse(topTag.ToString());
imgWidth = int.Parse(widthTag.ToString());
imgHeight = int.Parse(heightTag.ToString());
using (var memStream = new MemoryStream()) {
FreeImage.SaveToStream(img, memStream, FREE_IMAGE_FORMAT.FIF_TIFF, FREE_IMAGE_SAVE_FLAGS.TIFF_NONE);
memStream.Position = 0;
var decoder = new TiffBitmapDecoder(memStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
CroppedBitmap cropped = new CroppedBitmap(decoder.Frames[0], new System.Windows.Int32Rect(left, top, imgWidth, imgHeight));
ushort[] outArray = new ushort[cropped.PixelWidth * cropped.PixelHeight];
cropped.CopyPixels(outArray, 2 * cropped.PixelWidth, 0);
FreeImage.UnloadEx(ref img);
var imageArray = new ImageArray(flatArray: outArray, rawData: s.ToArray(), rawType: rawType);
var data = new ImageData(
imageArray: imageArray,
width: cropped.PixelWidth,
height: cropped.PixelHeight,
bitDepth: bitDepth,
isBayered: true,
metaData: metaData);
return Task.FromResult <IImageData>(data);
}
}
}));
}
private void TileImage(object sender, DoWorkEventArgs e)
{
try
{
Options o = GetOptions();
FIBITMAP dib = FreeImage.LoadEx(o.Filename);
// calc resolution of tile
int tileSizeResolution = o.VerticesPerTile - 1;
// commit to dib
if (o.Craters > 0)
{
// status
ce.StatusEvent += (k, msg) => { ((BackgroundWorker)sender).ReportProgress(0, msg); };
// reset dib
ce.dib = dib;
ce.Commit();
// save crater heightmap
string fn = Path.Combine(Path.GetDirectoryName(o.Filename), $"{Path.GetFileNameWithoutExtension(o.Filename)}-crater.png");
FreeImage.Save(FREE_IMAGE_FORMAT.FIF_PNG, dib, fn, FREE_IMAGE_SAVE_FLAGS.DEFAULT);
// save crater debug
fn = Path.Combine(Path.GetDirectoryName(o.Filename), $"{Path.GetFileNameWithoutExtension(o.Filename)}-crater-debug.png");
ce.debugbmp.Save(fn);
}
// tile
TileEngine te = new TileEngine(dib, Path.GetDirectoryName(o.Filename));
// status
te.StatusEvent += (k, msg) => { ((BackgroundWorker)sender).ReportProgress(0, msg); };
te.ScaleZ(o.ZScale / 100.0f);
te.Tile(tileSizeResolution);
// free
FreeImage.Unload(dib);
e.Result = "Finished";
}
catch (Exception ex)
{
e.Result = ex.Message;
}
}
public static ImageSource GetImageSourceFromFileName(string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
return(new BitmapImage());
}
var pngFileName = fileName.Replace(".dds", ".png").
Replace(".DDS", ".png").
Replace(".tga", ".png").
Replace(".TGA", ".png");
if (!File.Exists(pngFileName) && File.Exists(fileName))
{
var ms = new FileStream(fileName, FileMode.Open);
var dds = FreeImage.LoadFromStream(ms);
if (dds.IsNull)
{
return(new BitmapImage());
}
ms.Close();
try {
FreeImage.Save(FREE_IMAGE_FORMAT.FIF_PNG, dds, pngFileName, FREE_IMAGE_SAVE_FLAGS.PNG_Z_NO_COMPRESSION);
} catch (Exception e) { }
dds.SetNull();
ClearMemory();
}
if (File.Exists(pngFileName))
{
var img = new BitmapImage();
img.BeginInit();
if (pngFileName != null)
{
img.UriSource = new Uri(pngFileName);
}
img.EndInit();
return(img);
}
using (var memory = new MemoryStream()) {
Properties.Resources.errorpic.Save(memory, ImageFormat.Png);
memory.Position = 0;
var bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.StreamSource = memory;
bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
bitmapImage.EndInit();
return(bitmapImage);
}
}
public void ScaleZ(float scale)
{
// scale heights
for (uint i = 0; i < FreeImage.GetHeight(dib); i++)
{
Scanline <ushort> line = new Scanline <ushort>(dib, (int)i);
ushort[] data = line.Data;
for (int k = 0; k < data.Length; k++)
{
ushort v = data[k];
ushort adj = (ushort)(v * scale);
data[k] = adj;
}
line.Data = data;
}
}
/// <summary>
/// Gets a .NET PropertyItem for this metadata tag.
/// </summary>
/// <returns>The .NET PropertyItem.</returns>
public unsafe System.Drawing.Imaging.PropertyItem GetPropertyItem()
{
System.Drawing.Imaging.PropertyItem item = FreeImage.CreatePropertyItem();
item.Id = ID;
item.Len = (int)Length;
item.Type = (short)Type;
byte[] data = new byte[item.Len];
byte * ptr = (byte *)FreeImage.GetTagValue(tag);
for (int i = 0; i < data.Length; i++)
{
data[i] = ptr[i];
}
item.Value = data;
return(item);
}
public System.Drawing.Image LoadImage(string file)
{
try
{
FIBITMAP image = FreeImage.LoadEx(file);
int width = (int)FreeImage.GetWidth(image);
int height = (int)FreeImage.GetHeight(image);
int fileBPP = (int)FreeImage.GetBPP(image);
IntPtr ptr = FreeImage.GetHbitmap(image, new IntPtr(0), false); //obtain the Hbitmap
return(System.Drawing.Image.FromHbitmap(ptr));
}
catch (Exception ex)
{
return(null);
}
}
private void ImageViewerShown(object sender, EventArgs e)
{
Text = imageFile;
Cursor.Current = Cursors.WaitCursor;
ZoomLevels.SelectedIndexChanged -= ZoomLevelsSelectedIndexChanged;
foreach (int zoom in ImageView.ZoomLevels)
{
ZoomLevels.Items.Add(string.Format("{0}%", zoom));
if (zoom == 100)
{
ZoomLevels.SelectedIndex = ZoomLevels.Items.Count - 1;
}
}
ZoomLevels.SelectedIndexChanged += ZoomLevelsSelectedIndexChanged;
try
{
originalImage = FreeImage.LoadEx(imageFile);
if (!originalImage.IsNull)
{
Text = Text + " (" + FreeImage.GetHeight(originalImage) + " x " + FreeImage.GetWidth(originalImage) + ")";
FREE_IMAGE_TYPE type = FreeImage.GetImageType(originalImage);
if (type != FREE_IMAGE_TYPE.FIT_BITMAP)
{
displayImage = FreeImage.ToneMapping(originalImage, FREE_IMAGE_TMO.FITMO_REINHARD05, 0, -1);
}
else
{
displayImage = FreeImage.Clone(originalImage);
}
if (!displayImage.IsNull)
{
ImageView.Image = FreeImage.GetBitmap(displayImage);
icon = FreeImage.Rescale(displayImage, 16, 15, FREE_IMAGE_FILTER.FILTER_BOX);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error " + ex);
}
Cursor.Current = Cursors.Default;
}
public static Vector2 GetHeightRange(this FIBITMAP dib)
{
Vector2 range;
range.X = ushort.MaxValue;
range.Y = ushort.MinValue;
for (uint y = 0; y < FreeImage.GetHeight(dib); y++)
{
Scanline <ushort> line = new Scanline <ushort>(dib, (int)y);
for (int i = 0; i < line.Count; i++)
{
range.X = Math.Min(line[i], range.X);
range.Y = Math.Max(line[i], range.Y);
}
}
return(range);
}
public void ApplyFilters(List <Schema.SkinFile.Attachment.Filter> filters)
{
if (dib.IsNull)
{
return;
}
foreach (Schema.SkinFile.Attachment.Filter filter in filters)
{
switch (filter.name)
{
case "invert":
{
///
/// TODO: Variable invertion using amount property
///
FreeImage.AdjustColors(dib, 0, 0, 0, true);
break;
}
case "colorOverlay":
{
try
{
///
/// TODO: Variable overlay using amount property
///
RGBQUAD overlayColor = new RGBQUAD(), oldColor;
overlayColor.uintValue = Convert.ToUInt32(filter.color, 16);
//Console.WriteLine((double)filter.amount / 100);
for (uint y = 0; y < FreeImage.GetHeight(dib); y++)
{
for (uint x = 0; x < FreeImage.GetWidth(dib); x++)
{
FreeImage.GetPixelColor(dib, x, y, out oldColor);
overlayColor.rgbReserved = oldColor.rgbReserved;
FreeImage.SetPixelColor(dib, x, y, ref overlayColor);
}
}
}
catch { }
break;
}
}
}
}
public GDIBitmap(string filename)
{
FreeImage img = new FreeImage(filename);
IntPtr deskDC = NativeUser32Api.GetDC(new IntPtr(0));
_destDC = NativeGdi32Api.CreateCompatibleDC(deskDC);
IntPtr oldObj = NativeGdi32Api.SelectObject(_destDC, _hBmp);
_hBmp = NativeGdi32Api.CreateCompatibleBitmap(_destDC, img.Width, img.Height);
img.PaintToDevice(_destDC, 0, 0, img.Width, img.Height, 0, 0, 0, img.Height, 0);
NativeGdi32Api.SelectObject(_destDC, oldObj);
_width = img.Width;
_height = img.Height;
NativeGdi32Api.DeleteDC(deskDC);
//NativeGdi32Api.DeleteDC(destDC);
img.Dispose();
}
public Base64Image(string dataURI, FREE_IMAGE_LOAD_FLAGS flags)
{
Match match = Regex.Match(dataURI, @"data:image/(?<type>.+?);base64,(?<data>.+)");
if (match.Groups["data"] != null)
{
byte[] byteArray = Convert.FromBase64String(match.Groups["data"].Value);
using (MemoryStream byteStream = new MemoryStream(byteArray))
{
dib.SetNull();
FREE_IMAGE_FORMAT format = FREE_IMAGE_FORMAT.FIF_PNG;
if (match.Groups["type"] != null)
{
switch (match.Groups["type"].Value.ToLower())
{
case "bmp":
{
format = FREE_IMAGE_FORMAT.FIF_BMP;
break;
}
case "png":
{
format = FREE_IMAGE_FORMAT.FIF_PNG;
break;
}
case "jpeg":
case "jpg":
{
format = FREE_IMAGE_FORMAT.FIF_JPEG;
break;
}
case "tga":
{
format = FREE_IMAGE_FORMAT.FIF_TARGA;
break;
}
}
}
dib = FreeImage.LoadFromStream(byteStream, flags, ref format);
}
}
}
//private string getSuffix(ExportFileType type) {
//}
private DibMd loadFile(string srcPath, int icoSize)
{
string srcSuffix = Path.GetExtension(srcPath).ToLower();
FIBITMAP dib;
try {
switch (srcSuffix)
{
case ".ico": {
dib = FreeImage.Load(FREE_IMAGE_FORMAT.FIF_ICO, srcPath, FREE_IMAGE_LOAD_FLAGS.DEFAULT);
break;
}
case ".bmp": {
dib = FreeImage.Load(FREE_IMAGE_FORMAT.FIF_BMP, srcPath, FREE_IMAGE_LOAD_FLAGS.DEFAULT);
break;
}
case ".jpg": {
dib = FreeImage.Load(FREE_IMAGE_FORMAT.FIF_JPEG, srcPath, FREE_IMAGE_LOAD_FLAGS.DEFAULT);
break;
}
case ".png": {
dib = FreeImage.Load(FREE_IMAGE_FORMAT.FIF_PNG, srcPath, FREE_IMAGE_LOAD_FLAGS.DEFAULT);
break;
}
default: {
Bitmap img = FileIcon.getIcon(srcPath, icoSize);
if (img == null)
{
return(null);
}
dib = FreeImage.CreateFromBitmap(img);
break;
//return;
}
}
return(new DibMd(dib));
} catch (Exception) { }
return(null);
}
/// <summary>
/// Convert tga -> bitmap
/// </summary>
/// <param name="data">bytes of tga image file</param>
/// <returns></returns>
public Bitmap Tga2Bitmap(byte[] data)
{
Bitmap bm;
using (var ms = new MemoryStream(data))
{
// create targa
FIBITMAP dib = FreeImage.LoadFromStream(ms, FREE_IMAGE_LOAD_FLAGS.TARGA_LOAD_RGB888);
if (dib.IsNull)
{
throw new Exception("Targa image is corrupted");
}
// convert targa->bitmap
bm = FreeImage.GetBitmap(dib);
}
return(bm);
}
public IEncoder CreateIfSuitable(ResizeSettings settings, object original)
{
ImageFormat requestedFormat = DefaultEncoder.GetRequestedFormat(settings.Format, ImageFormat.Jpeg);
if (requestedFormat == null || !IsValidOutputFormat(requestedFormat))
{
return(null); //An unsupported format was explicitly specified.
}
if (!"freeimage".Equals(settings["encoder"], StringComparison.OrdinalIgnoreCase))
{
return(null);
}
if (!FreeImage.IsAvailable())
{
return(null);
}
return(new FreeImageEncoderPlugin(settings, original));
}
private DibMd formatOutput(DibMd dibMd, int icoSize, int bpp)
{
if (dibMd == null)
{
return(null);
}
uint width = FreeImage.GetWidth(dibMd.dib);
uint height = FreeImage.GetHeight(dibMd.dib);
try {
FIBITMAP dibOut = formatImage(dibMd.dib, icoSize, bpp);
return(new DibMd(dibOut));
} catch (Exception) { }
return(null);
}
public override IAsset Import(string pathToFile)
{
var name = Path.GetFileNameWithoutExtension(pathToFile);
if (Texture.textures.ContainsKey(name))
{
return(Texture.textures[name]);
}
var texture = new Texture();
var dib = FreeImage.LoadEx(pathToFile);
texture.TBO = -1;
texture.FullPath = pathToFile;
texture.bitmap = FreeImage.GetBitmap(dib);
//Console.WriteLine (IsPowerOfTwo(texture.bitmap.Width) +" : "+IsPowerOfTwo(texture.bitmap.Height));
Texture.textures.Add(texture.Name, texture);
return(texture);
}
private void ResizeImage(string file)
{
string newfile = Path.Combine(_tempFolder, "img" + _counter.ToString("000000") + ".jpg");
FIBITMAP dib = FreeImage.LoadEx(file);
uint dw = FreeImage.GetWidth(dib);
uint dh = FreeImage.GetHeight(dib);
int tw = ServiceProvider.Settings.DefaultSession.TimeLapse.VideoType.Width;
int th = ServiceProvider.Settings.DefaultSession.TimeLapse.VideoType.Height;
double zw = (tw / (double)dw);
double zh = (th / (double)dh);
double z = 0;
z = !ServiceProvider.Settings.DefaultSession.TimeLapse.FillImage ? ((zw <= zh) ? zw : zh) : ((zw >= zh) ? zw : zh);
dw = (uint)(dw * z);
dh = (uint)(dh * z);
int difw = (int)(tw - dw);
int difh = (int)(th - dh);
if (FreeImage.GetFileType(file, 0) == FREE_IMAGE_FORMAT.FIF_RAW)
{
FIBITMAP bmp = FreeImage.ToneMapping(dib, FREE_IMAGE_TMO.FITMO_REINHARD05, 0, 0); // ConvertToType(dib, FREE_IMAGE_TYPE.FIT_BITMAP, false);
FIBITMAP resized = FreeImage.Rescale(bmp, (int)dw, (int)dh, FREE_IMAGE_FILTER.FILTER_BILINEAR);
FIBITMAP final = FreeImage.EnlargeCanvas <RGBQUAD>(resized, difw / 2, difh / 2, difw - (difw / 2), difh - (difh / 2),
new RGBQUAD(System.Drawing.Color.Black),
FREE_IMAGE_COLOR_OPTIONS.FICO_RGB);
FreeImage.SaveEx(final, newfile);
FreeImage.UnloadEx(ref final);
FreeImage.UnloadEx(ref resized);
FreeImage.UnloadEx(ref dib);
FreeImage.UnloadEx(ref bmp);
}
else
{
FIBITMAP resized = FreeImage.Rescale(dib, (int)dw, (int)dh, FREE_IMAGE_FILTER.FILTER_BILINEAR);
FIBITMAP final = FreeImage.EnlargeCanvas <RGBQUAD>(resized, difw / 2, difh / 2, difw - (difw / 2), difh - (difh / 2),
new RGBQUAD(System.Drawing.Color.Black),
FREE_IMAGE_COLOR_OPTIONS.FICO_RGB);
FreeImage.SaveEx(final, newfile);
FreeImage.UnloadEx(ref final);
FreeImage.UnloadEx(ref resized);
FreeImage.UnloadEx(ref dib);
}
}
public GDIBitmap(string filename)
{
FreeImage img = new FreeImage(filename);
IntPtr deskDC = NativeUser32Api.GetDC(new IntPtr(0));
_destDC = NativeGdi32Api.CreateCompatibleDC(deskDC);
IntPtr oldObj = NativeGdi32Api.SelectObject(_destDC, _hBmp);
_hBmp = NativeGdi32Api.CreateCompatibleBitmap(_destDC, img.Width, img.Height);
img.PaintToDevice(_destDC, 0, 0, img.Width, img.Height, 0, 0, 0, img.Height, 0);
NativeGdi32Api.SelectObject(_destDC, oldObj);
_width = img.Width;
_height = img.Height;
NativeGdi32Api.DeleteDC(deskDC);
//NativeGdi32Api.DeleteDC(destDC);
img.Dispose();
}
static void Main(string[] args)
{
// Check if FreeImage.dll is available (can be in %path%).
if (!FreeImage.IsAvailable())
{
Console.WriteLine("FreeImage.dll seems to be missing. Aborting.");
return;
}
// Add this class to the message event
FreeImageEngine.Message += new OutputMessageFunction(FreeImage_Message);
Sample sample = new Sample();
sample.Example();
// Remove this class from the message event
FreeImageEngine.Message -= new OutputMessageFunction(FreeImage_Message);
}
private void btnLoadFile_Click(object sender, EventArgs e)
{
// Loads up a file dialog
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "Image Files|*.bmp;*.jpg;*.png;*.gif;*.tga; | All files|*.*";
if (ofd.ShowDialog() == DialogResult.OK)
{
// If there were previous textures, dispose of them
ClearTextures();
// Load a temporary file
FIBITMAP tmpFile = FreeImage.LoadEx(ofd.FileName);
if (tmpFile.IsNull)
{
MessageBox.Show("Couldn't load the selected image!");
return;
}
// Convert it to 32 bits
FIBITMAP imgFile = FreeImage.ConvertTo32Bits(tmpFile);
// Dispose of the temp file
FreeImage.UnloadEx(ref tmpFile);
// Get a .NET bitmap from FreeImage
bmTexture = FreeImage.GetBitmap(imgFile);
// Get the bytes as well as other information from the file
normalMap.SetTexture(imgFile);
// Dispose of another FreeImage file
FreeImage.UnloadEx(ref imgFile);
// Put it on screen
pbxTexture.Image = bmTexture;
// Generate the normal map with the default settings
GenerateNormalMap();
// Enable the options
ToggleOptions(true);
}
}
/// <summary>
/// Convert bitmap -> tga
/// </summary>
/// <param name="image">image to convert</param>
/// <returns></returns>
public FIBITMAP Bitmap2Tga(Bitmap image)
{
FIBITMAP dib;
using (var bitmap = new Bitmap(image.Width, image.Height))
{
using (var canvas = Graphics.FromImage(bitmap))
{
// draw bitmap on canvas
canvas.InterpolationMode = InterpolationMode.HighQualityBicubic;
canvas.DrawImage(image, 0, 0, image.Width, image.Height);
canvas.Save();
// convert canvas to freeimage
dib = FreeImage.CreateFromBitmap(bitmap);
}
}
return(dib);
}
public override object Process(FileInfo myInfo, string FilePath)
{
TextureComponent myTexture = new TextureComponent();
FileStream myStream = ReadFileStream(myInfo, FilePath);
var Result2 = FreeImage.LoadFromStream(myStream);
myTexture.Width = FreeImage.GetWidth(Result2);
myTexture.Height = FreeImage.GetHeight(Result2);
var Type = FreeImage.GetImageType(Result2);
Debug.WriteLine("ImageType: " + Enum.GetName(typeof(FREE_IMAGE_TYPE), Type) + " was detected!");
FreeImage.ConvertToType(Result2, FREE_IMAGE_TYPE.FIT_BITMAP, true);
// The bits per pixel and image type may have changed
myTexture.bpp = FreeImage.GetBPP(Result2);
myTexture.pitch = (int)FreeImage.GetPitch(Result2);
myTexture.redMask = FreeImage.GetRedMask(Result2);
myTexture.greenMask = FreeImage.GetGreenMask(Result2);
myTexture.blueMask = FreeImage.GetBlueMask(Result2);
myTexture.ImageBytes = new uint[(int)(myTexture.Width * myTexture.Height)];
// Create the byte array for the data
var Data = new byte[(int)((myTexture.Width * myTexture.Height * myTexture.bpp - 1f) / 8) + 1];
//Converts the pixel data to bytes, do not try to use this call to switch the color channels because that only works for 16bpp bitmaps
FreeImage.ConvertToRawBits(Data, Result2, myTexture.pitch, myTexture.bpp, myTexture.redMask, myTexture.greenMask, myTexture.blueMask, true);
int Count = Vector <byte> .Count;
float Iterator = Data.Length - (Data.Length % Count);
Vector <byte> Work;
int DestIterator = 0;
for (int i = 0; i < Iterator; i += Count)
{
Work = new Vector <byte>(Data, i);
var Result = Vector.AsVectorUInt32(Work);
Result.CopyTo(myTexture.ImageBytes, DestIterator++);
}
//Array.Copy(Data, 0, myTexture.ImageBytes, 0, Data.Length);
//FreeImage.FreeHbitmap(Result2); //TODO: FREE THE IMAGE OR LEAK
myStream.Close();
return(myTexture);
}
public static ushort GetHeight(this FIBITMAP dib, Vector2 p)
{
uint ImageHeight = FreeImage.GetHeight(dib);
uint ImageWidth = FreeImage.GetWidth(dib);
int scanline = (int)(ImageHeight - 1 - p.Y);
if (scanline < 0 || scanline >= ImageHeight)
{
throw new Exception($"Invalid Y coordinate {p.Y}");
}
if (p.X < 0 || p.X >= ImageWidth)
{
throw new Exception($"Invalid X coordinate {p.X}");
}
Scanline <ushort> line = new Scanline <ushort>(dib, scanline);
return(line.Data[(int)p.X]);
}
/// <summary>
/// Uploads an array of bytes as a texture.
/// </summary>
/// <param name="data">The bytes to upload.</param>
internal override void Create(byte[] data)
{
FIBITMAP freeImageBitmap;
// Put the bytes into a stream.
using (MemoryStream stream = new MemoryStream(data))
{
// Get the image format and load the image as a FreeImageBitmap.
FREE_IMAGE_FORMAT fileType = FreeImage.GetFileTypeFromStream(stream);
freeImageBitmap = FreeImage.ConvertTo32Bits(FreeImage.LoadFromStream(stream, ref fileType));
// Assign size.
Size = new Vector2(FreeImage.GetWidth(freeImageBitmap), FreeImage.GetHeight(freeImageBitmap));
}
// Upload the texture on the GL thread.
GLThread.ExecuteGLThread(() =>
{
Pointer = GL.GenTexture();
TextureMatrix = Matrix4.CreateOrthographicOffCenter(0, Size.X * 2, Size.Y * 2, 0, 0, 1);
// Bind the texture.
Bind(0);
// Set scaling to pixel perfect.
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (float)All.Nearest);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (float)All.Nearest);
// Create a swizzle mask to convert RGBA to BGRA which for some reason is the format FreeImage spits out above.
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleR, (int)All.Blue);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleG, (int)All.Green);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleB, (int)All.Red);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleA, (int)All.Alpha);
// Upload the texture.
GL.TexImage2D(TextureTarget2d.Texture2D, 0, TextureComponentCount.Rgba8, (int)Size.X, (int)Size.Y, 0, PixelFormat.Rgba, PixelType.UnsignedByte, FreeImage.GetBits(freeImageBitmap));
Helpers.CheckError("uploading texture");
// Cleanup FreeImage object.
FreeImage.Unload(freeImageBitmap);
});
}
