//
//
//
private static List<EdgeAggregator> IfCongruencesApplyToTrianglesGenerate(Triangle ct1, Triangle ct2, CongruentSegments css1, CongruentSegments css2)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// The congruent relationships need to link the given triangles
//
if (!css1.LinksTriangles(ct1, ct2)) return newGrounded;
if (!css2.LinksTriangles(ct1, ct2)) return newGrounded;
Segment seg1Tri1 = ct1.GetSegment(css1);
Segment seg2Tri1 = ct1.GetSegment(css2);
Segment seg1Tri2 = ct2.GetSegment(css1);
Segment seg2Tri2 = ct2.GetSegment(css2);
// Avoid redundant segments, if it arises
if (seg1Tri1.StructurallyEquals(seg2Tri1)) return newGrounded;
if (seg1Tri2.StructurallyEquals(seg2Tri2)) return newGrounded;
//
// Proportional Segments (we generate only as needed to avoid bloat in the hypergraph (assuming they are used by both triangles)
// We avoid generating proportions if they are truly congruences.
//
List<GroundedClause> propAntecedent = new List<GroundedClause>();
propAntecedent.Add(css1);
propAntecedent.Add(css2);
SegmentRatio ratio1 = new SegmentRatio(seg1Tri1, seg1Tri2);
SegmentRatio ratio2 = new SegmentRatio(seg2Tri1, seg2Tri2);
GeometricSegmentRatioEquation newEq = new GeometricSegmentRatioEquation(ratio1, ratio2);
newGrounded.Add(new EdgeAggregator(propAntecedent, newEq, annotation));
////
//// Only generate if ratios are not 1.
////
//GeometricSegmentRatio newProp = null;
//if (!Utilities.CompareValues(seg1Tri1.Length, seg1Tri2.Length))
//{
// newProp = new GeometricSegmentRatio(seg1Tri1, seg1Tri2);
// newGrounded.Add(new EdgeAggregator(propAntecedent, newProp, annotation));
//}
//if (!Utilities.CompareValues(seg1Tri1.Length, seg2Tri2.Length))
//{
// newProp = new GeometricSegmentRatio(seg1Tri1, seg2Tri2);
// newGrounded.Add(new EdgeAggregator(propAntecedent, newProp, annotation));
//}
//if (!Utilities.CompareValues(seg2Tri1.Length, seg1Tri2.Length))
//{
// newProp = new GeometricSegmentRatio(seg2Tri1, seg1Tri2);
// newGrounded.Add(new EdgeAggregator(propAntecedent, newProp, annotation));
//}
//if (!Utilities.CompareValues(seg2Tri1.Length, seg2Tri2.Length))
//{
// newProp = new GeometricSegmentRatio(seg2Tri1, seg2Tri2);
// newGrounded.Add(new EdgeAggregator(propAntecedent, newProp, annotation));
//}
return newGrounded;
}
//
// Checks for SSS given the 5 values
//
private static List<EdgeAggregator> InstantiateSSS(Triangle tri1, Triangle tri2, CongruentSegments css1, CongruentSegments css2, CongruentSegments css3)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// All congruence pairs must minimally relate the triangles
//
if (!css1.LinksTriangles(tri1, tri2)) return newGrounded;
if (!css2.LinksTriangles(tri1, tri2)) return newGrounded;
if (!css3.LinksTriangles(tri1, tri2)) return newGrounded;
Segment seg1Tri1 = tri1.GetSegment(css1);
Segment seg1Tri2 = tri2.GetSegment(css1);
Segment seg2Tri1 = tri1.GetSegment(css2);
Segment seg2Tri2 = tri2.GetSegment(css2);
Segment seg3Tri1 = tri1.GetSegment(css3);
Segment seg3Tri2 = tri2.GetSegment(css3);
//
// The vertices of both triangles must all be distinct and cover the triangle completely.
//
Point vertex1Tri1 = seg1Tri1.SharedVertex(seg2Tri1);
Point vertex2Tri1 = seg2Tri1.SharedVertex(seg3Tri1);
Point vertex3Tri1 = seg1Tri1.SharedVertex(seg3Tri1);
if (vertex1Tri1 == null || vertex2Tri1 == null || vertex3Tri1 == null) return newGrounded;
if (vertex1Tri1.StructurallyEquals(vertex2Tri1) ||
vertex1Tri1.StructurallyEquals(vertex3Tri1) ||
vertex2Tri1.StructurallyEquals(vertex3Tri1)) return newGrounded;
Point vertex1Tri2 = seg1Tri2.SharedVertex(seg2Tri2);
Point vertex2Tri2 = seg2Tri2.SharedVertex(seg3Tri2);
Point vertex3Tri2 = seg1Tri2.SharedVertex(seg3Tri2);
if (vertex1Tri2 == null || vertex2Tri2 == null || vertex3Tri2 == null) return newGrounded;
if (vertex1Tri2.StructurallyEquals(vertex2Tri2) ||
vertex1Tri2.StructurallyEquals(vertex3Tri2) ||
vertex2Tri2.StructurallyEquals(vertex3Tri2)) return newGrounded;
//
// Construct the corresponding points between the triangles
//
List<Point> triangleOne = new List<Point>();
List<Point> triangleTwo = new List<Point>();
triangleOne.Add(vertex1Tri1);
triangleTwo.Add(vertex1Tri2);
triangleOne.Add(vertex2Tri1);
triangleTwo.Add(vertex2Tri2);
triangleOne.Add(vertex3Tri1);
triangleTwo.Add(vertex3Tri2);
//
// Construct the new clauses: congruent triangles and CPCTC
//
GeometricCongruentTriangles gcts = new GeometricCongruentTriangles(new Triangle(triangleOne), new Triangle(triangleTwo));
// Hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(tri1);
antecedent.Add(tri2);
antecedent.Add(css1);
antecedent.Add(css2);
antecedent.Add(css3);
newGrounded.Add(new EdgeAggregator(antecedent, gcts, annotation));
// Add all the corresponding parts as new congruent clauses
newGrounded.AddRange(CongruentTriangles.GenerateCPCTC(gcts, triangleOne, triangleTwo));
return newGrounded;
}
//
// Checks for ASA given the 5 values
//
private static List<EdgeAggregator> InstantiateAAS(Triangle tri1, Triangle tri2,
CongruentAngles cas1, CongruentAngles cas2, CongruentSegments css)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// All congruence pairs must minimally relate the triangles
//
if (!cas1.LinksTriangles(tri1, tri2)) return newGrounded;
if (!cas2.LinksTriangles(tri1, tri2)) return newGrounded;
if (!css.LinksTriangles(tri1, tri2)) return newGrounded;
// Is this angle an 'extension' of the actual triangle angle? If so, acquire the normalized version of
// the angle, using only the triangle vertices to represent the angle
Angle angle1Tri1 = tri1.NormalizeAngle(tri1.AngleBelongs(cas1));
Angle angle1Tri2 = tri2.NormalizeAngle(tri2.AngleBelongs(cas1));
Angle angle2Tri1 = tri1.NormalizeAngle(tri1.AngleBelongs(cas2));
Angle angle2Tri2 = tri2.NormalizeAngle(tri2.AngleBelongs(cas2));
// The angles for each triangle must be distinct
if (angle1Tri1.Equals(angle2Tri1) || angle1Tri2.Equals(angle2Tri2)) return newGrounded;
Segment segTri1 = tri1.GetSegment(css);
Segment segTri2 = tri2.GetSegment(css);
// ASA situations
if (segTri1.IsIncludedSegment(angle1Tri1, angle2Tri1)) return newGrounded;
if (segTri2.IsIncludedSegment(angle1Tri2, angle2Tri2)) return newGrounded;
// The segments for each triangle must be corresponding
if (segTri1.Equals(tri1.OtherSide(angle1Tri1)) && segTri2.Equals(tri2.OtherSide(angle2Tri2))) return newGrounded;
if (segTri1.Equals(tri1.OtherSide(angle2Tri1)) && segTri2.Equals(tri2.OtherSide(angle1Tri2))) return newGrounded;
//
// Construct the corrsesponding points between the triangles
//
List<Point> triangleOne = new List<Point>();
List<Point> triangleTwo = new List<Point>();
triangleOne.Add(angle1Tri1.GetVertex());
triangleTwo.Add(angle1Tri2.GetVertex());
triangleOne.Add(angle2Tri1.GetVertex());
triangleTwo.Add(angle2Tri2.GetVertex());
// We know the segment endpoint mappings above, now acquire the opposite point
triangleOne.Add(tri1.OtherPoint(angle1Tri1.GetVertex(), angle2Tri1.GetVertex()));
triangleTwo.Add(tri2.OtherPoint(angle1Tri2.GetVertex(), angle2Tri2.GetVertex()));
//
// Construct the new clauses: congruent triangles and CPCTC
//
GeometricCongruentTriangles gcts = new GeometricCongruentTriangles(new Triangle(triangleOne), new Triangle(triangleTwo));
// Hypergraph
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(tri1);
antecedent.Add(tri2);
antecedent.Add(cas1);
antecedent.Add(cas2);
antecedent.Add(css);
newGrounded.Add(new EdgeAggregator(antecedent, gcts, annotation));
// Add all the corresponding parts as new congruent clauses
newGrounded.AddRange(CongruentTriangles.GenerateCPCTC(gcts, triangleOne, triangleTwo));
return newGrounded;
}
//
// Of all the congruent segment pairs, choose a subset of 3. Exhaustively check all; if they work, return the set.
//
private static List<EdgeAggregator> CheckForSSS(Triangle ct1, Triangle ct2, SegmentRatioEquation sre1, SegmentRatioEquation sre2)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// The proportional relationships need to link the given triangles
//
if (!sre1.LinksTriangles(ct1, ct2)) return newGrounded;
if (!sre2.LinksTriangles(ct1, ct2)) return newGrounded;
//
// Both equations must share a fraction (ratio)
//
if (!sre1.SharesRatio(sre2)) return newGrounded;
//
// Collect all of the applicable segments
//
SegmentRatio shared = sre1.GetSharedRatio(sre2);
SegmentRatio other1 = sre1.GetOtherRatio(shared);
SegmentRatio other2 = sre2.GetOtherRatio(shared);
Segment seg1Tri1 = ct1.GetSegment(shared);
Segment seg2Tri1 = ct1.GetSegment(other1);
Segment seg3Tri1 = ct1.GetSegment(other2);
if (seg1Tri1 == null || seg2Tri1 == null || seg3Tri1 == null) return newGrounded;
Segment seg1Tri2 = ct2.GetSegment(shared);
Segment seg2Tri2 = ct2.GetSegment(other1);
Segment seg3Tri2 = ct2.GetSegment(other2);
if (seg1Tri2 == null || seg2Tri2 == null || seg3Tri2 == null) return newGrounded;
// Avoid redundant segments, if they arise
if (seg1Tri1.StructurallyEquals(seg2Tri1) || seg1Tri1.StructurallyEquals(seg3Tri1) || seg2Tri1.StructurallyEquals(seg3Tri1)) return newGrounded;
if (seg1Tri2.StructurallyEquals(seg2Tri2) || seg1Tri2.StructurallyEquals(seg3Tri2) || seg2Tri2.StructurallyEquals(seg3Tri2)) return newGrounded;
//
// Collect the corresponding points
//
List<KeyValuePair<Point, Point>> pointPairs = new List<KeyValuePair<Point, Point>>();
pointPairs.Add(new KeyValuePair<Point, Point>(seg1Tri1.SharedVertex(seg2Tri1), seg1Tri2.SharedVertex(seg2Tri2)));
pointPairs.Add(new KeyValuePair<Point, Point>(seg1Tri1.SharedVertex(seg3Tri1), seg1Tri2.SharedVertex(seg3Tri2)));
pointPairs.Add(new KeyValuePair<Point, Point>(seg2Tri1.SharedVertex(seg3Tri1), seg2Tri2.SharedVertex(seg3Tri2)));
List<GroundedClause> simTriAntecedent = new List<GroundedClause>();
simTriAntecedent.Add(ct1);
simTriAntecedent.Add(ct2);
simTriAntecedent.Add(sre1);
simTriAntecedent.Add(sre2);
newGrounded.AddRange(SASSimilarity.GenerateCorrespondingParts(pointPairs, simTriAntecedent, annotation));
return newGrounded;
}