diff --git a/mono/Assistance/Geometry.cs b/mono/Assistance/Geometry.cs index 13bca52..749c039 100644 --- a/mono/Assistance/Geometry.cs +++ b/mono/Assistance/Geometry.cs @@ -114,7 +114,10 @@ namespace Assistance { + t1*( 3.0*ll - 2.0*l ); } - public static Track.Point interpolationSpline(Track.Point p0, Track.Point p1, Track.Point t0, Track.Point t1, double l) { + public static Point interpolationLinear(Point p0, Point p1, double l) + { return p0*(1.0 - l) + p1*l; } + + public static Point interpolationSpline(Point p0, Point p1, Point t0, Point t1, double l) { double ll = l*l; double lll = ll*l; return p0*( 2.0*lll - 3.0*ll + 1.0) @@ -123,7 +126,7 @@ namespace Assistance { + t1*( lll - 1.0*ll ); } - public static Track.Point interpolationSplineTangent(Track.Point p0, Track.Point p1, Track.Point t0, Track.Point t1, double l) { + public static Point interpolationSplineTangent(Point p0, Point p1, Point t0, Point t1, double l) { double ll = l*l; return (p0 - p1)*6.0*(ll - l) + t0*( 3.0*ll - 4.0*l + 1.0) diff --git a/mono/Assistance/Guideline.cs b/mono/Assistance/Guideline.cs index b90545a..bc34af4 100644 --- a/mono/Assistance/Guideline.cs +++ b/mono/Assistance/Guideline.cs @@ -10,7 +10,7 @@ namespace Assistance { public static readonly double snapScale = 1.0; public static readonly double maxLenght = 20.0*snapLenght*snapScale; - public virtual Track.WayPoint transformPoint(Track.WayPoint point) + public virtual Track.Point transformPoint(Track.Point point) { return point; } public virtual void draw(Cairo.Context context, bool active) { } @@ -25,9 +25,9 @@ namespace Assistance { double sumLength = 0.0; double sumDeviation = 0.0; - Point prev = track.points[0].point.position; - foreach(Track.WayPoint wp in track.points) { - Point p = wp.point.position; + Point prev = track.points[0].position; + foreach(Track.Point tp in track.points) { + Point p = tp.position; double length = (p - prev).len(); sumLength += length; @@ -36,8 +36,8 @@ namespace Assistance { double weight = length*Geometry.logNormalDistribuitionUnscaled(midStepLength, snapLenght, snapScale); sumWeight += weight; - Track.WayPoint nwp = transformPoint(wp); - double deviation = (nwp.point.position - p).len(); + Track.Point ntp = transformPoint(tp); + double deviation = (ntp.position - p).len(); sumDeviation += weight*deviation; } prev = p; diff --git a/mono/Assistance/GuidelineLine.cs b/mono/Assistance/GuidelineLine.cs index 77c993d..ed7cbfc 100644 --- a/mono/Assistance/GuidelineLine.cs +++ b/mono/Assistance/GuidelineLine.cs @@ -26,10 +26,9 @@ namespace Assistance { context.Restore(); } - public override Track.WayPoint transformPoint(Track.WayPoint p) { - Track.WayPoint np = p; - np.point.position = Point.dot(p.point.position - p0, direction)*direction + p0; - np.tangent.position = direction; + public override Track.Point transformPoint(Track.Point p) { + Track.Point np = p; + np.position = Point.dot(p.position - p0, direction)*direction + p0; return np; } } diff --git a/mono/Assistance/InputManager.cs b/mono/Assistance/InputManager.cs index 02ebce9..1c595ac 100644 --- a/mono/Assistance/InputManager.cs +++ b/mono/Assistance/InputManager.cs @@ -270,32 +270,35 @@ namespace Assistance { return createTrack(b, device, touchId, ticks); } - private void addTrackPoint(Track track, Track.Point point, double time, bool final) { + private void addTrackPoint(Track track, Point position, double pressure, Point tilt, double time, bool final) { // fix time if (track.points.Count > 0) time = Math.Max(time, track.getLast().time + Timer.step); // calc length double length = track.points.Count > 0 - ? (point.position - track.getLast().point.position).len() + track.getLast().length + ? (position - track.getLast().position).len() + track.getLast().length : 0.0; // add - track.points.Add( new Track.WayPoint( - point, - new Track.Point(), + track.points.Add( new Track.Point( + position, + pressure, + tilt, (double)track.points.Count, time, - length, - track.points.Count, + length, final )); ++track.wayPointsAdded; } private void touchTracks(bool finish = false) { - foreach(Track track in tracks[0]) - if (!track.isFinished() && track.points.Count > 0) - addTrackPoint(track, track.getLast().point, track.getLast().time, finish); + foreach(Track track in tracks[0]) { + if (!track.isFinished() && track.points.Count > 0) { + Track.Point p = track.getLast(); + addTrackPoint(track, p.position, p.pressure, p.tilt, p.time, finish); + } + } paintTracks(); } @@ -331,12 +334,12 @@ namespace Assistance { { return tracks[modifiers.Count]; } - public void trackEvent(Gdk.Device device, long touchId, Track.Point point, bool final, long ticks) { + public void trackEvent(Gdk.Device device, long touchId, Point position, double pressure, Point tilt, bool final, long ticks) { if (isActive()) { Track track = getTrack(device, touchId, ticks); if (!track.isFinished()) { double time = (double)(ticks - track.keyHistory.ticks)*Timer.step - track.keyHistory.timeOffset; - addTrackPoint(track, point, time, final); + addTrackPoint(track, position, pressure, tilt, time, final); paintTracks(); } } @@ -433,16 +436,16 @@ namespace Assistance { int level = keyPointsSent; color.apply(context); - context.MoveTo(track.points[start].point.position.x, track.points[start].point.position.y); + context.MoveTo(track.points[start].position.x, track.points[start].position.y); for(int i = start + 1; i < track.points.Count; ++i) { while(level < handler.keys.Count && handler.keys[level] <= i) { context.Stroke(); - context.MoveTo(track.points[i-1].point.position.x, track.points[i-1].point.position.y); + context.MoveTo(track.points[i-1].position.x, track.points[i-1].position.y); color.a *= levelAlpha; color.apply(context); ++level; } - context.LineTo(track.points[i].point.position.x, track.points[i].point.position.y); + context.LineTo(track.points[i].position.x, track.points[i].position.y); } } } diff --git a/mono/Assistance/InputModifierAssistants.cs b/mono/Assistance/InputModifierAssistants.cs index 3a98ba1..c7273c6 100644 --- a/mono/Assistance/InputModifierAssistants.cs +++ b/mono/Assistance/InputModifierAssistants.cs @@ -20,8 +20,8 @@ namespace Assistance { public InputManager.KeyPoint.Holder holder = null; public List guidelines = new List(); - public override Track.WayPoint calcWayPoint(double originalIndex) { - Track.WayPoint p = base.calcWayPoint(originalIndex); + public override Track.Point calcPoint(double originalIndex) { + Track.Point p = base.calcPoint(originalIndex); return guidelines.Count > 0 ? guidelines[0].transformPoint(p) : p; } } @@ -36,7 +36,7 @@ namespace Assistance { Track.Handler handler = new Track.Handler(this, track); modifier = new Modifier(handler); - workarea.getGuidelines(modifier.guidelines, track.points[0].point.position); + workarea.getGuidelines(modifier.guidelines, track.points[0].position); if (defaultTangents && modifier.guidelines.Count == 0) { base.modify(track, keyPoint, outTracks); return; } @@ -89,7 +89,7 @@ namespace Assistance { // add points for(int i = start; i < track.points.Count; ++i) - subTrack.points.Add(modifier.calcWayPoint(i)); + subTrack.points.Add(modifier.calcPoint(i)); subTrack.wayPointsAdded = subTrack.points.Count - start; track.wayPointsRemoved = 0; @@ -107,7 +107,7 @@ namespace Assistance { if (track.handler == null) return; Track subTrack = track.handler.tracks[0]; if (subTrack.points.Count > 0) - drawHover(context, subTrack.getLast().point.position); + drawHover(context, subTrack.getLast().position); } } } diff --git a/mono/Assistance/InputModifierInterpolation.cs b/mono/Assistance/InputModifierInterpolation.cs index b6af59b..da499c1 100644 --- a/mono/Assistance/InputModifierInterpolation.cs +++ b/mono/Assistance/InputModifierInterpolation.cs @@ -13,10 +13,10 @@ namespace Assistance { this.precisionSqr = this.precision*this.precision; } - public void addSegment(Track track, Track.WayPoint p0, Track.WayPoint p1, int level = 0) { - if (level >= maxRecursion || (p1.point.position - p0.point.position).lenSqr() <= precisionSqr) + public void addSegment(Track track, Track.Point p0, Track.Point p1, int level = 0) { + if (level >= maxRecursion || (p1.position - p0.position).lenSqr() <= precisionSqr) { track.points.Add(p1); return; } - Track.WayPoint p = track.modifier.calcWayPoint(0.5*(p0.originalIndex + p1.originalIndex)); + Track.Point p = track.modifier.calcPoint(0.5*(p0.originalIndex + p1.originalIndex)); addSegment(track, p0, p, level + 1); addSegment(track, p, p1, level + 1); } @@ -49,9 +49,9 @@ namespace Assistance { } // add points - Track.WayPoint p0 = subTrack.modifier.calcWayPoint(start - 1); + Track.Point p0 = subTrack.modifier.calcPoint(start - 1); for(int i = start; i < track.points.Count; ++i) { - Track.WayPoint p1 = subTrack.modifier.calcWayPoint(i); + Track.Point p1 = subTrack.modifier.calcPoint(i); addSegment(subTrack, p0, p1); p0 = p1; } diff --git a/mono/Assistance/InputModifierTangents.cs b/mono/Assistance/InputModifierTangents.cs index 82f30ae..1846650 100644 --- a/mono/Assistance/InputModifierTangents.cs +++ b/mono/Assistance/InputModifierTangents.cs @@ -3,27 +3,57 @@ using System.Collections.Generic; namespace Assistance { public class InputModifierTangents: InputManager.Modifier { + public struct Tangent { + public Point position; + public double pressure; + public Point tilt; + + public Tangent( + Point position, + double pressure = 0.0, + Point tilt = new Point() ) + { + this.position = position; + this.pressure = pressure; + this.tilt = tilt; + } + } + public class Modifier: Track.Modifier { public Modifier(Track.Handler handler): base(handler) { } public InputManager.KeyPoint.Holder holder = null; - public readonly List tangents = new List(); + public readonly List tangents = new List(); - public override Track.WayPoint calcWayPoint(double originalIndex) { + public override Track.Point calcPoint(double originalIndex) { double frac; int i0 = original.floorIndex(originalIndex, out frac); int i1 = original.ceilIndex(originalIndex); - Track.WayPoint p0 = original.getWayPoint(i0); - Track.WayPoint p1 = original.getWayPoint(i1); - p0.tangent = tangents[i0]; - p1.tangent = tangents[i1]; - Track.WayPoint p = Track.interpolate(p0, p1, frac); + Track.Point p = i0 < 0 ? new Track.Point() + : interpolateSpline( + original.points[i0], + original.points[i1], + tangents[i0], + tangents[i1], + frac ); p.originalIndex = originalIndex; return p; } } + public static Track.Point interpolateSpline(Track.Point p0, Track.Point p1, Tangent t0, Tangent t1, double l) { + if (l <= Geometry.precision) return p0; + if (l >= 1.0 - Geometry.precision) return p1; + return new Track.Point( + Geometry.interpolationSpline(p0.position, p1.position, t0.position, t1.position, l), + Geometry.interpolationSpline(p0.pressure, p1.pressure, t0.pressure, t1.pressure, l), + Geometry.interpolationSpline(p0.tilt, p1.tilt, t0.tilt, t1.tilt, l), + Geometry.interpolationLinear(p0.originalIndex, p1.originalIndex, l), + Geometry.interpolationLinear(p0.time, p1.time, l), + Geometry.interpolationLinear(p0.length, p1.length, l) ); + } + public override void modify(Track track, InputManager.KeyPoint keyPoint, List outTracks) { if (track.handler == null) { track.handler = new Track.Handler(this, track); @@ -41,7 +71,7 @@ namespace Assistance { if (!track.isChanged && subTrack.points.Count == track.points.Count - 1) { // add temporary point - modifier.tangents.Add(new Track.Point()); + modifier.tangents.Add(new Tangent()); subTrack.points.Add(track.getLast()); ++subTrack.wayPointsAdded; } else { @@ -61,7 +91,7 @@ namespace Assistance { // add first point int index = start; if (index == 0) { - modifier.tangents.Add(new Track.Point()); + modifier.tangents.Add(new Tangent()); subTrack.points.Add(track.getLast()); ++index; } @@ -69,15 +99,17 @@ namespace Assistance { // add points with tangents if (track.points.Count > 2) { while(index < track.points.Count - 1) { - Track.WayPoint p = track.points[index]; - double t0 = track.points[index-1].time; - double t2 = track.points[index+1].time; - double dt = t2 - t0; - p.tangent = dt > Geometry.precision - ? (track.points[index+1].point - track.points[index-1].point)*(p.time - t0)/dt - : new Track.Point(); - modifier.tangents.Add(p.tangent); - subTrack.points.Add(p); + Track.Point p0 = track.points[index-1]; + Track.Point p1 = track.points[index]; + Track.Point p2 = track.points[index+1]; + double dt = p2.time - p0.time; + double k = dt > Geometry.precision ? (p1.time - p0.time)/dt : 0.0; + Tangent tangent = new Tangent( + (p2.position - p0.position)*k, + (p2.pressure - p0.pressure)*k, + (p2.tilt - p0.tilt)*k ); + modifier.tangents.Add(tangent); + subTrack.points.Add(p1); ++index; } } @@ -94,7 +126,7 @@ namespace Assistance { if (track.isFinished()) { // finish - modifier.tangents.Add(new Track.Point()); + modifier.tangents.Add(new Tangent()); subTrack.points.Add(track.getLast()); ++subTrack.wayPointsAdded; } else { diff --git a/mono/Assistance/MainWindow.cs b/mono/Assistance/MainWindow.cs index 6e66fd5..138d843 100644 --- a/mono/Assistance/MainWindow.cs +++ b/mono/Assistance/MainWindow.cs @@ -148,16 +148,9 @@ namespace Assistance { } void addTrackPoint(Gdk.Device device, Point p, double time, double pressure, Point tilt, bool final) { - if (!painting) - return; - - Track.Point point = new Track.Point(); - point.position = p; - point.pressure = pressure; - point.tilt = tilt; - + if (!painting) return; long ticks = ticksStart + (long)Math.Round((time - timeStart)*Timer.frequency); - workarea.inputManager.trackEvent(device, touchId, point, final, ticks); + workarea.inputManager.trackEvent(device, touchId, p, pressure, tilt, final, ticks); } void addTrackPoint(double x, double y, uint t, Gdk.Device device, double[] axes, bool final) { diff --git a/mono/Assistance/ModifierSnowflake.cs b/mono/Assistance/ModifierSnowflake.cs index 598da76..76fbd58 100644 --- a/mono/Assistance/ModifierSnowflake.cs +++ b/mono/Assistance/ModifierSnowflake.cs @@ -19,11 +19,10 @@ namespace Assistance { public InputManager.KeyPoint.Holder holder = null; public List guidelines = new List(); - public override Track.WayPoint calcWayPoint(double originalIndex) { - Track.WayPoint p = base.calcWayPoint(originalIndex); - Point pp = p.point.position - center; - p.point.position = center + new Point(Point.dot(pp, px), Point.dot(pp, py)); - p.tangent.position = new Point(Point.dot(p.tangent.position, px), Point.dot(p.tangent.position, py)); + public override Track.Point calcPoint(double originalIndex) { + Track.Point p = base.calcPoint(originalIndex); + Point pp = p.position - center; + p.position = center + new Point(Point.dot(pp, px), Point.dot(pp, py)); return p; } } @@ -78,7 +77,7 @@ namespace Assistance { // add points for(int i = start; i < track.points.Count; ++i) - subTrack.points.Add( subTrack.modifier.calcWayPoint(i) ); + subTrack.points.Add( subTrack.modifier.calcPoint(i) ); subTrack.wayPointsAdded += subTrack.points.Count - start; } diff --git a/mono/Assistance/ModifierSpiro.cs b/mono/Assistance/ModifierSpiro.cs index f1d31ba..6391e56 100644 --- a/mono/Assistance/ModifierSpiro.cs +++ b/mono/Assistance/ModifierSpiro.cs @@ -14,44 +14,27 @@ namespace Assistance { public class Modifier: Track.Modifier { public double angle; public double radius; + public double speed; - public Modifier(Track.Handler handler, double angle, double radius): - base(handler) { this.angle = angle; this.radius = radius; } - public override Track.WayPoint calcWayPoint(double originalIndex) { - Track.WayPoint p = base.calcWayPoint(originalIndex); + public Modifier(Track.Handler handler, double angle, double radius, double speed = 1.0): + base(handler) { this.angle = angle; this.radius = radius; this.speed = speed; } + + public override Track.Point calcPoint(double originalIndex) { + Track.Point p = base.calcPoint(originalIndex); + double frac; + int i0 = original.floorIndex(originalIndex, out frac); + int i1 = original.ceilIndex(originalIndex); + if (i0 < 0) return p; + Handler handler = (Handler)this.handler; - double frac, a0, a1; - Point p0, p1; - int i = original.floorIndex(originalIndex, out frac); - if (frac > Geometry.precision) { - a0 = handler.angles[i]; - a1 = handler.angles[i+1]; - p0 = original.points[i].point.position; - p1 = original.points[i+1].point.position; - } else - if (i > 0) { - a0 = handler.angles[i-1]; - a1 = handler.angles[i]; - p0 = original.points[i-1].point.position; - p1 = original.points[i].point.position; - frac = 1.0; - } else { - a0 = handler.angles[i]; - a1 = handler.angles[i]; - p0 = original.points[i].point.position; - p1 = original.points[i].point.position; - } - - double angle = Geometry.interpolationLinear(a0, a1, frac) + this.angle; - double da = a1 - a0; - - double radius = 2.0*this.radius*p.point.pressure; + double angle = this.angle + speed*Geometry.interpolationLinear( + handler.angles[i0], handler.angles[i1], frac); + double radius = 2.0*this.radius*p.pressure; double s = Math.Sin(angle); double c = Math.Cos(angle); - p.point.position += new Point(c, s)*radius; - p.tangent.position = ((p1 - p0) + new Point(-s, c)*radius*(a1 - a0)).normalize(); + p.position += new Point(c, s)*radius; return p; } } @@ -91,8 +74,8 @@ namespace Assistance { for(int i = start; i < track.points.Count; ++i) { if (i > 0) { double dl = track.points[i].length - track.points[i-1].length; - double da = track.points[i].point.pressure > Geometry.precision - ? 0.25*dl/(2.0*radius*track.points[i].point.pressure) : 0.0; + double da = track.points[i].pressure > Geometry.precision + ? 0.25*dl/(2.0*radius*track.points[i].pressure) : 0.0; handler.angles.Add(handler.angles[i-1] + da); } else { handler.angles.Add(0.0); @@ -121,10 +104,10 @@ namespace Assistance { double step = segmentSize/Math.Abs(nextAngle - prevAngle); double end = 1.0 - 0.5*step; for(double frac = step; frac < end; frac += step) - subTrack.points.Add( subTrack.modifier.calcWayPoint((double)i - 1.0 + frac) ); + subTrack.points.Add( subTrack.modifier.calcPoint((double)i - 1.0 + frac) ); } } - subTrack.points.Add( subTrack.modifier.calcWayPoint(i) ); + subTrack.points.Add( subTrack.modifier.calcPoint(i) ); } subTrack.wayPointsAdded += subTrack.points.Count - subStart; } diff --git a/mono/Assistance/ToolFull.cs b/mono/Assistance/ToolFull.cs index 391e9fb..0ca178f 100644 --- a/mono/Assistance/ToolFull.cs +++ b/mono/Assistance/ToolFull.cs @@ -25,15 +25,14 @@ namespace Assistance { return true; } - private void paintPoint(DynamicSurface surface, Track.WayPoint point) { - Point p = point.point.position; - double r = pen.width*point.point.pressure; + private void paintPoint(DynamicSurface surface, Track.Point point) { + Point p = point.position; + double r = pen.width*point.pressure; Drawing.Color color = pen.color; if (r < 0.01) r = 0.01; if (r > Geometry.precision && r < 0.5) { color.a *= r/0.5; r = 0.5; } double rr = r + 1.0; - //rr += 10.0*(Math.Abs(point.tangent.position.x) + Math.Abs(point.tangent.position.y)) surface.expand(new Rectangle(p.x - rr, p.y - rr, p.x + rr, p.y + rr)); @@ -43,14 +42,6 @@ namespace Assistance { surface.context.Arc(p.x, p.y, r, 0.0, 2.0*Math.PI); surface.context.Fill(); - //pen.apply(surface.context); - //color.a = 0.5; - //color.apply(surface.context); - //surface.context.LineWidth = 0.5; - //surface.context.MoveTo(p.x, p.y); - //surface.context.RelLineTo(-10.0*point.tangent.position.y, 10.0*point.tangent.position.x); - //surface.context.Stroke(); - surface.context.Restore(); } diff --git a/mono/Assistance/Track.cs b/mono/Assistance/Track.cs index 75d81f7..fdff864 100644 --- a/mono/Assistance/Track.cs +++ b/mono/Assistance/Track.cs @@ -26,8 +26,8 @@ namespace Assistance { { get { return handler.owner; } } public Track original { get { return handler.original; } } - public virtual WayPoint calcWayPoint(double originalIndex) { - WayPoint p = original.calcWayPoint(originalIndex); + public virtual Point calcPoint(double originalIndex) { + Point p = original.calcPoint(originalIndex); p.originalIndex = originalIndex; return p; } @@ -37,66 +37,28 @@ namespace Assistance { public Assistance.Point position; public double pressure; public Assistance.Point tilt; - - public Point( - Assistance.Point position, - double pressure, - Assistance.Point tilt - ) { - this.position = position; - this.pressure = pressure; - this.tilt = tilt; - } - - public static Point operator+ (Point a, Point b) - { return new Point(a.position + b.position, a.pressure + b.pressure, a.tilt + b.tilt); } - public static Point operator- (Point a, Point b) - { return new Point(a.position - b.position, a.pressure - b.pressure, a.tilt - b.tilt); } - public static Point operator* (Point a, double b) - { return new Point(a.position*b, a.pressure*b, a.tilt*b); } - public static Point operator* (double a, Point b) - { return a*b; } - public static Point operator/ (Point a, double b) - { return a*(1.0/b); } - - public bool isEqual(Point other) { - return position.isEqual(other.position) - && Geometry.isEqual(pressure, other.pressure) - && tilt.isEqual(other.tilt); - } - - public Point normalize() { - double l = position.len(); - return l > Geometry.precision ? this/l : this; - } - } - - public struct WayPoint { - public Point point; - public Point tangent; public double originalIndex; public double time; public double length; - public int depRootIndex; public bool final; - public WayPoint( - Point point, - Point tangent = new Point(), + public Point( + Assistance.Point position, + double pressure = 0.5, + Assistance.Point tilt = new Assistance.Point(), double originalIndex = 0.0, double time = 0.0, double length = 0.0, - int depRootIndex = 0, bool final = false ) { - this.point = point; - this.tangent = tangent; + this.position = position; + this.pressure = pressure; + this.tilt = tilt; this.originalIndex = originalIndex; this.time = time; this.length = length; - this.depRootIndex = depRootIndex; this.final = final; } } @@ -107,7 +69,7 @@ namespace Assistance { public readonly long id; public readonly Gdk.Device device; public readonly long touchId; - public readonly List points = new List(); + public readonly List points = new List(); public readonly KeyHistory.Holder keyHistory; public readonly KeyHistory.Holder buttonHistory; @@ -152,10 +114,10 @@ namespace Assistance { public int getLevel() { return original == null ? 0 : original.getLevel() + 1; } - public WayPoint getFirst() - { return getWayPoint(0); } - public WayPoint getLast() - { return getWayPoint(points.Count - 1); } + public Point getFirst() + { return getPoint(0); } + public Point getLast() + { return getPoint(points.Count - 1); } public bool isFinished() { return points.Count > 0 && getLast().final; } @@ -179,19 +141,19 @@ namespace Assistance { public int ceilIndex(double index) { return clampIndex(ceilIndexNoClamp(index)); } - public WayPoint getWayPoint(int index) { + public Point getPoint(int index) { index = clampIndex(index); - return index < 0 ? new WayPoint() : points[index]; + return index < 0 ? new Point() : points[index]; } - public WayPoint floorWayPoint(double index, out double frac) - { return getWayPoint(floorIndex(index, out frac)); } - public WayPoint floorWayPoint(double index) - { return getWayPoint(floorIndex(index)); } - public WayPoint ceilWayPoint(double index) - { return getWayPoint(ceilIndex(index)); } + public Point floorPoint(double index, out double frac) + { return getPoint(floorIndex(index, out frac)); } + public Point floorPoint(double index) + { return getPoint(floorIndex(index)); } + public Point ceilPoint(double index) + { return getPoint(ceilIndex(index)); } - private delegate double WayPointFieldGetter(WayPoint p); - private double binarySearch(double value, WayPointFieldGetter getter) { + private delegate double PointFieldGetter(Point p); + private double binarySearch(double value, PointFieldGetter getter) { // points[a].value <= value < points[b].value if (points.Count <= 0) return 0.0; @@ -215,59 +177,59 @@ namespace Assistance { } public double indexByOriginalIndex(double originalIndex) - { return binarySearch(originalIndex, delegate(WayPoint p) { return p.originalIndex; }); } + { return binarySearch(originalIndex, delegate(Point p) { return p.originalIndex; }); } public double indexByTime(double time) - { return binarySearch(time, delegate(WayPoint p) { return p.time; }); } + { return binarySearch(time, delegate(Point p) { return p.time; }); } public double indexByLength(double length) - { return binarySearch(length, delegate(WayPoint p) { return p.length; }); } + { return binarySearch(length, delegate(Point p) { return p.length; }); } public double originalIndexByIndex(double index) { double frac; - WayPoint p0 = floorWayPoint(index, out frac), p1 = ceilWayPoint(index); + Point p0 = floorPoint(index, out frac), p1 = ceilPoint(index); return Geometry.interpolationLinear(p0.originalIndex, p1.originalIndex, frac); } public double timeByIndex(double index) { double frac; - WayPoint p0 = floorWayPoint(index, out frac), p1 = ceilWayPoint(index); + Point p0 = floorPoint(index, out frac), p1 = ceilPoint(index); return Geometry.interpolationLinear(p0.time, p1.time, frac); } public double lengthByIndex(double index) { double frac; - WayPoint p0 = floorWayPoint(index, out frac), p1 = ceilWayPoint(index); + Point p0 = floorPoint(index, out frac), p1 = ceilPoint(index); return Geometry.interpolationLinear(p0.length, p1.length, frac); } - public WayPoint calcWayPoint(double index) { + public Point calcPoint(double index) { return modifier == null - ? interpolate(index) - : modifier.calcWayPoint( originalIndexByIndex(index) ); + ? interpolateLinear(index) + : modifier.calcPoint( originalIndexByIndex(index) ); } - public WayPoint interpolate(double index) { + public Point interpolateLinear(double index) { double frac; - WayPoint p0 = floorWayPoint(index, out frac); - WayPoint p1 = ceilWayPoint(index); - return interpolate(p0, p1, frac); + Point p0 = floorPoint(index, out frac); + Point p1 = ceilPoint(index); + return interpolateLinear(p0, p1, frac); } - public static WayPoint interpolate(WayPoint p0, WayPoint p1, double l) { + public static Point interpolateLinear(Point p0, Point p1, double l) { if (l <= Geometry.precision) return p0; if (l >= 1.0 - Geometry.precision) return p1; - return new WayPoint( - Geometry.interpolationSpline(p0.point, p1.point, p0.tangent, p1.tangent, l), - Geometry.interpolationSplineTangent(p0.point, p1.point, p0.tangent, p1.tangent, l), + return new Point( + Geometry.interpolationLinear(p0.position, p1.position, l), + Geometry.interpolationLinear(p0.pressure, p1.pressure, l), + Geometry.interpolationLinear(p0.tilt, p1.tilt, l), Geometry.interpolationLinear(p0.originalIndex, p1.originalIndex, l), Geometry.interpolationLinear(p0.time, p1.time, l), - Geometry.interpolationLinear(p0.length, p1.length, l), - p1.depRootIndex ); + Geometry.interpolationLinear(p0.length, p1.length, l) ); } public void print() { - foreach(WayPoint wp in points) + foreach(Point wp in points) Console.Write( "{2:f1}, ", - wp.point.position.x, - wp.point.position.y, + wp.position.x, + wp.position.y, wp.originalIndex ); Console.WriteLine(); }