AreasF (com.io7m.jregions.documentation 0.0.2 API)

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

```
public final class AreasF
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 AreaF`	`alignCenter(AreaF outer, AreaF inner)` Align the area `inner` such that the center of the area is equal to the center of `outer`.
`static AreaF`	`alignHorizontallyCenter(AreaF outer, AreaF inner)` Align the area `inner` horizontally in the center of `outer`.
`static AreaF`	`alignHorizontallyMaxX(AreaF outer, AreaF inner)` Equivalent to calling `alignHorizontallyMaxXOffset(AreaF, AreaF, float)` with a zero offset.
`static AreaF`	`alignHorizontallyMaxXOffset(AreaF outer, AreaF inner, float offset)` Align the area `inner` horizontally against the inside maximum-x edge of `outer`.
`static AreaF`	`alignHorizontallyMinX(AreaF outer, AreaF inner)` Equivalent to calling `alignHorizontallyMinXOffset(AreaF, AreaF, float)` with a zero offset.
`static AreaF`	`alignHorizontallyMinXOffset(AreaF outer, AreaF inner, float offset)` Align the area `inner` horizontally against the inside minimum-x edge of `outer`.
`static AreaF`	`alignMaxYMaxX(AreaF outer, AreaF inner)` Equivalent to calling `alignMaxYMaxXOffset(AreaF, AreaF, float, float)` with zero offsets.
`static AreaF`	`alignMaxYMaxXOffset(AreaF outer, AreaF inner, float offset_x, float 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 AreaF`	`alignMaxYMinX(AreaF outer, AreaF inner)` Equivalent to calling `alignMaxYMinXOffset(AreaF, AreaF, float, float)` with zero offsets.
`static AreaF`	`alignMaxYMinXOffset(AreaF outer, AreaF inner, float offset_x, float 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 AreaF`	`alignMinYMaxX(AreaF outer, AreaF inner)` Equivalent to calling `alignMinYMaxXOffset(AreaF, AreaF, float, float)` with zero offsets.
`static AreaF`	`alignMinYMaxXOffset(AreaF outer, AreaF inner, float offset_x, float 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 AreaF`	`alignMinYMinX(AreaF outer, AreaF inner)` Equivalent to calling `alignMinYMinXOffset(AreaF, AreaF, float, float)` with zero offsets.
`static AreaF`	`alignMinYMinXOffset(AreaF outer, AreaF inner, float offset_x, float 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 AreaF`	`alignVerticallyCenter(AreaF outer, AreaF inner)` Align the area `inner` vertically in the center of `outer`.
`static AreaF`	`alignVerticallyMaxY(AreaF outer, AreaF inner)` Equivalent to calling `alignVerticallyMaxYOffset(AreaF, AreaF, float)` with a zero offset.
`static AreaF`	`alignVerticallyMaxYOffset(AreaF outer, AreaF inner, float offset)` Align the area `inner` vertically against the inside maximum-y edge of `outer`.
`static AreaF`	`alignVerticallyMinY(AreaF outer, AreaF inner)` Equivalent to calling `alignVerticallyMinYOffset(AreaF, AreaF, float)` with a zero offset.
`static AreaF`	`alignVerticallyMinYOffset(AreaF outer, AreaF inner, float offset)` Align the area `inner` vertically against the inside minimum-y edge of `outer`.
`static AreaF`	`containing(AreaF a, AreaF b)` Construct a area that will contain both `a` and `b`.
`static boolean`	`contains(AreaF a, AreaF b)` Determine whether or not one area contains another.
`static boolean`	`containsPoint(AreaF a, float x, float y)` Determine whether or not a area contains a given point.
`static boolean`	`couldFitInside(AreaF a, AreaF b)` Determine whether or not one area could fit inside another.
`static AreaF`	`create(float x, float y, float width, float height)` Create an area of width `width` and height `height`, placing the minimum corner at `(x, y)`.
`static AreaF`	`fitBetweenHorizontal(AreaF fit, AreaF a, AreaF b)` Attempt to fit `fit` between `a` and `b`, horizontally.
`static AreaF`	`fitBetweenVertical(AreaF fit, AreaF a, AreaF b)` Attempt to fit `fit` between `a` and `b`, vertically.
`static AreaF`	`hollowOut(AreaF outer, float min_x_offset, float max_x_offset, float min_y_offset, float max_y_offset)` Construct a new area that fits inside `outer` based on the given offsets from each edge.
`static AreaF`	`hollowOutEvenly(AreaF outer, float offset)` Equivalent to calling `hollowOut(AreaF, float, float, float, float)` with `offset` for all offset parameters.
`static AreaF`	`moveAbsolute(AreaF area, float x, float y)` Move the given area to `(x, y)`.
`static AreaF`	`moveRelative(AreaF area, float x, float y)` Move the given area by `(x, y)`.
`static AreaF`	`moveToOrigin(AreaF area)` Move the given area to `(0, 0)`.
`static boolean`	`overlaps(AreaF a, AreaF b)` Determine whether or not two areas overlap.
`static AreaF`	`scaleFromCenter(AreaF area, float x_diff, float y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaF`	`scaleFromMaxYMaxX(AreaF area, float x_diff, float y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaF`	`scaleFromMaxYMinX(AreaF area, float x_diff, float y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaF`	`scaleFromMinYMaxX(AreaF area, float x_diff, float y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaF`	`scaleFromMinYMinX(AreaF area, float x_diff, float y_diff)` Scale `area` by adding `x_diff` to the width, and `y_diff` to the height.
`static AreaF`	`setSizeFromCenter(AreaF area, float width, float height)` Set the width and height of `area` to `width` and `height`, respectively.
`static AreaF`	`setSizeFromMaxYMaxX(AreaF area, float width, float height)` Set the width and height of `area` to `width` and `height`, respectively.
`static AreaF`	`setSizeFromMaxYMinX(AreaF area, float width, float height)` Set the width and height of `area` to `width` and `height`, respectively.
`static AreaF`	`setSizeFromMinYMaxX(AreaF area, float width, float height)` Set the width and height of `area` to `width` and `height`, respectively.
`static AreaF`	`setSizeFromMinYMinX(AreaF area, float width, float height)` Set the width and height of `area` to `width` and `height`, respectively.
`static String`	`show(AreaF area)`
`static String`	`showToBuilder(AreaF area, StringBuilder sb)`
`static AreaXSplitF<AreaF>`	`splitAlongParallelToX(AreaF area, float y)` Split `area` along a line parallel to the X axis placed at `y` units from its own minimum-y edge.
`static AreaYSplitF<AreaF>`	`splitAlongParallelToY(AreaF area, float 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 AreaF create(float x,
                           float y,
                           float width,
                           float 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(AreaF a,
                               AreaF 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 AreaF moveRelative(AreaF area,
                                 float x,
                                 float 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 AreaF moveAbsolute(AreaF area,
                                 float x,
                                 float 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 AreaF moveToOrigin(AreaF area)
```
    Move the given area to (0, 0).
    
    Parameters:
    
    area - The area
    
    Returns:
    
    A moved area
  - alignHorizontallyCenter
