/// <summary>
/// Constructor.
/// </summary>
/// <param name="image">Source image</param>
/// <param name="transform">Transform that converts RGB to grayscale</param>
public unsafe GrayscaleImage(RGBImage image, float[] transform)
{
float t0 = transform[0];
float t1 = transform[1];
float t2 = transform[2];
_handler = new FloatArrayHandler(image.Rows, image.Columns, 1);
fixed(byte *src = image.RawArray)
{
fixed(float *dst = _handler.RawArray)
{
byte * srcPtr = src;
float *dstPtr = dst;
int length = Rows * Columns;
while (length-- > 0)
{
int R = *srcPtr++;
int G = *srcPtr++;
int B = *srcPtr++;
*dstPtr++ = t0 * R + t1 * G + t2 * B;
}
}
}
ID = image.ID;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="rgb">Source image</param>
/// <param name="converter">Converter to use</param>
public unsafe ColorImage(RGBImage rgb, ColorSpaceConverter converter)
{
_handler = new FloatArrayHandler(rgb.Rows, rgb.Columns, 3);
fixed(byte *src = rgb.RawArray)
{
fixed(float *dst = _handler.RawArray)
{
byte * srcPtr = src;
float *dstPtr = dst;
int length = Rows * Columns;
while (length-- > 0)
{
float i1 = *srcPtr++;
float i2 = *srcPtr++;
float i3 = *srcPtr++;
float o1, o2, o3;
o1 = o2 = o3 = 0;
converter(i1, i2, i3, ref o1, ref o2, ref o3);
*dstPtr++ = o1;
*dstPtr++ = o2;
*dstPtr++ = o3;
}
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="image">Source image</param>
public unsafe GrayscaleImage(RGBImage image)
{
_handler = new FloatArrayHandler(image.Rows, image.Columns, 1);
fixed(byte *src = image.RawArray)
{
fixed(float *dst = _handler.RawArray)
{
byte * srcPtr = src;
float *dstPtr = dst;
int length = Rows * Columns;
while (length-- > 0)
{
int R = *srcPtr++;
int G = *srcPtr++;
int B = *srcPtr++;
float min = Math.Min(R, Math.Min(G, B));
float max = Math.Max(R, Math.Max(G, B));
float val = (min + max) / 2;
* dstPtr++ = val / 255;
}
}
}
ID = image.ID;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="values">Values to use for populating this image</param>
public unsafe GrayscaleImage(float[,] values)
{
int rows = values.GetLength(0);
int columns = values.GetLength(1);
float[, ,] data = new float[rows, columns, 1];
fixed(float *src = values, dst = data)
{
int length = rows * columns;
float *srcPtr = src;
float *dstPtr = dst;
while (length-- > 0)
{
*dstPtr++ = *srcPtr++;
}
}
_handler = new FloatArrayHandler(data, false);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="bitmap">Source image</param>
/// <param name="converter">Converter to use</param>
public unsafe ColorImage(BitmapSource bitmap, ColorSpaceConverter converter)
{
float o1, o2, o3;
int rows = bitmap.PixelHeight;
int columns = bitmap.PixelWidth;
_handler = new FloatArrayHandler(rows, columns, 3);
FormatConvertedBitmap bmp = new FormatConvertedBitmap();
bmp.BeginInit();
bmp.Source = bitmap;
bmp.DestinationFormat = PixelFormats.Rgb24;
bmp.EndInit();
byte[] pixels = new byte[rows * columns * 3];
bmp.CopyPixels(pixels, columns * 3, 0);
fixed(byte *src = pixels)
{
fixed(float *dst = _handler.RawArray)
{
byte * srcPtr = src;
float *dstPtr = dst;
int length = rows * columns;
while (length-- > 0)
{
float i1 = *srcPtr++;
float i2 = *srcPtr++;
float i3 = *srcPtr++;
o1 = o2 = o3 = 0;
converter(i1, i2, i3, ref o1, ref o2, ref o3);
*dstPtr++ = o1;
*dstPtr++ = o2;
*dstPtr++ = o3;
}
}
}
pixels = null;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="bitmap">Source image</param>
/// <param name="converter">Converter to use</param>
public unsafe ColorImage(System.Drawing.Bitmap bitmap, ColorSpaceConverter converter)
{
int r, c;
float o1, o2, o3;
byte * srcPtr, srcScan;
float *dstPtr;
int rows = bitmap.Height;
int columns = bitmap.Width;
_handler = new FloatArrayHandler(rows, columns, 3);
System.Drawing.Imaging.BitmapData srcBuf = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
srcPtr = (byte *)srcBuf.Scan0;
int srcStride = srcBuf.Stride;
fixed(float *dstBuf = _handler.RawArray)
{
dstPtr = dstBuf;
for (r = 0; r < rows; r++, srcPtr += srcStride)
{
for (c = 0, srcScan = srcPtr; c < columns; c++)
{
float i3 = *srcScan++;
float i2 = *srcScan++;
float i1 = *srcScan++;
o1 = o2 = o3 = 0;
converter(i1, i2, i3, ref o1, ref o2, ref o3);
*dstPtr++ = o1;
*dstPtr++ = o2;
*dstPtr++ = o3;
}
}
}
bitmap.UnlockBits(srcBuf);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="rows">Number of rows</param>
/// <param name="columns">Number of columns</param>
public GrayscaleImage(int rows, int columns)
{
_handler = new FloatArrayHandler(rows, columns, 1);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="data">The raw image data</param>
public FilterBankImage(float[, ,] data)
{
_handler = new FloatArrayHandler(data, false);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="rows">The number of rows in the image</param>
/// <param name="columns">The number of columns in the image</param>
/// <param name="filters">The number of filters (i.e. channels) in the image</param>
public FilterBankImage(int rows, int columns, int filters)
{
_handler = new FloatArrayHandler(rows, columns, filters);
}
/// <summary>
/// Constructor.
/// </summary>
public FilterBankImage()
{
_handler = new FloatArrayHandler();
}
