/// <summary> /// Compares the imput rectangles and caculates the portion of the new rctangle not included in the old. /// </summary> /// <param name="current"> The current rectangle</param> /// <param name="previous">The previous rectangle</param> /// <returns>An array of rectangles describing the difference between the input rectangles.</returns> /// <remarks> /// This funtion is a liner exclusive OR on 2 rectangles. It is catagorized by specifying the order of the /// rectangles in a linear fashion so that the xor'd intersection is directional. A natural XOR intersection /// would include the portions of both rectangles not found the intersction of the two. A Linear XOR includes /// only the portion of the current rectangle not found in the intersection of the two. /// </remarks> public static RectangleF[] GetRegionScans(RectangleF current, RectangleF previous) { // If the extents are equal, or one contains the other, or they're not intersecting there's nothing // to do. Return the current rectangle. if ( !current.Equals(previous) && !Contains(current, previous) && !Contains(previous, current) && IntersectsWith(current, previous)) { // Get the horizontal rectangle, uncovered from a north or south pan RectangleF h = RectangleFHelper.FromLTRB( current.Left, //current.Left < previous.Left ? current.Left : previous.Left, current.Top < previous.Top ? current.Top : previous.Bottom, current.Right, //current.Left < previous.Left ? previous.Right : current.Right, current.Top < previous.Top ? previous.Top : current.Bottom ); // Get the vertical rectangle, uncovered from an east or west pan RectangleF v = RectangleFHelper.FromLTRB( current.Left < previous.Left ? current.Left : previous.Right, current.Top < previous.Top ? previous.Top : current.Top, current.Left < previous.Left ? previous.Left : current.Right, current.Top < previous.Top ? current.Bottom : previous.Bottom ); // Retangles with no width or height are excluded if ((h.Height <= 0 || h.Width <= 0) && (v.Height <= 0 || v.Width <= 0)) { return new RectangleF[] { current } } ; // Retangles with no width or height are excluded if (h.Height <= 0 || h.Width <= 0) { return new RectangleF[] { v } } ; if (v.Height <= 0 || v.Width <= 0) { return new RectangleF[] { h } } ; return(new RectangleF[] { h, v }); } return(new RectangleF[] { current }); }
/// <summary> /// Calculates the bounding rectangle for the supplied points. /// </summary> /// <returns></returns> public static RectangleF ComputeBoundingBox(PointF[] projectedPoints) { // ffs if (projectedPoints.Length == 0) { return(RectangleF.Empty); } // Now figure out which points represent the maximum bounds, starting // with the first point float projectedLeft = projectedPoints[0].X; float projectedRight = projectedPoints[0].X; float projectedTop = projectedPoints[0].Y; float projectedBottom = projectedPoints[0].Y; // Now consider all other points int Limit = projectedPoints.Length; for (int index = 1; index < Limit; index++) { // Get the current projected point PointF projectedPoint = projectedPoints[index]; // Now see if it exceeds the current bounds if (projectedPoint.X < projectedLeft) { projectedLeft = projectedPoint.X; } if (projectedPoint.X > projectedRight) { projectedRight = projectedPoint.X; } if (projectedPoint.Y < projectedTop) { projectedTop = projectedPoint.Y; } if (projectedPoint.Y > projectedBottom) { projectedBottom = projectedPoint.Y; } } // finally, return a rectangle with these bounds #if PocketPC return(RectangleFHelper.FromLTRB(projectedLeft, projectedTop, projectedRight, projectedBottom)); #else return(RectangleF.FromLTRB(projectedLeft, projectedTop, projectedRight, projectedBottom)); #endif }
public static RectangleF Inflate(RectangleF rectangle, float x, float y) { return(RectangleFHelper.FromLTRB(rectangle.X - x, rectangle.Y - y, rectangle.Right + x, rectangle.Bottom + y)); }