796 lines
26 KiB
C#
796 lines
26 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace AForge.Imaging;
|
|
|
|
public class UnmanagedImage : IDisposable
|
|
{
|
|
private IntPtr imageData;
|
|
|
|
private int width;
|
|
|
|
private int height;
|
|
|
|
private int stride;
|
|
|
|
private PixelFormat pixelFormat;
|
|
|
|
private bool mustBeDisposed;
|
|
|
|
public IntPtr ImageData => imageData;
|
|
|
|
public int Width => width;
|
|
|
|
public int Height => height;
|
|
|
|
public int Stride => stride;
|
|
|
|
public PixelFormat PixelFormat => pixelFormat;
|
|
|
|
public UnmanagedImage(IntPtr imageData, int width, int height, int stride, PixelFormat pixelFormat)
|
|
{
|
|
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
|
|
this.imageData = imageData;
|
|
this.width = width;
|
|
this.height = height;
|
|
this.stride = stride;
|
|
this.pixelFormat = pixelFormat;
|
|
}
|
|
|
|
public UnmanagedImage(BitmapData bitmapData)
|
|
{
|
|
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
|
|
imageData = bitmapData.Scan0;
|
|
width = bitmapData.Width;
|
|
height = bitmapData.Height;
|
|
stride = bitmapData.Stride;
|
|
pixelFormat = bitmapData.PixelFormat;
|
|
}
|
|
|
|
~UnmanagedImage()
|
|
{
|
|
Dispose(disposing: false);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(disposing: true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (mustBeDisposed && imageData != IntPtr.Zero)
|
|
{
|
|
Marshal.FreeHGlobal(imageData);
|
|
GC.RemoveMemoryPressure(stride * height);
|
|
imageData = IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
public UnmanagedImage Clone()
|
|
{
|
|
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
|
|
IntPtr dst = Marshal.AllocHGlobal(stride * height);
|
|
GC.AddMemoryPressure(stride * height);
|
|
UnmanagedImage unmanagedImage = new UnmanagedImage(dst, width, height, stride, pixelFormat);
|
|
unmanagedImage.mustBeDisposed = true;
|
|
SystemTools.CopyUnmanagedMemory(dst, imageData, stride * height);
|
|
return unmanagedImage;
|
|
}
|
|
|
|
public unsafe void Copy(UnmanagedImage destImage)
|
|
{
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
|
if (width != destImage.width || height != destImage.height || pixelFormat != destImage.pixelFormat)
|
|
{
|
|
throw new InvalidImagePropertiesException("Destination image has different size or pixel format.");
|
|
}
|
|
if (stride == destImage.stride)
|
|
{
|
|
SystemTools.CopyUnmanagedMemory(destImage.imageData, imageData, stride * height);
|
|
return;
|
|
}
|
|
int num = destImage.stride;
|
|
int count = ((stride < num) ? stride : num);
|
|
byte* ptr = (byte*)imageData.ToPointer();
|
|
byte* ptr2 = (byte*)destImage.imageData.ToPointer();
|
|
for (int i = 0; i < height; i++)
|
|
{
|
|
SystemTools.CopyUnmanagedMemory(ptr2, ptr, count);
|
|
ptr2 += num;
|
|
ptr += stride;
|
|
}
|
|
}
|
|
|
|
public static UnmanagedImage Create(int width, int height, PixelFormat pixelFormat)
|
|
{
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000c: Invalid comparison between Unknown and I4
|
|
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0046: Invalid comparison between Unknown and I4
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0015: Invalid comparison between Unknown and I4
|
|
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0063: Invalid comparison between Unknown and I4
|
|
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_004f: Invalid comparison between Unknown and I4
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0032: Invalid comparison between Unknown and I4
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001e: Invalid comparison between Unknown and I4
|
|
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_006c: Invalid comparison between Unknown and I4
|
|
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0058: Invalid comparison between Unknown and I4
|
|
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_003b: Invalid comparison between Unknown and I4
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0027: Invalid comparison between Unknown and I4
|
|
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0075: Invalid comparison between Unknown and I4
|
|
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
|
|
int num = 0;
|
|
if ((int)pixelFormat <= 925707)
|
|
{
|
|
if ((int)pixelFormat <= 139273)
|
|
{
|
|
if ((int)pixelFormat != 137224)
|
|
{
|
|
if ((int)pixelFormat == 139273)
|
|
{
|
|
goto IL_0085;
|
|
}
|
|
goto IL_0091;
|
|
}
|
|
num = 3;
|
|
}
|
|
else
|
|
{
|
|
if ((int)pixelFormat != 198659)
|
|
{
|
|
if ((int)pixelFormat == 925707)
|
|
{
|
|
goto IL_0085;
|
|
}
|
|
goto IL_0091;
|
|
}
|
|
num = 1;
|
|
}
|
|
}
|
|
else if ((int)pixelFormat <= 1060876)
|
|
{
|
|
if ((int)pixelFormat != 1052676)
|
|
{
|
|
if ((int)pixelFormat != 1060876)
|
|
{
|
|
goto IL_0091;
|
|
}
|
|
num = 6;
|
|
}
|
|
else
|
|
{
|
|
num = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((int)pixelFormat != 1851406)
|
|
{
|
|
if ((int)pixelFormat == 2498570)
|
|
{
|
|
goto IL_0085;
|
|
}
|
|
if ((int)pixelFormat != 3424269)
|
|
{
|
|
goto IL_0091;
|
|
}
|
|
}
|
|
num = 8;
|
|
}
|
|
goto IL_009c;
|
|
IL_0085:
|
|
num = 4;
|
|
goto IL_009c;
|
|
IL_0091:
|
|
throw new UnsupportedImageFormatException("Can not create image with specified pixel format.");
|
|
IL_009c:
|
|
if (width <= 0 || height <= 0)
|
|
{
|
|
throw new InvalidImagePropertiesException("Invalid image size specified.");
|
|
}
|
|
int num2 = width * num;
|
|
if (num2 % 4 != 0)
|
|
{
|
|
num2 += 4 - num2 % 4;
|
|
}
|
|
IntPtr dst = Marshal.AllocHGlobal(num2 * height);
|
|
SystemTools.SetUnmanagedMemory(dst, 0, num2 * height);
|
|
GC.AddMemoryPressure(num2 * height);
|
|
UnmanagedImage unmanagedImage = new UnmanagedImage(dst, width, height, num2, pixelFormat);
|
|
unmanagedImage.mustBeDisposed = true;
|
|
return unmanagedImage;
|
|
}
|
|
|
|
public Bitmap ToManagedImage()
|
|
{
|
|
return ToManagedImage(makeCopy: true);
|
|
}
|
|
|
|
public unsafe Bitmap ToManagedImage(bool makeCopy)
|
|
{
|
|
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_004f: Invalid comparison between Unknown and I4
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0029: Expected O, but got Unknown
|
|
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0034: Invalid comparison between Unknown and I4
|
|
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
|
|
Bitmap val = null;
|
|
try
|
|
{
|
|
if (!makeCopy)
|
|
{
|
|
val = new Bitmap(width, height, stride, pixelFormat, imageData);
|
|
if ((int)pixelFormat == 198659)
|
|
{
|
|
Image.SetGrayscalePalette(val);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
val = (Bitmap)(((int)pixelFormat == 198659) ? ((object)Image.CreateGrayscaleImage(width, height)) : ((object)new Bitmap(width, height, pixelFormat)));
|
|
BitmapData val2 = val.LockBits(new Rectangle(0, 0, width, height), (ImageLockMode)3, pixelFormat);
|
|
int num = val2.Stride;
|
|
int count = System.Math.Min(stride, num);
|
|
byte* ptr = (byte*)val2.Scan0.ToPointer();
|
|
byte* ptr2 = (byte*)imageData.ToPointer();
|
|
if (stride != num)
|
|
{
|
|
for (int i = 0; i < height; i++)
|
|
{
|
|
SystemTools.CopyUnmanagedMemory(ptr, ptr2, count);
|
|
ptr += num;
|
|
ptr2 += stride;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SystemTools.CopyUnmanagedMemory(ptr, ptr2, stride * height);
|
|
}
|
|
val.UnlockBits(val2);
|
|
}
|
|
return val;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
if (val != null)
|
|
{
|
|
((Image)val).Dispose();
|
|
}
|
|
throw new InvalidImagePropertiesException("The unmanaged image has some invalid properties, which results in failure of converting it to managed image.");
|
|
}
|
|
}
|
|
|
|
public static UnmanagedImage FromManagedImage(Bitmap image)
|
|
{
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
|
UnmanagedImage unmanagedImage = null;
|
|
BitmapData val = image.LockBits(new Rectangle(0, 0, ((Image)image).Width, ((Image)image).Height), (ImageLockMode)1, ((Image)image).PixelFormat);
|
|
try
|
|
{
|
|
return FromManagedImage(val);
|
|
}
|
|
finally
|
|
{
|
|
image.UnlockBits(val);
|
|
}
|
|
}
|
|
|
|
public static UnmanagedImage FromManagedImage(BitmapData imageData)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000d: Invalid comparison between Unknown and I4
|
|
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0015: Invalid comparison between Unknown and I4
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001d: Invalid comparison between Unknown and I4
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0025: Invalid comparison between Unknown and I4
|
|
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_002d: Invalid comparison between Unknown and I4
|
|
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0035: Invalid comparison between Unknown and I4
|
|
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_003d: Invalid comparison between Unknown and I4
|
|
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0045: Invalid comparison between Unknown and I4
|
|
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_004d: Invalid comparison between Unknown and I4
|
|
PixelFormat val = imageData.PixelFormat;
|
|
if ((int)val != 198659 && (int)val != 1052676 && (int)val != 137224 && (int)val != 139273 && (int)val != 2498570 && (int)val != 925707 && (int)val != 1060876 && (int)val != 3424269 && (int)val != 1851406)
|
|
{
|
|
throw new UnsupportedImageFormatException("Unsupported pixel format of the source image.");
|
|
}
|
|
IntPtr dst = Marshal.AllocHGlobal(imageData.Stride * imageData.Height);
|
|
GC.AddMemoryPressure(imageData.Stride * imageData.Height);
|
|
UnmanagedImage unmanagedImage = new UnmanagedImage(dst, imageData.Width, imageData.Height, imageData.Stride, val);
|
|
SystemTools.CopyUnmanagedMemory(dst, imageData.Scan0, imageData.Stride * imageData.Height);
|
|
unmanagedImage.mustBeDisposed = true;
|
|
return unmanagedImage;
|
|
}
|
|
|
|
public unsafe byte[] Collect8bppPixelValues(List<IntPoint> points)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0019: Invalid comparison between Unknown and I4
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_003b: Invalid comparison between Unknown and I4
|
|
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_005f: Invalid comparison between Unknown and I4
|
|
int num = Image.GetPixelFormatSize(pixelFormat) / 8;
|
|
if ((int)pixelFormat == 1052676 || num > 4)
|
|
{
|
|
throw new UnsupportedImageFormatException("Unsupported pixel format of the source image. Use Collect16bppPixelValues() method for it.");
|
|
}
|
|
byte[] array = new byte[points.Count * (((int)pixelFormat == 198659) ? 1 : 3)];
|
|
byte* ptr = (byte*)imageData.ToPointer();
|
|
if ((int)pixelFormat == 198659)
|
|
{
|
|
int num2 = 0;
|
|
foreach (IntPoint point in points)
|
|
{
|
|
byte* ptr2 = ptr + (nint)stride * (nint)point.Y + point.X;
|
|
array[num2++] = *ptr2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num3 = 0;
|
|
foreach (IntPoint point2 in points)
|
|
{
|
|
byte* ptr2 = ptr + (nint)stride * (nint)point2.Y + (nint)point2.X * (nint)num;
|
|
array[num3++] = ptr2[2];
|
|
array[num3++] = ptr2[1];
|
|
array[num3++] = *ptr2;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public List<IntPoint> CollectActivePixels()
|
|
{
|
|
return CollectActivePixels(new Rectangle(0, 0, width, height));
|
|
}
|
|
|
|
public unsafe List<IntPoint> CollectActivePixels(Rectangle rect)
|
|
{
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0068: Invalid comparison between Unknown and I4
|
|
List<IntPoint> list = new List<IntPoint>();
|
|
int num = Image.GetPixelFormatSize(pixelFormat) / 8;
|
|
rect.Intersect(new Rectangle(0, 0, width, height));
|
|
int x = rect.X;
|
|
int y = rect.Y;
|
|
int right = rect.Right;
|
|
int bottom = rect.Bottom;
|
|
byte* ptr = (byte*)imageData.ToPointer();
|
|
if ((int)pixelFormat == 1052676 || num > 4)
|
|
{
|
|
int num2 = num >> 1;
|
|
for (int i = y; i < bottom; i++)
|
|
{
|
|
ushort* ptr2 = (ushort*)(ptr + (nint)i * (nint)stride + (nint)x * (nint)num);
|
|
if (num2 == 1)
|
|
{
|
|
int num3 = x;
|
|
while (num3 < right)
|
|
{
|
|
if (*ptr2 != 0)
|
|
{
|
|
list.Add(new IntPoint(num3, i));
|
|
}
|
|
num3++;
|
|
ptr2++;
|
|
}
|
|
continue;
|
|
}
|
|
int num4 = x;
|
|
while (num4 < right)
|
|
{
|
|
if (ptr2[2] != 0 || ptr2[1] != 0 || *ptr2 != 0)
|
|
{
|
|
list.Add(new IntPoint(num4, i));
|
|
}
|
|
num4++;
|
|
ptr2 += num2;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int j = y; j < bottom; j++)
|
|
{
|
|
byte* ptr3 = ptr + (nint)j * (nint)stride + (nint)x * (nint)num;
|
|
if (num == 1)
|
|
{
|
|
int num5 = x;
|
|
while (num5 < right)
|
|
{
|
|
if (*ptr3 != 0)
|
|
{
|
|
list.Add(new IntPoint(num5, j));
|
|
}
|
|
num5++;
|
|
ptr3++;
|
|
}
|
|
continue;
|
|
}
|
|
int num6 = x;
|
|
while (num6 < right)
|
|
{
|
|
if (ptr3[2] != 0 || ptr3[1] != 0 || *ptr3 != 0)
|
|
{
|
|
list.Add(new IntPoint(num6, j));
|
|
}
|
|
num6++;
|
|
ptr3 += num;
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public unsafe void SetPixels(List<IntPoint> coordinates, Color color)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_004b: Invalid comparison between Unknown and I4
|
|
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_007a: Invalid comparison between Unknown and I4
|
|
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0054: Invalid comparison between Unknown and I4
|
|
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00a0: Invalid comparison between Unknown and I4
|
|
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0083: Invalid comparison between Unknown and I4
|
|
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0060: Invalid comparison between Unknown and I4
|
|
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00ac: Invalid comparison between Unknown and I4
|
|
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_008f: Invalid comparison between Unknown and I4
|
|
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_006c: Invalid comparison between Unknown and I4
|
|
//IL_049e: Unknown result type (might be due to invalid IL or missing references)
|
|
int num = Image.GetPixelFormatSize(pixelFormat) / 8;
|
|
byte* ptr = (byte*)imageData.ToPointer();
|
|
byte r = color.R;
|
|
byte g = color.G;
|
|
byte b = color.B;
|
|
byte a = color.A;
|
|
PixelFormat val = pixelFormat;
|
|
if ((int)val <= 198659)
|
|
{
|
|
if ((int)val == 137224 || (int)val == 139273)
|
|
{
|
|
foreach (IntPoint coordinate in coordinates)
|
|
{
|
|
if (coordinate.X >= 0 && coordinate.Y >= 0 && coordinate.X < width && coordinate.Y < height)
|
|
{
|
|
byte* ptr2 = ptr + (nint)coordinate.Y * (nint)stride + (nint)coordinate.X * (nint)num;
|
|
ptr2[2] = r;
|
|
ptr2[1] = g;
|
|
*ptr2 = b;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if ((int)val == 198659)
|
|
{
|
|
byte b2 = (byte)(0.2125 * (double)(int)r + 0.7154 * (double)(int)g + 0.0721 * (double)(int)b);
|
|
{
|
|
foreach (IntPoint coordinate2 in coordinates)
|
|
{
|
|
if (coordinate2.X >= 0 && coordinate2.Y >= 0 && coordinate2.X < width && coordinate2.Y < height)
|
|
{
|
|
byte* ptr3 = ptr + (nint)coordinate2.Y * (nint)stride + coordinate2.X;
|
|
*ptr3 = b2;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else if ((int)val <= 1060876)
|
|
{
|
|
if ((int)val == 1052676)
|
|
{
|
|
ushort num2 = (ushort)((ushort)(0.2125 * (double)(int)r + 0.7154 * (double)(int)g + 0.0721 * (double)(int)b) << 8);
|
|
{
|
|
foreach (IntPoint coordinate3 in coordinates)
|
|
{
|
|
if (coordinate3.X >= 0 && coordinate3.Y >= 0 && coordinate3.X < width && coordinate3.Y < height)
|
|
{
|
|
ushort* ptr4 = (ushort*)(ptr + (nint)coordinate3.Y * (nint)stride) + coordinate3.X;
|
|
*ptr4 = num2;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if ((int)val == 1060876)
|
|
{
|
|
ushort num3 = (ushort)(r << 8);
|
|
ushort num4 = (ushort)(g << 8);
|
|
ushort num5 = (ushort)(b << 8);
|
|
{
|
|
foreach (IntPoint coordinate4 in coordinates)
|
|
{
|
|
if (coordinate4.X >= 0 && coordinate4.Y >= 0 && coordinate4.X < width && coordinate4.Y < height)
|
|
{
|
|
ushort* ptr5 = (ushort*)(ptr + (nint)coordinate4.Y * (nint)stride + (nint)coordinate4.X * (nint)num);
|
|
ptr5[2] = num3;
|
|
ptr5[1] = num4;
|
|
*ptr5 = num5;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((int)val == 2498570)
|
|
{
|
|
{
|
|
foreach (IntPoint coordinate5 in coordinates)
|
|
{
|
|
if (coordinate5.X >= 0 && coordinate5.Y >= 0 && coordinate5.X < width && coordinate5.Y < height)
|
|
{
|
|
byte* ptr6 = ptr + (nint)coordinate5.Y * (nint)stride + (nint)coordinate5.X * (nint)num;
|
|
ptr6[2] = r;
|
|
ptr6[1] = g;
|
|
*ptr6 = b;
|
|
ptr6[3] = a;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if ((int)val == 3424269)
|
|
{
|
|
ushort num6 = (ushort)(r << 8);
|
|
ushort num7 = (ushort)(g << 8);
|
|
ushort num8 = (ushort)(b << 8);
|
|
ushort num9 = (ushort)(a << 8);
|
|
{
|
|
foreach (IntPoint coordinate6 in coordinates)
|
|
{
|
|
if (coordinate6.X >= 0 && coordinate6.Y >= 0 && coordinate6.X < width && coordinate6.Y < height)
|
|
{
|
|
ushort* ptr7 = (ushort*)(ptr + (nint)coordinate6.Y * (nint)stride + (nint)coordinate6.X * (nint)num);
|
|
ptr7[2] = num6;
|
|
ptr7[1] = num7;
|
|
*ptr7 = num8;
|
|
ptr7[3] = num9;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
throw new UnsupportedImageFormatException("The pixel format is not supported: " + pixelFormat);
|
|
}
|
|
|
|
public void SetPixel(IntPoint point, Color color)
|
|
{
|
|
SetPixel(point.X, point.Y, color);
|
|
}
|
|
|
|
public void SetPixel(int x, int y, Color color)
|
|
{
|
|
SetPixel(x, y, color.R, color.G, color.B, color.A);
|
|
}
|
|
|
|
public void SetPixel(int x, int y, byte value)
|
|
{
|
|
SetPixel(x, y, value, value, value, byte.MaxValue);
|
|
}
|
|
|
|
private unsafe void SetPixel(int x, int y, byte r, byte g, byte b, byte a)
|
|
{
|
|
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_005e: Invalid comparison between Unknown and I4
|
|
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0083: Invalid comparison between Unknown and I4
|
|
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0066: Invalid comparison between Unknown and I4
|
|
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00a3: Invalid comparison between Unknown and I4
|
|
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_008b: Invalid comparison between Unknown and I4
|
|
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_006e: Invalid comparison between Unknown and I4
|
|
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00ab: Invalid comparison between Unknown and I4
|
|
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0093: Invalid comparison between Unknown and I4
|
|
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0076: Invalid comparison between Unknown and I4
|
|
//IL_0181: Unknown result type (might be due to invalid IL or missing references)
|
|
if (x < 0 || y < 0 || x >= width || y >= height)
|
|
{
|
|
return;
|
|
}
|
|
int num = Image.GetPixelFormatSize(pixelFormat) / 8;
|
|
byte* ptr = (byte*)imageData.ToPointer() + (nint)y * (nint)stride + (nint)x * (nint)num;
|
|
ushort* ptr2 = (ushort*)ptr;
|
|
PixelFormat val = pixelFormat;
|
|
if ((int)val <= 198659)
|
|
{
|
|
if ((int)val == 137224 || (int)val == 139273)
|
|
{
|
|
ptr[2] = r;
|
|
ptr[1] = g;
|
|
*ptr = b;
|
|
return;
|
|
}
|
|
if ((int)val == 198659)
|
|
{
|
|
*ptr = (byte)(0.2125 * (double)(int)r + 0.7154 * (double)(int)g + 0.0721 * (double)(int)b);
|
|
return;
|
|
}
|
|
}
|
|
else if ((int)val <= 1060876)
|
|
{
|
|
if ((int)val == 1052676)
|
|
{
|
|
*ptr2 = (ushort)((ushort)(0.2125 * (double)(int)r + 0.7154 * (double)(int)g + 0.0721 * (double)(int)b) << 8);
|
|
return;
|
|
}
|
|
if ((int)val == 1060876)
|
|
{
|
|
ptr2[2] = (ushort)(r << 8);
|
|
ptr2[1] = (ushort)(g << 8);
|
|
*ptr2 = (ushort)(b << 8);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((int)val == 2498570)
|
|
{
|
|
ptr[2] = r;
|
|
ptr[1] = g;
|
|
*ptr = b;
|
|
ptr[3] = a;
|
|
return;
|
|
}
|
|
if ((int)val == 3424269)
|
|
{
|
|
ptr2[2] = (ushort)(r << 8);
|
|
ptr2[1] = (ushort)(g << 8);
|
|
*ptr2 = (ushort)(b << 8);
|
|
ptr2[3] = (ushort)(a << 8);
|
|
return;
|
|
}
|
|
}
|
|
throw new UnsupportedImageFormatException("The pixel format is not supported: " + pixelFormat);
|
|
}
|
|
|
|
public Color GetPixel(IntPoint point)
|
|
{
|
|
return GetPixel(point.X, point.Y);
|
|
}
|
|
|
|
public unsafe Color GetPixel(int x, int y)
|
|
{
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0078: Invalid comparison between Unknown and I4
|
|
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0092: Invalid comparison between Unknown and I4
|
|
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0080: Invalid comparison between Unknown and I4
|
|
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_009a: Invalid comparison between Unknown and I4
|
|
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0088: Invalid comparison between Unknown and I4
|
|
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
|
|
if (x < 0 || y < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException("x", "The specified pixel coordinate is out of image's bounds.");
|
|
}
|
|
if (x >= width || y >= height)
|
|
{
|
|
throw new ArgumentOutOfRangeException("y", "The specified pixel coordinate is out of image's bounds.");
|
|
}
|
|
Color color = default(Color);
|
|
int num = Image.GetPixelFormatSize(pixelFormat) / 8;
|
|
byte* ptr = (byte*)imageData.ToPointer() + (nint)y * (nint)stride + (nint)x * (nint)num;
|
|
PixelFormat val = pixelFormat;
|
|
if ((int)val <= 139273)
|
|
{
|
|
if ((int)val == 137224 || (int)val == 139273)
|
|
{
|
|
return Color.FromArgb(ptr[2], ptr[1], *ptr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((int)val == 198659)
|
|
{
|
|
return Color.FromArgb(*ptr, *ptr, *ptr);
|
|
}
|
|
if ((int)val == 2498570)
|
|
{
|
|
return Color.FromArgb(ptr[3], ptr[2], ptr[1], *ptr);
|
|
}
|
|
}
|
|
throw new UnsupportedImageFormatException("The pixel format is not supported: " + pixelFormat);
|
|
}
|
|
|
|
public unsafe ushort[] Collect16bppPixelValues(List<IntPoint> points)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0019: Invalid comparison between Unknown and I4
|
|
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_003f: Invalid comparison between Unknown and I4
|
|
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0063: Invalid comparison between Unknown and I4
|
|
int num = Image.GetPixelFormatSize(pixelFormat) / 8;
|
|
if ((int)pixelFormat == 198659 || num == 3 || num == 4)
|
|
{
|
|
throw new UnsupportedImageFormatException("Unsupported pixel format of the source image. Use Collect8bppPixelValues() method for it.");
|
|
}
|
|
ushort[] array = new ushort[points.Count * (((int)pixelFormat == 1052676) ? 1 : 3)];
|
|
byte* ptr = (byte*)imageData.ToPointer();
|
|
if ((int)pixelFormat == 1052676)
|
|
{
|
|
int num2 = 0;
|
|
foreach (IntPoint point in points)
|
|
{
|
|
ushort* ptr2 = (ushort*)(ptr + (nint)stride * (nint)point.Y + (nint)point.X * (nint)num);
|
|
array[num2++] = *ptr2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num3 = 0;
|
|
foreach (IntPoint point2 in points)
|
|
{
|
|
ushort* ptr2 = (ushort*)(ptr + (nint)stride * (nint)point2.Y + (nint)point2.X * (nint)num);
|
|
array[num3++] = ptr2[2];
|
|
array[num3++] = ptr2[1];
|
|
array[num3++] = *ptr2;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
}
|