public void TestRange5()
{
Range range1 = new Range(1, 2, true);
Range range2 = new Range(1.1, 1.3, true);
Assert.IsTrue(range1.IntersectsWith(range2));
Assert.IsTrue(range2.IntersectsWith(range1));
Assert.IsTrue(Double.IsPositiveInfinity(range1.Length));
Assert.IsTrue(Double.IsPositiveInfinity(range2.Length));
}
public void TestRange6()
{
const double eps = 1e-10;
Range range1 = new Range(1, 1);
Range range2 = new Range(1, 2);
Assert.IsTrue(range1.IntersectsWith(range2));
Assert.IsTrue(range2.IntersectsWith(range1));
Assert.AreEqual(range1.Length, 0, eps);
Assert.AreEqual(range2.Length, 1, eps);
}
public void TestRange4()
{
const double eps = 1e-10;
Range range1 = new Range(1, 2, true);
Range range2 = new Range(1.1, 1.3, false);
Assert.IsFalse(range1.IntersectsWith(range2));
Assert.IsFalse(range2.IntersectsWith(range1));
Assert.IsTrue(Double.IsPositiveInfinity(range1.Length));
Assert.AreEqual(range2.Length, 0.2, eps);
}
public void TestRange2()
{
const double eps = 1e-10;
Range range1 = new Range(1, 2);
Range range2 = new Range(2.1, 2.5);
Assert.IsFalse(range1.IntersectsWith(range2));
Assert.IsFalse(range2.IntersectsWith(range1));
Assert.AreEqual(range1.Length, 1, eps);
Assert.AreEqual(range2.Length, 0.4, eps);
}
private static double CalculateSingleEdgeLowerBound(
ShapeModel model, ShapeConstraints shapeConstraints, IList<ILengthAngleConstraints> lengthAngleConstraints)
{
// TODO: support models with multiple edges but without pairwise constraints
Debug.Assert(model.Structure.Edges.Count == 1);
Debug.Assert(lengthAngleConstraints.Count == 1);
double result;
// Calculate best possible edge width penalty
EdgeConstraints edgeConstraints = shapeConstraints.EdgeConstraints[0];
ShapeEdgeParams edgeParams = model.GetEdgeParams(0);
Range lengthBoundary = lengthAngleConstraints[0].LengthBoundary;
Range scaledLengthRange = new Range(lengthBoundary.Left * edgeParams.WidthToEdgeLengthRatio, lengthBoundary.Right * edgeParams.WidthToEdgeLengthRatio);
Range widthRange = new Range(edgeConstraints.MinWidth, edgeConstraints.MaxWidth);
if (scaledLengthRange.IntersectsWith(widthRange))
result = 0;
else
{
result = model.CalculateEdgeWidthEnergyTerm(0, widthRange.Right, lengthBoundary.Left);
result = Math.Min(result, model.CalculateEdgeWidthEnergyTerm(0, widthRange.Left, lengthBoundary.Right));
}
return result;
}
public void TestRange8()
{
Range range1 = new Range(1, 2);
Range range2 = new Range(1, 2);
Assert.IsTrue(range1.IntersectsWith(range2));
Assert.IsTrue(range2.IntersectsWith(range1));
}
public static BoxLengthAngleConstraints FromVertexConstraints(VertexConstraints constraints1, VertexConstraints constraints2)
{
Range angleRange;
Range xRange1 = new Range(constraints1.MinCoord.X, constraints1.MaxCoord.X);
Range yRange1 = new Range(constraints1.MinCoord.Y, constraints1.MaxCoord.Y);
Range xRange2 = new Range(constraints2.MinCoord.X, constraints2.MaxCoord.X);
Range yRange2 = new Range(constraints2.MinCoord.Y, constraints2.MaxCoord.Y);
bool xIntersection = xRange1.IntersectsWith(xRange2);
bool yIntersection = yRange1.IntersectsWith(yRange2);
double minLength = Double.PositiveInfinity, maxLength = 0;
if (xIntersection && yIntersection)
{
// Special case: intersecting rectangles
angleRange = new Range(-Math.PI, Math.PI);
minLength = 0;
}
else
{
// Angle changes from PI to -PI when second constraint is to the left of the first one
bool angleSignChanges = constraints1.MinCoord.X > constraints2.MaxCoord.X && yIntersection;
double minAngle = angleSignChanges ? -Math.PI : Math.PI;
double maxAngle = angleSignChanges ? Math.PI : -Math.PI;
foreach (Vector point1 in constraints1.Corners)
{
foreach (Vector point2 in constraints2.Corners)
{
double angle = Vector.AngleBetween(new Vector(1, 0), point2 - point1);
if (angleSignChanges)
{
if (angle < 0)
minAngle = Math.Max(minAngle, angle);
else
maxAngle = Math.Min(maxAngle, angle);
}
else
{
minAngle = Math.Min(minAngle, angle);
maxAngle = Math.Max(maxAngle, angle);
}
}
}
angleRange = new Range(minAngle, maxAngle, angleSignChanges);
// One constraint is on top or on bottom of another
if (xIntersection)
{
// 1 on top of 2
if (constraints1.MinCoord.Y > constraints2.MaxCoord.Y)
minLength = Math.Min(minLength, constraints1.MinCoord.Y - constraints2.MaxCoord.Y);
// 2 on top of 1
else
minLength = Math.Min(minLength, constraints2.MinCoord.Y - constraints1.MaxCoord.Y);
}
else if (yIntersection)
{
// 1 to the left of 2
if (constraints1.MaxCoord.X < constraints2.MinCoord.X)
minLength = Math.Min(minLength, constraints2.MinCoord.X - constraints1.MaxCoord.X);
// 2 to the left of 1
else
minLength = Math.Min(minLength, constraints1.MinCoord.X - constraints2.MaxCoord.X);
}
}
foreach (Vector point1 in constraints1.Corners)
{
foreach (Vector point2 in constraints2.Corners)
{
double length = (point1 - point2).Length;
minLength = Math.Min(minLength, length);
maxLength = Math.Max(maxLength, length);
}
}
Range lengthRange = new Range(minLength, maxLength);
return new BoxLengthAngleConstraints(lengthRange, angleRange);
}
public void TestEdgeConstraintSplitsNonIntersection()
{
EdgeConstraints constraints = new EdgeConstraints(3, 5);
List<EdgeConstraints> split = constraints.Split();
Assert.IsTrue(split.Count == 2);
Range range1 = new Range(split[0].MinWidth, split[0].MaxWidth, false);
Range range2 = new Range(split[1].MinWidth, split[1].MaxWidth, false);
Assert.IsFalse(range1.IntersectsWith(range2));
}
public void TestVertexConstraintSplitsNonIntersection()
{
VertexConstraints constraints = new VertexConstraints(new Vector(0, 0), new Vector(1, 1));
List<VertexConstraints> split = constraints.Split();
Assert.IsTrue(split.Count == 4);
for (int i = 0; i < split.Count; ++i)
{
for (int j = i + 1; j < split.Count; ++j)
{
Range xRange1 = new Range(split[i].MinCoord.X, split[i].MaxCoord.X, false);
Range yRange1 = new Range(split[i].MinCoord.Y, split[i].MaxCoord.Y, false);
Range xRange2 = new Range(split[j].MinCoord.X, split[j].MaxCoord.X, false);
Range yRange2 = new Range(split[j].MinCoord.Y, split[j].MaxCoord.Y, false);
Assert.IsFalse(xRange1.IntersectsWith(xRange2) && yRange1.IntersectsWith(yRange2));
}
}
}