```
public static AreaF alignHorizontallyCenter(AreaF outer,
                                            AreaF 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 AreaF alignHorizontallyMinX(AreaF outer,
                                          AreaF inner)
```
    Equivalent to calling alignHorizontallyMinXOffset(AreaF, AreaF, float) with a zero offset.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignHorizontallyMinXOffset
```
public static AreaF alignHorizontallyMinXOffset(AreaF outer,
                                                AreaF inner,
                                                float 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 AreaF alignHorizontallyMaxX(AreaF outer,
                                          AreaF inner)
```
    Equivalent to calling alignHorizontallyMaxXOffset(AreaF, AreaF, float) with a zero offset.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignHorizontallyMaxXOffset
```
public static AreaF alignHorizontallyMaxXOffset(AreaF outer,
                                                AreaF inner,
                                                float 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 AreaF alignVerticallyMinY(AreaF outer,
                                        AreaF inner)
```
    Equivalent to calling alignVerticallyMinYOffset(AreaF, AreaF, float) with a zero offset.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignVerticallyMinYOffset
```
public static AreaF alignVerticallyMinYOffset(AreaF outer,
                                              AreaF inner,
                                              float 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 AreaF alignVerticallyMaxY(AreaF outer,
                                        AreaF inner)
```
    Equivalent to calling alignVerticallyMaxYOffset(AreaF, AreaF, float) with a zero offset.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignVerticallyMaxYOffset
