BoundingSphere (CesiumJS GWT Wrapper 1.59.4 API)

java.lang.Object
- org.cesiumjs.cs.core.BoundingSphere

@JsType(isNative=true,
        namespace="Cesium",
        name="BoundingSphere")
public class BoundingSphere
extends Object

Author:: Serge Silaev aka iSergio

Field Summary

Fields
Modifier and Type Field and Description

Cartesian3 center
The center point of the sphere.

double radius
The radius of the sphere.

Fields
Modifier and Type	Field and Description
`Cartesian3`	`center` The center point of the sphere.
`double`	`radius` The radius of the sphere.

Constructor Summary

Constructors
Constructor and Description
`BoundingSphere()` A bounding sphere with a center and a radius.
`BoundingSphere(Cartesian3 center, double radius)` A bounding sphere with a center and a radius.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`BoundingSphere`	`clone()` Duplicates this BoundingSphere instance.
`static BoundingSphere`	`clone(BoundingSphere sphere)` Duplicates a BoundingSphere instance.
`static BoundingSphere`	`clone(BoundingSphere sphere, BoundingSphere result)` Duplicates a BoundingSphere instance.
`static Interval`	`computePlaneDistances(BoundingSphere sphere, Cartesian3 position, Cartesian3 direction)` The distances calculated by the vector from the center of the bounding sphere to position projected onto direction plus/minus the radius of the bounding sphere.
`static Interval`	`computePlaneDistances(BoundingSphere sphere, Cartesian3 position, Cartesian3 direction, Interval result)` The distances calculated by the vector from the center of the bounding sphere to position projected onto direction plus/minus the radius of the bounding sphere.
`Interval`	`computePlaneDistances(Cartesian3 position, Cartesian3 direction)` The distances calculated by the vector from the center of the bounding sphere to position projected onto direction plus/minus the radius of the bounding sphere.
`Interval`	`computePlaneDistances(Cartesian3 position, Cartesian3 direction, Interval result)` The distances calculated by the vector from the center of the bounding sphere to position projected onto direction plus/minus the radius of the bounding sphere.
`static double`	`distanceSquaredTo(BoundingSphere sphere, Cartesian3 cartesian)` Computes the estimated distance squared from the closest point on a bounding sphere to a point.
`double`	`distanceSquaredTo(Cartesian3 cartesian)` Computes the estimated distance squared from the closest point on a bounding sphere to a point.
`boolean`	`equals(BoundingSphere right)` Compares this BoundingSphere against the provided BoundingSphere componentwise and returns true if they are equal, false otherwise.
`static boolean`	`equals(BoundingSphere left, BoundingSphere right)` Compares the provided BoundingSphere componentwise and returns true if they are equal, false otherwise.
`static BoundingSphere`	`expand(BoundingSphere sphere, Cartesian3 point)` Computes a bounding sphere by enlarging the provided sphere to contain the provided point.
`static BoundingSphere`	`expand(BoundingSphere sphere, Cartesian3 point, BoundingSphere result)` Computes a bounding sphere by enlarging the provided sphere to contain the provided point.
`static BoundingSphere`	`fromBoundingSpheres(BoundingSphere[] boundingSpheres)` Computes a tight-fitting bounding sphere enclosing the provided array of bounding spheres.
`static BoundingSphere`	`fromBoundingSpheres(BoundingSphere[] boundingSpheres, BoundingSphere result)` Computes a tight-fitting bounding sphere enclosing the provided array of bounding spheres.
`static BoundingSphere`	`fromCornerPoints(Cartesian3 corner, Cartesian3 oppositeCorner)` Computes a bounding sphere from the corner points of an axis-aligned bounding box.
`static BoundingSphere`	`fromCornerPoints(Cartesian3 corner, Cartesian3 oppositeCorner, BoundingSphere result)` Computes a bounding sphere from the corner points of an axis-aligned bounding box.
`static BoundingSphere`	`fromEllipsoid(Ellipsoid ellipsoid)` Creates a bounding sphere encompassing an ellipsoid.
`static BoundingSphere`	`fromEllipsoid(Ellipsoid ellipsoid, BoundingSphere result)` Creates a bounding sphere encompassing an ellipsoid.
`static BoundingSphere`	`fromEncodedCartesianVertices(double[] positionsHigh, double[] positionsLow)` Computes a tight-fitting bounding sphere enclosing a list of EncodedCartesian3s, where the points are stored in parallel flat arrays in X, Y, Z, order.
`static BoundingSphere`	`fromEncodedCartesianVertices(double[] positionsHigh, double[] positionsLow, BoundingSphere result)` Computes a tight-fitting bounding sphere enclosing a list of EncodedCartesian3s, where the points are stored in parallel flat arrays in X, Y, Z, order.
`static BoundingSphere`	`fromOrientedBoundingBox(OrientedBoundingBox orientedBoundingBox)` Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box.
`static BoundingSphere`	`fromOrientedBoundingBox(OrientedBoundingBox orientedBoundingBox, BoundingSphere result)` Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box.
`static BoundingSphere`	`fromPoints(Cartesian3[] positions, BoundingSphere result)` Computes a tight-fitting bounding sphere enclosing a list of 3D Cartesian points.
`static BoundingSphere`	`fromRectangle2D(Rectangle rectangle)` Computes a bounding sphere from an rectangle projected in 2D.
`static BoundingSphere`	`fromRectangle2D(Rectangle rectangle, Object projection)` Computes a bounding sphere from an rectangle projected in 2D.
`static BoundingSphere`	`fromRectangle2D(Rectangle rectangle, Object projection, BoundingSphere result)` Computes a bounding sphere from an rectangle projected in 2D.
`static BoundingSphere`	`fromRectangle3D(Rectangle rectangle)` Computes a bounding sphere from an rectangle in 3D.
`static BoundingSphere`	`fromRectangle3D(Rectangle rectangle, Ellipsoid ellipsoid, double surfaceHeight)` Computes a bounding sphere from an rectangle in 3D.
`static BoundingSphere`	`fromRectangle3D(Rectangle rectangle, Ellipsoid ellipsoid, double surfaceHeight, BoundingSphere result)` Computes a bounding sphere from an rectangle in 3D.
`static BoundingSphere`	`fromRectangleWithHeights2D(Rectangle rectangle, Object projection, double minimumHeight, double maximumHeight)` Computes a bounding sphere from an rectangle projected in 2D.
`static BoundingSphere`	`fromRectangleWithHeights2D(Rectangle rectangle, Object projection, double minimumHeight, double maximumHeight, BoundingSphere result)` Computes a bounding sphere from an rectangle projected in 2D.
`static BoundingSphere`	`fromVertices(double[] positions)` Computes a tight-fitting bounding sphere enclosing a list of 3D points, where the points are stored in a flat array in X, Y, Z, order.
`static BoundingSphere`	`fromVertices(double[] positions, Cartesian3 center, int stride)` Computes a tight-fitting bounding sphere enclosing a list of 3D points, where the points are stored in a flat array in X, Y, Z, order.
`static BoundingSphere`	`fromVertices(double[] positions, Cartesian3 center, int stride, BoundingSphere result)` Computes a tight-fitting bounding sphere enclosing a list of 3D points, where the points are stored in a flat array in X, Y, Z, order.
`static Integer`	`intersectPlane(BoundingSphere sphere, Plane plane)` Determines which side of a plane a sphere is located.
`Number`	`intersectPlane(Plane plane)` Determines which side of a plane the sphere is located.
`static boolean`	`isOccluded(BoundingSphere sphere, Occluder occluder)` Determines whether or not a sphere is hidden from view by the occluder.
`boolean`	`isOccluded(Occluder occluder)` Determines whether or not a sphere is hidden from view by the occluder.
`static double[]`	`pack(BoundingSphere value, double[] array)` Stores the provided instance into the provided array.
`static double[]`	`pack(BoundingSphere value, double[] array, int startingIndex)` Stores the provided instance into the provided array.
`static BoundingSphere`	`projectTo2D(BoundingSphere sphere)` Creates a bounding sphere in 2D from a bounding sphere in 3D world coordinates.
`static BoundingSphere`	`projectTo2D(BoundingSphere sphere, Object projection)` Creates a bounding sphere in 2D from a bounding sphere in 3D world coordinates.
`static BoundingSphere`	`projectTo2D(BoundingSphere sphere, Object projection, BoundingSphere result)` Creates a bounding sphere in 2D from a bounding sphere in 3D world coordinates.
`static BoundingSphere`	`transform(BoundingSphere sphere, Matrix4 transform)` Applies a 4x4 affine transformation matrix to a bounding sphere.
`static BoundingSphere`	`transform(BoundingSphere sphere, Matrix4 transform, BoundingSphere result)` Applies a 4x4 affine transformation matrix to a bounding sphere.
`static BoundingSphere`	`transformWithoutScale(BoundingSphere sphere, Matrix4 transform)` Applies a 4x4 affine transformation matrix to a bounding sphere where there is no scale The transformation matrix is not verified to have a uniform scale of 1.
`static BoundingSphere`	`transformWithoutScale(BoundingSphere sphere, Matrix4 transform, BoundingSphere result)` Applies a 4x4 affine transformation matrix to a bounding sphere where there is no scale The transformation matrix is not verified to have a uniform scale of 1.
`static BoundingSphere`	`union(BoundingSphere left, BoundingSphere right)` Computes a bounding sphere that contains both the left and right bounding spheres.
`static BoundingSphere`	`union(BoundingSphere left, BoundingSphere right, BoundingSphere result)` Computes a bounding sphere that contains both the left and right bounding spheres.
`static BoundingSphere`	`unpack(double[] array)` Retrieves an instance from a packed array.
`static BoundingSphere`	`unpack(double[] array, int startingIndex)` Retrieves an instance from a packed array.
`static BoundingSphere`	`unpack(double[] array, int startingIndex, BoundingSphere result)` Retrieves an instance from a packed array.
`double`	`volume()` Computes the radius of the BoundingSphere.

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

