private void OnLoadColorButtonClick(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Images (*.png;*.jpeg;*.bmp;*.jpg)|*.png;*.jpeg;*.bmp;*.jpg";
if (openFileDialog.ShowDialog() == true)
{
string filepath = openFileDialog.FileName;
if (filepath != null && filepath.Length > 0)
{
BitmapImage colBitmap = new BitmapImage(new Uri(filepath));
double scaleX = Board.ActualWidth / colBitmap.PixelWidth;
double scaleY = Board.ActualHeight / colBitmap.PixelHeight;
var colBitmap2 = new TransformedBitmap(colBitmap, new ScaleTransform(scaleX, scaleY));
colBitmapStride = ((colBitmap2.PixelWidth * colBitmap2.Format.BitsPerPixel + 7) / 8);
int colBitmapSize = colBitmapStride * colBitmap2.PixelHeight;
ColBitmap = new byte[colBitmapSize];
colBitmap2.CopyPixels(ColBitmap, colBitmapStride, 0);
}
else
{
MessageBox.Show("No file chosen. Applying default color texture");
LoadColBitmap(Properties.Resources.bloom_blooming_bright_1131407);
}
}
else
{
MessageBox.Show("No file chosen. Applying default color texture");
LoadColBitmap(Properties.Resources.bloom_blooming_bright_1131407);
}
}
/// <summary>
/// Converts a value.
/// </summary>
/// <returns>
/// A converted value. If the method returns null, the valid null value is used.
/// </returns>
/// <param name="value">The value produced by the binding source.</param><param name="targetType">The type of the binding target property.</param><param name="parameter">The converter parameter to use.</param><param name="culture">The culture to use in the converter.</param>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
Image img = value as Image;
if (img != null)
{
BitmapSource src = img.Source as BitmapSource;
if (src != null)
{
if (src.Format != PixelFormats.Rgb24)
{
// Если изображение не в формате RGB24, то переводим его в этот формат
src = new FormatConvertedBitmap(src, PixelFormats.Rgb24, null, 1);
}
// Ужимаем иконку до размера 1x1
TransformedBitmap bmp = new TransformedBitmap(src, new ScaleTransform(1.0 / src.Width, 1.0 / src.PixelHeight));
// Достаём цвет пиксела
byte[] pixels = new byte[3];
bmp.CopyPixels(pixels, 3, 0);
// Возвращаём цвет полученного пиксела
return(Color.FromArgb(255, pixels[0], pixels[1], pixels[2]));
}
}
return(Colors.Yellow);
}
public static WriteableBitmap Scale(this WriteableBitmap image, double scale)
{
var s = new ScaleTransform(scale, scale);
var source = new TransformedBitmap(image, s);
// Calculate stride of source
int stride = source.PixelWidth * (source.Format.BitsPerPixel / 8);
// Create data array to hold source pixel data
byte[] data = new byte[stride * source.PixelHeight];
// Copy source image pixels to the data array
source.CopyPixels(data, stride, 0);
// Create WriteableBitmap to copy the pixel data to.
WriteableBitmap target = new WriteableBitmap(source.PixelWidth
, source.PixelHeight, source.DpiX, source.DpiY
, source.Format, null);
// Write the pixel data to the WriteableBitmap.
target.WritePixels(new Int32Rect(0, 0
, source.PixelWidth, source.PixelHeight)
, data, stride, 0);
return(target);
}
private void OnLoadNButtonClick(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Images (*.png;*.jpeg;*.bmp;*.jpg)|*.png;*.jpeg;*.bmp;*.jpg";
if (openFileDialog.ShowDialog() == true)
{
string filepath = openFileDialog.FileName;
if (filepath != null && filepath.Length > 0)
{
BitmapImage nBitmap = new BitmapImage(new Uri(filepath));
double scaleX = Board.ActualWidth / nBitmap.PixelWidth;
double scaleY = Board.ActualHeight / nBitmap.PixelHeight;
var nBitmap2 = new TransformedBitmap(nBitmap, new ScaleTransform(scaleX, scaleY));
nBitmapStride = ((nBitmap2.PixelWidth * nBitmap2.Format.BitsPerPixel + 7) / 8);
int nBitmapSize = nBitmapStride * nBitmap2.PixelHeight;
NBitmap = new byte[nBitmapSize];
nBitmap2.CopyPixels(NBitmap, nBitmapStride, 0);
}
else
{
MessageBox.Show("No file chosen. Applying default normal map");
LoadNBitmap(Properties.Resources.Carpet_01_NRM);
}
}
else
{
MessageBox.Show("No file chosen. Applying default normal map");
LoadNBitmap(Properties.Resources.Carpet_01_NRM);
}
}
private static Image ScaleImage(BitmapSource bitmapSource, Size scale)
{
// Scale the image so that it will display similarly to the WPF Image.
var newWidthRatio = (scale.Width != -1 ? scale.Width / (double)bitmapSource.PixelWidth : 1.0);
var newHeightRatio = (scale.Height != -1 ? ((scale.Width * bitmapSource.PixelHeight) / (double)bitmapSource.PixelWidth) / bitmapSource.PixelHeight : 1.0);
BitmapSource transformedBitmapSource = new TransformedBitmap(bitmapSource, new ScaleTransform(newWidthRatio, newHeightRatio));
var width = transformedBitmapSource.PixelWidth;
var height = transformedBitmapSource.PixelHeight;
var stride = width * ((transformedBitmapSource.Format.BitsPerPixel + 7) / 8);
var bits = new byte[height * stride];
transformedBitmapSource.CopyPixels(bits, stride, 0);
unsafe
{
fixed(byte *pBits = bits)
{
var bitmap = new Bitmap(width, height, stride, PixelFormat.Format32bppPArgb, new IntPtr(pBits));
return(bitmap);
}
}
}
public WriteableBitmap ResizeWritableBitmap(WriteableBitmap wBitmap, int reqWidth, int reqHeight)
{
int OriWidth = (int)wBitmap.PixelWidth;
int OriHeight = (int)wBitmap.PixelHeight;
double nXFactor = (double)reqWidth / OriWidth;
double nYFactor = (double)reqHeight / OriHeight;
var s = new ScaleTransform(nXFactor, nYFactor);
var res = new TransformedBitmap(wBitmap, s);
int stride = res.PixelWidth * (wBitmap.Format.BitsPerPixel / 8);
// Create data array to hold source pixel data
byte[] data = new byte[stride * res.PixelHeight];
// Copy source image pixels to the data array
res.CopyPixels(data, stride, 0);
// Create WriteableBitmap to copy the pixel data to.
WriteableBitmap target = new WriteableBitmap(res.PixelWidth
, res.PixelHeight, res.DpiX, res.DpiY
, res.Format, null);
// Write the pixel data to the WriteableBitmap.
target.WritePixels(new Int32Rect(0, 0
, res.PixelWidth, res.PixelHeight)
, data, stride, 0);
return(target);
}
/// <summary> Flips image horizontally </summary>
/// <param name="inputImagePath">path to image that will be flipped</param>
/// <param name="inputImagePath">path to file, where will be flipped image saved</param>
public static BitmapSource FlipHorizontalImage(BitmapSource inputSource)
{
TransformedBitmap tb = new TransformedBitmap(inputSource, new ScaleTransform(-1, 1));
//copy pixels to new bitmapSource because of strange .NET native memory leak
int stride = tb.PixelWidth * tb.Format.BitsPerPixel / 8;
byte[] bitmapArray = new byte[tb.PixelHeight * stride];
tb.CopyPixels(bitmapArray, stride, 0);
return(BitmapSource.Create(tb.PixelWidth, tb.PixelHeight, tb.DpiX, tb.DpiY, tb.Format,
tb.Palette, bitmapArray, stride));
}
private void LoadNBitmap(System.Drawing.Bitmap bitmap)
{
BitmapImage nBitmap = ToBitmapImage(bitmap);
double scaleX = Board.ActualWidth / nBitmap.PixelWidth;
double scaleY = Board.ActualHeight / nBitmap.PixelHeight;
var transformedColBitmap = new TransformedBitmap(nBitmap, new ScaleTransform(scaleX, scaleY));
nBitmapStride = ((transformedColBitmap.PixelWidth * transformedColBitmap.Format.BitsPerPixel + 7) / 8);
int nBitmapSize = nBitmapStride * transformedColBitmap.PixelHeight;
NBitmap = new byte[nBitmapSize];
transformedColBitmap.CopyPixels(NBitmap, nBitmapStride, 0);
}
private void Bw_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker me = sender as BackgroundWorker;
int[] a = new int[LedsPerStrip * StripCount];
TransformedBitmap tbmp = null;
System.Drawing.Color[,] grid = new System.Drawing.Color[StripCount, LedsPerStrip];
while (!me.CancellationPending)
{
if (width == 0)
{
viewport_border.Dispatcher.Invoke(() =>
{
PresentationSource source = PresentationSource.FromVisual(this);
width = (int)(viewport.ActualWidth * source.CompositionTarget.TransformToDevice.M11);
height = (int)(viewport.ActualHeight * source.CompositionTarget.TransformToDevice.M22);
if (width != 0)
{
rtb = new RenderTargetBitmap(width, height, 96.0, 96.0, PixelFormats.Pbgra32);
}
});
Thread.Sleep(33);
continue;
}
viewport_border.Dispatcher.Invoke(() =>
{
rtb.Render(viewport_border);
double scalex = LedsPerStrip * 1.0 / width;
double scaley = StripCount * 1.0 / height;
tbmp = new TransformedBitmap(rtb, new ScaleTransform(scalex, scaley));
tbmp.CopyPixels(a, 4 * LedsPerStrip, 0);
});
for (int i = 0; i < StripCount; i++)
{
for (int j = 0; j < LedsPerStrip; j++)
{
grid[i, j] = System.Drawing.Color.FromArgb(a[i * LedsPerStrip + j]);
}
}
_ledWall.SetWall(grid);
Thread.Sleep(33);
}
}
static float[] CreateInputTensorFromImage(String filename, int[] tensorDims, out float scaleFactor, out int offsetX, out int offsetY)
{
var bitmap = new BitmapImage(new Uri(filename));
var bitmapWidth = bitmap.PixelWidth;
var bitmapHeight = bitmap.PixelHeight;
scaleFactor = 1.0f;
if (bitmapWidth > bitmapHeight)
{
scaleFactor = (float)tensorDims[3] / bitmapWidth;
}
else
{
scaleFactor = (float)tensorDims[2] / bitmapHeight;
}
TransformedBitmap tb = new TransformedBitmap(bitmap, new System.Windows.Media.ScaleTransform(scaleFactor, scaleFactor));
int newWidth = tb.PixelWidth;
int newHeight = tb.PixelHeight;
int channels = tb.Format.BitsPerPixel / 8;
int stride = channels * newWidth;
byte[] rawData = new byte[stride * newHeight];
byte[] rawLabelOutput = new byte[tensorDims[2] * tensorDims[3]];
byte[] rawOutput = new byte[stride * newHeight];
tb.CopyPixels(rawData, stride, 0);
int paddingX = tensorDims[3] - newWidth;
int paddingY = tensorDims[2] - newHeight;
float[] testData = new float[tensorDims[2] * tensorDims[3] * tensorDims[1]];
for (int n = 0; n < tensorDims[2] * tensorDims[3] * tensorDims[1]; n++)
{
testData[n] = 0.0f;
}
offsetX = paddingX / 2;
offsetY = paddingY / 2;
// fill up tensor with image data
for (int y = 0; y < newHeight; y++)
{
int y1 = y;
for (int x = 0; x < newWidth; x++)
{
testData[(x + offsetX) + (y + offsetY) * tensorDims[3] + tensorDims[2] * tensorDims[3] * 2] = rawData[(x + y1 * newWidth) * channels] / 255.0f;
testData[(x + offsetX) + (y + offsetY) * tensorDims[3] + tensorDims[2] * tensorDims[3]] = rawData[(x + y1 * newWidth) * channels + 1] / 255.0f;
testData[(x + offsetX) + (y + offsetY) * tensorDims[3]] = rawData[(x + y1 * newWidth) * channels + 2] / 255.0f;
}
}
return(testData);
}
private void SaveImages()
{
if (System.IO.File.Exists(Settings.BackgroundImagePath))
{
WriteableBitmap wb;
BitmapImage fileBitmap = new BitmapImage(new Uri(Settings.BackgroundImagePath, UriKind.Relative));
wb = new WriteableBitmap(fileBitmap);
//wb.DpiX = 300;
int heightOffset = Settings.TopMargin;
double newWidth = wb.PixelWidth - Settings.SideMargin * 2;
foreach (var i in capturedImages)
{
double scaleFactor = newWidth / i.PixelWidth;
var bitmap = new TransformedBitmap(i, new ScaleTransform(
scaleFactor,
scaleFactor));
var stride = (bitmap.PixelWidth * bitmap.Format.BitsPerPixel + 7) / 8;
var buffer = new byte[stride * bitmap.PixelHeight];
bitmap.CopyPixels(buffer, stride, 0);
wb.WritePixels(
new Int32Rect(Settings.SideMargin, heightOffset, bitmap.PixelWidth, bitmap.PixelHeight),
buffer, stride, 0);
heightOffset += bitmap.PixelHeight + Settings.ImageGap;
}
var s = (wb.PixelWidth * wb.Format.BitsPerPixel + 7) / 8;
var buff = new byte[s * wb.PixelHeight];
wb.CopyPixels(buff, s, 0);
var composite = new WriteableBitmap(wb.PixelWidth * 2, wb.PixelHeight, wb.DpiX, wb.DpiY, wb.Format, wb.Palette);
composite.WritePixels(new Int32Rect(5, 0, wb.PixelWidth, wb.PixelHeight), buff, s, 0);
composite.WritePixels(new Int32Rect(wb.PixelWidth, 0, wb.PixelWidth, wb.PixelHeight), buff, s, 0);
PrintWindow pw = new PrintWindow(composite);
pw.Show();
}
else
{
System.Windows.MessageBox.Show("No background image could be found. Nothing to attach images on to.", "PhotoboothFree");
}
}
/// <summary>
/// Method to scale the original image to 600 x 600.
/// This should preserve the aspect ratio of the original image.
/// </summary>
/// <param name="fileName"></param>
void ScaleImage(string fileName)
{
double fac1 = Convert.ToDouble(scaledWidth / (1.0 * originalWidth));
double fac2 = Convert.ToDouble(scaledHeight / (1.0 * originalHeight));
var scale = new ScaleTransform(fac1, fac2);
scaledImage = new TransformedBitmap(originalImage, scale);
int stride = (scaledImage.PixelWidth * scaledImage.Format.BitsPerPixel + 7) / 8;
if (scaledPixels != null)
{
scaledPixels = null;
}
scaledPixels = new byte[stride * scaledHeight];
// Update the array scaledPixels from the scaled image
scaledImage.CopyPixels(Int32Rect.Empty, scaledPixels, stride, 0);
}
public void Resize(Bitmap src, Bitmap dst, object options = null)
{
var source = Misc.AllocWriteableBitmap(src.Width, src.Height, src.Depth, src.Channel);
Misc.CopyToWritableBitmap(source, src);
var scaleTransform = new ScaleTransform((double)dst.Width / src.Width, (double)dst.Height / src.Height);
BitmapSource transformed = new TransformedBitmap(source, scaleTransform);
if (transformed.Format.BitsPerPixel > 64)
{
var converted = new FormatConvertedBitmap();
converted.BeginInit();
converted.Source = transformed;
converted.DestinationFormat = dst.Channel == 4 ? PixelFormats.Rgba64 : PixelFormats.Rgb48;
converted.EndInit();
transformed = converted;
}
transformed.CopyPixels(Int32Rect.Empty, dst.Scan0, dst.Stride * dst.Height, dst.Stride);
}
/// <summary>
/// Создание таблиц преобразования интенсивностей изображений
/// в новый динамический диапазон.
/// Самый простой вариант - это линейное масштабирование.
/// Динамическое масштабирование не исследовано, но может оказаться полезным.
/// </summary>
private void correctIntencityRange(BeamParams b)
{
filmLUT = new ushort[256];
double r = image.DpiX * R * 2.0 / 25.4;
double x0 = b.O.X;
double y0 = b.O.Y;
Int32Rect rect = new Int32Rect();
rect.X = (int)(x0 - r);
rect.Y = (int)(y0 - r);
rect.Width = (int)(2 * r);
rect.Height = (int)(2 * r);
if (rect.X + rect.Width >= image.PixelWidth)
{
rect.X -= (int)(rect.X + rect.Width - image.PixelWidth + 1);
}
if (rect.Y + rect.Height >= image.PixelHeight)
{
rect.Y -= (int)(rect.Y + rect.Height - image.PixelHeight + 1);
}
if (rect.X < 0)
{
rect.Width += rect.X;
if (rect.Width < 1)
{
rect.Width = 1;
}
rect.X = 0;
}
if (rect.Y < 0)
{
rect.Height += rect.Y;
if (rect.Height < 1)
{
rect.Height = 1;
}
rect.Y = 0;
}
fx0 = (double)rect.X;
fy0 = (double)rect.Y;
fnx = rect.Width;
fny = rect.Height;
pixels = new byte[fnx * fny * 4];
image.CopyPixels(rect, pixels, fnx * 4, 0);
byte humax = 0;
int i, j;
for (i = 0; i < rect.Width; i++)
{
for (j = 0; j < rect.Height; j++)
{
byte bv = (byte)(255 - pixels[(i * rect.Height + j) * 4]);
pixels[(i * rect.Height + j) * 4] = bv;
if (bv > humax)
{
humax = bv;
}
}
}
double scale = (double)(inorm - 1) / (double)humax;
for (i = 0; i < 256; i++)
{
filmLUT[i] = (ushort)(scale * i);
}
// Debug
//DumpPixels("C:/tmp/pixels.txt");
}
private void Correct(InferenceSession session, string path)
{
var rawImage = new BitmapImage();
while (true)
{
try
{
using (var stream = File.OpenRead(path))
{
rawImage.BeginInit();
rawImage.CacheOption = BitmapCacheOption.OnLoad;
rawImage.StreamSource = stream;
rawImage.EndInit();
}
}
catch (System.IO.IOException e)
{
var ret = WinForms.MessageBox.Show(
e.Message, "VRCPhotoRotationCorrector",
WinForms.MessageBoxButtons.RetryCancel);
if (ret == WinForms.DialogResult.Retry)
{
continue;
}
else
{
return;
}
}
break;
}
var scale = INPUT_SIZE / (double)Math.Max(rawImage.PixelWidth, rawImage.PixelHeight);
var scaledImage = new TransformedBitmap(rawImage, new ScaleTransform(scale, scale));
var data = new byte[INPUT_SIZE * INPUT_SIZE * 4];
var stride = INPUT_SIZE * 4;
var offsetX = (INPUT_SIZE - scaledImage.PixelWidth) / 2;
var offsetY = (INPUT_SIZE - scaledImage.PixelHeight) / 2;
scaledImage.CopyPixels(data, stride, offsetX * 4 + offsetY * stride);
var source = TransposeAndCast(data);
var dims = new int[] { 1, 3, INPUT_SIZE, INPUT_SIZE };
var probs = new float[4];
for (int rot = 0; rot < 4; ++rot)
{
if (rot != 0)
{
Rotate90(source);
}
var tensor = new DenseTensor <float>(source, dims);
var inputs = new List <NamedOnnxValue>()
{
NamedOnnxValue.CreateFromTensor <float>("input.1", tensor)
};
using (var results = session.Run(inputs))
{
foreach (var r in results)
{
var values = r.AsTensor <float>().ToArray();
var e0 = (float)Math.Exp(values[0]);
var e1 = (float)Math.Exp(values[1]);
probs[rot] = e0 / (e0 + e1);
}
}
}
var maxval = probs.Max();
if (probs[0] != maxval)
{
var angle = 0.0;
for (int a = 0; a < 4; ++a)
{
if (probs[a] == maxval)
{
angle = a * 90.0;
}
}
var rotatedImage = new TransformedBitmap(rawImage, new RotateTransform(angle));
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(rotatedImage));
var tmp = path + ".tmp.png";
using (var stream = File.OpenWrite(tmp))
{
encoder.Save(stream);
}
File.Delete(path);
File.Move(tmp, path);
}
// MessageBox.Show(path + ": " + probs[0].ToString() + ", " + probs[1].ToString() + ", " + probs[2].ToString() + ", " + probs[3].ToString());
}
// create the output image upon clicking the create button
private void btnCreate_Click(object sender, RoutedEventArgs e)
{
// check that there is at least one enable tile to create the output image with
bool allTilesDisabled = true;
foreach (Tile tile in tilesList)
{
if (tile.enabled == true)
{
allTilesDisabled = false;
break;
}
}
if (allTilesDisabled)
{
// if every tile is disabled, show the relevant error message then return
showErrorMessage();
return;
}
// set the mouse to a wait cursor for the duration of the image processing
Mouse.OverrideCursor = Cursors.Wait;
try
{
// scale down the original image to the dimensions specified in the xScaling and yScaling text boxes
var bmScaled = new TransformedBitmap(bmMain, new ScaleTransform(Convert.ToDouble(xScaling.Text) / bmMain.PixelWidth, Convert.ToDouble(yScaling.Text) / bmMain.PixelHeight));
// calculate the stride (how many bytes in a single row of the image) of the resulting image
int stride = (bmScaled.PixelWidth * bmScaled.Format.BitsPerPixel + 7) / 8;
// create a byte array to copy this image into
byte[] pixels = new byte[bmScaled.PixelHeight * stride];
// copy the scaled imaged into the byte array
bmScaled.CopyPixels(pixels, stride, 0);
// create the output image, with size equal to the specified dimensions * the size of a tile, since the dimensions are given in 'tile' units.
WriteableBitmap background = new WriteableBitmap(tilesSize * (Convert.ToInt32(xScaling.Text)), tilesSize * (Convert.ToInt32(yScaling.Text)), bmMain.DpiX, bmMain.DpiY, bmMain.Format, null);
// iterate over the byte array, incrementing by 4 since there are 4 bytes in each pixel (A,R,G,B)
for (int i = 0; i <= pixels.Length - 4; i = i + 4)
{
// calcluate the color of the current pixel from each set of 4 bytes
Color c = Color.FromArgb(pixels[i + 3], pixels[i + 2], pixels[i + 1], pixels[i]);
// for this pixel, find the closest tile in the tiles list
var closestTile = findClosestTile(tilesList, c);
// calculate the position where this tile should be placed from the index
int row = (i / 4) / (Convert.ToInt32(xScaling.Text) + 0);
int col = (i / 4) % (Convert.ToInt32(xScaling.Text) + 0);
// add the found closest tile to the output image
addTileToImage(closestTile, row, col, background);
}
// show the output image, and enable saving
imgMain.Source = bmResult;
btnSave.IsEnabled = true;
}
finally
{
// reset the mouse cursor
Mouse.OverrideCursor = null;
}
}
public override BitmapSource Process(BitmapSource bmp, IFrameDestination dest)
{
var sw = new Stopwatch();
sw.Start();
var sliceWidth = bmp.Width / Width;
var sliceHeight = bmp.Height / Height;
var destRect = new Int32Rect();
var srcRect = new Int32Rect();
var lineRect = new Int32Rect();
var bytesPerPixel = (bmp.Format.BitsPerPixel + 7) / 8;
var wBmp = new WriteableBitmap(bmp);
srcRect.Height = 1;
destRect.X = 0;
destRect.Width = bmp.PixelWidth;
destRect.Height = srcRect.Height;
lineRect.Height = 1;
lineRect.X = 0;
lineRect.Width = bmp.PixelWidth;
var blockSize = bytesPerPixel * bmp.PixelWidth * srcRect.Height;
var stride = bmp.PixelWidth * bytesPerPixel;
var buffer = new byte[blockSize];
var line = new WriteableBitmap(bmp.PixelWidth, 1, bmp.DpiX, bmp.DpiY, bmp.Format, bmp.Palette);
for (var y = 0; y < bmp.PixelHeight; y++)
{
// copy line
lineRect.Y = y;
bmp.CopyPixels(lineRect, buffer, stride, 0);
lineRect.Y = 0;
line.WritePixels(lineRect, buffer, stride, 0);
// calculate scaling
var deltaAbs = (double)bmp.PixelWidth / 2 * Distortion;
var deltaRel = deltaAbs * (1 - (double)y / bmp.PixelHeight);
srcRect.Width = bmp.PixelWidth - (int)(2 * deltaRel);
srcRect.X = (int)deltaRel;
srcRect.Y = y;
destRect.Y = y;
var scaleX = (double)bmp.PixelWidth / srcRect.Width;
// scale line
var scaledLine = new TransformedBitmap(line, new ScaleTransform(scaleX, 1, (double)line.PixelWidth / 2, 0));
// copy scaled line to dest
lineRect.X = (int)((bmp.PixelWidth * scaleX) - bmp.PixelWidth) / 2;
scaledLine.CopyPixels(lineRect, buffer, stride, 0);
lineRect.X = 0;
lineRect.Y = y;
wBmp.WritePixels(lineRect, buffer, stride, 0);
}
sw.Stop();
Console.WriteLine("Distored image in {0}ms.", sw.ElapsedMilliseconds);
wBmp.Freeze();
_whenProcessed.OnNext(wBmp);
return(wBmp);
}
static void Main(string[] args)
{
if (args.Length < 2)
{
System.Console.WriteLine("Not enough arguments given use FaceSegmentationCMD inputimage outputimage");
}
else
{
byte[] REDLABEL = { 0, 0, 0, 255, 0, 255, 255, 255, 128, 255, 0 };
byte[] GREENLABEL = { 0, 255, 0, 0, 255, 255, 0, 255, 128, 192, 128 };
byte[] BLUELABEL = { 0, 0, 255, 0, 255, 0, 255, 255, 128, 192, 128 };
var options = new SessionOptions();
options.SetSessionGraphOptimizationLevel(2);
var path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location);
String onnxfile = path + "\\facesegmentation_full_344.onnx";
InferenceSession session = null;
try
{
session = new InferenceSession(onnxfile, options);
} catch (Exception e)
{
System.Console.WriteLine("Could not load ONNX model, because " + e.ToString());
return;
}
try
{
var bitmap = new BitmapImage(new Uri(args[0]));
var bitmapWidth = bitmap.Width;
var bitmapHeight = bitmap.Height;
var inputMeta = session.InputMetadata;
var container = new List <NamedOnnxValue>();
int[] inputDim = new int[4];
double scaleFactor = 1.0;
foreach (var name in inputMeta.Keys)
{
var dim = inputMeta[name].Dimensions;
for (int n = 0; n < dim.Length; n++)
{
inputDim[n] = dim[n];
}
}
if (bitmapWidth > bitmapHeight)
{
scaleFactor = (double)inputDim[3] / bitmapWidth;
}
else
{
scaleFactor = (double)inputDim[2] / bitmapHeight;
}
TransformedBitmap tb = new TransformedBitmap(bitmap, new System.Windows.Media.ScaleTransform(scaleFactor, scaleFactor));
int newWidth = tb.PixelWidth;
int newHeight = tb.PixelHeight;
int channels = tb.Format.BitsPerPixel / 8;
int stride = channels * newWidth;
byte[] rawData = new byte[stride * newHeight];
byte[] rawLabelOutput = new byte[inputDim[2] * inputDim[3]];
byte[] rawOutput = new byte[stride * newHeight];
tb.CopyPixels(rawData, stride, 0);
int paddingX = inputDim[3] - newWidth;
int paddingY = inputDim[2] - newHeight;
float[] testData = new float[inputDim[2] * inputDim[3] * inputDim[1]];
// intialize the whole tensor data to background value so do not have to deal with padding later
for (int n = 0; n < inputDim[2] * inputDim[3] * inputDim[1]; n++)
{
testData[n] = -1.0f;
}
var offsetX = paddingX / 2;
var offsetY = paddingY / 2;
// fill up tensor with image data
for (int y = 0; y < newHeight; y++)
{
int y1 = y;
for (int x = 0; x < newWidth; x++)
{
testData[(x + offsetX) + (y + offsetY) * inputDim[3] + inputDim[2] * inputDim[3] * 2] = rawData[(x + y1 * newWidth) * channels] / 127.5f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3] + inputDim[2] * inputDim[3]] = rawData[(x + y1 * newWidth) * channels + 1] / 127.5f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3]] = rawData[(x + y1 * newWidth) * channels + 2] / 127.5f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3] + inputDim[2] * inputDim[3] * 2] -= 1.0f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3] + inputDim[2] * inputDim[3]] -= 1.0f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3]] -= 1.0f;
}
}
foreach (var name in inputMeta.Keys)
{
var tensor = new DenseTensor <float>(testData, inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
using (var results = session.Run(container))
{
int numResults = results.Count;
foreach (var r in results)
{
System.Console.WriteLine(r.Name);
var resultTensor = r.AsTensor <float>();
var resultDimension = resultTensor.Dimensions;
System.Console.WriteLine(resultDimension.Length);
var resultArray = resultTensor.ToArray();
float[] pointVal = new float[resultDimension[1]];
for (var y = 0; y < resultDimension[2]; y++)
{
for (var x = 0; x < resultDimension[3]; x++)
{
for (var n = 0; n < resultDimension[1]; n++)
{
pointVal[n] = resultArray[x + y * resultDimension[3] + n * resultDimension[2] * resultDimension[3]];
}
Softmax(pointVal);
byte labelVal = (byte)MaxIndex(pointVal);
rawLabelOutput[x + y * resultDimension[3]] = labelVal;
}
}
if (resultDimension[1] < 64)
{
for (int y = 0; y < newHeight; y++)
{
for (int x = 0; x < newWidth; x++)
{
int n = rawLabelOutput[(x + offsetX) + (y + offsetY) * resultDimension[3]];
rawOutput[(x + y * newWidth) * channels + 3] = 255;
rawOutput[(x + y * newWidth) * channels + 2] = REDLABEL[n];
rawOutput[(x + y * newWidth) * channels + 1] = GREENLABEL[n];
rawOutput[(x + y * newWidth) * channels] = BLUELABEL[n];
}
}
}
else
{
for (int y = 0; y < newHeight; y++)
{
for (int x = 0; x < newWidth; x++)
{
int n = rawLabelOutput[(x + offsetX) + (y + offsetY) * resultDimension[3]];
rawOutput[(x + y * newWidth) * channels + 3] = 255;
rawOutput[(x + y * newWidth) * channels + 2] = (byte)n;
rawOutput[(x + y * newWidth) * channels + 1] = (byte)n;
rawOutput[(x + y * newWidth) * channels] = (byte)n;
}
}
}
var outputImage = ImageFromRawBgraArray(rawOutput, newWidth, newHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
outputImage = ResizeImage(outputImage, (int)bitmapHeight, (int)bitmapWidth);
outputImage.Save(args[1]);
}
}
}
catch (Exception e)
{
System.Console.WriteLine("Could not load image because of " + e.ToString());
}
}
}