protected unsafe override void ProcessFilter(UnmanagedImage sourceData, UnmanagedImage destinationData)
{
int width = destinationData.Width;
int height = destinationData.Height;
int stride = sourceData.Stride;
int stride2 = destinationData.Stride;
int num = width;
byte *ptr = (byte *)sourceData.ImageData.ToPointer();
byte *ptr2 = (byte *)destinationData.ImageData.ToPointer();
ptr += (long)minY * (long)stride;
if (destinationData.PixelFormat == PixelFormat.Format8bppIndexed)
{
ptr += minX;
}
else
{
ptr += (long)minX * 3L;
num *= 3;
}
for (int i = 0; i < height; i++)
{
SystemTools.CopyUnmanagedMemory(ptr2, ptr, num);
ptr2 += stride2;
ptr += stride;
}
}
public unsafe void Apply(UnmanagedImage sourceImage, UnmanagedImage destinationImage)
{
CheckSourceFormat(sourceImage.PixelFormat);
if (destinationImage.PixelFormat != sourceImage.PixelFormat)
{
throw new InvalidImagePropertiesException("Destination pixel format must be the same as pixel format of source image.");
}
if (destinationImage.Width != sourceImage.Width || destinationImage.Height != sourceImage.Height)
{
throw new InvalidImagePropertiesException("Destination image must have the same width and height as source image.");
}
int stride = destinationImage.Stride;
int stride2 = sourceImage.Stride;
int count = System.Math.Min(stride2, stride);
byte *ptr = (byte *)destinationImage.ImageData.ToPointer();
byte *ptr2 = (byte *)sourceImage.ImageData.ToPointer();
int i = 0;
for (int height = sourceImage.Height; i < height; i++)
{
SystemTools.CopyUnmanagedMemory(ptr, ptr2, count);
ptr += stride;
ptr2 += stride2;
}
ProcessFilter(destinationImage, new Rectangle(0, 0, destinationImage.Width, destinationImage.Height));
}
/// <summary>
/// Create managed image from the unmanaged.
/// </summary>
///
/// <returns>Returns managed copy of the unmanaged image.</returns>
///
/// <remarks><para>The method creates a managed copy of the unmanaged image with the
/// same size and pixel format.</para></remarks>
///
public Bitmap ToManagedImage()
{
// create new image of required format
Bitmap dstImage = (pixelFormat == PixelFormat.Format8bppIndexed) ?
NComputerVision.Common.Image.CreateGrayscaleImage(width, height) :
new Bitmap(width, height, pixelFormat);
// lock destination bitmap data
BitmapData dstData = dstImage.LockBits(
new Rectangle(0, 0, width, height),
ImageLockMode.ReadWrite, pixelFormat);
int dstStride = dstData.Stride;
int lineSize = System.Math.Min(stride, dstStride);
unsafe
{
byte *dst = (byte *)dstData.Scan0.ToPointer();
byte *src = (byte *)imageData.ToPointer();
// copy image
for (int y = 0; y < height; y++)
{
SystemTools.CopyUnmanagedMemory(dst, src, lineSize);
dst += dstStride;
src += stride;
}
}
// unlock destination images
dstImage.UnlockBits(dstData);
return(dstImage);
}
/// <summary>
/// Copy unmanaged image.
/// </summary>
///
/// <param name="destImage">Destination image to copy this image to.</param>
///
/// <remarks><para>The method copies current unmanaged image to the specified image.
/// Size and pixel format of the destination image must be exactly the same.</para></remarks>
///
/// <exception cref="InvalidImagePropertiesException">Destination image has different size or pixel format.</exception>
///
public void Copy(UnmanagedImage destImage)
{
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)
{
// copy entire image
SystemTools.CopyUnmanagedMemory(destImage.imageData, imageData, stride * height);
}
else
{
unsafe
{
int dstStride = destImage.stride;
int copyLength = (stride < dstStride) ? stride : dstStride;
byte *src = (byte *)imageData.ToPointer();
byte *dst = (byte *)destImage.imageData.ToPointer();
// copy line by line
for (int i = 0; i < height; i++)
{
SystemTools.CopyUnmanagedMemory(dst, src, copyLength);
dst += dstStride;
src += stride;
}
}
}
}
public unsafe void Apply(UnmanagedImage sourceImage, UnmanagedImage destinationImage)
{
this.CheckSourceFormat(sourceImage.PixelFormat);
if (destinationImage.PixelFormat != sourceImage.PixelFormat)
{
throw new InvalidImagePropertiesException("Destination pixel format must be the same as pixel format of source image.");
}
if ((destinationImage.Width != sourceImage.Width) || (destinationImage.Height != sourceImage.Height))
{
throw new InvalidImagePropertiesException("Destination image must have the same width and height as source image.");
}
int stride = destinationImage.Stride;
int num2 = sourceImage.Stride;
int count = Math.Min(num2, stride);
byte *dst = (byte *)destinationImage.ImageData.ToPointer();
byte *src = (byte *)sourceImage.ImageData.ToPointer();
int num4 = 0;
int height = sourceImage.Height;
while (num4 < height)
{
SystemTools.CopyUnmanagedMemory(dst, src, count);
dst += stride;
src += num2;
num4++;
}
this.ProcessFilter(destinationImage);
}
protected unsafe override void ProcessFilter(UnmanagedImage sourceData, UnmanagedImage destinationData)
{
Rectangle rectangle = rect;
rectangle.Intersect(new Rectangle(0, 0, sourceData.Width, sourceData.Height));
int left = rectangle.Left;
int top = rectangle.Top;
int num = rectangle.Bottom - 1;
int width = rectangle.Width;
int stride = sourceData.Stride;
int stride2 = destinationData.Stride;
int num2 = System.Drawing.Image.GetPixelFormatSize(sourceData.PixelFormat) / 8;
int count = width * num2;
byte *ptr = (byte *)sourceData.ImageData.ToPointer() + (long)top * (long)stride + (long)left * (long)num2;
byte *ptr2 = (byte *)destinationData.ImageData.ToPointer();
if (rect.Top < 0)
{
ptr2 -= (long)stride2 * (long)rect.Top;
}
if (rect.Left < 0)
{
ptr2 -= (long)num2 * (long)rect.Left;
}
for (int i = top; i <= num; i++)
{
SystemTools.CopyUnmanagedMemory(ptr2, ptr, count);
ptr += stride;
ptr2 += stride2;
}
}
protected override unsafe void ProcessFilter(UnmanagedImage sourceData, UnmanagedImage destinationData)
{
System.Drawing.Rectangle rect = this.rect;
rect.Intersect(new System.Drawing.Rectangle(0, 0, sourceData.Width, sourceData.Height));
int left = rect.Left;
int top = rect.Top;
int num3 = rect.Bottom - 1;
int width = rect.Width;
int stride = sourceData.Stride;
int num6 = destinationData.Stride;
int num7 = Image.GetPixelFormatSize(sourceData.PixelFormat) / 8;
int count = width * num7;
byte *src = (byte *)((sourceData.ImageData.ToPointer() + (top * stride)) + (left * num7));
byte *dst = (byte *)destinationData.ImageData.ToPointer();
if (this.rect.Top < 0)
{
dst -= num6 * this.rect.Top;
}
if (this.rect.Left < 0)
{
dst -= num7 * this.rect.Left;
}
for (int i = top; i <= num3; i++)
{
SystemTools.CopyUnmanagedMemory(dst, src, count);
src += stride;
dst += num6;
}
}
/// <summary>
/// Create unmanaged image from the specified managed image.
/// </summary>
///
/// <param name="imageData">Source locked image data.</param>
///
/// <returns>Returns new unmanaged image, which is a copy of source managed image.</returns>
///
/// <remarks><para>The method creates an exact copy of specified managed image, but allocated
/// in unmanaged memory. This means that managed image may be unlocked right after call to this
/// method.</para></remarks>
///
/// <exception cref="UnsupportedImageFormatException">Unsupported pixel format of source image.</exception>
///
public static UnmanagedImage FromManagedImage(BitmapData imageData)
{
PixelFormat pixelFormat = imageData.PixelFormat;
// check source pixel format
if (
(pixelFormat != PixelFormat.Format8bppIndexed) &&
(pixelFormat != PixelFormat.Format16bppGrayScale) &&
(pixelFormat != PixelFormat.Format24bppRgb) &&
(pixelFormat != PixelFormat.Format32bppRgb) &&
(pixelFormat != PixelFormat.Format32bppArgb) &&
(pixelFormat != PixelFormat.Format48bppRgb) &&
(pixelFormat != PixelFormat.Format64bppArgb))
{
throw new UnsupportedImageFormatException("Unsupported pixel format of the source image.");
}
// allocate memory for the image
IntPtr dstImageData = System.Runtime.InteropServices.Marshal.AllocHGlobal(imageData.Stride * imageData.Height);
UnmanagedImage image = new UnmanagedImage(dstImageData, imageData.Width, imageData.Height, imageData.Stride, pixelFormat);
SystemTools.CopyUnmanagedMemory(dstImageData, imageData.Scan0, imageData.Stride * imageData.Height);
image.mustBeDisposed = true;
return(image);
}
public unsafe void ProcessFrame(UnmanagedImage videoFrame)
{
lock (sync)
{
if (previousFrame == null)
{
width = videoFrame.Width;
height = videoFrame.Height;
previousFrame = UnmanagedImage.Create(width, height, PixelFormat.Format8bppIndexed);
motionFrame = UnmanagedImage.Create(width, height, PixelFormat.Format8bppIndexed);
frameSize = motionFrame.Stride * height;
if (suppressNoise)
{
tempFrame = UnmanagedImage.Create(width, height, PixelFormat.Format8bppIndexed);
}
Tools.ConvertToGrayscale(videoFrame, previousFrame);
return;
}
if ((videoFrame.Width != width) || (videoFrame.Height != height))
{
return;
}
Tools.ConvertToGrayscale(videoFrame, motionFrame);
byte *prevFrame = (byte *)previousFrame.ImageData.ToPointer();
byte *currFrame = (byte *)motionFrame.ImageData.ToPointer();
int diff;
for (int i = 0; i < frameSize; i++, prevFrame++, currFrame++)
{
diff = (int)*currFrame - (int)*prevFrame;
*prevFrame = *currFrame;
*currFrame = ((diff >= differenceThreshold) || (diff <= differenceThresholdNeg)) ? (byte)255 : (byte)0;
}
if (suppressNoise)
{
SystemTools.CopyUnmanagedMemory(tempFrame.ImageData, motionFrame.ImageData, frameSize);
erosionFilter.Apply(tempFrame, motionFrame);
}
pixelsChanged = 0;
byte *motion = (byte *)motionFrame.ImageData.ToPointer();
for (int i = 0; i < frameSize; i++, motion++)
{
pixelsChanged += (*motion & 1);
}
}
}
protected override unsafe void ProcessFilter(UnmanagedImage source, UnmanagedImage destination)
{
int num = Image.GetPixelFormatSize(source.PixelFormat) / 8;
int width = source.Width;
int height = source.Height;
int num4 = Math.Min(width, this.warpMap.GetLength(1));
int num5 = Math.Min(height, this.warpMap.GetLength(0));
int stride = source.Stride;
int num7 = destination.Stride;
int num8 = num7 - (num4 * num);
byte *numPtr = (byte *)source.ImageData.ToPointer();
byte *dst = (byte *)destination.ImageData.ToPointer();
for (int i = 0; i < num5; i++)
{
for (int j = 0; j < num4; j++)
{
int num9 = j + this.warpMap[i, j].X;
int num10 = i + this.warpMap[i, j].Y;
if (((num9 >= 0) && (num10 >= 0)) && ((num9 < width) && (num10 < height)))
{
byte *numPtr3 = (numPtr + (num10 * stride)) + (num9 * num);
int num13 = 0;
while (num13 < num)
{
dst[0] = numPtr3[0];
num13++;
dst++;
numPtr3++;
}
}
else
{
int num14 = 0;
while (num14 < num)
{
dst[0] = 0;
num14++;
dst++;
}
}
}
if (width != num4)
{
SystemTools.CopyUnmanagedMemory(dst, (numPtr + (i * stride)) + (num4 * num), (width - num4) * num);
}
dst += num8;
}
int num15 = num5;
while (num15 < height)
{
SystemTools.CopyUnmanagedMemory(dst, numPtr + (num15 * stride), width * num);
num15++;
dst += num7;
}
}
protected unsafe override void ProcessFilter(UnmanagedImage source, UnmanagedImage destination)
{
int num = System.Drawing.Image.GetPixelFormatSize(source.PixelFormat) / 8;
int width = source.Width;
int height = source.Height;
int num2 = System.Math.Min(width, warpMap.GetLength(1));
int num3 = System.Math.Min(height, warpMap.GetLength(0));
int stride = source.Stride;
int stride2 = destination.Stride;
int num4 = stride2 - num2 * num;
byte *ptr = (byte *)source.ImageData.ToPointer();
byte *ptr2 = (byte *)destination.ImageData.ToPointer();
for (int i = 0; i < num3; i++)
{
for (int j = 0; j < num2; j++)
{
int num5 = j + warpMap[i, j].X;
int num6 = i + warpMap[i, j].Y;
if (num5 >= 0 && num6 >= 0 && num5 < width && num6 < height)
{
byte *ptr3 = ptr + (long)num6 * (long)stride + (long)num5 * (long)num;
int num7 = 0;
while (num7 < num)
{
*ptr2 = *ptr3;
num7++;
ptr2++;
ptr3++;
}
}
else
{
int num8 = 0;
while (num8 < num)
{
*ptr2 = 0;
num8++;
ptr2++;
}
}
}
if (width != num2)
{
SystemTools.CopyUnmanagedMemory(ptr2, ptr + (long)i * (long)stride + (long)num2 * (long)num, (width - num2) * num);
}
ptr2 += num4;
}
int num9 = num3;
while (num9 < height)
{
SystemTools.CopyUnmanagedMemory(ptr2, ptr + (long)num9 * (long)stride, width * num);
num9++;
ptr2 += stride2;
}
}
protected override unsafe void ProcessFilter(UnmanagedImage source, UnmanagedImage destination, Rectangle rect)
{
int num = Image.GetPixelFormatSize(source.PixelFormat) / 8;
int left = rect.Left;
int top = rect.Top;
int num4 = left + rect.Width;
int num5 = top + rect.Height;
int stride = source.Stride;
int num7 = destination.Stride;
int num8 = num7 - (rect.Width * num);
int maxValue = (this.radius * 2) + 1;
byte *src = (byte *)source.ImageData.ToPointer();
byte *dst = (byte *)destination.ImageData.ToPointer();
if (stride == num7)
{
SystemTools.CopyUnmanagedMemory(dst, src, stride * source.Height);
}
else
{
int count = source.Width * num;
int num13 = 0;
int height = source.Height;
while (num13 < height)
{
SystemTools.CopyUnmanagedMemory(dst + (num7 * num13), src + (stride * num13), count);
num13++;
}
}
dst += (top * num7) + (left * num);
for (int i = top; i < num5; i++)
{
for (int j = left; j < num4; j++)
{
int num9 = (j + this.rand.Next(maxValue)) - this.radius;
int num10 = (i + this.rand.Next(maxValue)) - this.radius;
if (((num9 >= left) && (num10 >= top)) && ((num9 < num4) && (num10 < num5)))
{
byte *numPtr3 = (src + (num10 * stride)) + (num9 * num);
int num17 = 0;
while (num17 < num)
{
dst[0] = numPtr3[0];
num17++;
dst++;
numPtr3++;
}
}
else
{
dst += num;
}
}
dst += num8;
}
}
public UnmanagedImage Clone()
{
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);
}
protected unsafe override void ProcessFilter(UnmanagedImage source, UnmanagedImage destination, Rectangle rect)
{
int num = System.Drawing.Image.GetPixelFormatSize(source.PixelFormat) / 8;
int left = rect.Left;
int top = rect.Top;
int num2 = left + rect.Width;
int num3 = top + rect.Height;
int stride = source.Stride;
int stride2 = destination.Stride;
int num4 = stride2 - rect.Width * num;
int maxValue = radius * 2 + 1;
byte *ptr = (byte *)source.ImageData.ToPointer();
byte *ptr2 = (byte *)destination.ImageData.ToPointer();
if (stride == stride2)
{
SystemTools.CopyUnmanagedMemory(ptr2, ptr, stride * source.Height);
}
else
{
int count = source.Width * num;
int i = 0;
for (int height = source.Height; i < height; i++)
{
SystemTools.CopyUnmanagedMemory(ptr2 + (long)stride2 * (long)i, ptr + (long)stride * (long)i, count);
}
}
ptr2 += top * stride2 + left * num;
for (int j = top; j < num3; j++)
{
for (int k = left; k < num2; k++)
{
int num5 = k + rand.Next(maxValue) - radius;
int num6 = j + rand.Next(maxValue) - radius;
if (num5 >= left && num6 >= top && num5 < num2 && num6 < num3)
{
byte *ptr3 = ptr + (long)num6 * (long)stride + (long)num5 * (long)num;
int num7 = 0;
while (num7 < num)
{
*ptr2 = *ptr3;
num7++;
ptr2++;
ptr3++;
}
}
else
{
ptr2 += num;
}
}
ptr2 += num4;
}
}
public UnmanagedImage Clone()
{
IntPtr imageData = Marshal.AllocHGlobal((int)(this.stride * this.height));
UnmanagedImage image = new UnmanagedImage(imageData, this.width, this.height, this.stride, this.pixelFormat)
{
mustBeDisposed = true
};
SystemTools.CopyUnmanagedMemory(imageData, this.imageData, this.stride * this.height);
return(image);
}
public static Bitmap Clone(BitmapData sourceData)
{
int width = sourceData.Width;
int height = sourceData.Height;
Bitmap bitmap = new Bitmap(width, height, sourceData.PixelFormat);
BitmapData bitmapdata = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
SystemTools.CopyUnmanagedMemory(bitmapdata.Scan0, sourceData.Scan0, height * sourceData.Stride);
bitmap.UnlockBits(bitmapdata);
return(bitmap);
}
/// <summary>
/// Clone the unmanaged images.
/// </summary>
///
/// <returns>Returns clone of the unmanaged image.</returns>
///
/// <remarks><para>The method does complete cloning of the object.</para></remarks>
///
public UnmanagedImage Clone()
{
// allocate memory for the image
IntPtr newImageData = System.Runtime.InteropServices.Marshal.AllocHGlobal(stride * height);
UnmanagedImage newImage = new UnmanagedImage(newImageData, width, height, stride, pixelFormat);
newImage.mustBeDisposed = true;
SystemTools.CopyUnmanagedMemory(newImageData, imageData, stride * height);
return(newImage);
}
public void ApplyInPlace(UnmanagedImage image, Rectangle rect)
{
this.CheckSourceFormat(image.PixelFormat);
rect.Intersect(new Rectangle(0, 0, image.Width, image.Height));
if ((rect.Width | rect.Height) != 0)
{
int size = image.Stride * image.Height;
IntPtr dst = MemoryManager.Alloc(size);
SystemTools.CopyUnmanagedMemory(dst, image.ImageData, size);
this.ProcessFilter(new UnmanagedImage(dst, image.Width, image.Height, image.Stride, image.PixelFormat), image, rect);
MemoryManager.Free(dst);
}
}
public static UnmanagedImage FromManagedImage(BitmapData imageData)
{
System.Drawing.Imaging.PixelFormat pixelFormat = imageData.PixelFormat;
if (((((pixelFormat != System.Drawing.Imaging.PixelFormat.Format8bppIndexed) && (pixelFormat != System.Drawing.Imaging.PixelFormat.Format16bppGrayScale)) && ((pixelFormat != System.Drawing.Imaging.PixelFormat.Format24bppRgb) && (pixelFormat != System.Drawing.Imaging.PixelFormat.Format32bppRgb))) && (((pixelFormat != System.Drawing.Imaging.PixelFormat.Format32bppArgb) && (pixelFormat != System.Drawing.Imaging.PixelFormat.Format32bppPArgb)) && ((pixelFormat != System.Drawing.Imaging.PixelFormat.Format48bppRgb) && (pixelFormat != System.Drawing.Imaging.PixelFormat.Format64bppArgb)))) && (pixelFormat != System.Drawing.Imaging.PixelFormat.Format64bppPArgb))
{
throw new UnsupportedImageFormatException("Unsupported pixel format of the source image.");
}
IntPtr ptr = Marshal.AllocHGlobal((int)(imageData.Stride * imageData.Height));
UnmanagedImage image = new UnmanagedImage(ptr, imageData.Width, imageData.Height, imageData.Stride, pixelFormat);
SystemTools.CopyUnmanagedMemory(ptr, imageData.Scan0, imageData.Stride * imageData.Height);
image.mustBeDisposed = true;
return(image);
}
public static UnmanagedImage FromManagedImage(BitmapData imageData)
{
PixelFormat pixelFormat = imageData.PixelFormat;
if (pixelFormat != PixelFormat.Format8bppIndexed && pixelFormat != PixelFormat.Format16bppGrayScale && pixelFormat != PixelFormat.Format24bppRgb && pixelFormat != PixelFormat.Format32bppRgb && pixelFormat != PixelFormat.Format32bppArgb && pixelFormat != PixelFormat.Format32bppPArgb && pixelFormat != PixelFormat.Format48bppRgb && pixelFormat != PixelFormat.Format64bppArgb && pixelFormat != PixelFormat.Format64bppPArgb)
{
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, pixelFormat);
SystemTools.CopyUnmanagedMemory(dst, imageData.Scan0, imageData.Stride * imageData.Height);
unmanagedImage.mustBeDisposed = true;
return(unmanagedImage);
}
private static Bitmap CloneImage(BitmapData sourceData)
{
int width = sourceData.Width;
int height = sourceData.Height;
Bitmap destination = new Bitmap(width, height, sourceData.PixelFormat);
BitmapData destinationData = destination.LockBits(
new Rectangle(0, 0, width, height),
ImageLockMode.ReadWrite, destination.PixelFormat);
SystemTools.CopyUnmanagedMemory(destinationData.Scan0, sourceData.Scan0, height * sourceData.Stride);
destination.UnlockBits(destinationData);
return(destination);
}
public unsafe Bitmap ToManagedImage(bool makeCopy)
{
Bitmap bitmap = null;
try
{
if (!makeCopy)
{
bitmap = new Bitmap(width, height, stride, pixelFormat, imageData);
if (pixelFormat == PixelFormat.Format8bppIndexed)
{
Image.SetGrayscalePalette(bitmap);
}
}
else
{
bitmap = ((pixelFormat == PixelFormat.Format8bppIndexed) ? Image.CreateGrayscaleImage(width, height) : new Bitmap(width, height, pixelFormat));
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, pixelFormat);
int num = bitmapData.Stride;
int count = System.Math.Min(stride, num);
byte * ptr = (byte *)bitmapData.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);
}
bitmap.UnlockBits(bitmapData);
}
return(bitmap);
}
catch (Exception)
{
bitmap?.Dispose();
throw new InvalidImagePropertiesException("The unmanaged image has some invalid properties, which results in failure of converting it to managed image.");
}
}
public unsafe Bitmap ToManagedImage()
{
Bitmap bitmap = (this.pixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed) ? Image.CreateGrayscaleImage(this.width, this.height) : new Bitmap(this.width, this.height, this.pixelFormat);
BitmapData bitmapdata = bitmap.LockBits(new Rectangle(0, 0, this.width, this.height), ImageLockMode.ReadWrite, this.pixelFormat);
int stride = bitmapdata.Stride;
int count = Math.Min(this.stride, stride);
byte * dst = (byte *)bitmapdata.Scan0.ToPointer();
byte * src = (byte *)this.imageData.ToPointer();
for (int i = 0; i < this.height; i++)
{
SystemTools.CopyUnmanagedMemory(dst, src, count);
dst += stride;
src += this.stride;
}
bitmap.UnlockBits(bitmapdata);
return(bitmap);
}
public Bitmap Apply(BitmapData imageData)
{
PixelFormat pixelFormat = imageData.PixelFormat;
this.CheckSourceFormat(pixelFormat);
int width = imageData.Width;
int height = imageData.Height;
Bitmap bitmap = (pixelFormat == PixelFormat.Format8bppIndexed) ? Image.CreateGrayscaleImage(width, height) : new Bitmap(width, height, pixelFormat);
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, pixelFormat);
SystemTools.CopyUnmanagedMemory(bitmapData.Scan0, imageData.Scan0, imageData.Stride * height);
try
{
this.ProcessFilter(new UnmanagedImage(bitmapData));
}
finally
{
bitmap.UnlockBits(bitmapData);
}
return(bitmap);
}
public unsafe void Copy(UnmanagedImage destImage)
{
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 unsafe void Copy(UnmanagedImage destImage)
{
if (((this.width != destImage.width) || (this.height != destImage.height)) || (this.pixelFormat != destImage.pixelFormat))
{
throw new InvalidImagePropertiesException("Destination image has different size or pixel format.");
}
if (this.stride == destImage.stride)
{
SystemTools.CopyUnmanagedMemory(destImage.imageData, this.imageData, this.stride * this.height);
}
else
{
int stride = destImage.stride;
int count = (this.stride < stride) ? this.stride : stride;
byte *src = (byte *)this.imageData.ToPointer();
byte *dst = (byte *)destImage.imageData.ToPointer();
for (int i = 0; i < this.height; i++)
{
SystemTools.CopyUnmanagedMemory(dst, src, count);
dst += stride;
src += this.stride;
}
}
}
private static Bitmap Copy(this BitmapData sourceData, Bitmap destination)
{
if (destination == null)
{
// create new image
destination = new Bitmap(sourceData.Width, sourceData.Height, sourceData.PixelFormat);
}
// get source image size
int width = sourceData.Width;
int height = sourceData.Height;
// lock destination bitmap data
BitmapData destinationData = destination.LockBits(ImageLockMode.WriteOnly);
System.Diagnostics.Debug.Assert(destinationData.Stride == sourceData.Stride);
SystemTools.CopyUnmanagedMemory(destinationData.Scan0, sourceData.Scan0, height * sourceData.Stride);
// unlock destination image
destination.UnlockBits(destinationData);
return(destination);
}
public unsafe void ProcessFrame(UnmanagedImage videoFrame)
{
lock (sync)
{
if (backgroundFrame == null)
{
lastTimeMeasurment = DateTime.Now;
width = videoFrame.Width;
height = videoFrame.Height;
backgroundFrame = UnmanagedImage.Create(width, height, PixelFormat.Format8bppIndexed);
motionFrame = UnmanagedImage.Create(width, height, PixelFormat.Format8bppIndexed);
frameSize = motionFrame.Stride * height;
if (suppressNoise)
{
tempFrame = UnmanagedImage.Create(width, height, PixelFormat.Format8bppIndexed);
}
Tools.ConvertToGrayscale(videoFrame, backgroundFrame);
return;
}
if ((videoFrame.Width != width) || (videoFrame.Height != height))
{
return;
}
Tools.ConvertToGrayscale(videoFrame, motionFrame);
byte *backFrame;
byte *currFrame;
int diff;
if (millisecondsPerBackgroundUpdate == 0)
{
if (++framesCounter == framesPerBackgroundUpdate)
{
framesCounter = 0;
backFrame = (byte *)backgroundFrame.ImageData.ToPointer();
currFrame = (byte *)motionFrame.ImageData.ToPointer();
for (int i = 0; i < frameSize; i++, backFrame++, currFrame++)
{
diff = *currFrame - *backFrame;
if (diff > 0)
{
(*backFrame)++;
}
else if (diff < 0)
{
(*backFrame)--;
}
}
}
}
else
{
DateTime currentTime = DateTime.Now;
TimeSpan timeDff = currentTime - lastTimeMeasurment;
lastTimeMeasurment = currentTime;
int millisonds = (int)timeDff.TotalMilliseconds + millisecondsLeftUnprocessed;
millisecondsLeftUnprocessed = millisonds % millisecondsPerBackgroundUpdate;
int updateAmount = (int)(millisonds / millisecondsPerBackgroundUpdate);
backFrame = (byte *)backgroundFrame.ImageData.ToPointer();
currFrame = (byte *)motionFrame.ImageData.ToPointer();
for (int i = 0; i < frameSize; i++, backFrame++, currFrame++)
{
diff = *currFrame - *backFrame;
if (diff > 0)
{
(*backFrame) += (byte)((diff < updateAmount) ? diff : updateAmount);
}
else if (diff < 0)
{
(*backFrame) += (byte)((-diff < updateAmount) ? diff : -updateAmount);
}
}
}
backFrame = (byte *)backgroundFrame.ImageData.ToPointer();
currFrame = (byte *)motionFrame.ImageData.ToPointer();
for (int i = 0; i < frameSize; i++, backFrame++, currFrame++)
{
diff = (int)*currFrame - (int)*backFrame;
*currFrame = ((diff >= differenceThreshold) || (diff <= differenceThresholdNeg)) ? (byte)255 : (byte)0;
}
if (suppressNoise)
{
SystemTools.CopyUnmanagedMemory(tempFrame.ImageData, motionFrame.ImageData, frameSize);
erosionFilter.Apply(tempFrame, motionFrame);
if (keepObjectEdges)
{
SystemTools.CopyUnmanagedMemory(tempFrame.ImageData, motionFrame.ImageData, frameSize);
dilatationFilter.Apply(tempFrame, motionFrame);
}
}
pixelsChanged = 0;
byte *motion = (byte *)motionFrame.ImageData.ToPointer();
for (int i = 0; i < frameSize; i++, motion++)
{
pixelsChanged += (*motion & 1);
}
}
}
private void HandleDataReceived(IntPtr device, IntPtr depthData, UInt32 timestamp)
{
int width = depthModeInfo.Width;
int height = depthModeInfo.Height;
Bitmap image = null;
BitmapData data = null;
try
{
image = new Bitmap(width, height, (!provideOriginalDepthImage) ?
PixelFormat.Format24bppRgb : PixelFormat.Format16bppGrayScale);
data = image.LockBits(new Rectangle(0, 0, width, height),
ImageLockMode.ReadWrite, image.PixelFormat);
unsafe
{
ushort *src = (ushort *)imageBuffer.ToPointer( );
if (!provideOriginalDepthImage)
{
// color the depth image into white->red->yellow->green->cyan->blue->black gradient
byte *dst = (byte *)data.Scan0.ToPointer( );
int offset = data.Stride - width * 3;
byte red, green, blue;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++, src++, dst += 3)
{
ushort pval = gamma[*src];
ushort lb = (ushort)(pval & 0xff);
switch (pval >> 8)
{
case 0: // white to red
red = 255;
green = (byte)(255 - lb);
blue = (byte)(255 - lb);
break;
case 1: // red to yellow
red = 255;
green = (byte)lb;
blue = 0;
break;
case 2: // yellow to green
red = (byte)(255 - lb);
green = 255;
blue = 0;
break;
case 3: // green to cyan
red = 0;
green = 255;
blue = (byte)lb;
break;
case 4: // cyan to blue
red = 0;
green = (byte)(255 - lb);
blue = 255;
break;
case 5: // blue to black
red = 0;
green = 0;
blue = (byte)(255 - lb);
break;
default:
red = green = blue = 0;
break;
}
dst[2] = red;
dst[1] = green;
dst[0] = blue;
}
dst += offset;
}
}
else
{
// copy original depth image
ushort *dst = (ushort *)data.Scan0.ToPointer( );
int offset = (data.Stride >> 1) - width;
if (offset == 0)
{
SystemTools.CopyUnmanagedMemory((byte *)dst, (byte *)src, height * width * 2);
}
else
{
for (int y = 0; y < height; y++)
{
SystemTools.CopyUnmanagedMemory((byte *)dst, (byte *)src, width * 2);
dst += width;
src += width;
dst += offset;
}
}
}
}
image.UnlockBits(data);
framesReceived++;
bytesReceived += (int)depthModeInfo.Bytes;
}
catch (Exception ex)
{
if (VideoSourceError != null)
{
VideoSourceError(this, new VideoSourceErrorEventArgs(ex.Message));
}
if (image != null)
{
if (data != null)
{
image.UnlockBits(data);
}
image.Dispose( );
image = null;
}
}
if (image != null)
{
if (NewFrame != null)
{
NewFrame(this, new NewFrameEventArgs(image));
}
image.Dispose( );
}
}
private void HandleDataReceived(IntPtr device, IntPtr imageData, UInt32 timeStamp)
{
int width = videoModeInfo.Width;
int height = videoModeInfo.Height;
Bitmap image = null;
BitmapData data = null;
try
{
image = (cameraMode == VideoCameraMode.Color) ?
new Bitmap(width, height, PixelFormat.Format24bppRgb) :
Accord.Imaging.Image.CreateGrayscaleImage(width, height);
data = image.LockBits(new Rectangle(0, 0, width, height),
ImageLockMode.ReadWrite, image.PixelFormat);
unsafe
{
byte *dst = (byte *)data.Scan0.ToPointer();
byte *src = (byte *)imageBuffer.ToPointer();
if (cameraMode == VideoCameraMode.Color)
{
// color RGB 24 mode
int offset = data.Stride - width * 3;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++, src += 3, dst += 3)
{
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
}
dst += offset;
}
}
else
{
// infra red mode - grayscale output
int stride = data.Stride;
if (stride != width)
{
for (int y = 0; y < height; y++)
{
SystemTools.CopyUnmanagedMemory(dst, src, width);
dst += stride;
src += width;
}
}
else
{
SystemTools.CopyUnmanagedMemory(dst, src, width * height);
}
}
}
image.UnlockBits(data);
framesReceived++;
bytesReceived += width * height;
}
catch (Exception ex)
{
if (VideoSourceError != null)
{
VideoSourceError(this, new VideoSourceErrorEventArgs(ex.Message));
}
if (image != null)
{
if (data != null)
{
image.UnlockBits(data);
}
image.Dispose();
image = null;
}
}
if (image != null)
{
if (NewFrame != null)
{
NewFrame(this, new NewFrameEventArgs(image));
}
image.Dispose();
}
}
