Module com.io7m.jregions.core
Package com.io7m.jregions.core.unparameterized.areas

## Class AreasF

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

-     public final class AreasF
      extends java.lang.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 Deprecated Methods
    Modifier and Type | Method | 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)` | Deprecated. Use `alignOnXCenter(AreaF, AreaF)`
    `static AreaF` | `alignHorizontallyMaxX​(AreaF outer, AreaF inner)` | Deprecated. Use `alignOnXMaxX(AreaF, AreaF)`
    `static AreaF` | `alignHorizontallyMaxXOffset​(AreaF outer, AreaF inner, float offset)` | Deprecated. Use `alignOnXMaxXOffset(AreaF, AreaF, float)`
    `static AreaF` | `alignHorizontallyMinX​(AreaF outer, AreaF inner)` | Deprecated. Use `alignOnXMinX(AreaF, AreaF)`
    `static AreaF` | `alignHorizontallyMinXOffset​(AreaF outer, AreaF inner, float offset)` | Deprecated. Use `alignOnXMinXOffset(AreaF, AreaF, float)`
    `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` | `alignOnXCenter​(AreaF outer, AreaF inner)` | Align the area `inner` along the X axis in the center of `outer`.
    `static AreaF` | `alignOnXMaxX​(AreaF outer, AreaF inner)` | Equivalent to calling `alignOnXMaxXOffset(AreaF, AreaF, float)` with a zero offset.
    `static AreaF` | `alignOnXMaxXOffset​(AreaF outer, AreaF inner, float offset)` | Align the area `inner` along the X axis against the inside maximum-x edge of `outer`.
    `static AreaF` | `alignOnXMinX​(AreaF outer, AreaF inner)` | Equivalent to calling `alignOnXMinXOffset(AreaF, AreaF, float)` with a zero offset.
    `static AreaF` | `alignOnXMinXOffset​(AreaF outer, AreaF inner, float offset)` | Align the area `inner` along the X axis against the inside minimum-x edge of `outer`.
    `static AreaF` | `alignOnYCenter​(AreaF outer, AreaF inner)` | Align the area `inner` along the Y axis in the center of `outer`.
    `static AreaF` | `alignOnYMaxY​(AreaF outer, AreaF inner)` | Equivalent to calling `alignOnYMaxYOffset(AreaF, AreaF, float)` with a zero offset.
    `static AreaF` | `alignOnYMaxYOffset​(AreaF outer, AreaF inner, float offset)` | Align the area `inner` along the Y axis against the inside maximum-y edge of `outer`.
    `static AreaF` | `alignOnYMinY​(AreaF outer, AreaF inner)` | Equivalent to calling `alignOnYMinYOffset(AreaF, AreaF, float)` with a zero offset.
    `static AreaF` | `alignOnYMinYOffset​(AreaF outer, AreaF inner, float offset)` | Align the area `inner` along the Y axis against the inside minimum-y edge of `outer`.
    `static AreaF` | `alignVerticallyCenter​(AreaF outer, AreaF inner)` | Deprecated. Use `alignOnYCenter(AreaF, AreaF)`
    `static AreaF` | `alignVerticallyMaxY​(AreaF outer, AreaF inner)` | Deprecated. Use `alignOnYMaxY(AreaF, AreaF)`
    `static AreaF` | `alignVerticallyMaxYOffset​(AreaF outer, AreaF inner, float offset)` | Deprecated. Use `alignOnYMaxYOffset(AreaF, AreaF, float)`
    `static AreaF` | `alignVerticallyMinY​(AreaF outer, AreaF inner)` | Deprecated. Use `alignOnYMinY(AreaF, AreaF)`
    `static AreaF` | `alignVerticallyMinYOffset​(AreaF outer, AreaF inner, float offset)` | Deprecated. Use `alignOnYMinYOffset(AreaF, AreaF, float)`
    `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 size_x, float size_y)` | Create an area of size `size_x` on the X axis and size `size_y` on the Y axis, placing the minimum corner at `(x, y)`.
    `static AreaF` | `fitBetweenHorizontal​(AreaF fit, AreaF a, AreaF b)` | Deprecated. Use `fitBetweenOnX(AreaF, AreaF, AreaF)`
    `static AreaF` | `fitBetweenOnX​(AreaF fit, AreaF a, AreaF b)` | Attempt to fit `fit` between `a` and `b`, horizontally.
    `static AreaF` | `fitBetweenOnY​(AreaF fit, AreaF a, AreaF b)` | Attempt to fit `fit` between `a` and `b`, vertically.
    `static AreaF` | `fitBetweenVertical​(AreaF fit, AreaF a, AreaF b)` | Deprecated. Use `fitBetweenOnY(AreaF, AreaF, AreaF)`
    `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 sizeX, and `y_diff` to the sizeY.
    `static AreaF` | `scaleFromMaxYMaxX​(AreaF area, float x_diff, float y_diff)` | Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
    `static AreaF` | `scaleFromMaxYMinX​(AreaF area, float x_diff, float y_diff)` | Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
    `static AreaF` | `scaleFromMinYMaxX​(AreaF area, float x_diff, float y_diff)` | Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
    `static AreaF` | `scaleFromMinYMinX​(AreaF area, float x_diff, float y_diff)` | Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
    `static AreaF` | `setSizeFromCenter​(AreaF area, float sizeX, float sizeY)` | Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
    `static AreaF` | `setSizeFromMaxYMaxX​(AreaF area, float sizeX, float sizeY)` | Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
    `static AreaF` | `setSizeFromMaxYMinX​(AreaF area, float sizeX, float sizeY)` | Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
    `static AreaF` | `setSizeFromMinYMaxX​(AreaF area, float sizeX, float sizeY)` | Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
    `static AreaF` | `setSizeFromMinYMinX​(AreaF area, float sizeX, float sizeY)` | Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
    `static java.lang.String` | `show​(AreaF area)` |
    `static java.lang.String` | `showToBuilder​(AreaF area, java.lang.StringBuilder sb)` |
    `static AreaSizeF` | `size​(AreaF area)` |
    `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.
    `static AreaXYSplitF<AreaF>` | `splitAlongXY​(AreaF area, float x, float y)` | Split `area` along a two axis-aligned perpendicular lines that intercept at `(x, y)`.

    - ### 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 size_x,
                                     float size_y)

      Create an area of size `size_x` on the X axis and size `size_y` on the Y axis, placing the minimum corner at `(x, y)`.
      Parameters:
        `x` - The X value of the minimum corner
        `y` - The Y value of the minimum corner
        `size_x` - The size of the area on the X axis
        `size_y` - The size of the area on the Y axis
      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) \u2192 contains(b, c) \u2192 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

    - #### alignOnXCenter

          public static AreaF alignOnXCenter​(AreaF outer,
                                             AreaF inner)

      Align the area `inner` along the X axis in the center of `outer`.
      Parameters:
        `outer` - The outer area
        `inner` - The inner area
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnXMinX

          public static AreaF alignOnXMinX​(AreaF outer,
                                           AreaF inner)

      Equivalent to calling `alignOnXMinXOffset(AreaF, AreaF, float)` with a zero offset.
      Parameters:
        `outer` - The outer area
        `inner` - The inner area
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnXMinXOffset

          public static AreaF alignOnXMinXOffset​(AreaF outer,
                                                 AreaF inner,
                                                 float offset)

      Align the area `inner` along the X axis 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
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnXMaxX

          public static AreaF alignOnXMaxX​(AreaF outer,
                                           AreaF inner)

      Equivalent to calling `alignOnXMaxXOffset(AreaF, AreaF, float)` with a zero offset.
      Parameters:
        `outer` - The outer area
        `inner` - The inner area
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnXMaxXOffset

          public static AreaF alignOnXMaxXOffset​(AreaF outer,
                                                 AreaF inner,
                                                 float offset)

      Align the area `inner` along the X axis 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
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnYMinY

          public static AreaF alignOnYMinY​(AreaF outer,
                                           AreaF inner)

      Equivalent to calling `alignOnYMinYOffset(AreaF, AreaF, float)` with a zero offset.
      Parameters:
        `outer` - The outer area
        `inner` - The inner area
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnYMinYOffset

          public static AreaF alignOnYMinYOffset​(AreaF outer,
                                                 AreaF inner,
                                                 float offset)

      Align the area `inner` along the Y axis 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
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnYMaxY

          public static AreaF alignOnYMaxY​(AreaF outer,
                                           AreaF inner)

      Equivalent to calling `alignOnYMaxYOffset(AreaF, AreaF, float)` with a zero offset.
      Parameters:
        `outer` - The outer area
        `inner` - The inner area
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnYMaxYOffset

          public static AreaF alignOnYMaxYOffset​(AreaF outer,
                                                 AreaF inner,
                                                 float offset)

      Align the area `inner` along the Y axis 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
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignOnYCenter

          public static AreaF alignOnYCenter​(AreaF outer,
                                             AreaF inner)

      Align the area `inner` along the Y axis in the center of `outer`.
      Parameters:
        `outer` - The outer area
        `inner` - The inner area
      Returns:
        An aligned area
      Since:
        1.1.0

    - #### alignHorizontallyCenter

          @Deprecated
          public static AreaF alignHorizontallyCenter​(AreaF outer,
                                                      AreaF inner)

      Deprecated. Use `alignOnXCenter(AreaF, AreaF)`
      Align the area `inner` horizontally in the center of `outer`.
      Parameters:
        `outer` - The outer area
        `inner` - The inner area
      Returns:
        An aligned area

    - #### alignHorizontallyMinX

          @Deprecated
          public static AreaF alignHorizontallyMinX​(AreaF outer,
                                                    AreaF inner)

      Deprecated. Use `alignOnXMinX(AreaF, AreaF)`
      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

          @Deprecated
          public static AreaF alignHorizontallyMinXOffset​(AreaF outer,
                                                          AreaF inner,
                                                          float offset)

      Deprecated. Use `alignOnXMinXOffset(AreaF, AreaF, float)`
      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
      Returns:
        An aligned area

    - #### alignHorizontallyMaxX

          @Deprecated
          public static AreaF alignHorizontallyMaxX​(AreaF outer,
                                                    AreaF inner)

      Deprecated. Use `alignOnXMaxX(AreaF, AreaF)`
      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

          @Deprecated
          public static AreaF alignHorizontallyMaxXOffset​(AreaF outer,
                                                          AreaF inner,
                                                          float offset)

      Deprecated. Use `alignOnXMaxXOffset(AreaF, AreaF, float)`
      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
      Returns:
        An aligned area

    - #### alignVerticallyMinY

          @Deprecated
          public static AreaF alignVerticallyMinY​(AreaF outer,
                                                  AreaF inner)

      Deprecated. Use `alignOnYMinY(AreaF, AreaF)`
      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

          @Deprecated
          public static AreaF alignVerticallyMinYOffset​(AreaF outer,
                                                        AreaF inner,
                                                        float offset)

      Deprecated. Use `alignOnYMinYOffset(AreaF, AreaF, float)`
      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
      Returns:
        An aligned area

    - #### alignVerticallyMaxY

          @Deprecated
          public static AreaF alignVerticallyMaxY​(AreaF outer,
                                                  AreaF inner)

      Deprecated. Use `alignOnYMaxY(AreaF, AreaF)`
      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

          @Deprecated
          public static AreaF alignVerticallyMaxYOffset​(AreaF outer,
                                                        AreaF inner,
                                                        float offset)

      Deprecated. Use `alignOnYMaxYOffset(AreaF, AreaF, float)`
      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
      Returns:
        An aligned area

    - #### alignVerticallyCenter

          @Deprecated
          public static AreaF alignVerticallyCenter​(AreaF outer,
                                                    AreaF inner)

      Deprecated. Use `alignOnYCenter(AreaF, AreaF)`
      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 sizeX,
                                                float sizeY)

      Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

      The area is resized from its own center.

      Parameters:
        `area` - The area
        `sizeX` - The new sizeX (must be non-negative)
        `sizeY` - The new sizeY (must be non-negative)
      Returns:
        A resized area

    - #### setSizeFromMinYMinX

          public static AreaF setSizeFromMinYMinX​(AreaF area,
                                                  float sizeX,
                                                  float sizeY)

      Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

      The area is resized by moving its minimum-y-minimum-x corner.

      Parameters:
        `area` - The area
        `sizeX` - The new sizeX (must be non-negative)
        `sizeY` - The new sizeY (must be non-negative)
      Returns:
        A resized area

    - #### setSizeFromMinYMaxX

          public static AreaF setSizeFromMinYMaxX​(AreaF area,
                                                  float sizeX,
                                                  float sizeY)

      Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

      The area is resized by moving its minimum-y-maximum-x corner.

      Parameters:
        `area` - The area
        `sizeX` - The new sizeX (must be non-negative)
        `sizeY` - The new sizeY (must be non-negative)
      Returns:
        A resized area

    - #### setSizeFromMaxYMaxX

          public static AreaF setSizeFromMaxYMaxX​(AreaF area,
                                                  float sizeX,
                                                  float sizeY)

      Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

      The area is resized by moving its maximum-y-maximum-x corner.

      Parameters:
        `area` - The area
        `sizeX` - The new sizeX (must be non-negative)
        `sizeY` - The new sizeY (must be non-negative)
      Returns:
        A resized area

    - #### setSizeFromMaxYMinX

          public static AreaF setSizeFromMaxYMinX​(AreaF area,
                                                  float sizeX,
                                                  float sizeY)

      Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

      The area is resized by moving its maximum-y-minimum-x corner.

      Parameters:
        `area` - The area
        `sizeX` - The new sizeX (must be non-negative)
        `sizeY` - The new sizeY (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 sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY 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 sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY 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 sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY 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 sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY 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 sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY 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) == overlaps(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) \u2192 couldFitInside(b, c) \u2192 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

          @Deprecated
          public static AreaF fitBetweenHorizontal​(AreaF fit,
                                                   AreaF a,
                                                   AreaF b)

      Deprecated. Use `fitBetweenOnX(AreaF, AreaF, AreaF)`
      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

          @Deprecated
          public static AreaF fitBetweenVertical​(AreaF fit,
                                                 AreaF a,
                                                 AreaF b)

      Deprecated. Use `fitBetweenOnY(AreaF, AreaF, AreaF)`
      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

    - #### fitBetweenOnX

          public static AreaF fitBetweenOnX​(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

    - #### fitBetweenOnY

          public static AreaF fitBetweenOnY​(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

    - #### splitAlongXY

          public static AreaXYSplitF<AreaF> splitAlongXY​(AreaF area,
                                                         float x,
                                                         float y)

      Split `area` along a two axis-aligned perpendicular lines that intercept at `(x, y)`.
      Parameters:
        `area` - The area to be split
        `x` - The relative X coordinate of the splitting edge
        `y` - The relative Y coordinate of the splitting edge
      Returns:
        The four resulting quadrants
      Since:
        1.1.0

    - #### show

          public static java.lang.String show​(AreaF area)

      Parameters:
        `area` - The area
      Returns:
        A terse string describing the position and size of the area

    - #### size

          public static AreaSizeF size​(AreaF area)

      Parameters:
        `area` - The area
      Returns:
        The size of the area

    - #### showToBuilder

          public static java.lang.String showToBuilder​(AreaF area,
                                                       java.lang.StringBuilder sb)

      Parameters:
        `area` - The area
        `sb` - A string builder
      Returns:
        A terse string describing the position and size of the area

Copyright © 2017 <code@io7m.com> http://io7m.com