/// <summary> /// Get the length of the line. /// </summary> /// <param name="propName">The property name indicates the line.</param> /// <param name="entity">An entity in the service.</param> /// <returns>Return the length of the line.</returns> private double GetLength(string propName, JObject entity) { var propVal = entity[propName]["coordinates"] as JArray; var pts = new List <Point>(); for (int i = 0; i < propVal.Count - 1; i += 2) { var pt = new Point(Convert.ToDouble(propVal[i]), Convert.ToDouble(propVal[i + 1])); pts.Add(pt); } var segs = new List <SegmentEquation>(); for (int i = 0; i < pts.Count - 1; i++) { var seg = new SegmentEquation(pts[i], pts[i + 1]); segs.Add(seg); } double len = 0.0; foreach (var seg in segs) { len += seg.Length; } return(len); }
private static bool HandleSimpleSegmentEquation(KnownMeasurementsAggregator known, SegmentEquation theEq) { if (theEq.GetAtomicity() != Equation.BOTH_ATOMIC) { return(false); } Segment unknownSegment = null; double segmentValue = -1; if (theEq.lhs is NumericValue) { unknownSegment = theEq.rhs as Segment; segmentValue = (theEq.lhs as NumericValue).DoubleValue; } else if (theEq.rhs is NumericValue) { unknownSegment = theEq.lhs as Segment; segmentValue = (theEq.rhs as NumericValue).DoubleValue; } else { return(false); } // // (7) Add to the list of knowns // return(known.AddSegmentLength(unknownSegment, segmentValue)); }
// // (1) Make a copy // (2) Collect the equation terms. // (3) Are all but one known? // (4) Substitute // (5) Simplify // (6) Acquire the unknown and its value. // (7) Add to the list of knowns. // private static bool HandleSegmentEquation(KnownMeasurementsAggregator known, List <GroundedClause> clauses, SegmentEquation theEq) { if (theEq.GetAtomicity() == Equation.BOTH_ATOMIC) { return(HandleSimpleSegmentEquation(known, theEq)); } // CTA: Verify this calls the correct Equation deep copy mechanism. // (1) Make a copy SegmentEquation copy = (SegmentEquation)theEq.DeepCopy(); // (2) Collect the equation terms. List <GroundedClause> left = copy.lhs.CollectTerms(); double[] leftVal = new double[left.Count]; List <GroundedClause> right = copy.rhs.CollectTerms(); double[] rightVal = new double[right.Count]; // (3) Are all but one term known? int unknownCount = 0; for (int ell = 0; ell < left.Count; ell++) { if (left[ell] is NumericValue) { leftVal[ell] = (left[ell] as NumericValue).DoubleValue; } else { leftVal[ell] = known.GetSegmentLength(left[ell] as Segment); if (leftVal[ell] <= 0) { unknownCount++; } } } for (int r = 0; r < right.Count; r++) { if (right[r] is NumericValue) { rightVal[r] = (right[r] as NumericValue).DoubleValue; } else { rightVal[r] = known.GetSegmentLength(right[r] as Segment); if (rightVal[r] <= 0) { unknownCount++; } } } // We can't solve for more or less than one unknown. if (unknownCount != 1) { return(false); } // // (4) Substitute // for (int ell = 0; ell < left.Count; ell++) { if (leftVal[ell] > 0) { copy.Substitute(left[ell], new NumericValue(leftVal[ell])); } } for (int r = 0; r < right.Count; r++) { if (rightVal[r] > 0) { copy.Substitute(right[r], new NumericValue(rightVal[r])); } } // // (5) Simplify // SegmentEquation simplified = (SegmentEquation)GenericInstantiator.Simplification.Simplify(copy); return(HandleSimpleSegmentEquation(known, simplified)); }