2020-04-14 00:42:04 +01:00
using System ;
using System.Collections.Generic ;
using System.Diagnostics ;
using System.Diagnostics.CodeAnalysis ;
using System.Linq ;
using Microsoft.Msagl.Core ;
using Microsoft.Msagl.Core.DataStructures ;
using Microsoft.Msagl.Core.Geometry ;
using Microsoft.Msagl.Core.Geometry.Curves ;
using Microsoft.Msagl.Core.Layout ;
using Microsoft.Msagl.Core.Routing ;
using Microsoft.Msagl.DebugHelpers ;
namespace Microsoft.Msagl.Routing.Spline.Bundling {
/// <summary>
/// this class nudges the edges
/// </summary>
internal class EdgeNudger : AlgorithmBase {
readonly BundlingSettings bundlingSettings ;
readonly MetroGraphData metroGraphData ;
IMetroMapOrderingAlgorithm metroOrdering ;
/// <summary>
/// Constructor
/// </summary>
internal EdgeNudger ( MetroGraphData metroGraphData , BundlingSettings bundlingSettings ) {
this . metroGraphData = metroGraphData ;
this . bundlingSettings = bundlingSettings ;
}
bool CreateUnderlyingPolylines {
get { return bundlingSettings . CreateUnderlyingPolyline ; }
}
protected override void RunInternal ( ) {
CreateMetroOrdering ( ) ;
InitRadii ( ) ;
FinalizePaths ( ) ;
}
void InitRadii ( ) {
new HubRadiiCalculator ( metroGraphData , bundlingSettings ) . CreateNodeRadii ( ) ;
}
/// <summary>
/// bundle-map ordering
/// </summary>
void CreateMetroOrdering ( ) {
if ( bundlingSettings . UseGreedyMetrolineOrdering )
metroOrdering = new GeneralMetroMapOrdering ( metroGraphData . Metrolines ) ;
else
metroOrdering = new LinearMetroMapOrdering ( metroGraphData . Metrolines , metroGraphData . PointToStations ) ;
}
void FinalizePaths ( ) {
CreateBundleBases ( ) ;
CreateSegmentsInsideHubs ( ) ;
#if DEBUG & & TEST_MSAGL
//ShowHubs(metroGraphData, metroOrdering, null);
#endif
CreateCurves ( ) ;
}
void CreateBundleBases ( ) {
var bbCalc = new BundleBasesCalculator ( metroOrdering , metroGraphData , bundlingSettings ) ;
bbCalc . Run ( ) ;
}
void CreateCurves ( ) {
Debug . Assert ( metroGraphData . Metrolines . Count = = metroGraphData . Edges . Length ) ;
for ( int i = 0 ; i < metroGraphData . Metrolines . Count ; i + + )
CreateCurveLine ( metroGraphData . Metrolines [ i ] , metroGraphData . Edges [ i ] ) ;
}
void CreateCurveLine ( Metroline line , EdgeGeometry edge ) {
var c = new Curve ( ) ;
Point start = FindCurveStart ( metroGraphData , metroOrdering , line ) ;
Point currentEnd = start ;
var hubSegsOfLine = HubSegsOfLine ( metroGraphData , metroOrdering , line ) ;
foreach ( var seg in hubSegsOfLine ) {
if ( seg = = null ) continue ;
c . AddSegment ( new LineSegment ( currentEnd , seg . Start ) ) ;
c . AddSegment ( seg ) ;
currentEnd = seg . End ;
}
c . AddSegment ( new LineSegment ( currentEnd , FindCurveEnd ( metroGraphData , metroOrdering , line ) ) ) ;
edge . Curve = c ;
if ( CreateUnderlyingPolylines )
edge . SmoothedPolyline = BuildUnderlyingPolyline ( start , currentEnd , hubSegsOfLine ) ;
}
static Point FindCurveStart ( MetroGraphData metroGraphData , IMetroMapOrderingAlgorithm metroOrdering , Metroline metroline ) {
Station u = metroGraphData . PointToStations [ metroline . Polyline . StartPoint . Point ] ;
Station v = metroGraphData . PointToStations [ metroline . Polyline . StartPoint . Next . Point ] ;
BundleBase bb = u . BundleBases [ v ] ;
int index = ( ! bb . IsParent ? metroOrdering . GetLineIndexInOrder ( v , u , metroline ) : metroOrdering . GetLineIndexInOrder ( u , v , metroline ) ) ;
return bb . Points [ index ] ;
}
static Point FindCurveEnd ( MetroGraphData metroGraphData , IMetroMapOrderingAlgorithm metroOrdering , Metroline metroline ) {
Station u = metroGraphData . PointToStations [ metroline . Polyline . EndPoint . Prev . Point ] ;
Station v = metroGraphData . PointToStations [ metroline . Polyline . EndPoint . Point ] ;
BundleBase bb = v . BundleBases [ u ] ;
int index = ( ! bb . IsParent ? metroOrdering . GetLineIndexInOrder ( u , v , metroline ) : metroOrdering . GetLineIndexInOrder ( v , u , metroline ) ) ;
return bb . Points [ index ] ;
}
internal static SmoothedPolyline BuildUnderlyingPolyline ( Point start , Point end , IEnumerable < ICurve > cubicSegsOfLine ) {
return null ;
/ * SmoothedPolyline sp = GetVanilaSmoothedPolyline ( cubicSegsOfLine , start , end ) ;
FleshOutSites ( sp . HeadSite , cubicSegsOfLine ) ;
return sp ; * /
}
static IEnumerable < ICurve > HubSegsOfLine ( MetroGraphData metroGraphData , IMetroMapOrderingAlgorithm metroOrdering , Metroline line ) {
for ( PolylinePoint i = line . Polyline . StartPoint . Next ; i . Next ! = null ; i = i . Next )
yield return SegOnLineVertex ( metroGraphData , metroOrdering , line , i ) ;
}
static ICurve SegOnLineVertex ( MetroGraphData metroGraphData , IMetroMapOrderingAlgorithm metroOrdering , Metroline line , PolylinePoint i ) {
Station u = metroGraphData . PointToStations [ i . Prev . Point ] ;
Station v = metroGraphData . PointToStations [ i . Point ] ;
BundleBase h0 = v . BundleBases [ u ] ;
int j0 = metroOrdering . GetLineIndexInOrder ( u , v , line ) ;
if ( h0 . OrientedHubSegments [ j0 ] = = null | | h0 . OrientedHubSegments [ j0 ] . Segment = = null ) {
var w = metroGraphData . PointToStations [ i . Next . Point ] ;
var otherBase = v . BundleBases [ w ] ;
var j1 = metroOrdering . GetLineIndexInOrder ( w , v , line ) ;
return new LineSegment ( h0 . Points [ j0 ] , otherBase . Points [ j1 ] ) ;
}
return h0 . OrientedHubSegments [ j0 ] . Segment ;
}
void CreateSegmentsInsideHubs ( ) {
foreach ( var metroline in metroGraphData . Metrolines )
CreateOrientedSegsOnLine ( metroline ) ;
if ( bundlingSettings . UseCubicBezierSegmentsInsideOfHubs )
FanBezierSegs ( ) ;
}
void CreateOrientedSegsOnLine ( Metroline line ) {
for ( PolylinePoint polyPoint = line . Polyline . StartPoint . Next ; polyPoint . Next ! = null ; polyPoint = polyPoint . Next )
CreateOrientedSegsOnLineVertex ( line , polyPoint ) ;
}
void CreateOrientedSegsOnLineVertex ( Metroline line , PolylinePoint polyPoint ) {
Station u = metroGraphData . PointToStations [ polyPoint . Prev . Point ] ;
Station v = metroGraphData . PointToStations [ polyPoint . Point ] ;
Station w = metroGraphData . PointToStations [ polyPoint . Next . Point ] ;
BundleBase h0 = v . BundleBases [ u ] ;
BundleBase h1 = v . BundleBases [ w ] ;
int j0 = metroOrdering . GetLineIndexInOrder ( u , v , line ) ;
int j1 = metroOrdering . GetLineIndexInOrder ( w , v , line ) ;
var seg = bundlingSettings . UseCubicBezierSegmentsInsideOfHubs ?
StandardBezier ( h0 . Points [ j0 ] , h0 . Tangents [ j0 ] , h1 . Points [ j1 ] , h1 . Tangents [ j1 ] ) :
BiArc ( h0 . Points [ j0 ] , h0 . Tangents [ j0 ] , h1 . Points [ j1 ] , h1 . Tangents [ j1 ] ) ;
h0 . OrientedHubSegments [ j0 ] . Segment = seg ;
h1 . OrientedHubSegments [ j1 ] . Segment = seg ;
}
#region Debug show
2020-06-04 01:36:55 +01:00
// #if DEBUG && TEST_MSAGL
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static internal void ShowHubs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering, Station station) {
// var ttt = GetAllDebugCurves(metroMapOrdering, metroGraphData);
// if (station != null)
// ttt = ttt.Concat(new[] { new DebugCurve(255, 3, "pink", CurveFactory.CreateDiamond(20, 20, station.Position)) });
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(ttt);
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static internal IEnumerable<DebugCurve> GetAllDebugCurves(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData) {
// return GraphNodes(metroGraphData).Concat(VertexDebugCurves(metroMapOrdering, metroGraphData)).Concat(DebugEdges(metroGraphData));
// }
//
// static IEnumerable<DebugCurve> DebugEdges(MetroGraphData metroGraphData1) {
// return metroGraphData1.Edges.Select(e => new DebugCurve(40, 0.1, "gray", e.Curve));
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> VertexDebugCurves(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData) {
// return DebugCircles(metroGraphData).Concat(DebugHubBases(metroGraphData)).
// Concat(DebugSegs(metroGraphData, metroMapOrdering)).
// Concat(BetweenHubs(metroMapOrdering, metroGraphData));
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> BetweenHubs(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData) {
// foreach (Metroline ml in metroGraphData.Metrolines) {
// List<Tuple<Point, Point>> segs = GetInterestingSegs(metroGraphData, metroMapOrdering, ml);
// string color = GetMonotoneColor(ml.Polyline.Start, ml.Polyline.End, segs);
// foreach (var seg in segs)
// yield return new DebugCurve(100, ml.Width, color, new LineSegment(seg.Item1, seg.Item2));
// }
// }
//
// static List<Tuple<Point, Point>> GetInterestingSegs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering, Metroline line) {
// var ret = new List<Tuple<Point, Point>>();
// Point start = FindCurveStart(metroGraphData, metroMapOrdering, line);
// var cubicSegs = HubSegsOfLine(metroGraphData, metroMapOrdering, line);
// foreach (var seg in cubicSegs) {
// if (seg == null) continue;
// ret.Add(new Tuple<Point, Point>(start, seg.Start));
// start = seg.End;
// }
// ret.Add(new Tuple<Point, Point>(start, FindCurveEnd(metroGraphData, metroMapOrdering, line)));
//
// return ret;
// }
//
// static string GetMonotoneColor(Point start, Point end, List<Tuple<Point, Point>> segs) {
// return "green";
// // Point dir = end - start;
// // bool monotone = segs.All(seg => (seg.Second - seg.First)*dir >= 0);
// // return monotone ? "green" : "magenta";
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> DebugHubBases(MetroGraphData metroGraphData) {
// List<DebugCurve> dc = new List<DebugCurve>();
// foreach (var s in metroGraphData.Stations)
// foreach (var h in s.BundleBases.Values) {
// dc.Add(new DebugCurve(100, 1, "red", new LineSegment(h.LeftPoint, h.RightPoint)));
// }
//
// return dc;
// //return
// // metroGraphData.Stations.SelectMany(s => s.BundleBases.Values).Select(
// // h => new DebugCurve(100, 0.01, "red", new LineSegment(h.Points[0], h.Points.Last())));
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> DebugCircles(MetroGraphData metroGraphData) {
// return
// metroGraphData.Stations.Select(
// station => new DebugCurve(100, 0.1, "blue", CurveFactory.CreateCircle(station.Radius, station.Position)));
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> DebugSegs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering) {
//
// var ls = new List<ICurve>();
// foreach (var s in metroGraphData.VirtualNodes()) {
// foreach (var b in s.BundleBases.Values) {
// foreach (var h in b.OrientedHubSegments) {
// if (h == null) continue;
// if (h.Segment == null) {
// var uBase = h.Other.BundleBase;
// var i = h.Index;
// var j = h.Other.Index;
// ls.Add(new LineSegment(b.Points[i], uBase.Points[j]));
// }
// else {
// ls.Add(h.Segment);
// }
// }
// }
// }
//
// return ls.Select(s => new DebugCurve(100, 0.01, "green", s));
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> GraphNodes(MetroGraphData metroGraphData) {
// var nodes =
// new Set<ICurve>(
// metroGraphData.Edges.Select(e => e.SourcePort.Curve).Concat(
// metroGraphData.Edges.Select(e => e.TargetPort.Curve)));
// return nodes.Select(n => new DebugCurve(40, 1, "black", n));
// }
// #endif
2020-04-14 00:42:04 +01:00
#endregion
#region BiArcs
/// <summary>
/// Following "Biarc approximation of NURBS curves", Les A. Piegl, and Wayne Tiller. The paper has a bug in V, where they write that v=p0+p4, it is p0-p4.
/// Also I treat special cases differently.
/// </summary>
/// <param name="p0"></param>
/// <param name="ts"></param>
/// <param name="p4"></param>
/// <param name="te"></param>
/// <returns></returns>
internal static ICurve BiArc ( Point p0 , Point ts , Point p4 , Point te ) {
Debug . Assert ( ApproximateComparer . Close ( ts . LengthSquared , 1 ) ) ;
Debug . Assert ( ApproximateComparer . Close ( te . LengthSquared , 1 ) ) ;
var v = p0 - p4 ;
if ( v . Length < ApproximateComparer . DistanceEpsilon )
return null ;
var vtse = v * ( ts - te ) ;
var tste = - ts * te ;
//solving a quadratic equation
var a = 2 * ( tste - 1 ) ;
var b = 2 * vtse ;
var c = v * v ;
double al ;
if ( Math . Abs ( a ) < ApproximateComparer . DistanceEpsilon ) { //we have b*al+c=0
if ( Math . Abs ( b ) > ApproximateComparer . DistanceEpsilon ) {
al = - c / b ;
}
else {
return null ;
}
}
else {
var d = b * b - 4 * a * c ;
Debug . Assert ( d > = - ApproximateComparer . Tolerance ) ;
if ( d < 0 )
d = 0 ;
d = Math . Sqrt ( d ) ;
al = ( - b + d ) / ( 2 * a ) ;
if ( al < 0 )
al = ( - b - d ) / ( 2 * a ) ;
}
var p1 = p0 + al * ts ;
var p3 = p4 + al * te ;
var p2 = 0.5 * ( p1 + p3 ) ;
var curve = new Curve ( ) ;
curve . AddSegs ( ArcOn ( p0 , p1 , p2 ) , ArcOn ( p2 , p3 , p4 ) ) ;
//bad input for BiArc. we shouldn't allow such cases during bundle bases construction
if ( ts * ( p4 - p0 ) < = 0 & & ts * te < = 0 ) {
//switch to Bezier
var curve2 = StandardBezier ( p0 , ts , p4 , te ) ;
#if DEBUG & & TEST_MSAGL
/ * List < DebugCurve > dc = new List < DebugCurve > ( ) ;
dc . Add ( new DebugCurve ( curve ) ) ;
dc . Add ( new DebugCurve ( 0.3 , "black" , curve2 ) ) ;
dc . Add ( new DebugCurve ( 0.1 , "red" , new LineSegment ( p0 , p0 + 3 * ts ) ) ) ;
dc . Add ( new DebugCurve ( 0.1 , "blue" , new LineSegment ( p4 , p4 + 3 * te ) ) ) ;
LayoutAlgorithmSettings . ShowDebugCurvesEnumeration ( dc ) ; * /
#endif
return curve2 ;
}
return curve ;
}
/// <summary>
/// returns the arc that a,b,c touches
/// </summary>
/// <param name="a">belongs to the arc, the tangent point of ba</param>
/// <param name="b">ba, and bc are tangents to the arc</param>
/// <param name="c">belongs to the arc, the tangent point of bc</param>
/// <returns></returns>
internal static ICurve ArcOn ( Point a , Point b , Point c ) {
Point center ;
if ( Math . Abs ( Point . SignedDoubledTriangleArea ( a , b , c ) ) < 0.0001 | | ! FindArcCenter ( a , b , c , out center ) )
return new LineSegment ( a , c ) ;
var radius = ( a - center ) . Length ;
var chordLength = ( a - b ) . Length ;
if ( chordLength / radius < 0.0001 ) //to avoid a floating point error
return new LineSegment ( a , c ) ;
var cenA = a - center ;
var aAngle = Math . Atan2 ( cenA . Y , cenA . X ) ;
var cenC = c - center ;
var cAngle = Math . Atan2 ( cenC . Y , cenC . X ) ;
var delac = cAngle - aAngle ;
if ( delac < 0 ) {
delac + = 2 * Math . PI ;
cAngle + = 2 * Math . PI ;
}
if ( delac < = Math . PI ) {
//going ccw
var el = new Ellipse ( aAngle , cAngle , new Point ( radius , 0 ) , new Point ( 0 , radius ) , center ) ;
return el ;
}
//going clockwise
if ( cAngle > 2 * Math . PI )
cAngle - = 2 * Math . PI ;
aAngle = Math . PI - aAngle ;
cAngle = Math . PI - cAngle ;
if ( aAngle < 0 )
aAngle + = 2 * Math . PI ;
while ( cAngle < aAngle )
cAngle + = 2 * Math . PI ;
delac = cAngle - aAngle ;
Debug . Assert ( delac < = Math . PI ) ;
return new Ellipse ( aAngle , cAngle , new Point ( - radius , 0 ) , new Point ( 0 , radius ) , center ) ;
}
static bool FindArcCenter ( Point a , Point b , Point c , out Point center ) {
var perp0 = ( b - a ) . Rotate90Cw ( ) ;
var perp1 = ( b - c ) . Rotate90Cw ( ) ;
return Point . LineLineIntersection ( a , a + perp0 , c , c + perp1 , out center ) ;
}
#endregion
#region Bezier segments
internal static CubicBezierSegment StandardBezier ( Point segStart , Point tangentAtStart , Point segEnd , Point tangentAtEnd ) {
double len = ( segStart - segEnd ) . Length / 4.0 ;
return new CubicBezierSegment ( segStart , segStart + tangentAtStart * len , segEnd + tangentAtEnd * len , segEnd ) ;
}
void FanBezierSegs ( ) {
bool progress = true ;
const int maxSteps = 5 ;
int steps = 0 ;
while ( progress & & steps + + < maxSteps ) {
progress = false ;
foreach ( Station s in metroGraphData . Stations )
foreach ( var segmentHub in s . BundleBases . Values )
progress | = FanEdgesOfHubSegment ( segmentHub ) ;
}
}
bool FanEdgesOfHubSegment ( BundleBase bundleHub ) {
bool ret = false ;
for ( int i = 0 ; i < bundleHub . Count - 1 ; i + + )
ret | = FanCouple ( bundleHub , i , bundleHub . CurveCenter , bundleHub . Curve . BoundingBox . Diagonal / 2 ) ;
return ret ;
}
/// <summary>
/// fans the couple i,i+1
/// </summary>
bool FanCouple ( BundleBase bundleHub , int i , Point center , double radius ) {
OrientedHubSegment lSeg = bundleHub . OrientedHubSegments [ i ] ;
OrientedHubSegment rSeg = bundleHub . OrientedHubSegments [ i + 1 ] ;
if ( lSeg = = null ) return false ;
Point x ;
if ( LineSegment . Intersect ( lSeg . Segment . Start , lSeg . Segment . End , rSeg . Segment . Start , rSeg . Segment . End , out x ) )
return false ; //it doesn not make sense to push these segs apart
if ( Point . GetTriangleOrientation ( lSeg [ 0 ] , lSeg [ 0.5 ] , lSeg [ 1 ] ) ! =
Point . GetTriangleOrientation ( rSeg [ 0 ] , rSeg [ 0.5 ] , rSeg [ 1 ] ) )
return false ;
double ll = BaseLength ( lSeg ) ;
double rl = BaseLength ( rSeg ) ;
if ( Math . Abs ( ll - rl ) < ApproximateComparer . IntersectionEpsilon )
return false ;
if ( ll > rl )
return AdjustLongerSeg ( lSeg , rSeg , center , radius ) ;
return AdjustLongerSeg ( rSeg , lSeg , center , radius ) ;
/ *
var del0 = lSeg . Start - rSeg . Start ;
var del1 = lSeg . End - rSeg . End ;
var desiredDelta = Math . Min ( del0 , del1 ) ;
var leftMiddle = lSeg [ 0.5 ] ;
var rightMiddle = rSeg [ 0.5 ] ;
if ( ( leftMiddle - rightMiddle ) . Length > = desiredDelta - ApproximateComparer . DistanceEpsilon )
return false ;
var leftMiddleToCenter = ( leftMiddle - BundleHub . Vertex ) . Length ;
var rightMiddleToCenter = ( rightMiddle - BundleHub . Vertex ) . Length ;
if ( leftMiddleToCenter > rightMiddleToCenter ) {
if ( MoveSegToDesiredDistance ( rightMiddle , lSeg , desiredDelta ) )
return true ;
} else if ( MoveSegToDesiredDistance ( leftMiddle , rSeg , desiredDelta ) )
return true ;
return false ; * /
}
bool AdjustLongerSeg ( OrientedHubSegment longerSeg , OrientedHubSegment shorterSeg , Point center ,
double radius ) {
Point del0 = longerSeg [ 0 ] - shorterSeg [ 0 ] ;
Point del1 = longerSeg [ 1 ] - shorterSeg [ 1 ] ;
double minDelLength = Math . Min ( del0 . Length , del1 . Length ) ;
Point midPointOfShorter = shorterSeg [ 0.5 ] ;
double maxDelLen = Math . Max ( del0 . Length , del1 . Length ) ;
if ( NicelyAligned ( ( CubicBezierSegment ) longerSeg . Segment , del0 , del1 , midPointOfShorter , minDelLength , maxDelLen ) = = 0 )
return false ;
return FitLonger ( longerSeg , del0 , del1 , midPointOfShorter , minDelLength , maxDelLen , center , radius ) ;
}
const double SqueezeBound = 0.2 ;
bool FitLonger ( OrientedHubSegment longerOrientedSeg , Point del0 , Point del1 , Point midPointOfShorter ,
double minDelLength , double maxDel , Point center , double radius ) {
CubicBezierSegment seg = ( CubicBezierSegment ) longerOrientedSeg . Segment ;
Point start = seg . Start ;
Point end = seg . End ;
// LayoutAlgorithmSettings.ShowDebugCurves(new DebugCurve("green", shorterDebugOnly), new DebugCurve("red", seg));
int steps = 0 ;
const int maxSteps = 10 ;
Point lowP1 = ( 1 - SqueezeBound ) * seg . Start + SqueezeBound * seg . B ( 1 ) ;
Point lowP2 = ( 1 - SqueezeBound ) * seg . End + SqueezeBound * seg . B ( 2 ) ;
Point highP1 = 2 * seg . B ( 1 ) - seg . Start ;
//originally the tangents were 0.25 of the length of seg[1]-seg[0] - so were are safe to lengthen two times
Point highP2 = 2 * seg . B ( 2 ) - seg . End ;
PullControlPointToTheCircle ( seg . Start , ref highP1 , center , radius ) ;
int r = NicelyAligned ( seg , del0 , del1 , midPointOfShorter , minDelLength , maxDel ) ;
do {
if ( r = = - 1 ) {
//pull the control points lower
Point p1 = ( seg . B ( 1 ) + lowP1 ) / 2 ;
Point p2 = ( seg . B ( 2 ) + lowP2 ) / 2 ;
highP1 = seg . B ( 1 ) ;
highP2 = seg . B ( 2 ) ;
seg = new CubicBezierSegment ( start , p1 , p2 , end ) ;
}
else {
Debug . Assert ( r = = 1 ) ;
//pull the control points higher
Point p1 = ( seg . B ( 1 ) + highP1 ) / 2 ;
Point p2 = ( seg . B ( 2 ) + highP2 ) / 2 ;
lowP1 = seg . B ( 1 ) ;
lowP2 = seg . B ( 2 ) ;
seg = new CubicBezierSegment ( start , p1 , p2 , end ) ;
}
if ( ( r = NicelyAligned ( seg , del0 , del1 , midPointOfShorter , minDelLength , maxDel ) ) = = 0 ) {
longerOrientedSeg . Other . Segment = longerOrientedSeg . Segment = seg ;
return true ;
}
if ( steps + + > maxSteps ) return false ; //cannot fix it
} while ( true ) ;
}
void PullControlPointToTheCircle ( Point start , ref Point highP , Point center , double radius ) {
Point closestPointOnLine = Point . ProjectionToLine ( start , highP , center ) ;
//the max offset from closestPointOnLine
double maxOffset = Math . Sqrt ( radius * radius - ( closestPointOnLine - center ) . LengthSquared ) ;
Point offsetNow = highP - closestPointOnLine ;
double offsetLen = offsetNow . Length ;
if ( offsetLen > maxOffset )
highP = closestPointOnLine + maxOffset * offsetNow / offsetLen ;
}
/// <summary>
///
/// </summary>
/// <param name="longerSeg"></param>
/// <param name="del0"></param>
/// <param name="del1"></param>
/// <param name="midPointOfShorter"></param>
/// <param name="minDelLength"></param>
/// <param name="maxDelLen"></param>
/// <returns> 1 - need to stretch, -1 - need to squeze, 0 - OK </returns>
int NicelyAligned ( CubicBezierSegment longerSeg , Point del0 , Point del1 , Point midPointOfShorter ,
double minDelLength , double maxDelLen ) {
const double eps = 0.001 ;
Point midDel = longerSeg [ 0.5 ] - midPointOfShorter ;
double midDelLen = midDel . Length ;
if ( del0 * midDel < 0 | | del1 * midDel < 0 )
return 1 ;
if ( midDelLen < minDelLength - eps )
return 1 ;
if ( midDelLen > maxDelLen + eps )
return - 1 ;
return 0 ;
}
double BaseLength ( OrientedHubSegment seg ) {
return ( seg [ 0 ] - seg [ 1 ] ) . LengthSquared ;
}
#endregion
}
}