public override void OnMouseMove(InkCanvas inkCanvas, System.Windows.Input.MouseEventArgs e) { if (e.LeftButton == MouseButtonState.Pressed) { endPoint = e.GetPosition(inkCanvas); if(startPoint != endPoint) { StylusPointCollection pts = new StylusPointCollection(); GetLine(pts, (s) => { if (StrokeResult != null) inkCanvas.Strokes.Remove(StrokeResult); DrawingAttributes drawingAttributes = new DrawingAttributes { Color = inkCanvas.DefaultDrawingAttributes.Color, Width = inkCanvas.DefaultDrawingAttributes.Width, StylusTip = StylusTip.Ellipse, IgnorePressure = true, FitToCurve = true }; StrokeResult = new LineStroke(s, drawingAttributes); inkCanvas.Strokes.Add(StrokeResult); } ); } } }
/// <summary> /// Adds a StylusPacket representing an incremental move of the hit-testing tool /// </summary> /// <param name="stylusPoints">stylusPoints</param> public void AddPoints(StylusPointCollection stylusPoints) { if (stylusPoints == null) { throw new System.ArgumentNullException("stylusPoints"); } if (stylusPoints.Count == 0) { throw new System.ArgumentException(SR.Get(SRID.EmptyArrayNotAllowedAsArgument), "stylusPoints"); } if (false == _fValid) { throw new System.InvalidOperationException(SR.Get(SRID.EndHitTestingCalled)); } System.Diagnostics.Debug.Assert(_strokes != null); Point[] points = new Point[stylusPoints.Count]; for (int x = 0; x < stylusPoints.Count; x++) { points[x] = (Point)stylusPoints[x]; } AddPointsCore(points); }
public CustomStroke(StylusPointCollection col, Color strokeColor, int thickness, Color fill) : base(col) { this.strokeColor = strokeColor; this.thickness = thickness; this.fillColor = fill; }
public static string Classify(bool useRubine, float duration, bool righthandedness, List<float> SpeakerAngles, PointCollection pointHist, StylusPointCollection S, List<List<int>> hist, List<List<int>> ihist) { // Convert all parameters to format used in GestureTests List<Vector2> InterpretedPoints = new List<Vector2>(); List<Vector2> StylusPoints = new List<Vector2>(); List<Vector2> VelocityHistory = new List<Vector2>(); List<Vector2> InverseVelocityHistory = new List<Vector2>(); foreach(Point P in pointHist) InterpretedPoints.Add(new Vector2((float)P.X,(float)P.Y)); foreach(StylusPoint P in S) StylusPoints.Add(new Vector2((float)P.X,(float)P.Y)); for (int i = 0; i < hist[0].Count; i++) { VelocityHistory.Add(new Vector2(hist[0][i], hist[1][i])); InverseVelocityHistory.Add(new Vector2(ihist[0][i], ihist[1][i])); } // Create a new Sample, compute the features, and classify GS = new GestureSample(GestureTests.Types.GestureType.unknown, righthandedness,duration,SpeakerAngles,InterpretedPoints,StylusPoints,VelocityHistory,InverseVelocityHistory); GS.ComputeFeatures(GestureFeatures.PointsStroke); if (useRubine) return EC.Recognizer.Classify(GS).ToString(); WriteARFF(); Instances test = new Instances(new java.io.FileReader("outfile.arff")); test.setClassIndex(0); double clsLabel = cls.classifyInstance(test.instance(0)); test.instance(0).setClassValue(clsLabel); // Return the appropriate label return ((GestureType2D)((int)clsLabel+1)).ToString(); }
public Stroke Representation() { StylusPointCollection collection = new StylusPointCollection(); foreach (var data in stylusPoints) collection.Add(data.Representation()); return new Stroke(collection); }
private void addNextPDF() { PdfPage page = new PdfPage(); page.Size = PageSize.A4; double h = SystemParameters.PrimaryScreenHeight; double w = SystemParameters.PrimaryScreenWidth; //XPdfFontOptions options = new XPdfFontOptions(PdfFontEncoding.Unicode, PdfFontEmbedding.Always); var rateW = page.Width / w; var rateH = page.Height / h; var strokes = CanvasStroke.ToList(); List<Point[]> pl = new List<Point[]>(); foreach (Stroke stroke in strokes) { StylusPointCollection points = stroke.StylusPoints; StylusPointCollection newPoints = new StylusPointCollection(); var pointList = points.ToList(); foreach (StylusPoint pt in pointList) { StylusPoint newPt = new StylusPoint(pt.X * rateW, pt.Y * rateH); newPoints.Add(newPt); } Point[] p = (Point[])newPoints; pList.Add(p); pl.Add(p); CanvasStroke.Remove(stroke); } pointL.Add(pl); }
public static WindowsInk.Stroke ToWindowsStroke(NineInk.Stroke nineStroke) { var points = new StylusPointCollection(); foreach (var point in nineStroke.Points) points.Add(new StylusPoint(point.X, point.Y, point.Pressure)); var drwAttr = new WindowsInk.DrawingAttributes(); var c = new Color(); c.R = nineStroke.DrawingAttributes.Color.R; c.G = nineStroke.DrawingAttributes.Color.G; c.B = nineStroke.DrawingAttributes.Color.B; c.A = nineStroke.DrawingAttributes.Color.A; drwAttr.Color = c; switch (nineStroke.DrawingAttributes.Brush.Name) { case "Rectangle": drwAttr.StylusTip = WindowsInk.StylusTip.Rectangle; break; case "Ellipse": default: drwAttr.StylusTip = WindowsInk.StylusTip.Ellipse; break; } drwAttr.Height = nineStroke.DrawingAttributes.Height; drwAttr.Width = nineStroke.DrawingAttributes.Width; drwAttr.IsHighlighter = nineStroke.DrawingAttributes.IsHighlighter; return new WindowsInk.Stroke(points, drwAttr); }
//Метод, который отвечает за зеркальное отражение, как по-вертикали, так и по-горизонтали public void MirrorReflection(object sender, EventArgs e) { double val; bool horizontally = false; if ((sender as MenuItem).Name == "horizontal") { val = surface.ActualHeight; horizontally = true; } else { val = surface.ActualWidth; } for (int i = 0; i < surface.Strokes.Count; i++) { DrawingAttributes dr = surface.Strokes[i].DrawingAttributes; StylusPointCollection newPoints = new StylusPointCollection(); for (int j = 0; j < surface.Strokes[i].StylusPoints.Count; j++) { StylusPoint p = surface.Strokes[i].StylusPoints[j]; if (horizontally) { p.Y = val - p.Y; } else { p.X = val - p.X; } newPoints.Add(p); } surface.Strokes[i].StylusPoints = newPoints; } }
public bool HitTest (StylusPointCollection stylusPointCollection) { if (stylusPointCollection == null) throw new ArgumentException ("stylusPointCollection"); return NativeMethods.stroke_hit_test (native, stylusPointCollection.native); }
public override void OnMouseMove(System.Windows.Controls.InkCanvas inkCanvas, System.Windows.Input.MouseEventArgs e) { if (e.LeftButton == MouseButtonState.Pressed) { bottomRight = e.GetPosition(inkCanvas); if(topLeft != bottomRight) { StylusPointCollection pts = new StylusPointCollection(); GetRectangle(pts, (s) => { if (StrokeResult != null) inkCanvas.Strokes.Remove(StrokeResult); DrawingAttributes drawingAttributes = new DrawingAttributes { Color = inkCanvas.DefaultDrawingAttributes.Color, Width = inkCanvas.DefaultDrawingAttributes.Width, StylusTip = StylusTip.Ellipse, IgnorePressure = true, FitToCurve = true }; var BackgroundColor = inkCanvas.DefaultDrawingAttributes.GetPropertyData(DrawAttributesGuid.BackgroundColor); drawingAttributes.AddPropertyData(DrawAttributesGuid.BackgroundColor, BackgroundColor); StrokeResult = new RectangleStroke(s, drawingAttributes); inkCanvas.Strokes.Add(StrokeResult); } ); } } }
void GetRectangle(StylusPointCollection pts, Action<StylusPointCollection> exec) { pts.Add(new StylusPoint(topLeft.X, topLeft.Y)); pts.Add(new StylusPoint(bottomRight.X, bottomRight.Y)); exec(pts); }
public customStroke(StylusPointCollection pts,PaintingCanvas ink) : base(pts) { this.StylusPoints = pts; this.color = ink.colorName; this.size = ink.penSize; }
//A new stroke object named MyStroke is created. MyStroke is added to the StrokeCollection of the InkPresenter named MyIP private void MyIP_MouseLeftButtonDown(object sender, MouseEventArgs e) { MyIP.CaptureMouse(); if (eraseflag == true) { StylusPointCollection MyStylusPointCollection = new StylusPointCollection(); MyStylusPointCollection.Add(e.StylusDevice.GetStylusPoints(MyIP)); NewStroke = new Stroke(MyStylusPointCollection); NewStroke.DrawingAttributes.Color = Colors.Red; MyIP.Strokes.Add(NewStroke); StylusPointCollection ErasePointCollection = new StylusPointCollection(); } else { StylusPointCollection pointErasePoints = e.StylusDevice.GetStylusPoints(MyIP); StrokeCollection hitStrokes = MyIP.Strokes.HitTest(pointErasePoints); if (hitStrokes.Count > 0) { foreach (Stroke hitStroke in hitStrokes) { MyIP.Strokes.Remove(hitStroke); //undoStack.Push(hitStroke); //undoStateBufferStack.Push(true); } } } }
public TouchPoint2(TouchInfo info, UIElement source, StylusPointCollection stylusPoints) { this.Source = source; Stroke = new Stroke(stylusPoints); TouchDeviceId = info.TouchDeviceId; StartTime = DateTime.Now; UpdateTouchInfo(info); }
public static void up(MouseButtonEventArgs e, InkPresenter inkCanvas, Grid LayoutRoot) { int clickedLayer = Common.hitTestLayer(e, inkCanvas); StylusPointCollection spc = new StylusPointCollection(); checkIfStrokeSelected(e, inkCanvas, spc); checkIfLayerSelected(LayoutRoot, clickedLayer); }
private static void checkIfStrokeSelected(MouseButtonEventArgs e, InkPresenter inkCanvas, StylusPointCollection spc) { spc.Add(new StylusPoint(e.GetPosition(inkCanvas).X, e.GetPosition(inkCanvas).Y)); if (inkCanvas.Strokes.HitTest(spc).Count > 0) { removeSelectedStroke(inkCanvas, spc); } return; }
private bool IsEnclosedAreaWithinRange(StylusPointCollection stylusPointCollection) { // TODO: Move the magic number to configuration Point[] points = stylusPointCollection.ToFilteredPoints(5); double area = ConvexHullArea.GetArea(points); if (area >= _data.Min && area <= _data.Max) return true; else return false; }
private void myInkPresenter_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { //捕获鼠标焦点 myInkPresenter.CaptureMouse(); myPointCollection = new StylusPointCollection(); myPointCollection.Add(e.StylusDevice.GetStylusPoints(myInkPresenter)); currentStroke = new Stroke(myPointCollection); //设置画笔属性 currentStroke.DrawingAttributes.Color = currentColor; currentStroke.DrawingAttributes.Height = sliderThickness.Value; currentStroke.DrawingAttributes.Width = sliderThickness.Value; myInkPresenter.Strokes.Add(currentStroke); }
/// <summary> /// Construct bezier control points from points /// </summary> /// <param name="stylusPoints">Original StylusPointCollection</param> /// <param name="fitError">Fitting error</param> /// <returns>Whether the algorithm succeeded</returns> internal bool ConstructBezierState(StylusPointCollection stylusPoints, double fitError) { // If the point count is zero, the curve cannot be constructed if ((null == stylusPoints) || (stylusPoints.Count == 0)) return false; // Compile list of distinct points and their nodes CuspData dat = new CuspData(); dat.Analyze(stylusPoints, fitError /*typically zero*/); return ConstructFromData(dat, fitError); }
public void Deserialize(XmlNode xmlNode, FlowDocument flowDocument) { var inkCanvas = new InkCanvasEx(); foreach (XmlNode strokeNode in xmlNode.ChildNodes) { var points = new StylusPointCollection(); foreach (XmlNode pointNode in strokeNode.ChildNodes) { points.Add(new StylusPoint(Double.Parse(pointNode.Attributes["X"].InnerText), Double.Parse(pointNode.Attributes["Y"].InnerText))); } inkCanvas.Strokes.Add(new Stroke(points)); //TODO DrawingAttributes } flowDocument.Blocks.Add(new DrawerBlock { Child = new DrawerControl { Strokes = inkCanvas.Strokes }}); }
public static void down(MouseButtonEventArgs e, InkPresenter inkCanvas, Grid LayoutRoot) { dragStarted = true; inkCanvas.CaptureMouse(); clickedLayer = Common.hitTestLayer(e, inkCanvas); initialPos = e.GetPosition(inkCanvas); StylusPointCollection spc = new StylusPointCollection(); spc.Add(new StylusPoint(e.GetPosition(inkCanvas).X, e.GetPosition(inkCanvas).Y)); hitCount = inkCanvas.Strokes.HitTest(spc).Count; System.Diagnostics.Debug.WriteLine("layer " + clickedLayer); if (clickedLayer != -1) { //Calculate offset of left, right, top, bottom calculateOffset(e, inkCanvas); //System.Diagnostics.Debug.WriteLine("maxLeft " + MainPage.layerList[clickedLayer].imageToBorderDist[LEFT]); //System.Diagnostics.Debug.WriteLine("offSetLeft " + offSetLeft); //System.Diagnostics.Debug.WriteLine("positionY" + e.GetPosition(inkCanvas).Y); //System.Diagnostics.Debug.WriteLine("maxTop " + MainPage.layerList[clickedLayer].imageToBorderDist[TOP]); //System.Diagnostics.Debug.WriteLine("offSetTop " + offSetTop); //if the clickedLayer's image is out of bound if (clickedLayer != -1 && MainPage.layerList[clickedLayer].imgBackup != null) { replaceMovingImgWithBackupImg(LayoutRoot); } else { //temporarly save image in image backup imageBackup = new WriteableBitmap((BitmapSource)MainPage.layerList[clickedLayer].img.Source); } } //Line clicked if (hitCount > 0) { moveInkToNewInkPresenter(inkCanvas, LayoutRoot, spc); } }
/// <summary> /// Constructs internal data structure from points for doing operations like /// cusp detection or tangent computation /// </summary> /// <param name="stylusPoints">Points to be analyzed</param> /// <param name="rSpan">Distance between two consecutive distinct points</param> internal void Analyze(StylusPointCollection stylusPoints, double rSpan) { // If the count is less than 1, return if ((null == stylusPoints) || (stylusPoints.Count == 0)) return; _points = new List<CDataPoint>(stylusPoints.Count); _nodes = new List<double>(stylusPoints.Count); // Construct the lists of data points and nodes _nodes.Add(0); CDataPoint cdp0 = new CDataPoint(); cdp0.Index = 0; //convert from Avalon to Himetric Point point = (Point)stylusPoints[0]; point.X *= StrokeCollectionSerializer.AvalonToHimetricMultiplier; point.Y *= StrokeCollectionSerializer.AvalonToHimetricMultiplier; cdp0.Point = point; _points.Add(cdp0); //drop duplicates int index = 0; for (int i = 1; i < stylusPoints.Count; i++) { if (!DoubleUtil.AreClose(stylusPoints[i].X, stylusPoints[i - 1].X) || !DoubleUtil.AreClose(stylusPoints[i].Y, stylusPoints[i - 1].Y)) { //this is a unique point, add it index++; CDataPoint cdp = new CDataPoint(); cdp.Index = index; //convert from Avalon to Himetric Point point2 = (Point)stylusPoints[i]; point2.X *= StrokeCollectionSerializer.AvalonToHimetricMultiplier; point2.Y *= StrokeCollectionSerializer.AvalonToHimetricMultiplier; cdp.Point = point2; _points.Insert(index, cdp); _nodes.Insert(index, _nodes[index - 1] + (XY(index) - XY(index - 1)).Length); } } SetLinks(rSpan); }
// This is called on the application thread. protected override void OnStylusUpProcessed(object callbackData, bool targetVerified) { // Check that the element actually receive the OnStylusUp input. if (targetVerified) { StylusPointCollection strokePoints = callbackData as StylusPointCollection; if (strokePoints == null) { return; } // Raise the StrokeRendered event so the consumer of the plugin can // add the filtered stroke to its StrokeCollection. StrokeRenderedEventArgs e = new StrokeRenderedEventArgs(strokePoints); OnStrokeRendered(e); } }
/// <summary> /// Creates a default enumerator for a given stroke /// If using the strokes drawing attributes, pass stroke.DrawingAttributes for the second /// argument. If using an overridden DA, use that instance. /// </summary> internal static StrokeNodeIterator GetIterator(StylusPointCollection stylusPoints, DrawingAttributes drawingAttributes) { if (stylusPoints == null) { throw new System.ArgumentNullException("stylusPoints"); } if (drawingAttributes == null) { throw new System.ArgumentNullException("drawingAttributes"); } StrokeNodeOperations operations = StrokeNodeOperations.CreateInstance(drawingAttributes.StylusShape); bool usePressure = !drawingAttributes.IgnorePressure; return new StrokeNodeIterator(stylusPoints, operations, usePressure); }
private StylusPointCollection SetStylusPointDescription(StylusPointCollection stylusPointCollection) { StylusPointDescription stylusPointDescription; stylusPointDescription = this.StylusPointDescription; StylusPointCollection stylusPointCollection2; stylusPointCollection2 = new StylusPointCollection(stylusPointDescription, stylusPointCollection.Count); if (stylusPointDescription != null) { foreach (var stylusPoint in stylusPointCollection) { var item = new StylusPoint(stylusPoint.X, stylusPoint.Y, stylusPoint.PressureFactor, stylusPointDescription, new int[StylusPointDescription.PropertyCount - 3]); stylusPointCollection2.Add(item); } } return(stylusPointCollection2); }
protected override void OnDraw(DrawingContext drawingContext, StylusPointCollection stylusPoints, Geometry geometry, Brush fillBrush) { var owner = this.Element; var visual = GetContainerVisual(); visual?.Children.Clear(); if (owner is InkCanvas inkCanvas) { // 如果有选中的Stroke 那么不显示 if (inkCanvas.GetSelectedStrokes().Any()) { return; } // 没有选中的 画矩形选择框 drawingContext.DrawRectangle(Pen.Brush, Pen, new Rect(_downPoint, (Point)stylusPoints[stylusPoints.Count - 1])); } }
public void RenderPackets(StylusPointCollectionInfo stylusPointCollectionInfo) { StrokeInfo strokeInfo = stylusPointCollectionInfo.StrokeInfo; InkRenderInfo inkRenderInfo = strokeInfo.InkRenderInfo; foreach (var stylusPoint in stylusPointCollectionInfo.StylusPlugInCollection) { StylusPointCollection stylusPointCollection = inkRenderInfo.StrokeTipBuilder.AddPoint(stylusPoint); if (stylusPointCollection != null) { StrokeVisual strokeVisual = new StrokeVisual(strokeInfo.FillSolidColorBrush, strokeInfo.DrawingAttributes, stylusPointCollection); inkRenderInfo.ContainerVisual.Children.Add(strokeVisual); inkRenderInfo.StrokeVisualList.AddLast(strokeVisual); strokeVisual.Redraw(); } } // inkRenderInfo.StrokeTipBuilder.Redraw(); }
public ShapeStroke(StylusPointCollection pts) : base(pts) { guid = Guid.NewGuid(); name = "This is a stroke"; Point lastPoint = pts[pts.Count - 1].ToPoint(); Coordinates coordinates = new Coordinates(lastPoint.X, lastPoint.Y); shapeStyle = new ShapeStyle(coordinates, 1, 1, 0, "#000000", 0, "#FFFFFF"); while (StylusPoints.Count > 1) { StylusPoints.RemoveAt(0); } linksTo = new List <string>(); linksFrom = new List <string>(); }
private WriteableBitmap GetImageInternal(Size scale, Rect signatureBounds, Size imageSize, float strokeWidth, Color strokeColor, Color backgroundColor) { var presenter = new InkPresenter { Width = imageSize.Width / scale.Width, Height = imageSize.Height / scale.Height, Strokes = new StrokeCollection(), Background = new SolidColorBrush(backgroundColor) }; foreach (var stroke in inkPresenter.Strokes) { Stroke tempStroke; if (signatureBounds.X != 0 || signatureBounds.Y != 0) { var newCollection = new StylusPointCollection(); foreach (var point in stroke.StylusPoints) { var newPoint = new StylusPoint { X = point.X - signatureBounds.X, Y = point.Y - signatureBounds.Y }; newCollection.Add(newPoint); } tempStroke = new Stroke(newCollection); } else { tempStroke = new Stroke(stroke.StylusPoints); } tempStroke.DrawingAttributes.Color = strokeColor; tempStroke.DrawingAttributes.Width = lineWidth; tempStroke.DrawingAttributes.Height = lineWidth; presenter.Strokes.Add(tempStroke); tempStroke = null; } return(new WriteableBitmap(presenter, new ScaleTransform { ScaleX = scale.Width, ScaleY = scale.Height })); }
public void drawLine(int nPenStatus, int x, int y, float nCompress) { Point p = new Point(x, y); if (!pointIsInvalid(nPenStatus, p)) { return; } if (nPenStatus == 0)//离笔 { IsHaveLastPoint = false; startCount = 0; } else { startCount++; if (!IsHaveLastPoint) { stylusPointCollection = new StylusPointCollection(); stylusPointCollection.Add(new StylusPoint(x, y, 0.1f)); Console.WriteLine("draw4:{0},{1},{2}", x, y, nCompress); stroke = new Stroke(stylusPointCollection); stroke.DrawingAttributes = new DrawingAttributes { Width = brushWidth, Height = brushWidth, Color = Color.FromRgb(0, 0, 0) }; IsHaveLastPoint = true; ic.Strokes.Add(stroke); } else { if (startCount < 3) { stylusPointCollection.Add(new StylusPoint(x, y, 0.1f)); } else { stylusPointCollection.Add(new StylusPoint(x, y, nCompress)); } Console.WriteLine("draw4:{0},{1},{2}", x, y, nCompress); } } }
/// <summary> /// Check whether a certain percentage of the stroke is within the Rect passed in. /// </summary> /// <param name="bounds"></param> /// <param name="percentageWithinBounds"></param> /// <returns></returns> public bool HitTest(Rect bounds, int percentageWithinBounds) { if ((percentageWithinBounds < 0) || (percentageWithinBounds > 100)) { throw new System.ArgumentOutOfRangeException("percentageWithinBounds"); } if (percentageWithinBounds == 0) { return(true); } StrokeInfo strokeInfo = null; try { strokeInfo = new StrokeInfo(this); StylusPointCollection stylusPoints = strokeInfo.StylusPoints; double target = strokeInfo.TotalWeight * percentageWithinBounds / 100.0f - PercentageTolerance; for (int i = 0; i < stylusPoints.Count; i++) { if (true == bounds.Contains((Point)stylusPoints[i])) { target -= strokeInfo.GetPointWeight(i); if (DoubleUtil.LessThanOrClose(target, 0d)) { return(true); } } } return(false); } finally { if (strokeInfo != null) { //detach from event handlers, or else we leak. strokeInfo.Detach(); } } }
//描く処理(ペン用) private void inkCanvas1_StylusMove(object sender, StylusEventArgs e) { //消しゴムモードなら抜け出す if (inkCanvas1.EditingMode == InkCanvasEditingMode.EraseByPoint) { return; } UIElement el = sender as UIElement; Console.WriteLine("dragging = " + dragging + " in mousemove"); //自由線モード if (dragging && isFreeLine) { points.Add(e.GetPosition(el)); counter++; //点の情報を集め、始点と現在の点をむすぶ StylusPointCollection spc = new StylusPointCollection(); spc.Add(new StylusPoint(prevP.X, prevP.Y)); spc.Add(new StylusPoint(e.GetPosition(el).X, e.GetPosition(el).Y)); Stroke stroke = new Stroke(spc, inkDAs.Last()); inkCanvas1.Strokes.Add(stroke); prevP = e.GetPosition(el); } //直線モード else if (!isFreeLine && dragging) { inkCanvas1.Strokes.Clear(); drawAll(); //点の情報を集め、始点と現在の点をむすぶ StylusPointCollection spc = new StylusPointCollection(); spc.Add(new StylusPoint(startP.X, startP.Y)); spc.Add(new StylusPoint(e.GetPosition(el).X, e.GetPosition(el).Y)); Stroke stroke = new Stroke(spc, inkDAs.Last()); inkCanvas1.Strokes.Add(stroke); counter++; } }
protected override void OnStylusUp(StylusEventArgs e) { base.OnStylusUp(e); // TJC: only take in stylus ink, not multitouch bool isStylus = e.StylusDevice.Id == MyRend.STYLUS_ID || e.StylusDevice.StylusButtons.Count == 2; // tip and barrel if (!isStylus) { _touchCount--; //System.Console.WriteLine("UP TC: " + _touchCount + " " + _maxTouches); //if (_maxTouches > 0) return; // TJC: test // reset max touch once we hit 0 if (_touchCount <= 0) { _maxTouches = 0; } } // Release stylus capture. if (Stylus.Captured == this) // bcz: uncapturing the stylus will uncapture the mouse. However, widgets like SelectionFeedback may have Captured just the Mouse and won't get their Up events - so don't uncapture unless the captured object is 'this' { Stylus.Capture(null); } if (_stylusPoints == null) { return; } _stylusPoints.Add(e.GetStylusPoints(this, _stylusPoints.Description)); Stroke stroke = new Stroke(_stylusPoints); stroke.DrawingAttributes = _dynamicRenderer.DrawingAttributes.Clone(); Stroq s = new Stroq(stroke); if (KeepStroqs) { _stroqs.Add(s); } _stylusPoints = null; RaiseStroqCollectedEvent(s, !isStylus || e.StylusDevice.SwitchState(InqUtils.BarrelSwitch) == StylusButtonState.Down); }
// Token: 0x06006DB7 RID: 28087 RVA: 0x001F85E8 File Offset: 0x001F67E8 protected override void StylusInputContinue(StylusPointCollection stylusPoints, bool userInitiated) { if (this._lassoHelper != null) { List <Point> list = new List <Point>(); for (int i = 0; i < stylusPoints.Count; i++) { list.Add((Point)stylusPoints[i]); } Point[] array = this._lassoHelper.AddPoints(list); if (array.Length != 0) { this._incrementalLassoHitTester.AddPoints(array); return; } } else if (!this._disableLasso) { bool flag = false; List <Point> list2 = new List <Point>(); for (int j = 0; j < stylusPoints.Count; j++) { Point point = (Point)stylusPoints[j]; if (!flag) { double lengthSquared = (point - this._startPoint).LengthSquared; if (DoubleUtil.GreaterThan(lengthSquared, 49.0)) { list2.Add(point); flag = true; } } else { list2.Add(point); } } if (flag) { this.StartLasso(list2); } } }
protected void Update( object sender, EventArgs e ) { paintCanvas.Strokes.Clear(); windowWidth = (float)this.Width; windowHeight = (float)this.Height; Leap.Frame frame = leap.Frame(); InteractionBox interactionBox = leap.Frame().InteractionBox; foreach ( Pointable pointable in leap.Frame().Pointables ) { // ここから追加 // 伸びている指、ツール以外は無視する //if ( !pointable.IsExtended ) { // continue; //} // ここまで追加 Leap.Vector normalizedPosition = interactionBox.NormalizePoint( pointable.StabilizedTipPosition ); float tx = normalizedPosition.x * windowWidth; float ty = windowHeight - normalizedPosition.y * windowHeight; int alpha = 255; if ( (pointable.TouchDistance > 0 && pointable.TouchZone != Pointable.Zone.ZONENONE ) ) { alpha = 255 - (int)(255 * pointable.TouchDistance); touchIndicator.Color = Color.FromArgb( (byte)alpha, 0x0, 0xff, 0x0 ); } else if ( pointable.TouchDistance <= 0 ) { alpha = -(int)(255 * pointable.TouchDistance); touchIndicator.Color = Color.FromArgb( (byte)alpha, 0xff, 0x0, 0x0 ); } else { alpha = 50; touchIndicator.Color = Color.FromArgb( (byte)alpha, 0x0, 0x0, 0xff ); } StylusPoint touchPoint = new StylusPoint( tx, ty ); StylusPointCollection tips = new StylusPointCollection( new StylusPoint[] { touchPoint } ); Stroke touchStroke = new Stroke( tips, touchIndicator ); paintCanvas.Strokes.Add( touchStroke ); } }
private void OnMouseDown(object sender, MouseButtonEventArgs e) { inkPresenter.CaptureMouse(); var points = new StylusPointCollection(); points.Add(e.StylusDevice.GetStylusPoints(inkPresenter)); currentStroke = new Stroke(points); currentStroke.DrawingAttributes = new DrawingAttributes { Color = StrokeColor, OutlineColor = StrokeColor, Width = StrokeWidth, Height = StrokeWidth, }; inkPresenter.Strokes.Add(currentStroke); }
public string ToText(IEnumerable <PdfAnnotation> annots) { if (annots == null) { return(null); } var actualStrokes = new StrokeCollection(); foreach (var annot in annots) { var stylusPoints = new StylusPointCollection(); for (int i = 0; i < annot.Rect.Length - 1; i += 2) { stylusPoints.Add(new StylusPoint(annot.Rect[i], annot.Rect[i + 1]));; } actualStrokes.Add(new Stroke(stylusPoints)); } return(ToText(actualStrokes)); }
/// <summary> /// 移动批量关键帧动画类 /// </summary> /// <param name="spiralSummarization"></param> /// <param name="operationId"></param> /// <param name="insertIndex"></param> /// <param name="fromKeyPointIndexes"></param> /// <param name="toKeyPointIndexes"></param> /// <param name="keyFrames"></param> public MoveKeyFrame(SpiralSummarization spiralSummarization, int operationId, int insertIndex, List <int> fromKeyPointIndexes, List <int> toKeyPointIndexes, List <KeyFrame> keyFrames)//, int index, KeyFrame keyFrame, int startIndex, int endIndex, double duration,bool isInsert) { if (spiralSummarization != null) { spiralSummarization.InkCollector.IsShowUnbrokenKeyFrame = false; } this.operationId = operationId; this.fromKeyPointIndexes = fromKeyPointIndexes; this.toKeyPointIndexes = toKeyPointIndexes; this.keyFrames = keyFrames; this.spiralSummarization = spiralSummarization; this.insertIndex = insertIndex; showCount = keyFrames.Count; this.showSpiralStroke = spiralSummarization.ShowSpiralStroke; this.points = spiralSummarization.Points; for (int i = 1; i < showCount; i++) { int movePointCount = Math.Abs(fromKeyPointIndexes[i] - toKeyPointIndexes[i]); if (movePointCount > maxMovePointCount) { maxMovePointCount = movePointCount; maxMovePointCountIndex = i; } else if (movePointCount < minMovePointCount && movePointCount > 0) { minMovePointCount = movePointCount; } } for (int i = 1; i < showCount; i++) { int movePointCount = Math.Abs(fromKeyPointIndexes[i] - toKeyPointIndexes[i]); int movePointCountPerTime = (int)Math.Floor((double)movePointCount / minMovePointCount); int restPointCount = movePointCount % minMovePointCount; restPointCountList.Add(restPointCount); int moveTime = (int)Math.Ceiling((double)movePointCount / movePointCountPerTime); if (moveTime > maxMoveTime) { maxMoveTime = moveTime; } movePointCountPerTimes.Add(movePointCountPerTime); } }
public void DrawTextInRectangle(object sender, RoutedEventArgs e) { StylusPointCollection pts = new StylusPointCollection(); pts.Add(new StylusPoint(100, 100)); pts.Add(new StylusPoint(100, 300)); pts.Add(new StylusPoint(300, 300)); pts.Add(new StylusPoint(300, 100)); pts.Add(new StylusPoint(100, 100)); CustomStroke st = new CustomStroke(pts); st.DrawingAttributes.Color = Colors.Red; inkCanvas1.Strokes.Add(st); }
/// <summary> /// 清空 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void button2_Click(object sender, EventArgs e) { if (!ic.CollectingInk) { Strokes strokesToDelete = ic.Ink.Strokes; ic.Ink.DeleteStrokes(strokesToDelete); ic.Ink.DeleteStrokes(); //清除手写区域笔画; ink_here.Refresh(); //刷新手写区域 richTextBox1.Clear(); signPoints = new List <StylusPoint>(); strokes = new StrokeCollection(); strokeColl = new StylusPointCollection(); bpoint = new string[3] { "0", "0", "0" }; } }
/// <summary> /// Replaces the StylusPoints. /// </summary> /// <remarks> /// Callers must have Unmanaged code permission to call this API. /// </remarks> /// <param name="stylusPoints">stylusPoints</param> public void SetStylusPoints(StylusPointCollection stylusPoints) { if (null == stylusPoints) { throw new ArgumentNullException("stylusPoints"); } if (!StylusPointDescription.AreCompatible(stylusPoints.Description, _report.StylusPointDescription)) { throw new ArgumentException(SR.Get(SRID.IncompatibleStylusPointDescriptions), "stylusPoints"); } if (stylusPoints.Count == 0) { throw new ArgumentException(SR.Get(SRID.Stylus_StylusPointsCantBeEmpty), "stylusPoints"); } _stylusPoints = stylusPoints.Clone(); }
//private void cSlide1(object sender, RoutedPropertyChangedEventArgs<double> e) //{ // StylusPointCollection allPoints = new StylusPointCollection(); // foreach (Stroke stroke in inkIn1.Strokes) // { // allPoints.Add(stroke.StylusPoints); // } // ComplexStroke cStroke = new ComplexStroke(allPoints); // inkReconstruction1.Strokes = new StrokeCollection(); // inkReconstruction1.Strokes.Add(cStroke.ReconstructedStroke((int)coefficientSlider1.Value)); //} private void cSlide1(object sender, RoutedPropertyChangedEventArgs <double> e) { StylusPointCollection allPoints = new StylusPointCollection(); foreach (Stroke stroke in inkIn1.Strokes) { allPoints.Add(stroke.StylusPoints); } ComplexStroke cStroke = new ComplexStroke(allPoints); inkReconstruction1.Children.Clear(); Stroke reconstruct = cStroke.ReconstructedStroke((int)coefficientSlider1.Value); DrawStrokePoints(reconstruct, inkReconstruction1, Brushes.Red); inkReconstruction1.Strokes = new StrokeCollection(); inkReconstruction1.Strokes.Add(cStroke.ReconstructedStroke((int)coefficientSlider1.Value)); }
public override Point Draw(Point first, MyInkData tool, DrawingContext dc, StylusPointCollection points) { for (int i = 0; i < points.Count; i++) { Point pt = (Point)points[i]; Vector v = Point.Subtract(pt, first); Size size; double distance = GetStylusInkDistance(tool, out size); if (v.Length >= distance) { double x = pt.X - size.Width; double y = pt.Y - size.Height; Rect rect = new Rect(x, y, 2 * size.Width, 2 * size.Height); dc.DrawImage(bi, rect); first = pt; } } return(first); }
//public void AddStroke(System.Windows.Ink.Stroke stroke) //{ // int[] packets = stroke.StylusPoints.ToHiMetricArray(); // Guid[] packetDescription = stroke.StylusPoints.Description.GetStylusPointPropertyIds(); // _inkAnalyzerBase.AddStroke(_strokeId++, packets, packetDescription); //} void StylusPointCollectionSnippets() { //MessageBox.Show("hi"); //<Snippet20> StylusPointCollection points = new StylusPointCollection(new Point[] { new Point(100, 100), new Point(100, 200), new Point(200, 250), new Point(300, 300) }); //</Snippet20> //points.RemoveAt(0); //points.RemoveAt(0); StylusPoint point = new StylusPoint(400, 300); //points.Insert(3, point); //points.Insert(2, point); }
public void Clear() { StylusPointCollection spc = new StylusPointCollection(); foreach (Stroke st in canvas.Strokes) { spc.Add(st.StylusPoints[0]); } if (spc.Count != 0) { RedoList.Add(new Stroke(spc)); UndoPoints.Add(spc.Count); ActionHistory.Add(Actions.Clear); } this.canvas.Strokes.Clear(); dirty = true; }
public override void MakeShape() { StylusPointCollection pts = new StylusPointCollection(); pts.Add(new StylusPoint(this.Center.X - this.Width / 2, this.Center.Y - this.Height / 2)); pts.Add(new StylusPoint(pts[0].X + this.Width, pts[0].Y)); pts.Add(new StylusPoint(pts[0].X + this.Width, pts[0].Y + this.Height)); pts.Add(new StylusPoint(pts[0].X, pts[0].Y + this.Height)); pts.Add(new StylusPoint(pts[0].X, pts[0].Y)); this.StylusPoints = pts; if (this.CurrentRotation != 0) { int rotation = this.CurrentRotation; this.CurrentRotation = 0; this.SetRotation(rotation); } }
// Token: 0x06006D65 RID: 28005 RVA: 0x001F6864 File Offset: 0x001F4A64 protected override void StylusInputBegin(StylusPointCollection stylusPoints, bool userInitiated) { this._incrementalStrokeHitTester = base.InkCanvas.Strokes.GetIncrementalStrokeHitTester(base.InkCanvas.EraserShape); if (InkCanvasEditingMode.EraseByPoint == this._cachedEraseMode) { this._incrementalStrokeHitTester.StrokeHit += this.OnPointEraseResultChanged; } else { this._incrementalStrokeHitTester.StrokeHit += this.OnStrokeEraseResultChanged; } this._stylusPoints = new StylusPointCollection(stylusPoints.Description, 100); this._stylusPoints.Add(stylusPoints); this._incrementalStrokeHitTester.AddPoints(stylusPoints); if (InkCanvasEditingMode.EraseByPoint == this._cachedEraseMode) { base.EditingCoordinator.InvalidateBehaviorCursor(this); } }
protected override void OnStylusDown(StylusDownEventArgs e) { Stylus.Capture(this); //Get the StylusPoints that have come in so far StylusPointCollection newStylusPoints = e.GetStylusPoints(this); // Allocate memory for the StylusPointsCollection and // add the StylusPoints that have come in so far //stylusPoints = new StylusPointCollection(newStylusPoints.Description); //stylusPoints.Add(newStylusPoints); //Create a new StylusPointCollection using the StylusPointDescription //from the stylus points in the StylusDownEventArgs. stylusPoints = new StylusPointCollection(); StylusPointCollection eventPoints = e.GetStylusPoints(this, stylusPoints.Description); stylusPoints.Add(eventPoints); }
/// <summary> /// Handles the MouseLeftButtonDown event of the InkPresenterCommentText control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.Windows.Input.MouseButtonEventArgs"/> instance containing the event data.</param> private void InkPresenterCommentText_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e) { this.InkPresenterCommentText.CaptureMouse(); if (this.editingMode == InkEditingMode.Ink) { this.currentStroke = new Stroke { DrawingAttributes = { Color = this.currentColor } }; this.currentStroke.StylusPoints.Add(e.StylusDevice.GetStylusPoints(this.InkPresenterCommentText)); this.InkPresenterCommentText.Strokes.Add(this.currentStroke); } if (this.editingMode == InkEditingMode.Erase) { this.pointsToErase = e.StylusDevice.GetStylusPoints(this.InkPresenterCommentText); } }
private void DrawPolygon( Color color, params Point[] points) { StylusPointCollection stylusPointCollection = new StylusPointCollection(); foreach (Point point in points) { stylusPointCollection.Add(new StylusPoint(point.X, point.Y)); } Stroke stroke = new Stroke(stylusPointCollection); stroke.DrawingAttributes.Color = color; stroke.DrawingAttributes.Width = 1; stroke.DrawingAttributes.Height = 1; _surface.Strokes.Add(stroke); }
/// <summary> /// 画对顺时针称螺旋线 /// </summary> private void drawSpiralClockwise() { StylusPointCollection spc = new StylusPointCollection();//螺旋线上点集合 double x = 0; double y = 0; double r = 0; double max = Math.PI * 15; double interval = Math.PI / 180; StylusPointCollection spcCenter = new StylusPointCollection(); for (double i = 0; i < Math.PI / 2; i += interval) { r = newSpiralWidth * i; x = center.X + r * Math.Cos(i); y = center.Y + r * Math.Sin(i); StylusPoint sp = new StylusPoint(x, y); spcCenter.Add(sp); } Stroke sCenter = new Stroke(spcCenter); sCenter.DrawingAttributes.Color = Color.FromArgb(255, 255, 255, 0); sCenter.DrawingAttributes.Width = SpiralStrokeWidth; sCenter.DrawingAttributes.Height = SpiralStrokeWidth; _inkCanvas.Strokes.Add(sCenter); for (double i = Math.PI / 2; i < max; i += interval) { r = newSpiralWidth * i; x = center.X + r * Math.Cos(i); y = center.Y + r * Math.Sin(i); StylusPoint sp = new StylusPoint(x, y); spc.Add(sp); } Stroke s = new Stroke(spc); //s.DrawingAttributes.FitToCurve = true; s.DrawingAttributes.Color = Color.FromArgb(0, 255, 255, 0); s.DrawingAttributes.Width = SpiralStrokeWidth; s.DrawingAttributes.Height = SpiralStrokeWidth; spiralStroke = s; _inkCanvas.Strokes.Add(spiralStroke); }
private void StrokeRectConvert(System.Windows.Ink.Stroke stroke) { StylusPointCollection ptsRect = new StylusPointCollection(); StylusPointCollection pts = stroke.StylusPoints; double minX = double.MaxValue; double minY = minX; double maxX = double.MinValue; double maxY = maxX; //find bounding area foreach (StylusPoint pt in pts) { if (pt.X > maxX) { maxX = pt.X; } if (pt.X < minX) { minX = pt.X; } if (pt.Y > maxY) { maxY = pt.Y; } if (pt.Y < minY) { minY = pt.Y; } } //stroke four corners of the rect ptsRect.Add(new StylusPoint(minX, minY)); ptsRect.Add(new StylusPoint(minX, maxY)); ptsRect.Add(new StylusPoint(maxX, maxY)); ptsRect.Add(new StylusPoint(maxX, minY)); ptsRect.Add(new StylusPoint(minX, minY)); stroke.StylusPoints = ptsRect; //no smoothing stroke.DrawingAttributes.FitToCurve = false; }
private void HandleInteraction(object clientData, RawStylusSystemGestureInputReport originalReport) { RawStylusSystemGestureInputReport report = new RawStylusSystemGestureInputReport( InputMode.Foreground, Environment.TickCount, CriticalActiveSource, () => { return(PointerTabletDevice.StylusPointDescription); }, TabletDevice.Id, Id, originalReport.SystemGesture, originalReport.GestureX, originalReport.GestureY, originalReport.ButtonState) { StylusDevice = StylusDevice, }; // For a flick, update the points in the stylus device to the flick location. // This forces processing of the stylus over to use the initial flick location // instead of the last WM_POINTER message location allowing command processing to // be done on the flick location itself. if (report.SystemGesture == SystemGesture.Flick) { StylusPoint flickPoint = _currentStylusPoints[_currentStylusPoints.Count - 1]; flickPoint.X = report.GestureX; flickPoint.Y = report.GestureY; _currentStylusPoints = new StylusPointCollection(flickPoint.Description, flickPoint.GetPacketData(), GetTabletToElementTransform(null), Matrix.Identity); } InputReportEventArgs irea = new InputReportEventArgs(StylusDevice, report) { RoutedEvent = InputManager.PreviewInputReportEvent, }; // Now send the input report InputManager.UnsecureCurrent.ProcessInput(irea); }
public StylusPointCollection getCurve(StylusPoint start, StylusPoint end) { StylusPointCollection collection = new StylusPointCollection(); if (start.X > end.X) { StylusPoint temp = start; start = end; end = temp; } StylusPoint[] pts = getMidPoints(start, end); for (int i = 1; i < pts.Length; i++) { StylusPoint p1 = pts[i - 1]; StylusPoint p2 = pts[i]; int num = (int)(MathTool.getInstance().distanceP2P(p1, p2)); StylusPoint b = new StylusPoint(); StylusPoint temp = new StylusPoint(p1.X + (p2.X - p1.X) / 3, p1.Y + (p2.Y - p1.Y) / 3); double angle = MathTool.getInstance().getAngleP2P(p1, p2); double angle1 = 90 + angle; double kk = Math.Tan(angle1 / 180); b.X = (int)(temp.X - H / kk); b.Y = temp.Y + H; for (int k = 0; k < num; k++) { double t = k * 1.0 / num; double a, e, c; a = (1 - t) * (1 - t); e = 2 * t * (1 - t); c = t * t; int x1 = (int)(p1.X * a + b.X * e + p2.X * c); int y1 = (int)(p1.Y * a + b.Y * e + p2.Y * c); collection.Add(new StylusPoint(x1, y1)); } } return(collection); }
public void Stroke_StylusPointCollection () { StylusPointCollection spc = new StylusPointCollection (); spc.Add (new StylusPoint (1, 2)); Stroke s = new Stroke (spc); Assert.AreEqual (1, s.StylusPoints.Count, "StylusPoints-1"); spc.Add (new StylusPoint (3, 4)); Assert.AreEqual (2, s.StylusPoints.Count, "StylusPoints-2"); s.StylusPoints.Add (new StylusPoint (5, 6)); Assert.AreEqual (3, s.StylusPoints.Count, "StylusPoints-3a"); Assert.AreEqual (3, spc.Count, "StylusPoints-3b"); Assert.Throws<ArgumentException> (delegate { s.HitTest (null); }, "HitTest-null"); Assert.IsTrue (s.HitTest (s.StylusPoints), "HitTest-StylusPoints"); }
public TouchPoint2(TouchInfo info, UIElement source) { this.Source = source; #if SILVERLIGHT Stroke = new Stroke(); #else var stylusPoints = new StylusPointCollection(1); stylusPoints.Add(new StylusPoint(info.Position.X, info.Position.Y)); Stroke = new Stroke(stylusPoints); #endif TouchDeviceId = info.TouchDeviceId; StartTime = DateTime.Now; #if SILVERLIGHT UpdateTouchStroke(info); #endif UpdateTouchInfo(info); }
/// <summary>Create a stroke from a StylusPointCollection</summary> /// <remarks> /// </remarks> /// <param name="stylusPoints">StylusPointCollection that makes up the stroke</param> /// <param name="drawingAttributes">drawingAttributes</param> /// <param name="extendedProperties">extendedProperties</param> internal Stroke(StylusPointCollection stylusPoints, DrawingAttributes drawingAttributes, ExtendedPropertyCollection extendedProperties) { if (stylusPoints == null) { throw new ArgumentNullException("stylusPoints"); } if (stylusPoints.Count == 0) { throw new ArgumentException(SR.Get(SRID.InvalidStylusPointCollectionZeroCount), "stylusPoints"); } if (drawingAttributes == null) { throw new ArgumentNullException("drawingAttributes"); } _drawingAttributes = drawingAttributes; _stylusPoints = stylusPoints; _extendedProperties = extendedProperties; Initialize(); }
private StrokeCollection GetStrokeCollectionFromPoints(dynamic strokePoints) { var strokeCollection = new StrokeCollection(); foreach (var stroke in strokePoints.Strokes) { var points = new StylusPointCollection(); foreach (var point in stroke.Points) { var x = (float)point.X; var y = (float)point.Y; points.Add(new StylusPoint(x, y)); } strokeCollection.Add(new Stroke(points)); } return strokeCollection; }
public static StrokeCollection ConvertToStrokeCollection(SerializableStrokeCollection strokeCollection) { StrokeCollection resultCollection = new StrokeCollection(); foreach (var stroke in strokeCollection) { DrawingAttributes drawingAttr = new DrawingAttributes { Color = stroke.DrawingAttributes.Color, FitToCurve = stroke.DrawingAttributes.FitToCurve, Height = stroke.DrawingAttributes.Height, Width = stroke.DrawingAttributes.Width, IgnorePressure = stroke.DrawingAttributes.IgnorePressure, IsHighlighter = stroke.DrawingAttributes.IsHighlighter, StylusTipTransform = stroke.DrawingAttributes.StylusTipTransform }; switch (stroke.DrawingAttributes.StylusTip) { case SerializableDrawingAttributes.StylusTips.Ellipse: drawingAttr.StylusTip = StylusTip.Ellipse; break; case SerializableDrawingAttributes.StylusTips.Rectangle: drawingAttr.StylusTip = StylusTip.Rectangle; break; default: break; } StylusPointCollection spc = new StylusPointCollection(); foreach (var stylusPoint in stroke.StylusPoints) { StylusPoint sp = new StylusPoint { X = stylusPoint.X, Y = stylusPoint.Y, PressureFactor = stylusPoint.PressureFactor }; spc.Add(sp); } Stroke newStroke = new Stroke(spc); newStroke.DrawingAttributes = drawingAttr; resultCollection.Add(newStroke); } return resultCollection; }
/// <summary> /// StylusInputContinue /// </summary> /// <param name="stylusPoints">stylusPoints</param> /// <param name="userInitiated">true if the source eventArgs.UserInitiated flag was set to true</param> protected override void StylusInputContinue(StylusPointCollection stylusPoints, bool userInitiated) { _stylusPoints.Add(stylusPoints); _incrementalStrokeHitTester.AddPoints(stylusPoints); }