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);
}
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);
}
public new static List <FigSynthProblem> SubtractShape(Figure outerShape, List <Connection> conns, List <Point> points)
{
List <FigSynthProblem> composed = new List <FigSynthProblem>();
// Possible triangles.
List <Triangle> tris = null;
if (outerShape is ConcavePolygon)
{
tris = Triangle.GetTrianglesFromPoints(outerShape as ConcavePolygon, points);
}
else
{
tris = Triangle.GetTrianglesFromPoints(points);
}
// Check all triangles to determine applicability.
foreach (Triangle tri in tris)
{
// Avoid equilateral, isosceles, and right triangles.
if (!tri.IsEquilateral() && !tri.IsIsosceles() && !tri.isRightTriangle() && !tri.StructurallyEquals(outerShape))
{
SubtractionSynth subSynth = new SubtractionSynth(outerShape, tri);
try
{
subSynth.SetOpenRegions(FigSynthProblem.AcquireOpenAtomicRegions(conns, tri.points, tri));
composed.Add(subSynth);
}
catch (Exception) { }
}
}
return(FigSynthProblem.RemoveSymmetric(composed));
}
public new static 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 rectangles that don't match the outer shape.
if (quad.VerifyRectangle() && !quad.HasSamePoints(outerShape as Polygon))
{
Rectangle rect = new Rectangle(quad);
SubtractionSynth subSynth = new SubtractionSynth(outerShape, rect);
try
{
subSynth.SetOpenRegions(FigSynthProblem.AcquireOpenAtomicRegions(conns, rect.points, rect));
composed.Add(subSynth);
}
catch (Exception) { }
}
}
return(FigSynthProblem.RemoveSymmetric(composed));
}
public new static 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));
}
public new static 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> 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);
}
public override FigSynthProblem Copy()
{
SubtractionSynth copy = new SubtractionSynth(this.leftProblem.Copy(), this.rightProblem.Copy());
copy.SetOpenRegions(new List <AtomicRegion>(this.openRegions));
return(copy);
}
//
// Append subtraction to this current problem; the subtraction occurs within one of the open atomic regions.
//
public static FigSynthProblem AppendAtomicSubtraction(FigSynthProblem that, FigSynthProblem toAppend)
{
BinarySynthOperation binaryAppend = toAppend as BinarySynthOperation;
if (binaryAppend == null)
{
return(null);
}
// Verify that the outer part of toAppend is an open atomic region.
if (!that.openRegions.Contains(new ShapeAtomicRegion((binaryAppend.leftProblem as UnarySynth).figure)))
{
throw new ArgumentException("Shape is not an open atomic region: " + (binaryAppend.leftProblem as UnarySynth).figure);
}
// Since the 'left' expression was an open region, the 'right' is the actual shape we are appending.
SubtractionSynth newSub = new SubtractionSynth(that.Copy(), binaryAppend.rightProblem);
// Update the open regions to the inner-most shape.
newSub.SetOpenRegions(toAppend.openRegions);
return(newSub);
}
public new static 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));
}
public static new List<FigSynthProblem> SubtractShape(Figure outerShape, List<Connection> conns, List<Point> points)
{
List<FigSynthProblem> composed = new List<FigSynthProblem>();
// Possible triangles.
List<Triangle> tris = null;
if (outerShape is ConcavePolygon) tris = Triangle.GetTrianglesFromPoints(outerShape as ConcavePolygon, points);
else tris = Triangle.GetTrianglesFromPoints(points);
// Check all triangles to determine applicability.
foreach (Triangle tri in tris)
{
// Avoid equilateral, isosceles, and right triangles.
if (!tri.IsEquilateral() && !tri.IsIsosceles() && !tri.isRightTriangle() && !tri.StructurallyEquals(outerShape))
{
SubtractionSynth subSynth = new SubtractionSynth(outerShape, tri);
try
{
subSynth.SetOpenRegions(FigSynthProblem.AcquireOpenAtomicRegions(conns, tri.points, tri));
composed.Add(subSynth);
}
catch (Exception) { }
}
}
return FigSynthProblem.RemoveSymmetric(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 override FigSynthProblem Copy()
{
SubtractionSynth copy = new SubtractionSynth(this.leftProblem.Copy(), this.rightProblem.Copy());
copy.SetOpenRegions(new List<AtomicRegion>(this.openRegions));
return copy;
}
//
// Append subtraction to this current problem; the subtraction occurs within one of the open atomic regions.
//
public static FigSynthProblem AppendAtomicSubtraction(FigSynthProblem that, FigSynthProblem toAppend)
{
BinarySynthOperation binaryAppend = toAppend as BinarySynthOperation;
if (binaryAppend == null) return null;
// Verify that the outer part of toAppend is an open atomic region.
if (!that.openRegions.Contains(new ShapeAtomicRegion((binaryAppend.leftProblem as UnarySynth).figure)))
{
throw new ArgumentException("Shape is not an open atomic region: " + (binaryAppend.leftProblem as UnarySynth).figure);
}
// Since the 'left' expression was an open region, the 'right' is the actual shape we are appending.
SubtractionSynth newSub = new SubtractionSynth(that.Copy(), binaryAppend.rightProblem);
// Update the open regions to the inner-most shape.
newSub.SetOpenRegions(toAppend.openRegions);
return newSub;
}
