void OnInkPresenterStrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
var points = args.Strokes.First()
.GetInkPoints()
.Select(point => new Point(point.Position.X, point.Position.Y))
.ToList();
var elementPoints = Element.Points;
elementPoints.Clear();
foreach (var point in points)
{
elementPoints.Add(point);
}
if (elementPoints.Count > 0)
{
if (Element.DrawingCompletedCommand?.CanExecute(null) ?? false)
{
Element.DrawingCompletedCommand.Execute(elementPoints);
}
}
if (Element.ClearOnFinish)
{
Clear();
}
}
private void DrawingCanvas_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
System.Collections.Generic.IReadOnlyList <InkStroke> strokes = sender.StrokeContainer.GetStrokes();
StrokeSampleBuilder sampleBuilder = new StrokeSampleBuilder((uint)strokes.Count);
foreach (InkStroke stroke in strokes)
{
System.Collections.Generic.IReadOnlyList <InkPoint> points = stroke.GetInkPoints();
StrokeBuilder strokeBuilder = new StrokeBuilder((uint)points.Count);
foreach (InkPoint point in points)
{
strokeBuilder.AddPoint(point.Position.X, point.Position.Y);
}
sampleBuilder.AddStroke(strokeBuilder.build());
}
StrokeSample sample = sampleBuilder.build();
Scores scores = classifier.classify(sample);
ResultsList.Items.Clear();
foreach (Score score in scores)
{
ResultsList.Items.Add(new SymbolListItem(score.Symbol, score.Value));
}
}
private async void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
Rect viewBounds = ApplicationView.GetForCurrentView().VisibleBounds;
Rect inkBounds = args.Strokes[0].BoundingRect;
ApplicationData.Current.LocalSettings.Values["X"] = viewBounds.X + inkBounds.Left;
ApplicationData.Current.LocalSettings.Values["Y"] = viewBounds.Y + inkBounds.Top;
ApplicationData.Current.LocalSettings.Values["Width"] = Window.Current.Bounds.Width;
ApplicationData.Current.LocalSettings.Values["Height"] = Window.Current.Bounds.Height;
var inkPoints = args.Strokes[0].GetInkPoints();
var rawPoints = new double[inkPoints.Count * 2];
for (int i = 0; i < inkPoints.Count; i++)
{
rawPoints[2 * i] = inkPoints[i].Position.X - inkBounds.Left;
rawPoints[2 * i + 1] = inkPoints[i].Position.Y - inkBounds.Top;
}
SavePointsToSettings(rawPoints);
if (ApiInformation.IsApiContractPresent("Windows.ApplicationModel.FullTrustAppContract", 1, 0))
{
await FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync();
}
await Task.Delay(1000);
sender.StrokeContainer.Clear();
}
private void OnStrokeCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
var list = _inkSynchronizer.BeginDry();
StrokeCollected?.Invoke(this, list);
_inkSynchronizer.EndDry();
}
private async void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
try
{
IReadOnlyList <InkStroke> currentStrokes = Gana.InkPresenter.StrokeContainer.GetStrokes();
if (currentStrokes.Count > 0)
{
var recognitionResults = await inkRecognizerContainer.RecognizeAsync(Gana.InkPresenter.StrokeContainer, InkRecognitionTarget.All);
if (recognitionResults.Count > 0)
{
// Display recognition result
string str = "";
foreach (var r in recognitionResults)
{
str += r.GetTextCandidates()[0];
}
CheckCharacter(str, false, currentStrokes.Count);
}
}
}catch (Exception)
{
Gana.InkPresenter.StrokeContainer.Clear();
}
}
void OnStrokesCollected(object sender, InkStrokesCollectedEventArgs args)
{
if (LineDrawn != null)
{
LineDrawn(this, EventArgs.Empty);
}
}
async void OnStrokesCollected(
InkPresenter sender,
InkStrokesCollectedEventArgs args)
{
// create the ink recognizer if we haven't done already.
if (this.inkRecognizer == null)
{
this.inkRecognizer = new InkRecognizerContainer();
}
// recognise the ink which has not already been recognised
// (i.e. do incremental ink recognition).
var results = await this.inkRecognizer.RecognizeAsync(
sender.StrokeContainer,
InkRecognitionTarget.Recent);
// update the container so that it knows next time that this
// ink is already recognised.
sender.StrokeContainer.UpdateRecognitionResults(results);
// we take all the top results that the recogniser gives us
// back.
var newTags = results.Select(
result => result.GetTextCandidates().FirstOrDefault());
// add the new tags to our photo.
await this.photoControl.AddTagsToPhotoAsync(this.currentPhotoId, newTags);
}
//SaveNecessity
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
AddStrokeOperation addStrokeOperation = new AddStrokeOperation(args.Strokes.Last());
ViewModel.UndoRedoBase.AddOperationToUndoneOperations(addStrokeOperation);
SaveNecessity = true;
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
var strokes = _synch.BeginDry();
RenderStrokes(strokes);
_synch.EndDry();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
//Add back to undoAvailable but only if its less than MaxUndos
if (undosAvailable < maxUndo)
{
undosAvailable += 1;
}
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
foreach (var item in args.Strokes)
{
_redoList.Add(item);
}
_undoCommand?.RaiseCanExecuteChanged();
_redoCommand?.RaiseCanExecuteChanged();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
foreach (var s in args.Strokes)
{
_inkManager.AddStroke(s);
}
//_canvasOne.DrawLine(args.Strokes);
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
Job j = DataContext as Job;
if (j != null)
{
IReadOnlyList <InkStroke> strokes = Annotation.InkPresenter.StrokeContainer.GetStrokes();
j.Strokes = strokes.ToList();
}
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
strokeList.AddRange(args.Strokes);
foreach (var s in args.Strokes)
{
inkManager.AddStroke(s);
}
canvasControl.Invalidate();
}
private void InkPresenterOnStrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
foreach (var stroke in args.Strokes)
{
var strokeId = Guid.NewGuid();
idToStrokeMapping[strokeId] = stroke;
strokeChangeBroker.SendStrokeCollected(strokeId, stroke);
}
}
private async void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
try
{
InputReady?.Invoke(this, await MnistHelper.GetHandWrittenImageAsync(inkGrid));
}
catch (Exception ex)
{
PageService?.ShowNotification(ex.Message);
}
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
foreach (var item in args.Strokes)
{
_redoList.Add(item);
}
_undoList.Clear();
_undoCommand?.OnCanExecuteChanged();
_redoCommand?.OnCanExecuteChanged();
StrokesChanged?.Invoke(sender, EventArgs.Empty);
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs e)
{
IReadOnlyList <InkStroke> strokes = e.Strokes;
string log = $"Strokes collected: {strokes.Count}";
foreach (InkStroke stroke in strokes)
{
log += $"\nId: {stroke.Id}, StartedTime: {stroke.StrokeStartedTime}, Duration: {stroke.StrokeDuration}";
}
rootPage.NotifyUser(log, NotifyType.StatusMessage);
}
private async void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
lastModifiedTime = DateTime.Now;
await Task.Delay(2000);
if (DateTime.Now - lastModifiedTime > new TimeSpan(0, 0, 2))
{
//save only if more than 2 secs from last modification
await SaveCalendarInk();
}
}
//Detects when the writing strokes are finished
private void inkCanvas_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
timer.Stop();
foreach (var stroke in args.Strokes)
{
analyzerText.AddDataForStroke(stroke);
analyzerText.SetStrokeDataKind(stroke.Id, InkAnalysisStrokeKind.Writing);
}
timer.Start();
}
void OnStrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
// We tell the framework that we are ready to begin 'drying'.
// Keep track of the strokes that need to be dried.
this.wetInkStrokes = this.inkSync.BeginDry();
// Ensure that our over-all collection of strokes is up to date.
this.allInkStrokes.AddStrokes(args.Strokes);
// Cause our control to repaint itself...
this.canvasControl.Invalidate();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
foreach (var s in args.Strokes)
{
inkManager.AddStroke(s);
}
Debug.Assert(pendingDry == null);
pendingDry = inkSynchronizer.BeginDry();
canvasControl.Invalidate();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
this.pendingDry = this.inkSynchronizer.BeginDry();
var container = new InkStrokeContainer();
foreach (var stroke in this.pendingDry)
{
container.AddStroke(stroke.Clone());
}
this.strokes.Add(container);
canvas.Invalidate();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
var strokes = _inkSynchronizer.BeginDry();
var container = new InkStrokeContainer();
container.AddStrokes(from item in strokes
select item.Clone());
_inkStrokes.Add(container);
history.Push(_inkStrokes);
_inkSynchronizer.EndDry();
DrawingCanvas.Invalidate();
}
/// <summary>
/// Render XAML and Ink to preview image
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
var renderTargetBitmap = await generateBackground();
var renderedImageSource = await _inkBitmapRenderer.RenderToImageSourceAsync(
renderTargetBitmap,
_inkPresenter.StrokeContainer.GetStrokes(),
_highlightStrokes.GetStrokes(),
AnnotationInkCanvas.ActualWidth,
AnnotationInkCanvas.ActualHeight
);
TargetImage.Source = renderedImageSource;
}
private async void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)inkDataCanvas.ActualWidth, (int)inkDataCanvas.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.Black);
ds.DrawInk(inkDataCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
using (var ms = new InMemoryRandomAccessStream())
{
await renderTarget.SaveAsync(ms, CanvasBitmapFileFormat.Jpeg, 1);
await ms.FlushAsync();
var decoder = await BitmapDecoder.CreateAsync(ms);
var img = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, ms);
encoder.BitmapTransform.ScaledHeight = (uint)ViewModelLocator.Instance.Main.ImageSize;
encoder.BitmapTransform.ScaledWidth = (uint)ViewModelLocator.Instance.Main.ImageSize;
encoder.SetSoftwareBitmap(img);
await encoder.FlushAsync();
decoder = await BitmapDecoder.CreateAsync(ms);
img = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
img = SoftwareBitmap.Convert(img, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
var sbs = new SoftwareBitmapSource();
await sbs.SetBitmapAsync(img);
inkImage.Source = sbs;
//var targetImage = new SoftwareBitmap(BitmapPixelFormat.Bgra8, img.PixelWidth, img.PixelHeight);
// img.CopyTo(targetImage);
ViewModelLocator.Instance.Main.CurrentInkImage = ms.CloneStream();
ms.Dispose();
}
}
void OnInkPresenterStrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs e)
{
Element.Lines.CollectionChanged -= OnCollectionChanged;
if (e.Strokes.Count > 0)
{
if (!Element.MultiLineMode)
{
Element.Lines.Clear();
}
var lines = Element.MultiLineMode ? e.Strokes : new List <InkStroke>()
{
e.Strokes.First()
};
foreach (var line in lines)
{
var points = line.GetInkPoints().Select(point => new Point(point.Position.X, point.Position.Y));
Element.Lines.Add(new Line()
{
Points = new ObservableCollection <Point>(points),
LineColor = Color.FromRgba(line.DrawingAttributes.Color.R, line.DrawingAttributes.Color.G,
line.DrawingAttributes.Color.B, line.DrawingAttributes.Color.A),
LineWidth = (float)line.DrawingAttributes.Size.Width
});
}
if (Element.Lines.Count > 0)
{
var lastLine = Element.Lines.Last();
Element.OnDrawingLineCompleted(lastLine);
}
if (Element.ClearOnFinish)
{
Element.Lines.CollectionChanged -= OnCollectionChanged;
Clear(true);
Element.Lines.CollectionChanged += OnCollectionChanged;
}
}
Element.Lines.CollectionChanged += OnCollectionChanged;
}
//Detects when the writing strokes are finished
private void inkCanvas_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
timer.Stop();
for (int i = 0; i < inkCanvas.Length; i++)
{
if (inkCanvas[i].InkPresenter == sender)
{
currentCanvasNumber = i;
}
}
foreach (var stroke in args.Strokes)
{
analyzerText.AddDataForStroke(stroke);
analyzerText.SetStrokeDataKind(stroke.Id, InkAnalysisStrokeKind.Writing);
}
timer.Start();
}
private void StrokeInput_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
if (this.IsSkritter == true)
{
var strokes = this.WritingInkCanvas.InkPresenter.StrokeContainer.GetStrokes();
SketchStroke lastStroke = new SketchStroke(strokes[strokes.Count - 1], this.timeCollection[this.timeCollection.Count - 1]);
if (SkritterHelpers.ValidateStroke(lastStroke, this.currentTemplateSketchStrokes[this.sketchStrokes.Count]) == true)
{
this.sketchStrokes.Add(lastStroke);
InteractionTools.ShowStroke(this.AnimationCanvas, this.currentTemplateSketchStrokes[this.sketchStrokes.Count - 1]);
}
else
{
this.timeCollection.RemoveAt(this.timeCollection.Count - 1);
}
strokes[strokes.Count - 1].Selected = true;
this.WritingInkCanvas.InkPresenter.StrokeContainer.DeleteSelected();
}
}
private async void InkPresenter_StrokesCollectedAsync(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
var bitmap = Inker.GetCropedSoftwareBitmap(newWidth: 227, newHeight: 227, keepRelativeSize: true);
var frame = VideoFrame.CreateWithSoftwareBitmap(bitmap);
var input = new ModelInput()
{
data = frame
};
var output = await model.EvaluateAsync(input);
var guessedTag = output.classLabel.First();
var guessedPercentage = output.loss.OrderByDescending(kv => kv.Value).First().Value;
if (guessedPercentage < 0.9)
{
SubText.Text = $"draw {currentShape} to snooze - don't know what that is";
}
else if (guessedTag != currentShape)
{
SubText.Text = $"draw {currentShape} to snooze - you drew {guessedTag}";
}
else
{
AlarmOn = false;
foreach (var stroke in Inker.InkPresenter.StrokeContainer.GetStrokes())
{
var attributes = stroke.DrawingAttributes;
attributes.PencilProperties.Opacity = 1;
attributes.Color = Colors.DarkBlue;
attributes.Size = new Size(60, 60);
stroke.DrawingAttributes = attributes;
stroke.PointTransform = Matrix3x2.CreateScale(2, new Vector2((float)ActualWidth / 2, (float)ActualHeight / 2));
}
}
Debug.WriteLine($"Current guess: {guessedTag}({guessedPercentage})");
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
timer.Start();
}
/// <summary>
/// Start countdown timer once the user has finished inking
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void InkCanvas_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
pointerTimer.Stop();
recognitionTimer.Start();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
try
{
((App)App.Current).SyncStrokeEx(strokeMapping, ink.InkPresenter.StrokeContainer, ink.Width);
}
catch (Exception e)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine(e.Message);
#endif
}
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
saved = false;
}
private async void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
// Notify user about the risk when using inking for the first time.
if ((bool)App.AppSettings[App.INKING_WARNING])
{
int userResponse = await App.NotifyUserWithOptions(Messages.INK_STROKE_WARNING,
new string[] { "OK, do not show this again.", "Notify me again next time." });
switch (userResponse)
{
case 0: // Do not show again
ApplicationData.Current.RoamingSettings.Values[App.INKING_WARNING] = false;
App.AppSettings[App.INKING_WARNING] = false;
break;
default:
App.AppSettings[App.INKING_WARNING] = false;
break;
}
}
int p = findPageNumberByInkPresenter(sender);
await inkManager.addStrokes(p, sender.StrokeContainer, args.Strokes);
}
async void OnStrokesCollected(
InkPresenter sender,
InkStrokesCollectedEventArgs args)
{
// create the ink recognizer if we haven't done already.
if (this.inkRecognizer == null)
{
this.inkRecognizer = new InkRecognizerContainer();
}
// recognise the ink which has not already been recognised
// (i.e. do incremental ink recognition).
var results = await this.inkRecognizer.RecognizeAsync(
sender.StrokeContainer,
InkRecognitionTarget.Recent);
// update the container so that it knows next time that this
// ink is already recognised.
sender.StrokeContainer.UpdateRecognitionResults(results);
// we take all the top results that the recogniser gives us
// back.
var newTags = results.Select(
result => result.GetTextCandidates().FirstOrDefault());
// add the new tags to our photo.
await this.photoControl.AddTagsToPhotoAsync(this.currentPhotoId, newTags);
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
strokeList.AddRange(args.Strokes);
foreach (var s in args.Strokes)
{
inkManager.AddStroke(s);
}
canvasControl.Invalidate();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
rootPage.NotifyUser(args.Strokes.Count + " stroke(s) collected!", NotifyType.StatusMessage);
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
System.Diagnostics.Debug.WriteLine("InkPresenter_StrokesCollected");
timer.Start();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
SendInk();
}
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
foreach (var s in args.Strokes)
{
inkManager.AddStroke(s);
}
Debug.Assert(pendingDry == null);
pendingDry = inkSynchronizer.BeginDry();
canvasControl.Invalidate();
}
/* Event Handlers */
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
RecogniseText();
}
