| Package | Description |
|---|---|
| agi.foundation.access |
Contains types used in performing access calculations.
|
| agi.foundation.aircraftpropagation |
Contains types for propagating an aircraft through various maneuvers subject to
flight phase performance models and wind effects.
|
| agi.foundation.ccsds |
Contains types for interoperating with data formats supported by
The Consultative Committee for Space Data Systems (CCSDS).
|
| agi.foundation.celestial |
Contains types used in modeling characteristics of celestial objects and celestial phenomena.
|
| agi.foundation.cesium |
Contains types used for defining graphical properties of definitional objects to be written out as CZML.
|
| agi.foundation.communications |
Contains types for representing electromagnetic signals and propagating them along communication links.
|
| agi.foundation.communications.antennas |
Contains types for representing antennas, defining gain patterns, and processing electromagnetic signals.
|
| agi.foundation.coordinates |
Contains types for quantifying and converting between various coordinate representations.
|
| agi.foundation.coverage |
Contains types for computing complex access calculations between many different objects simultaneously.
|
| agi.foundation.geometry |
Contains types for expressing the motion of fundamental geometric objects such as points, axes, and reference frames;
the manner in which they are related; and transformations between representations.
|
| agi.foundation.geometry.discrete |
Contains types which define discretization algorithms and metadata for analysis of spatial geometry.
|
| agi.foundation.geometry.shapes |
Contains types for representing geometric shapes such as curves, surfaces, and solids.
|
| agi.foundation.graphics |
Provides commonly used and instantiated graphics types related to 3D scene management, terrain and imagery, and more.
|
| agi.foundation.graphics.advanced |
Provides less commonly instantiated graphics types for the camera, mouse options, primitive options, and others.
|
| agi.foundation.navigation |
Contains types useful in modeling navigation processes which utilize the Global Positioning System (GPS).
|
| agi.foundation.navigation.datareaders |
Contains types for reading various navigation-related data file formats.
|
| agi.foundation.numericalmethods |
Contains general numerical algorithms.
|
| agi.foundation.platforms |
Contains types used in modeling various mechanical platforms such as satellites, facilities, aircraft, etc.
|
| agi.foundation.propagators |
Contains types used in producing the state of an object from a known element set.
|
| agi.foundation.propagators.advanced |
Contains types used to create more specialized propagation scenarios.
|
| agi.foundation.routedesign |
Contains types for creating simple routes by specifying procedures at points of interest, how to connect them, and what height and speed to use along the route.
|
| agi.foundation.routedesign.advanced |
Contains types used to define immutable geometry and configuration for routes.
|
| agi.foundation.segmentpropagation |
Contains types for modeling a trajectory in segments, where the type of propagation varies for each segment.
|
| agi.foundation.stk |
Contains types for interoperating with the STK desktop application and related data.
|
| agi.foundation.terrain |
Contains types for reading and analyzing terrain data.
|
| agi.foundation.tracking |
Contains types for acquiring, analyzing and archiving dynamic data, such as those found in real-time feeds or simulation environments.
|
| Modifier and Type | Method and Description |
|---|---|
static JulianDate |
AccessConstraintSampling.getNextStepFromRelativeMotion(JulianDate epoch,
Motion1<Cartesian> relativeMotion,
double maximumAngularMotion)
Computes an appropriate next sample step based on the relative motion between the two
platforms involved in the Access computation and a maximum relative motion per step.
|
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
AircraftMotionElement.getInitialPosition()
Gets the initial position in the fixed frame.
|
Cartesian |
AircraftMotionElement.getInitialVelocity()
Gets the initial velocity in the fixed frame.
|
| Modifier and Type | Method and Description |
|---|---|
Motion1<Cartesian> |
AircraftStateElementConverter.convertState(double[] overallState)
Convert the raw state into a
Cartesian and its derivatives. |
abstract Evaluator<Cartesian> |
Maneuver.getAccelerationEvaluator(EvaluatorGroup group,
IServiceProvider serviceProvider)
Gets an instance of an evaluator that can compute the acceleration components of the maneuver.
|
Evaluator<Cartesian> |
CompositeManeuver.getAccelerationEvaluator(EvaluatorGroup group,
IServiceProvider serviceProvider)
Gets an instance of an evaluator that can compute the acceleration components of the maneuver.
|
Evaluator<Cartesian> |
Maneuver.getAccelerationEvaluator(IServiceProvider serviceProvider)
Gets an instance of an evaluator that can compute the acceleration components of the maneuver.
|
Evaluator<Cartesian> |
SimpleFixedWingForwardFlightAerodynamics.getEvaluator()
Gets an evaluator that computes the aerodynamic force in the wind frame as drag, side, and lift force components.
|
Evaluator<Cartesian> |
SimpleFixedWingForwardFlightAerodynamics.getEvaluator(EvaluatorGroup group)
Gets an evaluator that computes the aerodynamic force in the wind frame as drag, side, and lift force components.
|
Motion1<Cartesian> |
AircraftReferenceState.toMotionInFixedFrame(WindModel winds)
|
| Modifier and Type | Method and Description |
|---|---|
static double |
Maneuver.convertHorizontalAirspeedRateToHorizontalGroundSpeedRate(double horizontalGroundSpeed,
double sineTrueCourse,
double cosineTrueCourse,
double sineTrueHeading,
double cosineTrueHeading,
Cartesian windRate,
double horizontalAirspeedRate,
double trueCourseRate)
Converts the rate of change of horizontal airspeed to rate of change of horizontal ground speed.
|
static AzimuthHorizontalVertical |
Maneuver.convertMovingAtmosphereRatesToStaticAtmosphereRates(double verticalGroundSpeed,
double horizontalGroundSpeed,
double sineTrueCourse,
double cosineTrueCourse,
double verticalAirspeed,
double horizontalAirspeed,
double sineTrueHeading,
double cosineTrueHeading,
Cartesian windRate,
AzimuthHorizontalVertical derivatives)
Converts the rates with respect to the moving atmosphere to rates with respect to the static atmosphere.
|
static double |
Maneuver.convertTrueHeadingRateToTrueCourseRate(double horizontalGroundSpeed,
double sineTrueCourse,
double cosineTrueCourse,
double horizontalAirspeed,
double sineTrueHeading,
double cosineTrueHeading,
Cartesian windRate,
double horizontalGroundSpeedRate,
double trueHeadingRate)
Converts the rate of change of true heading to the rate of change of true course.
|
void |
AircraftMotionElement.setInitialPosition(Cartesian value)
Sets the initial position in the fixed frame.
|
void |
AircraftMotionElement.setInitialVelocity(Cartesian value)
Sets the initial velocity in the fixed frame.
|
| Constructor and Description |
|---|
AircraftStateElementConverter(String identification,
Motion1<int[]> stateIndices,
Cartesian initialPosition,
Cartesian initialVelocity,
Ellipsoid ellipsoid)
Initializes a new instance.
|
AircraftStateElementConverter(String identification,
Motion1<int[]> stateIndices,
Cartesian initialPosition,
Cartesian initialVelocity,
Ellipsoid ellipsoid,
Motion1<double[]> weights)
Initializes a new instance.
|
| Modifier and Type | Method and Description |
|---|---|
DateMotionCollection1<Cartesian> |
CcsdsOrbitEphemerisMessageSegment.getEphemerisData()
Gets the ephemeris data.
|
| Modifier and Type | Method and Description |
|---|---|
void |
CcsdsOrbitEphemerisMessageSegment.setEphemerisData(DateMotionCollection1<Cartesian> value)
Sets the ephemeris data.
|
| Modifier and Type | Method and Description |
|---|---|
static Cartesian |
TwoBodyGravity.calculateAcceleration(Cartesian position,
double gravitationalParameter)
Calculates the acceleration at a position caused by two-body gravity.
|
static Cartesian |
AtmosphericDragForce.calculateForce(Cartesian velocity,
double density,
double dragCoefficient,
double area)
Calculates the atmospheric drag force on an object.
|
Cartesian |
ConstantForce.getForce()
Gets the direction and magnitude of the force.
|
Cartesian |
OffAxisTorque.getOffset()
Gets the body-fixed position of the thruster with respect to the center of mass of the vehicle.
|
Cartesian |
ConstantTorque.getTorque()
Gets the direction and magnitude of the torque.
|
| Modifier and Type | Method and Description |
|---|---|
static Cartesian |
TwoBodyGravity.calculateAcceleration(Cartesian position,
double gravitationalParameter)
Calculates the acceleration at a position caused by two-body gravity.
|
static Cartesian |
AtmosphericDragForce.calculateForce(Cartesian velocity,
double density,
double dragCoefficient,
double area)
Calculates the atmospheric drag force on an object.
|
static Vector |
ContinuousThrustForceModel.createIspThrustVector(Scalar isp,
Scalar massFlowRate,
Axes burnAxes,
Cartesian thrustDirection)
Creates a thrust
Vector where the thrust is computed from the
isp, and massFlowRate pointing in the thrustDirection
in the specified burnAxes. |
static boolean |
CentralBodyIntersection.doesIntersect(Cartesian positionOne,
Cartesian velocityOne,
Cartesian positionTwo,
Cartesian velocityTwo,
int numberOfRevs,
double geocentricRadiusOfIntersection,
double gravitationalParameter)
Determines if an orbit will intersect the planet specified by the corresponding gravitational parameter and geocentric radius of intersection.
|
protected static double[] |
ScalarOccultation.eclipseAngles(Ellipsoid eclipsingBody,
Cartesian platformToEclipsing,
Cartesian platformToIlluminating,
Ellipsoid illuminatingBody)
Returns the angles needed for the various eclipse calculations in the format
[relative angle, eclipse body half angle, illuminating body half angle].
|
void |
ConstantForce.setForce(Cartesian value)
Sets the direction and magnitude of the force.
|
void |
OffAxisTorque.setOffset(Cartesian value)
Sets the body-fixed position of the thruster with respect to the center of mass of the vehicle.
|
void |
ConstantTorque.setTorque(Cartesian value)
Sets the direction and magnitude of the torque.
|
| Modifier and Type | Method and Description |
|---|---|
static boolean |
CentralBodyIntersection.doesIntersect(Motion1<Cartesian> motionOne,
Motion1<Cartesian> motionTwo,
int numberOfRevs,
double geocentricRadiusOfIntersection,
double gravitationalParameter)
Determines if an orbit will intersect the planet specified by the corresponding gravitational parameter and geocentric radius of intersection.
|
static boolean |
CentralBodyIntersection.doesIntersect(Motion1<Cartesian> motionOne,
Motion1<Cartesian> motionTwo,
int numberOfRevs,
double geocentricRadiusOfIntersection,
double gravitationalParameter)
Determines if an orbit will intersect the planet specified by the corresponding gravitational parameter and geocentric radius of intersection.
|
| Constructor and Description |
|---|
ConstantForce(Axes definedInAxes,
Cartesian force)
Initializes a new instance of the class.
|
ConstantTorque(Axes definedInAxes,
Cartesian torque)
Initializes a new instance of the class.
|
MagneticCoilTorque(Vector magneticFieldVector,
double numberOfLoops,
Scalar current,
Cartesian directedArea,
Axes bodyAxes)
Initializes the magnetic coil torque model.
|
OffAxisTorque(Scalar thrustMagnitude,
UnitCartesian thrustAxis,
Cartesian offset,
Axes bodyAxes)
Initializes a model of the torque generated by a thruster that is not aligned with the center of mass of a vehicle.
|
OffAxisTorque(Vector thrustVector,
Cartesian offset,
Axes bodyAxes)
Initializes a model of the torque generated by a thruster that is not aligned with the center of mass of a vehicle.
|
| Constructor and Description |
|---|
TorqueEvaluator(Evaluator<Cartesian> existingInstance,
CopyContext context)
Initializes a new instance as a copy of an existing instance.
|
| Modifier and Type | Method and Description |
|---|---|
CesiumProperty<Cartesian> |
LabelGraphics.getEyeOffset()
Gets the label's offset from the origin in eye coordinates.
|
CesiumProperty<Cartesian> |
BillboardGraphics.getEyeOffset()
Gets the billboard's offset from the origin in eye coordinates.
|
CesiumProperty<Cartesian> |
EllipsoidGraphics.getInnerRadii()
Gets the inner radii of the ellipsoid.
|
CesiumProperty<Cartesian> |
ViewFrom.getOffset()
Gets the suggested initial offset when tracking an object.
|
CesiumProperty<Cartesian> |
EllipsoidGraphics.getRadii()
Gets the radii of the ellipsoid.
|
CesiumProperty<Cartesian> |
NodeTransformationGraphics.getScale()
Gets the x,y,z scaling to apply to the model node.
|
CesiumProperty<Cartesian> |
NodeTransformationGraphics.getTranslation()
Gets the x,y,z translation to apply to the model node.
|
| Modifier and Type | Method and Description |
|---|---|
void |
LabelGraphics.setEyeOffset(CesiumProperty<Cartesian> value)
Sets the label's offset from the origin in eye coordinates.
|
void |
BillboardGraphics.setEyeOffset(CesiumProperty<Cartesian> value)
Sets the billboard's offset from the origin in eye coordinates.
|
void |
EllipsoidGraphics.setInnerRadii(CesiumProperty<Cartesian> value)
Sets the inner radii of the ellipsoid.
|
void |
ViewFrom.setOffset(CesiumProperty<Cartesian> value)
Sets the suggested initial offset when tracking an object.
|
void |
EllipsoidGraphics.setRadii(CesiumProperty<Cartesian> value)
Sets the radii of the ellipsoid.
|
void |
NodeTransformationGraphics.setScale(CesiumProperty<Cartesian> value)
Sets the x,y,z scaling to apply to the model node.
|
void |
NodeTransformationGraphics.setTranslation(CesiumProperty<Cartesian> value)
Sets the x,y,z translation to apply to the model node.
|
| Modifier and Type | Method and Description |
|---|---|
ElectricFieldVectorComponents |
SphericalTabularElectricFieldPattern.computeElectricFieldComponents(Cartesian linkVector)
Computes the electric field vector components given the cartesian direction.
|
| Modifier and Type | Method and Description |
|---|---|
Function2<Cartesian,Double> |
CustomGainPattern.getGainFunction()
Gets the gain pattern function which takes a direction as a
Cartesian and
returns a gain value as a double. |
| Modifier and Type | Method and Description |
|---|---|
Double |
SphericalTabularGainData.evaluate(Cartesian direction)
Evaluate the gain given the cartesian direction expressed in the antennas axes.
|
Motion1<Double> |
SphericalTabularGainData.evaluate(Cartesian direction,
int order)
Evaluate the gain given the cartesian direction expressed in the antennas axes.
|
| Modifier and Type | Method and Description |
|---|---|
void |
CustomGainPattern.setGainFunction(Function2<Cartesian,Double> value)
Sets the gain pattern function which takes a direction as a
Cartesian and
returns a gain value as a double. |
| Constructor and Description |
|---|
CustomGainPattern(Function2<Cartesian,Double> gainFunction)
Initialize an instance with a given pattern function.
|
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
UnitCartesian.add(Cartesian other)
Adds the specified set of
Cartesian coordinates to this instance. |
Cartesian |
Cartesian.add(Cartesian other)
Adds the specified set of
Cartesian coordinates to this instance. |
static Cartesian |
Cartesian.add(Cartesian left,
Cartesian right)
|
static Cartesian |
UnitCartesian.add(Cartesian left,
UnitCartesian right)
Adds a specified set of
UnitCartesian coordinates to a specified set of Cartesian coordinates. |
Cartesian |
UnitCartesian.add(UnitCartesian other)
Adds the specified set of
UnitCartesian coordinates to this instance. |
static Cartesian |
UnitCartesian.add(UnitCartesian left,
Cartesian right)
Adds a specified set of
Cartesian coordinates to a specified set of UnitCartesian coordinates. |
static Cartesian |
UnitCartesian.add(UnitCartesian left,
UnitCartesian right)
Adds a specified set of
UnitCartesian coordinates to another specified set of UnitCartesian coordinates. |
Cartesian |
UnitCartesian.cross(Cartesian other)
Forms the cross product of the specified set of
Cartesian coordinates with this instance. |
Cartesian |
Cartesian.cross(Cartesian other)
Forms the cross product of the specified set of
Cartesian coordinates with this instance. |
Cartesian |
UnitCartesian.cross(UnitCartesian other)
Forms the cross product of the specified set of
UnitCartesian coordinates with this instance. |
static Cartesian |
Cartesian.divide(Cartesian left,
double right)
Divides a specified set of
Cartesian coordinates by a scalar. |
Cartesian |
UnitCartesian.divide(double scalar)
Divides this instance by a scalar.
|
Cartesian |
Cartesian.divide(double scalar)
Divides this instance by a scalar.
|
static Cartesian |
UnitCartesian.divide(UnitCartesian left,
double right)
Divides a specified set of
UnitCartesian coordinates by a scalar. |
Cartesian |
RotationVectorAngularVelocity.getAngularVelocity()
Gets the body-fixed angular velocity of the rigid-body.
|
Cartesian |
CartesianBounds.getLowerBound()
Gets the minimal value defining the bounds.
|
Cartesian |
HelmertTransformation.getRotation()
Gets the off-diagonal components of the skew-symmetric rotation matrix.
|
Cartesian |
KinematicTransformation.getRotationalAcceleration()
Gets the rotational acceleration of the second reference frame relative to and expressed in
the first reference frame.
|
Cartesian |
HelmertTransformation.getRotationalVelocity()
Gets the rate of change of the off-diagonal components over time.
|
Cartesian |
KinematicTransformation.getRotationalVelocity()
Gets the rotational velocity of the second reference frame relative to and expressed in
the first reference frame.
|
Cartesian |
Covariance3By3Derivative.getRotationDerivative()
Gets the
Cartesian describing the derivative of the rotation to the axes of the Covariance Ellipsoid. |
Cartesian |
RotationVectorAngularVelocity.getRotationVector()
Gets the rotation vector, which is the rotation angle times the rotation axis.
|
Cartesian |
Covariance3By3Derivative.getSigmaDerivatives()
Gets the
Cartesian with the derivative of the sigma values of the transformed Covariance Matrix. |
Cartesian |
Covariance3By3SizeAndOrientation.getSigmas()
Gets the
Cartesian with the sigma values of the transformed Covariance Matrix. |
Cartesian |
HelmertTransformation.getTranslation()
Gets the relative position vector between the reference frames.
|
Cartesian |
KinematicTransformation.getTranslation()
Gets the relative position vector between the reference frames.
|
Cartesian |
KinematicTransformation.getTranslationalAcceleration()
Gets the relative acceleration vector between the reference frames.
|
Cartesian |
HelmertTransformation.getTranslationalVelocity()
Gets the relative velocity vector between the reference frames.
|
Cartesian |
KinematicTransformation.getTranslationalVelocity()
Gets the relative velocity vector between the reference frames.
|
static Cartesian |
Cartesian.getUndefined()
Gets a set of
Cartesian coordinates with values of Double.NaN. |
Cartesian |
CartesianBounds.getUpperBound()
Gets the maximal value defining the bounds.
|
static Cartesian |
Cartesian.getZero()
Gets a set of
Cartesian coordinates with values of zero. |
Cartesian |
Cartesian.invert()
Inverts this instance.
|
Cartesian |
Matrix3By3Symmetric.multiply(Cartesian vector)
Forms a new Cartesian vector as the product of this 3-by-3 matrix and the provided Cartesian vector.
|
Cartesian |
Matrix3By3.multiply(Cartesian vector)
Forms a new Cartesian vector as the product of this 3-by-3 matrix and the provided Cartesian vector.
|
static Cartesian |
Cartesian.multiply(Cartesian left,
double right)
Multiplies a specified set of
Cartesian coordinates by a scalar. |
static Cartesian |
Cartesian.multiply(Cartesian left,
Matrix3By3 right)
Multiplies a specified set of
Cartesian coordinates by a Matrix3By3. |
Cartesian |
UnitCartesian.multiply(double scalar)
Multiplies this instance by a scalar.
|
Cartesian |
Cartesian.multiply(double scalar)
Multiplies this instance by a scalar.
|
static Cartesian |
Cartesian.multiply(double left,
Cartesian right)
Multiplies a scalar by a specified set of set of
Cartesian coordinates. |
static Cartesian |
UnitCartesian.multiply(double left,
UnitCartesian right)
Multiplies a scalar by a specified set of
UnitCartesian coordinates. |
Cartesian |
Cartesian.multiply(Matrix3By3 matrix)
Multiplies this instance (treated as a row vector) by a
Matrix3By3. |
static Cartesian |
Matrix3By3.multiply(Matrix3By3 matrix,
Cartesian vector)
Multiplies the 3-by-3 matrix by the Cartesian vector.
|
static Cartesian |
Matrix3By3Symmetric.multiply(Matrix3By3Symmetric matrix,
Cartesian vector)
Multiplies the 3-by-3 matrix by the Cartesian vector.
|
static Cartesian |
UnitCartesian.multiply(UnitCartesian left,
double right)
Multiplies a specified set of
UnitCartesian coordinates by a scalar. |
static Cartesian |
Cartesian.negate(Cartesian coordinates)
|
Cartesian |
Cartesian.rotate(ElementaryRotation rotation)
Produces a set of
Cartesian coordinates representing this instance which results from rotating
the original axes used to represent this instance by the provided ElementaryRotation rotation. |
Cartesian |
Cartesian.rotate(Matrix3By3 rotation)
Produces a set of
Cartesian coordinates representing this instance which results from rotating
the original axes used to represent this instance by the provided Matrix3By3 rotation. |
Cartesian |
Cartesian.rotate(UnitQuaternion rotation)
Produces a set of
Cartesian coordinates representing this instance which results from rotating
the original axes used to represent this instance by the provided UnitQuaternion rotation. |
Cartesian |
UnitCartesian.subtract(Cartesian other)
Subtracts the specified set of
Cartesian coordinates from this instance. |
Cartesian |
Cartesian.subtract(Cartesian other)
Subtracts the specified set of
Cartesian coordinates from this instance. |
static Cartesian |
Cartesian.subtract(Cartesian left,
Cartesian right)
|
static Cartesian |
UnitCartesian.subtract(Cartesian left,
UnitCartesian right)
Subtracts a specified set of
UnitCartesian coordinates from a specified set of Cartesian coordinates. |
Cartesian |
UnitCartesian.subtract(UnitCartesian other)
Subtracts the specified set of
UnitCartesian coordinates from this instance. |
static Cartesian |
UnitCartesian.subtract(UnitCartesian left,
Cartesian right)
Subtracts a specified set of
Cartesian coordinates from a specified set of UnitCartesian coordinates. |
static Cartesian |
UnitCartesian.subtract(UnitCartesian left,
UnitCartesian right)
Subtracts a specified set of
UnitCartesian coordinates from another specified set of UnitCartesian coordinates. |
static Cartesian |
Cartesian.toCartesian(UnitCartesian coordinates)
Converts a set of
UnitCartesian coordinates to a set of Cartesian coordinates. |
Cartesian |
HelmertTransformation.transform(Cartesian position)
Transforms the position observed in the A frame to the B frame.
|
Cartesian |
KinematicTransformation.transform(Cartesian position)
Transforms the position observed in the A frame to the B frame.
|
static Cartesian |
RotationVectorAngularVelocity.unitQuaternionToRotationVector(UnitQuaternion unitQuaternion)
Converts a unit quaternion to a rotation vector.
|
| Modifier and Type | Method and Description |
|---|---|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(AngleAxisRotation first,
Motion2<UnitQuaternion,Cartesian> second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(ElementaryRotation first,
Motion2<UnitQuaternion,Cartesian> second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
AngleAxisRotation second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
ElementaryRotation second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
Motion2<UnitQuaternion,Cartesian> second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitCartesian,Cartesian> |
UnitCartesian.convertMotion(Motion1<Cartesian> motion,
int order)
Converts the motion given in terms of a set of
Cartesian coordinates to motion
of the corresponding set of UnitCartesian coordinates. |
static Motion1<Cartesian> |
Cartesian.convertMotion(Motion1<LongitudeLatitudeRadius> motion,
int order)
Converts the motion given in terms of a set of
LongitudeLatitudeRadius coordinates to motion
of the corresponding set of Cartesian coordinates. |
static Motion2<UnitQuaternion,Cartesian> |
AlignedConstrained.getMotion(Motion1<Cartesian> principal,
Motion1<Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AlignedConstrained.getMotion(Motion2<UnitCartesian,Cartesian> principal,
Motion2<UnitCartesian,Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
Motion2<UnitQuaternion,Cartesian> |
KinematicTransformation.getRotationalMotion()
Gets the rotational portion of this transformation.
|
Motion1<Cartesian> |
KinematicTransformation.getTranslationalMotion()
Gets the translational portion of this transformation.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.invert(Motion2<UnitQuaternion,Cartesian> motion,
int order)
Forms the inverse rotational transformation.
|
Motion1<Cartesian> |
ModifiedKeplerianElements.toCartesian()
Returns a cartesian representation of these orbital elements.
|
Motion1<Cartesian> |
KozaiIzsakMeanElements.toCartesian()
Returns an osculating
Cartesian representation of these mean orbital elements. |
Motion1<Cartesian> |
KeplerianElements.toCartesian()
Returns a cartesian representation of these orbital elements.
|
Motion1<Cartesian> |
EquinoctialElements.toCartesian()
Converts this set of equinoctial elements to a cartesian position and velocity.
|
Motion1<Cartesian> |
DelaunayElements.toCartesian()
Converts this set of Delaunay elements to a cartesian position and velocity.
|
static DateMotionCollection2<UnitQuaternion,Cartesian> |
RotationVectorAngularVelocity.toDateMotionCollectionUnitQuaternionCartesian(DateMotionCollection1<RotationVectorAngularVelocity> inputCollection,
int order)
Converts a
DateMotionCollection<RotationVectorAngularVelocity> to a DateMotionCollection<UnitQuaternion, Cartesian>. |
static Motion2<UnitQuaternion,Cartesian> |
RotationVectorAngularVelocity.toMotionUnitQuaternionCartesian(Motion1<RotationVectorAngularVelocity> motionRotationVectorAngularVelocity,
int order)
|
static Motion2<UnitQuaternion,Cartesian> |
RotationVectorAngularVelocity.toMotionUnitQuaternionCartesian(RotationVectorAngularVelocity rotationVectorAngularVelocity,
int order)
|
Motion1<Cartesian> |
HelmertTransformation.transform(Motion1<Cartesian> motion)
Transforms the motion observed in the A frame to the B frame.
|
Motion1<Cartesian> |
KinematicTransformation.transform(Motion1<Cartesian> motion)
Transforms the motion observed in the A frame to the B frame.
|
Motion1<Cartesian> |
HelmertTransformation.transform(Motion1<Cartesian> motion,
int order)
Transforms the motion observed in the A frame to the B frame.
|
Motion1<Cartesian> |
KinematicTransformation.transform(Motion1<Cartesian> motion,
int order)
Transforms the motion observed in the A frame to the B frame.
|
static Motion1<Cartesian> |
RotationalTransformation.transform(Motion2<UnitQuaternion,Cartesian> rotationalTransformation,
Motion1<Cartesian> motion,
int order)
Transforms the vector observed in the A axes to the B axes.
|
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
UnitCartesian.add(Cartesian other)
Adds the specified set of
Cartesian coordinates to this instance. |
Cartesian |
Cartesian.add(Cartesian other)
Adds the specified set of
Cartesian coordinates to this instance. |
static Cartesian |
Cartesian.add(Cartesian left,
Cartesian right)
|
static Cartesian |
UnitCartesian.add(Cartesian left,
UnitCartesian right)
Adds a specified set of
UnitCartesian coordinates to a specified set of Cartesian coordinates. |
static Cartesian |
UnitCartesian.add(UnitCartesian left,
Cartesian right)
Adds a specified set of
Cartesian coordinates to a specified set of UnitCartesian coordinates. |
Cartesian |
UnitCartesian.cross(Cartesian other)
Forms the cross product of the specified set of
Cartesian coordinates with this instance. |
Cartesian |
Cartesian.cross(Cartesian other)
Forms the cross product of the specified set of
Cartesian coordinates with this instance. |
static Matrix3By3 |
Matrix3By3.crossProductEquivalentMatrix(Cartesian vector)
Forms a
Matrix3By3 from the input vector such that the result of the cross product of the input vector
with another vector is equivalent to premultiplying the other vector by the returned matrix. |
static Matrix3By3Symmetric |
Matrix3By3Symmetric.diagonalMatrix(Cartesian vector)
Forms a diagonal matrix from the input vector.
|
static Matrix3By3 |
Matrix3By3.diagonalMatrix(Cartesian vector)
Forms a diagonal matrix from the input vector.
|
static Cartesian |
Cartesian.divide(Cartesian left,
double right)
Divides a specified set of
Cartesian coordinates by a scalar. |
double |
UnitCartesian.dot(Cartesian other)
Forms the dot product of the specified set of
Cartesian coordinates with this instance. |
double |
Cartesian.dot(Cartesian other)
Forms the dot product of the specified set of
Cartesian coordinates with this instance. |
static boolean |
Cartesian.equals(Cartesian left,
Cartesian right)
Returns
true if the two instances are exactly equal. |
boolean |
Cartesian.equalsEpsilon(Cartesian other,
double epsilon)
Indicates whether each coordinate value of another instance of this type
is within the required tolerance of the corresponding coordinate value of this instance.
|
boolean |
Cartesian.equalsType(Cartesian other)
Indicates whether another instance of this type is exactly equal to this instance.
|
static AzimuthElevationRange |
AzimuthElevationRange.fromCartesian(Cartesian coordinates)
Initializes a set of
AzimuthElevationRange coordinates from the provided set of
Cartesian coordinates represented in the North-East-Down orientation with
X pointing north, Y pointing east, and Z pointing down. |
Cartesian |
Matrix3By3Symmetric.multiply(Cartesian vector)
Forms a new Cartesian vector as the product of this 3-by-3 matrix and the provided Cartesian vector.
|
Cartesian |
Matrix3By3.multiply(Cartesian vector)
Forms a new Cartesian vector as the product of this 3-by-3 matrix and the provided Cartesian vector.
|
static Cartesian |
Cartesian.multiply(Cartesian left,
double right)
Multiplies a specified set of
Cartesian coordinates by a scalar. |
static Cartesian |
Cartesian.multiply(Cartesian left,
Matrix3By3 right)
Multiplies a specified set of
Cartesian coordinates by a Matrix3By3. |
static Cartesian |
Cartesian.multiply(double left,
Cartesian right)
Multiplies a scalar by a specified set of set of
Cartesian coordinates. |
static Cartesian |
Matrix3By3.multiply(Matrix3By3 matrix,
Cartesian vector)
Multiplies the 3-by-3 matrix by the Cartesian vector.
|
static Cartesian |
Matrix3By3Symmetric.multiply(Matrix3By3Symmetric matrix,
Cartesian vector)
Multiplies the 3-by-3 matrix by the Cartesian vector.
|
static Cartesian |
Cartesian.negate(Cartesian coordinates)
|
static boolean |
Cartesian.notEquals(Cartesian left,
Cartesian right)
Returns
true if the two instances are not exactly equal. |
static UnitQuaternion |
RotationVectorAngularVelocity.rotationVectorToUnitQuaternion(Cartesian rotationVector)
Converts a rotation vector to a unit quaternion.
|
Cartesian |
UnitCartesian.subtract(Cartesian other)
Subtracts the specified set of
Cartesian coordinates from this instance. |
Cartesian |
Cartesian.subtract(Cartesian other)
Subtracts the specified set of
Cartesian coordinates from this instance. |
static Cartesian |
Cartesian.subtract(Cartesian left,
Cartesian right)
|
static Cartesian |
UnitCartesian.subtract(Cartesian left,
UnitCartesian right)
Subtracts a specified set of
UnitCartesian coordinates from a specified set of Cartesian coordinates. |
static Cartesian |
UnitCartesian.subtract(UnitCartesian left,
Cartesian right)
Subtracts a specified set of
Cartesian coordinates from a specified set of UnitCartesian coordinates. |
Cartesian |
HelmertTransformation.transform(Cartesian position)
Transforms the position observed in the A frame to the B frame.
|
Cartesian |
KinematicTransformation.transform(Cartesian position)
Transforms the position observed in the A frame to the B frame.
|
| Modifier and Type | Method and Description |
|---|---|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(AngleAxisRotation first,
Motion2<UnitQuaternion,Cartesian> second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(ElementaryRotation first,
Motion2<UnitQuaternion,Cartesian> second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
AngleAxisRotation second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
ElementaryRotation second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
Motion2<UnitQuaternion,Cartesian> second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.compose(Motion2<UnitQuaternion,Cartesian> first,
Motion2<UnitQuaternion,Cartesian> second,
int order)
Forms a new rotational transformation as the composition of two transformations.
|
static Motion2<UnitCartesian,Cartesian> |
UnitCartesian.convertMotion(Motion1<Cartesian> motion,
int order)
Converts the motion given in terms of a set of
Cartesian coordinates to motion
of the corresponding set of UnitCartesian coordinates. |
static Motion1<LongitudeLatitudeRadius> |
LongitudeLatitudeRadius.convertMotion(Motion1<Cartesian> motion,
int order)
Converts the motion given in terms of a set of
Cartesian coordinates to motion
of the corresponding set of LongitudeLatitudeRadius coordinates. |
static Motion1<AzimuthElevationRange> |
AzimuthElevationRange.convertMotion(Motion1<Cartesian> topographic,
int order)
Construct a Motion<Cartesian> which represents the motion
expressed with
AzimuthElevationRange values and derivatives. |
static Motion1<Double> |
UnitCartesian.dihedralAngle(Motion2<UnitCartesian,Cartesian> motFrom,
Motion2<UnitCartesian,Cartesian> motTo,
Motion2<UnitCartesian,Cartesian> motAxis,
int order)
Calculates the scalar dihedral angle (and derivatives) of the three given values with
Cartesian derivative information.
|
static Motion1<Double> |
UnitCartesian.dihedralAngle(Motion2<UnitCartesian,Cartesian> motFrom,
Motion2<UnitCartesian,Cartesian> motTo,
Motion2<UnitCartesian,Cartesian> motAxis,
int order)
Calculates the scalar dihedral angle (and derivatives) of the three given values with
Cartesian derivative information.
|
static Motion1<Double> |
UnitCartesian.dihedralAngle(Motion2<UnitCartesian,Cartesian> motFrom,
Motion2<UnitCartesian,Cartesian> motTo,
Motion2<UnitCartesian,Cartesian> motAxis,
int order)
Calculates the scalar dihedral angle (and derivatives) of the three given values with
Cartesian derivative information.
|
static Motion2<UnitQuaternion,Cartesian> |
AlignedConstrained.getMotion(Motion1<Cartesian> principal,
Motion1<Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AlignedConstrained.getMotion(Motion1<Cartesian> principal,
Motion1<Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AlignedConstrained.getMotion(Motion2<UnitCartesian,Cartesian> principal,
Motion2<UnitCartesian,Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AlignedConstrained.getMotion(Motion2<UnitCartesian,Cartesian> principal,
Motion2<UnitCartesian,Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
RotationalTransformation.invert(Motion2<UnitQuaternion,Cartesian> motion,
int order)
Forms the inverse rotational transformation.
|
static DateMotionCollection1<RotationVectorAngularVelocity> |
RotationVectorAngularVelocity.toDateMotionCollectionRotationVectorAngularVelocity(DateMotionCollection2<UnitQuaternion,Cartesian> inputCollection,
int order)
Converts a
DateMotionCollection<UnitQuaternion, Cartesian> to a DateMotionCollection<RotationVectorAngularVelocity>. |
static Motion1<RotationVectorAngularVelocity> |
RotationVectorAngularVelocity.toMotionRotationVectorAngularVelocity(Motion2<UnitQuaternion,Cartesian> motionUnitQuaternionCartesian,
int order)
|
static RotationVectorAngularVelocity |
RotationVectorAngularVelocity.toRotationVectorAngularVelocity(Motion2<UnitQuaternion,Cartesian> motionUnitQuaternionCartesian)
|
Motion1<Cartesian> |
HelmertTransformation.transform(Motion1<Cartesian> motion)
Transforms the motion observed in the A frame to the B frame.
|
Motion1<Cartesian> |
KinematicTransformation.transform(Motion1<Cartesian> motion)
Transforms the motion observed in the A frame to the B frame.
|
Motion1<Cartesian> |
HelmertTransformation.transform(Motion1<Cartesian> motion,
int order)
Transforms the motion observed in the A frame to the B frame.
|
Motion1<Cartesian> |
KinematicTransformation.transform(Motion1<Cartesian> motion,
int order)
Transforms the motion observed in the A frame to the B frame.
|
static Motion1<Cartesian> |
RotationalTransformation.transform(Motion2<UnitQuaternion,Cartesian> rotationalTransformation,
Motion1<Cartesian> motion,
int order)
Transforms the vector observed in the A axes to the B axes.
|
static Motion1<Cartesian> |
RotationalTransformation.transform(Motion2<UnitQuaternion,Cartesian> rotationalTransformation,
Motion1<Cartesian> motion,
int order)
Transforms the vector observed in the A axes to the B axes.
|
| Constructor and Description |
|---|
AzimuthElevationRange(Cartesian coordinates)
Initializes a set of
AzimuthElevationRange coordinates from the provided set of
Cartesian coordinates represented in the North-East-Down orientation with
X pointing north, Y pointing east, and Z pointing down. |
CartesianBounds(Cartesian lowerBound,
Cartesian upperBound)
Holds two
Cartesian values which form the bounds of a range of cartesian coordinates. |
Covariance3By3Derivative(Cartesian sigmaDerivatives,
Cartesian rotationDerivative,
int order)
Initializes a new
Covariance3By3SizeAndOrientation object from the sigmas and a rotation. |
Covariance3By3SizeAndOrientation(Cartesian sigmas,
UnitQuaternion rotation)
Initializes a new
Covariance3By3SizeAndOrientation object from the sigmas and a rotation. |
Cylindrical(Cartesian coordinates)
Initializes a set of
Cylindrical coordinates from the provided set of Cartesian coordinates. |
DelaunayElements(Cartesian position,
Cartesian velocity,
double gravitationalParameter)
Initialize a set of Delaunay elements based upon a cartesian position and velocity.
|
DelaunayElements(Cartesian position,
Cartesian velocity,
double gravitationalParameter,
double eccentricityTolerance,
double inclinationTolerance)
Initialize a set of Delaunay elements based upon a cartesian position and velocity.
|
EquinoctialElements(Cartesian position,
Cartesian velocity,
double gravitationalParameter)
Initialize a set of equinoctial elements from cartesian position and velocity.
|
HelmertTransformation(Cartesian translation,
Cartesian translationalVelocity,
double scaling,
double scalingRate,
Cartesian rotation,
Cartesian rotationalVelocity)
Initializes a new instance with the specified translational, scaling, and rotational parameters.
|
KeplerianElements(Cartesian position,
Cartesian velocity,
double gravitationalParameter)
Initialize a set of classical Keplerian elements from a
Cartesian position and velocity. |
KeplerianElements(Cartesian position,
Cartesian velocity,
double gravitationalParameter,
double eccentricityTolerance,
double inclinationTolerance)
Initialize a set of classical Keplerian elements from a cartesian position and velocity.
|
KinematicTransformation(Cartesian translation,
Cartesian translationalVelocity,
Cartesian translationalAcceleration,
Motion2<UnitQuaternion,Cartesian> rotationalTransformation)
Initializes a new instance with the specified translational parameters and
RotationalMotion (get). |
KinematicTransformation(Cartesian translation,
Cartesian translationalVelocity,
Cartesian translationalAcceleration,
UnitQuaternion rotation,
Cartesian rotationalVelocity,
Cartesian rotationalAcceleration)
Initializes a new instance with the specified translational and rotational parameters.
|
KozaiIzsakMeanElements(Cartesian position,
Cartesian velocity,
double gravitationalParameter,
double j2UnnormalizedValue,
double referenceDistance)
Initialize a set of Kozai-Izsak mean elements from a
Cartesian position and velocity. |
LongitudeLatitudeRadius(Cartesian coordinates)
Initializes a set of
LongitudeLatitudeRadius coordinates from the provided set of Cartesian coordinates. |
ModifiedKeplerianElements(Cartesian position,
Cartesian velocity,
double gravitationalParameter)
|
ModifiedKeplerianElements(Cartesian position,
Cartesian velocity,
double gravitationalParameter,
double eccentricityTolerance,
double inclinationTolerance)
Initializes a new instance from the specified
Cartesian motion and gravitational constant. |
Pyramidal(Cartesian coordinates)
|
RotationVectorAngularVelocity(Cartesian rotationVector,
Cartesian angularVelocity)
Initializes this type directly from a rotation vector and a body-fixed angular velocity.
|
Spherical(Cartesian coordinates)
|
UnitCartesian(Cartesian coordinates)
Initializes a set of
UnitCartesian coordinates from the provided set of Cartesian coordinates. |
UnitCartesian(Cartesian coordinates,
double[] magnitude)
Initializes a set of
UnitCartesian coordinates from the provided set of Cartesian coordinates. |
| Constructor and Description |
|---|
DelaunayElements(Motion1<Cartesian> motion,
double gravitationalParameter)
Initializes a new instance from the specified cartesian motion and gravitational constant.
|
DelaunayElements(Motion1<Cartesian> motion,
double gravitationalParameter,
double eccentricityTolerance,
double inclinationTolerance)
Initializes a new instance from the specified cartesian motion and gravitational constant.
|
EquinoctialElements(Motion1<Cartesian> motion,
double gravitationalParameter)
Initializes a new instance from the specified cartesian motion and gravitational constant.
|
KeplerianElements(Motion1<Cartesian> motion,
double gravitationalParameter)
Initializes a new instance from the specified
Cartesian motion and gravitational parameter. |
KeplerianElements(Motion1<Cartesian> motion,
double gravitationalParameter,
double eccentricityTolerance,
double inclinationTolerance)
Initializes a new instance from the specified cartesian motion and gravitational constant.
|
KinematicTransformation(Cartesian translation,
Cartesian translationalVelocity,
Cartesian translationalAcceleration,
Motion2<UnitQuaternion,Cartesian> rotationalTransformation)
Initializes a new instance with the specified translational parameters and
RotationalMotion (get). |
KinematicTransformation(Motion1<Cartesian> translationalMotion,
Motion2<UnitQuaternion,Cartesian> rotationalMotion)
Initializes a new instance from the specified translational and rotational motion.
|
KinematicTransformation(Motion1<Cartesian> translationalMotion,
Motion2<UnitQuaternion,Cartesian> rotationalMotion)
Initializes a new instance from the specified translational and rotational motion.
|
KozaiIzsakMeanElements(Motion1<Cartesian> motion,
double gravitationalParameter,
double j2UnnormalizedValue,
double referenceDistance)
Initializes a set of Kozai-Izsak mean elements from the specified
Cartesian motion. |
ModifiedKeplerianElements(Motion1<Cartesian> motion,
double gravitationalParameter)
Initializes a new instance from the specified
Cartesian motion and gravitational constant. |
ModifiedKeplerianElements(Motion1<Cartesian> motion,
double gravitationalParameter,
double eccentricityTolerance,
double inclinationTolerance)
Initializes a new instance from the specified
Cartesian motion and gravitational parameter. |
| Modifier and Type | Method and Description |
|---|---|
CoverageGridPointWithResults |
CoverageResults.findNearestGridPoint(Cartesian cartesianLocation)
Given a cartesian location find the nearest grid point according to physical distance.
|
CoverageGridPointWithResults |
CoverageResults.findNearestGridPointAtTime(Cartesian cartesianLocation,
JulianDate date)
Given a cartesian location and date, find the nearest grid point according to physical distance.
|
| Modifier and Type | Method and Description |
|---|---|
protected Cartesian |
EllipsoidSurfaceRegionBuilder.getCentroid(ArrayList<Cartographic> nodes)
Computes the centroid of the input points.
|
Cartesian |
VectorFixed.getComponents()
Gets the components of this Vector resolved in the defining reference axes.
|
Cartesian |
PointFixedOffset.getOffset()
Gets the displacement of this point from the origin of the defining reference frame.
|
Cartesian |
ConstantCovariance3By3.getSigmas()
Gets the Cartesian representing the constant
Sigmas (get) for the location point
uncertainty described by this instance. |
| Modifier and Type | Method and Description |
|---|---|
static Motion2<UnitQuaternion,Cartesian> |
AxesEastNorthUp.computeFixedToEastNorthUpRotation(Ellipsoid shape,
Motion1<Cartesian> fixedReferencePoint,
int order)
Computes the rotation from the central body's fixed axes to a set of east-north-up axes based on
a specified reference point.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesNorthEastDown.computeFixedToNorthEastDownRotation(Ellipsoid shape,
Motion1<Cartesian> fixedReferencePoint,
int order)
Computes the rotation from the central body's fixed axes to a set of north-east-down axes based on
a specified reference point.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion1<Cartesian> principal,
AxisIndicator principalAxis,
Motion1<Cartesian> reference,
AxisIndicator referenceAxis,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion1<Cartesian> principal,
Motion1<Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
AxisIndicator principalAxis,
Motion2<UnitCartesian,Cartesian> reference,
AxisIndicator referenceAxis,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
Motion2<UnitCartesian,Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
Motion2<UnitCartesian,Cartesian> |
NormalizedVectorEvaluator.evaluate(JulianDate date,
int order)
Evaluates the function.
|
MotionEvaluator1<Cartesian> |
DynamicCovariance3By3.getEllipsoidSizeEvaluator(Scalar sigmaFactor)
Constructs an evaluator that calculates dimensions of the ellipsoid containing the uncertainty of a position
over time.
|
MotionEvaluator1<Cartesian> |
DynamicCovariance3By3.getEllipsoidSizeEvaluator(Scalar sigmaFactor,
EvaluatorGroup group)
Constructs an evaluator that calculates dimensions of the ellipsoid containing the uncertainty of a position
over time.
|
ParameterEvaluator<Motion1<Cartesian>> |
CartesianParameter.getEvaluator(EvaluatorGroup group)
Gets the placeholder evaluator associated with this parameter.
|
Motion1<Cartesian> |
InternationalTerrestrialReferenceFrameTransformer.getRotation()
|
MotionEvaluator1<Cartesian> |
DynamicCovariance3By3.getStandardDeviationEvaluator()
Constructs an evaluator that calculates the standard deviation (or sigma) of the position variance over time.
|
MotionEvaluator1<Cartesian> |
DynamicCovariance3By3.getStandardDeviationEvaluator(EvaluatorGroup group)
Constructs an evaluator that calculates the standard deviation (or sigma) of the position variance over time.
|
Motion1<Cartesian> |
InternationalTerrestrialReferenceFrameTransformer.getTranslation()
|
DateMotionCollection1<Cartesian> |
InternationalTerrestrialReferenceFrameTransformer.transformCollection(DateMotionCollection1<Cartesian> collection)
|
| Modifier and Type | Method and Description |
|---|---|
static UnitQuaternion |
AxesEastNorthUp.computeFixedToEastNorthUpRotation(Ellipsoid shape,
Cartesian fixedReferencePoint)
Computes the rotation from the central body's fixed axes to a set of east-north-up axes based on
a specified reference point.
|
static UnitQuaternion |
AxesNorthEastDown.computeFixedToNorthEastDownRotation(Ellipsoid shape,
Cartesian fixedReferencePoint)
Computes the rotation from the central body's fixed axes to a set of north-east-down axes based on
a specified reference point.
|
static UnitQuaternion |
AxesAlignedConstrained.computeTransformation(Cartesian principal,
AxisIndicator principalAxis,
Cartesian reference,
AxisIndicator referenceAxis)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static UnitQuaternion |
AxesAlignedConstrained.computeTransformation(Cartesian principal,
Cartesian reference)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
void |
VectorFixed.setComponents(Cartesian value)
Sets the components of this Vector resolved in the defining reference axes.
|
void |
PointFixedOffset.setOffset(Cartesian value)
Sets the displacement of this point from the origin of the defining reference frame.
|
void |
ConstantCovariance3By3.setSigmas(Cartesian value)
Sets the Cartesian representing the constant
Sigmas (get) for the location point
uncertainty described by this instance. |
| Modifier and Type | Method and Description |
|---|---|
static Motion2<UnitQuaternion,Cartesian> |
AxesEastNorthUp.computeFixedToEastNorthUpRotation(Ellipsoid shape,
Motion1<Cartesian> fixedReferencePoint,
int order)
Computes the rotation from the central body's fixed axes to a set of east-north-up axes based on
a specified reference point.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesNorthEastDown.computeFixedToNorthEastDownRotation(Ellipsoid shape,
Motion1<Cartesian> fixedReferencePoint,
int order)
Computes the rotation from the central body's fixed axes to a set of north-east-down axes based on
a specified reference point.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion1<Cartesian> principal,
AxisIndicator principalAxis,
Motion1<Cartesian> reference,
AxisIndicator referenceAxis,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion1<Cartesian> principal,
AxisIndicator principalAxis,
Motion1<Cartesian> reference,
AxisIndicator referenceAxis,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion1<Cartesian> principal,
Motion1<Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion1<Cartesian> principal,
Motion1<Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
AxisIndicator principalAxis,
Motion2<UnitCartesian,Cartesian> reference,
AxisIndicator referenceAxis,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
AxisIndicator principalAxis,
Motion2<UnitCartesian,Cartesian> reference,
AxisIndicator referenceAxis,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
Motion2<UnitCartesian,Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static Motion2<UnitQuaternion,Cartesian> |
AxesAlignedConstrained.computeTransformation(Motion2<UnitCartesian,Cartesian> principal,
Motion2<UnitCartesian,Cartesian> reference,
int order)
Given a principal and reference vector expressed in the same set of axes, computes a transformation that
will take a vector expressed in that set of axes and expresses it in the aligned-constrained axes.
|
static PointInterpolator |
InternationalTerrestrialReferenceFrameTransformer.createPointInterpolatorInFixedFrame(EarthCentralBody earth,
InternationalTerrestrialReferenceFrameTransformer itrf,
String itrfFrameOfData,
InterpolationAlgorithm algorithm,
int interpolationDegree,
DateMotionCollection1<Cartesian> data)
|
static PointInterpolator |
InternationalTerrestrialReferenceFrameTransformer.createPointInterpolatorInFixedFrame(EarthCentralBody earth,
Iterable<InternationalTerrestrialReferenceFrameTransformer> itrfList,
String itrfFrameOfData,
InterpolationAlgorithm algorithm,
int interpolationDegree,
DateMotionCollection1<Cartesian> data)
|
void |
InternationalTerrestrialReferenceFrameTransformer.setRotation(Motion1<Cartesian> value)
|
void |
InternationalTerrestrialReferenceFrameTransformer.setTranslation(Motion1<Cartesian> value)
|
DateMotionCollection1<Cartesian> |
InternationalTerrestrialReferenceFrameTransformer.transformCollection(DateMotionCollection1<Cartesian> collection)
|
| Constructor and Description |
|---|
ConstantCovariance3By3(Cartesian standardDeviations,
Axes orientationAxes)
Creates a new instance from the specified constant size and the orientation axes.
|
PointFixedOffset(ReferenceFrame frame,
Cartesian offset)
Initializes a new instance of the
PointFixedOffset class using the
provided offset with respect to the provided frame. |
VectorFixed(Axes definedInAxes,
Cartesian components)
Initializes a new instance of the
VectorFixed class using the
provided vector components with respect to the provided Axes. |
VectorNormalized(Axes axes,
Cartesian direction)
Construct a new unit vector based on a direction and an axes.
|
| Constructor and Description |
|---|
AxesInterpolator(Axes referenceAxes,
InterpolationAlgorithm interpolationAlgorithm,
int degree,
DateMotionCollection2<UnitQuaternion,Cartesian> data)
Initializes a new instance of the
AxesInterpolator class from the provided parameters. |
AxesInterpolator(Axes referenceAxes,
InterpolationAlgorithm interpolationAlgorithm,
int degree,
DateMotionCollection2<UnitQuaternion,Cartesian> data,
List<JulianDate> segmentBoundaryTimes)
Initializes a new instance of the
AxesInterpolator class from the provided parameters. |
AxesInterpolator(Axes referenceAxes,
InterpolationAlgorithmType algorithmType,
int degree,
DateMotionCollection2<UnitQuaternion,Cartesian> data)
Initializes a new instance of the
AxesInterpolator class from the provided parameters. |
AxesInterpolator(Axes referenceAxes,
InterpolationAlgorithmType algorithmType,
int degree,
DateMotionCollection2<UnitQuaternion,Cartesian> data,
List<JulianDate> segmentBoundaryTimes)
Initializes a new instance of the
AxesInterpolator class from the provided parameters. |
InternationalTerrestrialReferenceFrameTransformer(String from,
String to,
JulianDate epoch,
Motion1<Cartesian> translation,
Motion1<Double> scaling,
Motion1<Cartesian> rotation)
Initializes a new instance.
|
InternationalTerrestrialReferenceFrameTransformer(String from,
String to,
JulianDate epoch,
Motion1<Cartesian> translation,
Motion1<Double> scaling,
Motion1<Cartesian> rotation)
Initializes a new instance.
|
PointInterpolator(ReferenceFrame referenceFrame,
InterpolationAlgorithm interpolationAlgorithm,
int degree,
DateMotionCollection1<Cartesian> data)
Initializes a new instance of the
PointInterpolator class from the provided parameters. |
PointInterpolator(ReferenceFrame referenceFrame,
InterpolationAlgorithm interpolationAlgorithm,
int degree,
DateMotionCollection1<Cartesian> data,
List<JulianDate> segmentBoundaryTimes)
Initializes a new instance of the
PointInterpolator class from the provided parameters. |
PointInterpolator(ReferenceFrame referenceFrame,
InterpolationAlgorithmType algorithmType,
int degree,
DateMotionCollection1<Cartesian> data)
Initializes a new instance of the
PointInterpolator class from the provided parameters. |
PointInterpolator(ReferenceFrame referenceFrame,
InterpolationAlgorithmType algorithmType,
int degree,
DateMotionCollection1<Cartesian> data,
List<JulianDate> segmentBoundaryTimes)
Initializes a new instance of the
PointInterpolator class from the provided parameters. |
VectorInterpolator(Axes definedInAxes,
InterpolationAlgorithm interpolationAlgorithm,
int degree,
DateMotionCollection1<Cartesian> data)
Initializes a new instance of the
VectorInterpolator class from the provided parameters. |
VectorInterpolator(Axes definedInAxes,
InterpolationAlgorithm interpolationAlgorithm,
int degree,
DateMotionCollection1<Cartesian> data,
List<JulianDate> segmentBoundaryTimes)
Initializes a new instance of the
VectorInterpolator class from the provided parameters. |
VectorInterpolator(Axes definedInAxes,
InterpolationAlgorithmType algorithmType,
int degree,
DateMotionCollection1<Cartesian> data)
Initializes a new instance of the
VectorInterpolator class from the provided parameters. |
VectorInterpolator(Axes definedInAxes,
InterpolationAlgorithmType algorithmType,
int degree,
DateMotionCollection1<Cartesian> data,
List<JulianDate> segmentBoundaryTimes)
Initializes a new instance of the
VectorInterpolator class from the provided parameters. |
| Modifier and Type | Method and Description |
|---|---|
BaseCollection<Cartesian> |
ExtrudedPolylineTriangulatorResult.getBottomBoundaryPositions()
Gets the boundary positions along the bottom of the extrusion.
|
BaseCollection<Cartesian> |
SurfaceTriangulatorResult.getBoundaryPositions()
Gets the boundary positions that surround the mesh.
|
BaseCollection<Cartesian> |
TriangulatorResult.getNormals()
Gets the normals of the mesh.
|
BaseCollection<Cartesian> |
SurfaceTriangulatorResult.getNormals() |
BaseCollection<Cartesian> |
SolidTriangulatorResult.getNormals() |
BaseCollection<Cartesian> |
ExtrudedPolylineTriangulatorResult.getNormals() |
BaseCollection<Cartesian> |
SolidTriangulatorResult.getOutlinePositions()
Gets the positions outlining the solid.
|
BaseCollection<Cartesian> |
TriangulatorResult.getPositions()
Gets the positions of the mesh.
|
BaseCollection<Cartesian> |
SurfaceTriangulatorResult.getPositions() |
BaseCollection<Cartesian> |
SurfaceShapesResult.getPositions()
Gets the positions of the computed shape.
|
BaseCollection<Cartesian> |
SolidTriangulatorResult.getPositions() |
BaseCollection<Cartesian> |
ExtrudedPolylineTriangulatorResult.getPositions() |
BaseCollection<Cartesian> |
ExtrudedPolylineTriangulatorResult.getTopBoundaryPositions()
Gets the boundary positions along the top of the extrusion.
|
| Modifier and Type | Method and Description |
|---|---|
static SolidTriangulatorResult |
EllipsoidTriangulator.compute(Cartesian radii)
Computes the triangulation for an ellipsoid with the specified
radii,
centered at the origin, using 32 slices and 16 stacks. |
static SolidTriangulatorResult |
BoxTriangulator.compute(Cartesian size)
Computes the triangulation for a box of the specified
size, centered at the origin. |
static SolidTriangulatorResult |
EllipsoidTriangulator.compute(Cartesian radii,
int slices,
int stacks)
Computes the triangulation for an ellipsoid with the specified
radii,
centered at the origin. |
static SurfaceShapesResult |
SurfaceShapes.computeCircle(CentralBody centralBody,
Cartesian center,
double radius)
Computes boundary positions for a circle on the specified
centralBody
with the specified center and radius. |
static SurfaceShapesResult |
SurfaceShapes.computeCircle(CentralBody centralBody,
Cartesian center,
double radius,
double granularity)
Computes boundary positions for a circle on the specified
centralBody
with the specified center, radius and
granularity. |
static SurfaceShapesResult |
SurfaceShapes.computeEllipse(CentralBody centralBody,
Cartesian center,
double majorAxisRadius,
double minorAxisRadius,
double bearing)
Computes boundary positions for an ellipse on the specified
centralBody
This is equivalent to calling
SurfaceShapes.computeEllipse(agi.foundation.celestial.CentralBody,agi.foundation.coordinates.Cartesian,double,double,double)
with a granularity of 1 degree. |
static SurfaceShapesResult |
SurfaceShapes.computeEllipse(CentralBody centralBody,
Cartesian center,
double majorAxisRadius,
double minorAxisRadius,
double bearing,
double granularity)
Computes boundary positions for an ellipse on the specified
centralBody. |
static SurfaceShapesResult |
SurfaceShapes.computeSector(CentralBody centralBody,
Cartesian center,
double innerRadius,
double outerRadius,
double startBearing,
double endBearing)
Computes boundary positions for a sector on the specified
centralBody
This is equivalent to calling
SurfaceShapes.computeSector(agi.foundation.celestial.CentralBody,agi.foundation.coordinates.Cartesian,double,double,double,double)
with a granularity of 1 degree. |
static SurfaceShapesResult |
SurfaceShapes.computeSector(CentralBody centralBody,
Cartesian center,
double innerRadius,
double outerRadius,
double startBearing,
double endBearing,
double granularity)
Computes boundary positions for a sector on the specified
centralBody. |
| Modifier and Type | Method and Description |
|---|---|
static SurfaceTriangulatorResult |
SurfacePolygonTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> positions)
Computes the triangulation on the specified
centralBody
for a polygon whose boundary is defined by the specified positions. |
static ExtrudedPolylineTriangulatorResult |
ExtrudedPolylineTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> positions,
double bottomAltitude,
double topAltitude)
Computes an extrusion of
positions on the specified
centralBody with a constant bottomAltitude
and topAltitude. |
static SurfaceTriangulatorResult |
SurfacePolygonTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> positions,
double altitude,
double granularity,
WindingOrder positionsWindingOrder)
Computes the triangulation on the specified
centralBody
for a polygon whose boundary is defined by the specified positions. |
static ExtrudedPolylineTriangulatorResult |
ExtrudedPolylineTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> positions,
double bottomAltitude,
double topAltitude,
WindingOrder positionsWindingOrder)
Computes an extrusion of
positions on the specified
centralBody with a constant bottomAltitude
and topAltitude. |
static SurfaceTriangulatorResult |
SurfacePolygonTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> positions,
Iterable<Cartesian> holePositions)
Computes the triangulation on the specified
centralBody
for a polygon whose boundary is defined by the specified positions
with a hole specified by holePositions. |
static SurfaceTriangulatorResult |
SurfacePolygonTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> positions,
Iterable<Cartesian> holePositions)
Computes the triangulation on the specified
centralBody
for a polygon whose boundary is defined by the specified positions
with a hole specified by holePositions. |
static ExtrudedPolylineTriangulatorResult |
ExtrudedPolylineTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> bottomPositions,
Iterable<Cartesian> topPositions)
Computes an extrusion between
bottomPositions and topPositions
on the specified centralBody. |
static ExtrudedPolylineTriangulatorResult |
ExtrudedPolylineTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> bottomPositions,
Iterable<Cartesian> topPositions)
Computes an extrusion between
bottomPositions and topPositions
on the specified centralBody. |
static SurfaceTriangulatorResult |
SurfacePolygonTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> positions,
Iterable<Cartesian> holePositions,
double altitude,
double granularity)
Computes the triangulation on the specified
centralBody
for a polygon whose boundary is defined by the specified positions
with a hole specified by holePositions. |
static SurfaceTriangulatorResult |
SurfacePolygonTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> positions,
Iterable<Cartesian> holePositions,
double altitude,
double granularity)
Computes the triangulation on the specified
centralBody
for a polygon whose boundary is defined by the specified positions
with a hole specified by holePositions. |
static ExtrudedPolylineTriangulatorResult |
ExtrudedPolylineTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> bottomPositions,
Iterable<Cartesian> topPositions,
WindingOrder positionsWindingOrder)
Computes an extrusion between
bottomPositions and topPositions
on the specified centralBody. |
static ExtrudedPolylineTriangulatorResult |
ExtrudedPolylineTriangulator.compute(CentralBody centralBody,
Iterable<Cartesian> bottomPositions,
Iterable<Cartesian> topPositions,
WindingOrder positionsWindingOrder)
Computes an extrusion between
bottomPositions and topPositions
on the specified centralBody. |
static ExtrudedPolylineTriangulatorResult |
ExtrudedPolylineTriangulator.computeSingleConstantAltitude(CentralBody centralBody,
Iterable<Cartesian> positions,
double altitude)
Computes an extrusion of
positions on the specified
centralBody. |
static ExtrudedPolylineTriangulatorResult |
ExtrudedPolylineTriangulator.computeSingleConstantAltitude(CentralBody centralBody,
Iterable<Cartesian> positions,
double altitude,
WindingOrder positionsWindingOrder)
Computes an extrusion of
positions on the specified
centralBody. |
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
Ellipsoid.cartographicToCartesian(Cartographic position)
Converts the motion given in terms of planetodetic cartographic coordinates to motion in cartesian coordinates.
|
Cartesian |
Ellipsoid.cartographicToCartesian(double longitude,
double latitude)
Converts the specified planetodetic surface location into a cartesian vector in the fixed frame of the ellipsoid.
|
abstract Cartesian |
Curve.getFinalPoint()
Gets the final point of the curve.
|
abstract Cartesian |
Curve.getInitialPoint()
Gets the initial point of the curve.
|
Cartesian |
PointOnCurve.getPoint()
Gets the coordinates of the point on the curve.
|
Cartesian |
Ellipsoid.getSemiaxisLengths()
Gets the semiaxis lengths.
|
Cartesian |
Ellipsoid.gradient(Cartesian position)
The gradient of the ellipsoid evaluated at the provided position.
|
Cartesian[] |
Ellipsoid.grazingAngleLocations(Cartesian point,
UnitCartesian direction)
Provides the two points on the limb of the ellipsoid with the smallest and largest apparent
angular separation with respect to the indicated direction, as viewed from the provided
point.
|
abstract Cartesian |
Curve.interpolateUsingAngleSubtended(double angle)
|
abstract Cartesian |
Curve.interpolateUsingFraction(double fraction)
|
Cartesian |
Ellipsoid.radialProjection(Cartesian position)
Computes the radial projection of the position vector onto the surface of the ellipsoid.
|
Cartesian |
EllipsoidGeodesic.surfaceMotion(double distance)
Converts the motion given in terms of motion on the geodesic curve to motion of the surface point.
|
Cartesian |
Ellipsoid.surfaceProjection(Cartesian position)
Computes the projection of the cartesian position onto the ellipsoid surface.
|
Cartesian |
Ellipsoid.surfaceProjection(Cartographic position)
Computes the projection of the cartographic position onto the ellipsoid surface.
|
Cartesian[] |
Ellipsoid.tangents(Cartesian position,
UnitCartesian normal)
From the indicated position, provides the points of tangency on an ellipsoid which also lie in
the plane defined by the indicated normal.
|
Cartesian[] |
Ellipsoid.tangents(Cartesian position,
UnitCartesian axis,
double halfAngle)
From the indicated position, provides the points of tangency on an ellipsoid which also lie on an
axisymmetric cone defined by the indicated axis and half angle.
|
| Modifier and Type | Method and Description |
|---|---|
Motion1<Cartesian> |
Ellipsoid.cartographicToCartesian(Motion1<Cartographic> cartographicMotion,
int order)
Converts the motion given in terms of planetodetic cartographic coordinates to motion in cartesian coordinates.
|
RealValuedScalarFunction1<Cartesian> |
EnclosureDescription.getFunction()
Gets the enclosure function.
|
Motion1<Cartesian> |
EllipsoidRhumbLine.surfaceMotion(double distance,
double groundSpeed,
double groundAcceleration)
Converts the motion given in terms of motion on the rhumb line curve to motion of the surface point.
|
Motion1<Cartesian> |
EllipsoidGeodesic.surfaceMotion(double distance,
double groundSpeed,
double groundAcceleration)
Converts the motion given in terms of motion on the geodesic curve to motion of the surface point.
|
Motion2<UnitCartesian,Cartesian> |
Ellipsoid.surfaceNormalMotion(Motion1<Cartesian> surfaceMotion,
int order)
Converts the motion given in terms of a surface point to motion of the surface normal vector.
|
Motion1<Cartesian> |
Ellipsoid.surfaceProjection(Motion1<Cartesian> motion,
int order)
Computes the projection of the cartesian motion onto the ellipsoid surface.
|
Motion1<Cartesian> |
Ellipsoid.surfaceProjectionCartographic(Motion1<Cartographic> cartographicMotion,
int order)
Computes the projection of the cartographic motion onto the ellipsoid surface.
|
| Modifier and Type | Method and Description |
|---|---|
double[] |
Ellipsoid.apparentAngularSize(Cartesian point)
Provides the minimum and maximum apparent angular size of the ellipsoid, as
viewed from the provided point.
|
Cartographic |
Ellipsoid.cartesianToCartographic(Cartesian position)
Converts the motion given in terms of cartesian coordinates to motion in cartographic coordinates.
|
double |
Ellipsoid.computeApproximateHeight(Cartesian position)
Compute an approximate value of the height above the surface.
|
UnitQuaternion |
Ellipsoid.eastNorthUpTransformation(Cartesian surfacePosition)
Returns the quaternion transformation between the x-y-z axes of the ellipsoid to the axes oriented to the cartographic
east-north-up axes at the given position on the surface.
|
double |
Ellipsoid.ellipsoidSeparationDistance(Ellipsoid other,
Cartesian centerPointsDisplacement,
Matrix3By3 thisToOtherRotation)
If the given
Ellipsoid does not intersect with this ellipsoid this method returns the minimum separation
between the surfaces of the two ellipsoids. |
double |
Ellipsoid.ellipsoidSeparationDistance(Ellipsoid other,
Cartesian centerPointsDisplacement,
Matrix3By3 thisToOtherRotation,
Cartesian[] pointOnThisSurface,
Cartesian[] pointOnOtherSurface)
If the given
Ellipsoid does not intersect with this ellipsoid this method returns the minimum separation
between the surfaces of the two ellipsoids. |
double |
Ellipsoid.ellipsoidSeparationDistance(Ellipsoid other,
Cartesian centerPointsDisplacement,
Matrix3By3 thisToOtherRotation,
Cartesian[] pointOnThisSurface,
Cartesian[] pointOnOtherSurface)
If the given
Ellipsoid does not intersect with this ellipsoid this method returns the minimum separation
between the surfaces of the two ellipsoids. |
double |
Ellipsoid.ellipsoidSeparationDistance(Ellipsoid other,
Cartesian centerPointsDisplacement,
Matrix3By3 thisToOtherRotation,
Cartesian[] pointOnThisSurface,
Cartesian[] pointOnOtherSurface)
If the given
Ellipsoid does not intersect with this ellipsoid this method returns the minimum separation
between the surfaces of the two ellipsoids. |
boolean |
SyntheticApertureRadarVolume.encloses(Cartesian point)
Indicates if the provided point is inside the volume.
|
abstract boolean |
Solid.encloses(Cartesian point)
Indicates if the provided point is inside the volume.
|
boolean |
RectangularPyramid.encloses(Cartesian point)
Indicates if the provided point is inside the volume.
|
boolean |
CustomSensorPattern.encloses(Cartesian point)
Indicates if the provided point is inside the volume.
|
boolean |
ComplexConic.encloses(Cartesian point)
Indicates if the provided point is inside the volume.
|
double |
Ellipsoid.getDegreeOfObstruction(Cartesian thisFixed,
Cartesian otherFixed)
Gets the obstruction value given two positions.
|
double |
Ellipsoid.getDegreeOfObstruction(Cartesian thisFixed,
Cartesian otherFixed,
double[] nearDistance)
Gets the obstruction value given two positions.
|
Cartesian |
Ellipsoid.gradient(Cartesian position)
The gradient of the ellipsoid evaluated at the provided position.
|
double |
Ellipsoid.grazingAltitude(Cartesian initial,
Cartesian _final)
Provides the nearest distance between the ellipsoid and the line segment
between the initial and final points.
|
double |
Ellipsoid.grazingAltitude(Cartesian position,
UnitCartesian direction)
Provides the nearest distance between the ellipsoid and the line segment
from the provided position and along the indicated direction.
|
Cartographic |
Ellipsoid.grazingAltitudeLocation(Cartesian initial,
Cartesian _final)
Provides the point on the line segment between the initial and final points
which is nearest to the ellipsoid.
|
Cartographic |
Ellipsoid.grazingAltitudeLocation(Cartesian position,
UnitCartesian direction)
Provides the point on the line segment from the provided position and along
the indicated direction which is nearest to the ellipsoid.
|
Cartesian[] |
Ellipsoid.grazingAngleLocations(Cartesian point,
UnitCartesian direction)
Provides the two points on the limb of the ellipsoid with the smallest and largest apparent
angular separation with respect to the indicated direction, as viewed from the provided
point.
|
double[] |
Ellipsoid.grazingAngles(Cartesian point,
UnitCartesian direction)
Provides the angles from the indicated direction to the two points on the limb
of the ellipsoid with the smallest and largest apparent angular separation, as
viewed from the provided point.
|
double[] |
Ellipsoid.intersections(Cartesian position,
UnitCartesian direction)
Computes the intersection of the line of sight vector emanating from a given external point with the ellipsoid.
|
boolean |
Ellipsoid.isAtCenter(Cartesian position)
Gets a value indicating if the provided position is within the
CenterTolerance (get) of the center of the ellipsoid. |
boolean |
Ellipsoid.isAtOrBeneathSurface(Cartesian position)
Gets a value indicating if the provided position is within the
SurfaceTolerance (get) of the surface of the ellipsoid,
or is beneath the surface of the ellipsoid. |
boolean |
Ellipsoid.isAtSurface(Cartesian position)
Gets a value indicating if the provided position is within the
SurfaceTolerance (get) of the surface of the ellipsoid. |
double |
Ellipsoid.norm(Cartesian position)
The ellipsoid norm evaluated at the provided position.
|
double |
Ellipsoid.normSquared(Cartesian position)
The square of the ellipsoid
Ellipsoid.norm(agi.foundation.coordinates.Cartesian) evaluated at the provided position. |
UnitQuaternion |
Ellipsoid.northEastDownTransformation(Cartesian surfacePosition)
Returns the quaternion transformation between the x-y-z axes of the ellipsoid to the axes oriented to the cartographic
north-east-down axes at the given position on the surface.
|
double |
Ellipsoid.pointSeparationDistance(Cartesian centerToPoint)
If the given
Cartesian does not lie within this ellipsoid this method returns the minimum separation
between the this ellipsoid on the given point. |
double |
Ellipsoid.pointSeparationDistance(Cartesian centerToPoint,
Cartesian[] pointOnSurface)
If the given
Cartesian does not lie within this ellipsoid this method returns the minimum separation
between the this ellipsoid on the given point. |
double |
Ellipsoid.pointSeparationDistance(Cartesian centerToPoint,
Cartesian[] pointOnSurface)
If the given
Cartesian does not lie within this ellipsoid this method returns the minimum separation
between the this ellipsoid on the given point. |
Cartesian |
Ellipsoid.radialProjection(Cartesian position)
Computes the radial projection of the position vector onto the surface of the ellipsoid.
|
UnitCartesian |
Ellipsoid.surfaceNormalMotion(Cartesian surfacePosition)
Converts the position given in terms of a surface point to the surface normal vector.
|
Cartesian |
Ellipsoid.surfaceProjection(Cartesian position)
Computes the projection of the cartesian position onto the ellipsoid surface.
|
Cartesian[] |
Ellipsoid.tangents(Cartesian position,
UnitCartesian normal)
From the indicated position, provides the points of tangency on an ellipsoid which also lie in
the plane defined by the indicated normal.
|
Cartesian[] |
Ellipsoid.tangents(Cartesian position,
UnitCartesian axis,
double halfAngle)
From the indicated position, provides the points of tangency on an ellipsoid which also lie on an
axisymmetric cone defined by the indicated axis and half angle.
|
boolean |
Ellipsoid.tangentTotal(Cartesian sensorPosition,
UnitCartesian sensorHeading,
double halfAngle)
Determines whether the cone emanating from sensor at the given position and with the given
heading and half angle lies completely tangent to the Ellipsoid.
|
UnitQuaternion |
Ellipsoid.upEastNorthTransformation(Cartesian surfacePosition)
Returns the quaternion transformation between the x-y-z axes of the ellipsoid to the axes oriented to the cartographic
up-east-north axes at the given position on the surface.
|
| Modifier and Type | Method and Description |
|---|---|
Motion1<Cartographic> |
Ellipsoid.cartesianToCartographic(Motion1<Cartesian> cartesianMotion,
int order)
Converts the motion given in terms of cartesian coordinates to motion in cartographic coordinates.
|
Motion2<UnitCartesian,Cartesian> |
Ellipsoid.surfaceNormalMotion(Motion1<Cartesian> surfaceMotion,
int order)
Converts the motion given in terms of a surface point to motion of the surface normal vector.
|
Motion1<Cartesian> |
Ellipsoid.surfaceProjection(Motion1<Cartesian> motion,
int order)
Computes the projection of the cartesian motion onto the ellipsoid surface.
|
| Constructor and Description |
|---|
Ellipsoid(Cartesian semiaxisLengths)
Initializes an ellipsoid as a scalene ellipsoid.
|
Ellipsoid(Cartesian semiaxisLengths,
double centerTolerance,
double surfaceTolerance)
Initializes an ellipsoid as a scalene ellipsoid.
|
PointOnCurve(double fraction,
double arcDistance,
Cartesian point)
Initializes a new instance.
|
| Constructor and Description |
|---|
EnclosureDescription(RealValuedScalarFunction1<Cartesian> function,
EnclosureFunctionType functionType)
Initializes a new instance.
|
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
TextBatchPrimitiveOptionalParameters.getEyeOffset()
Gets the per-batch eye offset, which is applied to each string in the text batch.
|
Cartesian |
MarkerBatchPrimitive.getEyeOffset()
Gets the per-batch eye offset, which is applied to each marker in the batch.
|
Cartesian |
PathPointBuilder.getPosition()
Gets the position associated with this point.
|
Cartesian |
PathPoint.getPosition()
Gets the position associated with this point.
|
Cartesian |
SolidPrimitive.getPosition()
Gets the solid's position.
|
Cartesian |
PickResult.getPosition()
Gets the position of the picked location in the central body's fixed reference frame.
|
Cartesian |
ModelPrimitive.getPosition()
Gets the position of the model.
|
Cartesian |
DistanceToPositionDisplayCondition.getPosition()
Gets the position used to compute the distance from the camera.
|
Cartesian |
Camera.getPosition()
Gets the position of the camera.
|
Cartesian |
Camera.getReferencePoint()
Gets the reference point of the camera.
|
Cartesian |
SolidPrimitive.getScale()
Gets a non-uniform scale that is applied to the solid to increase or
decrease its rendered size.
|
| Modifier and Type | Method and Description |
|---|---|
BaseCollection<Cartesian> |
RhumbLineInterpolator.interpolate(Iterable<Cartesian> positions)
Computes a rhumb line based on the input
positions. |
BaseCollection<Cartesian> |
PositionInterpolator.interpolate(Iterable<Cartesian> positions)
Computes interpolated positions based on the input
positions. |
BaseCollection<Cartesian> |
GreatArcInterpolator.interpolate(Iterable<Cartesian> positions)
Computes a great arc based on the input
positions. |
| Modifier and Type | Method and Description |
|---|---|
void |
MarkerBatchPrimitive.alignToAxis(CentralBody centralBody,
Cartesian axis)
Sets the up vector of the markers to point towards the
axis of
centralBody. |
static TriangleMeshPrimitive |
PrimitiveFactory.createCircle(CentralBody centralBody,
Cartesian center,
double radius)
Creates a circle triangle mesh.
|
static TriangleMeshPrimitive |
PrimitiveFactory.createCircle(CentralBody centralBody,
Cartesian center,
double radius,
double granularity)
Creates a circle triangle mesh with a specified granularity.
|
static PolylinePrimitive |
PrimitiveFactory.createCircleBoundary(CentralBody centralBody,
Cartesian center,
double radius)
Creates a circle shaped
PolylinePrimitive. |
static PolylinePrimitive |
PrimitiveFactory.createCircleBoundary(CentralBody centralBody,
Cartesian center,
double radius,
double granularity)
Creates a circle shaped
PolylinePrimitive with a specified granularity. |
static TriangleMeshPrimitive |
PrimitiveFactory.createEllipse(CentralBody centralBody,
Cartesian center,
double majorAxisRadius,
double minorAxisRadius,
double bearing)
Creates an ellipse triangle mesh.
|
static TriangleMeshPrimitive |
PrimitiveFactory.createEllipse(CentralBody centralBody,
Cartesian center,
double majorAxisRadius,
double minorAxisRadius,
double bearing,
double granularity)
Creates an ellipse triangle mesh with a specified granularity.
|
static PolylinePrimitive |
PrimitiveFactory.createEllipseBoundary(CentralBody centralBody,
Cartesian center,
double majorAxisRadius,
double minorAxisRadius,
double bearing)
Creates an ellipse shaped
PolylinePrimitive. |
static PolylinePrimitive |
PrimitiveFactory.createEllipseBoundary(CentralBody centralBody,
Cartesian center,
double majorAxisRadius,
double minorAxisRadius,
double bearing,
double granularity)
Creates an ellipse shaped
PolylinePrimitive with a specified granularity. |
static TriangleMeshPrimitive |
PrimitiveFactory.createSector(CentralBody centralBody,
Cartesian center,
double innerRadius,
double outerRadius,
double startBearing,
double endBearing)
Creates a sector triangle mesh.
|
static TriangleMeshPrimitive |
PrimitiveFactory.createSector(CentralBody centralBody,
Cartesian center,
double innerRadius,
double outerRadius,
double startBearing,
double endBearing,
double granularity)
Creates a sector triangle mesh with a specified granularity.
|
static PolylinePrimitive |
PrimitiveFactory.createSectorBoundary(CentralBody centralBody,
Cartesian center,
double innerRadius,
double outerRadius,
double startBearing,
double endBearing)
Creates a sector shaped
PolylinePrimitive. |
static PolylinePrimitive |
PrimitiveFactory.createSectorBoundary(CentralBody centralBody,
Cartesian center,
double innerRadius,
double outerRadius,
double startBearing,
double endBearing,
double granularity)
Creates a sector shaped
PolylinePrimitive with a specified granularity. |
void |
TextBatchPrimitiveOptionalParameters.setEyeOffset(Cartesian value)
Sets the per-batch eye offset, which is applied to each string in the text batch.
|
void |
MarkerBatchPrimitive.setEyeOffset(Cartesian value)
Sets the per-batch eye offset, which is applied to each marker in the batch.
|
void |
PathPointBuilder.setPosition(Cartesian value)
Sets the position associated with this point.
|
void |
SolidPrimitive.setPosition(Cartesian value)
Sets the solid's position.
|
void |
ModelPrimitive.setPosition(Cartesian position)
Sets the position of the model.
|
void |
DistanceToPositionDisplayCondition.setPosition(Cartesian value)
Sets the position used to compute the distance from the camera.
|
void |
Camera.setPosition(Cartesian value)
Sets the position of the camera.
|
void |
Camera.setReferencePoint(Cartesian value)
Sets the reference point of the camera.
|
void |
SolidPrimitive.setScale(Cartesian value)
Sets a non-uniform scale that is applied to the solid to increase or
decrease its rendered size.
|
void |
PolylinePrimitive.setSubset(Cartesian[] positions,
int index,
int count)
Defines the positions of a polyline using a subset of input positions.
|
void |
Camera.viewOffset(Axes axes,
Point referencePoint,
Cartesian offset)
Sets the camera's reference point - the point the camera is looking at.
|
void |
Camera.viewOffset(Axes axes,
Point referencePoint,
Cartesian offset,
UnitCartesian upAxis)
Sets the camera's reference point - the point the camera is looking at.
|
| Modifier and Type | Method and Description |
|---|---|
static TriangleMeshPrimitive |
PrimitiveFactory.createPolygon(CentralBody centralBody,
List<Cartesian> positions)
Creates a polygon triangle mesh.
|
static PolylinePrimitive |
PrimitiveFactory.createPolygonBoundary(List<Cartesian> positions)
Creates a bounded polygon from a list of positions.
|
BaseCollection<Cartesian> |
RhumbLineInterpolator.interpolate(Iterable<Cartesian> positions)
Computes a rhumb line based on the input
positions. |
BaseCollection<Cartesian> |
PositionInterpolator.interpolate(Iterable<Cartesian> positions)
Computes interpolated positions based on the input
positions. |
BaseCollection<Cartesian> |
GreatArcInterpolator.interpolate(Iterable<Cartesian> positions)
Computes a great arc based on the input
positions. |
void |
PolylinePrimitive.set(Iterable<Cartesian> positions)
Defines the positions for a polyline primitive.
|
void |
PointBatchPrimitive.set(Iterable<Cartesian> positions)
Defines the positions of points in a point batch.
|
void |
MarkerBatchPrimitive.set(Iterable<Cartesian> positions)
Defines the positions of markers in a marker batch.
|
void |
TriangleMeshPrimitive.set(Iterable<Cartesian> positions,
Iterable<Cartesian> normals,
Iterable<Integer> indices)
Defines the triangle mesh using an indexed triangle list specified by
positions, normals, and
indices. |
void |
TriangleMeshPrimitive.set(Iterable<Cartesian> positions,
Iterable<Cartesian> normals,
Iterable<Integer> indices)
Defines the triangle mesh using an indexed triangle list specified by
positions, normals, and
indices. |
void |
SolidPrimitive.set(Iterable<Cartesian> positions,
Iterable<Cartesian> normals,
Iterable<Integer> indices,
Iterable<Integer> outlineIndices,
WindingOrder windingOrder,
BoundingSphere boundingSphere,
boolean closed)
Defines the solid using the specified parameters.
|
void |
SolidPrimitive.set(Iterable<Cartesian> positions,
Iterable<Cartesian> normals,
Iterable<Integer> indices,
Iterable<Integer> outlineIndices,
WindingOrder windingOrder,
BoundingSphere boundingSphere,
boolean closed)
Defines the solid using the specified parameters.
|
void |
TriangleMeshPrimitive.set(Iterable<Cartesian> positions,
Iterable<Cartesian> normals,
Iterable<Integer> indices,
TriangleMeshPrimitiveOptionalParameters optionalParameters)
Defines the triangle mesh using an indexed triangle list specified by
positions, normals,
indices, and optionalParameters. |
void |
TriangleMeshPrimitive.set(Iterable<Cartesian> positions,
Iterable<Cartesian> normals,
Iterable<Integer> indices,
TriangleMeshPrimitiveOptionalParameters optionalParameters)
Defines the triangle mesh using an indexed triangle list specified by
positions, normals,
indices, and optionalParameters. |
void |
PolylinePrimitive.set(Iterable<Cartesian> positions,
Iterable<Color> colors)
Defines the positions and colors of a polyline.
|
void |
PointBatchPrimitive.set(Iterable<Cartesian> positions,
Iterable<Color> colors)
Defines the positions and colors of points in a point batch.
|
void |
PolylinePrimitive.set(Iterable<Cartesian> positions,
Iterable<Color> colors,
PolylinePrimitiveOptionalParameters optionalParameters)
Defines the positions, colors, and/or optional point properties of a polyline.
|
void |
PolylinePrimitive.set(Iterable<Cartesian> positions,
Iterable<Color> colors,
RenderPassHint renderPassHint)
Defines the positions and colors of a polyline.
|
void |
PointBatchPrimitive.set(Iterable<Cartesian> positions,
Iterable<Color> colors,
RenderPassHint renderPassHint)
Defines the positions and colors of points in a point batch.
|
void |
TextBatchPrimitive.set(Iterable<Cartesian> positions,
Iterable<String> text)
Defines the positions and text of strings in a text batch.
|
void |
TextBatchPrimitive.set(Iterable<Cartesian> positions,
Iterable<String> text,
TextBatchPrimitiveOptionalParameters optionalParameters)
Defines the positions, text, and optional parameters of strings in a
text batch.
|
void |
TextBatchPrimitive.set(Iterable<Cartesian> positions,
Iterable<String> text,
TextBatchPrimitiveOptionalParameters optionalParameters,
RenderPassHint renderPassHint)
Defines the positions, text, and optional parameters of strings in a
text batch.
|
void |
MarkerBatchPrimitive.set(Iterable<Cartesian> positions,
MarkerBatchPrimitiveOptionalParameters optionalParameters)
Defines the positions and optional per-marker parameters of markers in a
marker batch.
|
void |
MarkerBatchPrimitive.set(Iterable<Cartesian> positions,
MarkerBatchPrimitiveOptionalParameters optionalParameters,
RenderPassHint renderPassHint)
Defines the positions and optional per-marker parameters of markers in a
marker batch.
|
void |
TextBatchPrimitiveOptionalParameters.setEyeOffsets(Iterable<Cartesian> eyeOffsets)
Defines a collection of eye offsets, one for each string in the batch.
|
void |
MarkerBatchPrimitiveOptionalParameters.setEyeOffsets(Iterable<Cartesian> eyeOffsets)
Defines a collection of eye offsets, one for each marker in the batch.
|
void |
PolylinePrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Color> colors,
Iterable<Integer> indices)
Updates a subset of positions and/or colors in a polyline.
|
void |
PointBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Color> colors,
Iterable<Integer> indices)
Updates a subset of positions and/or colors in a point batch.
|
void |
PolylinePrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Color> colors,
Iterable<Integer> indices,
IndicesOrderHint indicesOrderHint,
RenderPassHint renderPassHint)
Updates a subset of positions and/or colors in a polyline.
|
void |
PointBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Color> colors,
Iterable<Integer> indices,
IndicesOrderHint indicesOrderHint,
RenderPassHint renderPassHint)
Updates a subset of positions and/or colors in a point batch.
|
void |
PolylinePrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Color> colors,
PolylinePrimitiveOptionalParameters optionalParameters,
Iterable<Integer> indices)
Updates a subset of positions, colors, and/or optional point properties in a polyline.
|
void |
PolylinePrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Integer> indices)
Updates a subset of positions in a polyline.
|
void |
PointBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Integer> indices)
Updates a subset of positions in a point batch.
|
void |
MarkerBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Integer> indices)
Updates a subset of marker positions in a marker batch.
|
void |
PolylinePrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Integer> indices,
IndicesOrderHint indicesOrderHint)
Updates a subset of positions in a polyline.
|
void |
PointBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Integer> indices,
IndicesOrderHint indicesOrderHint)
Updates a subset of positions in a point batch.
|
void |
MarkerBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<Integer> indices,
IndicesOrderHint indicesOrderHint)
Updates a subset of marker positions in a marker batch.
|
void |
TextBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<String> text,
Iterable<Integer> indices)
Updates a subset of positions and/or text in a text batch.
|
void |
TextBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<String> text,
Iterable<Integer> indices,
IndicesOrderHint indicesOrderHint)
Updates a subset of positions and/or text in a text batch.
|
void |
TextBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<String> text,
TextBatchPrimitiveOptionalParameters optionalParameters,
Iterable<Integer> indices)
Updates a subset of positions, text, and/or optional per-string parameters in a text batch.
|
void |
TextBatchPrimitive.setPartial(Iterable<Cartesian> positions,
Iterable<String> text,
TextBatchPrimitiveOptionalParameters optionalParameters,
Iterable<Integer> indices,
IndicesOrderHint indicesOrderHint,
RenderPassHint renderPassHint)
Updates a subset of positions, text, and/or optional per-string parameters in a text batch.
|
void |
MarkerBatchPrimitive.setPartial(Iterable<Cartesian> positions,
MarkerBatchPrimitiveOptionalParameters optionalParameters,
Iterable<Integer> indices)
Updates a subset of marker positions and/or per-marker parameters in a marker batch.
|
void |
MarkerBatchPrimitive.setPartial(Iterable<Cartesian> positions,
MarkerBatchPrimitiveOptionalParameters optionalParameters,
Iterable<Integer> indices,
IndicesOrderHint indicesOrderHint,
RenderPassHint renderPassHint)
Updates a subset of marker positions and/or per-marker parameters in a marker batch.
|
| Constructor and Description |
|---|
DistanceToPositionDisplayCondition(Cartesian position,
double minimumDistance,
double maximumDistance)
Initializes a distance display condition with the inclusive distance interval
[
minimumDistance, maximumDistance]. |
DistanceToPositionDisplayCondition(ReferenceFrame referenceFrame,
Cartesian position,
double minimumDistance,
double maximumDistance)
Initializes a distance display condition with the inclusive distance interval
[
minimumDistance, maximumDistance]. |
PathPoint(Cartesian position,
JulianDate date)
Initializes a
PathPoint with the given position and date. |
PathPoint(Cartesian position,
JulianDate date,
Color color)
Initializes a
PathPoint with the given position, date, and color. |
PathPoint(Cartesian position,
JulianDate date,
Color color,
float translucency)
Initializes a
PathPoint with the given position, date, color, and translucency. |
PathPoint(Cartesian position,
JulianDate date,
Color color,
float translucency,
Color outlineColor)
Initializes a
PathPoint with the given position, date, color, translucency,
and outline color. |
PathPoint(Cartesian position,
JulianDate date,
Color color,
float translucency,
Color outlineColor,
float outlineTranslucency)
Initializes a
PathPoint with the given cartesian position, date, color,
translucency, outline color, and outline translucency. |
PathPointBuilder(Cartesian position,
JulianDate date)
Initializes a
PathPointBuilder with the given position and date. |
PathPointBuilder(Cartesian position,
JulianDate date,
Color color)
Initializes a
PathPointBuilder with the given position, date, and color. |
PathPointBuilder(Cartesian position,
JulianDate date,
Color color,
float translucency)
Initializes a
PathPointBuilder with the given position, date, color, and translucency. |
PathPointBuilder(Cartesian position,
JulianDate date,
Color color,
float translucency,
Color outlineColor)
Initializes a
PathPointBuilder with the given position, date, color, translucency,
and outline color. |
PathPointBuilder(Cartesian position,
JulianDate date,
Color color,
float translucency,
Color outlineColor,
float outlineTranslucency)
Initializes a
PathPointBuilder with the given cartesian position, date, color,
translucency, outline color, and outline translucency. |
| Modifier and Type | Method and Description |
|---|---|
Cartesian[] |
TriangulatedSensorProjection.computeSurfaceBoundaryLines()
Gets the boundary lines of the portions of the sensor that intersected with the surface of the
central body as of the last call to
TriangulatedSensorProjection.updateFromNewProjection(CentralBody,Cartesian,SensorProjection,int). |
Cartesian |
BoundingSphere.getCenter()
Gets the Cartesian center of the bounding sphere.
|
Cartesian[] |
TriangulatedSensorProjection.getMeshVertexNormals()
Gets the normals of the vertices definining the sensor volume mesh.
|
Cartesian[] |
TriangulatedSensorProjection.getMeshVertexPositions()
Gets the positions of the vertices definining the sensor volume mesh.
|
Cartesian |
Projection.getPosition()
Gets the
Cartesian defining the position of the Projection in the central body's fixed reference frame. |
Cartesian |
TriangulatedSensorProjection.getSensorOrigin()
Gets the origin of the sensor as of the last time that
TriangulatedSensorProjection.updateFromNewProjection(CentralBody,Cartesian,SensorProjection,int) was called. |
| Modifier and Type | Method and Description |
|---|---|
void |
Projection.setPosition(Cartesian xyz)
Sets the
Cartesian defining the position of the Projection in the central body's fixed reference frame. |
void |
TriangulatedSensorProjection.updateFromNewProjection(CentralBody centralBody,
Cartesian sensorOrigin,
SensorProjection projection,
int approximateSamplesPerBoundary)
Updates the triangulation from a given sensor projection.
|
void |
TriangulatedSensorProjection.updateFromNewProjection(CentralBody centralBody,
Cartesian sensorOrigin,
SensorProjection projection,
int approximateSamplesPerBoundary,
boolean triangulateProjectionEndCap)
Updates the triangulation from a given sensor projection.
|
| Constructor and Description |
|---|
BoundingSphere(Cartesian center,
double radius)
Initializes a
BoundingSphere from a center (Cartesian) and a radius (double). |
Projection(Cartesian position,
UnitQuaternion orientation,
double fieldOfViewHorizontal,
double fieldOfViewVertical,
double nearPlane,
double farPlane)
Initializes a new instance.
|
| Modifier and Type | Method and Description |
|---|---|
static SatelliteUserRangeError |
SatelliteUserRangeError.compute(Cartesian lineOfSightVector,
PerformanceAssessmentField performanceAssessmentField)
Computes the user range error for a satellite.
|
| Modifier and Type | Method and Description |
|---|---|
static DilutionOfPrecision |
DilutionOfPrecision.compute(Matrix3By3 receiverOrientation,
Iterable<Cartesian> satelliteRelativePositions)
Computes the Dilution of Precision (DOP).
|
| Modifier and Type | Method and Description |
|---|---|
SP3dEphemerisData<Cartesian> |
SP3dEphemeris.getPositions()
Gets the position data, by Satellite Identifier.
|
SP3cEphemerisData<Cartesian> |
SP3cEphemeris.getPositions()
Gets the position data, by Satellite Identifier.
|
SP3aEphemerisData<Cartesian> |
SP3aEphemeris.getPositions()
Gets the position data, by pseudorandom number.
|
SP3dEphemerisData<Cartesian> |
SP3dEphemeris.getPositionStandardDeviations()
Gets the standard deviations for the position data, defined on the "EP" lines of the SP3d file,
by Satellite Identifier.
|
SP3cEphemerisData<Cartesian> |
SP3cEphemeris.getPositionStandardDeviations()
Gets the standard deviations for the position data, defined on the "EP" lines of the SP3c file,
by Satellite Identifier.
|
SP3dEphemerisData<Cartesian> |
SP3dEphemeris.getPositionStandardDeviationsApproximate()
Gets the approximate standard deviations for the position data, defined on the same line as the
position data, by Satellite Identifier.
|
SP3cEphemerisData<Cartesian> |
SP3cEphemeris.getPositionStandardDeviationsApproximate()
Gets the approximate standard deviations for the position data, defined on the same line as the
position data, by Satellite Identifier.
|
SP3dEphemerisData<Cartesian> |
SP3dEphemeris.getVelocities()
Gets the Velocity data, by Satellite Identifier.
|
SP3cEphemerisData<Cartesian> |
SP3cEphemeris.getVelocities()
Gets the Velocity data, by Satellite Identifier.
|
SP3aEphemerisData<Cartesian> |
SP3aEphemeris.getVelocities()
Gets the Velocity data, by pseudorandom number.
|
SP3dEphemerisData<Cartesian> |
SP3dEphemeris.getVelocityStandardDeviations()
Gets the standard deviations for the velocity data, defined on the "EV" lines of the SP3d file,
by Satellite Identifier.
|
SP3cEphemerisData<Cartesian> |
SP3cEphemeris.getVelocityStandardDeviations()
Gets the standard deviations for the velocity data, defined on the "EV" lines of the SP3c file,
by Satellite Identifier.
|
SP3dEphemerisData<Cartesian> |
SP3dEphemeris.getVelocityStandardDeviationsApproximate()
Gets the approximate standard deviations for the velocity data, defined on the same line as the
velocity data, by Satellite Identifier.
|
SP3cEphemerisData<Cartesian> |
SP3cEphemeris.getVelocityStandardDeviationsApproximate()
Gets the approximate standard deviations for the velocity data, defined on the same line as the
velocity data, by Satellite Identifier.
|
| Modifier and Type | Method and Description |
|---|---|
DateMotionCollection1<Cartesian> |
TranslationalMotionInterpolator.getData()
Gets the data over which to interpolate.
|
DateMotionCollection2<UnitQuaternion,Cartesian> |
RotationalMotionInterpolator.getData()
Gets the data over which to interpolate.
|
MotionEvaluator1<Cartesian> |
TranslationalMotionInterpolator.getEvaluator()
Gets an evaluator that interpolates and extrapolates translational motion represented as
Cartesian coordinates. |
MotionEvaluator2<UnitQuaternion,Cartesian> |
RotationalMotionInterpolator.getEvaluator()
Gets an evaluator that interpolates and extrapolates rotational motion with the rotation represented as a
Quaternion and derivatives represented as rotation vectors. |
MotionEvaluator1<Cartesian> |
TranslationalMotionInterpolator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that interpolates and extrapolates translational motion represented as
Cartesian coordinates. |
MotionEvaluator2<UnitQuaternion,Cartesian> |
RotationalMotionInterpolator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that interpolates and extrapolates rotational motion with the rotation represented as a
Quaternion and derivatives represented as rotation vectors. |
DateMotionCollection1<Cartesian> |
Covariance6By6TwoBodyBlender.getOrbitStates()
|
| Modifier and Type | Method and Description |
|---|---|
void |
TranslationalMotionInterpolator.setData(DateMotionCollection1<Cartesian> value)
Sets the data over which to interpolate.
|
void |
RotationalMotionInterpolator.setData(DateMotionCollection2<UnitQuaternion,Cartesian> value)
Sets the data over which to interpolate.
|
void |
Covariance6By6TwoBodyBlender.setOrbitStates(DateMotionCollection1<Cartesian> value)
|
static Matrix |
Covariance6By6TwoBodyBlender.transformCovariance(Matrix originalCovariance,
Motion2<UnitQuaternion,Cartesian> axesTransformation)
Transforms a 6x6 covariance matrix into new axes.
|
| Modifier and Type | Method and Description |
|---|---|
Evaluator<Cartesian> |
VectorGraphicsParameter.getEvaluator(EvaluatorGroup group)
Gets an evaluator which wraps the previously specified Vector.
|
Evaluator<Cartesian> |
PointGraphicsParameter.getEvaluator(EvaluatorGroup group)
Gets an evaluator which wraps the previously specified Point.
|
GraphicsParameter<Cartesian> |
TextGraphics.getEyeOffset()
Gets a parameter indicating the eye offset of the text over time.
|
GraphicsParameter<Cartesian> |
MarkerGraphics.getEyeOffset()
Gets a parameter indicating the eye offset of the marker over time.
|
GraphicsParameter<Cartesian> |
SolidGraphics.getScale()
Gets a parameter defining the scale of the solid.
|
| Modifier and Type | Method and Description |
|---|---|
protected boolean |
VectorGraphicsParameter.checkForSameDefinition(GraphicsParameter<Cartesian> other)
Checks to determine if another instance has the same definition as this instance and
returns
true if it does. |
protected boolean |
PointGraphicsParameter.checkForSameDefinition(GraphicsParameter<Cartesian> other)
Checks to determine if another instance has the same definition as this instance and
returns
true if it does. |
void |
TextGraphics.setEyeOffset(GraphicsParameter<Cartesian> value)
Sets a parameter indicating the eye offset of the text over time.
|
void |
MarkerGraphics.setEyeOffset(GraphicsParameter<Cartesian> value)
Sets a parameter indicating the eye offset of the marker over time.
|
void |
SolidGraphics.setScale(GraphicsParameter<Cartesian> value)
Sets a parameter defining the scale of the solid.
|
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
BallisticPropagator.configureInitialPositionFromCartographic(Cartographic initialPosition)
|
Cartesian |
BallisticPropagator.configureInitialPositionFromFixedCartesian(Cartesian initialPositionFixed)
|
Cartesian[] |
Sgp4Propagator.Sgp4EstimationOutput.getFinalPositionResiduals()
Gets an array of the final position errors between the input position and the estimated position.
|
Cartesian |
PropagationEulerianAxes.getInitialAngularVelocity()
Gets the initial angular velocity expressed in body-fixed axes.
|
Cartesian |
PropagationNewtonianPoint.getInitialPosition()
Gets the initial position.
|
Cartesian |
BallisticPropagator.getInitialPosition()
|
Cartesian[] |
Sgp4Propagator.Sgp4EstimationOutput.getInitialPositionResiduals()
Gets an array of the initial position errors between the input position and the estimated position.
|
Cartesian |
PropagationNewtonianPoint.getInitialVelocity()
Gets the initial velocity.
|
Cartesian |
BallisticPropagator.getInitialVelocity()
|
| Modifier and Type | Method and Description |
|---|---|
DateMotionCollection1<Cartesian> |
SinglePointStoppablePropagatorResults.getEphemeris()
Gets the ephemeris as computed by the
SinglePointStoppablePropagator. |
MotionEvaluator1<Cartesian> |
CartesianOnePointPropagator.getEvaluator()
Gets an evaluator that can propagate at individual dates.
|
MotionEvaluator1<Cartesian> |
NavstarISGps200DPropagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
MotionEvaluator1<Cartesian> |
GpsRinexPropagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
MotionEvaluator1<Cartesian> |
WaypointPropagator.getEvaluator(EvaluatorGroup group)
|
MotionEvaluator1<Cartesian> |
TwoBodyPropagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
MotionEvaluator1<Cartesian> |
SimpleAscentPropagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
MotionEvaluator1<Cartesian> |
Sgp4Propagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
MotionEvaluator1<Cartesian> |
J4Propagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
MotionEvaluator1<Cartesian> |
J2Propagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
abstract MotionEvaluator1<Cartesian> |
CartesianOnePointPropagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
MotionEvaluator1<Cartesian> |
BallisticPropagator.getEvaluator(EvaluatorGroup group)
Gets an evaluator that can propagate at individual dates.
|
Motion1<Cartesian> |
BallisticTrajectoryInformation.getFinalConditionsFixed()
|
Motion1<Cartesian> |
BallisticTrajectoryInformation.getFinalConditionsInertial()
|
Motion1<Cartesian> |
LambertResult.getFinalPositionMotion()
Gets the final motion as computed by the
LambertOrbitSolver. |
Motion1<Cartesian> |
TwoBodyStateTransitionMatrixPropagator.getInitialConditions()
|
Motion1<Cartesian> |
TwoBodyPropagator.getInitialConditions()
Gets the orbital elements from which to propagate.
|
Motion1<Cartesian> |
BallisticTrajectoryInformation.getInitialConditionsFixed()
|
Motion1<Cartesian> |
BallisticTrajectoryInformation.getInitialConditionsInertial()
|
Motion1<Cartesian> |
SinglePointStoppablePropagatorDefinition.getInitialMotion()
Gets the optional initial position and velocity for this propagator.
|
Motion1<Cartesian> |
LambertResult.getInitialPositionMotion()
Gets the initial motion as computed by the
LambertOrbitSolver. |
Motion1<Cartesian> |
PropagationVector.getInitialState()
|
Motion1<Cartesian> |
InitialOrbitSolverResults.getPosition1Motion()
Gets the motion for the first position in the orbit.
|
Motion1<Cartesian> |
InitialOrbitSolverResults.getPosition2Motion()
Gets the motion for the second position in the orbit.
|
Motion1<Cartesian> |
InitialOrbitSolverResults.getPosition3Motion()
Gets the motion for the third position in the orbit.
|
agi.foundation.compatibility.Tuple2<Cartesian,Cartesian> |
LambertOrbitSolver.lambertHodograph(Cartesian r1,
Cartesian r2,
Cartesian v1,
double semilatusRectum,
double eccentricity,
double changeInTrueAnomaly,
double timeOfFlight)
This function accomplishes 180 deg transfer(and 360 deg) for the Lambert problem.
|
agi.foundation.compatibility.Tuple2<Cartesian,Cartesian> |
LambertOrbitSolver.lambertHodograph(Cartesian r1,
Cartesian r2,
Cartesian v1,
double semilatusRectum,
double eccentricity,
double changeInTrueAnomaly,
double timeOfFlight)
This function accomplishes 180 deg transfer(and 360 deg) for the Lambert problem.
|
static Motion1<Cartesian> |
SimpleAscentPropagator.mixedFixedPositionAndInertialVelocityToMotionFixed(boolean isAtPole,
KinematicTransformation inertialToFixed,
Cartesian position,
double inertialSpeed,
double inertialFlightPathAngle,
double inertialAzimuth)
|
DateMotionCollection1<Cartesian> |
CartesianOnePointPropagator.propagate(JulianDate startDate,
JulianDate stopDate,
Duration timeStep,
int order,
ReferenceFrame outputReferenceFrame)
Calculates position (and zero or more derivatives) for regular time steps over an interval.
|
DateMotionCollection1<Cartesian> |
CartesianOnePointPropagator.propagate(JulianDate startDate,
JulianDate stopDate,
Duration timeStep,
int order,
ReferenceFrame outputReferenceFrame,
ITrackCalculationProgress tracker)
Calculates position (and zero or more derivatives) for regular time steps over an interval.
|
Motion1<Cartesian> |
InitialOrbitSolver.solve(Cartesian position1,
Cartesian position2,
Cartesian position3)
Solves the initial orbit determination problem using the Gibbs method.
|
Motion1<Cartesian> |
InitialOrbitSolver.solve(Cartesian position1,
Cartesian position2,
Cartesian position3,
JulianDate time1,
JulianDate time2,
JulianDate time3)
Solves the initial orbit determination problem using the Herrick-Gibbs method for closely spaced positions.
|
| Modifier and Type | Method and Description |
|---|---|
BallisticPropagatorSolutionType |
BallisticPropagator.configureForMinimumEccentricity(Cartesian targetPositionFixed)
|
BallisticPropagatorSolutionType |
BallisticPropagator.configureForMinimumEnergy(Cartesian targetPositionFixed)
|
BallisticPropagatorSolutionType |
BallisticPropagator.configureFromApogeeAltitude(Cartesian targetPositionFixed,
double apogeeAltitude)
|
BallisticPropagatorSolutionType |
BallisticPropagator.configureFromDeltaV(Cartesian targetPositionFixed,
double deltaV,
boolean highArc)
|
BallisticPropagatorSolutionType |
BallisticPropagator.configureFromFlightDuration(Cartesian targetPositionFixed,
Duration flightDuration)
|
Cartesian |
BallisticPropagator.configureInitialPositionFromFixedCartesian(Cartesian initialPositionFixed)
|
static Sgp4Propagator.Sgp4EstimationOutput |
Sgp4Propagator.estimateElements(DateMotionCollection1<Cartesian> ephemerisInTEME,
Cartesian epochPosition,
Cartesian epochVelocity,
Sgp4Propagator.Sgp4EstimationInput configuration)
Produces a batch least squares fit for a given set of trajectory observations (states).
|
agi.foundation.compatibility.Tuple2<Cartesian,Cartesian> |
LambertOrbitSolver.lambertHodograph(Cartesian r1,
Cartesian r2,
Cartesian v1,
double semilatusRectum,
double eccentricity,
double changeInTrueAnomaly,
double timeOfFlight)
This function accomplishes 180 deg transfer(and 360 deg) for the Lambert problem.
|
static Sgp4Elements |
Sgp4Propagator.meanElementsAtEpoch(JulianDate date,
Cartesian posInTEME,
Cartesian velInTEME)
Produces an element set from a given
Cartesian state at a given time. |
static Sgp4Elements |
Sgp4Propagator.meanElementsAtEpoch(JulianDate date,
Cartesian posInTEME,
Cartesian velInTEME,
int maximumIterations)
Produces an element set from a given
Cartesian state at a given time. |
static Sgp4Elements |
Sgp4Propagator.meanElementsAtEpoch(JulianDate date,
Cartesian posInTEME,
Cartesian velInTEME,
int maximumIterations,
double bStarValue)
Produces an element set from a given
Cartesian state at a given time. |
static Motion1<Cartesian> |
SimpleAscentPropagator.mixedFixedPositionAndInertialVelocityToMotionFixed(boolean isAtPole,
KinematicTransformation inertialToFixed,
Cartesian position,
double inertialSpeed,
double inertialFlightPathAngle,
double inertialAzimuth)
|
void |
PropagationEulerianAxes.setInitialAngularVelocity(Cartesian value)
Sets the initial angular velocity expressed in body-fixed axes.
|
void |
PropagationNewtonianPoint.setInitialPosition(Cartesian value)
Sets the initial position.
|
void |
BallisticPropagator.setInitialPosition(Cartesian value)
|
void |
PropagationNewtonianPoint.setInitialVelocity(Cartesian value)
Sets the initial velocity.
|
void |
BallisticPropagator.setInitialVelocity(Cartesian value)
|
Motion1<Cartesian> |
InitialOrbitSolver.solve(Cartesian position1,
Cartesian position2,
Cartesian position3)
Solves the initial orbit determination problem using the Gibbs method.
|
Motion1<Cartesian> |
InitialOrbitSolver.solve(Cartesian position1,
Cartesian position2,
Cartesian position3,
JulianDate time1,
JulianDate time2,
JulianDate time3)
Solves the initial orbit determination problem using the Herrick-Gibbs method for closely spaced positions.
|
LambertResult |
LambertOrbitSolver.solveFixedDurationTransfer(Cartesian initialPosition,
Cartesian finalPosition,
Duration timeOfFlight,
int numberOfRevolutions,
LambertPathType pathType,
OrbitDirectionType directionOfFlight)
Solves the classic Lambert problem with the specified number of revolutions.
|
LambertResult |
LambertOrbitSolver.solveFixedDurationTransfer(Cartesian initialPosition,
Cartesian finalPosition,
Duration timeOfFlight,
int numberOfRevolutions,
LambertPathType pathType,
OrbitDirectionType directionOfFlight,
Cartesian orbitalPlaneVector)
Solves the classic Lambert problem with the specified number of revolutions.
|
InitialOrbitSolverResults |
InitialOrbitSolver.solveForAllVelocities(Cartesian position1,
Cartesian position2,
Cartesian position3)
Solves the initial orbit determination problem using the Gibbs method.
|
InitialOrbitSolverResults |
InitialOrbitSolver.solveForAllVelocities(Cartesian position1,
Cartesian position2,
Cartesian position3,
JulianDate time1,
JulianDate time2,
JulianDate time3)
Solves the initial orbit determination problem using the Herrick-Gibbs method for closely spaced positions.
|
LambertResult |
LambertOrbitSolver.solveMinimumDurationMultipleRevolutionTransfer(Cartesian initialPosition,
Cartesian finalPosition,
int numberOfRevolutions,
LambertPathType pathType,
OrbitDirectionType directionOfFlight)
Solves the constrained Lambert problem given the input.
|
LambertResult |
LambertOrbitSolver.solveMinimumDurationMultipleRevolutionTransfer(Cartesian initialPosition,
Cartesian finalPosition,
int numberOfRevolutions,
LambertPathType pathType,
OrbitDirectionType directionOfFlight,
Cartesian orbitalPlaneVector)
Solves the constrained Lambert problem given the input.
|
LambertResult |
LambertOrbitSolver.solveMinimumEccentricityTransfer(Cartesian initialPosition,
Cartesian finalPosition)
Solves the constrained Lambert problem given the input.
|
LambertResult |
LambertOrbitSolver.solveMinimumEccentricityTransfer(Cartesian initialPosition,
Cartesian finalPosition,
Cartesian orbitalPlaneVector)
Solves the constrained Lambert problem given the input.
|
LambertResult |
LambertOrbitSolver.solveMinimumEnergyTransfer(Cartesian initialPosition,
Cartesian finalPosition)
Solves the constrained Lambert problem given the input.
|
LambertResult |
LambertOrbitSolver.solveMinimumEnergyTransfer(Cartesian initialPosition,
Cartesian finalPosition,
Cartesian orbitalPlaneVector)
Solves the constrained Lambert problem given the input.
|
LambertResult |
LambertOrbitSolver.solveParabolicTransfer(Cartesian initialPosition,
Cartesian finalPosition,
OrbitDirectionType directionOfFlight)
Solves the constrained Lambert problem given the input.
|
LambertResult |
LambertOrbitSolver.solveParabolicTransfer(Cartesian initialPosition,
Cartesian finalPosition,
OrbitDirectionType directionOfFlight,
Cartesian orbitalPlaneVector)
Solves the constrained Lambert problem given the input.
|
| Modifier and Type | Method and Description |
|---|---|
static Sgp4Propagator.Sgp4EstimationOutput |
Sgp4Propagator.estimateElements(DateMotionCollection1<Cartesian> ephemerisInTEME,
Cartesian epochPosition,
Cartesian epochVelocity,
Sgp4Propagator.Sgp4EstimationInput configuration)
Produces a batch least squares fit for a given set of trajectory observations (states).
|
static Sgp4Propagator.Sgp4EstimationOutput |
Sgp4Propagator.estimateElements(DateMotionCollection1<Cartesian> ephemerisInTEME,
Sgp4Propagator.Sgp4EstimationInput configuration)
Produces a batch least squares fit for a given set of trajectory observations (states).
|
protected abstract PointEvaluator |
SinglePointStoppablePropagator.initializePropagationPoint(JulianDate date,
Motion1<Cartesian> motion)
Creates the
PointEvaluator that will be sampled for propagation. |
SinglePointStoppablePropagatorResults |
SinglePointStoppablePropagator.propagateUntilStop(JulianDate initialDate,
Motion1<Cartesian> initialState,
IntegrationSense direction,
ITrackCalculationProgress progressTracker)
Propagates a
Point forward in time from the initial conditions. |
SinglePointStoppablePropagatorResults |
SinglePointStoppablePropagator.propagateUntilStop(JulianDate initialDate,
Motion1<Cartesian> initialState,
Iterable<? extends StoppingConditionEvaluator> conditions,
IntegrationSense direction,
int outputSparsity,
ITrackCalculationProgress progressTracker)
Propagates a
Point forward in time from the initial conditions. |
void |
LambertResult.setFinalPositionMotion(Motion1<Cartesian> value)
Sets the final motion as computed by the
LambertOrbitSolver. |
void |
TwoBodyStateTransitionMatrixPropagator.setInitialConditions(Motion1<Cartesian> value)
|
void |
TwoBodyPropagator.setInitialConditions(Motion1<Cartesian> value)
Sets the orbital elements from which to propagate.
|
void |
SinglePointStoppablePropagatorDefinition.setInitialMotion(Motion1<Cartesian> value)
Sets the optional initial position and velocity for this propagator.
|
void |
LambertResult.setInitialPositionMotion(Motion1<Cartesian> value)
Sets the initial motion as computed by the
LambertOrbitSolver. |
void |
PropagationVector.setInitialState(Motion1<Cartesian> value)
|
| Constructor and Description |
|---|
BallisticPropagator(CentralBody centralBody,
double gravitationalParameter,
JulianDate initialTime,
Cartesian initialPositionInertial)
Initializes a new instance.
|
PropagationEulerianAxes(String id,
ReferenceFrame propagationFrame,
UnitQuaternion initialAttitudeQuaternion,
Cartesian initialAngularVelocity,
Matrix3By3Symmetric inertiaMatrix)
Initializes a new instance.
|
PropagationNewtonianPoint(String id,
ReferenceFrame propagationFrame,
Cartesian initialPosition,
Cartesian initialVelocity)
Initializes a new instance.
|
PropagationVector(Cartesian... initialValues)
Initializes a new instance.
|
| Constructor and Description |
|---|
InitialOrbitSolverResults(Motion1<Cartesian> position1Motion,
Motion1<Cartesian> position2Motion,
Motion1<Cartesian> position3Motion)
Initializes the results data container.
|
InitialOrbitSolverResults(Motion1<Cartesian> position1Motion,
Motion1<Cartesian> position2Motion,
Motion1<Cartesian> position3Motion)
Initializes the results data container.
|
InitialOrbitSolverResults(Motion1<Cartesian> position1Motion,
Motion1<Cartesian> position2Motion,
Motion1<Cartesian> position3Motion)
Initializes the results data container.
|
J2Propagator(JulianDate orbitEpoch,
ReferenceFrame referenceFrame,
Motion1<Cartesian> initialConditions,
double gravitationalParameter,
double j2UnnormalizedValue,
double referenceDistance)
Initializes a new instance.
|
J4Propagator(JulianDate orbitEpoch,
ReferenceFrame referenceFrame,
Motion1<Cartesian> initialConditions,
double gravitationalParameter,
double j2UnnormalizedValue,
double j4UnnormalizedValue,
double referenceDistance)
Initializes a new instance.
|
SinglePointStoppablePropagatorResults(StoppingConditionEvent stoppingEvent,
List<StoppingConditionEvent> detectedEvents,
DateMotionCollection1<Cartesian> ephemeris,
List<ITimeBasedState> propagatedStates,
boolean aborted)
Initializes a new instance.
|
TwoBodyPropagator(JulianDate orbitEpoch,
ReferenceFrame referenceFrame,
Motion1<Cartesian> initialConditions,
double gravitationalParameter)
Initializes a new instance.
|
TwoBodyStateTransitionMatrixPropagator(JulianDate epoch,
Motion1<Cartesian> initialConditions,
double gravitationalParameter)
Initializes a new instance.
|
| Modifier and Type | Method and Description |
|---|---|
Motion1<Cartesian> |
CartesianStateElementConverter.convertState(double[] overallState)
Convert the raw state into a
Cartesian
and its derivatives. |
| Constructor and Description |
|---|
CartesianStateElementConverter(String identification,
Motion1<int[]> stateIndices,
Motion1<Cartesian> initialState)
Initializes a new instance.
|
CartesianStateElementConverter(String identification,
Motion1<int[]> stateIndices,
Motion1<Cartesian> initialState,
Motion1<double[]> weights)
Initializes a new instance.
|
| Modifier and Type | Method and Description |
|---|---|
static HeadingAtWaypointProcedure |
HeadingAtWaypointProcedure.getFinalFromNextState(CentralBody centralBody,
Motion1<Cartesian> stateInFixedFrame,
ProfileDynamics dynamics,
double turningRadius)
Creates an instance of the procedure to represent a final state for a route
based on a given state (position and velocity) in the
FixedFrame (get / set) of the CentralBody. |
static HeadingAtWaypointProcedure |
HeadingAtWaypointProcedure.getInitialFromPreviousState(CentralBody centralBody,
Motion1<Cartesian> stateInFixedFrame,
ProfileDynamics dynamics,
double turningRadius)
Creates an instance of the procedure to represent an initial state for a route
based on a given state (position and velocity) in the
FixedFrame (get / set) of the CentralBody. |
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
SurfaceSegment.traverseFixed(double distanceAlongPath)
|
Cartesian |
SurfaceCurveSegment.traverseFixed(double distanceAlongPath)
|
| Modifier and Type | Method and Description |
|---|---|
Motion1<Cartesian> |
ParametricRouteSegment.traverseFixed(Duration time,
int order)
Produces the position along the route in the fixed frame of the
SurfaceShape (get)
as a function of time from the start of this segment of the route. |
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
ImpulsiveManeuverInformation.getDeltaV()
|
| Modifier and Type | Method and Description |
|---|---|
DateMotionCollection1<Cartesian> |
SegmentResults.getDateMotionCollectionOfOverallTrajectory(String element,
ReferenceFrame frame)
Gets a
DateMotionCollection1 of the element in the specified
ReferenceFrame from the EphemerisForOverallTrajectory (get). |
DateMotionCollection1<Cartesian> |
SegmentListResults.getDateMotionCollectionOfOverallTrajectory(String element,
ReferenceFrame frame)
Gets a
DateMotionCollection1 of the element in the specified
ReferenceFrame from the EphemerisForOverallTrajectory (get). |
| Modifier and Type | Method and Description |
|---|---|
void |
ImpulsiveManeuverInformation.setDeltaV(Cartesian value)
|
| Constructor and Description |
|---|
ImpulsiveManeuverInformation(String propagationElementIdentification,
Cartesian deltaV)
Initializes a new instance.
|
ImpulsiveManeuverInformation(String propagationElementIdentification,
Cartesian deltaV,
Axes orientationAxes)
Initializes a new instance.
|
ImpulsiveManeuverInformation(String propagationElementIdentification,
Cartesian deltaV,
Axes orientationAxes,
String fuelMassIdentification,
String dryMassIdentification,
Scalar exhaustVelocity,
InvalidFuelStateBehavior whatToDo)
Initializes a new instance.
|
ImpulsiveManeuverInformation(String propagationElementIdentification,
Cartesian deltaV,
String fuelMassIdentification,
String dryMassIdentification,
Scalar exhaustVelocity,
InvalidFuelStateBehavior whatToDo)
Initializes a new instance.
|
| Modifier and Type | Method and Description |
|---|---|
static DateMotionCollection2<UnitQuaternion,Cartesian> |
StkAttitudeFile.AttitudeTimeQuaternions.convertFromStkAttitudeConvention(DateMotionCollection2<UnitQuaternion,Cartesian> data)
|
static DateMotionCollection2<UnitQuaternion,Cartesian> |
StkAttitudeFile.AttitudeTimeQuaternions.convertToStkAttitudeConvention(DateMotionCollection2<UnitQuaternion,Cartesian> data)
|
DateMotionCollection2<UnitQuaternion,Cartesian> |
StkAttitudeFile.AttitudeTimeQuaternions.getAttitudeData()
|
DateMotionCollection1<Cartesian> |
StkEphemerisFile.EphemerisTimePos.getEphemerisData()
|
| Modifier and Type | Method and Description |
|---|---|
static DateMotionCollection2<UnitQuaternion,Cartesian> |
StkAttitudeFile.AttitudeTimeQuaternions.convertFromStkAttitudeConvention(DateMotionCollection2<UnitQuaternion,Cartesian> data)
|
static DateMotionCollection2<UnitQuaternion,Cartesian> |
StkAttitudeFile.AttitudeTimeQuaternions.convertToStkAttitudeConvention(DateMotionCollection2<UnitQuaternion,Cartesian> data)
|
void |
StkAttitudeFile.AttitudeTimeQuaternions.setAttitudeData(DateMotionCollection2<UnitQuaternion,Cartesian> value)
|
void |
StkEphemerisFile.EphemerisTimePos.setEphemerisData(DateMotionCollection1<Cartesian> value)
|
| Modifier and Type | Method and Description |
|---|---|
static Cartesian |
TerrainAlongLine.computePositionWithMaximumElevationAngle(Cartesian observerPositionFixed,
Cartesian targetPositionFixed,
TerrainProvider terrainProvider)
|
static Cartesian |
TerrainAlongLine.computePositionWithMaximumElevationAngle(Cartesian observerPositionFixed,
Cartesian targetPositionFixed,
TerrainProvider terrainProvider,
double minimumTerrainHeight,
double maximumTerrainHeight)
|
static Cartesian |
TerrainAlongLine.computePositionWithMaximumElevationAngle(Cartographic observerPosition,
Cartographic targetPosition,
TerrainProvider terrainProvider)
|
static Cartesian |
TerrainAlongLine.computePositionWithMaximumElevationAngle(Cartographic observerPosition,
Cartographic targetPosition,
TerrainProvider terrainProvider,
double minimumTerrainHeight,
double maximumTerrainHeight)
|
Cartesian |
QuantizedMeshTerrainTile.getCenter()
Gets the center coordinates of the tile in the fixed frame of the central body.
|
Cartesian |
TerrainProvider.getGradient(double longitude,
double latitude)
|
| Modifier and Type | Method and Description |
|---|---|
static double |
TerrainAlongLine.computeElevationAngleAboveTerrain(Cartesian observerPositionFixed,
Cartesian targetPositionFixed,
TerrainProvider terrainProvider)
Computes the angle from the line of sight between the target and observer positions
and the direction to the point on terrain with the highest elevation angle.
|
static double |
TerrainAlongLine.computeElevationAngleAboveTerrain(Cartesian observerPositionFixed,
Cartesian targetPositionFixed,
TerrainProvider terrainProvider,
double minimumTerrainHeight,
double maximumTerrainHeight)
Computes the angle from the line of sight between the target and observer positions
and the direction to the point on terrain with the highest elevation angle.
|
static double |
TerrainAlongLine.computeObstructionMetric(Cartesian observerPositionFixed,
Cartesian targetPositionFixed,
TerrainProvider terrainProvider,
boolean findWorstObstruction,
boolean findIndicatedExtremaPrecisely)
Computes a metric value indicating the amount of obstruction from the line of sight between the target and observer positions
and the direction to the point on terrain with the highest elevation angle.
|
static double |
TerrainAlongLine.computeObstructionMetric(Cartesian observerPositionFixed,
Cartesian targetPositionFixed,
TerrainProvider terrainProvider,
double minimumTerrainHeight,
double maximumTerrainHeight,
boolean findWorstObstruction,
boolean findIndicatedExtremaPrecisely)
Computes a metric value indicating the amount of obstruction from the line of sight between the target and observer positions
and the direction to the point on terrain with the highest elevation angle.
|
static Cartesian |
TerrainAlongLine.computePositionWithMaximumElevationAngle(Cartesian observerPositionFixed,
Cartesian targetPositionFixed,
TerrainProvider terrainProvider)
|
static Cartesian |
TerrainAlongLine.computePositionWithMaximumElevationAngle(Cartesian observerPositionFixed,
Cartesian targetPositionFixed,
TerrainProvider terrainProvider,
double minimumTerrainHeight,
double maximumTerrainHeight)
|
static Cartographic |
TerrainAlongLine.computeTerrainIntersection(Cartesian cartesian,
Cartographic cartographic,
UnitCartesian direction,
double granularity,
double maximumDistance,
TerrainProvider terrainProvider)
Computes the location of the first intersection with terrain from the provided location along the indicated direction.
|
static Cartographic |
TerrainAlongLine.computeTerrainIntersection(Cartesian cartesian,
Cartographic cartographic,
UnitCartesian direction,
double granularity,
double maximumDistance,
TerrainProvider terrainProvider,
double minimumTerrainHeight,
double maximumTerrainHeight)
Computes the location of the first intersection with terrain from the provided location along the indicated direction.
|
static Cartographic |
TerrainAlongLine.computeTerrainIntersection(Cartesian cartesian,
UnitCartesian direction,
double granularity,
double maximumDistance,
TerrainProvider terrainProvider)
Computes the location of the first intersection with terrain from the provided location along the indicated direction.
|
static Cartographic |
TerrainAlongLine.computeTerrainIntersection(Cartesian cartesian,
UnitCartesian direction,
double granularity,
double maximumDistance,
TerrainProvider terrainProvider,
double minimumTerrainHeight,
double maximumTerrainHeight)
Computes the location of the first intersection with terrain from the provided location along the indicated direction.
|
| Modifier and Type | Method and Description |
|---|---|
Cartesian |
MarkerVisualizer.getEyeOffset()
Gets the eye offset of each marker from the position of the entity.
|
Cartesian |
LabelVisualizer.getEyeOffset()
Gets the eye offset of each label from the position of the entity.
|
Cartesian |
ViewEntityFromOffset.getOffset()
Gets the initial offset from the entity to place the camera,
specified as
AxesEastNorthUp. |
| Modifier and Type | Method and Description |
|---|---|
TransactedProperty<Cartesian> |
IEntityAcceleration.getAcceleration()
Gets the transactional property that holds the acceleration of the entity.
|
DateMotionCollection2<UnitQuaternion,Cartesian> |
TrackingArchive.getOrientations(Object entityIdentifier,
JulianDate start,
int maximumPoints)
Gets a
DateMotionCollection2 representing
the archived orientation, rotational velocity and rotational acceleration of the
specified entity beginning at the specified time and lasting for the specified duration. |
DateMotionCollection2<UnitQuaternion,Cartesian> |
TrackingArchive.getOrientations(Object entityIdentifier,
JulianDate start,
JulianDate stop)
Gets a
DateMotionCollection2 representing
the archived orientation, rotational velocity and rotational acceleration of the
specified entity beginning at the specified time and lasting for the specified duration. |
DateMotionCollection2<UnitQuaternion,Cartesian> |
TrackingArchive.getOrientations(Object entityIdentifier,
JulianDate start,
JulianDate stop,
int maximumPoints)
Gets a
DateMotionCollection2 representing
the archived orientation, rotational velocity and rotational acceleration of the
specified entity beginning at the specified time and lasting for the specified duration. |
TransactedProperty<Cartesian> |
IEntityPosition.getPosition()
Gets the transactional property that holds the position of the entity.
|
Iterable<Cartesian> |
EntityHistory.getPositions()
Gets the list of positions currently recorded in the
HistoryGenerator. |
DateMotionCollection1<Cartesian> |
TrackingArchive.getPositions(Object entityIdentifier,
JulianDate start,
int maximumPoints)
Gets a
DateMotionCollection1 representing the
archived position, velocity and acceleration of the specified entity
beginning at the specified time and lasting for the specified duration. |
DateMotionCollection1<Cartesian> |
TrackingArchive.getPositions(Object entityIdentifier,
JulianDate start,
JulianDate stop)
Gets a
DateMotionCollection1 representing the
archived position, velocity and acceleration of the specified entity
beginning at the specified time and lasting for the specified duration. |
DateMotionCollection1<Cartesian> |
TrackingArchive.getPositions(Object entityIdentifier,
JulianDate start,
JulianDate stop,
int maximumPoints)
Gets a
DateMotionCollection1 representing the
archived position, velocity and acceleration of the specified entity
beginning at the specified time and lasting for the specified duration. |
TransactedProperty<Cartesian> |
IEntityRotationalAcceleration.getRotationalAcceleration()
Gets the transactional property that holds the rotational acceleration of the entity.
|
TransactedProperty<Cartesian> |
IEntityRotationalVelocity.getRotationalVelocity()
Gets the transactional property that holds the rotational velocity of the entity.
|
TransactedProperty<Cartesian> |
IEntityVelocity.getVelocity()
Gets the transactional property that holds the velocity of the entity.
|
| Modifier and Type | Method and Description |
|---|---|
void |
MarkerVisualizer.setEyeOffset(Cartesian value)
Sets the eye offset of each marker from the position of the entity.
|
void |
LabelVisualizer.setEyeOffset(Cartesian value)
Sets the eye offset of each label from the position of the entity.
|
void |
ViewEntityFromOffset.setOffset(Cartesian value)
Sets the initial offset from the entity to place the camera,
specified as
AxesEastNorthUp. |
| Constructor and Description |
|---|
ViewEntityFromOffset(TypeLiteral<TEntity> typeLiteralTEntity,
Camera camera,
TEntity entity,
Cartesian offset,
CentralBody centralBody)
Creates a new instance, specifying all parameters.
|