- Field Detail
  - center
```
@JsProperty
public Cartesian3 center
```
    The center point of the sphere. Default: Cartesian3.ZERO()
  - radius
```
@JsProperty
public double radius
```
    The radius of the sphere. Default: 0.0
- Constructor Detail
  - BoundingSphere
```
@JsConstructor
public BoundingSphere()
```
    A bounding sphere with a center and a radius.
    
    See Also:
    
    Packable
  - BoundingSphere
```
@JsConstructor
public BoundingSphere(Cartesian3 center,
                                     double radius)
```
    A bounding sphere with a center and a radius.
    
    Parameters:
    
    center - The center of the bounding sphere. Default: Cartesian3.ZERO()
    
    radius - The radius of the bounding sphere. Default: 0.0
    
    See Also:
    
    Packable
- Method Detail
  - clone
```
@JsMethod
public static BoundingSphere clone(BoundingSphere sphere,
                                             BoundingSphere result)
```
    Duplicates a BoundingSphere instance.
    
    Parameters:
    
    sphere - The bounding sphere to duplicate.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided. (Returns undefined if sphere is undefined)
  - clone
```
@JsMethod
public static BoundingSphere clone(BoundingSphere sphere)
```
    Duplicates a BoundingSphere instance.
    
    Parameters:
    
    sphere - The bounding sphere to duplicate.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided. (Returns undefined if sphere is undefined)
  - computePlaneDistances
