/*
* Annotated scaffolding
*
*/
public static void FromPointsToLineSegment(LineSegmentSymbol lss)
{
var ls = lss.Shape as LineSegment;
Debug.Assert(ls != null);
var pt1Symbol = new PointSymbol(ls.Pt1);
var pt2Symbol = new PointSymbol(ls.Pt2);
string strategy;
TraceStep ts00 = new TraceStep(null, pt1Symbol, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(pt1Symbol));
TraceStep ts01 = new TraceStep(null, pt2Symbol, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(pt2Symbol));
TraceStep ts02 = null;
if (ls.Pt1.Concrete && ls.Pt2.Concrete)
{
ts02 = new TraceStep(null, lss, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(lss));
}
strategy = "Plot a Line Segment passing through two points.";
lss._innerLoop.Add(ts00);
lss._innerLoop.Add(ts01);
if (ts02 != null)
{
lss._innerLoop.Add(ts02);
}
lss.GenerateATrace(strategy);
/* string stepMetaRule = "Consider draw a line segment passing through the two points.";
string stepAppliedRule = String.Format("Draw the line segment passing through two points {0} and {1}",
pt1Symbol, pt2Symbol);
var traceStep = new TraceStep(null, lss, stepMetaRule, stepAppliedRule);
lss._innerLoop.Add(traceStep);*/
}
/*
* Annotated scaffolding
*
*/
public static void FromPointsToLineSegment(LineSegmentSymbol lss)
{
var ls = lss.Shape as LineSegment;
Debug.Assert(ls != null);
var pt1Symbol = new PointSymbol(ls.Pt1);
var pt2Symbol = new PointSymbol(ls.Pt2);
string strategy;
TraceStep ts00 = new TraceStep(null, pt1Symbol, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(pt1Symbol));
TraceStep ts01 = new TraceStep(null, pt2Symbol, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(pt2Symbol));
TraceStep ts02 = null;
if (ls.Pt1.Concrete && ls.Pt2.Concrete)
{
ts02 = new TraceStep(null, lss, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(lss));
}
strategy = "Plot a Line Segment passing through two points.";
lss._innerLoop.Add(ts00);
lss._innerLoop.Add(ts01);
if (ts02 != null)
{
lss._innerLoop.Add(ts02);
}
lss.GenerateATrace(strategy);
/* string stepMetaRule = "Consider draw a line segment passing through the two points.";
* string stepAppliedRule = String.Format("Draw the line segment passing through two points {0} and {1}",
* pt1Symbol, pt2Symbol);
*
* var traceStep = new TraceStep(null, lss, stepMetaRule, stepAppliedRule);
* lss._innerLoop.Add(traceStep);*/
}
//forward solving
private static object InferDistance(this LineSegmentSymbol inputLineSymbol, string label)
{
var lineSeg = inputLineSymbol.Shape as LineSegment;
Debug.Assert(lineSeg != null);
if (label != null && lineSeg.Distance != null)
{
var goal = new EqGoal(new Var(label), lineSeg.Distance);
TraceInstructionalDesign.FromLineSegmentToDistance(inputLineSymbol);
goal.Traces.AddRange(inputLineSymbol.Traces);
return(goal);
}
if (label != null && inputLineSymbol.CachedSymbols.Count != 0)
{
var goalList = new List <object>();
foreach (var lss in inputLineSymbol.CachedSymbols)
{
var cachedLss = lss as LineSegmentSymbol;
Debug.Assert(cachedLss != null);
var cachedLs = cachedLss.Shape as LineSegment;
Debug.Assert(cachedLs != null);
var goal = new EqGoal(new Var(label), cachedLs.Distance);
//goal.Traces.AddRange(cachedLss.Traces);
TraceInstructionalDesign.FromLineSegmentToDistance(cachedLss);
goal.Traces.AddRange(cachedLss.Traces);
goalList.Add(goal);
}
return(goalList);
}
return(null);
}
public void Test_Unify()
{
var x = new Var("x");
var pt1 = new Point(x, 2.0);
var pt2 = new Point(3.0, 5.0);
var ls = new LineSegment(pt1, pt2);
var lss = new LineSegmentSymbol(ls);
var d = new Var("d");
var eqGoal = new EqGoal(d, 5);
object obj;
bool result = lss.UnifyProperty(eqGoal, out obj);
Assert.True(result);
var lst = obj as List <object>;
Assert.NotNull(lst);
Assert.True(lst.Count == 2);
var gGoal1 = lst[0] as EqGoal;
Assert.NotNull(gGoal1);
Assert.True(gGoal1.Lhs.ToString().Equals("x"));
Assert.True(gGoal1.Rhs.ToString().Equals("7"));
Assert.True(gGoal1.Traces.Count == 3);
var gGoal2 = lst[1] as EqGoal;
Assert.NotNull(gGoal2);
Assert.True(gGoal2.Lhs.ToString().Equals("x"));
Assert.True(gGoal2.Rhs.ToString().Equals("-1"));
// Assert.True(gGoal2.Traces.Count == 1);
}
public static LineSegmentSymbol GenerateLineSegment(Point pt1, Point pt2)
{
if (pt1.Equals(pt2)) return null;
Debug.Assert(pt1.Concrete);
Debug.Assert(pt2.Concrete);
var ls = new LineSegment(pt1, pt2);
var lss = new LineSegmentSymbol(ls);
if(pt1.Traces.Count != 0) lss.Traces.AddRange(pt1.Traces);
if(pt2.Traces.Count != 0) lss.Traces.AddRange(pt2.Traces);
TraceInstructionalDesign.FromPointsToLineSegment(lss);
return lss;
}
public void Problem01()
{
/* const string input1 = "A(2,0)";
* const string input2 = "B(5,4)";*/
var pt1 = new Point(2, 0);
var ps1 = new PointSymbol(pt1);
var pt2 = new Point(5, 4);
var ps2 = new PointSymbol(pt2);
var d = new Var("d");
var eqGoal = new EqGoal(d, 5);
var ls = new LineSegment(pt1, pt2);
var lss = new LineSegmentSymbol(ls);
TraceInstructionalDesign.FromPointsToLineSegment(lss);
TraceInstructionalDesign.FromLineSegmentToDistance(lss);
}
/*
* Automatic scaffolding
*
* Distance function (x-x0)^2+(y-y0)^2 = d^2
*
* Forward chaining to derive d.
* Backward chaining to derive other four parameters.
*/
private static Tuple<object, object> DistanceSubstitution(LineSegmentSymbol lss)
{
var ls = lss.Shape as LineSegment;
var lst = new List<TraceStep>();
string step1metaRule = "The Distance Function between two points it: d^2=(x0-x1)^2+(y0-y1)^2";
string step1AppliedRule = String.Format(
"Substitute two points into the distance function d^2=({0}-{1})^2+({2}-{3})^2",
ls.Pt1.XCoordinate.ToString(),
ls.Pt2.XCoordinate.ToString(),
ls.Pt1.YCoordinate.ToString(),
ls.Pt2.YCoordinate.ToString());
var pt1X = new Var("x0");
var pt1Y = new Var("y0");
var pt2X = new Var("x1");
var pt2Y = new Var("y1");
var term1_1 = new Term(Expression.Subtract, new List<object>() { pt1X, pt2X });
var term11_1 = new Term(Expression.Power, new List<object>() { term1_1, 2.0 });
var term2_1 = new Term(Expression.Subtract, new List<object>() { pt1Y, pt2Y });
var term22_1 = new Term(Expression.Power, new List<object>() { term2_1, 2.0 });
var rhs_1 = new Term(Expression.Add, new List<object>() { term11_1, term22_1 });
var variable = new Var('d');
var lhs = new Term(Expression.Power, new List<object>() { variable, 2.0 });
var term1 = new Term(Expression.Subtract, new List<object>() { ls.Pt1.XCoordinate, ls.Pt2.XCoordinate });
var term11 = new Term(Expression.Power, new List<object>() { term1, 2.0 });
var term2 = new Term(Expression.Subtract, new List<object>() { ls.Pt1.YCoordinate, ls.Pt2.YCoordinate });
var term22 = new Term(Expression.Power, new List<object>() { term2, 2.0 });
var rhs = new Term(Expression.Add, new List<object>() { term11, term22 });
var eq = new Equation(lhs, rhs);
var old_eq = new Equation(lhs, rhs_1);
var trace = new TraceStep(old_eq, eq, GeometryScaffold.KC_Distance, step1metaRule, step1AppliedRule);
lst.Add(trace);
string strategy = "Substitute two points coordinates into the distance function.";
var newTuple = new Tuple<object, object>(strategy, lst);
return newTuple;
}
public static LineSegmentSymbol GenerateLineSegment(Point pt1, Point pt2)
{
if (pt1.Equals(pt2))
{
return(null);
}
Debug.Assert(pt1.Concrete);
Debug.Assert(pt2.Concrete);
var ls = new LineSegment(pt1, pt2);
var lss = new LineSegmentSymbol(ls);
if (pt1.Traces.Count != 0)
{
lss.Traces.AddRange(pt1.Traces);
}
if (pt2.Traces.Count != 0)
{
lss.Traces.AddRange(pt2.Traces);
}
TraceInstructionalDesign.FromPointsToLineSegment(lss);
return(lss);
}
public static object Unify(this LineSegmentSymbol lss, object constraint)
{
var label = constraint as string;
var eqGoal = constraint as EqGoal;
//forward solving
if (label != null)
{
switch (label)
{
case LineSegmentAcronym.Distance1:
case LineSegmentAcronym.Distance2:
return(lss.InferDistance(label));
}
}
//backward solving
if (eqGoal != null)
{
var rhs = eqGoal.Rhs;
double dNum;
bool isDouble = LogicSharp.IsDouble(rhs, out dNum);
if (!isDouble)
{
return(null);
}
var lhs = eqGoal.Lhs.ToString();
switch (lhs)
{
case LineSegmentAcronym.Distance1:
case LineSegmentAcronym.Distance2:
return(lss.InferDistance(dNum));
}
}
return(null);
}
private LineSegmentSymbol MockSegment()
{
var pt1 = new Point("A", 2, 0);
var pt2 = new Point("B", 5, 4);
var seg = new LineSegment("AB", pt1, pt2);
var segSymbol = new LineSegmentSymbol(seg);
return segSymbol;
}
public void Test_Unify()
{
var x = new Var("x");
var pt1 = new Point(x, 2.0);
var pt2 = new Point(3.0, 5.0);
var ls = new LineSegment(pt1, pt2);
var lss = new LineSegmentSymbol(ls);
var d = new Var("d");
var eqGoal = new EqGoal(d, 5);
object obj;
bool result = lss.UnifyProperty(eqGoal, out obj);
Assert.True(result);
var lst = obj as List<object>;
Assert.NotNull(lst);
Assert.True(lst.Count == 2);
var gGoal1 = lst[0] as EqGoal;
Assert.NotNull(gGoal1);
Assert.True(gGoal1.Lhs.ToString().Equals("x"));
Assert.True(gGoal1.Rhs.ToString().Equals("7"));
Assert.True(gGoal1.Traces.Count == 3);
var gGoal2 = lst[1] as EqGoal;
Assert.NotNull(gGoal2);
Assert.True(gGoal2.Lhs.ToString().Equals("x"));
Assert.True(gGoal2.Rhs.ToString().Equals("-1"));
// Assert.True(gGoal2.Traces.Count == 1);
}
//backward chaining
public static object FromLineSegmentToDistance(LineSegmentSymbol lss, double value)
{
//0. Plotting existing knowledge
//1. Substitute two points coordinates into the distance function.
//2. Manipulate the expression to derive the goal.
////////////////////////////////////////////////////////
var ls = lss.Shape as LineSegment;
Debug.Assert(ls != null);
FromPointsToLineSegment(lss);
var term1_1 = new Term(Expression.Multiply, new List <object>()
{
-1, ls.Pt2.XCoordinate
});
var term1 = new Term(Expression.Add, new List <object>()
{
ls.Pt1.XCoordinate, term1_1
});
var term11 = new Term(Expression.Power, new List <object>()
{
term1, 2.0
});
var term2_2 = new Term(Expression.Multiply, new List <object>()
{
-1, ls.Pt2.YCoordinate
});
var term2 = new Term(Expression.Add, new List <object>()
{
ls.Pt1.YCoordinate, term2_2
});
var term22 = new Term(Expression.Power, new List <object>()
{
term2, 2.0
});
var rhs = new Term(Expression.Add, new List <object>()
{
term11, term22
});
var lhs = new Term(Expression.Power, new List <object>()
{
value, 2.0
});
var eq = new Equation(lhs, rhs);
object obj1;
bool result = eq.IsEqGoal(out obj1);
if (result)
{
var lst = obj1 as List <object>;
if (lst != null)
{
foreach (object tempObj in lst)
{
var gGoal = tempObj as EqGoal;
if (gGoal != null)
{
var newTraces = new List <Tuple <object, object> >();
newTraces.AddRange(lss.Traces);
newTraces.Add(DistanceSubstitution(lss));
newTraces.AddRange(gGoal.Traces);
gGoal.Traces = newTraces;
}
}
}
return(obj1);
}
return(null);
}
private static bool Reify(this LineSegmentSymbol lineSegSymbol,
PointSymbol ps1, PointSymbol ps2)
{
//if (!lineSeg.RelationStatus) return false;
lineSegSymbol.CachedSymbols.Clear(); //re-compute purpose
var shape1Lst = new List <PointSymbol>();
var shape2Lst = new List <PointSymbol>();
#region Caching Point 1
if (ps1.Shape.Concrete)
{
shape1Lst.Add(ps1);
}
else
{
foreach (var shapeSymbol in ps1.CachedSymbols.ToList())
{
var ptTemp = shapeSymbol as PointSymbol;
Debug.Assert(ptTemp != null);
if (ptTemp.Shape.Concrete)
{
shape1Lst.Add(ptTemp);
}
}
}
#endregion
#region Caching Point 2
if (ps2.Shape.Concrete)
{
shape2Lst.Add(ps2);
}
else
{
foreach (var shapeSymbol in ps2.CachedSymbols.ToList())
{
var ptTemp = shapeSymbol as PointSymbol;
Debug.Assert(ptTemp != null);
if (ptTemp.Shape.Concrete)
{
shape2Lst.Add(ptTemp);
}
}
}
#endregion
#region Generate caching linesegment
if (shape1Lst.Count == 0 || shape2Lst.Count == 0)
{
return(false);
}
foreach (var gPt1 in shape1Lst)
{
foreach (var gPt2 in shape2Lst)
{
Debug.Assert(gPt1 != null);
Debug.Assert(gPt2 != null);
var gPoint1 = gPt1.Shape as Point;
var gPoint2 = gPt2.Shape as Point;
Debug.Assert(gPoint1 != null);
Debug.Assert(gPoint2 != null);
Debug.Assert(gPoint1.Concrete);
Debug.Assert(gPoint2.Concrete);
var lineTemp = LineSegmentGenerationRule.GenerateLineSegment(gPoint1, gPoint2);
if (lineTemp != null)
{
lineSegSymbol.CachedSymbols.Add(lineTemp);
}
}
}
#endregion
return(true);
}
/*
* Automatic scaffolding
*
* Distance function (x-x0)^2+(y-y0)^2 = d^2
*
* Forward chaining to derive d.
* Backward chaining to derive other four parameters.
*/
private static Tuple <object, object> DistanceSubstitution(LineSegmentSymbol lss)
{
var ls = lss.Shape as LineSegment;
var lst = new List <TraceStep>();
string step1metaRule = "The Distance Function between two points it: d^2=(x0-x1)^2+(y0-y1)^2";
string step1AppliedRule = String.Format(
"Substitute two points into the distance function d^2=({0}-{1})^2+({2}-{3})^2",
ls.Pt1.XCoordinate.ToString(),
ls.Pt2.XCoordinate.ToString(),
ls.Pt1.YCoordinate.ToString(),
ls.Pt2.YCoordinate.ToString());
var pt1X = new Var("x0");
var pt1Y = new Var("y0");
var pt2X = new Var("x1");
var pt2Y = new Var("y1");
var term1_1 = new Term(Expression.Subtract, new List <object>()
{
pt1X, pt2X
});
var term11_1 = new Term(Expression.Power, new List <object>()
{
term1_1, 2.0
});
var term2_1 = new Term(Expression.Subtract, new List <object>()
{
pt1Y, pt2Y
});
var term22_1 = new Term(Expression.Power, new List <object>()
{
term2_1, 2.0
});
var rhs_1 = new Term(Expression.Add, new List <object>()
{
term11_1, term22_1
});
var variable = new Var('d');
var lhs = new Term(Expression.Power, new List <object>()
{
variable, 2.0
});
var term1 = new Term(Expression.Subtract, new List <object>()
{
ls.Pt1.XCoordinate, ls.Pt2.XCoordinate
});
var term11 = new Term(Expression.Power, new List <object>()
{
term1, 2.0
});
var term2 = new Term(Expression.Subtract, new List <object>()
{
ls.Pt1.YCoordinate, ls.Pt2.YCoordinate
});
var term22 = new Term(Expression.Power, new List <object>()
{
term2, 2.0
});
var rhs = new Term(Expression.Add, new List <object>()
{
term11, term22
});
var eq = new Equation(lhs, rhs);
var old_eq = new Equation(lhs, rhs_1);
var trace = new TraceStep(old_eq, eq, GeometryScaffold.KC_Distance, step1metaRule, step1AppliedRule);
lst.Add(trace);
string strategy = "Substitute two points coordinates into the distance function.";
var newTuple = new Tuple <object, object>(strategy, lst);
return(newTuple);
}
//backward chaining
public static object FromLineSegmentToDistance(LineSegmentSymbol lss, double value)
{
//0. Plotting existing knowledge
//1. Substitute two points coordinates into the distance function.
//2. Manipulate the expression to derive the goal.
////////////////////////////////////////////////////////
var ls = lss.Shape as LineSegment;
Debug.Assert(ls != null);
FromPointsToLineSegment(lss);
var term1_1 = new Term(Expression.Multiply, new List<object>() {-1, ls.Pt2.XCoordinate});
var term1 = new Term(Expression.Add, new List<object>() { ls.Pt1.XCoordinate, term1_1 });
var term11 = new Term(Expression.Power, new List<object>() { term1, 2.0 });
var term2_2 = new Term(Expression.Multiply, new List<object>() {-1, ls.Pt2.YCoordinate});
var term2 = new Term(Expression.Add, new List<object>() { ls.Pt1.YCoordinate, term2_2});
var term22 = new Term(Expression.Power, new List<object>() { term2, 2.0 });
var rhs = new Term(Expression.Add, new List<object>() { term11, term22 });
var lhs = new Term(Expression.Power, new List<object>() {value, 2.0});
var eq = new Equation(lhs, rhs);
object obj1;
bool result = eq.IsEqGoal(out obj1);
if (result)
{
var lst = obj1 as List<object>;
if (lst != null)
{
foreach (object tempObj in lst)
{
var gGoal = tempObj as EqGoal;
if (gGoal != null)
{
var newTraces = new List<Tuple<object, object>>();
newTraces.AddRange(lss.Traces);
newTraces.Add(DistanceSubstitution(lss));
newTraces.AddRange(gGoal.Traces);
gGoal.Traces = newTraces;
}
}
}
return obj1;
}
return null;
}
//forward chaining
public static void FromLineSegmentToDistance(LineSegmentSymbol lss)
{
//1. Substitute two points coordinates into the distance function.
//2. Manipulate the expression to derive the goal.
////////////////////////////////////////////////////////
//1.
lss.Traces.Add(DistanceSubstitution(lss));
////////////////////////////////////////////////////////
//2.
var ls = lss.Shape as LineSegment;
var variable = new Var('d');
var lhs = new Term(Expression.Power, new List<object>() { variable, 2.0 });
var term1 = new Term(Expression.Subtract, new List<object>() {ls.Pt1.XCoordinate, ls.Pt2.XCoordinate});
var term11 = new Term(Expression.Power, new List<object>() {term1, 2.0});
var term2 = new Term(Expression.Subtract, new List<object>() {ls.Pt1.YCoordinate, ls.Pt2.YCoordinate});
var term22 = new Term(Expression.Power, new List<object>() {term2, 2.0});
var rhs = new Term(Expression.Add, new List<object>() {term11, term22});
var eq = new Equation(lhs, rhs);
object obj1;
bool result = eq.IsEqGoal(out obj1);
EqGoal eqGoal = null;
Debug.Assert(result);
var lst1 = obj1 as List<object>;
foreach (var temp in lst1)
{
var tempGoal = temp as EqGoal;
if (tempGoal == null) continue;
double dNum;
bool tempResult = LogicSharp.IsDouble(tempGoal.Rhs, out dNum);
if (tempResult && dNum > 0)
{
eqGoal = tempGoal;
break;
}
}
Debug.Assert(eqGoal != null);
lss.Traces.AddRange(eqGoal.Traces);
}
public static Expr ToExpr(this LineSegmentSymbol lss)
{
Debug.Assert(lss.Shape.Label != null);
return(Text.Convert(lss.ToString()));
}
//forward chaining
public static void FromLineSegmentToDistance(LineSegmentSymbol lss)
{
//1. Substitute two points coordinates into the distance function.
//2. Manipulate the expression to derive the goal.
////////////////////////////////////////////////////////
//1.
lss.Traces.Add(DistanceSubstitution(lss));
////////////////////////////////////////////////////////
//2.
var ls = lss.Shape as LineSegment;
var variable = new Var('d');
var lhs = new Term(Expression.Power, new List <object>()
{
variable, 2.0
});
var term1 = new Term(Expression.Subtract, new List <object>()
{
ls.Pt1.XCoordinate, ls.Pt2.XCoordinate
});
var term11 = new Term(Expression.Power, new List <object>()
{
term1, 2.0
});
var term2 = new Term(Expression.Subtract, new List <object>()
{
ls.Pt1.YCoordinate, ls.Pt2.YCoordinate
});
var term22 = new Term(Expression.Power, new List <object>()
{
term2, 2.0
});
var rhs = new Term(Expression.Add, new List <object>()
{
term11, term22
});
var eq = new Equation(lhs, rhs);
object obj1;
bool result = eq.IsEqGoal(out obj1);
EqGoal eqGoal = null;
Debug.Assert(result);
var lst1 = obj1 as List <object>;
foreach (var temp in lst1)
{
var tempGoal = temp as EqGoal;
if (tempGoal == null)
{
continue;
}
double dNum;
bool tempResult = LogicSharp.IsDouble(tempGoal.Rhs, out dNum);
if (tempResult && dNum > 0)
{
eqGoal = tempGoal;
break;
}
}
Debug.Assert(eqGoal != null);
lss.Traces.AddRange(eqGoal.Traces);
}
public static LineSegmentSymbol Unify(PointSymbol pt1, PointSymbol pt2)
{
//point identify check
if (pt1.Equals(pt2))
{
return(null);
}
var point1 = pt1.Shape as Point;
var point2 = pt2.Shape as Point;
Debug.Assert(point1 != null);
Debug.Assert(point2 != null);
//lazy evaluation
//Constraint solving on Graph
var lineSeg = new LineSegment(null); //Ghost Line Segment
lineSeg.Pt1 = point1;
lineSeg.Pt2 = point2;
var lss = new LineSegmentSymbol(lineSeg);
//Line build process
if (pt1.Shape.Concrete)
{
if (pt2.Shape.Concrete)
{
return(LineSegmentGenerationRule.GenerateLineSegment(point1, point2));
}
if (pt2.CachedSymbols.Count != 0)
{
foreach (ShapeSymbol ss in pt2.CachedSymbols)
{
var ps = ss as PointSymbol;
Debug.Assert(ps != null);
Debug.Assert(ps.Shape.Concrete);
var cachePoint = ps.Shape as Point;
Debug.Assert(cachePoint != null);
var gLss = LineSegmentGenerationRule.GenerateLineSegment(point1, cachePoint);
gLss.Traces.AddRange(ps.Traces);
lss.CachedSymbols.Add(gLss);
}
}
return(lss);
}
Debug.Assert(!pt1.Shape.Concrete);
if (pt2.Shape.Concrete)
{
if (pt1.CachedSymbols.Count != 0)
{
foreach (ShapeSymbol ss in pt1.CachedSymbols)
{
var ps = ss as PointSymbol;
Debug.Assert(ps != null);
Debug.Assert(ps.Shape.Concrete);
var cachePoint = ps.Shape as Point;
Debug.Assert(cachePoint != null);
var gLss = LineSegmentGenerationRule.GenerateLineSegment(cachePoint, point2);
gLss.Traces.AddRange(ps.Traces);
lss.CachedSymbols.Add(gLss);
}
}
return(lss);
}
Debug.Assert(!pt2.Shape.Concrete);
foreach (ShapeSymbol ss1 in pt1.CachedSymbols)
{
foreach (ShapeSymbol ss2 in pt2.CachedSymbols)
{
var ps1 = ss1 as PointSymbol;
Debug.Assert(ps1 != null);
Debug.Assert(ps1.Shape.Concrete);
var cachePoint1 = ps1.Shape as Point;
Debug.Assert(cachePoint1 != null);
var ps2 = ss2 as PointSymbol;
Debug.Assert(ps2 != null);
Debug.Assert(ps2.Shape.Concrete);
var cachePoint2 = ps2.Shape as Point;
Debug.Assert(cachePoint2 != null);
var gLss = LineSegmentGenerationRule.GenerateLineSegment(cachePoint1, cachePoint2);
gLss.Traces.AddRange(ps1.Traces);
gLss.Traces.AddRange(ps2.Traces);
lss.CachedSymbols.Add(gLss);
}
}
return(lss);
}
//backward solving
private static object InferDistance(this LineSegmentSymbol inputLineSymbol, double value)
{
return(TraceInstructionalDesign.FromLineSegmentToDistance(inputLineSymbol, value));
}
