/// <summary>
/// Apply filter.
/// </summary>
/// <param name="Data">Bitmap</param>
public void Apply(Bitmap Data)
{
BitmapData bmData = BitmapFormat.Lock32bpp(Data);
Apply(bmData);
BitmapFormat.Unlock(Data, bmData);
return;
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="Data">Bitmap</param>
/// <param name="Src">Bitmap</param>
public void Apply(Bitmap Data, Bitmap Src)
{
BitmapData bmData = BitmapFormat.Lock32bpp(Data);
BitmapData bmSrc = BitmapFormat.Lock32bpp(Src);
Apply(bmData, bmSrc);
BitmapFormat.Unlock(Data, bmData);
BitmapFormat.Unlock(Src, bmSrc);
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="bmData">Bitmap data</param>
public void Apply(BitmapData bmData)
{
Bitmap Src = (Bitmap)BitmapFormat.Bitmap(bmData).Clone();
BitmapData bmSrc = BitmapFormat.Lock32bpp(Src);
Apply(bmData, bmSrc);
BitmapFormat.Unlock(Src, bmSrc);
Src.Dispose();
return;
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="Data">Bitmap</param>
/// <param name="Src">Bitmap</param>
public float[,] Apply(Bitmap Data, Bitmap Src)
{
BitmapData bmData = BitmapFormat.Lock32bpp(Data);
BitmapData bmSrc = BitmapFormat.Lock32bpp(Src);
var output = Apply(bmData, bmSrc);
BitmapFormat.Unlock(Data, bmData);
BitmapFormat.Unlock(Src, bmSrc);
return(output);
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="bmData">Bitmap data</param>
/// <param name="bmSrc">Bitmap data</param>
public void Apply(BitmapData bmData, BitmapData bmSrc)
{
// Creating resources:
Bitmap Src0 = (Bitmap)BitmapFormat.Bitmap(bmSrc).Clone();
BitmapData bmSrc0 = BitmapFormat.Lock32bpp(Src0);
// Filter applying:
closing.Apply(bmSrc, bmSrc0);
subtraction.Apply(bmData, bmSrc);
// Delete resources:
BitmapFormat.Unlock(Src0, bmSrc0);
Src0.Dispose();
}
/// <summary>
/// Converts a BGR tensor arrays to Bitmap.
/// </summary>
/// <param name="tensor">Tensor arrays</param>
/// <param name="width">Width</param>
/// <param name="height">Height</param>
/// <param name="rgb">RGB or BGR</param>
/// <returns>Bitmap</returns>
public unsafe static Bitmap FromFloatTensor(this float[][] tensor, int width, int height, bool rgb = false)
{
// params
Bitmap Data = new Bitmap(width, height);
BitmapData bmData = BitmapFormat.Lock32bpp(Data);
int stride = bmData.Stride;
byte * p = (byte *)bmData.Scan0.ToPointer();
int shift = height * width;
int z = 0;
// do job
if (rgb)
{
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++, z++)
{
int k, jstride = j * stride;
k = jstride + i * 4;
// transform
p[k + 2] = (byte)tensor[0][z];
p[k + 1] = (byte)tensor[1][z];
p[k + 0] = (byte)tensor[2][z];
}
}
}
else
{
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++, z++)
{
int k, jstride = j * stride;
k = jstride + i * 4;
// transform
p[k + 0] = (byte)tensor[0][z];
p[k + 1] = (byte)tensor[1][z];
p[k + 2] = (byte)tensor[2][z];
}
}
}
// arrays
BitmapFormat.Unlock(Data, bmData);
return(Data);
}
/// <summary>
/// Converts a matrix of channel values to a monochrome Bitmap.
/// </summary>
/// <param name="m">Matrix</param>
/// <returns>Bitmap</returns>
public unsafe static Bitmap FromGrayscale(this float[,] m)
{
int width = m.GetLength(1), height = m.GetLength(0);
Bitmap bitmap = new Bitmap(width, height);
BitmapData bmData = BitmapFormat.Lock32bpp(bitmap);
int stride = bmData.Stride;
byte * p = (byte *)bmData.Scan0.ToPointer();
Parallel.For(0, height, j =>
{
int i, k, jstride = j * stride;
for (i = 0; i < width; i++)
{
k = jstride + i * 4;
p[k + 2] = p[k + 1] = p[k] = Maths.Byte(m[j, i] * 255.0f);
p[k + 3] = 255;
}
});
BitmapFormat.Unlock(bitmap, bmData);
return(bitmap);
}
/// <summary>
/// Apply filter.
/// </summary>
/// <param name="bmData">Bitmap data</param>
public void Apply(BitmapData bmData)
{
Bitmap Max = (Bitmap)BitmapFormat.Bitmap(bmData).Clone();
Bitmap Min = (Bitmap)Max.Clone();
di.Apply(Max); er.Apply(Min);
BitmapData bmMax = BitmapFormat.Lock32bpp(Max);
BitmapData bmMin = BitmapFormat.Lock32bpp(Min);
if (smoothing)
{
gb.Apply(bmMax);
}
gb.Apply(bmMin);
Apply(bmData, bmMax, bmMin);
BitmapFormat.Unlock(Max, bmMax);
BitmapFormat.Unlock(Min, bmMin);
Max.Dispose(); Min.Dispose();
return;
}
/// <summary>
/// Converts an RGB structure to a color image.
/// </summary>
/// <param name="array">RGBA structure array</param>
/// <returns>Bitmap</returns>
public unsafe static Bitmap FromRGB(this float[][,] array)
{
// matrices
float[,] x = array[0];
float[,] y = array[1];
float[,] z = array[2];
// params
int width = x.GetLength(1), height = x.GetLength(0);
Bitmap bitmap = new Bitmap(width, height);
BitmapData bmData = BitmapFormat.Lock32bpp(bitmap);
int stride = bmData.Stride;
byte * p = (byte *)bmData.Scan0.ToPointer();
// alpha
bool alpha = array.Length == 4;
if (alpha)
{
float[,] a = array[3];
Parallel.For(0, height, j =>
{
int i, k, jstride = j * stride;
for (i = 0; i < width; i++)
{
// shift:
k = jstride + i * 4;
// recording model:
p[k + 0] = Maths.Byte(x[j, i] * 255.0f);
p[k + 1] = Maths.Byte(y[j, i] * 255.0f);
p[k + 2] = Maths.Byte(z[j, i] * 255.0f);
p[k + 3] = Maths.Byte(a[j, i] * 255.0f);
}
});
}
else
{
Parallel.For(0, height, j =>
{
int i, k, jstride = j * stride;
for (i = 0; i < width; i++)
{
// shift:
k = jstride + i * 4;
// recording model:
p[k + 0] = Maths.Byte(x[j, i] * 255.0f);
p[k + 1] = Maths.Byte(y[j, i] * 255.0f);
p[k + 2] = Maths.Byte(z[j, i] * 255.0f);
p[k + 3] = (byte)255;
}
});
}
BitmapFormat.Unlock(bitmap, bmData);
return(bitmap);
}
