public static void GeometricCenter_Returns_GeometricCenter_of_Extents()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7.5),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7.5, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9.5, extents.Height);
CartesianCoordinate geometricCenter = extents.GeometricCenter();
Assert.AreEqual(2.5, geometricCenter.X);
Assert.AreEqual(2.75, geometricCenter.Y);
}
public static void Translate_Returns_Translated_Copy_of_Extents()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
PointExtents translatedExtents = extents.Translate(3, 4) as PointExtents;
Assert.AreEqual(3, translatedExtents.MinX);
Assert.AreEqual(8, translatedExtents.MaxX);
Assert.AreEqual(2, translatedExtents.MinY);
Assert.AreEqual(11, translatedExtents.MaxY);
Assert.AreEqual(5, translatedExtents.Width);
Assert.AreEqual(9, translatedExtents.Height);
}
public static void Clone_Returns_Copy_of_Extents()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
PointExtents extentsClone = extents.Clone();
Assert.AreEqual(0, extentsClone.MinX);
Assert.AreEqual(5, extentsClone.MaxX);
Assert.AreEqual(-2, extentsClone.MinY);
Assert.AreEqual(7, extentsClone.MaxY);
Assert.AreEqual(5, extentsClone.Width);
Assert.AreEqual(9, extentsClone.Height);
}
public static void Extents_Returns_Extents_of_Boundary()
{
List <CartesianCoordinate> coordinates = new List <CartesianCoordinate>()
{
new CartesianCoordinate(0, 0),
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 4),
new CartesianCoordinate(5, 6)
};
List <LineSegment> segments = new List <LineSegment>()
{
new LineSegment(coordinates[0], coordinates[1]),
new LineSegment(coordinates[1], coordinates[2]),
new LineSegment(coordinates[2], coordinates[3])
};
SegmentsBoundary boundary = new SegmentsBoundary(segments);
Assert.IsTrue(boundary.IsReadOnly);
Assert.AreEqual(3, boundary.Count);
PointExtents extents = boundary.Extents() as PointExtents;
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(0, extents.MinY);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(6, extents.MaxY);
}
public static void Clear_Clears_Extents()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
extents.Clear();
Assert.AreEqual(double.NegativeInfinity, extents.MinX);
Assert.AreEqual(double.PositiveInfinity, extents.MaxX);
Assert.AreEqual(double.NegativeInfinity, extents.MinY);
Assert.AreEqual(double.PositiveInfinity, extents.MaxY);
Assert.AreEqual(double.PositiveInfinity, extents.Width);
Assert.AreEqual(double.PositiveInfinity, extents.Height);
}
/// <summary>
/// Initializes the segment to span between the provided points.
/// </summary>
/// <param name="i">First point of the line.</param>
/// <param name="j">Second point of the line.</param>
protected PathSegment(CartesianCoordinate i, CartesianCoordinate j)
{
i.Tolerance = _tolerance;
j.Tolerance = _tolerance;
I = i;
J = j;
_extents = new PointExtents(i, j);
}
/// <summary>
/// Determines if the point lies below the segment extents end.
/// </summary>
/// <param name="yPtN">The y-coordinate of pt n.</param>
/// <param name="segment">The segment.</param>
/// <returns><c>true</c> if the point lies to below the segment bottom, <c>false</c> otherwise.</returns>
public static bool PointIsBelowSegmentExtentsExclusive(
double yPtN,
IPathSegment segment)
{
PointExtents extents = segment.Extents;
return(yPtN < extents.MaxY);
}
/// <summary>
/// Determines if the point lies within the segment extents width.
/// </summary>
/// <param name="xPtN">The x-coordinate of pt n.</param>
/// <param name="segment">The segment.</param>
/// <returns><c>true</c> if the point lies within the segment width, <c>false</c> otherwise.</returns>
public static bool PointIsWithinSegmentExtentsWidthExclusive(
double xPtN,
IPathSegment segment)
{
PointExtents extents = segment.Extents;
return(extents.MinX < xPtN && xPtN < extents.MaxX);
}
/// <summary>
/// Determines if the point lies within the segment extents height, not including the boundary locations.
/// </summary>
/// <param name="yPtN">The y-coordinate of pt n.</param>
/// <param name="segment">The segment.</param>
/// <returns><c>true</c> if the point lies within the segment extents height, <c>false</c> otherwise.</returns>
public static bool PointIsWithinSegmentExtentsHeightExclusive(
double yPtN,
IPathSegment segment)
{
PointExtents extents = segment.Extents;
return(extents.MinY < yPtN && yPtN < extents.MaxY);
}
/// <summary>
/// Determines if the point lies to the left of the segment extents max x-coordinate, not including the boundary coordinate.
/// </summary>
/// <param name="xPtN">The x-coordinate of pt n.</param>
/// <param name="segment">The segment.</param>
/// <returns><c>true</c> if the point lies to the left of the segment end, <c>false</c> otherwise.</returns>
public static bool PointIsLeftOfSegmentExtentsEndExclusive(
double xPtN,
IPathSegment segment)
{
PointExtents extents = segment.Extents;
return(xPtN < extents.MaxX);
}
public static void Extents()
{
Polygon polygon = new Polygon(bowTieNonCrossingSegments);
PointExtents pointExtents = polygon.Extents();
Assert.AreEqual(0, pointExtents.MinX);
Assert.AreEqual(2, pointExtents.MaxX);
Assert.AreEqual(1, pointExtents.MinY);
Assert.AreEqual(3, pointExtents.MaxY);
}
public static void Initialization_without_Coordinates_Results_in_Empty_Object()
{
PointExtents extents = new PointExtents();
Assert.AreEqual(double.PositiveInfinity, extents.MaxY);
Assert.AreEqual(double.PositiveInfinity, extents.MaxX);
Assert.AreEqual(double.NegativeInfinity, extents.MinY);
Assert.AreEqual(double.NegativeInfinity, extents.MinX);
Assert.AreEqual(double.PositiveInfinity, extents.Width);
Assert.AreEqual(double.PositiveInfinity, extents.Height);
}
public static void Initialization_with_Empty_Coordinates_List()
{
PointExtents extents = new PointExtents(new List <CartesianCoordinate>());
Assert.AreEqual(double.NegativeInfinity, extents.MinX);
Assert.AreEqual(double.PositiveInfinity, extents.MaxX);
Assert.AreEqual(double.NegativeInfinity, extents.MinY);
Assert.AreEqual(double.PositiveInfinity, extents.MaxY);
Assert.AreEqual(double.PositiveInfinity, extents.Width);
Assert.AreEqual(double.PositiveInfinity, extents.Height);
}
public static void Initialization_with_2_Coordinates_Results_Object()
{
PointExtents extents = new PointExtents(
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5)
);
Assert.AreEqual(1, extents.MinX);
Assert.AreEqual(3, extents.MaxX);
Assert.AreEqual(2, extents.MinY);
Assert.AreEqual(5, extents.MaxY);
Assert.AreEqual(2, extents.Width);
Assert.AreEqual(3, extents.Height);
}
/// <summary>
/// Initializes a new instance of the <see cref="ElasticBendingProperties"/> class.
/// </summary>
/// <param name="extents">The extents.</param>
/// <param name="centroid">The centroid.</param>
/// <param name="rotationalInertia">The rotational inertia.</param>
public ElasticBendingProperties(PointExtents extents, CartesianCoordinate centroid, MomentOfInertia rotationalInertia)
{
PointExtents extentsAlignedAtCentroid = CalculateExtentsAlignedAtCentroid(extents, centroid);
Extents_33positive = NMath.Abs(extentsAlignedAtCentroid.MaxX);
Extents_33negative = NMath.Abs(extentsAlignedAtCentroid.MinX);
Extents_22positive = NMath.Abs(extentsAlignedAtCentroid.MaxY);
Extents_22negative = NMath.Abs(extentsAlignedAtCentroid.MinY);
S_22positive = CalculateElasticModulus(rotationalInertia.I_22, Extents_33positive);
S_22negative = CalculateElasticModulus(rotationalInertia.I_22, Extents_33negative);
S_33positive = CalculateElasticModulus(rotationalInertia.I_33, Extents_22positive);
S_33negative = CalculateElasticModulus(rotationalInertia.I_33, Extents_22negative);
}
public static void Initialization_with_2_Collinear_Coordinates_Horizontal_List()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(2, 2)
});
Assert.AreEqual(1, extents.MinX);
Assert.AreEqual(2, extents.MaxX);
Assert.AreEqual(2, extents.MinY);
Assert.AreEqual(2, extents.MaxY);
Assert.AreEqual(1, extents.Width);
Assert.AreEqual(0, extents.Height);
}
public static void Extents_Returns_Extends_of_Boundary()
{
List <CartesianCoordinate> coordinates = new List <CartesianCoordinate>()
{
new CartesianCoordinate(0, 0),
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 4),
new CartesianCoordinate(5, 6)
};
PointBoundary boundary = new PointBoundary(coordinates);
PointExtents extents = boundary.Extents() as PointExtents;
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(0, extents.MinY);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(6, extents.MaxY);
}
public static void IsWithinExtents_Returns_True_if_Point_is_within_Extents_False_otherwise()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
CartesianCoordinate coordinateWithinExtents = new CartesianCoordinate(1, 1);
Assert.IsTrue(extents.IsWithinExtents(coordinateWithinExtents));
CartesianCoordinate coordinateOutsideExtentsX = new CartesianCoordinate(6, 1);
Assert.IsFalse(extents.IsWithinExtents(coordinateOutsideExtentsX));
CartesianCoordinate coordinateOutsideExtentsY = new CartesianCoordinate(1, 8);
Assert.IsFalse(extents.IsWithinExtents(coordinateOutsideExtentsY));
CartesianCoordinate coordinateOutsideExtentsXY = new CartesianCoordinate(6, 8);
Assert.IsFalse(extents.IsWithinExtents(coordinateOutsideExtentsXY));
}
public static void AddRange_Updates_Extents_Boundaries_for_Any_Point_that_Lies_Outside_Current_Extents()
{
PointExtents extents = new PointExtents();
extents.AddRange(new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
}
public static void Initialization_with_Multiple_Coordinates_List()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
}
);
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
}
public static void ScaleFromPoint_Scales_Shape(double scale,
double expectedCentroid_x, double expectedCentroid_y)
{
List <CartesianCoordinate> bowTieNonCrossingSegmentsScaled = new List <CartesianCoordinate>()
{
new CartesianCoordinate(4, 3.5),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(3, 2),
new CartesianCoordinate(4, 3.5),
new CartesianCoordinate(5, 2),
new CartesianCoordinate(5, 5),
new CartesianCoordinate(4, 3.5),
};
Polygon polygon = new Polygon(bowTieNonCrossingSegmentsScaled);
// Check shape position
CartesianCoordinate originalCentroid = polygon.Centroid;
Assert.AreEqual(4, originalCentroid.X);
Assert.AreEqual(3.5, originalCentroid.Y);
CartesianCoordinate referencePoint = new CartesianCoordinate(2, 1);
Polygon polygonScaled = polygon.ScaleFromPoint(scale, referencePoint) as Polygon;
// Check shape scale
PointExtents extents = polygonScaled.Extents();
Assert.AreEqual(2 * scale.Abs(), extents.Width);
Assert.AreEqual(3 * scale.Abs(), extents.Height);
// Check scaled centroid position
CartesianCoordinate scaledCentroid = polygonScaled.Centroid;
Assert.AreEqual(expectedCentroid_x, scaledCentroid.X);
Assert.AreEqual(expectedCentroid_y, scaledCentroid.Y);
}
public static void Reset_Resets_Extents()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
List <CartesianCoordinate> newList = new List <CartesianCoordinate>()
{
new CartesianCoordinate(-1, -2),
new CartesianCoordinate(1, 1),
new CartesianCoordinate(1, -7)
};
extents.Reset(newList);
Assert.AreEqual(-1, extents.MinX);
Assert.AreEqual(1, extents.MaxX);
Assert.AreEqual(-7, extents.MinY);
Assert.AreEqual(1, extents.MaxY);
Assert.AreEqual(2, extents.Width);
Assert.AreEqual(8, extents.Height);
}
public static void Boundary_Returns_Boundary_Cordinates_of_Extents()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
IList <CartesianCoordinate> boundary = extents.Boundary();
Assert.AreEqual(0, boundary[0].X);
Assert.AreEqual(7, boundary[0].Y);
Assert.AreEqual(5, boundary[1].X);
Assert.AreEqual(7, boundary[1].Y);
Assert.AreEqual(5, boundary[2].X);
Assert.AreEqual(-2, boundary[2].Y);
Assert.AreEqual(0, boundary[3].X);
Assert.AreEqual(-2, boundary[3].Y);
}
public static void Rotate_Returns_Rotated_Copy_of_Extents()
{
PointExtents extents = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
PointExtents rotatedExtents = extents.Rotate(Numbers.PiOver4) as PointExtents;
Assert.AreEqual(-2.449747, rotatedExtents.MinX, Tolerance);
Assert.AreEqual(7.449747, rotatedExtents.MaxX, Tolerance);
Assert.AreEqual(-2.449747, rotatedExtents.MinY, Tolerance);
Assert.AreEqual(7.449747, rotatedExtents.MaxY, Tolerance);
rotatedExtents = rotatedExtents.Rotate(1.8 * Numbers.Pi) as PointExtents;
Assert.AreEqual(-4.413818, rotatedExtents.MinX, Tolerance);
Assert.AreEqual(9.413818, rotatedExtents.MaxX, Tolerance);
Assert.AreEqual(-4.413818, rotatedExtents.MinY, Tolerance);
Assert.AreEqual(9.413818, rotatedExtents.MaxY, Tolerance);
}
public static void Add_Updates_Extents_Boundaries_if_Point_Lies_Outside_Current_Extents()
{
PointExtents extents = new PointExtents();
// Empty
Assert.AreEqual(double.NegativeInfinity, extents.MinX);
Assert.AreEqual(double.PositiveInfinity, extents.MaxX);
Assert.AreEqual(double.NegativeInfinity, extents.MinY);
Assert.AreEqual(double.PositiveInfinity, extents.MaxY);
Assert.AreEqual(double.PositiveInfinity, extents.Width);
Assert.AreEqual(double.PositiveInfinity, extents.Height);
// First Point
extents.Add(new CartesianCoordinate(1, 2));
Assert.AreEqual(double.NegativeInfinity, extents.MinX);
Assert.AreEqual(double.PositiveInfinity, extents.MaxX);
Assert.AreEqual(double.NegativeInfinity, extents.MinY);
Assert.AreEqual(double.PositiveInfinity, extents.MaxY);
Assert.AreEqual(double.PositiveInfinity, extents.Width);
Assert.AreEqual(double.PositiveInfinity, extents.Height);
// Second Point
extents.Add(new CartesianCoordinate(3, 5));
Assert.AreEqual(1, extents.MinX);
Assert.AreEqual(3, extents.MaxX);
Assert.AreEqual(2, extents.MinY);
Assert.AreEqual(5, extents.MaxY);
Assert.AreEqual(2, extents.Width);
Assert.AreEqual(3, extents.Height);
// Third Point
extents.Add(new CartesianCoordinate(2, 6));
Assert.AreEqual(1, extents.MinX);
Assert.AreEqual(3, extents.MaxX);
Assert.AreEqual(2, extents.MinY);
Assert.AreEqual(6, extents.MaxY);
Assert.AreEqual(2, extents.Width);
Assert.AreEqual(4, extents.Height);
// Point Beyond Min X
extents.Add(new CartesianCoordinate(0, 4));
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(3, extents.MaxX);
Assert.AreEqual(2, extents.MinY);
Assert.AreEqual(6, extents.MaxY);
Assert.AreEqual(3, extents.Width);
Assert.AreEqual(4, extents.Height);
// Point Beyond Min Y
extents.Add(new CartesianCoordinate(1.5, -2));
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(3, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(6, extents.MaxY);
Assert.AreEqual(3, extents.Width);
Assert.AreEqual(8, extents.Height);
// Point Beyond Max X
extents.Add(new CartesianCoordinate(5, 4));
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(6, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(8, extents.Height);
// Point Beyond Max Y
extents.Add(new CartesianCoordinate(1, 7));
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
// Point Inside
extents.Add(new CartesianCoordinate(3.5, -1));
Assert.AreEqual(0, extents.MinX);
Assert.AreEqual(5, extents.MaxX);
Assert.AreEqual(-2, extents.MinY);
Assert.AreEqual(7, extents.MaxY);
Assert.AreEqual(5, extents.Width);
Assert.AreEqual(9, extents.Height);
}
public static void AddExtents_Updates_Extents_Boundaries_if_Provided_Extents_Extends_Outside_Current_Extents()
{
PointExtents extents1 = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1, 2),
new CartesianCoordinate(3, 5),
new CartesianCoordinate(2, 6),
new CartesianCoordinate(0, 4),
new CartesianCoordinate(1.5, -2)
});
Assert.AreEqual(0, extents1.MinX);
Assert.AreEqual(3, extents1.MaxX);
Assert.AreEqual(-2, extents1.MinY);
Assert.AreEqual(6, extents1.MaxY);
Assert.AreEqual(3, extents1.Width);
Assert.AreEqual(8, extents1.Height);
PointExtents extents2 = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(1.5, -2),
new CartesianCoordinate(5, 4),
new CartesianCoordinate(1, 7),
new CartesianCoordinate(3.5, -1)
});
Assert.AreEqual(1, extents2.MinX);
Assert.AreEqual(5, extents2.MaxX);
Assert.AreEqual(-2, extents2.MinY);
Assert.AreEqual(7, extents2.MaxY);
Assert.AreEqual(4, extents2.Width);
Assert.AreEqual(9, extents2.Height);
extents1.AddExtents(extents2);
Assert.AreEqual(0, extents1.MinX);
Assert.AreEqual(5, extents1.MaxX);
Assert.AreEqual(-2, extents1.MinY);
Assert.AreEqual(7, extents1.MaxY);
Assert.AreEqual(5, extents1.Width);
Assert.AreEqual(9, extents1.Height);
PointExtents extents3 = new PointExtents(
new List <CartesianCoordinate>()
{
new CartesianCoordinate(-1, -2),
new CartesianCoordinate(1, 1),
new CartesianCoordinate(1, -7)
});
Assert.AreEqual(-1, extents3.MinX);
Assert.AreEqual(1, extents3.MaxX);
Assert.AreEqual(-7, extents3.MinY);
Assert.AreEqual(1, extents3.MaxY);
Assert.AreEqual(2, extents3.Width);
Assert.AreEqual(8, extents3.Height);
extents1.AddExtents(extents3);
Assert.AreEqual(-1, extents1.MinX);
Assert.AreEqual(5, extents1.MaxX);
Assert.AreEqual(-7, extents1.MinY);
Assert.AreEqual(7, extents1.MaxY);
Assert.AreEqual(6, extents1.Width);
Assert.AreEqual(14, extents1.Height);
}
/// <summary>
/// Calculates the extents aligned at centroid.
/// </summary>
/// <param name="extents">The extents.</param>
/// <param name="centroid">The centroid.</param>
/// <returns>PointExtents.</returns>
public static PointExtents CalculateExtentsAlignedAtCentroid(PointExtents extents, CartesianCoordinate centroid)
{
PointExtents extentsAlignedAtCentroid = extents.Translate(-centroid.X, -centroid.Y) as PointExtents;
return(extentsAlignedAtCentroid);
}
