private async void Button_Click(object sender, RoutedEventArgs e)
{
using (var stream = await Root.RenderToRandomAccessStream())
{
var device = new CanvasDevice();
var bitmap = await CanvasBitmap.LoadAsync(device, stream);
var renderer = new CanvasRenderTarget(device, bitmap.SizeInPixels.Width, bitmap.SizeInPixels.Height, bitmap.Dpi);
using (var ds = renderer.CreateDrawingSession())
{
var blur = new GaussianBlurEffect();
blur.BlurAmount = 5.0f;
blur.Source = bitmap;
ds.DrawImage(blur);
}
stream.Seek(0);
await renderer.SaveAsync(stream, CanvasBitmapFileFormat.Png);
BitmapImage image = new BitmapImage();
image.SetSource(stream);
Blured.Source = image;
}
}
public async static Task<Uri> ToQrDataUri(this ISdp sdp, int width, int height)
{
var qrCodeWriter = new QRCodeWriter();
var bitMatrix = qrCodeWriter.encode(sdp.ToString(), ZXing.BarcodeFormat.QR_CODE, width, height);
using (var canvasRenderTarget = new CanvasRenderTarget(CanvasDevice.GetSharedDevice(), 500, 500, 96))
{
using (var drawingSession = canvasRenderTarget.CreateDrawingSession())
{
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
drawingSession.DrawRectangle(x, y, 1, 1, bitMatrix.get(x, y) ? Color.FromArgb(0, 0, 0, 0) : Color.FromArgb(255, 255, 255, 255));
}
}
}
using (var inMemoryRandomAccessStream = new InMemoryRandomAccessStream())
{
await canvasRenderTarget.SaveAsync(inMemoryRandomAccessStream, CanvasBitmapFileFormat.Png);
inMemoryRandomAccessStream.Seek(0);
var buffer = new byte[inMemoryRandomAccessStream.Size];
await inMemoryRandomAccessStream.ReadAsync(buffer.AsBuffer(), (uint)inMemoryRandomAccessStream.Size, InputStreamOptions.None);
return new Uri($"data:image/png;base64,{Convert.ToBase64String(buffer)}");
}
}
}
public async Task Save(StorageFile file)
{
var image = GetImage();
// Measure the extent of the image (which may be cropped).
Rect imageBounds;
using (var commandList = new CanvasCommandList(sourceBitmap.Device))
using (var drawingSession = commandList.CreateDrawingSession())
{
imageBounds = image.GetBounds(drawingSession);
}
// Rasterize the image into a rendertarget.
using (var renderTarget = new CanvasRenderTarget(sourceBitmap.Device, (float)imageBounds.Width, (float)imageBounds.Height, 96))
{
using (var drawingSession = renderTarget.CreateDrawingSession())
{
drawingSession.Blend = CanvasBlend.Copy;
drawingSession.DrawImage(image, -(float)imageBounds.X, -(float)imageBounds.Y);
}
// Save it out.
var format = file.FileType.Equals(".png", StringComparison.OrdinalIgnoreCase) ? CanvasBitmapFileFormat.Png : CanvasBitmapFileFormat.Jpeg;
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
stream.Size = 0;
await renderTarget.SaveAsync(stream, format);
}
}
}
public byte[] DrawStrokeOnImageBackground(IReadOnlyList<InkStroke> strokes, byte[] backgroundImageBuffer)
{
var stmbuffer = new InMemoryRandomAccessStream();
stmbuffer.AsStreamForWrite().AsOutputStream().WriteAsync(backgroundImageBuffer.AsBuffer()).AsTask().Wait();
CanvasDevice device = CanvasDevice.GetSharedDevice();
var canbit = CanvasBitmap.LoadAsync(device, stmbuffer, 96).AsTask().Result;
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, canbit.SizeInPixels.Width, canbit.SizeInPixels.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.Transparent);
if (backgroundImageBuffer != null)
{
ds.DrawImage(canbit);
}
ds.DrawInk(strokes);
}
var stm = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stm, CanvasBitmapFileFormat.Png).AsTask().Wait();
var readfrom = stm.GetInputStreamAt(0).AsStreamForRead();
var ms = new MemoryStream();
readfrom.CopyTo(ms);
var outputBuffer = ms.ToArray();
return outputBuffer;
}
public void Process(CanvasBitmap input, CanvasRenderTarget output, TimeSpan time)
{
using (CanvasDrawingSession session = output.CreateDrawingSession())
{
session.DrawImage(input);
session.DrawText("Canvas Effect test", 0f, 0f, Colors.Red);
}
}
public void drawText(CanvasRenderTarget crt, Color color)
{
using (CanvasDrawingSession ds = crt.CreateDrawingSession())
{
ds.DrawTextLayout(textLayout, (float)location.X, (float)location.Y, color);
}
}
/// <summary>
/// Applys a blur to a UI element
/// </summary>
/// <param name="sourceElement">UIElement to blur, generally an Image control, but can be anything</param>
/// <param name="blurAmount">Level of blur to apply</param>
/// <returns>Blurred UIElement as BitmapImage</returns>
public static async Task<BitmapImage> BlurElementAsync(this UIElement sourceElement, float blurAmount = 2.0f)
{
if (sourceElement == null)
return null;
var rtb = new RenderTargetBitmap();
await rtb.RenderAsync(sourceElement);
var buffer = await rtb.GetPixelsAsync();
var array = buffer.ToArray();
var displayInformation = DisplayInformation.GetForCurrentView();
using (var stream = new InMemoryRandomAccessStream())
{
var pngEncoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
pngEncoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied,
(uint) rtb.PixelWidth,
(uint) rtb.PixelHeight,
displayInformation.RawDpiX,
displayInformation.RawDpiY,
array);
await pngEncoder.FlushAsync();
stream.Seek(0);
var canvasDevice = new CanvasDevice();
var bitmap = await CanvasBitmap.LoadAsync(canvasDevice, stream);
var renderer = new CanvasRenderTarget(canvasDevice,
bitmap.SizeInPixels.Width,
bitmap.SizeInPixels.Height,
bitmap.Dpi);
using (var ds = renderer.CreateDrawingSession())
{
var blur = new GaussianBlurEffect
{
BlurAmount = blurAmount,
Source = bitmap
};
ds.DrawImage(blur);
}
stream.Seek(0);
await renderer.SaveAsync(stream, CanvasBitmapFileFormat.Png);
var image = new BitmapImage();
await image.SetSourceAsync(stream);
return image;
}
}
public ImageInfo(CanvasRenderTarget image)
{
_crt = image;
BitmapSize bsize = image.SizeInPixels;
Size size = image.Size;
_offset = new Point(size.Width / 2.0f, size.Height / 2.0f);
using (CanvasDrawingSession ds = image.CreateDrawingSession())
{
_symbolBounds = image.GetBounds(ds);
_imageBounds = ShapeUtilities.clone(_symbolBounds);
}
}
public void Process(CanvasBitmap input, CanvasRenderTarget output, TimeSpan time)
{
using (CanvasDrawingSession session = output.CreateDrawingSession())
{
session.DrawImage(input);
session.FillCircle(
(float)input.Bounds.Width / 2,
(float)input.Bounds.Height / 2,
(float)(Math.Min(input.Bounds.Width, input.Bounds.Height) / 2 * Math.Cos(2 * Math.PI * time.TotalSeconds)),
Colors.Aqua
);
}
}
//Creates textures of different sizes
public void CreateParticleBitmaps(bool blur = false)
{
SetColors(baseColor);
particleBitmaps = new CanvasRenderTarget[sizes];
int i = -1;
var nextRadius = 0;
var nextSize =0;
var transparent = Color.FromArgb(0, 0, 0, 0);
float viewportsize = 100; //Here is the trick, if this value is too small appears the displacement and the original image
for (int r = 1; r < sizes + 1; r += 1)
{
nextRadius = (r * minRadius);
nextSize = nextRadius * 2;
CanvasRenderTarget canvas = new CanvasRenderTarget(device, viewportsize, viewportsize, parent.Dpi);
var center = new Vector2((viewportsize - nextRadius) / 2);
//The following is like a 'drawing graph', the output of the first is the input of the second one;
using (CanvasDrawingSession targetSession = canvas.CreateDrawingSession())
{
targetSession.Clear(transparent);
targetSession.FillCircle(center, nextRadius, outerColor);
targetSession.FillCircle(center, nextRadius - 6, innerColor);
}
if (!blur)
{
particleBitmaps[++i] = canvas;
}
else //Add blur just one time
{
var blurEffect = new GaussianBlurEffect() { BlurAmount = 2f };
CanvasRenderTarget blurredcanvas = new CanvasRenderTarget(device, viewportsize, viewportsize, parent.Dpi);
blurEffect.Source = canvas;
using (CanvasDrawingSession targetSession = blurredcanvas.CreateDrawingSession())
{
targetSession.Clear(transparent);
targetSession.DrawImage(blurEffect);
}
particleBitmaps[++i] = blurredcanvas;
}
}
}
public void RenderTargetDpiTest()
{
const float defaultDpi = 96;
const float highDpi = defaultDpi * 2;
const float size = 100;
const float fractionalSize = 100.8f;
var device = new CanvasDevice();
var renderTargetDefault = new CanvasRenderTarget(device, size, size, defaultDpi);
var renderTargetHigh = new CanvasRenderTarget(device, size, size, highDpi);
var renderTargetFractionalSize = new CanvasRenderTarget(device, fractionalSize, fractionalSize, highDpi);
// Check each rendertarget reports the expected DPI.
Assert.AreEqual(defaultDpi, renderTargetDefault.Dpi);
Assert.AreEqual(highDpi, renderTargetHigh.Dpi);
Assert.AreEqual(highDpi, renderTargetFractionalSize.Dpi);
// Check each rendertarget is of the expected size.
Assert.AreEqual(size, renderTargetDefault.Size.Width);
Assert.AreEqual(size, renderTargetDefault.Size.Height);
Assert.AreEqual(size, renderTargetHigh.Size.Width);
Assert.AreEqual(size, renderTargetHigh.Size.Height);
Assert.AreEqual(Math.Round(fractionalSize), renderTargetFractionalSize.Size.Width);
Assert.AreEqual(Math.Round(fractionalSize), renderTargetFractionalSize.Size.Height);
// Check sizes in pixels.
Assert.AreEqual(size, renderTargetDefault.SizeInPixels.Width);
Assert.AreEqual(size, renderTargetDefault.SizeInPixels.Height);
Assert.AreEqual(size * highDpi / defaultDpi, renderTargetHigh.SizeInPixels.Width);
Assert.AreEqual(size * highDpi / defaultDpi, renderTargetHigh.SizeInPixels.Height);
Assert.AreEqual(Math.Round(fractionalSize * highDpi / defaultDpi), renderTargetFractionalSize.SizeInPixels.Width);
Assert.AreEqual(Math.Round(fractionalSize * highDpi / defaultDpi), renderTargetFractionalSize.SizeInPixels.Height);
// Check that drawing sessions inherit the DPI of the rendertarget being drawn onto.
var drawingSessionDefault = renderTargetDefault.CreateDrawingSession();
var drawingSessionHigh = renderTargetHigh.CreateDrawingSession();
Assert.AreEqual(defaultDpi, drawingSessionDefault.Dpi);
Assert.AreEqual(highDpi, drawingSessionHigh.Dpi);
}
public byte[] DrawStrokeOnSolidColorBackground(IReadOnlyList<InkStroke> strokes, int width, int height, Color color )
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, width, height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(color);
ds.DrawInk(strokes);
}
var stm = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stm, CanvasBitmapFileFormat.Png).AsTask().Wait();
var readfrom = stm.GetInputStreamAt(0).AsStreamForRead();
var ms = new MemoryStream();
readfrom.CopyTo(ms);
var outputBuffer = ms.ToArray();
return outputBuffer;
}
private static async Task<CanvasBitmap> DownloadPng(CanvasDevice device, Uri uri)
{
try
{
return await CanvasBitmap.LoadAsync(device, await CachedData.GetRandomAccessStreamAsync(uri));
}
catch (FileNotFoundException)
{
var rt = new CanvasRenderTarget(device, 480, 360, 96);
using (var ds = rt.CreateDrawingSession())
{
ds.Clear(Colors.Transparent);
ds.DrawLine(0, 0, (float)rt.Size.Width, (float)rt.Size.Height, Colors.Black, 1);
ds.DrawLine(0, (float)rt.Size.Height, (float)rt.Size.Width, 0, Colors.Black, 1);
}
return rt;
}
}
private async void BtnSave_Click(object sender, RoutedEventArgs e)
{
StorageFolder storageFolder = KnownFolders.SavedPictures;
var file = await storageFolder.CreateFileAsync("sample.jpg", CreationCollisionOption.ReplaceExisting);
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)MyInkCanvas.ActualWidth, (int)MyInkCanvas.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawInk(MyInkCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Jpeg, 1f);
}
}
private static void RendererImage(Stream stream, SvgImageRendererSettings settings)
{
var svg = settings.Document;
var viewPort = svg.RootElement.ViewPort;
if (!viewPort.HasValue) throw new ArgumentException(nameof(settings));
var width = viewPort.Value.Width;
var height = viewPort.Value.Height;
var device = CanvasDevice.GetSharedDevice();
using (var offScreen = new CanvasRenderTarget(device, width, height, settings.Scaling * 96.0F))
{
using (var renderer = new Win2dRenderer(offScreen, svg))
using (var session = offScreen.CreateDrawingSession())
{
session.Clear(Colors.Transparent);
renderer.Render(width, height, session);
}
offScreen.SaveAsync(stream.AsRandomAccessStream(), (CanvasBitmapFileFormat)settings.Format, settings.Quality).AsTask().GetAwaiter().GetResult();
}
}
public async Task<SoftwareBitmap> RenderAsync(IEnumerable<InkStroke> inkStrokes, double width, double height)
{
var dpi = DisplayInformation.GetForCurrentView().LogicalDpi;
try
{
var renderTarget = new CanvasRenderTarget(_canvasDevice, (float)width, (float)height, dpi); using (renderTarget)
{
using (var drawingSession = renderTarget.CreateDrawingSession())
{
drawingSession.DrawInk(inkStrokes);
}
return await SoftwareBitmap.CreateCopyFromSurfaceAsync(renderTarget);
}
}
catch (Exception e) when (_canvasDevice.IsDeviceLost(e.HResult))
{
_canvasDevice.RaiseDeviceLost();
}
return null;
}
public static ImageInfo getIcon(String symbolID, int size, Color color, int outlineSize)
{
ImageInfo returnVal = null;
if (_tgl == null)
_tgl = TacticalGraphicLookup.getInstance();
int mapping = _tgl.getCharCodeFromSymbol(symbolID);
CanvasRenderTarget coreBMP = null;
SVGPath svgTG = null;
//SVGPath svgFrame = null;
if (mapping > 0)
svgTG = TGSVGTable.getInstance().getSVGPath(mapping);
//float scale = 1;
Matrix3x2 mScale, mTranslate;
Matrix3x2 mIdentity = Matrix3x2.Identity;
Rect rectF = new Rect();
Matrix3x2 m = svgTG.CreateMatrix(size, size, out rectF, out mScale, out mTranslate);
//svgTG.TransformToFitDimensions(size, size);
Rect rr = svgTG.computeBounds(m);
CanvasDevice device = CanvasDevice.GetSharedDevice();
//CanvasRenderTarget offscreen = new CanvasRenderTarget(device, width, height, 96);
coreBMP = new CanvasRenderTarget(device, (int)(rr.Width + 0.5), (int)(rr.Height + 0.5),96);
using (CanvasDrawingSession cds = coreBMP.CreateDrawingSession())
{
svgTG.Draw(cds, Colors.Transparent, 0, color, m);
cds.DrawRectangle(coreBMP.GetBounds(device), Colors.Red);
}
returnVal = new ImageInfo(coreBMP,new Point(coreBMP.Size.Width/2f,coreBMP.Size.Height/2.0f),new Rect(0,0,coreBMP.Size.Width,coreBMP.Size.Height),coreBMP.GetBounds(device));
return returnVal;
}
public static IRandomAccessStream GenerateFromString(string str, string fontFamily, Color color)
{
float size = 512;
using (var device = new CanvasDevice())
using (var renderTarget = new CanvasRenderTarget(device, size, size, 96))
{
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawText(str, size / 2, size / 2, color,
new CanvasTextFormat()
{
FontFamily = fontFamily,
FontSize = size / 2,
HorizontalAlignment = CanvasHorizontalAlignment.Center,
VerticalAlignment = CanvasVerticalAlignment.Center
});
}
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stream, CanvasBitmapFileFormat.Png).AsTask().Wait();
return stream;
}
}
public void SetPixelBytesReadHazards()
{
var device = new CanvasDevice();
var bitmap = CanvasBitmap.CreateFromBytes(device, new byte[4], 1, 1, DirectXPixelFormat.B8G8R8A8UIntNormalized);
var renderTarget = new CanvasRenderTarget(device, 2, 1, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
bitmap.SetPixelBytes(new byte[] { 255, 0, 0, 255 });
ds.DrawImage(bitmap, 0, 0);
bitmap.SetPixelBytes(new byte[] { 0, 0, 255, 255 });
ds.DrawImage(bitmap, 1, 0);
}
CollectionAssert.AreEqual(new Color[] { Colors.Blue, Colors.Red }, renderTarget.GetPixelColors());
}
static async Task<string> GenerateAndSaveTileImage(CanvasDevice device, float width, float height)
{
using (var renderTarget = new CanvasRenderTarget(device, width, height, 96))
{
using (var ds = renderTarget.CreateDrawingSession())
{
DrawTile(ds, width, height);
}
var filename = string.Format("tile-{0}x{1}-{2}.png",
(int)width,
(int)height,
Guid.NewGuid().ToString());
await renderTarget.SaveAsync(Path.Combine(ApplicationData.Current.LocalFolder.Path, filename));
return filename;
}
}
void DoTest(float opacity, CanvasBitmap source, CanvasRenderTarget target)
{
using (var ds = target.CreateDrawingSession())
{
ds.FillRectangle(target.Bounds, fillPattern);
var leftHalf = source.Bounds;
leftHalf.Width /= 2;
var rightHalf = source.Bounds;
rightHalf.Width /= 2;
rightHalf.X += rightHalf.Width;
// This version calls D2D DrawBitmap
ds.DrawImage(source, 0, 0, leftHalf, opacity, CanvasImageInterpolation.Linear);
// This version calls D2D DrawImage with emulated opacity
ds.DrawImage(source, (float)rightHalf.X, 0, rightHalf, opacity, CanvasImageInterpolation.Cubic);
ds.Antialiasing = CanvasAntialiasing.Aliased;
ds.DrawLine((float)rightHalf.X, 0, (float)rightHalf.X, (float)rightHalf.Height, Colors.Black, 1, hairline);
}
}
public OffsetDemo(DrawImageEmulations example, CanvasControl sender)
{
fillPattern = example.checkedFillPattern;
var rt = new CanvasRenderTarget(sender, (float)example.tiger.Size.Width, (float)example.tiger.Size.Height, sender.Dpi / 3);
using (var ds = rt.CreateDrawingSession())
{
ds.DrawImage(example.tiger, rt.Bounds);
}
sourceBitmap = rt;
sourceEffect = new HueRotationEffect()
{
Source = sourceBitmap,
Angle = 1
};
showSourceRectRT = new CanvasRenderTarget(sender, (float)rt.Size.Width, (float)rt.Size.Height, rt.Dpi);
}
public void ProcessFrame(ProcessVideoFrameContext context)
{
try
{
// When using SupportedMemoryTypes => MediaMemoryTypes.GpuAndCpu we need to check if we're using GPU or CPU for the frame
// If we're on GPU, use InputFrame.Direct3DSurface
if (context.InputFrame.SoftwareBitmap == null)
{
using (var inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawImage(inputBitmap);
ds.DrawImage(this._overlay, inputBitmap.Bounds);
}
return;
}
// If we're on CPU, use InputFrame.SoftwareBitmap
if (context.InputFrame.Direct3DSurface == null)
{
// InputFrame's raw pixels
byte[] inputFrameBytes = new byte[4 * context.InputFrame.SoftwareBitmap.PixelWidth * context.InputFrame.SoftwareBitmap.PixelHeight];
context.InputFrame.SoftwareBitmap.CopyToBuffer(inputFrameBytes.AsBuffer());
using (var inputBitmap = CanvasBitmap.CreateFromBytes(
_canvasDevice,
inputFrameBytes,
context.InputFrame.SoftwareBitmap.PixelWidth,
context.InputFrame.SoftwareBitmap.PixelHeight,
context.InputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat()))
using (var renderTarget = new CanvasRenderTarget(
_canvasDevice,
context.OutputFrame.SoftwareBitmap.PixelWidth,
context.OutputFrame.SoftwareBitmap.PixelHeight,
(float)context.OutputFrame.SoftwareBitmap.DpiX,
context.OutputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat(),
CanvasAlphaMode.Premultiplied))
{
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawImage(inputBitmap);
ds.DrawImage(this._overlay, inputBitmap.Bounds);
}
}
}
}
catch (Exception)
{
if (crashCount < 20)
{
crashCount++;
Debug.WriteLine($"ProcessFrame Exception: #{crashCount}");
}
else
{
//System.Exception HResult = 0x88990012
//Message = Objects used together must be created from the same factory instance. (Exception from HRESULT: 0x88990012)
//Source = System.Private.CoreLib
//StackTrace:
//at System.Runtime.InteropServices.WindowsRuntime.IClosable.Close()
//at System.Runtime.InteropServices.WindowsRuntime.IClosableToIDisposableAdapter.Dispose()
//at VideoEffects.Win2D.OverlayVideoEffect.ProcessFrame(ProcessVideoFrameContext context) in D:\GitHub\VideoDiary\src\VideoDiary.EffectsLibrary\Win2dEffects\OverlayVideoEffect.cs:line 66
throw;
}
}
}
private void Draw()
{
using (var ds = currentSurface.CreateDrawingSession())
{
ds.Clear(Colors.Black);
ds.Transform =
Matrix3x2.Multiply(
Matrix3x2.CreateScale(new Vector2(1, -1)),
Matrix3x2.CreateTranslation(new Vector2(simulationW / 2, simulationH / 2)));
if (_tempMousePositions != null)
{
for (int i = 1; i < _tempMousePositions.Count; i++)
{
var p1 = new Vector2(_tempMousePositions[i - 1].X - simulationW / 2, simulationH / 2 - _tempMousePositions[i - 1].Y);
var p2 = new Vector2(_tempMousePositions[i].X - simulationW / 2, simulationH / 2 - _tempMousePositions[i].Y);
ds.DrawLine(p1, p2, Colors.Yellow);
}
}
bool syncRobot = false;
bool beginFigure = false;
bool endFigure = false;
lock (_jobs)
{
if (_jobs.Count > 0 && DateTime.Now >= _wakeUpTime)
{
// get oldest list
List <Vector2> positions = _jobs[0];
if (positions.Count > 0)
{
if (_jobPosIndex < positions.Count)
{
if (_jobPosIndex == 0)
{
beginFigure = true;
}
_targetPosition = positions[_jobPosIndex++];
}
else
{
endFigure = true;
_jobs.RemoveAt(0);
_jobPosIndex = 0;
}
if (_socket != null && _socket.Connected)
{
syncRobot = true;
}
}
// still something to do?
if (_jobs.Count > 0)
{
_wakeUpTime = DateTime.Now + TimeSpan.FromMilliseconds(125);
}
else
{
System.Diagnostics.Debug.WriteLine("no jobs pending");
}
// draw points
foreach (List <Vector2> remainingPaths in _jobs)
{
for (int i = 1; i < remainingPaths.Count; i++)
{
var p1 = new Vector2(remainingPaths[i - 1].X - simulationW / 2, simulationH / 2 - remainingPaths[i - 1].Y);
var p2 = new Vector2(remainingPaths[i].X - simulationW / 2, simulationH / 2 - remainingPaths[i].Y);
ds.DrawLine(p1, p2, Colors.LightSteelBlue);
}
}
}
}
var mx = _mousePosition.X - simulationW / 2;
var my = simulationH / 2 - _mousePosition.Y;
ds.DrawImage(_bitmap, new Vector2(mx, my));
// stick to last known position
var x = _targetPosition.X - simulationW / 2;
var y = simulationH / 2 - _targetPosition.Y;
Vector2 pos = new Vector2(x, y);
Vector2 normalizedPos = Vector2.Normalize(pos);
if (pos.LengthSquared() > (l1 + l2) * (l1 + l2))
{
Vector2 clamped = Vector2.Multiply((float)(l1 + l2), normalizedPos);
x = clamped.X;
y = clamped.Y;
}
// http://thingsiamdoing.com/inverse-kinematics/
double L = Math.Sqrt(x * x + y * y);
double a = Math.Acos((l1 * l1 + L * L - l2 * l2) / (2 * l1 * L));
double b = Math.Acos((l1 * l1 + l2 * l2 - L * L) / (2 * l1 * l2));
double XL = Math.Atan2(normalizedPos.Y, normalizedPos.X) - Math.Atan2(0, 1);
if (XL < 0)
{
XL += 2 * Math.PI;
}
double o1 = XL - a;
double o2 = Math.PI - b + o1;
ds.DrawCircle(Vector2.Zero, l1 + l2, Colors.Gray, 2);
// robot arm
ds.DrawLine(Vector2.Zero, new Vector2((float)(l1 * Math.Cos(o1)), (float)(l1 * Math.Sin(o1))), Colors.Green, 10);
ds.DrawLine(
new Vector2((float)(l1 * Math.Cos(o1)), (float)(l1 * Math.Sin(o1))),
new Vector2((float)(l1 * Math.Cos(o1) + l2 * Math.Cos(o2)), (float)(l1 * Math.Sin(o1) + l2 * Math.Sin(o2))), Colors.Red, 10);
ds.Transform = Matrix3x2.CreateTranslation(new Vector2(simulationW / 2, simulationH / 2));
ds.DrawText(string.Format("{0:0.00}:{1:0.00}", 180 * o1 / Math.PI, 180 * (b) / Math.PI), new Vector2(x, -y), Colors.Green);
if (syncRobot)
{
// send that command to the robot
SocketAsyncEventArgs completeArgs = new SocketAsyncEventArgs();
string robotCommand = "";
if (beginFigure)
{
robotCommand = "MOV;{0:0.00};{1:0.00}\0DWN;\0";
}
else if (endFigure)
{
robotCommand = "UP;\0";
}
else
{
robotCommand = "MOV;{0:0.00};{1:0.00}\0";
}
byte[] buffer = Encoding.ASCII.GetBytes(string.Format(robotCommand, 180 * o1 / Math.PI, (180 * (b) / Math.PI)));
completeArgs.SetBuffer(buffer, 0, buffer.Length);
completeArgs.UserToken = _socket;
completeArgs.RemoteEndPoint = _socket.RemoteEndPoint;
_socket.SendAsync(completeArgs);
}
}
}
//private bool correctionFlag = false;
public void ProcessFrame(ProcessVideoFrameContext context)
{
using (CanvasBitmap inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
using (CanvasRenderTarget renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
using (CanvasDrawingSession ds = renderTarget.CreateDrawingSession())
using (var scaleEffect = new ScaleEffect())
using (CanvasSolidColorBrush solidColorBrush = new CanvasSolidColorBrush(_canvasDevice, _backgroundColor))
{
solidColorBrush.Opacity = _backgroundOpacity;
double rel = context.InputFrame.RelativeTime.Value.Ticks / (double)TimeSpan.TicksPerMillisecond;
//context.OutputFrame.Duration = new TimeSpan( (long)(frameLength * TimeSpan.TicksPerMillisecond));
int frameTimeCounter = (int)Math.Round(rel / _frameLength, 0);
int[] pitch = new int[_count];
int[] yaw = new int[_count];
int[] fov = new int[_count];
for (int i = 0; i < _count; i++)
{
try
{
//pitch[i] = this.pitch[ (frameTimeCounter + (int)Math.Round(offset, 0)) * (count) + i];
//fov[i] = this.fov[ (frameTimeCounter + (int)Math.Round(offset, 0)) * (count) + i];
//yaw[i] = this.yaw[ (frameTimeCounter + (int)Math.Round(offset, 0)) * (count) + i];
pitch[i] = this._pitch[(frameTimeCounter + (int)_offset) * (_count) + i];
fov[i] = this._fov[(frameTimeCounter + (int)_offset) * (_count) + i];
yaw[i] = this._yaw[(frameTimeCounter + (int)_offset) * (_count) + i];
}
catch (ArgumentOutOfRangeException ex)
{
Debug.WriteLine(ex.Message);
pitch[i] = 0;
fov[i] = 0;
yaw[i] = 0;
}
}
byte[] tab = Heatmap.GenerateHeatmap(pitch, yaw, fov);
CanvasBitmap cb = CanvasBitmap.CreateFromBytes(_canvasDevice, tab, 64, 64, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized, 96, CanvasAlphaMode.Premultiplied);
scaleEffect.Source = cb;
scaleEffect.Scale = new System.Numerics.Vector2((float)_width / 64, (float)_height / 64);
scaleEffect.InterpolationMode = CanvasImageInterpolation.Cubic;
scaleEffect.BorderMode = EffectBorderMode.Hard;
if (_graysclaleVideoFlag)
{
var grayScaleEffect = new GrayscaleEffect
{
BufferPrecision = CanvasBufferPrecision.Precision8UIntNormalized,
CacheOutput = false,
Source = inputBitmap
};
ds.DrawImage(grayScaleEffect);
}
else
{
ds.DrawImage(inputBitmap);
}
ds.DrawImage(scaleEffect, 0, 0, new Windows.Foundation.Rect {
Height = _height, Width = _width
}, _heatmapOpacity);
if (_generateDots)
{
for (int i = 0; i < _count; i++)
{
ds.FillCircle(yaw[i] * _width / 64, pitch[i] * _height / 64, _dotsRadius, _colors[i % 5]);
}
}
ds.FillRectangle(new Windows.Foundation.Rect {
Height = _height, Width = _width
}, solidColorBrush);
ds.Flush();
}
}
public static async Task <ExportResult> ExportPngAsync(
ExportStyle style,
InstalledFont selectedFont,
FontVariant selectedVariant,
Character selectedChar,
CanvasTextLayoutAnalysis analysis,
CanvasTypography typography,
AppSettings settings)
{
try
{
string name = GetFileName(selectedFont, selectedVariant, selectedChar, "png");
if (await PickFileAsync(name, "PNG Image", new[] { ".png" }) is StorageFile file)
{
CachedFileManager.DeferUpdates(file);
if (analysis.GlyphFormats.Contains(GlyphImageFormat.Png))
{
IBuffer buffer = GetGlyphBuffer(selectedVariant.FontFace, selectedChar.UnicodeIndex, GlyphImageFormat.Png);
await FileIO.WriteBufferAsync(file, buffer);
}
else
{
var device = Utils.CanvasDevice;
var localDpi = 96; //Windows.Graphics.Display.DisplayInformation.GetForCurrentView().LogicalDpi;
var canvasH = (float)settings.PngSize;
var canvasW = (float)settings.PngSize;
using var renderTarget = new CanvasRenderTarget(device, canvasW, canvasH, localDpi);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.Transparent);
var d = settings.PngSize;
var r = settings.PngSize / 2;
var textColor = style == ExportStyle.Black ? Colors.Black : Colors.White;
var fontSize = (float)d;
using CanvasTextLayout layout = new CanvasTextLayout(device, $"{selectedChar.Char}", new CanvasTextFormat
{
FontSize = fontSize,
FontFamily = selectedVariant.Source,
FontStretch = selectedVariant.FontFace.Stretch,
FontWeight = selectedVariant.FontFace.Weight,
FontStyle = selectedVariant.FontFace.Style,
HorizontalAlignment = CanvasHorizontalAlignment.Center,
Options = style == ExportStyle.ColorGlyph ? CanvasDrawTextOptions.EnableColorFont : CanvasDrawTextOptions.Default
}, canvasW, canvasH);
if (style == ExportStyle.ColorGlyph)
{
layout.Options = CanvasDrawTextOptions.EnableColorFont;
}
layout.SetTypography(0, 1, typography);
var db = layout.DrawBounds;
double scale = Math.Min(1, Math.Min(canvasW / db.Width, canvasH / db.Height));
var x = -db.Left + ((canvasW - (db.Width * scale)) / 2d);
var y = -db.Top + ((canvasH - (db.Height * scale)) / 2d);
ds.Transform =
Matrix3x2.CreateTranslation(new Vector2((float)x, (float)y))
* Matrix3x2.CreateScale(new Vector2((float)scale));
ds.DrawTextLayout(layout, new Vector2(0), textColor);
}
using var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite);
fileStream.Size = 0;
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Png, 1f);
}
await CachedFileManager.CompleteUpdatesAsync(file);
return(new ExportResult(true, file));
}
}
catch (Exception ex)
{
await Ioc.Default.GetService <IDialogService>()
.ShowMessageAsync(ex.Message, Localization.Get("SaveImageError"));
}
return(new ExportResult(false, null));
}
public CanvasRenderTarget applyEdgeDetectionEffects(CanvasBitmap workingBitmap)
{
//CanvasBitmap workingBitmap = SelectWorkingBitmap(useOriginalBitmap);
if (workingBitmap != null)
{
int ww = (int)workingBitmap.SizeInPixels.Width;
int hh = (int)workingBitmap.SizeInPixels.Height;
//GrayscaleEffect grayscaleEffect = new GrayscaleEffect();
//grayscaleEffect.Source=canvasBitmap;
ContrastEffect contrastEffect = new ContrastEffect();
contrastEffect.Contrast = (float)edgeDetectionContrast;
contrastEffect.Source = workingBitmap;
ExposureEffect exposureEffect = new ExposureEffect();
exposureEffect.Source = contrastEffect;
exposureEffect.Exposure = (float)edgeDetectionExposure;
EdgeDetectionEffect edgeDetectionEffect = new EdgeDetectionEffect();
edgeDetectionEffect.Source = exposureEffect;
edgeDetectionEffect.Amount = (float)edgeDetectionAmount;
edgeDetectionEffect.BlurAmount = (float)edgeDetectionBlurAmount;
//edgeDetectionEffect.OverlayEdges = true;
//edgeDetectionEffect.Mode = EdgeDetectionEffectMode.Prewitt;
GrayscaleEffect grayscaleEffect = null;
if (edgeDetectionGrayscale)
{
grayscaleEffect = new GrayscaleEffect();
grayscaleEffect.Source = exposureEffect;
edgeDetectionEffect.Source = grayscaleEffect;
}
InvertEffect invertEdgeEffect = null;
if (edgeDetectionMaskInvert)
{
invertEdgeEffect = new InvertEffect();
invertEdgeEffect.Source = edgeDetectionEffect;
}
BlendEffect blendEffect = null;
if (edgeDetectionOverlayImage)
{
OpacityEffect opacityEffect = new OpacityEffect();
opacityEffect.Opacity = (float)edgeDetectionOverlayOpacity;
opacityEffect.Source = workingBitmap;
blendEffect = new BlendEffect();
blendEffect.Foreground = edgeDetectionEffect;
blendEffect.Background = opacityEffect;
if (edgeDetectionMaskInvert)
{
//blendEffect.Background = invertEdgeEffect;
//blendEffect.Foreground = opacityEffect;
InvertEffect invertOrgEffect = new InvertEffect();
invertOrgEffect.Source = opacityEffect;
blendEffect.Background = invertOrgEffect;
}
blendEffect.Mode = edgeDetectionBlendEffectMode;
}
//if (canvasRenderTarget != null)
// canvasRenderTarget.Dispose();
CanvasRenderTarget canvasRenderTarget = new CanvasRenderTarget(CanvasDevice.GetSharedDevice(), ww, hh, canvasBitmap.Dpi);
using (var session = canvasRenderTarget.CreateDrawingSession())
{
if (edgeDetectionOverlayImage)
{
session.DrawImage(blendEffect);
}
else
{
if (edgeDetectionMaskInvert)
{
session.DrawImage(invertEdgeEffect);
}
else
{
session.DrawImage(edgeDetectionEffect);
}
}
}
return(canvasRenderTarget);
}
return(null);
}
public CanvasRenderTarget apply3DLightingEffects(CanvasBitmap workingBitmap)
{
//CanvasBitmap workingBitmap = SelectWorkingBitmap(useOriginalBitmap);
if (workingBitmap != null)
{
int ww = (int)workingBitmap.SizeInPixels.Width;
int hh = (int)workingBitmap.SizeInPixels.Height;
//LuminanceToAlphaEffect heightField = new LuminanceToAlphaEffect();
//heightField.Source = workingBitmap;
LuminanceToAlphaEffect heightMap = new LuminanceToAlphaEffect();
heightMap.Source = workingBitmap;
GaussianBlurEffect heightField = new GaussianBlurEffect();
heightField.BlurAmount = (float)gaussianBlurAmount;
heightField.Source = heightMap;
heightField.BorderMode = EffectBorderMode.Soft;
DistantDiffuseEffect distantDiffuseEffect = new DistantDiffuseEffect();
distantDiffuseEffect.Source = heightField;
distantDiffuseEffect.HeightMapScale = (float)distantDiffuseEffectHeightMapScale;
distantDiffuseEffect.HeightMapInterpolationMode = CanvasImageInterpolation.HighQualityCubic;
distantDiffuseEffect.Azimuth = (float)distantAzimuth;
distantDiffuseEffect.Elevation = (float)distantElevation;
distantDiffuseEffect.LightColor = distantLightColor;
distantDiffuseEffect.HeightMapKernelSize = new System.Numerics.Vector2((float)distantDiffuseKernelWidth, (float)distantDiffuseKernelWidth);
//distantDiffuseEffect.DiffuseAmount = (float) distantDiffuseAmount;
DistantSpecularEffect distantSpecularEffect = new DistantSpecularEffect();
distantSpecularEffect.Source = heightField;
distantSpecularEffect.SpecularExponent = (float)distantSpecularEffectSpecularExponent;
distantSpecularEffect.HeightMapInterpolationMode = CanvasImageInterpolation.HighQualityCubic;
distantSpecularEffect.HeightMapKernelSize = new System.Numerics.Vector2((float)distantSpecularKernelWidth, (float)distantSpecularKernelWidth);
distantSpecularEffect.HeightMapScale = (float)distantSpecularHeightMapScale;
distantSpecularEffect.Azimuth = (float)distantAzimuth;
distantSpecularEffect.Elevation = (float)distantElevation;
//distantSpecularEffect.SpecularAmount = (float)distantSpecularAmount;
//distantSpecularEffect.LightColor = distantLightColor;
ArithmeticCompositeEffect arithmeticCompositeEffect = new ArithmeticCompositeEffect();
arithmeticCompositeEffect.Source1 = distantDiffuseEffect;
//arithmeticCompositeEffect.Source1 = blendedDiffuseEffect;
arithmeticCompositeEffect.Source2 = distantSpecularEffect;
arithmeticCompositeEffect.Source1Amount = 1;
arithmeticCompositeEffect.Source2Amount = 1;
arithmeticCompositeEffect.MultiplyAmount = 0;
SaturationEffect saturationEffect = new SaturationEffect();
saturationEffect.Source = workingBitmap;
saturationEffect.Saturation = (float)distantDiffuseSaturation;
ArithmeticCompositeEffect blendedDiffuseEffect = new ArithmeticCompositeEffect();
//blendedDiffuseEffect.Source1 = workingBitmap;
blendedDiffuseEffect.Source1 = saturationEffect;
blendedDiffuseEffect.Source2 = arithmeticCompositeEffect;
blendedDiffuseEffect.Source1Amount = 0;
blendedDiffuseEffect.Source2Amount = 0;
blendedDiffuseEffect.MultiplyAmount = 1;
//if (canvasRenderTarget != null)
// canvasRenderTarget.Dispose();
CanvasRenderTarget canvasRenderTarget = new CanvasRenderTarget(CanvasDevice.GetSharedDevice(), ww, hh, canvasBitmap.Dpi);
using (var session = canvasRenderTarget.CreateDrawingSession())
{
//session.DrawImage(arithmeticCompositeEffect);
session.DrawImage(blendedDiffuseEffect);
}
return(canvasRenderTarget);
}
return(null);
}
private void DrawBackGround(CanvasDevice device, RenderingOptions options)
{
float useHeight = (float)ChartWin2DCanvas.Size.Height;
float useWidth = (float)ChartWin2DCanvas.Size.Width;
//this is always drawn in the size of control, so all texts drawn in it are sharp
_offscreenBackGround = new CanvasRenderTarget(device, useWidth, useHeight, 96);
using (CanvasDrawingSession ds = _offscreenBackGround.CreateDrawingSession())
{
ds.Clear(BACKGROUND_COLOR);
//draw lines
DrawGraphValueLines(ds, useWidth, useHeight);
//draw value texts
DrawYAxisTexts(ds, useHeight, options);
}
}
void canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args)
{
// We animate the source image by changing which character is highlighted in yellow.
// Therefore there can be two changed regions: the highlighted character has changed from
// white to yellow, while the previous highlight has changed from yellow back to white.
// Look up the bounds of the two changed characters.
var highlightBounds = GetCharacterBounds(highlightedCharacter);
var previousBounds = GetCharacterBounds(previousHighlight);
// Tell our effects that the highlighted character region has changed.
blurEffect.InvalidateSourceRectangle(args.DrawingSession, 0, highlightBounds);
shadowEffect.InvalidateSourceRectangle(args.DrawingSession, 0, highlightBounds);
// Query what part of the output image will change as a result.
var highlightInvalidRects = compositeEffect.GetInvalidRectangles(args.DrawingSession);
var highlightInvalidUnion = GetRectangleUnion(highlightInvalidRects);
// Also tell the effects about the previously highlighted character.
blurEffect.InvalidateSourceRectangle(args.DrawingSession, 0, previousBounds);
shadowEffect.InvalidateSourceRectangle(args.DrawingSession, 0, previousBounds);
// Query the output region again. This will return a superset of highlightInvalidRects,
// as it now accounts for the change to previousBounds as well as highlightBounds.
var totalInvalidRects = compositeEffect.GetInvalidRectangles(args.DrawingSession);
var totalInvalidUnion = GetRectangleUnion(totalInvalidRects);
// We can also look up in the opposite direction: given that we are going to redraw only
// the totalInvalidUnion area, what portion of each source image is needed to do that?
// When using filter kernels like blur, this will be larger than just highlightBounds+previousBounds.
var requiredSourceRects = compositeEffect.GetRequiredSourceRectangles(args.DrawingSession,
totalInvalidUnion,
new ICanvasEffect[] { blurEffect, shadowEffect },
new uint[] { 0, 0 },
new Rect[2] {
sourceRenderTarget.Bounds, sourceRenderTarget.Bounds
});
// How about if we were going to redraw only highlightBounds, skipping previousBounds?
// (we don't actually do this, but do display what source regions it would require).
var blurSourceRect = compositeEffect.GetRequiredSourceRectangle(args.DrawingSession, highlightInvalidUnion, blurEffect, 0, sourceRenderTarget.Bounds);
var shadowSourceRect = compositeEffect.GetRequiredSourceRectangle(args.DrawingSession, highlightInvalidUnion, shadowEffect, 0, sourceRenderTarget.Bounds);
// Draw text into the source rendertarget.
using (var drawingSession = sourceRenderTarget.CreateDrawingSession())
{
// To make sure the correct requiredSourceRects were reported, we clear the background outside
// that region to magenta. If everything is working correctly, this should never be picked up by
// effect drawing, as we only leave magenta in the areas we don't expect the effects to read from.
drawingSession.Clear(Colors.Magenta);
// Clear the requiredSourceRects to transparent.
drawingSession.Blend = CanvasBlend.Copy;
foreach (var r in requiredSourceRects)
{
drawingSession.FillRectangle(r, Colors.Transparent);
}
// Draw the text characters.
drawingSession.Blend = CanvasBlend.SourceOver;
for (int i = 0; i < characterLayouts.Count; i++)
{
var color = (i == highlightedCharacter) ? Colors.Yellow : Colors.White;
drawingSession.DrawTextLayout(characterLayouts[i], characterPositions[i], color);
}
}
// Draw the effect graph (which reads from sourceRenderTarget) into destRenderTarget.
using (var drawingSession = destRenderTarget.CreateDrawingSession())
{
// Slightly darken down the existing contents of the output rendertarget. This causes everything
// except totalInvalidUnion to gradually fade out, so we can see which areas are getting redrawn.
// If this FillRectangle was removed, the result of redrawing only the changed region would be
// identical to if we redrew the whole thing every time (by removing the CreateLayer call).
drawingSession.FillRectangle(destRenderTarget.Bounds, Color.FromArgb(16, 0, 0, 0));
// Clip our drawing to the totalInvalidUnion rectangle,
// which should be the only part of the output that has changed.
using (var layer = drawingSession.CreateLayer(1, totalInvalidUnion))
{
drawingSession.Clear(Colors.CornflowerBlue);
drawingSession.DrawImage(compositeEffect, totalInvalidUnion, totalInvalidUnion);
}
}
if (!ThumbnailGenerator.IsDrawingThumbnail)
{
args.DrawingSession.Transform = Matrix3x2.CreateTranslation(gap, gap);
// Display sourceRenderTarget.
args.DrawingSession.DrawImage(sourceRenderTarget);
// Display highlightBounds, blurSourceRect, and shadowSourceRect.
args.DrawingSession.DrawRectangle(highlightBounds, Colors.Gray);
args.DrawingSession.DrawRectangle(blurSourceRect, Colors.Blue);
args.DrawingSession.DrawRectangle(shadowSourceRect, Colors.Blue);
}
args.DrawingSession.Transform = Matrix3x2.CreateTranslation(gap, gap * 2 + height);
// Display destRenderTarget.
args.DrawingSession.DrawImage(destRenderTarget);
// Display highlightInvalidRects.
foreach (var i in highlightInvalidRects)
{
args.DrawingSession.DrawRectangle(i, Colors.DarkBlue);
}
previousHighlight = highlightedCharacter;
// When generating thumbnails, repeat the first draw a bunch of times to reach a more interesting image.
if (ThumbnailGenerator.IsDrawingThumbnail && highlightedCharacter < characterLayouts.Count * 5 / 6)
{
highlightedCharacter++;
canvas_Draw(sender, args);
}
}
private async void ExportImage()
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
using (CanvasRenderTarget offscreen = new CanvasRenderTarget(
device, item.ImageProperties.Width, item.ImageProperties.Height, 96))
{
using (IRandomAccessStream stream = await item.ImageFile.OpenReadAsync())
using (CanvasBitmap image = await CanvasBitmap.LoadAsync(offscreen, stream, 96))
{
ImageEffectsBrush.SetSource(image);
using (CanvasDrawingSession ds = offscreen.CreateDrawingSession())
{
ds.Clear(Windows.UI.Colors.Black);
var img = ImageEffectsBrush.Image;
ds.DrawImage(img);
}
var fileSavePicker = new FileSavePicker()
{
SuggestedStartLocation = PickerLocationId.PicturesLibrary,
SuggestedSaveFile = item.ImageFile
};
fileSavePicker.FileTypeChoices.Add("JPEG files", new List <string>()
{
".jpg"
});
var outputFile = await fileSavePicker.PickSaveFileAsync();
if (outputFile != null)
{
using (IRandomAccessStream outStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
await offscreen.SaveAsync(outStream, CanvasBitmapFileFormat.Jpeg);
}
// Check whether this save is overwriting the original image.
// If it is, replace it in the list. Otherwise, insert it as a copy.
bool replace = false;
if (outputFile.IsEqual(item.ImageFile))
{
replace = true;
}
try
{
await LoadSavedImageAsync(outputFile, replace);
}
catch (Exception ex)
{
if (ex.Message.Contains("0x80070323"))
{
// The handle with which this oplock was associated has been closed.
// The oplock is now broken. (Exception from HRESULT: 0x80070323)
// This is a temporary condition, so just try again.
await LoadSavedImageAsync(outputFile, replace);
}
}
}
}
}
}
public static async Task <StorageFile> DrawStrokesAsync(StorageFile file, IReadOnlyList <SmoothPathBuilder> strokes, Rect rectangle, BitmapRotation rotation, BitmapFlip flip)
{
var device = CanvasDevice.GetSharedDevice();
var bitmap = await CanvasBitmap.LoadAsync(device, file.Path);
var canvas1 = new CanvasRenderTarget(device, (float)bitmap.Size.Width, (float)bitmap.Size.Height, bitmap.Dpi);
var canvas2 = new CanvasRenderTarget(device, (float)bitmap.Size.Width, (float)bitmap.Size.Height, bitmap.Dpi);
var size = canvas1.Size.ToVector2();
var canvasSize = canvas1.Size.ToVector2();
var scaleX = 1 / (float)rectangle.Width;
var scaleY = 1 / (float)rectangle.Height;
var offsetX = (float)rectangle.X * scaleX;
var offsetY = (float)rectangle.Y * scaleY;
if (rotation == BitmapRotation.Clockwise270Degrees ||
rotation == BitmapRotation.Clockwise90Degrees)
{
size = new Vector2(size.Y, size.X);
scaleX = scaleY;
scaleY = 1 * 1 / (float)rectangle.Width;
}
using (var session = canvas1.CreateDrawingSession())
{
switch (rotation)
{
case BitmapRotation.Clockwise90Degrees:
var transform1 = Matrix3x2.CreateRotation(MathFEx.ToRadians(90));
transform1.Translation = new Vector2(size.Y, 0);
session.Transform = transform1;
break;
case BitmapRotation.Clockwise180Degrees:
var transform2 = Matrix3x2.CreateRotation(MathFEx.ToRadians(180));
transform2.Translation = new Vector2(size.X, size.Y);
session.Transform = transform2;
break;
case BitmapRotation.Clockwise270Degrees:
var transform3 = Matrix3x2.CreateRotation(MathFEx.ToRadians(270));
transform3.Translation = new Vector2(0, size.X);
session.Transform = transform3;
break;
}
switch (flip)
{
case BitmapFlip.Horizontal:
switch (rotation)
{
case BitmapRotation.Clockwise90Degrees:
case BitmapRotation.Clockwise270Degrees:
session.Transform = Matrix3x2.Multiply(session.Transform, Matrix3x2.CreateScale(1, -1, canvasSize / 2));
break;
default:
session.Transform = Matrix3x2.Multiply(session.Transform, Matrix3x2.CreateScale(-1, 1, canvasSize / 2));
break;
}
break;
case BitmapFlip.Vertical:
switch (rotation)
{
case BitmapRotation.None:
case BitmapRotation.Clockwise180Degrees:
session.Transform = Matrix3x2.Multiply(session.Transform, Matrix3x2.CreateScale(1, -1, canvasSize / 2));
break;
default:
session.Transform = Matrix3x2.Multiply(session.Transform, Matrix3x2.CreateScale(-1, 1, canvasSize / 2));
break;
}
break;
}
session.Transform = Matrix3x2.Multiply(session.Transform, Matrix3x2.CreateScale(scaleX, scaleY));
session.Transform = Matrix3x2.Multiply(session.Transform, Matrix3x2.CreateTranslation(-(offsetX * size.X), -(offsetY * size.Y)));
foreach (var builder in strokes)
{
PencilCanvas.DrawPath(session, builder, size);
}
}
using (var session = canvas2.CreateDrawingSession())
{
session.DrawImage(bitmap);
session.DrawImage(canvas1);
}
bitmap.Dispose();
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await canvas2.SaveAsync(stream, CanvasBitmapFileFormat.Jpeg /*, 0.77f*/);
}
canvas2.Dispose();
canvas1.Dispose();
return(file);
}
static CanvasBitmap MakeThumbnailPretty(CanvasBitmap capturedBitmap, float thumbnailWidth, float thumbnailHeight, Rect targetRect)
{
var pixelColors = capturedBitmap.GetPixelColors();
// Remove any unused space around the edge of the bitmap, so it will fill the thumbnail.
Rect cropRect = CropCapturedBitmap(capturedBitmap, pixelColors);
// Choose a (hopefully) aesthetically pleasing background color.
Color backgroundColor = ChooseBackgroundColor(pixelColors);
// Apply letterbox scaling to fit the image into the target thumbnail.
Vector2 outputSize = new Vector2((float)targetRect.Width, (float)targetRect.Height);
var sourceSize = new Vector2((float)cropRect.Width, (float)cropRect.Height);
var letterbox = Utils.GetDisplayTransform(outputSize, sourceSize);
var translate = Matrix3x2.CreateTranslation((float)targetRect.X, (float)targetRect.Y);
// Position the image where we want it.
var scaledImage = new Transform2DEffect
{
Source = new AtlasEffect
{
Source = capturedBitmap,
SourceRectangle = cropRect,
},
InterpolationMode = CanvasImageInterpolation.HighQualityCubic,
TransformMatrix = letterbox * translate,
};
// Create the final thumbnail image.
var finalImage = new CompositeEffect
{
Sources =
{
// Blurred shadow.
new ShadowEffect
{
Source = new MorphologyEffect
{
Source = scaledImage,
Mode = MorphologyEffectMode.Dilate,
Width = dilateAmount,
Height = dilateAmount,
},
BlurAmount = blurAmount,
},
// Overlay the image itself.
scaledImage
}
};
// Rasterize the effect into a rendertarget.
CanvasRenderTarget output = new CanvasRenderTarget(capturedBitmap.Device, thumbnailWidth, thumbnailHeight, 96);
using (var ds = output.CreateDrawingSession())
{
ds.Clear(backgroundColor);
ds.DrawImage(finalImage);
}
return(output);
}
public void ProcessFrame(ProcessVideoFrameContext context)
{
//using (CanvasBitmap inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
//using (CanvasRenderTarget renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
//using (CanvasDrawingSession ds = renderTarget.CreateDrawingSession())
//{
// var invert = new InvertEffect()
// {
// Source = inputBitmap
// };
// ds.DrawImage(invert);
//}
// When using SupportedMemoryTypes => MediaMemoryTypes.GpuAndCpu we need to check if we're using GPU or CPU for the frame
// If we're on GPU, use InputFrame.Direct3DSurface
if (context.InputFrame.SoftwareBitmap == null)
{
using (var inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, context.InputFrame.Direct3DSurface))
using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
using (var ds = renderTarget.CreateDrawingSession())
{
var invert = new InvertEffect()
{
Source = inputBitmap
};
ds.DrawImage(invert);
}
return;
}
// If we're on CPU, use InputFrame.SoftwareBitmap
if (context.InputFrame.Direct3DSurface == null)
{
// InputFrame's raw pixels
byte[] inputFrameBytes = new byte[4 * context.InputFrame.SoftwareBitmap.PixelWidth * context.InputFrame.SoftwareBitmap.PixelHeight];
context.InputFrame.SoftwareBitmap.CopyToBuffer(inputFrameBytes.AsBuffer());
using (var inputBitmap = CanvasBitmap.CreateFromBytes(
_canvasDevice,
inputFrameBytes,
context.InputFrame.SoftwareBitmap.PixelWidth,
context.InputFrame.SoftwareBitmap.PixelHeight,
context.InputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat()))
using (var renderTarget = new CanvasRenderTarget(
_canvasDevice,
context.OutputFrame.SoftwareBitmap.PixelWidth,
context.OutputFrame.SoftwareBitmap.PixelHeight,
(float)context.OutputFrame.SoftwareBitmap.DpiX,
context.OutputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat(),
CanvasAlphaMode.Premultiplied))
{
using (var ds = renderTarget.CreateDrawingSession())
{
var invert = new InvertEffect()
{
Source = inputBitmap
};
ds.DrawImage(invert);
}
}
}
}
private ICanvasImage AddTextOverlay(ICanvasImage effect, float x, float y)
{
var textOverlay = new CanvasRenderTarget(canvas, 200, 30);
using (var ds = textOverlay.CreateDrawingSession())
{
ds.Clear(Color.FromArgb(0, 0, 0, 0));
ds.DrawText(effect.GetType().Name.Replace("Effect", ""), 0, 0, Colors.White);
}
return new Transform2DEffect
{
Source = new BlendEffect
{
Background = effect,
Foreground = textOverlay,
Mode = BlendEffectMode.Screen
},
TransformMatrix = Matrix3x2.CreateTranslation(x, y)
};
}
/// <summary>
/// Recognize the text from handwriting using Microsoft Azure service.
/// </summary>
public async void RecognizeInking(IReadOnlyList <InkStroke> strokeList, double pageWidth, double pageHeight)
{
// Current bounding box for the strokes.
double tlX = double.MaxValue;
double tlY = double.MaxValue;
double brX = 0;
double brY = 0;
inkingStatus = SERVICE_STATUS.PENDING;
// Make a copy of this list
List <InkStroke> newList = new List <InkStroke>();
foreach (InkStroke ss in strokeList)
{
newList.Add(ss);
tlX = Math.Min(tlX, ss.BoundingRect.Left);
tlY = Math.Min(tlY, ss.BoundingRect.Top);
brX = Math.Max(brX, ss.BoundingRect.Right);
brY = Math.Max(brY, ss.BoundingRect.Bottom);
}
double originalCroppedWidth = brX - tlX;
double originalCroppedHeight = brY - tlY;
// Create boundary
tlX = Math.Max(0, tlX - originalCroppedWidth * 0.2);
tlY = Math.Max(0, tlY - originalCroppedHeight * 0.4);
brX = Math.Min(pageWidth, brX + originalCroppedWidth * 0.2);
brY = Math.Min(pageHeight, brY + originalCroppedHeight * 0.4);
originalCroppedWidth = brX - tlX;
originalCroppedHeight = brY - tlY;
StorageFolder storageFolder = KnownFolders.CameraRoll;
var file = await storageFolder.CreateFileAsync("sampleInking.jpg", CreationCollisionOption.GenerateUniqueName);
// Render a whole image (paper size * inking scale)
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (float)pageWidth, (float)pageHeight, 96);
//await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
// () =>
// {
// using (var ds = renderTarget.CreateDrawingSession())
// {
// ds.Clear(Colors.White);
// ds.DrawInk(strokeList);
// }
// });
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawInk(newList);
}
// Crop the image: using same algorithm as in OCR method.
// croppedBytes: image bytes.
// byteData: final format, with bmp header.
byte[] byteData = new byte[1];
byte[] croppedBytes = new byte[1];
uint width = 0, height = 0;
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Jpeg, 1f);
//Debug.Log("Save to:" + file.Name);
// Crop this image.
// Create a decoder from the stream. With the decoder, we can get the properties of the image.
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);
// make sure the image is larger than 50x50 in real pixels.
double scale = Math.Max(1.0f, Math.Max(AZURE_API_MIN_SIZE / originalCroppedWidth, AZURE_API_MIN_SIZE / originalCroppedHeight));
uint startPointX = (uint)Math.Floor(tlX * scale);
uint startPointY = (uint)Math.Floor(tlY * scale);
width = (uint)Math.Floor(originalCroppedWidth * scale);
height = (uint)Math.Floor(originalCroppedHeight * scale);
// The scaledSize of original image.
uint scaledWidth = (uint)Math.Floor(decoder.PixelWidth * scale);
uint scaledHeight = (uint)Math.Floor(decoder.PixelHeight * scale);
// Refine the start point and the size.
if (startPointX + width > scaledWidth)
{
startPointX = scaledWidth - width;
}
if (startPointY + height > scaledHeight)
{
startPointY = scaledHeight - height;
}
// Get the cropped pixels.
BitmapTransform transform = new BitmapTransform();
BitmapBounds bounds = new BitmapBounds();
bounds.X = startPointX;
bounds.Y = startPointY;
bounds.Height = height;
bounds.Width = width;
transform.Bounds = bounds;
transform.ScaledWidth = scaledWidth;
transform.ScaledHeight = scaledHeight;
// Get the cropped pixels within the bounds of transform.
PixelDataProvider pix = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
transform,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.ColorManageToSRgb);
croppedBytes = pix.DetachPixelData();
//Debug.Log(string.Format("Crop Handwritten image: start: {0},{1}, width:{2}, height:{3}", bounds.X, bounds.Y, bounds.Width, bounds.Height));
}
await file.DeleteAsync();
// Again, I have to save to file stream byte[] to image.
// https://code.msdn.microsoft.com/windowsapps/How-to-save-WriteableBitmap-bd23d455
var tempFile = await storageFolder.CreateFileAsync("temp-sampleInking.jpg", CreationCollisionOption.GenerateUniqueName);
using (var stream = await tempFile.OpenAsync(FileAccessMode.ReadWrite))
{
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, width, height, 96, 96, croppedBytes);
await encoder.FlushAsync();
var reader = new DataReader(stream.GetInputStreamAt(0));
byteData = new byte[stream.Size];
await reader.LoadAsync((uint)stream.Size);
reader.ReadBytes(byteData);
}
await tempFile.DeleteAsync();
//ReadHandwrittenText("");
HttpClient client = new HttpClient();
// Request headers.
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", azureKey);
// Request parameter. Set "handwriting" to false for printed text.
string requestParameters = "handwriting=true";
// Assemble the URI for the REST API Call.
string uri = azureUri + "recognizeText?" + requestParameters;
HttpResponseMessage response = null;
// This operation requrires two REST API calls. One to submit the image for processing,
// the other to retrieve the text found in the image. This value stores the REST API
// location to call to retrieve the text.
string operationLocation = null;
// Request body. Posts a locally stored JPEG image.
//byte[] byteData = canvasImg;
ByteArrayContent content = new ByteArrayContent(byteData);
// This example uses content type "application/octet-stream".
// You can also use "application/json" and specify an image URL.
content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
// The first REST call starts the async process to analyze the written text in the image.
response = await client.PostAsync(uri, content);
// The response contains the URI to retrieve the result of the process.
if (response.IsSuccessStatusCode)
{
operationLocation = response.Headers.GetValues("Operation-Location").FirstOrDefault();
}
else
{
// Display the JSON error data.
string errInfo = "RecognizeInking: PosyAsync Response Error." + response.StatusCode.ToString();
inkingResult = errInfo;
inkingStatus = SERVICE_STATUS.ERROR;
Debug.Log(errInfo + "\n");
//Debug.Log(JsonPrettyPrint(await response.Content.ReadAsStringAsync()));
return;
}
// The second REST call retrieves the text written in the image.
//
// Note: The response may not be immediately available. Handwriting recognition is an
// async operation that can take a variable amount of time depending on the length
// of the handwritten text. You may need to wait or retry this operation.
//
// This example checks once per second for ten seconds.
string contentString;
int i = 0;
do
{
await Task.Delay(1000);
response = await client.GetAsync(operationLocation);
contentString = await response.Content.ReadAsStringAsync();
++i;
}while (i < 10 && contentString.IndexOf("\"status\":\"Succeeded\"") == -1);
if (i == 10 && contentString.IndexOf("\"status\":\"Succeeded\"") == -1)
{
string errInfo = "RecognizeInking: Timeout Error.";
inkingResult = errInfo;
Debug.Log(errInfo + "\n");
inkingStatus = SERVICE_STATUS.ERROR;
return;
}
// Display the JSON response.
//Debug.Log("\nResponse:\n");
//Debug.Log(JsonPrettyPrint(contentString));
// Parse to output the result.
var result = JsonConvert.DeserializeObject <JSONInking.RootObject>(contentString).recognitionResult;
var texts = new List <string>();
foreach (var line in result.lines)
{
texts.Add(line.text);
}
if (texts.Count > 0)
{
inkingResult = string.Join(" ", texts);
//Debug.Log("Inking Recognition succeeded:" + inkingResult);
inkingStatus = SERVICE_STATUS.DONE;
}
else
{
string errInfo = "Inking Recognition succeeded but the result is empty.";
inkingResult = errInfo;
Debug.Log(errInfo);
inkingStatus = SERVICE_STATUS.ERROR;
}
}
private async void HomeContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
HomeContentDialog.Hide();
LoadingControl.IsLoading = true;//Con：加载控件
await Task.Delay(400);
//1、创建一个XDocument对象
XDocument xDoc = new XDocument();
XDeclaration XDec = new XDeclaration("1.0", "utf-8", "no");
//设置xml的文档定义
xDoc.Declaration = XDec;
//2、创建根节点
XElement root = new XElement("Layers");
xDoc.Add(root);
XElement Width = new XElement("Width", App.Model.Width);
root.Add(Width);
XElement Height = new XElement("Height", App.Model.Height);
root.Add(Height);
XElement Tool = new XElement("Tool", App.Model.Tool);
root.Add(Tool);
XElement Index = new XElement("Index", App.Model.Index);
root.Add(Index);
//3、创建主图片
ICanvasImage ci = App.Model.NullRenderTarget;
for (int i = App.Model.Layers.Count - 1; i >= 0; i--) //自下而上渲染
{
ci = App.RenderTransform(App.Model.Layers[i], ci); //渲染
}
using (CanvasDrawingSession ds = App.Model.SecondBottomRenderTarget.CreateDrawingSession())
{
ds.Clear(Color.FromArgb(0, 0, 0, 0));
ds.DrawImage(ci);
}
var MainBytes = App.Model.SecondBottomRenderTarget.GetPixelBytes(); //把位图转为byte[]
var MainString = Convert.ToBase64String(MainBytes); //把btye[]转为字符串
XElement MainCanvasRender = new XElement("MainRenderTarget", MainString); //字符串写入xml节点
root.Add(MainCanvasRender);
//4、循环创建节点
foreach (var l in App.Model.Layers)
{
XElement Layer = new XElement("Layer");
root.Add(Layer);
//4、创建元素
XElement LayerName = new XElement("LayerName", l.Name);
Layer.Add(LayerName);
XElement LayerVisual = new XElement("LayerVisual", l.Visual);
Layer.Add(LayerVisual);
XElement LayerOpacity = new XElement("LayerOpacity", l.Opacity);
Layer.Add(LayerOpacity);
XElement LayerBlendIndex = new XElement("LayerBlendIndex", l.BlendIndex);
Layer.Add(LayerBlendIndex);
XElement LayerWidth = new XElement("LayerWidth", l.CanvasRenderTarget.SizeInPixels.Width);
Layer.Add(LayerWidth);
XElement LayerHeight = new XElement("LayerHeight", l.CanvasRenderTarget.SizeInPixels.Height);
Layer.Add(LayerHeight);
var Bytes = l.CanvasRenderTarget.GetPixelBytes(); //把位图转为byte[]
var str = Convert.ToBase64String(Bytes); //把btye[]转为字符串
XElement CanvasRenderTarget = new XElement("CanvasRenderTarget", str); //字符串写入xml节点
Layer.Add(CanvasRenderTarget);
}
//5、保存
string path = ApplicationData.Current.LocalFolder.Path + "/" + App.Model.Name + ".photo"; //将XML文件加载进来
xDoc.Save(path);
//6、缩略图 （裁切成宽高最大256的图片）
//缩略图缩放比例
float scale = App.Model.Width < App.Model.Height ? 256.0f / App.Model.Width : 256.0f / App.Model.Height;
//缩放后宽高并确定左右上下偏移
float W = scale * App.Model.Width;
float H = scale * App.Model.Height;
CanvasRenderTarget crt = new CanvasRenderTarget(App.Model.VirtualControl, W, H);
using (CanvasDrawingSession ds = crt.CreateDrawingSession())
{
//绘制缩略图
ds.DrawImage(new ScaleEffect
{
Source = App.Model.MainRenderTarget,
Scale = new Vector2(scale)
});
}
Library.Image.SavePng(ApplicationData.Current.LocalFolder, crt, App.Model.Name, CreationCollisionOption.ReplaceExisting);
LoadingControl.IsLoading = false;//Con：加载控件
// Frame.GoBack();
App.Model.StartVisibility = Visibility.Visible;
}
private CanvasRenderTarget CreateSourceImage(CanvasControl sender, CanvasAlphaMode alphaMode)
{
var image = new CanvasRenderTarget(sender, 64, 64, sender.Dpi, DirectXPixelFormat.B8G8R8A8UIntNormalized, alphaMode);
using (var ds = image.CreateDrawingSession())
{
ds.Clear(Colors.Transparent);
ds.FillRectangle(0, 0, 64, 16, Colors.Blue);
ds.FillRectangle(0, 32 - 8, 64, 16, Color.FromArgb(128, 0, 0, 255));
ds.FillRectangle(0, 64 - 16, 64, 16, Colors.Blue);
ds.FillCircle(32, 32, 16, Colors.Yellow);
}
return image;
}
async Task GenerateIcon(AppInfo appInfo, IconInfo iconInfo, StorageFolder folder)
{
// Draw the icon image into a command list.
var commandList = new CanvasCommandList(device);
using (var ds = commandList.CreateDrawingSession())
{
appInfo.DrawIconImage(ds, iconInfo);
}
ICanvasImage iconImage = commandList;
// Rasterize into a rendertarget.
var renderTarget = new CanvasRenderTarget(device, iconInfo.Width, iconInfo.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
// Initialize with the appropriate background color.
ds.Clear(iconInfo.TransparentBackground ? Colors.Transparent : appInfo.BackgroundColor);
// Work out where to position the icon image.
var imageBounds = iconImage.GetBounds(ds);
imageBounds.Height *= 1 + iconInfo.BottomPadding;
float scaleUpTheSmallerIcons = Math.Max(1, 1 + (60f - iconInfo.Width) / 50f);
float imageScale = appInfo.ImageScale * scaleUpTheSmallerIcons;
var transform = Matrix3x2.CreateTranslation((float)-imageBounds.X, (float)-imageBounds.Y) *
Utils.GetDisplayTransform(renderTarget.Size.ToVector2(), new Vector2((float)imageBounds.Width, (float)imageBounds.Height)) *
Matrix3x2.CreateScale(imageScale, renderTarget.Size.ToVector2() / 2);
if (iconInfo.Monochrome)
{
// Optionally convert to monochrome.
iconImage = new DiscreteTransferEffect
{
Source = new Transform2DEffect
{
Source = new LuminanceToAlphaEffect {
Source = iconImage
},
TransformMatrix = transform
},
RedTable = new float[] { 1 },
GreenTable = new float[] { 1 },
BlueTable = new float[] { 1 },
AlphaTable = new float[] { 0, 1 }
};
}
else
{
ds.Transform = transform;
// Optional shadow effect.
if (appInfo.AddShadow)
{
var shadow = new ShadowEffect
{
Source = iconImage,
BlurAmount = 12,
};
ds.DrawImage(shadow);
}
}
// draw the main icon image.
ds.DrawImage(iconImage);
}
// Save to a file.
using (var stream = await folder.OpenStreamForWriteAsync(iconInfo.Filename, CreationCollisionOption.ReplaceExisting))
{
await renderTarget.SaveAsync(stream.AsRandomAccessStream(), CanvasBitmapFileFormat.Png);
}
}
private async void PlayBackImage_ImageOpened(IRandomAccessStream stream)
{
if (CurrentSong != null)
{
{
var device = new CanvasDevice();
var bitmap = await CanvasBitmap.LoadAsync(device, stream);
var renderer = new CanvasRenderTarget(device,
bitmap.SizeInPixels.Width,
bitmap.SizeInPixels.Height, bitmap.Dpi);
using (var ds = renderer.CreateDrawingSession())
{
var blur = new GaussianBlurEffect
{
Source = bitmap
};
blur.BlurAmount = 16.0f;
blur.BorderMode = EffectBorderMode.Hard;
ds.DrawImage(blur);
}
stream.Seek(0);
await renderer.SaveAsync(stream, CanvasBitmapFileFormat.Png);
stream.Seek(0);
BitmapImage image = new BitmapImage();
image.SetSource(stream);
BackgroundBlur.Source = image;
renderer = null;
bitmap = null;
device = null;
GC.Collect();
}
}
}
// ** Methods ** //
// This is run for every video frame passed in the media pipleine (MediaPlayer, MediaCapture, etc)
public void ProcessFrame(ProcessVideoFrameContext context)
{
evaluatableVideoFrame = VideoFrame.CreateWithDirect3D11Surface(context.InputFrame.Direct3DSurface);
// ********** Draw Bounding Boxes with Win2D ********** //
// Use Direct3DSurface if using GPU memory
if (context.InputFrame.Direct3DSurface != null)
{
if (modelBindingComplete && options.PreferredDeviceKind != LearningModelDeviceKindPreview.LearningDeviceGpu)
{
options.PreferredDeviceKind = LearningModelDeviceKindPreview.LearningDeviceGpu;
}
using (var inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(canvasDevice, context.InputFrame.Direct3DSurface))
using (var renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(canvasDevice, context.OutputFrame.Direct3DSurface))
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawImage(inputBitmap);
foreach (var box in filteredBoxes)
{
var x = (uint)Math.Max(box.X, 0);
var y = (uint)Math.Max(box.Y, 0);
var w = (uint)Math.Min(renderTarget.Bounds.Width - x, box.Width);
var h = (uint)Math.Min(renderTarget.Bounds.Height - y, box.Height);
// Draw the Text 10px above the top of the bounding box
ds.DrawText(box.Label, x, y - 10, Colors.Yellow);
ds.DrawRectangle(new Rect(x, y, w, h), new CanvasSolidColorBrush(canvasDevice, Colors.Yellow), 2f);
}
}
return;
}
// Use SoftwareBitmap if using CPU memory
if (context.InputFrame.SoftwareBitmap != null)
{
if (modelBindingComplete && options.PreferredDeviceKind != LearningModelDeviceKindPreview.LearningDeviceCpu)
{
options.PreferredDeviceKind = LearningModelDeviceKindPreview.LearningDeviceCpu;
}
// InputFrame's pixels
byte[] inputFrameBytes = new byte[4 * context.InputFrame.SoftwareBitmap.PixelWidth * context.InputFrame.SoftwareBitmap.PixelHeight];
context.InputFrame.SoftwareBitmap.CopyToBuffer(inputFrameBytes.AsBuffer());
using (var inputBitmap = CanvasBitmap.CreateFromBytes(canvasDevice, inputFrameBytes, context.InputFrame.SoftwareBitmap.PixelWidth, context.InputFrame.SoftwareBitmap.PixelHeight, context.InputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat()))
using (var renderTarget = new CanvasRenderTarget(canvasDevice, context.OutputFrame.SoftwareBitmap.PixelWidth, context.InputFrame.SoftwareBitmap.PixelHeight, (float)context.OutputFrame.SoftwareBitmap.DpiX, context.OutputFrame.SoftwareBitmap.BitmapPixelFormat.ToDirectXPixelFormat(), CanvasAlphaMode.Premultiplied))
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawImage(inputBitmap);
foreach (var box in filteredBoxes)
{
var x = (uint)Math.Max(box.X, 0);
var y = (uint)Math.Max(box.Y, 0);
var w = (uint)Math.Min(context.OutputFrame.SoftwareBitmap.PixelWidth - x, box.Width);
var h = (uint)Math.Min(context.OutputFrame.SoftwareBitmap.PixelHeight - y, box.Height);
// Draw the Text 10px above the top of the bounding box
ds.DrawText(box.Label, x, y - 10, Colors.Yellow);
ds.DrawRectangle(new Rect(x, y, w, h), new CanvasSolidColorBrush(canvasDevice, Colors.Yellow), 2f);
}
}
}
}
private async void loadImage_Click(object sender, RoutedEventArgs e)
{
FileOpenPicker fileOpenPicker = new FileOpenPicker();
fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileOpenPicker.FileTypeFilter.Add(".jpg");
fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
var inputFile = await fileOpenPicker.PickSingleFileAsync();
if (inputFile == null)
{
// The user cancelled the picking operation
return;
}
SoftwareBitmap softwareBitmap;
using (IRandomAccessStream stream = await inputFile.OpenAsync(FileAccessMode.ReadWrite))
{
// Create the decoder from the stream
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
// Get the SoftwareBitmap representation of the file
softwareBitmap = await decoder.GetSoftwareBitmapAsync();
}
if (softwareBitmap.BitmapPixelFormat != BitmapPixelFormat.Bgra8 || softwareBitmap.BitmapAlphaMode == BitmapAlphaMode.Straight)
{
softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
}
var source = new SoftwareBitmapSource();
await source.SetBitmapAsync(softwareBitmap);
imageControl.Source = source;
var device = CanvasDevice.GetSharedDevice();
var image = default(CanvasBitmap);
using (var s = await inputFile.OpenReadAsync())
{
image = await CanvasBitmap.LoadAsync(device, s);
}
var offscreen = new CanvasRenderTarget(device, (float)image.Bounds.Width, (float)image.Bounds.Height, 96);
using (var ds = offscreen.CreateDrawingSession())
{
ds.DrawImage(image, 0, 0);
ds.DrawText("Hello note", 10, 400, Colors.Aqua);
}
var displayInformation = DisplayInformation.GetForCurrentView();
var savepicker = new FileSavePicker();
savepicker.FileTypeChoices.Add("png", new List <string> {
".png"
});
var destFile = await savepicker.PickSaveFileAsync();
using (var s = await destFile.OpenAsync(FileAccessMode.ReadWrite))
{
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, s);
encoder.SetPixelData(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Ignore,
(uint)offscreen.Size.Width,
(uint)offscreen.Size.Height,
displayInformation.LogicalDpi,
displayInformation.LogicalDpi,
offscreen.GetPixelBytes());
await encoder.FlushAsync();
}
}
public async Task <Point> DrawWeather(CanvasDrawingSession ds, CanvasDevice device, CanvasBitmap canvasBitmap, Point drawPoint, bool isBackground = false)
{
#region Init & Get Weather Informations
Size screenSize = SettingManager.GetWindowsResolution();
var width = screenSize.Width;
var height = screenSize.Height;
float space = (float)width - (float)drawPoint.X;
Rect textSize;
var newWidth = width - space;
double tempWidth = 0;
var oldDrawPoint = drawPoint.Y;
if (drawPoint.Y >= height)
{
drawPoint.Y = drawPoint.Y > height ? drawPoint.Y - height - height * 22 / 100 : height - height * 25 / 100;
}
if (!SettingsHelper.GetSetting <bool>(SettingKey.IsDisplayWeather.ToString()))
{
return(drawPoint);
}
//Get Weather condition in the 1st time
if (CurrentWeatherInfo.Temp == null)
{
if (CurrentWeather?.Main == null)
{
//If FixedLocation Mode is ON then get weather with FixedLocation
if (IsFixedLocation)
{
await GetWeather(false);
}
else
{
await GetWeather();
}
}
}
else
{
//If the final state is dif then get new WeatherCondition
if (IsFixedLocation == IsNormalMode)
{
if (IsFixedLocation)
{
if (!string.IsNullOrEmpty(UserLocation))
{
await GetWeather(false);
}
//Update Mode status & IconSaved
StartVm.IsIconSaved = false;
IsNormalMode = false;
}
else
{
await GetWeather();
StartVm.IsIconSaved = false;
IsNormalMode = true;
}
}
}
var isFahrenheit = SettingsHelper.GetSetting <bool>(SettingKey.IsFahrenheit.ToString());
//If CurrentWeather isn't loaded then draw with temporary template
//Avoid step out DrawWeather method when haven't drawn and make User think Weather Function is broken
if (CurrentWeather?.Main == null)
{
CurrentWeatherInfo.Temp = isFahrenheit ? "? °F" : "? °C";
if (string.IsNullOrEmpty(CurrentWeatherInfo.Address))
{
CurrentWeatherInfo.Address = "???";
CurrentWeatherInfo.Condition = "clouds";
CurrentWeatherInfo.MainCondition = "??";
}
//Update final state to get WeatherCondition in the next time
IsNormalMode = IsFixedLocation;
}
else
{
if (isFahrenheit)
{
CurrentWeatherInfo.Temp = Math.Round(CurrentWeather.Main.Temp * 1.8 + 32) + "°F";
}
else
{
CurrentWeatherInfo.Temp = Math.Round(CurrentWeather.Main.Temp) + "°C";
}
CurrentWeatherInfo.MainCondition = CurrentWeather.Weather[0].Main;
CurrentWeatherInfo.Condition = CurrentWeather.Weather[0].Description;
}
var address = CurrentWeatherInfo.Address;
#endregion
#region Get Address & Caculate area size, position
if (address != null)
{
var strArr = address.Split(',');
if (strArr.Count() >= 2)
{
CurrentWeatherInfo.Address = string.Format("{0},{1}", strArr[strArr.Length - 2],
strArr[strArr.Length - 1]);
}
else
{
CurrentWeatherInfo.Address = strArr[0];
}
var textFormat = new CanvasTextFormat
{
FontFamily = "Segoe UI Light",
FontSize = (float)(height * 4 / 100),
WordWrapping = CanvasWordWrapping.NoWrap
};
textSize = BitmapHelper.TextRect(CurrentWeatherInfo.Address, textFormat, ds);
if (string.IsNullOrEmpty(CurrentWeatherInfo.MainCondition))
{
CurrentWeatherInfo.Condition = "clouds";
CurrentWeatherInfo.MainCondition = "??";
}
//Caculate WeatherCondition text length for drawing AntiBright & Weather
var conditionSize = BitmapHelper.TextRect(CurrentWeatherInfo.MainCondition, new CanvasTextFormat()
{
FontSize = (float)(height * 4.5 / 100),
FontFamily = "Segoe UI Light",
FontWeight = FontWeights.Thin,
WordWrapping = CanvasWordWrapping.NoWrap
}, ds);
var tempSize = BitmapHelper.TextRect(CurrentWeatherInfo.Temp, new CanvasTextFormat()
{
FontSize = (float)(height * 7.5 / 100),
WordWrapping = CanvasWordWrapping.NoWrap,
FontFamily = "Segoe UI Light",
FontWeight = FontWeights.Thin
}, ds);
//Check if CenterX + WeatherCondition(or Temperature if Temp>WeatherCon) > Address to update CenterX(use for draw WeatherCondition)
tempWidth = tempSize.Width > conditionSize.Width ? tempSize.Width : conditionSize.Width;
DrawPoint = new Point(newWidth - textSize.Width, drawPoint.Y);
if (DrawPoint.X + textSize.Width + height / 100 >= newWidth)
{
newWidth -= height / 100;
DrawPoint = new Point(newWidth - textSize.Width, drawPoint.Y);
}
if (drawPoint.X == 0)
{
newWidth = textSize.Width > tempWidth + height * 15 / 100 + width / 100 ? textSize.Width + height * 3 / 100 : tempWidth + height * 15 / 100 + width / 100 + height * 3 / 100;
DrawPoint = new Point(newWidth - textSize.Width, drawPoint.Y);
}
//Check if WeatherIcon + TempWidth > Address to update DrawPoint
if (DrawPoint.X + tempWidth + height * 15 / 100 + width / 100 + height / 100 >= newWidth)
{
var x = DrawPoint.X - (tempWidth + DrawPoint.X + width / 100 + height * 15 / 100 + height / 100 - newWidth);
DrawPoint = new Point(x, drawPoint.Y);
}
if (Math.Abs(drawPoint.X - width / 2) < 0.5)
{
var leftToCenter = width / 2 - DrawPoint.X + height * 2 / 100;
var haftWidth = (newWidth - DrawPoint.X + height * 2 / 100) / 2;
var tempSpace = leftToCenter - haftWidth;
DrawPoint = new Point(DrawPoint.X + tempSpace, DrawPoint.Y);
newWidth += tempSpace;
}
}
#endregion
#region Draw Methods
if ((DrawPoint.X == 0) && (DrawPoint.Y == 0))
{
return(drawPoint);
}
{
//Check and draw transparent black rectangle if necessary
if (BitmapHelper.IsBrightArea(canvasBitmap,
(int)(DrawPoint.X - height * 2 / 100),
(int)(DrawPoint.Y - height / 100),
(int)(newWidth - DrawPoint.X + height * 2 / 100),
(int)height * 22 / 100))
{
ds.FillRoundedRectangle(
new Rect(DrawPoint.X - height * 2 / 100,
(int)DrawPoint.Y - height / 100,
newWidth - DrawPoint.X + height * 2 / 100,
height * 22 / 100), 20, 20,
new CanvasSolidColorBrush(device, Colors.Black)
{
Opacity = 0.4F
});
}
var strArr = CurrentWeatherInfo.Address?.Split(',');
if (strArr?.Length > 2)
{
CurrentWeatherInfo.Address = strArr[strArr.Length - 2] + "," + strArr[strArr.Length - 1];
}
if (CurrentWeatherInfo.Address != null)
{
ds.DrawText(CurrentWeatherInfo.Address, (float)(newWidth - height * 1.5 / 100), (float)DrawPoint.Y,
Colors.White,
new CanvasTextFormat
{
FontSize = (float)(height * 4 / 100),
HorizontalAlignment = CanvasHorizontalAlignment.Right,
FontFamily = "Segoe UI Light",
FontWeight = FontWeights.Thin
});
}
var centerX = (float)(DrawPoint.X + (newWidth - DrawPoint.X) / 2);
//Config Area position for better Draw design
if (tempWidth + centerX + width * 2 / 100 >= newWidth)
{
centerX -= (float)tempWidth + centerX + (float)(width * 2 / 100) - (float)newWidth;
}
else
{
if ((tempWidth + height * 15 / 100 >= textSize.Width) &&
(tempWidth + height * 15 / 100 + (newWidth - (float)width * 2 / 100) - textSize.Width) <= newWidth)
{
centerX = (float)((newWidth - (float)width * 2 / 100) - textSize.Width);
}
}
if (CurrentWeatherInfo.Temp != null)
{
ds.DrawText(CurrentWeatherInfo.Temp, centerX, (float)(DrawPoint.Y + height * 4.5 / 100), Colors.White,
new CanvasTextFormat
{
FontSize = (float)(height * 7.5 / 100),
HorizontalAlignment = CanvasHorizontalAlignment.Left,
FontFamily = "Segoe UI Light",
FontWeight = FontWeights.Thin
});
}
if (CurrentWeatherInfo.MainCondition != null)
{
ds.DrawText(CurrentWeatherInfo.MainCondition, centerX, (float)(DrawPoint.Y + height * 13 / 100),
Colors.White,
new CanvasTextFormat
{
FontSize = (float)(height * 4.5 / 100),
HorizontalAlignment = CanvasHorizontalAlignment.Left,
FontFamily = "Segoe UI Light",
FontWeight = FontWeights.Thin
});
}
if (CurrentWeatherInfo.Condition != null)
{
if (isBackground)
{
var weatherIcon = PickWeatherIcon(CurrentWeatherInfo.Condition);
var iconSizeStr = weatherIcon.Substring(0, 3);
var iconSize = int.Parse(iconSizeStr);
var iconBitmap = new CanvasRenderTarget(device, iconSize, iconSize, 500);
using (var ds1 = iconBitmap.CreateDrawingSession())
{
var file =
await
StorageFile.GetFileFromApplicationUriAsync(
new Uri("ms-appx:///ShareClass/Assets/WeatherIcon/" + weatherIcon + ".svg"));
using (var stream = await file.OpenStreamForReadAsync())
using (var reader = new StreamReader(stream))
{
var xml = new XmlDocument();
xml.LoadXml(reader.ReadToEnd(), new XmlLoadSettings {
ProhibitDtd = false
});
var svgDocument = SvgDocument.Parse(xml);
using (var renderer = new Win2dRenderer(iconBitmap, svgDocument))
renderer.Render(iconSize, iconSize, ds1);
ds.DrawImage(iconBitmap, new Rect(centerX - height * 15 / 100,
DrawPoint.Y + height * 5.5 / 100, height * 13 / 100, height * 13 / 100));
}
}
}
else
{
if (!StartVm.IsIconSaved)
{
var weatherIcon = PickWeatherIcon(CurrentWeatherInfo.Condition);
var iconSizeStr = weatherIcon.Substring(0, 3);
var iconSize = int.Parse(iconSizeStr);
var iconBitmap = new CanvasRenderTarget(device, iconSize, iconSize, 500);
using (var ds1 = iconBitmap.CreateDrawingSession())
{
var file =
await
StorageFile.GetFileFromApplicationUriAsync(
new Uri("ms-appx:///ShareClass/Assets/WeatherIcon/" + weatherIcon + ".svg"));
using (var stream = await file.OpenStreamForReadAsync())
using (var reader = new StreamReader(stream))
{
var xml = new XmlDocument();
xml.LoadXml(reader.ReadToEnd(), new XmlLoadSettings {
ProhibitDtd = false
});
var svgDocument = SvgDocument.Parse(xml);
using (var renderer = new Win2dRenderer(iconBitmap, svgDocument))
renderer.Render(iconSize, iconSize, ds1);
StartVm.IconBitmap = new CanvasRenderTarget(device, iconSize, iconSize, 500);
StartVm.IconBitmap = iconBitmap;
StartVm.IsIconSaved = true;
ds.DrawImage(iconBitmap, new Rect(centerX - height * 15 / 100,
DrawPoint.Y + height * 5.5 / 100, height * 13 / 100, height * 13 / 100));
}
}
}
else
{
ds.DrawImage(StartVm.IconBitmap,
new Rect(centerX - height * 15 / 100, DrawPoint.Y + height * 5.5 / 100, height * 13 / 100, height * 13 / 100));
}
}
}
if (oldDrawPoint >= screenSize.Height)
{
var temp = DrawPoint.Y - height * 1.5 / 100;
if (temp + screenSize.Height <= screenSize.Height * 2)
{
return(new Point(drawPoint.X, temp + screenSize.Height));
}
return(new Point(-1, -1));
}
else
{
var temp = DrawPoint.Y - height * 2 / 100 + height * 22 / 100;
if (temp <= screenSize.Height)
{
return(new Point(drawPoint.X, temp));
}
return(new Point(-1, -1));
}
}
#endregion
}
public void SetPixelColorsReadHazards()
{
var device = new CanvasDevice();
var bitmap = CanvasBitmap.CreateFromColors(device, new Color[1], 1, 1);
var renderTarget = new CanvasRenderTarget(device, 2, 1, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
bitmap.SetPixelColors(new Color[] { Colors.Blue });
ds.DrawImage(bitmap, 0, 0);
bitmap.SetPixelColors(new Color[] { Colors.Red });
ds.DrawImage(bitmap, 1, 0);
}
CollectionAssert.AreEqual(new Color[] { Colors.Blue, Colors.Red }, renderTarget.GetPixelColors());
}
private void DrawToCanvas(CanvasRenderTarget crt, List <Dot> dots, float scale, float offsetX, float offsetY, Color color, CanvasStrokeStyle canvasStrokeStyle, float thickness = 1f)
{
if (crt == null)
{
return;
}
if (dots == null || dots.Count == 0)
{
return;
}
using (CanvasDrawingSession drawSession = crt.CreateDrawingSession())
{
if (dots.Count <= 2)
{
float p = (float)dots[dots.Count - 1].Force / 1023 * thickness;
if (dots.Count == 1) // 점찍기
{
drawSession.FillCircle(dots[0].X * scale + offsetX, dots[0].Y * scale + offsetY, p, color);
}
else if (dots.Count == 2) // 선그리기
{
drawSession.DrawLine(dots[0].X * scale + offsetX, dots[0].Y * scale + offsetY, dots[1].X * scale + offsetX, dots[1].Y * scale + offsetY, color, p, canvasStrokeStyle);
}
}
else
{
thickness /= 2;
float x0, x1, x2, x3, y0, y1, y2, y3, p0, p1, p2, p3;
float vx01, vy01, vx21, vy21;
float norm;
float n_x0, n_y0, n_x2, n_y2;
x0 = dots[0].X * scale + offsetX + 0.1f;
y0 = dots[0].Y * scale + offsetY;
// TODO Change MaxForce
p0 = (float)dots[0].Force / 1023 * thickness;
x1 = dots[1].X * scale + offsetX + 0.1f;
y1 = dots[1].Y * scale + offsetY;
p1 = (float)dots[1].Force / 1023 * thickness;
vx01 = x1 - x0;
vy01 = y1 - y0;
// instead of dividing tangent/norm by two, we multiply norm by 2
norm = (float)System.Math.Sqrt(vx01 * vx01 + vy01 * vy01 + 0.0001f) * 2f;
//vx01 = vx01 / norm * scaled_pen_thickness * p0;
//vy01 = vy01 / norm * scaled_pen_thickness * p0;
vx01 = vx01 / norm * p0;
vy01 = vy01 / norm * p0;
n_x0 = vy01;
n_y0 = -vx01;
CanvasPathBuilder pathBuilder;
int count = dots.Count;
for (int i = 2; i < count; ++i)
{
x3 = dots[i].X * scale + offsetX + 0.1f;
y3 = dots[i].Y * scale + offsetY;
p3 = (float)dots[i].Force / 1023 * thickness;
x2 = (x1 + x3) / 2.0f;
y2 = (y1 + y3) / 2.0f;
p2 = (p1 + p3) / 2.0f;
vx21 = x1 - x2;
vy21 = y1 - y2;
norm = (float)System.Math.Sqrt(vx21 * vx21 + vy21 * vy21 + 0.0001f) * 2.0f;
vx21 = vx21 / norm * p2;
vy21 = vy21 / norm * p2;
n_x2 = -vy21;
n_y2 = vx21;
pathBuilder = new CanvasPathBuilder(drawableCanvas);
pathBuilder.BeginFigure(x0 + n_x0, y0 + n_y0);
// The + boundary of the stroke
pathBuilder.AddCubicBezier(new Vector2(x1 + n_x0, y1 + n_y0), new Vector2(x1 + n_x2, y1 + n_y2), new Vector2(x2 + n_x2, y2 + n_y2));
// round out the cap
pathBuilder.AddCubicBezier(new Vector2(x2 + n_x2 - vx21, y2 + n_y2 - vy21), new Vector2(x2 - n_x2 - vx21, y2 - n_y2 - vy21), new Vector2(x2 - n_x2, y2 - n_y2));
// THe - boundary of the stroke
pathBuilder.AddCubicBezier(new Vector2(x1 - n_x2, y1 - n_y2), new Vector2(x1 - n_x0, y1 - n_y0), new Vector2(x0 - n_x0, y0 - n_y0));
// round out the other cap
pathBuilder.AddCubicBezier(new Vector2(x0 - n_x0 - vx01, y0 - n_y0 - vy01), new Vector2(x0 + n_x0 - vx01, y0 + n_y0 - vy01), new Vector2(x0 + n_x0, y0 + n_y0));
pathBuilder.EndFigure(CanvasFigureLoop.Open);
drawSession.DrawGeometry(CanvasGeometry.CreatePath(pathBuilder), color, p2);
x0 = x2;
y0 = y2;
p0 = p2;
x1 = x3;
y1 = y3;
p1 = p3;
vx01 = -vx21;
vy01 = -vy21;
n_x0 = n_x2;
n_y0 = n_y2;
}
x2 = dots[count - 1].X * scale + offsetX + 0.1f;
y2 = dots[count - 1].Y * scale + offsetY;
p2 = dots[count - 1].Force / 1023 * thickness;
vx21 = x1 - x2;
vy21 = y1 - y2;
norm = (float)System.Math.Sqrt(vx21 * vx21 + vy21 * vy21 + 0.0001f) * 2f;
//vx21 = vx21 / norm * scaled_pen_thickness * p2;
//vy21 = vy21 / norm * scaled_pen_thickness * p2;
vx21 = vx21 / norm * p2;
vy21 = vy21 / norm * p2;
n_x2 = -vy21;
n_y2 = vx21;
pathBuilder = new CanvasPathBuilder(drawableCanvas);
pathBuilder.BeginFigure(x0 + n_x0, y0 + n_y0);
pathBuilder.AddCubicBezier(new Vector2(x1 + n_x0, y1 + n_y0), new Vector2(x1 + n_x2, y1 + n_y2), new Vector2(x2 + n_x2, y2 + n_y2));
pathBuilder.AddCubicBezier(new Vector2(x2 + n_x2 - vx21, y2 + n_y2 - vy21), new Vector2(x2 - n_x2 - vx21, y2 - n_y2 - vy21), new Vector2(x2 - n_x2, y2 - n_y2));
pathBuilder.AddCubicBezier(new Vector2(x1 - n_x2, y1 - n_y2), new Vector2(x1 - n_x0, y1 - n_y0), new Vector2(x0 - n_x0, y0 - n_y0));
pathBuilder.AddCubicBezier(new Vector2(x0 - n_x0 - vx01, y0 - n_y0 - vy01), new Vector2(x0 + n_x0 - vx01, y0 + n_y0 - vy01), new Vector2(x0 + n_x0, y0 + n_y0));
pathBuilder.EndFigure(CanvasFigureLoop.Open);
drawSession.DrawGeometry(CanvasGeometry.CreatePath(pathBuilder), color, p2);
}
}
}
private void DrawCharData(CanvasDevice device, RenderingOptions options, HeartbeatMeasurement[] data)
{
//Size restrictions descriped in : http://microsoft.github.io/Win2D/html/P_Microsoft_Graphics_Canvas_CanvasDevice_MaximumBitmapSizeInPixels.htm
float useHeight = (float)ChartWin2DCanvas.Size.Height > device.MaximumBitmapSizeInPixels ? device.MaximumBitmapSizeInPixels : (float)ChartWin2DCanvas.Size.Height;
float useWidth = data.Length > device.MaximumBitmapSizeInPixels ? device.MaximumBitmapSizeInPixels : data.Length;
//this will change the values array to array with drawing-line-points for the graph
List<DataPoint> dataList = FillOffsetList(data, options, useWidth, useHeight);
//reset zoom & moving values
_zoomFactor = 100;
_graphDrawingPoint = new Point(0, 0);
_graphDrawingSource = new Size(useWidth, useHeight);
//create the graph image
_offscreenChartImage = new CanvasRenderTarget(device, useWidth, useHeight, 96);
using (CanvasDrawingSession ds = _offscreenChartImage.CreateDrawingSession())
{
//This creates drawing geometry from the drawing-line-points
CanvasGeometry chart = getDrawChartGeometry(device, dataList);
//and then we simply draw it with defined color
ds.DrawGeometry(chart, 0, 0, GRAPG_COLOR);
}
}
public override void Init(WriteableBitmap bmp, IGrap9Attr attr = null)
{
var newbg = attr.bgurl != bgurl || attr.fgurl != fgurl || attr.hard != hard;
base.Init(bmp, attr);
b = bmp;
source = new CanvasRenderTarget(
device, b.PixelWidth, b.PixelHeight, 96,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized,
CanvasAlphaMode.Premultiplied
);
Canvas = new CanvasRenderTarget(
device, b.PixelWidth, b.PixelHeight, 96,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized,
CanvasAlphaMode.Premultiplied
);
Invalidate(true);
try
{
if (newbg)
{
if (fgurl != "")
{
var img = LayerPaint.Img.Create(fgurl);
Shape = CanvasBitmap.CreateFromBytes(
device, img.PixelBuffer, img.PixelWidth, img.PixelHeight,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized
);
}
else
{
var px = 200;
var csize = Canvas.Size;
var sample = new CanvasRenderTarget(device, 2 * px, 2 * px, 96,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized, CanvasAlphaMode.Premultiplied
);
var tb = new CanvasRadialGradientBrush(device, new[] {
new CanvasGradientStop()
{
Color = Color.FromArgb(255, 255, 255, 255), Position = hard
},
new CanvasGradientStop()
{
Color = Color.FromArgb(255, 0, 0, 0), Position = 1f
},
}, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Straight);
using (var s = sample.CreateDrawingSession())
{
tb.RadiusX = px; tb.RadiusY = px; tb.Center = new Vector2(px, px);
s.FillRectangle(0, 0, px * 2, px * 2, tb);
}
Shape = sample;
}
if (bgurl != "")
{
var img = LayerPaint.Img.Create(bgurl);
Texture = CanvasBitmap.CreateFromBytes(
device, img.PixelBuffer, img.PixelWidth, img.PixelHeight,
Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized
);
}
else
{
Texture = null;
}
//fgurl = bgurl= "";
}
}
catch (Exception e)
{
new Windows.UI.Popups.MessageDialog(e.ToString()).ShowMux();
}
Loadd();
}
private async void SaveInkPicture()
{
if (ink.Width == 0)
{
return;
}
//ink.Width = WB_CapturedImage.PixelWidth;
//ink.Height = WB_CapturedImage.PixelHeight;
((App)App.Current).SyncStrokeEx(strokeMapping, ink.InkPresenter.StrokeContainer, ink.Width, true);
CanvasDevice device = CanvasDevice.GetSharedDevice();
//CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, WB_CapturedImage.PixelWidth, WB_CapturedImage.PixelHeight, 96);
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (float)ink.Width, (float)ink.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Color.FromArgb(0, 255, 255, 255));
ds.DrawInk(ink.InkPresenter.StrokeContainer.GetStrokes());
}
StorageFolder savedPics = KnownFolders.PicturesLibrary;
string fileName = DateTime.Now.ToString("yyyyMMddHHmmss") + ".png";
StorageFile file = await savedPics.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Png, 1f);
}
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
//image.SetSource(fileStream);
WriteableBitmap InkImage = new WriteableBitmap(WB_CapturedImage.PixelWidth, WB_CapturedImage.PixelHeight);
await InkImage.SetSourceAsync(fileStream);
imageInk.Source = InkImage;
imageInk.Visibility = Visibility.Visible;
ink.InkPresenter.StrokeContainer.Clear();
ink.Visibility = Visibility.Collapsed;
}
RenderTargetBitmap rtb = new RenderTargetBitmap();
await rtb.RenderAsync(this.imagePanel);
// 提取像素数据
IBuffer buffer = await rtb.GetPixelsAsync();
// 获取文件流
IRandomAccessStream streamOut = await file.OpenAsync(FileAccessMode.ReadWrite);
// 实例化编码器
BitmapEncoder pngEncoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, streamOut);
//重写writeablebitmap
WB_CapturedImage = new WriteableBitmap((int)rtb.PixelWidth, (int)rtb.PixelHeight);
// 写入像素数据
byte[] data = buffer.ToArray();
pngEncoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
(uint)rtb.PixelWidth,
(uint)rtb.PixelHeight,
96d, 96d, data);
await pngEncoder.FlushAsync();
streamOut.Dispose();
ink.Visibility = Visibility.Visible;
imageInk.Visibility = Visibility.Collapsed;
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
await WB_CapturedImage.SetSourceAsync(fileStream);
image.Source = WB_CapturedImage;
}
//var bmp = new RenderTargetBitmap();
//await bmp.RenderAsync(ink);
//StorageFolder savedPics = KnownFolders.PicturesLibrary;
//string fileName = DateTime.Now.ToString("yyyyMMddHHmmss") + ".png";
//StorageFile file = await savedPics.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
//// Saving to file.
//using (var stream = await file.OpenStreamForWriteAsync())
//{
// // Initialization.
// var pixelBuffer = await bmp.GetPixelsAsync();
// var logicalDpi = DisplayInformation.GetForCurrentView().LogicalDpi;
// // convert stream to IRandomAccessStream
// var randomAccessStream = stream.AsRandomAccessStream();
// // encoding to PNG
// var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, randomAccessStream);
// // Finish saving
// encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)bmp.PixelWidth,
// (uint)bmp.PixelHeight, logicalDpi, logicalDpi, pixelBuffer.ToArray());
// // Flush encoder.
// await encoder.FlushAsync();
// filePath = file.Path;
//}
}
//check
public static async Task saveInk(bool isfront)
{
Card selected = CardPage.selected;
if (selected != null)
{
StorageFolder deckfolder = await ApplicationData.Current.LocalFolder.GetFolderAsync(App.viewModel.selectedDeck.Id);
StorageFolder cardFolder = await deckfolder.GetFolderAsync(selected.Name);
if (isfront)
{
IReadOnlyList <InkStroke> currentStrokes = FrontInk.InkPresenter.StrokeContainer.GetStrokes();
if (currentStrokes.Count > 0)
{
try
{
StorageFile data = await cardFolder.CreateFileAsync("Front" + selected.Name + ".gif", CreationCollisionOption.ReplaceExisting);
StorageFile imageNew = await cardFolder.CreateFileAsync("Front" + selected.Name + ".jpeg", CreationCollisionOption.ReplaceExisting);
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)FrontInk.ActualWidth, (int)FrontInk.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(selected.Background);
ds.DrawInk(currentStrokes);
}
using (var fileStream = await imageNew.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Jpeg, 1f);
await fileStream.FlushAsync();
fileStream.Dispose();
}
selected.Front = imageNew.Path;
App.viewModel.updateCard(selected);
IRandomAccessStream stream = await data.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outputStream = stream.GetOutputStreamAt(0))
{
await FrontInk.InkPresenter.StrokeContainer.SaveAsync(outputStream);
await outputStream.FlushAsync();
}
stream.Dispose();
}
catch (FileLoadException fex)
{
await saveInk(true);
}
}
else if (currentStrokes.Count < 1)
{
selected.Front = "Assets/empty.png";
try
{
StorageFile data = await cardFolder.GetFileAsync("Front" + selected.Name + ".gif");
if (data != null)
{
await data.DeleteAsync();
}
else if (data == null)
{
return;
}
}
catch (FileNotFoundException e)
{
return;
}
}
}
else if (!isfront)
{
IReadOnlyList <InkStroke> currentStrokes = BackInk.InkPresenter.StrokeContainer.GetStrokes();
if (currentStrokes.Count > 0)
{
try
{
StorageFile data = await cardFolder.CreateFileAsync("Back" + selected.Name + ".gif", CreationCollisionOption.ReplaceExisting);
StorageFile imageNew = await cardFolder.CreateFileAsync("Back" + selected.Name + ".jpeg", CreationCollisionOption.ReplaceExisting);
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)BackInk.ActualWidth, (int)BackInk.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(selected.Background);
ds.DrawInk(currentStrokes);
}
using (var fileStream = await imageNew.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Jpeg, 1f);
await fileStream.FlushAsync();
fileStream.Dispose();
}
selected.Back = imageNew.Path;
App.viewModel.updateCard(selected);
IRandomAccessStream stream = await data.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outputStream = stream.GetOutputStreamAt(0))
{
await BackInk.InkPresenter.StrokeContainer.SaveAsync(outputStream);
await outputStream.FlushAsync();
}
stream.Dispose();
}
catch (FileLoadException fex)
{
await saveInk(false);
}
}
else if (currentStrokes.Count < 1)
{
selected.Back = "Assets/empty.png";
try
{
StorageFile data = await cardFolder.GetFileAsync("Back" + selected.Name + ".gif");
if (data != null)
{
await data.DeleteAsync();
}
else if (data == null)
{
return;
}
}
catch (FileNotFoundException e)
{
return;
}
}
}
}
}
private ICanvasImage CreateShadow()
{
var renderTarget = new CanvasRenderTarget(canvas, 360, 150);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Color.FromArgb(0, 0, 0, 0));
ds.DrawText("This text is drawn onto a rendertarget", 10, 10, Colors.White);
ds.DrawText("with a different color per line,", 10, 40, Colors.Red);
ds.DrawText("after which a drop shadow is", 10, 70, Colors.Green);
ds.DrawText("generated using image effects.", 10, 100, Colors.Blue);
}
var shadowEffect = new Transform2DEffect
{
Source = new ShadowEffect
{
Source = renderTarget,
BlurAmount = 2
},
TransformMatrix = Matrix3x2.CreateTranslation(3, 3)
};
var whiteBackground = new CropEffect
{
Source = new ColorSourceEffect { Color = Colors.White },
SourceRectangle = renderTarget.Bounds
};
var compositeEffect = new CompositeEffect
{
Sources = { whiteBackground, shadowEffect, renderTarget }
};
animationFunction = elapsedTime => { };
currentEffectSize = renderTarget.Size.ToVector2();
return compositeEffect;
}
private void DrawElevation(CanvasDrawingSession drawingSession, Size size, Rect destinationRelative)
{
if (trackpoints == null)
{
return;
}
var foreground = new CanvasSolidColorBrush(drawingSession, Colors.Green);
var absoluteDestination = GetAbsoluteDestinationRect(size, destinationRelative);
var renderTarget = new CanvasRenderTarget(drawingSession, (float)absoluteDestination.Width, (float)absoluteDestination.Height);
_elevationTransform = GetTransformationMatrix(size, destinationRelative);
_elevationPoints = GetPolyLinePointsRelative(tp => tp.Coordinate.Elevation, true);
using (var ds = renderTarget.CreateDrawingSession())
{
var elevationRenderTargetTransform = _elevationTransform * Matrix3x2.CreateTranslation((float)(-destinationRelative.Left * size.Width), (float)(-destinationRelative.Top * size.Height));
var gradientStops = new List <CanvasGradientStop>();
var minInclination = _elevationPoints.Keys.Min(tp => tp.Inclination);
var maxInclination = _elevationPoints.Keys.Max(tp => tp.Inclination);
var positions = new List <Vector2>();
var pathBuilder = new CanvasPathBuilder(drawingSession);
bool first = true;
foreach (var point in _elevationPoints)
{
var position = point.Value;
if (first)
{
pathBuilder.BeginFigure(position);
first = false;
}
else
{
pathBuilder.AddLine(position);
}
var mu = (point.Key.Inclination - minInclination) / (maxInclination - minInclination);
var color = GenerateColor(1, 1, 1, 4, 2, 1, 128, 127, mu * 2);
gradientStops.Add(new CanvasGradientStop {
Color = color, Position = position.X
});
}
pathBuilder.AddLine(new Vector2(1, 1));
pathBuilder.AddLine(new Vector2(0, 1));
pathBuilder.EndFigure(CanvasFigureLoop.Closed);
var geometry = CanvasGeometry.CreatePath(pathBuilder);
var brush = new CanvasLinearGradientBrush(ds, gradientStops.ToArray(), CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Straight)
{
StartPoint = new Vector2((float)0, 0),
EndPoint = new Vector2((float)1, 0),
};
ds.Transform = elevationRenderTargetTransform;
ds.FillGeometry(geometry, brush);
ds.Transform = Matrix3x2.Identity;
}
var sharpen = new ConvolveMatrixEffect()
{
Source = renderTarget,
KernelMatrix = new float[] { -1, -1, -1, -1, 9, -1, -1, -1, -1 },
};
//drawingSession.DrawImage(sharpen, (float)absoluteDestination.X, (float)absoluteDestination.Y);
drawingSession.DrawImage(renderTarget, (float)absoluteDestination.X, (float)absoluteDestination.Y);
}