```
@JsMethod
public static Interval computePlaneDistances(BoundingSphere sphere,
                                                       Cartesian3 position,
                                                       Cartesian3 direction)
```
    The distances calculated by the vector from the center of the bounding sphere to position projected onto direction plus/minus the radius of the bounding sphere.
    
    Parameters:
    
    sphere - The bounding sphere to calculate the distance to.
    
    position - The position to calculate the distance from.
    
    direction - The direction from position.
    
    Returns:
    
    The nearest and farthest distances on the bounding sphere from position in direction.
  - computePlaneDistances
```
@JsMethod
public static Interval computePlaneDistances(BoundingSphere sphere,
                                                       Cartesian3 position,
                                                       Cartesian3 direction,
                                                       Interval result)
```
    The distances calculated by the vector from the center of the bounding sphere to position projected onto direction plus/minus the radius of the bounding sphere.
    
    Parameters:
    
    sphere - The bounding sphere to calculate the distance to.
    
    position - The position to calculate the distance from.
    
    direction - The direction from position.
    
    result - A Interval to store the nearest and farthest distances.
    
    Returns:
    
    The nearest and farthest distances on the bounding sphere from position in direction.
  - distanceSquaredTo
```
@JsMethod
public static double distanceSquaredTo(BoundingSphere sphere,
                                                 Cartesian3 cartesian)
```
    Computes the estimated distance squared from the closest point on a bounding sphere to a point.
    
    Parameters:
    
    sphere - The sphere.
    
    cartesian - The point.
    
    Returns:
    
    The estimated distance squared from the bounding sphere to the point.
  - equals
```
@JsMethod
public static boolean equals(BoundingSphere left,
                                       BoundingSphere right)
```
    Compares the provided BoundingSphere componentwise and returns true if they are equal, false otherwise.
    
    Parameters:
    
    left - The first BoundingSphere.
    
    right - The second BoundingSphere.
    
    Returns:
    
    true if left and right are equal, false otherwise.
  - expand
```
@JsMethod
public static BoundingSphere expand(BoundingSphere sphere,
                                              Cartesian3 point,
                                              BoundingSphere result)
```
    Computes a bounding sphere by enlarging the provided sphere to contain the provided point.
    
    Parameters:
    
    sphere - A sphere to expand.
    
    point - A point to enclose in a bounding sphere.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - expand
```
@JsMethod
public static BoundingSphere expand(BoundingSphere sphere,
                                              Cartesian3 point)
```
    Computes a bounding sphere by enlarging the provided sphere to contain the provided point.
    
    Parameters:
    
    sphere - A sphere to expand.
    
    point - A point to enclose in a bounding sphere.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromBoundingSpheres
```
@JsMethod
public static BoundingSphere fromBoundingSpheres(BoundingSphere[] boundingSpheres)
```
    Computes a tight-fitting bounding sphere enclosing the provided array of bounding spheres.
    
    Parameters:
    
    boundingSpheres - The array of bounding spheres.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromBoundingSpheres
```
@JsMethod
public static BoundingSphere fromBoundingSpheres(BoundingSphere[] boundingSpheres,
                                                           BoundingSphere result)
```
    Computes a tight-fitting bounding sphere enclosing the provided array of bounding spheres.
    
    Parameters:
    
    boundingSpheres - The array of bounding spheres.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromCornerPoints
