// // Acquire the set of atomic regions and OMIT the region given by the inner shape. // public static List<AtomicRegion> AcquireOpenAtomicRegions(List<Connection> connections, List<Point> innerShapePoints, Figure innerShape) { List<AtomicRegion> atoms = ConstructAtomicRegions(connections, innerShapePoints, innerShape); int foundIndex = -1; for (int a = 0; a < atoms.Count; a++) { ShapeAtomicRegion shapeAtom = atoms[a] as ShapeAtomicRegion; if (shapeAtom != null) { Polygon shapeAtomPoly = shapeAtom.shape as Polygon; Polygon innerShapePoly = innerShape as Polygon; if (shapeAtomPoly != null && innerShapePoly != null) { if (shapeAtomPoly.HasSamePoints(innerShapePoly)) foundIndex = a; } else if (shapeAtom.shape.StructurallyEquals(innerShape)) { foundIndex = a; } } } if (foundIndex == -1) { throw new Exception("Expected to find the original shape " + innerShape.ToString() + " as atomic region; did not."); } atoms.RemoveAt(foundIndex); return atoms; }
public override bool CoordinateCongruent(Figure that) { Sector thatSector = that as Sector; if (thatSector == null) return false; return this.theArc.CoordinateCongruent(thatSector.theArc); }
public Connection(Point e1, Point e2, ConnectionType t, Figure so) { endpoint1 = e1; endpoint2 = e2; type = t; segmentOrArc = so; }
public static new List<FigSynthProblem> SubtractShape(Figure outerShape, List<Connection> conns, List<Point> points) { // Possible triangles. List<Triangle> tris = null; if (outerShape is ConcavePolygon) tris = Triangle.GetTrianglesFromPoints(outerShape as ConcavePolygon, points); else tris = Triangle.GetTrianglesFromPoints(points); List<FigSynthProblem> composed = new List<FigSynthProblem>(); foreach (Triangle tri in tris) { // Select only parallelograms that don't match the outer shape. if (tri.IsEquilateral() && !tri.StructurallyEquals(outerShape)) { EquilateralTriangle eqTri = new EquilateralTriangle(tri); SubtractionSynth subSynth = new SubtractionSynth(outerShape, eqTri); try { subSynth.SetOpenRegions(FigSynthProblem.AcquireOpenAtomicRegions(conns, eqTri.points, eqTri)); composed.Add(subSynth); } catch (Exception) { } } } return FigSynthProblem.RemoveSymmetric(composed); }
// Add a shape to the list which contains this region. public virtual void AddOwner(Figure f) { if (!Utilities.AddStructurallyUnique<Figure>(owners, f)) return; // Check if this new atomic region is the outermost owner. if (topOwner == null || f.Contains(topOwner)) topOwner = f; }
public override bool CoordinateCongruent(Figure that) { Semicircle thatSemi = that as Semicircle; if (thatSemi == null) return false; return theCircle.CoordinateCongruent(thatSemi.theCircle); }
public static new List<FigSynthProblem> AppendShape(Figure outerShape, List<Segment> segments) { // // Acquire a set of lengths of the given segments. // List<int> lengths = new List<int>(); segments.ForEach(s => Utilities.AddUnique<int>(lengths, (int)s.Length)); // Acquire the length of the rectangle so it is fixed among all appended shapes. // We avoid a square by looping. int newLength = -1; for (newLength = Figure.DefaultSideLength(); lengths.Contains(newLength); newLength = Figure.DefaultSideLength()) ; List<FigSynthProblem> composed = new List<FigSynthProblem>(); foreach (Segment seg in segments) { Rectangle rect1; Rectangle rect2; MakeRectangles(seg, newLength, out rect1, out rect2); FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, rect1); if (prob != null) composed.Add(prob); prob = Figure.MakeAdditionProblem(outerShape, rect2); if (prob != null) composed.Add(prob); } return FigSynthProblem.RemoveSymmetric(composed); }
// // Append parallelograms to appropriate segments. // public static new List<FigSynthProblem> AppendShape(Figure outerShape, List<Segment> segments) { // Acquire a set of lengths of the given segments. List<int> lengths = new List<int>(); segments.ForEach(s => Utilities.AddUnique<int>(lengths, (int)s.Length)); // Acquire the length of the rectangle so it is fixed among all appended shapes. // We avoid a rhombus by looping. int newLength = -1; for (newLength = Figure.DefaultSideLength(); lengths.Contains(newLength); newLength = Figure.DefaultSideLength()) ; int angle = Figure.DefaultFirstQuadrantNonRightAngle(); // Create the shapes. List<FigSynthProblem> composed = new List<FigSynthProblem>(); foreach (Segment seg in segments) { List<Parallelogram> parallelograms = new List<Parallelogram>(); parallelograms.AddRange(MakeParallelograms(seg, newLength, angle)); foreach (Parallelogram para in parallelograms) { FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, para); if (prob != null) composed.Add(prob); } } return FigSynthProblem.RemoveSymmetric(composed); }
public static new List<FigSynthProblem> SubtractShape(Figure outerShape, List<Connection> conns, List<Point> points) { // Possible quadrilaterals. List<Quadrilateral> quads = null; if (outerShape is ConcavePolygon) quads = Quadrilateral.GetQuadrilateralsFromPoints(outerShape as ConcavePolygon, points); else quads = Quadrilateral.GetQuadrilateralsFromPoints(points); List<FigSynthProblem> composed = new List<FigSynthProblem>(); foreach (Quadrilateral quad in quads) { // Select only isosceles trapezoids that don't match the outer shape. if (quad.VerifyIsoscelesTrapezoid() && !quad.HasSamePoints(outerShape as Polygon)) { IsoscelesTrapezoid isoTrap = new IsoscelesTrapezoid(quad); SubtractionSynth subSynth = new SubtractionSynth(outerShape, isoTrap); subSynth.SetOpenRegions(FigSynthProblem.AcquireOpenAtomicRegions(conns, isoTrap.points, isoTrap)); composed.Add(subSynth); } } return FigSynthProblem.RemoveSymmetric(composed); }
// // Outer minus circle; the circle will only be situation if it touches all sides of the outer figure. // public static List<FigSynthProblem> SubtractShape(Figure outerShape, List<Connection> conns, List<Point> points) { List<FigSynthProblem> composed = new List<FigSynthProblem>(); List<Midpoint> midpoints = outerShape.GetMidpointClauses(); if (midpoints.Count < 3) return composed; // // Construct the circle based on the first 3 points. // Circle circ = Circle.ConstructCircle(midpoints[0].point, midpoints[1].point, midpoints[2].point); // // Verify that the remaining points lie on the circle. // for (int p = 4; p < midpoints.Count; p++) { if (!circ.PointLiesOn(midpoints[p].point)) return composed; } SubtractionSynth subSynth = new SubtractionSynth(outerShape, circ); composed.Add(subSynth); return composed; }
public static new List<FigSynthProblem> SubtractShape(Figure outerShape, List<Connection> conns, List<Point> points) { List<Triangle> tris = Triangle.GetTrianglesFromPoints(points); List<FigSynthProblem> composed = new List<FigSynthProblem>(); foreach (Triangle tri in tris) { // Only create right triangles that are NOT the outershape. if (tri.isRightTriangle() && !tri.StructurallyEquals(outerShape)) { RightTriangle rTri = new RightTriangle(tri); SubtractionSynth subSynth = new SubtractionSynth(outerShape, rTri); try { subSynth.SetOpenRegions(FigSynthProblem.AcquireOpenAtomicRegions(conns, rTri.points, rTri)); composed.Add(subSynth); } catch (Exception) { } } } return FigSynthProblem.RemoveSymmetric(composed); }
public static new List<FigSynthProblem> AppendShape(Figure outerShape, List<Segment> segments) { List<FigSynthProblem> composed = new List<FigSynthProblem>(); // Acquire a set of lengths of the given segments. // List<int> lengths = new List<int>(); segments.ForEach(s => Utilities.AddUnique<int>(lengths, (int)s.Length)); // Acquire an isosceles triangle by looping. int newLength = -1; for (newLength = Figure.DefaultSideLength(); lengths.Contains(newLength); newLength = Figure.DefaultSideLength()) ; foreach (Segment seg in segments) { List<RightTriangle> tris; MakeRightTriangles(seg, newLength, out tris); foreach (RightTriangle rt in tris) { FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, rt); if (prob != null) composed.Add(prob); } } return FigSynthProblem.RemoveSymmetric(composed); }
public static new List<FigSynthProblem> SubtractShape(Figure outerShape, List<Connection> conns, List<Point> points) { // Possible quadrilaterals. List<Quadrilateral> quads = null; if (outerShape is ConcavePolygon) quads = Quadrilateral.GetQuadrilateralsFromPoints(outerShape as ConcavePolygon, points); else quads = Quadrilateral.GetQuadrilateralsFromPoints(points); List<FigSynthProblem> composed = new List<FigSynthProblem>(); foreach (Quadrilateral quad in quads) { // Select only rhombi that don't match the outer shape. if (quad.VerifyRhombus() && !quad.HasSamePoints(outerShape as Polygon)) { Rhombus rhombus = new Rhombus(quad); SubtractionSynth subSynth = new SubtractionSynth(outerShape, rhombus); try { subSynth.SetOpenRegions(FigSynthProblem.AcquireOpenAtomicRegions(conns, rhombus.points, rhombus)); composed.Add(subSynth); } catch (Exception) { } } } return FigSynthProblem.RemoveSymmetric(composed); }
// // A shape within this shape? // public override bool Contains(Figure that) { if (that is Circle) return ContainsCircle(that as Circle); if (that is Polygon) return ContainsPolygon(that as Polygon); if (that is Sector) return ContainsSector(that as Sector); return false; }
public override bool CoordinateCongruent(Figure that) { MajorArc thatArc = that as MajorArc; if (thatArc == null) return false; if (!theCircle.CoordinateCongruent(thatArc.theCircle)) return false; return Utilities.CompareValues(this.GetMajorArcMeasureDegrees(), thatArc.GetMajorArcMeasureDegrees()); }
public AtomicRegion() { ordered = false; connections = new List<Connection>(); owners = new List<Figure>(); topOwner = null; knownAtomic = false; polygonalized = null; thisArea = -1; }
// // All innerShape connections are among the points that lie on the set of given connections. // Determine which of this innerShape endpoints lie between the 'outer' set of connections. // public static List<AtomicRegion> ConstructAtomicRegions(List<Connection> connections, List<Point> innerShapePoints, Figure innerShape) { List<Point> points; List<Segment> segments; List<Arc> arcs; List<Circle> circles; CollectConstituentElements(connections, innerShapePoints, innerShape, out points, out segments, out arcs, out circles); // Acquire circle granularity for atomic region finding. Dictionary<Circle, int> circGranularity = Circle.AcquireCircleGranularity(circles); // Extract the atomic regions. return GeometryTutorLib.AtomicRegionIdentifier.AtomicIdentifierMain.AcquireAtomicRegionsFromGraph(points, segments, arcs, circles, circGranularity); }
// // With appending in this case, we choose the given segment to be the base. // public static new List<FigSynthProblem> AppendShape(Figure outerShape, List<Segment> segments) { List<FigSynthProblem> composed = new List<FigSynthProblem>(); // Acquire a set of lengths of the given segments. List<int> lengths = new List<int>(); segments.ForEach(s => Utilities.AddUnique<int>(lengths, (int)s.Length)); // // Acquire the length of the isosceles triangle so that it is longer than the half the distance of the segment. // int newLength = -1; for (newLength = Figure.DefaultSideLength(); ; newLength = Figure.DefaultSideLength()) { bool longEnough = true; foreach (Segment side in segments) { if (newLength < (side.Length / 2.0) + 1) { longEnough = false; break; } } if (longEnough) break; } // // Construct the triangles. // foreach (Segment seg in segments) { List<Triangle> tris; MakeIsoscelesTriangles(seg, newLength, out tris); foreach (Triangle t in tris) { FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, t); if (prob != null) composed.Add(prob); } } return FigSynthProblem.RemoveSymmetric(composed); }
public static new List<FigSynthProblem> AppendShape(Figure outerShape, List<Segment> segments) { List<FigSynthProblem> composed = new List<FigSynthProblem>(); int length = Figure.DefaultSideLength(); int angle = Figure.DefaultFirstQuadrantNonRightAngle(); foreach (Segment seg in segments) { List<Triangle> tris; MakeTriangles(seg, length, angle, out tris); foreach (Triangle t in tris) { FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, t); if (prob != null) composed.Add(prob); } } return FigSynthProblem.RemoveSymmetric(composed); }
public static new List<FigSynthProblem> AppendShape(Figure outerShape, List<Segment> segments) { List<FigSynthProblem> composed = new List<FigSynthProblem>(); foreach (Segment seg in segments) { Rectangle rect1; Rectangle rect2; Rectangle.MakeRectangles(seg, seg.Length, out rect1, out rect2); Square sq1 = new Square(rect1); Square sq2 = new Square(rect2); FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, sq2); if (prob != null) composed.Add(prob); prob = Figure.MakeAdditionProblem(outerShape, sq2); if (prob != null) composed.Add(prob); } return FigSynthProblem.RemoveSymmetric(composed); }
// // With appending in this case, we choose the given segment to be the base. // public static new List<FigSynthProblem> AppendShape(Figure outerShape, List<Segment> segments) { List<FigSynthProblem> composed = new List<FigSynthProblem>(); // // Construct the triangles. // foreach (Segment seg in segments) { List<Triangle> tris; IsoscelesTriangle.MakeIsoscelesTriangles(seg, seg.Length, out tris); foreach (Triangle t in tris) { FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, t); if (prob != null) composed.Add(prob); } } return FigSynthProblem.RemoveSymmetric(composed); }
public static new List<FigSynthProblem> AppendShape(Figure outerShape, List<Segment> segments) { throw new NotImplementedException(); }
public static new List<FigSynthProblem> SubtractShape(Figure outerShape, List<Connection> conns, List<Point> points) { throw new NotImplementedException(); }
// // A shape within this shape? // public virtual bool Contains(Figure that) { return thisAtomicRegion.Contains(that.GetFigureAsAtomicRegion()); }
public void AddSuperFigure(Figure f) { if (!Utilities.HasStructurally<Figure>(superFigures, f)) superFigures.Add(f); }
public List<AtomicRegion> GetAtomicRegionsByFigure(Figure fig) { List<AtomicRegion> atoms = new List<AtomicRegion>(); foreach (AtomicRegion atom in atomicRegions) { ShapeAtomicRegion shapeAtom = atom as ShapeAtomicRegion; if (shapeAtom != null) { if (fig.Contains(shapeAtom.shape)) atoms.Add(atom); } else { if (fig.Contains(this.allFigurePoints, atom)) atoms.Add(atom); } } return atoms; }
private List<int> GetAtomicRegionIndicesByFigure(Figure fig) { List<int> atomIndices = new List<int>(); for (int a = 0; a < atomicRegions.Count; a++) { ShapeAtomicRegion shapeAtom = atomicRegions[a] as ShapeAtomicRegion; if (shapeAtom != null) { if (fig.Contains(shapeAtom.shape)) atomIndices.Add(a); } else { if (fig.Contains(this.allFigurePoints, atomicRegions[a])) atomIndices.Add(a); } } return atomIndices; }
public static List <FigSynthProblem> SubtractShape(Figure outerShape, List <Connection> conns, List <Point> points) { throw new NotImplementedException(); }
public override bool CoordinateCongruent(Figure that) { Circle thatCirc = that as Circle; if (thatCirc == null) return false; return Utilities.CompareValues(this.radius, thatCirc.radius); }
public new static List <FigSynthProblem> AppendShape(Figure outerShape, List <Segment> segments) { // // Acquire a set of lengths of the given segments. // List <int> lengths = new List <int>(); segments.ForEach(s => Utilities.AddUnique <int>(lengths, (int)s.Length)); // Acquire the length of the rectangle so it is fixed among all appended shapes. // We avoid a square by looping. int newLength = -1; for (newLength = Figure.DefaultSideLength(); lengths.Contains(newLength); newLength = Figure.DefaultSideLength()) { ; } List <FigSynthProblem> composed = new List <FigSynthProblem>(); foreach (Segment seg in segments) { Rectangle rect1; Rectangle rect2; MakeRectangles(seg, newLength, out rect1, out rect2); FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, rect1); if (prob != null) { composed.Add(prob); } prob = Figure.MakeAdditionProblem(outerShape, rect2); if (prob != null) { composed.Add(prob); } } return(FigSynthProblem.RemoveSymmetric(composed)); }
// // A shape within this shape? // public virtual bool Contains(Figure that) { return thisAtomicRegion.Contains(that.GetFigureAsAtomicRegion()); }
public FigureNode(Figure f) { }
public void AddSubFigure(Figure f) { if (!Utilities.HasStructurally<Figure>(subFigures, f)) subFigures.Add(f); }
// // Append parallelograms to appropriate segments. // public new static List <FigSynthProblem> AppendShape(Figure outerShape, List <Segment> segments) { // Acquire a set of lengths of the given segments. List <int> lengths = new List <int>(); segments.ForEach(s => Utilities.AddUnique <int>(lengths, (int)s.Length)); // Acquire the length of the rectangle so it is fixed among all appended shapes. // We avoid a rhombus by looping. int newLength = -1; for (newLength = Figure.DefaultSideLength(); lengths.Contains(newLength); newLength = Figure.DefaultSideLength()) { ; } int angle = Figure.DefaultFirstQuadrantNonRightAngle(); // Create the shapes. List <FigSynthProblem> composed = new List <FigSynthProblem>(); foreach (Segment seg in segments) { List <Parallelogram> parallelograms = new List <Parallelogram>(); parallelograms.AddRange(MakeParallelograms(seg, newLength, angle)); foreach (Parallelogram para in parallelograms) { FigSynthProblem prob = Figure.MakeAdditionProblem(outerShape, para); if (prob != null) { composed.Add(prob); } } } return(FigSynthProblem.RemoveSymmetric(composed)); }
public static Circle ConstructDefaultCircle() { int radius = Figure.DefaultSideLength() / 2; return(new Circle(origin, radius)); }
public static List <FigSynthProblem> AppendShape(Figure outerShape, List <Segment> segments) { throw new NotImplementedException(); }
public void AddConnection(Point e1, Point e2, ConnectionType t, Figure owner) { connections.Add(new Connection(e1, e2, t, owner)); }