```
public static AreaF alignVerticallyMaxYOffset(AreaF outer,
                                              AreaF inner,
                                              float 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 AreaF alignVerticallyCenter(AreaF outer,
                                          AreaF 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 AreaF alignMinYMinX(AreaF outer,
                                  AreaF inner)
```
    Equivalent to calling alignMinYMinXOffset(AreaF, AreaF, float, float) with zero offsets.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMinYMinXOffset
```
public static AreaF alignMinYMinXOffset(AreaF outer,
                                        AreaF inner,
                                        float offset_x,
                                        float 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 AreaF alignMinYMaxX(AreaF outer,
                                  AreaF inner)
```
    Equivalent to calling alignMinYMaxXOffset(AreaF, AreaF, float, float) with zero offsets.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMinYMaxXOffset
```
public static AreaF alignMinYMaxXOffset(AreaF outer,
                                        AreaF inner,
                                        float offset_x,
                                        float 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 AreaF alignMaxYMinX(AreaF outer,
                                  AreaF inner)
```
    Equivalent to calling alignMaxYMinXOffset(AreaF, AreaF, float, float) with zero offsets.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMaxYMinXOffset
```
public static AreaF alignMaxYMinXOffset(AreaF outer,
                                        AreaF inner,
                                        float offset_x,
                                        float 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 AreaF alignMaxYMaxX(AreaF outer,
                                  AreaF inner)
```
    Equivalent to calling alignMaxYMaxXOffset(AreaF, AreaF, float, float) with zero offsets.
    
    Parameters:
    
    outer - The outer area
    
    inner - The inner area
    
    Returns:
    
    An aligned area
  - alignMaxYMaxXOffset
```
public static AreaF alignMaxYMaxXOffset(AreaF outer,
                                        AreaF inner,
                                        float offset_x,
                                        float 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 AreaF alignCenter(AreaF outer,
                                AreaF 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 AreaF hollowOut(AreaF outer,
                              float min_x_offset,
                              float max_x_offset,
                              float min_y_offset,
                              float 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 AreaF hollowOutEvenly(AreaF outer,
                                    float offset)
```
    Equivalent to calling hollowOut(AreaF, float, float, float, float) 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 AreaF setSizeFromCenter(AreaF area,
                                      float width,
                                      float 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 AreaF setSizeFromMinYMinX(AreaF area,
                                        float width,
                                        float 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 AreaF setSizeFromMinYMaxX(AreaF area,
                                        float width,
                                        float 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 AreaF setSizeFromMaxYMaxX(AreaF area,
                                        float width,
                                        float 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 AreaF setSizeFromMaxYMinX(AreaF area,
                                        float width,
                                        float 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 AreaF scaleFromMinYMinX(AreaF area,
                                      float x_diff,
                                      float 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 AreaF scaleFromMinYMaxX(AreaF area,
                                      float x_diff,
                                      float 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 AreaF scaleFromMaxYMinX(AreaF area,
                                      float x_diff,
                                      float 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 AreaF scaleFromMaxYMaxX(AreaF area,
                                      float x_diff,
                                      float 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 AreaF scaleFromCenter(AreaF area,
                                    float x_diff,
                                    float 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(AreaF a,
                               AreaF 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(AreaF a,
                                     AreaF 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 AreaF containing(AreaF a,
                               AreaF 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(AreaF a,
                                    float x,
                                    float 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 AreaF fitBetweenHorizontal(AreaF fit,
                                         AreaF a,
                                         AreaF 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 AreaF fitBetweenVertical(AreaF fit,
                                       AreaF a,
                                       AreaF 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 AreaXSplitF<AreaF> splitAlongParallelToX(AreaF area,
                                                       float 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 AreaYSplitF<AreaF> splitAlongParallelToY(AreaF area,
                                                       float 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(AreaF area)
```
    Parameters:
    
    area - The area
    
    Returns:
    
    A terse string describing the position and size of the area
  - showToBuilder
```
public static String showToBuilder(AreaF area,
                                   StringBuilder sb)
```
    Parameters:
    
    area - The area
    
    sb - A string builder
    
    Returns:
    
    A terse string describing the position and size of the area

Class AreasF

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

showToBuilder