```
@JsMethod
public static BoundingSphere fromCornerPoints(Cartesian3 corner,
                                                        Cartesian3 oppositeCorner)
```
    Computes a bounding sphere from the corner points of an axis-aligned bounding box. The sphere tighly and fully encompases the box.
```
     Example:
     
     // Create a bounding sphere around the unit cube
     BoundingSphere sphere = BoundingSphere.fromCornerPoints(new Cartesian3(-0.5, -0.5, -0.5), new Cartesian3(0.5, 0.5, 0.5));
     
 
```
    Parameters:
    
    corner - The minimum height over the rectangle.
    
    oppositeCorner - The maximum height over the rectangle.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromCornerPoints
```
@JsMethod
public static BoundingSphere fromCornerPoints(Cartesian3 corner,
                                                        Cartesian3 oppositeCorner,
                                                        BoundingSphere result)
```
    Computes a bounding sphere from the corner points of an axis-aligned bounding box. The sphere tighly and fully encompases the box.
```
     Example:
     
     // Create a bounding sphere around the unit cube
     BoundingSphere sphere = BoundingSphere.fromCornerPoints(new Cartesian3(-0.5, -0.5, -0.5), new Cartesian3(0.5, 0.5, 0.5));
     
 
```
    Parameters:
    
    corner - The minimum height over the rectangle.
    
    oppositeCorner - The maximum height over the rectangle.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromEllipsoid
```
@JsMethod
public static BoundingSphere fromEllipsoid(Ellipsoid ellipsoid)
```
    Creates a bounding sphere encompassing an ellipsoid.
```
     Example:
     
     BoundingSphere boundingSphere = BoundingSphere.fromEllipsoid(ellipsoid);
     
 
```
    Parameters:
    
    ellipsoid - The ellipsoid around which to create a bounding sphere.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromEllipsoid
```
@JsMethod
public static BoundingSphere fromEllipsoid(Ellipsoid ellipsoid,
                                                     BoundingSphere result)
```
    Creates a bounding sphere encompassing an ellipsoid.
```
     Example:
     
     BoundingSphere boundingSphere = BoundingSphere.fromEllipsoid(ellipsoid);
     
 
```
    Parameters:
    
    ellipsoid - The ellipsoid around which to create a bounding sphere.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromEncodedCartesianVertices
```
@JsMethod
public static BoundingSphere fromEncodedCartesianVertices(double[] positionsHigh,
                                                                    double[] positionsLow)
```
    Computes a tight-fitting bounding sphere enclosing a list of EncodedCartesian3s, where the points are stored in parallel flat arrays in X, Y, Z, order. The bounding sphere is computed by running two algorithms, a naive algorithm and Ritter's algorithm. The smaller of the two spheres is used to ensure a tight fit.
    
    Parameters:
    
    positionsHigh - An array of high bits of the encoded cartesians that the bounding sphere will enclose. Each point is formed from three elements in the array in the order X, Y, Z.
    
    positionsLow - An array of low bits of the encoded cartesians that the bounding sphere will enclose. Each point is formed from three elements in the array in the order X, Y, Z.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
    
    See Also:
    
    Sphere computation article
  - fromEncodedCartesianVertices
```
@JsMethod
public static BoundingSphere fromEncodedCartesianVertices(double[] positionsHigh,
                                                                    double[] positionsLow,
                                                                    BoundingSphere result)
```
    Computes a tight-fitting bounding sphere enclosing a list of EncodedCartesian3s, where the points are stored in parallel flat arrays in X, Y, Z, order. The bounding sphere is computed by running two algorithms, a naive algorithm and Ritter's algorithm. The smaller of the two spheres is used to ensure a tight fit.
    
    Parameters:
    
    positionsHigh - An array of high bits of the encoded cartesians that the bounding sphere will enclose. Each point is formed from three elements in the array in the order X, Y, Z.
    
    positionsLow - An array of low bits of the encoded cartesians that the bounding sphere will enclose. Each point is formed from three elements in the array in the order X, Y, Z.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
    
    See Also:
    
    Sphere computation article
  - fromOrientedBoundingBox
```
@JsMethod
public static BoundingSphere fromOrientedBoundingBox(OrientedBoundingBox orientedBoundingBox)
```
    Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box.
    
    Parameters:
    
    orientedBoundingBox - The oriented bounding box.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromOrientedBoundingBox
```
@JsMethod
public static BoundingSphere fromOrientedBoundingBox(OrientedBoundingBox orientedBoundingBox,
                                                               BoundingSphere result)
```
    Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box.
    
    Parameters:
    
    orientedBoundingBox - The oriented bounding box.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromPoints
