AreasL (com.io7m.jregions.documentation 0.0.4 API)

java.lang.Object
- com.io7m.jregions.core.unparameterized.areas.AreasL

```
public final class AreasL
extends Object
```
Functions over areas.

These functions operate using the concepts of minimum-x, maximum-x, minimum-y, and maximum-y edges. It is up to individual applications to assign meaning to these edges such as "left" for minimum-x and "top" for minimum-y.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static AreaL`	`alignCenter(AreaL outer, AreaL inner)` Align the area `inner` such that the center of the area is equal to the center of `outer`.
`static AreaL`	`alignHorizontallyCenter(AreaL outer, AreaL inner)` Align the area `inner` horizontally in the center of `outer`.
`static AreaL`	`alignHorizontallyMaxX(AreaL outer, AreaL inner)` Equivalent to calling `alignHorizontallyMaxXOffset(AreaL, AreaL, long)` with a zero offset.
`static AreaL`	`alignHorizontallyMaxXOffset(AreaL outer, AreaL inner, long offset)` Align the area `inner` horizontally against the inside maximum-x edge of `outer`.
`static AreaL`	`alignHorizontallyMinX(AreaL outer, AreaL inner)` Equivalent to calling `alignHorizontallyMinXOffset(AreaL, AreaL, long)` with a zero offset.
`static AreaL`	`alignHorizontallyMinXOffset(AreaL outer, AreaL inner, long offset)` Align the area `inner` horizontally against the inside minimum-x edge of `outer`.
`static AreaL`	`alignMaxYMaxX(AreaL outer, AreaL inner)` Equivalent to calling `alignMaxYMaxXOffset(AreaL, AreaL, long, long)` with zero offsets.
`static AreaL`	`alignMaxYMaxXOffset(AreaL outer, AreaL inner, long offset_x, long offset_y)` Align the area `inner` such that the maximum-y edge is at least `offset_y` from the inside maximum-y edge of `outer` and the maximum-x edge is at least `offset_x` from the inside maximum-x edge of `outer`.
`static AreaL`	`alignMaxYMinX(AreaL outer, AreaL inner)` Equivalent to calling `alignMaxYMinXOffset(AreaL, AreaL, long, long)` with zero offsets.
`static AreaL`	`alignMaxYMinXOffset(AreaL outer, AreaL inner, long offset_x, long offset_y)` Align the area `inner` such that the maximum-y edge is at least `offset_y` from the inside maximum-y edge of `outer` and the minimum-x edge is at least `offset_x` from the inside minimum-x edge of `outer`.
`static AreaL`	`alignMinYMaxX(AreaL outer, AreaL inner)` Equivalent to calling `alignMinYMaxXOffset(AreaL, AreaL, long, long)` with zero offsets.
`static AreaL`	`alignMinYMaxXOffset(AreaL outer, AreaL inner, long offset_x, long offset_y)` Align the area `inner` such that the minimum-y edge is at least `offset_y` from the inside minimum-y edge of `outer` and the maximum-x edge is at least `offset_x` from the inside maximum-x edge of `outer`.
`static AreaL`	`alignMinYMinX(AreaL outer, AreaL inner)` Equivalent to calling `alignMinYMinXOffset(AreaL, AreaL, long, long)` with zero offsets.
`static AreaL`	`alignMinYMinXOffset(AreaL outer, AreaL inner, long offset_x, long offset_y)` Align the area `inner` such that the minimum-y edge is at least `offset_y` from the inside minimum-y edge of `outer` and the minimum-x edge is at least `offset_x` from the inside minimum-x edge of `outer`.
`static AreaL`	`alignVerticallyCenter(AreaL outer, AreaL inner)` Align the area `inner` vertically in the center of `outer`.
`static AreaL`	`alignVerticallyMaxY(AreaL outer, AreaL inner)` Equivalent to calling `alignVerticallyMaxYOffset(AreaL, AreaL, long)` with a zero offset.
`static AreaL`	`alignVerticallyMaxYOffset(AreaL outer, AreaL inner, long offset)` Align the area `inner` vertically against the inside maximum-y edge of `outer`.
`static AreaL`	`alignVerticallyMinY(AreaL outer, AreaL inner)` Equivalent to calling `alignVerticallyMinYOffset(AreaL, AreaL, long)` with a zero offset.
`static AreaL`	`alignVerticallyMinYOffset(AreaL outer, AreaL inner, long offset)` Align the area `inner` vertically against the inside minimum-y edge of `outer`.
`static AreaL`	`containing(AreaL a, AreaL b)` Construct a area that will contain both `a` and `b`.
`static boolean`	`contains(AreaL a, AreaL b)` Determine whether or not one area contains another.
`static boolean`	`containsPoint(AreaL a, long x, long y)` Determine whether or not a area contains a given point.
`static boolean`	`couldFitInside(AreaL a, AreaL b)` Determine whether or not one area could fit inside another.
`static AreaL`	`create(long x, long y, long width, long height)` Create an area of width `width` and height `height`, placing the minimum corner at `(x, y)`.
`static AreaL`	`fitBetweenHorizontal(AreaL fit, AreaL a, AreaL b)` Attempt to fit `fit` between `a` and `b`, horizontally.
`static AreaL`	`fitBetweenVertical(AreaL fit, AreaL a, AreaL b)` Attempt to fit `fit` between `a` and `b`, vertically.
`static AreaL`	`hollowOut(AreaL outer, long min_x_offset, long max_x_offset, long min_y_offset, long max_y_offset)` Construct a new area that fits inside `outer` based on the given offsets from each edge.
`static AreaL`	`hollowOutEvenly(AreaL outer, long offset)` Equivalent to calling `hollowOut(AreaL, long, long, long, long)` with `offset` for all offset parameters.
`static AreaL`	`moveAbsolute(AreaL area, long x, long y)` Move the given area to `(x, y)`.
`static AreaL`	`moveRelative(AreaL area, long x, long y)` Move the given area by `(x, y)`.
`static AreaL`	`moveToOrigin(AreaL area)` Move the given area to `(0, 0)`.
`static boolean`	`overlaps(AreaL a, AreaL b)` Determine whether or not two areas overlap.
`static AreaL`	`scaleFromCenter(AreaL area, long x_diff, long y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaL`	`scaleFromMaxYMaxX(AreaL area, long x_diff, long y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaL`	`scaleFromMaxYMinX(AreaL area, long x_diff, long y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaL`	`scaleFromMinYMaxX(AreaL area, long x_diff, long y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaL`	`scaleFromMinYMinX(AreaL area, long x_diff, long y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaL`	`setSizeFromCenter(AreaL area, long width, long height)` Set the width and height of `area` to `width` and `height`, respectively.
`static AreaL`	`setSizeFromMaxYMaxX(AreaL area, long width, long height)` Set the width and height of `area` to `width` and `height`, respectively.
`static AreaL`	`setSizeFromMaxYMinX(AreaL area, long width, long height)` Set the width and height of `area` to `width` and `height`, respectively.
`static AreaL`	`setSizeFromMinYMaxX(AreaL area, long width, long height)` Set the width and height of `area` to `width` and `height`, respectively.
`static AreaL`	`setSizeFromMinYMinX(AreaL area, long width, long height)` Set the width and height of `area` to `width` and `height`, respectively.
`static String`	`show(AreaL area)`
`static String`	`showToBuilder(AreaL area, StringBuilder sb)`
`static AreaSizeL`	`size(AreaL area)`
`static AreaXSplitL<AreaL>`	`splitAlongParallelToX(AreaL area, long y)` Split `area` along a line parallel to the X axis placed at `y` units from its own minimum-y edge.
`static AreaYSplitL<AreaL>`	`splitAlongParallelToY(AreaL area, long x)` Split `area` along a line parallel to the Y axis placed at `x` units from its own minimum-x edge.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - create
```
public static AreaL create(long x,
                           long y,
                           long width,
                           long height)
```
    Create an area of width width and height height, placing the minimum corner at (x, y).
    
    Parameters:
    
    x - The X value of the minimum corner
    
    y - The Y value of the minimum corner
    
    width - The width of the area
    
    height - The height of the area
    
    Returns:
    
    An area
  - contains
```
public static boolean contains(AreaL a,
                               AreaL b)
```
    Determine whether or not one area contains another.
    
    Containing is reflexive: contains(a, a) == true.
    
    Containing is transitive: contains(a, b) → contains(b, c) → contains(a, c).
    
    Containing is not necessarily symmetric.
    
    Parameters:
    
    a - Area A
    
    b - Area B
    
    Returns:
    
    true iff a contains b
  - moveRelative
```
public static AreaL moveRelative(AreaL area,
                                 long x,
                                 long y)
```
    Move the given area by (x, y).
    
    Parameters:
    
    area - The area
    
    x - The amount to move on the X axis
    
    y - The amount to move on the Y axis
    
    Returns:
    
    A moved area
  - moveAbsolute
```
public static AreaL moveAbsolute(AreaL area,
                                 long x,
                                 long y)
```
    Move the given area to (x, y).
    
    Parameters:
    
    area - The area
    
    x - The position to which to move on the X axis
    
    y - The position to which to move on the Y axis
    
    Returns:
    
    A moved area
  - moveToOrigin
```
public static AreaL moveToOrigin(AreaL area)
```
    Move the given area to (0, 0).
    
    Parameters:
    
    area - The area
    
    Returns:
    
    A moved area
  - alignHorizontallyCenter
```
public static AreaL alignHorizontallyCenter(AreaL outer,
                                            AreaL inner)
```
    Align the area inner horizontally in the center of outer.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignHorizontallyMinX
```
public static AreaL alignHorizontallyMinX(AreaL outer,
                                          AreaL inner)
```
    Equivalent to calling alignHorizontallyMinXOffset(AreaL, AreaL, long) with a zero offset.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignHorizontallyMinXOffset
```
public static AreaL alignHorizontallyMinXOffset(AreaL outer,
                                                AreaL inner,
                                                long offset)
```
    Align the area inner horizontally against the inside minimum-x edge of outer. The area will be at least offset units from the minimum-x edge.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    offset - The offset from the edge s
    
    Returns:
    
    An aligned area
  - alignHorizontallyMaxX
```
public static AreaL alignHorizontallyMaxX(AreaL outer,
                                          AreaL inner)
```
    Equivalent to calling alignHorizontallyMaxXOffset(AreaL, AreaL, long) with a zero offset.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignHorizontallyMaxXOffset
```
public static AreaL alignHorizontallyMaxXOffset(AreaL outer,
                                                AreaL inner,
                                                long offset)
```
    Align the area inner horizontally against the inside maximum-x edge of outer. The area will be at least offset units from the maximum-x edge.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    offset - The offset from the edge s
    
    Returns:
    
    An aligned area
  - alignVerticallyMinY
```
public static AreaL alignVerticallyMinY(AreaL outer,
                                        AreaL inner)
```
    Equivalent to calling alignVerticallyMinYOffset(AreaL, AreaL, long) with a zero offset.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignVerticallyMinYOffset
```
public static AreaL alignVerticallyMinYOffset(AreaL outer,
                                              AreaL inner,
                                              long offset)
```
    Align the area inner vertically against the inside minimum-y edge of outer. The area will be at least offset units from the minimum-y edge.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    offset - The offset from the edge s
    
    Returns:
    
    An aligned area
  - alignVerticallyMaxY
```
public static AreaL alignVerticallyMaxY(AreaL outer,
                                        AreaL inner)
```
    Equivalent to calling alignVerticallyMaxYOffset(AreaL, AreaL, long) with a zero offset.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignVerticallyMaxYOffset
```
public static AreaL alignVerticallyMaxYOffset(AreaL outer,
                                              AreaL inner,
                                              long offset)
```
    Align the area inner vertically against the inside maximum-y edge of outer. The area will be at least offset units from the maximum-y edge.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    offset - The offset from the edge s
    
    Returns:
    
    An aligned area
  - alignVerticallyCenter
```
public static AreaL alignVerticallyCenter(AreaL outer,
                                          AreaL inner)
```
    Align the area inner vertically in the center of outer.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMinYMinX
```
public static AreaL alignMinYMinX(AreaL outer,
                                  AreaL inner)
```
    Equivalent to calling alignMinYMinXOffset(AreaL, AreaL, long, long) with zero offsets.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMinYMinXOffset
```
public static AreaL alignMinYMinXOffset(AreaL outer,
                                        AreaL inner,
                                        long offset_x,
                                        long offset_y)
```
    Align the area inner such that the minimum-y edge is at least offset_y from the inside minimum-y edge of outer and the minimum-x edge is at least offset_x from the inside minimum-x edge of outer.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    offset_x - The offset from the minimum-x edge
    
    offset_y - The offset from the minimum-y edge
    
    Returns:
    
    An aligned area
  - alignMinYMaxX
```
public static AreaL alignMinYMaxX(AreaL outer,
                                  AreaL inner)
```
    Equivalent to calling alignMinYMaxXOffset(AreaL, AreaL, long, long) with zero offsets.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMinYMaxXOffset
```
public static AreaL alignMinYMaxXOffset(AreaL outer,
                                        AreaL inner,
                                        long offset_x,
                                        long offset_y)
```
    Align the area inner such that the minimum-y edge is at least offset_y from the inside minimum-y edge of outer and the maximum-x edge is at least offset_x from the inside maximum-x edge of outer.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    offset_x - The offset from the maximum-x edge
    
    offset_y - The offset from the minimum-y edge
    
    Returns:
    
    An aligned area
  - alignMaxYMinX
```
public static AreaL alignMaxYMinX(AreaL outer,
                                  AreaL inner)
```
    Equivalent to calling alignMaxYMinXOffset(AreaL, AreaL, long, long) with zero offsets.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMaxYMinXOffset
```
public static AreaL alignMaxYMinXOffset(AreaL outer,
                                        AreaL inner,
                                        long offset_x,
                                        long offset_y)
```
    Align the area inner such that the maximum-y edge is at least offset_y from the inside maximum-y edge of outer and the minimum-x edge is at least offset_x from the inside minimum-x edge of outer.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    offset_x - The offset from the minimum-x edge
    
    offset_y - The offset from the maximum-y edge
    
    Returns:
    
    An aligned area
  - alignMaxYMaxX
```
public static AreaL alignMaxYMaxX(AreaL outer,
                                  AreaL inner)
```
    Equivalent to calling alignMaxYMaxXOffset(AreaL, AreaL, long, long) with zero offsets.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMaxYMaxXOffset
```
public static AreaL alignMaxYMaxXOffset(AreaL outer,
                                        AreaL inner,
                                        long offset_x,
                                        long offset_y)
```
    Align the area inner such that the maximum-y edge is at least offset_y from the inside maximum-y edge of outer and the maximum-x edge is at least offset_x from the inside maximum-x edge of outer.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    offset_x - The offset from the maximum-x edge
    
    offset_y - The offset from the maximum-y edge
    
    Returns:
    
    An aligned area
  - alignCenter
```
public static AreaL alignCenter(AreaL outer,
                                AreaL inner)
```
    Align the area inner such that the center of the area is equal to the center of outer.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - hollowOut
```
public static AreaL hollowOut(AreaL outer,
                              long min_x_offset,
                              long max_x_offset,
                              long min_y_offset,
                              long max_y_offset)
```
    Construct a new area that fits inside outer based on the given offsets from each edge.
    
    Parameters:
    
    outer - The containing area
    
    min_x_offset - The offset from the minimum-x edge (must be non-negative)
    
    max_x_offset - The offset from the maximum-x edge (must be non-negative)
    
    min_y_offset - The offset from the minimum-y edge (must be non-negative)
    
    max_y_offset - The offset from the maximum-y edge (must be non-negative)
    
    Returns:
    
    A new area
  - hollowOutEvenly
```
public static AreaL hollowOutEvenly(AreaL outer,
                                    long offset)
```
    Equivalent to calling hollowOut(AreaL, long, long, long, long) with offset for all offset parameters.
    
    Parameters:
    
    outer - The containing area
    
    offset - The offset from each edge (must be non-negative)
    
    Returns:
    
    A new area
  - setSizeFromCenter
```
public static AreaL setSizeFromCenter(AreaL area,
                                      long width,
                                      long height)
```
    Set the width and height of area to width and height, respectively.
    
    The area is resized from its own center.
    
    Parameters:
    
    area - The area
    
    width - The new width (must be non-negative)
    
    height - The new height (must be non-negative)
    
    Returns:
    
    A resized area
  - setSizeFromMinYMinX
```
public static AreaL setSizeFromMinYMinX(AreaL area,
                                        long width,
                                        long height)
```
    Set the width and height of area to width and height, respectively.
    
    The area is resized by moving its minimum-y-minimum-x corner.
    
    Parameters:
    
    area - The area
    
    width - The new width (must be non-negative)
    
    height - The new height (must be non-negative)
    
    Returns:
    
    A resized area
  - setSizeFromMinYMaxX
```
public static AreaL setSizeFromMinYMaxX(AreaL area,
                                        long width,
                                        long height)
```
    Set the width and height of area to width and height, respectively.
    
    The area is resized by moving its minimum-y-maximum-x corner.
    
    Parameters:
    
    area - The area
    
    width - The new width (must be non-negative)
    
    height - The new height (must be non-negative)
    
    Returns:
    
    A resized area
  - setSizeFromMaxYMaxX
```
public static AreaL setSizeFromMaxYMaxX(AreaL area,
                                        long width,
                                        long height)
```
    Set the width and height of area to width and height, respectively.
    
    The area is resized by moving its maximum-y-maximum-x corner.
    
    Parameters:
    
    area - The area
    
    width - The new width (must be non-negative)
    
    height - The new height (must be non-negative)
    
    Returns:
    
    A resized area
  - setSizeFromMaxYMinX
```
public static AreaL setSizeFromMaxYMinX(AreaL area,
                                        long width,
                                        long height)
```
    Set the width and height of area to width and height, respectively.
    
    The area is resized by moving its maximum-y-minimum-x corner.
    
    Parameters:
    
    area - The area
    
    width - The new width (must be non-negative)
    
    height - The new height (must be non-negative)
    
    Returns:
    
    A resized area
  - scaleFromMinYMinX
```
public static AreaL scaleFromMinYMinX(AreaL area,
                                      long x_diff,
                                      long y_diff)
```
    Scale area by adding x_diff to the width, and y_diff to the height. The size of the resulting area is clamped so that its width and height are always non-negative.
    
    The area is resized by moving its minimum-y-minimum-x corner.
    
    Parameters:
    
    area - The area
    
    x_diff - The X difference
    
    y_diff - The Y difference
    
    Returns:
    
    A resized area
  - scaleFromMinYMaxX
```
public static AreaL scaleFromMinYMaxX(AreaL area,
                                      long x_diff,
                                      long y_diff)
```
    Scale area by adding x_diff to the width, and y_diff to the height. The size of the resulting area is clamped so that its width and height are always non-negative.
    
    The area is resized by moving its minimum-y-maximum-x corner.
    
    Parameters:
    
    area - The area
    
    x_diff - The X difference
    
    y_diff - The Y difference
    
    Returns:
    
    A resized area
  - scaleFromMaxYMinX
```
public static AreaL scaleFromMaxYMinX(AreaL area,
                                      long x_diff,
                                      long y_diff)
```
    Scale area by adding x_diff to the width, and y_diff to the height. The size of the resulting area is clamped so that its width and height are always non-negative.
    
    The area is resized by moving its maximum-y-minimum-x corner.
    
    Parameters:
    
    area - The area
    
    x_diff - The X difference
    
    y_diff - The Y difference
    
    Returns:
    
    A resized area
  - scaleFromMaxYMaxX
```
public static AreaL scaleFromMaxYMaxX(AreaL area,
                                      long x_diff,
                                      long y_diff)
```
    Scale area by adding x_diff to the width, and y_diff to the height. The size of the resulting area is clamped so that its width and height are always non-negative.
    
    The area is resized by moving its maximum-y-maximum-x corner.
    
    Parameters:
    
    area - The area
    
    x_diff - The X difference
    
    y_diff - The Y difference
    
    Returns:
    
    A resized area
  - scaleFromCenter
```
public static AreaL scaleFromCenter(AreaL area,
                                    long x_diff,
                                    long y_diff)
```
    Scale area by adding x_diff to the width, and y_diff to the height. The size of the resulting area is clamped so that its width and height are always non-negative.
    
    The area is resized from its own center.
    
    Parameters:
    
    area - The area
    
    x_diff - The X difference
    
    y_diff - The Y difference
    
    Returns:
    
    A resized area
  - overlaps
```
public static boolean overlaps(AreaL a,
                               AreaL b)
```
    Determine whether or not two areas overlap.
    
    Overlapping is reflexive: overlaps(a, a) == true.
    
    Overlapping is symmetric: overlaps(a, b) == contains(b, a).
    
    Overlapping is not necessarily transitive.
    
    Parameters:
    
    a - An area
    
    b - An area
    
    Returns:
    
    true iff a overlaps b
  - couldFitInside
```
public static boolean couldFitInside(AreaL a,
                                     AreaL b)
```
    Determine whether or not one area could fit inside another.
    
    Fitting is reflexive: couldFitInside(a, a) == true.
    
    Fitting is transitive: couldFitInside(a, b) → couldFitInside(b, c) → couldFitInside(a, c).
    
    Fitting is not necessarily symmetric.
    
    Parameters:
    
    a - An area
    
    b - An area
    
    Returns:
    
    true iff a could fit inside b
  - containing
```
public static AreaL containing(AreaL a,
                               AreaL b)
```
    Construct a area that will contain both a and b.
    
    Parameters:
    
    a - An area
    
    b - An area
    
    Returns:
    
    An area containing a and b
  - containsPoint
```
public static boolean containsPoint(AreaL a,
                                    long x,
                                    long y)
```
    Determine whether or not a area contains a given point.
    
    Parameters:
    
    a - An area
    
    x - The X coordinate of the point
    
    y - The Y coordinate of the point
    
    Returns:
    
    true iff a contains (x, y)
  - fitBetweenHorizontal
```
public static AreaL fitBetweenHorizontal(AreaL fit,
                                         AreaL a,
                                         AreaL b)
```
    Attempt to fit fit between a and b, horizontally.
    
    Parameters:
    
    fit - The area to be fitted
    
    a - An area
    
    b - An area
    
    Returns:
    
    A fitted area
  - fitBetweenVertical
```
public static AreaL fitBetweenVertical(AreaL fit,
                                       AreaL a,
                                       AreaL b)
```
    Attempt to fit fit between a and b, vertically.
    
    Parameters:
    
    fit - The area to be fitted
    
    a - An area
    
    b - An area
    
    Returns:
    
    A fitted area
  - splitAlongParallelToX
```
public static AreaXSplitL<AreaL> splitAlongParallelToX(AreaL area,
                                                       long y)
```
    Split area along a line parallel to the X axis placed at y units from its own minimum-y edge.
    
    Parameters:
    
    area - The area to be split
    
    y - The relative Y coordinate of the splitting edge
    
    Returns:
    
    A pair of areas
  - splitAlongParallelToY
```
public static AreaYSplitL<AreaL> splitAlongParallelToY(AreaL area,
                                                       long x)
```
    Split area along a line parallel to the Y axis placed at x units from its own minimum-x edge.
    
    Parameters:
    
    area - The area to be split
    
    x - The relative X coordinate of the splitting edge
    
    Returns:
    
    A pair of areas
  - show
```
public static String show(AreaL area)
```
    Parameters:
    
    area - The area
    
    Returns:
    
    A terse string describing the position and size of the area
  - size
```
public static AreaSizeL size(AreaL area)
```
    Parameters:
    
    area - The area
    
    Returns:
    
    The size of the area
  - showToBuilder
```
public static String showToBuilder(AreaL area,
                                   StringBuilder sb)
```
    Parameters:
    
    area - The area
    
    sb - A string builder
    
    Returns:
    
    A terse string describing the position and size of the area

Class AreasL

Method Summary

Methods inherited from class java.lang.Object

Method Detail

create

contains

moveRelative

moveAbsolute

moveToOrigin

alignHorizontallyCenter

alignHorizontallyMinX

alignHorizontallyMinXOffset

alignHorizontallyMaxX

alignHorizontallyMaxXOffset

alignVerticallyMinY

alignVerticallyMinYOffset

alignVerticallyMaxY

alignVerticallyMaxYOffset

alignVerticallyCenter

alignMinYMinX

alignMinYMinXOffset

alignMinYMaxX

alignMinYMaxXOffset

alignMaxYMinX

alignMaxYMinXOffset

alignMaxYMaxX

alignMaxYMaxXOffset

alignCenter

hollowOut

hollowOutEvenly

setSizeFromCenter

setSizeFromMinYMinX

setSizeFromMinYMaxX

setSizeFromMaxYMaxX

setSizeFromMaxYMinX

scaleFromMinYMinX

scaleFromMinYMaxX

scaleFromMaxYMinX

scaleFromMaxYMaxX

scaleFromCenter

overlaps

couldFitInside

containing

containsPoint

fitBetweenHorizontal

fitBetweenVertical

splitAlongParallelToX

splitAlongParallelToY

show

size

showToBuilder