void GetTriangle(StylusPointCollection pts, Action <StylusPointCollection> exec)
{
pts.Add(new StylusPoint(topLeft.X, topLeft.Y));
pts.Add(new StylusPoint(bottomRight.X, bottomRight.Y));
exec(pts);
}
void _recognier_OnLineEnded(object sender, EventArgs e)
{
// 가상 선 등록
//Line straightLine = new Line();
//straightLine = new Line();
//straightLine.StrokeThickness = this.DrawingCanvas.DefaultDrawingAttributes.Width;
//straightLine.Stroke = this.DrawingCanvas.DefaultDrawingAttributes.Color;
//straightLine.X1 = _floatingLine.X1;
//straightLine.Y1 = _floatingLine.Y1;
//straightLine.X2 = _floatingLine.X2;
//straightLine.Y2 = _floatingLine.Y2;
StylusPointCollection stcol = new StylusPointCollection();
stcol.Add(new StylusPoint(_floatingLine.X1, _floatingLine.Y1));
stcol.Add(new StylusPoint(_floatingLine.X2, _floatingLine.Y2));
StrokeCollection col = new StrokeCollection();
Stroke st = new Stroke(stcol);
col.Add(st);
this.DrawingCanvas.Strokes.Add(col);
//gridMain.Children.Add(straightLine);
//gridMain.RegisterName("ui_straightLine" + DateTime.Now.ToFileTime().ToString(), straightLine);
_floatingLine.Visibility = System.Windows.Visibility.Collapsed;
}
/// <summary>
/// Cursor has been moved
/// </summary>
/// <param name="cursor">Position</param>
/// <param name="mode">State</param>
private void cursorMove(Point point)
{
var p = relativeTransform(point);
// Check buttons
helpButton.Over((helpButton.Intersects(this, point)));
clearButton.Over((clearButton.Intersects(this, point)));
cancelButton.Over((cancelButton.Intersects(this, point)));
continueButton.Over((continueButton.Intersects(this, point)));
// Stop if input capture isn't ready
if (stylusPoints == null)
{
return;
}
// Add current point
stylusPoints.Add(toStylusPoint(p));
//Erase if need be
if (cursor.Mode == CursorModes.Erase)
{
erase();
}
}
// Resampling all the strokes with the same distance intervals
/*
* public static void Resampling(Stroke myStroke, double scaleFactor, Rect myBounds)
* {
* double diagonalLength = GeometryRelation.Distance(myBounds.BottomLeft, myBounds.TopRight);
* double S = diagonalLength / scaleFactor;
* //MessageBox.Show("S = "+S);
* //
* double D = 0;
* StylusPointCollection resampledStylusPointsCollection = new StylusPointCollection();
*
*
* // Add the first point to resampled stylus points
* resampledStylusPointsCollection.Add(myStroke.StylusPoints[0]);
* for (int i = 1; i < myStroke.StylusPoints.Count; i++)
* {
* StylusPoint p1, p2;
* p1 = myStroke.StylusPoints[i - 1];
* p2 = myStroke.StylusPoints[i];
* double d = GeometryRelation.Distance(p1, p2);
* if ((D + d) >= S)
* {
* StylusPoint newPoint = new StylusPoint(p1.X + ((S - D) / d) * (p2.X - p1.X), p1.Y + ((S - D) / d) * (p2.Y - p1.Y));
* resampledStylusPointsCollection.Add(newPoint);
* myStroke.StylusPoints[i] = newPoint;
* D = 0;
* }
* else
* {
* D = D + d;
* }
* }
* myStroke.StylusPoints = resampledStylusPointsCollection;
* }
*/
public static void Resampling(Stroke myStroke, int n)
{
double S = Length(myStroke) / (n - 1);
double D = 0;
StylusPointCollection resampledStylusPointsCollection = new StylusPointCollection();
// Add the first point to resampled stylus points
resampledStylusPointsCollection.Add(myStroke.StylusPoints[0]);
for (int i = 1; i < myStroke.StylusPoints.Count; i++)
{
StylusPoint p1, p2;
p1 = myStroke.StylusPoints[i - 1];
p2 = myStroke.StylusPoints[i];
double d = Distance(p1, p2);
if ((D + d) >= S)
{
StylusPoint newPoint = new StylusPoint(p1.X + ((S - D) / d) * (p2.X - p1.X), p1.Y + ((S - D) / d) * (p2.Y - p1.Y));
resampledStylusPointsCollection.Add(newPoint);
myStroke.StylusPoints.Insert(i, newPoint);
//myStroke.StylusPoints[i] = newPoint;
D = 0;
}
else
{
D = D + d;
}
}
myStroke.StylusPoints = resampledStylusPointsCollection;
if (myStroke.StylusPoints.Count == n - 1)
{
myStroke.StylusPoints.Add(new StylusPoint(myStroke.StylusPoints[myStroke.StylusPoints.Count - 1].X, myStroke.StylusPoints[myStroke.StylusPoints.Count - 1].Y));
}
}
public override StylusPointCollection AddPoint(StylusPoint stylusPoint)
{
if (this._stylusPointQueue == null)
{
this._stylusPointQueue = new StylusPointQueue(18);
this._stylusPointQueue.Enqueue(stylusPoint);
return(null);
}
StylusPointCollection stylusPointCollection2;
int num = this._stylusPointQueue.Count;
if (num != 16)
{
this._stylusPointQueue.Enqueue(stylusPoint);
}
stylusPointCollection2 = new StylusPointCollection(stylusPoint.Description);
int num2 = 0;
if (num < 8)
{
stylusPointCollection2.Add(this._stylusPointQueue.Dequeue());
num2++;
num = num2;
}
stylusPointCollection2.Add(this._stylusPointQueue[0]);
return(stylusPointCollection2);
}
private void CreateSaveGroupStroke(InkCanvas _ink, string img_file, string str_file)
{
StrokeCollection InkGroup = new StrokeCollection();
for (int j = 0; j < pointHist.Count; j++)
{
StylusPointCollection T = new StylusPointCollection();
T.Add(new StylusPoint(_ink.ActualWidth / 2, _ink.ActualHeight / 2));
for (int i = j; i < pointHist.Count; i++)
{
T.Add(new StylusPoint(T[i - j].X - pointHist[i].X, T[i - j].Y - pointHist[i].Y));
}
Stroke So = new Stroke(T);
InkGroup.Add(So);
}
FileStream file = File.Create(str_file);
InkGroup.Save(file);
file.Flush();
file.Close();
_ink.Strokes.Clear();
_ink.Strokes.Add(InkGroup);
CreateSaveBitmap(_ink, img_file);
}
private void BtnStroke_Click(object sender, RoutedEventArgs e)
{
StylusPointCollection stylusPointCollection = new StylusPointCollection();
// StylusPoint stylusPoint = new StylusPoint(100, 200, .2f);
stylusPointCollection.Add(new StylusPoint(100, 200, .2f));
stylusPointCollection.Add(new StylusPoint(100, 250, .5f));
stylusPointCollection.Add(new StylusPoint(100, 300, .9f));
Stroke stroke = new Stroke(stylusPointCollection);
stroke.DrawingAttributes = new DrawingAttributes {
Width = 25, Height = 25, Color = Color.FromRgb(0, 0, 0)
};
this.inkCanvas.Strokes.Add(stroke);
stylusPointCollection = new StylusPointCollection();
// StylusPoint stylusPoint = new StylusPoint(100, 200, .2f);
stylusPointCollection.Add(new StylusPoint(200, 200, .2f));
stylusPointCollection.Add(new StylusPoint(200, 250, .5f));
stylusPointCollection.Add(new StylusPoint(200, 300, .9f));
stroke = new Stroke(stylusPointCollection);
stroke.DrawingAttributes = new DrawingAttributes {
Width = 25, Height = 25, Color = Color.FromRgb(0, 0, 0)
};
this.inkCanvas.Strokes.Add(stroke);
}
protected void DrawLeapLine(Controller leap, Leap.Frame frame)
{
FingerList allFingers = frame.Fingers.Extended();
if (allFingers.Count != 2 || leap.Frame(10).Fingers.Extended().Count != 2)
{
return;
}
Finger finger1 = allFingers.Leftmost;
Finger finger2 = allFingers.Rightmost;
InteractionBox interactionBox = frame.InteractionBox;
Leap.Vector normalizedPosition1 = interactionBox.NormalizePoint(finger1.StabilizedTipPosition);
Leap.Vector normalizedPosition2 = interactionBox.NormalizePoint(finger2.StabilizedTipPosition);
double tx1 = normalizedPosition1.x * windowWidth;
double ty1 = windowHeight - normalizedPosition1.y * windowHeight;
double tx2 = normalizedPosition2.x * windowWidth;
double ty2 = windowHeight - normalizedPosition2.y * windowHeight;
StylusPointCollection tips = new StylusPointCollection();
tips.Add(new StylusPoint(tx1, ty1));
tips.Add(new StylusPoint(tx2, ty2));
Stroke stroke = new Stroke(tips, lineIndicator);
this.InkCanvas_LeapPaint.Strokes.Add(stroke);
}
public static Stroke StrokeToCircle(Stroke originalStroke)
{
//Fix the center.
StylusPoint start = originalStroke.StylusPoints[0];
double radiusX = originalStroke.GetGeometry().Bounds.Width * 0.5;
double radiusY = originalStroke.GetGeometry().Bounds.Height * 0.5;
double ycenter = originalStroke.GetGeometry().Bounds.Top + radiusY;
double xcenter = originalStroke.GetGeometry().Bounds.Left + radiusX;
StylusPointCollection s = new StylusPointCollection();
double angle = 0.0f;
for (int i = 0; i < 360; i++)
{
angle = Math.PI * i / 180.0;
s.Add(new StylusPoint(xcenter + (radiusX * Math.Cos(angle)), ycenter + (radiusY * Math.Sin(angle))));
}
//make sure to close the loop
s.Add(new StylusPoint(s[0].X, s[0].Y));
Stroke st = new Stroke(s);
return(st);
}
/// <summary>
/// 每条注释笔迹完成以后的操作
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void InkCanvasAnnotation_StrokeCollected(object sender, System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e)
{
if (null != _keyFramesAnnotation)
{
if (_keyFramesAnnotation.Strokes.Count == 0)
{
if (_inkCollector.DefaultSummarizationNum == 0)
{
//关键帧索引
int index = _inkCollector.VideoSummarization.ShowKeyFrames.IndexOf(_inkCollector.SelectKeyFrames[0]);
((SpiralSummarization)_inkCollector.VideoSummarization).AddPoints2ShowSpiral(index, Colors.Red, 0);
}
else if (_inkCollector.DefaultSummarizationNum == 1)
{
int index = _inkCollector.VideoSummarization.KeyFrames.IndexOf(_inkCollector.SelectKeyFrames[0]);
StylusPoint slPoint = _inkCollector.VideoSummarization.KeyPoints[index];
StylusPointCollection spc = new StylusPointCollection();
StylusPoint currPoint1 = new StylusPoint(slPoint.X - _inkCollector.VideoSummarization.ShowWidth / 2, slPoint.Y + _inkCollector.VideoSummarization.ShowHeight / 2 + 2);
StylusPoint currPoint2 = new StylusPoint(slPoint.X + _inkCollector.VideoSummarization.ShowWidth / 2, slPoint.Y + _inkCollector.VideoSummarization.ShowHeight / 2 + 2);
spc.Add(currPoint1);
spc.Add(currPoint2);
Stroke s = new Stroke(spc);
s.DrawingAttributes.Color = Colors.Red;
s.DrawingAttributes.Width = 3;
s.DrawingAttributes.Height = 3;
((InkCanvas)(_inkCollector._mainPage._inkCanvas.Children[1])).Strokes.Add(s);
}
}
Stroke lastStroke = InkCanvasAnnotation.Strokes[InkCanvasAnnotation.Strokes.Count - 1].Clone();
_keyFramesAnnotation.Strokes.Add(lastStroke);
}
}
//描く処理(マウスムーブ)
private void inkCanvas1_MouseMove(object sender, MouseEventArgs e)
{
UIElement el = sender as UIElement;
Console.WriteLine("dragging = " + dragging + " in mousemove");
//かくモード
if (dragging && isFreeLine)
{
points.Add(e.GetPosition(el));
Console.WriteLine(e.GetPosition(el));
counter++;
}
//直線モード
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, inkDA);
inkCanvas1.Strokes.Add(stroke);
counter++;
}
}
/// <summary>
/// We create a stroke with points close and then add the stroke to the canvas.
/// If the points are far apart, we create a new stroke for those points.
/// </summary>
/// <param name="inkCanvas"></param>
/// <param name="strokeInfo"></param>
public static void AddStrokePreview(this InkCanvas inkCanvas, StrokeInfo strokeInfo)
{
StylusPoint firstPoint = strokeInfo.PointCollection[0];
StylusPointCollection tmpPoints = new StylusPointCollection();
tmpPoints.Add(firstPoint);
for (int i = 0; i < strokeInfo.PointCollection.Count - 1; i++)
{
if (CalculateDistance(strokeInfo.PointCollection[i], strokeInfo.PointCollection[i + 1]) < 5)
{
tmpPoints.Add(strokeInfo.PointCollection[i + 1]);
}
else
{
inkCanvas.Strokes.Add(CreateStroke(strokeInfo, tmpPoints.Clone()));
tmpPoints.Clear();
tmpPoints.Add(strokeInfo.PointCollection[i + 1]);
}
}
if (tmpPoints.Count > 0)
{
inkCanvas.Strokes.Add(CreateStroke(strokeInfo, tmpPoints));
}
}
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 void Update()
{
double Mass1X = X0 + L1 * Math.Sin(Phi1);
double Mass1Y = Y0 + L1 * Math.Cos(Phi1);
double Mass2X = Mass1X + L2 * Math.Sin(Phi2);
double Mass2Y = Mass1Y + L2 * Math.Cos(Phi2);
SetSize(mass1, 2 * M1);
SetSize(mass2, 2 * M2);
SetPosition(mass1, Mass1X - M1, Mass1Y - M1);
SetPosition(mass2, Mass2X - M2, Mass2Y - M2);
SetPosition(Arm1, X0, Y0, Mass1X, Mass1Y);
SetPosition(Arm2, Mass1X, Mass1Y, Mass2X, Mass2Y);
var sp = new StylusPoint(Mass2X, Mass2Y);
if (col == null || col.Count >= 1000)
{
var ncol = new StylusPointCollection();
if (col != null)
{
ncol.Add(col.Last());
}
ncol.Add(sp);
stroke = new Stroke(ncol);
stroke.DrawingAttributes.Color = Colors.Blue;
_ink.Strokes.Add(stroke);
col = ncol;
}
else
{
col.Add(sp);
}
}
public override StylusPointCollection GetShapePointCollection(Point anchor, Point cursor)
{
var pointCollection = new StylusPointCollection();
int angleNum = 5; //The number of angles in the shape.
double radius = Math.Min(Math.Abs(anchor.X - cursor.X), Math.Abs(anchor.Y - cursor.Y)) / 2; //Getting radii of inscribed and circumscribed circles.
double angle = 20; //Pitch angle.
double x = (anchor.X + cursor.X) / 2; //Center coords
double y = (anchor.Y + cursor.Y) / 2;
double div = x / y;
//Counting of star's apexes coords.
for (int i = 1; i < angleNum * 2 + 2; i++)
{
var point = new StylusPoint();
point.X = x + radius / 2 * Math.Cos(angle * Math.PI / 180) * div;
point.Y = y - radius / 2 * Math.Sin(angle * Math.PI / 180) / div;
angle = angle + 360 / angleNum;
//Adding current apex to collection.
pointCollection.Add(point);
}
//Adding first point to the collection's tail.
pointCollection.Add(pointCollection[0]);
//Drawing strokes between points.
var pentagone = new Stroke(pointCollection);
return(pointCollection);
}
public Rectangle(Point TopPnt, Point LowerPnt, Color color)
{
if (TopPnt.X < LowerPnt.X)
{
TopLeft = TopPnt;
TopRight = new Point(LowerPnt.X, TopPnt.Y);
LowerLeft = new Point(TopPnt.X, LowerPnt.Y);
LowerRight = LowerPnt;
}
else
{
TopRight = TopPnt;
TopLeft = new Point(LowerPnt.X, TopPnt.Y);
LowerRight = new Point(TopRight.X, LowerPnt.Y);
LowerLeft = LowerPnt;
}
StylusPointCollection pts = new StylusPointCollection();
pts.Add(new StylusPoint(TopLeft.X, TopLeft.Y));
pts.Add(new StylusPoint(TopRight.X, TopRight.Y));
pts.Add(new StylusPoint(LowerRight.X, LowerRight.Y));
pts.Add(new StylusPoint(LowerLeft.X, LowerLeft.Y));
pts.Add(new StylusPoint(TopLeft.X, TopLeft.Y));
Outline = new Stroke(pts);
Outline.DrawingAttributes.Color = color;
}
private void StrokeArrowConvert(System.Windows.Ink.Stroke stroke)
{
//Console.WriteLine("Stroke Completed");
double toRadians = Math.PI / 180.0;
StylusPointCollection ptsRect = new StylusPointCollection();
StylusPointCollection pts = stroke.StylusPoints;
StylusPoint pt1 = pts[pts.Count - 1];
StylusPoint pt2 = pts[0];
ptsRect.Add(pt1);
ptsRect.Add(pt2);
//compute arrow head
double arrowAngle = 30.0 * toRadians;
double deltaX = pt2.X - pt1.X;
double deltaY = pt2.Y - pt1.Y;
double theta = Math.Atan2(deltaY, deltaX); //radians
double x1 = Math.Cos(theta + arrowAngle);
double x2 = Math.Cos(theta - arrowAngle);
double y1 = Math.Sin(theta + arrowAngle);
double y2 = Math.Sin(theta - arrowAngle);
double mag = 10.0; //arrorhead line length
ptsRect.Add(new StylusPoint(pt2.X - mag * x1, pt2.Y - mag * y1));
ptsRect.Add(new StylusPoint(pt2.X, pt2.Y));
ptsRect.Add(new StylusPoint(pt2.X - mag * x2, pt2.Y - mag * y2));
stroke.StylusPoints = ptsRect;
stroke.DrawingAttributes.FitToCurve = false;
}
public static Stroke PositionsToCircle(Point startPoint, Point endPoint)
{
StylusPointCollection stp = new StylusPointCollection();
stp.Add(new StylusPoint(startPoint.X, startPoint.Y));
stp.Add(new StylusPoint(endPoint.X, endPoint.Y));
return(InkTransformerHelper.StrokeToCircle(new Stroke(stp)));
}
// Collect the points as the user draws the stroke.
protected override void OnStylusMove(RawStylusInput rawStylusInput)
{
// Check whether the stylus that started the stroke is the same, and
// that the element hasn't lost focus since the stroke began.
if (points != null && currentStylus == rawStylusInput.StylusDeviceId)
{
points.Add(rawStylusInput.GetStylusPoints());
}
}
public override StylusPointCollection GetShapePointCollection(Point anchor, Point cursor)
{
var pointCollection = new StylusPointCollection();
pointCollection.Add(new StylusPoint(anchor.X, anchor.Y));
pointCollection.Add(new StylusPoint(cursor.X, cursor.Y));
return(pointCollection);
}
public override Stroke getShapeStroke(Point anchor, Point cursor)
{ /*
* var pointCollection = new StylusPointCollection();
* int angleNum = 5; //The number of angles in the shape.
* double radius = Math.Min(Math.Abs(anchor.X - cursor.X), Math.Abs(anchor.Y - cursor.Y)) / 2; //Getting radii of inscribed and circumscribed circles.
* double angle = 20; //Pitch angle.
* double x = (anchor.X + cursor.X) / 2; //Center coords
* double y = (anchor.Y + cursor.Y) / 2;
* double div = x / y;
*
* //Counting of star's apexes coords.
* for (int i = 1; i < angleNum * 2 + 2; i++)
* {
* var point = new StylusPoint();
*
* point.X = x + radius / 2 * Math.Cos(angle * Math.PI / 180) * div;
* point.Y = y - radius / 2 * Math.Sin(angle * Math.PI / 180) / div;
*
* angle = angle + 360 / angleNum;
* //Adding current apex to collection.
* pointCollection.Add(point);
* }
*
* //Adding first point to the collection's tail.
* pointCollection.Add(pointCollection[0]);
*
* //Drawing strokes between points.
* var pentagone = new Stroke(pointCollection);
* return pentagone;
*/
var pointCollection = new StylusPointCollection();
double x = Math.Abs(anchor.X - cursor.X) / 2; //Center coords
double y = Math.Abs(anchor.Y - cursor.Y) / 2;
double angle = 20;
int angleNum = 5;
double div = x / y;
for (int i = 0; i < 5; i++)
{
var point = new StylusPoint();
double fi = 72;//Math.Atan((div) * Math.Tan(angle));
point.X = (anchor.X + cursor.X) / 2 + (x / Math.Cos(fi));
point.Y = (anchor.X + cursor.X) / 2 + (y / Math.Sin(fi));
//angle = angle + 360 / angleNum;
pointCollection.Add(point);
}
//Adding first point to the collection's tail.
pointCollection.Add(pointCollection[0]);
//Drawing strokes between points.
var pentagone = new Stroke(pointCollection);
return(pentagone);
}
protected override void OnStylusMove(StylusEventArgs e)
{
// Allocate memory for the StylusPointsCollection, if necessary
stylusPoints ??= new StylusPointCollection();
// Add the StylusPoints that have come in since the last call to OnStylusMove
StylusPointCollection newStylusPoints = e.GetStylusPoints(this, stylusPoints.Description);
stylusPoints.Add(newStylusPoints);
}
protected override void OnStylusMove(StylusEventArgs e)
{
if (stylusPoints == null)
{
stylusPoints = new StylusPointCollection();
}
StylusPointCollection newStylusPoints = e.GetStylusPoints(this, stylusPoints.Description);
stylusPoints.Add(newStylusPoints);
}
public override Stroke draw(Point anchor, Point cursor)
{
var pointCollection = new StylusPointCollection();
pointCollection.Add(new StylusPoint(anchor.X, anchor.Y));
pointCollection.Add(new StylusPoint(cursor.X, cursor.Y));
var line = new Stroke(pointCollection);
return(line);
}
protected override void OnStylusMove(StylusEventArgs e)
{
base.OnStylusMove(e);
if (stylusPoints == null)
{
stylusPoints = new StylusPointCollection();
}
stylusPoints.Add(e.GetStylusPoints(this, stylusPoints.Description));
}
public void AddPoint(StylusPoint point)
{
if (Drawing)
{
activePoints.Add(point);
}
else
{
throw new NotSupportedException("Not drawing a stroke. Failed to add a point.");
}
}
public static StylusPointCollection box(Rect rect)
{
StylusPointCollection r = new StylusPointCollection();
r.Add(sp(rect.TopLeft));
r.Add(sp(rect.TopRight));
r.Add(sp(rect.BottomRight));
r.Add(sp(rect.BottomLeft));
r.Add(sp(rect.TopLeft));
return(r);
}
public void Add_StylusPointCollection_Empty()
{
StylusPointCollection spc = new StylusPointCollection();
StylusPointCollection child = new StylusPointCollection();
spc.Add(child);
// twice
spc.Add(child);
// self
spc.Add(spc);
Assert.AreEqual(0, spc.Count, "Count-3");
}
//</Snippet9>
// Collect the stylus packets as the stylus moves.
protected override void OnStylusMove(StylusEventArgs e)
{
if (stylusPoints == null)
{
return;
}
StylusPointCollection collectedPoints = e.GetStylusPoints(this, stylusPoints.Description);
stylusPoints.Add(collectedPoints);
AddPointsToHitTester(collectedPoints);
}
static StylusPointCollection Points(StylusPointCollection StylusPointCollection)
{
var start = StylusPointCollection.First().ToPoint();
var end = StylusPointCollection.Last().ToPoint();
RectangleDynamicRenderer.Prepare(ref start, ref end, out var w, out var h);
var center = new Point(start.X + w / 2, start.Y + h / 2);
var stylusPoints = new StylusPointCollection();
const double step = 0.05;
var arc1 = new List <StylusPoint>();
var arc2 = new List <StylusPoint>();
var arc3 = new List <StylusPoint>();
var arc4 = new List <StylusPoint>();
for (var dx = 0.0; dx < w / 2; dx += step)
{
var dy = (h / 2) * Math.Sqrt(1 - Math.Pow(2 * dx / w, 2));
arc1.Add(new StylusPoint(center.X + dx, center.Y + dy));
arc2.Add(new StylusPoint(center.X - dx, center.Y + dy));
arc3.Add(new StylusPoint(center.X - dx, center.Y - dy));
arc4.Add(new StylusPoint(center.X + dx, center.Y - dy));
}
foreach (var point in arc1.AsEnumerable().Reverse())
{
stylusPoints.Add(point);
}
foreach (var point in arc2)
{
stylusPoints.Add(point);
}
foreach (var point in arc3.AsEnumerable().Reverse())
{
stylusPoints.Add(point);
}
foreach (var point in arc4)
{
stylusPoints.Add(point);
}
stylusPoints.Add(arc1[arc1.Count - 1]);
return(stylusPoints);
}
//creates stroke and draws it on the canvas.
public void generateStroke(PointCollection pointHist)
{
S = new StylusPointCollection();
S.Add(new StylusPoint(_ink.ActualWidth / 2, _ink.ActualHeight / 2));
for (int i = 0; i < pointHist.Count; i++)
{
S.Add(new StylusPoint(S[i].X - pointHist[i].X, S[i].Y - pointHist[i].Y));
}
Stroke So = new Stroke(S);
_ink.Strokes.Clear();
_ink.Strokes.Add(So);
}
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);
}
//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 Stroke Representation()
{
StylusPointCollection collection = new StylusPointCollection();
foreach (var data in stylusPoints)
collection.Add(data.Representation());
return new Stroke(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");
}
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 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);
}
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);
}
}
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);
}
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;
}
private void UIThreadDevice_StackingTouchEvent(object sender, StackingTouchEventArgs e)
{
if (e.Action == TouchAction.Down)
{
StylusPointCollection points = new StylusPointCollection();
points.Add(new StylusPoint(e.Location.X, e.Location.Y));
stackingSelectionStroke = new Stroke(points, inkCScribble.DefaultDrawingAttributes);
inkCScribble.Strokes.Add(stackingSelectionStroke);
}
else if (e.Action == TouchAction.Move)
{
stackingSelectionStroke.StylusPoints.Add(new StylusPoint(e.Location.X, e.Location.Y));
foreach (ScribbleCollection collection in ActualDocument[ActualPage].ScribblingCollections)
{
foreach (Stroke stroke in collection.Scribbles)
{
if (!stroke.HitTest(e.Location))
continue;
Synch.SendContent(ActualDocument.ID, ActualPage, stroke);
}
}
var line = cHighlights.InputHitTest(e.Location);
if (line == null || !(line is Line))
return;
Highlight highlight = (Highlight)ActualDocument[ActualPage].Highlights.SingleOrDefault(tmp => (tmp as Highlight).Line == line);
if (highlight == null)
return;
Synch.SendContent(ActualDocument.ID, ActualPage, highlight);
}
else if (e.Action == TouchAction.Up)
{
if (inkCScribble.Strokes.Contains(stackingSelectionStroke))
inkCScribble.Strokes.Remove(stackingSelectionStroke);
}
}
private void loadInk()
{
String inkFile = sceneName + ".ink";
if(File.Exists(sceneDir + "\\" + inkFile))
{
StreamReader reader = new StreamReader(sceneDir + "\\" + inkFile);
double x = -1;
double y = -1;
StylusPointCollection points = new StylusPointCollection();
String s = reader.ReadLine();
while (s != null)
{
if (s != "")
{
x = Convert.ToDouble(s);
}
s = reader.ReadLine();
if (s != null && s != "")
{
y = Convert.ToDouble(s);
}
if (x != -1 && y != -1)
{
points.Add(new StylusPoint(x, y));
}
s = reader.ReadLine();
if (s == "---")
{
scene.Strokes.Add(new Stroke(points));
points = new StylusPointCollection();
s = reader.ReadLine();
}
}
reader.Close();
}
}
public void Add_StylusPointCollection_MultipleTimes ()
{
StylusPointCollection spc = new StylusPointCollection ();
StylusPointCollection child = new StylusPointCollection ();
child.Add (new StylusPoint (1, 2));
spc.Add (child);
Assert.AreEqual (1, spc.Count, "Count-1");
// twice
Assert.Throws<InvalidOperationException> (delegate {
spc.Add (child);
}, "child already added");
Assert.AreEqual (1, spc.Count, "Count-2");
Assert.Throws<InvalidOperationException> (delegate {
spc.Add (spc);
}, "child already added/2");
Assert.AreEqual (1, spc.Count, "Count-3");
}
/// <summary>
/// We just received (outsite event) and we want to draw and then delete the stroke.
/// </summary>
/// <param name="fullStroke">The full stroke.</param>
public void DrawStroke(Stroke fullStroke)
{
var nbPts = HowManyPointPerTick(fullStroke.StylusPoints.Count);
// Preparation of the pointer stroke
var points = new StylusPointCollection();
points.Add(fullStroke.StylusPoints[0]);
fullStroke.StylusPoints.RemoveAt(0);
var stroke = new Stroke(points);
var uid = Guid.NewGuid().GetHashCode();
toBeDrawed.Add(uid, new List<StylusPoint>());
foreach (var pt in fullStroke.StylusPoints)
toBeDrawed[uid].Add(pt);
// Replicates the drawing attributes of that stroke
stroke.DrawingAttributes = fullStroke.DrawingAttributes;
// Adding our new Stroke to the ViewModel
Application.Current.Dispatcher.BeginInvoke(
new Action(
() => { LS.PointerStrokes.Add(stroke); }
),
DispatcherPriority.Render
);
// Creation of the Timer who will add the points
var insertionTimer = new Timer(_quantum);
var deletionTimer = new Timer(_quantum);
// Preparation of the deletion timer, InsertionTimer will start it at the end
deletionTimer.Elapsed += (src, args) => TimedDeletion(
src,
new Tuple<StrokeCollection, Stroke, int>(
LS.PointerStrokes,
stroke,
nbPts));
insertionTimer.Elapsed += (src, args) => TimedInsertion(
src, new Tuple<Timer, int, StylusPointCollection, int>(
deletionTimer,
uid,
points,
nbPts));
insertionTimer.Start();
}
protected override void StylusInputBegin(StylusPointCollection stylusPoints, bool userInitiated)
{
_userInitiated = false;
//we only initialize to true if the first stylusPoints were user initiated
if (userInitiated)
{
_userInitiated = true;
}
_stylusPoints = new StylusPointCollection(stylusPoints.Description, 100);
_stylusPoints.Add(stylusPoints);
_strokeDrawingAttributes = this.InkCanvas.DefaultDrawingAttributes.Clone();
// Reset the dynamic renderer if it's been flagged.
if ( _resetDynamicRenderer )
{
InputDevice inputDevice = EditingCoordinator.GetInputDeviceForReset();
if ( InkCanvas.InternalDynamicRenderer != null && inputDevice != null )
{
StylusDevice stylusDevice = inputDevice as StylusDevice;
// If the input device is MouseDevice, null will be passed in Reset Method.
InkCanvas.InternalDynamicRenderer.Reset(stylusDevice, stylusPoints);
}
_resetDynamicRenderer = false;
}
// Call InvalidateBehaviorCursor at the end of the routine. The method will cause an external event fired.
// So it should be invoked after we set up our states.
EditingCoordinator.InvalidateBehaviorCursor(this);
}
public Correlation(TouchPoint2 points)
{
//Account for a degenerate amount of points
if (points.Stroke.StylusPoints.Count <= 1)
{
RSquared = 0;
Slope = 0;
Intercept = 0;
VerticalLine = false;
SlopeRad = 0;
return;
}
var pointlist = points.Stroke.StylusPoints;
//Remove duplicate points
var workingList = new StylusPointCollection();
for (int i = 1; i < pointlist.Count; i++ )
{
var point1 = pointlist[i - 1];
var point2 = pointlist[i];
if (!(point1.X == point2.X && point1.Y == point2.Y))
{
workingList.Add(point1);
}
}
VerticalLine = false;
xavg = 0;
yavg = 0;
foreach (var p in workingList)
{
xavg += p.X;
yavg += p.Y;
}
xavg = xavg / workingList.Count;
yavg = yavg / workingList.Count;
double numerator = 0;
double denominator = 0;
foreach (var p in workingList)
{
numerator += (p.X - xavg) * (p.Y - yavg);
denominator += Math.Pow(p.X - xavg,2);
}
SlopeRad = Math.Atan2(numerator, denominator);
if (denominator != 0)
{
Slope = numerator / denominator;
Intercept = yavg - Slope * xavg;
}
else
{
VerticalLine = true;
}
TouchPoint2 tp = points.GetEmptyCopy();
if(workingList.Count > 0)
tp.Stroke.StylusPoints = workingList;
RSquared = CalculateRSquared(tp);
}
// Generates a collection of strokes representing an entire word.
StrokeCollection GetStrokesForString(string text,
Dictionary<char, StylusToken> fontData)
{
double currentX = 0.0;
StrokeCollection stringStrokes = new StrokeCollection();
for (int i = 0; i < text.Length; i++)
{
char c = text[i];
if (fontData.Keys.Contains(c))
{
StylusToken token = fontData[c];
double kerningLeft = 2.0;
if (i > 0 && Char.ToLower(text[i - 1]) == text[i - 1] &&
Char.ToLower(c) == c)
kerningLeft += token.width * 0.14;
double kerningRight = 2.0;
if (i < text.Length - 1 && Char.ToLower(text[i + 1]) == text[i + 1] &&
Char.ToLower(c) == c)
kerningRight += token.width * 0.14;
foreach (Stroke stroke in token.strokes)
{
StylusPointCollection newPoints = new StylusPointCollection();
foreach (StylusPoint point in stroke.StylusPoints)
{
newPoints.Add(new StylusPoint(
point.X + currentX + kerningLeft, point.Y));
}
stringStrokes.Add(new Stroke(newPoints));
}
currentX += token.width + kerningLeft + kerningRight;
}
}
return stringStrokes;
}
private void PlaybackSession(object sender, RoutedEventArgs e)
{
playback = true;
Microsoft.Win32.OpenFileDialog dialogBox = new Microsoft.Win32.OpenFileDialog();
dialogBox.DefaultExt = ".xml";
Nullable<bool> result = dialogBox.ShowDialog();
String filename;
if (result == true)
{
filename = dialogBox.FileName;
if (File.Exists(filename))
{
XmlDocument xmlDoc = new XmlDocument();
//load xml file
xmlDoc.Load(filename);
XmlElement session = xmlDoc.DocumentElement;
XmlNodeList sceneNodes = session.GetElementsByTagName("Scene");
//begin playback
playback = true;
//load scenes listed in xml file
foreach (XmlNode currScene in sceneNodes)
{
XmlElement sceneNode = currScene as XmlElement;
String scenePath = currScene.Attributes.GetNamedItem("FilePath").Value;
StreamReader mysr = new StreamReader(scenePath);
LoadXAML(scenePath);
//InkCanvas sessionScene = LogicalTreeHelper.FindLogicalNode(rootObject, "scene") as InkCanvas;
//perform events on scene
XmlNode eventNode = sceneNode.GetElementsByTagName("Events").Item(0);
XmlNodeList events;
if (eventNode.HasChildNodes)
{
events = eventNode.ChildNodes;
}
else
{
continue;
}
foreach (XmlNode mtEvent in events)
{
String mtAction = mtEvent.Name;
if (mtAction == "InkStroke")
{
//get points
XmlNodeList mtInkPoints = mtEvent.ChildNodes;
StylusPoint defaultPoint;
StylusPointCollection defaultPoints = new StylusPointCollection();
Stroke mtStroke;
XmlElement inkPoint = mtInkPoints[0] as XmlElement;
String xVal = inkPoint.Attributes.GetNamedItem("X").Value;
String yVal = inkPoint.Attributes.GetNamedItem("Y").Value;
Double X = Convert.ToDouble(xVal);
Double Y = Convert.ToDouble(yVal);
defaultPoint = new StylusPoint(X, Y);
defaultPoints.Add(defaultPoint);
mtStroke = new Stroke(defaultPoints);
scene.Strokes.Add(mtStroke);
for (int i = 1; i < mtInkPoints.Count; i++)
{
inkPoint = mtInkPoints[i] as XmlElement;
xVal = inkPoint.Attributes.GetNamedItem("X").Value;
yVal = inkPoint.Attributes.GetNamedItem("Y").Value;
X = Convert.ToDouble(xVal);
Y = Convert.ToDouble(yVal);
//draw ink stroke one section at a time
mtStroke.StylusPoints.Add(new StylusPoint(X, Y));
//scene.Strokes.Remove(mtStroke);
//scene.Strokes.Add(mtStroke);
Refresh(scene);
}
}
else
{
XmlAttributeCollection attributes = mtEvent.Attributes;
Double X, Y, CenterX, CenterY, Rotation;
String elementName = attributes.GetNamedItem("Element").Value;
// objects = LogicalTreeHelper.GetChildren(scene);
Object mtElement = LogicalTreeHelper.FindLogicalNode(mtViewbox, elementName);
String objectType = mtElement.GetType().ToString();
UIElement currControl = new UIElement();
switch (objectType)
{
case "System.Windows.Controls.Image":
currControl = mtElement as Image;
break;
case "System.Windows.Controls.StackPanel":
currControl = mtElement as StackPanel;
break;
case "System.Windows.Controls.MediaElement":
currControl = mtElement as MediaElement;
break;
case "System.Windows.Controls.TextBlock":
currControl = mtElement as TextBlock;
break;
case "System.Windows.Shapes.Ellipse":
currControl = mtElement as Ellipse;
break;
case "System.Windows.Shapes.Rectangle":
currControl = mtElement as Rectangle;
break;
}
Matrix matrix = ((MatrixTransform)currControl.RenderTransform).Matrix;
switch (mtAction)
{
case "Rotate":
Rotation = Convert.ToDouble(attributes.GetNamedItem("Rotation").Value);
CenterX = Convert.ToDouble(attributes.GetNamedItem("CenterX").Value);
CenterY = Convert.ToDouble(attributes.GetNamedItem("CenterY").Value);
matrix.RotateAt(Rotation, CenterX, CenterY);
break;
case "Scale":
CenterX = Convert.ToDouble(attributes.GetNamedItem("CenterX").Value);
CenterY = Convert.ToDouble(attributes.GetNamedItem("CenterY").Value);
X = Convert.ToDouble(attributes.GetNamedItem("X").Value);
Y = Convert.ToDouble(attributes.GetNamedItem("Y").Value);
matrix.ScaleAt(X, Y, CenterX, CenterY);
break;
case "Translate":
X = Convert.ToDouble(attributes.GetNamedItem("X").Value);
Y = Convert.ToDouble(attributes.GetNamedItem("Y").Value);
matrix.Translate(X, Y);
break;
}
currControl.RenderTransform = new MatrixTransform(matrix);
bringElementToFront(currControl);
//currControl
Refresh(currControl);
}
System.Threading.Thread.Sleep(50);
}
}
//apply each action to the scene
}
}
}
private void ImageArea_MouseLeftButtonDown(object sender, MouseEventArgs e)
{
ImageArea.CaptureMouse();
var MyStylusPointCollection = new StylusPointCollection();
MyStylusPointCollection.Add(e.StylusDevice.GetStylusPoints(ImageArea));
_newStroke = new Stroke(MyStylusPointCollection);
_newStroke.DrawingAttributes.Color = (LocalizedStrings.LocalizedResources.FeedbackDrawingColor as string).ConvertStringToColor(Colors.Red);
ImageArea.Strokes.Add(_newStroke);
}
void GetBrush(StylusPointCollection pts, Action<StylusPointCollection> exec)
{
pts.Add(new StylusPoint(point.X, point.Y));
exec(pts);
}
private void AddSingleStrokeBasedNote(IdeationUnit strokeBasedIdea)
{
try
{
StrokeData ideaData = (StrokeData)(strokeBasedIdea.Content);
List<System.Windows.Point> strokePoints = ideaData.StrokePoints;
StylusPointCollection stylusPoints = new StylusPointCollection();
foreach (System.Windows.Point p in strokePoints)
{
StylusPoint stylusP = new StylusPoint(p.X, p.Y);
stylusPoints.Add(stylusP);
}
Stroke newStroke = new Stroke(stylusPoints);
if (!ideaData.IsErasingStroke)
{
newStroke.DrawingAttributes = DrawingCanvasModeSwitcher.normalDrawingAttribute.Clone();
newStroke.DrawingAttributes.Color = (System.Windows.Media.Color)System.Windows.Media.ColorConverter.ConvertFromString(ideaData.StrokeColorCode);
}
else
{
newStroke.DrawingAttributes = new DrawingAttributes();
newStroke.DrawingAttributes.Color = System.Windows.Media.Color.FromRgb(0, 0, 0);
newStroke.DrawingAttributes.Width = newStroke.DrawingAttributes.Height = 30;
}
drawingCanvas.Strokes.Add(newStroke);
}
catch (Exception ex)
{
Utilities.UtilitiesLib.LogError(ex);
}
}
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 void Deserialize(XmlNode xmlNode, FlowDocument flowDocument)
{
var strokes = new StrokeCollection();
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)));
}
strokes.Add(new Stroke(points)); //TODO DrawingAttributes
}
flowDocument.Blocks.Add(new PlotBlock(strokes));
}
public void Add_StylusPoint_Validation ()
{
StylusPointCollection spc = new StylusPointCollection ();
StylusPoint sp = new StylusPoint ();
spc.Add (sp);
Assert.AreEqual (1, spc.Count, "Count");
}
// TODO : add opacity
private void DrawFrame(Object sender, EventArgs e)
{
// Test if there are new strokes to draw, not started yet
while (remainingStrokes && strokesEnum.Current.Beginning == currentDrawing.CurrentFrame)
{
IEnumerator<Dot> temp = strokesEnum.Current.Enum;
temp.MoveNext();
dotPointerList.Add(temp);
remainingStrokes = strokesEnum.MoveNext();
}
List<IEnumerator<Dot>> toBeRemoved = new List<IEnumerator<Dot>>();
// Draw the current dots, linked to the previous ones
foreach (IEnumerator<Dot> Enumerator in dotPointerList)
{
Dot d = Enumerator.Current;
if (Enumerator.MoveNext())
{
Dot d2 = Enumerator.Current;
var strokePoints = new StylusPointCollection();
strokePoints.Add(new StylusPoint(d.X, d.Y));
strokePoints.Add(new StylusPoint(d2.X, d2.Y));
var drawingAttributes = new System.Windows.Ink.DrawingAttributes();
drawingAttributes.Color = d.GetColor();
drawingAttributes.Width = d.Radius;
drawingAttributes.Height = d.Radius;
Stroke stroke = new Stroke(strokePoints, drawingAttributes);
canvas.Strokes.Add(stroke);
}
else
{
toBeRemoved.Add(Enumerator);
}
}
// Remove the finished strokes
dotPointerList.RemoveAll(x => toBeRemoved.Contains(x));
currentDrawing.NewFrame();
if (!remainingStrokes && dotPointerList.Count() == 0)
{
drawTimer.Stop();
}
}
public void Add_StylusPoint_Collection_Validation ()
{
StylusPointCollection spc = new StylusPointCollection ();
// not an ArgumentNullException (or NRE)
Assert.Throws<ArgumentException> (delegate {
spc.Add ((StylusPointCollection) null);
}, "null");
}
/// <summary>
/// StylusInputBegin
/// </summary>
/// <param name="stylusPoints">stylusPoints</param>
/// <param name="userInitiated">true if the source eventArgs.UserInitiated flag was set to true</param>
protected override void StylusInputBegin(StylusPointCollection stylusPoints, bool userInitiated)
{
//
// get a disposable dynamic hit-tester and add event handler
//
_incrementalStrokeHitTester =
this.InkCanvas.Strokes.GetIncrementalStrokeHitTester(this.InkCanvas.EraserShape);
if ( InkCanvasEditingMode.EraseByPoint == _cachedEraseMode )
{
_incrementalStrokeHitTester.StrokeHit += new StrokeHitEventHandler(OnPointEraseResultChanged);
}
else
{
//we're in stroke hit test mode
_incrementalStrokeHitTester.StrokeHit += new StrokeHitEventHandler(OnStrokeEraseResultChanged);
}
_stylusPoints = new StylusPointCollection(stylusPoints.Description, 100);
_stylusPoints.Add(stylusPoints);
//
// start erasing
//
_incrementalStrokeHitTester.AddPoints(stylusPoints);
// NTRAID:WINDOWSOS#1642274-2006/05/10-WAYNEZEN,
// Since InkCanvas will ignore the animated tranforms when it receives the property changes.
// So we should update our cursor when the stylus is down if there are animated transforms applied to InkCanvas.
if ( InkCanvasEditingMode.EraseByPoint == _cachedEraseMode )
{
// Call InvalidateBehaviorCursor at the end of the routine. The method will cause an external event fired.
// So it should be invoked after we set up our states.
EditingCoordinator.InvalidateBehaviorCursor(this);
}
}
public void Add_StylusPointCollection_Empty ()
{
StylusPointCollection spc = new StylusPointCollection ();
StylusPointCollection child = new StylusPointCollection ();
spc.Add (child);
// twice
spc.Add (child);
// self
spc.Add (spc);
Assert.AreEqual (0, spc.Count, "Count-3");
}