```
@JsMethod
public static BoundingSphere fromPoints(Cartesian3[] positions,
                                                  BoundingSphere result)
```
    Computes a tight-fitting bounding sphere enclosing a list of 3D Cartesian points. The bounding sphere is computed by running two algorithms, a naive algorithm and Ritter's algorithm. The smaller of the two spheres is used to ensure a tight fit.
    
    Parameters:
    
    positions - An array of points that the bounding sphere will enclose. Each point must have x, y, and z properties.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
    
    See Also:
    
    Bounding Sphere computation article
  - fromRectangle2D
```
@JsMethod
public static BoundingSphere fromRectangle2D(Rectangle rectangle)
```
    Computes a bounding sphere from an rectangle projected in 2D.
    
    Parameters:
    
    rectangle - The rectangle around which to create a bounding sphere.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromRectangle2D
```
@JsMethod
public static BoundingSphere fromRectangle2D(Rectangle rectangle,
                                                       Object projection)
```
    Computes a bounding sphere from an rectangle projected in 2D.
    
    Parameters:
    
    rectangle - The rectangle around which to create a bounding sphere.
    
    projection - The projection used to project the rectangle into 2D. Default: GeographicProjection
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromRectangle2D
```
@JsMethod
public static BoundingSphere fromRectangle2D(Rectangle rectangle,
                                                       Object projection,
                                                       BoundingSphere result)
```
    Computes a bounding sphere from an rectangle projected in 2D.
    
    Parameters:
    
    rectangle - The rectangle around which to create a bounding sphere.
    
    projection - The projection used to project the rectangle into 2D. Default: GeographicProjection
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromRectangle3D
```
@JsMethod
public static BoundingSphere fromRectangle3D(Rectangle rectangle)
```
    Computes a bounding sphere from an rectangle in 3D. The bounding sphere is created using a subsample of points on the ellipsoid and contained in the rectangle. It may not be accurate for all rectangles on all types of ellipsoids.
    
    Parameters:
    
    rectangle - The valid rectangle used to create a bounding sphere.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromRectangle3D
```
@JsMethod
public static BoundingSphere fromRectangle3D(Rectangle rectangle,
                                                       Ellipsoid ellipsoid,
                                                       double surfaceHeight)
```
    Computes a bounding sphere from an rectangle in 3D. The bounding sphere is created using a subsample of points on the ellipsoid and contained in the rectangle. It may not be accurate for all rectangles on all types of ellipsoids.
    
    Parameters:
    
    rectangle - The valid rectangle used to create a bounding sphere.
    
    ellipsoid - The ellipsoid used to determine positions of the rectangle. Default: Ellipsoid.WGS84()
    
    surfaceHeight - The height above the surface of the ellipsoid.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromRectangle3D
```
@JsMethod
public static BoundingSphere fromRectangle3D(Rectangle rectangle,
                                                       Ellipsoid ellipsoid,
                                                       double surfaceHeight,
                                                       BoundingSphere result)
```
    Computes a bounding sphere from an rectangle in 3D. The bounding sphere is created using a subsample of points on the ellipsoid and contained in the rectangle. It may not be accurate for all rectangles on all types of ellipsoids.
    
    Parameters:
    
    rectangle - The valid rectangle used to create a bounding sphere.
    
    ellipsoid - The ellipsoid used to determine positions of the rectangle. Default: Ellipsoid.WGS84()
    
    surfaceHeight - The height above the surface of the ellipsoid.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromRectangleWithHeights2D
```
@JsMethod
public static BoundingSphere fromRectangleWithHeights2D(Rectangle rectangle,
                                                                  Object projection,
                                                                  double minimumHeight,
                                                                  double maximumHeight)
```
    Computes a bounding sphere from an rectangle projected in 2D. The bounding sphere accounts for the object's minimum and maximum heights over the rectangle.
    
    Parameters:
    
    rectangle - The rectangle around which to create a bounding sphere.
    
    projection - The projection used to project the rectangle into 2D. Default: GeographicProjection
    
    minimumHeight - The minimum height over the rectangle. Default: 0.0
    
    maximumHeight - The maximum height over the rectangle. Default: 0.0
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromRectangleWithHeights2D
```
@JsMethod
public static BoundingSphere fromRectangleWithHeights2D(Rectangle rectangle,
                                                                  Object projection,
                                                                  double minimumHeight,
                                                                  double maximumHeight,
                                                                  BoundingSphere result)
```
    Computes a bounding sphere from an rectangle projected in 2D. The bounding sphere accounts for the object's minimum and maximum heights over the rectangle.
    
    Parameters:
    
    rectangle - The rectangle around which to create a bounding sphere.
    
    projection - The projection used to project the rectangle into 2D. Default: GeographicProjection
    
    minimumHeight - The minimum height over the rectangle. Default: 0.0
    
    maximumHeight - The maximum height over the rectangle. Default: 0.0
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - fromVertices
```
@JsMethod
public static BoundingSphere fromVertices(double[] positions)
```
    Computes a tight-fitting bounding sphere enclosing a list of 3D points, where the points are stored in a flat array in X, Y, Z, order. The bounding sphere is computed by running two algorithms, a naive algorithm and Ritter's algorithm. The smaller of the two spheres is used to ensure a tight fit.
    
    Parameters:
    
    positions - An array of points that the bounding sphere will enclose. Each point is formed from three elements in the array in the order X, Y, Z.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
    
    See Also:
    
    Sphere computation article
  - fromVertices
```
@JsMethod
public static BoundingSphere fromVertices(double[] positions,
                                                    Cartesian3 center,
                                                    int stride)
```
    Computes a tight-fitting bounding sphere enclosing a list of 3D points, where the points are stored in a flat array in X, Y, Z, order. The bounding sphere is computed by running two algorithms, a naive algorithm and Ritter's algorithm. The smaller of the two spheres is used to ensure a tight fit.
```
     Example:
     
     // Compute the bounding sphere from 3 positions, each specified relative to a center.
     // In addition to the X, Y, and Z coordinates, the points array contains two additional
     // elements per point which are ignored for the purpose of computing the bounding sphere.
     Cartesian3 center = new Cartesian3(1.0, 2.0, 3.0);
     double[] points = {1.0, 2.0, 3.0, 0.1, 0.2, 4.0, 5.0, 6.0, 0.1, 0.2, 7.0, 8.0, 9.0, 0.1, 0.2};
     BoundingSphere sphere = BoundingSphere.fromVertices(points, center, 5);
     
 
```
    Parameters:
    
    positions - An array of points that the bounding sphere will enclose. Each point is formed from three elements in the array in the order X, Y, Z.
    
    center - The position to which the positions are relative, which need not be the origin of the coordinate system. This is useful when the positions are to be used for relative-to-center (RTC) rendering. Default: Cartesian3.ZERO()
    
    stride - The number of array elements per vertex. It must be at least 3, but it may be higher. Regardless of the value of this parameter, the X coordinate of the first position is at array index 0, the Y coordinate is at array index 1, and the Z coordinate is at array index 2. When stride is 3, the X coordinate of the next position then begins at array index 3. If the stride is 5, however, two array elements are skipped and the next position begins at array index 5. Default: 0
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
    
    See Also:
    
    Sphere computation article
  - fromVertices
```
@JsMethod
public static BoundingSphere fromVertices(double[] positions,
                                                    Cartesian3 center,
                                                    int stride,
                                                    BoundingSphere result)
```
    Computes a tight-fitting bounding sphere enclosing a list of 3D points, where the points are stored in a flat array in X, Y, Z, order. The bounding sphere is computed by running two algorithms, a naive algorithm and Ritter's algorithm. The smaller of the two spheres is used to ensure a tight fit.
```
     Example:
     
     // Compute the bounding sphere from 3 positions, each specified relative to a center.
     // In addition to the X, Y, and Z coordinates, the points array contains two additional
     // elements per point which are ignored for the purpose of computing the bounding sphere.
     Cartesian3 center = new Cartesian3(1.0, 2.0, 3.0);
     double[] points = {1.0, 2.0, 3.0, 0.1, 0.2, 4.0, 5.0, 6.0, 0.1, 0.2, 7.0, 8.0, 9.0, 0.1, 0.2};
     BoundingSphere sphere = BoundingSphere.fromVertices(points, center, 5);
     
 
```
    Parameters:
    
    positions - An array of points that the bounding sphere will enclose. Each point is formed from three elements in the array in the order X, Y, Z.
    
    center - The position to which the positions are relative, which need not be the origin of the coordinate system. This is useful when the positions are to be used for relative-to-center (RTC) rendering. Default: Cartesian3.ZERO()
    
    stride - The number of array elements per vertex. It must be at least 3, but it may be higher. Regardless of the value of this parameter, the X coordinate of the first position is at array index 0, the Y coordinate is at array index 1, and the Z coordinate is at array index 2. When stride is 3, the X coordinate of the next position then begins at array index 3. If the stride is 5, however, two array elements are skipped and the next position begins at array index 5. Default: 0
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
    
    See Also:
    
    Sphere computation article
  - intersectPlane
```
@JsMethod
public static Integer intersectPlane(BoundingSphere sphere,
                                               Plane plane)
```
    Determines which side of a plane a sphere is located.
    
    Parameters:
    
    sphere - The bounding sphere to test.
    
    plane - The plane to test against.
    
    Returns:
    
    Intersect.INSIDE() if the entire sphere is on the side of the plane the normal is pointing, Intersect.OUTSIDE() if the entire sphere is on the opposite side, and Intersect.INTERSECTING() if the sphere intersects the plane.
  - isOccluded
```
@JsMethod
public static boolean isOccluded(BoundingSphere sphere,
                                           Occluder occluder)
```
    Determines whether or not a sphere is hidden from view by the occluder.
    
    Parameters:
    
    sphere - The bounding sphere surrounding the occludee object.
    
    occluder - The occluder.
    
    Returns:
    
    true if the sphere is not visible; otherwise false.
  - pack
```
public static double[] pack(BoundingSphere value,
                            double[] array)
```
    Stores the provided instance into the provided array.
    
    Parameters:
    
    value - The value to pack.
    
    array - The array to pack into.
    
    Returns:
    
    The array that was packed into
  - pack
```
public static double[] pack(BoundingSphere value,
                            double[] array,
                            int startingIndex)
```
    Stores the provided instance into the provided array.
    
    Parameters:
    
    value - The value to pack.
    
    array - The array to pack into.
    
    startingIndex - The index into the array at which to start packing the elements. Default: 0
    
    Returns:
    
    The array that was packed into
  - projectTo2D
```
@JsMethod
public static BoundingSphere projectTo2D(BoundingSphere sphere)
```
    Creates a bounding sphere in 2D from a bounding sphere in 3D world coordinates.
    
    Parameters:
    
    sphere - The bounding sphere to transform to 2D.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - projectTo2D
```
@JsMethod
public static BoundingSphere projectTo2D(BoundingSphere sphere,
                                                   Object projection)
```
    Creates a bounding sphere in 2D from a bounding sphere in 3D world coordinates.
    
    Parameters:
    
    sphere - The bounding sphere to transform to 2D.
    
    projection - The projection to 2D. Default: GeographicProjection
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - projectTo2D
```
@JsMethod
public static BoundingSphere projectTo2D(BoundingSphere sphere,
                                                   Object projection,
                                                   BoundingSphere result)
```
    Creates a bounding sphere in 2D from a bounding sphere in 3D world coordinates.
    
    Parameters:
    
    sphere - The bounding sphere to transform to 2D.
    
    projection - The projection to 2D. Default: GeographicProjection
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - transform
```
@JsMethod
public static BoundingSphere transform(BoundingSphere sphere,
                                                 Matrix4 transform)
```
    Applies a 4x4 affine transformation matrix to a bounding sphere.
    
    Parameters:
    
    sphere - The bounding sphere to apply the transformation to.
    
    transform - The transformation matrix to apply to the bounding sphere.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - transform
```
@JsMethod
public static BoundingSphere transform(BoundingSphere sphere,
                                                 Matrix4 transform,
                                                 BoundingSphere result)
```
    Applies a 4x4 affine transformation matrix to a bounding sphere.
    
    Parameters:
    
    sphere - The bounding sphere to apply the transformation to.
    
    transform - The transformation matrix to apply to the bounding sphere.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - transformWithoutScale
```
@JsMethod
public static BoundingSphere transformWithoutScale(BoundingSphere sphere,
                                                             Matrix4 transform)
```
    Applies a 4x4 affine transformation matrix to a bounding sphere where there is no scale The transformation matrix is not verified to have a uniform scale of 1. This method is faster than computing the general bounding sphere transform using BoundingSphere.transform.
```
     Example:
     
     var modelMatrix = Transforms.eastNorthUpToFixedFrame(positionOnEllipsoid);
     BoundingSphere boundingSphere = new BoundingSphere();
     BoundingSphere newBoundingSphere = BoundingSphere.transformWithoutScale(boundingSphere, modelMatrix);
     
 
```
    Parameters:
    
    sphere - The bounding sphere to apply the transformation to.
    
    transform - The transformation matrix to apply to the bounding sphere.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - transformWithoutScale
```
@JsMethod
public static BoundingSphere transformWithoutScale(BoundingSphere sphere,
                                                             Matrix4 transform,
                                                             BoundingSphere result)
```
    Applies a 4x4 affine transformation matrix to a bounding sphere where there is no scale The transformation matrix is not verified to have a uniform scale of 1. This method is faster than computing the general bounding sphere transform using BoundingSphere.transform.
```
     Example:
     
     var modelMatrix = Transforms.eastNorthUpToFixedFrame(positionOnEllipsoid);
     BoundingSphere boundingSphere = new BoundingSphere();
     BoundingSphere newBoundingSphere = BoundingSphere.transformWithoutScale(boundingSphere, modelMatrix);
     
 
```
    Parameters:
    
    sphere - The bounding sphere to apply the transformation to.
    
    transform - The transformation matrix to apply to the bounding sphere.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - union
```
@JsMethod
public static BoundingSphere union(BoundingSphere left,
                                             BoundingSphere right)
```
    Computes a bounding sphere that contains both the left and right bounding spheres.
    
    Parameters:
    
    left - A sphere to enclose in a bounding sphere.
    
    right - A sphere to enclose in a bounding sphere.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - union
```
@JsMethod
public static BoundingSphere union(BoundingSphere left,
                                             BoundingSphere right,
                                             BoundingSphere result)
```
    Computes a bounding sphere that contains both the left and right bounding spheres.
    
    Parameters:
    
    left - A sphere to enclose in a bounding sphere.
    
    right - A sphere to enclose in a bounding sphere.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - unpack
```
public static BoundingSphere unpack(double[] array)
```
    Retrieves an instance from a packed array.
    
    Parameters:
    
    array - The packed array.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
  - unpack
```
public static BoundingSphere unpack(double[] array,
                                    int startingIndex)
```
    Retrieves an instance from a packed array.
    
    Parameters:
    
    array - The packed array.
    
    startingIndex - The starting index of the element to be unpacked. Default: 0
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
  - unpack
```
public static BoundingSphere unpack(double[] array,
                                    int startingIndex,
                                    BoundingSphere result)
```
    Retrieves an instance from a packed array.
    
    Parameters:
    
    array - The packed array.
    
    startingIndex - The starting index of the element to be unpacked. Default: 0
    
    result - The object into which to store the result.
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if one was not provided.
  - clone
```
@JsMethod
public BoundingSphere clone()
```
    Duplicates this BoundingSphere instance.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    The modified result parameter or a new BoundingSphere instance if none was provided.
  - computePlaneDistances
```
@JsMethod
public Interval computePlaneDistances(Cartesian3 position,
                                                Cartesian3 direction)
```
    The distances calculated by the vector from the center of the bounding sphere to position projected onto direction plus/minus the radius of the bounding sphere. If you imagine the infinite number of planes with normal direction, this computes the smallest distance to the closest and farthest planes from position that intersect the bounding sphere.
    
    Parameters:
    
    position - The position to calculate the distance from.
    
    direction - The direction from position.
    
    Returns:
    
    The nearest and farthest distances on the bounding sphere from position in direction.
  - computePlaneDistances
```
@JsMethod
public Interval computePlaneDistances(Cartesian3 position,
                                                Cartesian3 direction,
                                                Interval result)
```
    The distances calculated by the vector from the center of the bounding sphere to position projected onto direction plus/minus the radius of the bounding sphere. If you imagine the infinite number of planes with normal direction, this computes the smallest distance to the closest and farthest planes from position that intersect the bounding sphere.
    
    Parameters:
    
    position - The position to calculate the distance from.
    
    direction - The direction from position.
    
    result - A Interval to store the nearest and farthest distances.
    
    Returns:
    
    The nearest and farthest distances on the bounding sphere from position in direction.
  - distanceSquaredTo
```
@JsMethod
public double distanceSquaredTo(Cartesian3 cartesian)
```
    Computes the estimated distance squared from the closest point on a bounding sphere to a point.
    
    Parameters:
    
    cartesian - The point
    
    Returns:
    
    The estimated distance squared from the bounding sphere to the point.
  - equals
```
@JsMethod
public boolean equals(BoundingSphere right)
```
    Compares this BoundingSphere against the provided BoundingSphere componentwise and returns true if they are equal, false otherwise.
    
    Parameters:
    
    right - The right hand side BoundingSphere.
    
    Returns:
    
    true if they are equal, false otherwise.
  - intersectPlane
```
@JsMethod
public Number intersectPlane(Plane plane)
```
    Determines which side of a plane the sphere is located.
    
    Parameters:
    
    plane - The plane to test against.
    
    Returns:
    
    Intersect.INSIDE() if the entire sphere is on the side of the plane the normal is pointing, Intersect.OUTSIDE() if the entire sphere is on the opposite side, and Intersect.INTERSECTING() if the sphere intersects the plane.
  - isOccluded
```
@JsMethod
public boolean isOccluded(Occluder occluder)
```
    Determines whether or not a sphere is hidden from view by the occluder.
    
    Parameters:
    
    occluder - The occluder.
    
    Returns:
    
    true if the sphere is not visible; otherwise false.
  - volume
```
@JsMethod
public double volume()
```
    Computes the radius of the BoundingSphere.
    
    Returns:
    
    The radius of the BoundingSphere.

Class BoundingSphere

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

center

radius

Constructor Detail

BoundingSphere

BoundingSphere

Method Detail

clone

clone

computePlaneDistances

computePlaneDistances

distanceSquaredTo

equals

expand

expand

fromBoundingSpheres

fromBoundingSpheres

fromCornerPoints

fromCornerPoints

fromEllipsoid

fromEllipsoid

fromEncodedCartesianVertices

fromEncodedCartesianVertices

fromOrientedBoundingBox

fromOrientedBoundingBox

fromPoints

fromRectangle2D

fromRectangle2D

fromRectangle2D

fromRectangle3D

fromRectangle3D

fromRectangle3D

fromRectangleWithHeights2D

fromRectangleWithHeights2D

fromVertices

fromVertices

fromVertices

intersectPlane

isOccluded

pack

pack

projectTo2D

projectTo2D

projectTo2D

transform

transform

transformWithoutScale

transformWithoutScale

union

union

unpack

unpack

unpack

clone

computePlaneDistances

computePlaneDistances

distanceSquaredTo

equals

intersectPlane

isOccluded

volume