Examples with Transform org.orekit.frames.Transform used on opensource projects

Example 41 with Transform

use of org.orekit.frames.Transform in project Orekit by CS-SI.

the class JPLCelestialBody method getPVCoordinates.

/**
 * {@inheritDoc}
 */
public TimeStampedPVCoordinates getPVCoordinates(final AbsoluteDate date, final Frame frame) throws OrekitException {
    // apply the scale factor to raw position-velocity
    final PVCoordinates rawPV = rawPVProvider.getRawPV(date);
    final TimeStampedPVCoordinates scaledPV = new TimeStampedPVCoordinates(date, scale, rawPV);
    // the raw PV are relative to the parent of the body centered inertially oriented frame
    final Transform transform = getInertiallyOrientedFrame().getParent().getTransformTo(frame, date);
    // convert to requested frame
    return transform.transformPVCoordinates(scaledPV);
}

Example 42 with Transform

use of org.orekit.frames.Transform in project Orekit by CS-SI.

the class OneAxisEllipsoid method transform.

/**
 * Transform a Cartesian point to a surface-relative point.
 * @param point Cartesian point
 * @param frame frame in which Cartesian point is expressed
 * @param date date of the computation (used for frames conversions)
 * @return point at the same location but as a surface-relative point,
 * using time as the single derivation parameter
 * @exception OrekitException if point cannot be converted to body frame
 */
public FieldGeodeticPoint<DerivativeStructure> transform(final PVCoordinates point, final Frame frame, final AbsoluteDate date) throws OrekitException {
    // transform point to body frame
    final Transform toBody = frame.getTransformTo(bodyFrame, date);
    final PVCoordinates pointInBodyFrame = toBody.transformPVCoordinates(point);
    final FieldVector3D<DerivativeStructure> p = pointInBodyFrame.toDerivativeStructureVector(2);
    final DerivativeStructure pr2 = p.getX().multiply(p.getX()).add(p.getY().multiply(p.getY()));
    final DerivativeStructure pr = pr2.sqrt();
    final DerivativeStructure pz = p.getZ();
    // project point on the ellipsoid surface
    final TimeStampedPVCoordinates groundPoint = projectToGround(new TimeStampedPVCoordinates(date, pointInBodyFrame), bodyFrame);
    final FieldVector3D<DerivativeStructure> gp = groundPoint.toDerivativeStructureVector(2);
    final DerivativeStructure gpr2 = gp.getX().multiply(gp.getX()).add(gp.getY().multiply(gp.getY()));
    final DerivativeStructure gpr = gpr2.sqrt();
    final DerivativeStructure gpz = gp.getZ();
    // relative position of test point with respect to its ellipse sub-point
    final DerivativeStructure dr = pr.subtract(gpr);
    final DerivativeStructure dz = pz.subtract(gpz);
    final double insideIfNegative = g2 * (pr2.getReal() - ae2) + pz.getReal() * pz.getReal();
    return new FieldGeodeticPoint<>(DerivativeStructure.atan2(gpz, gpr.multiply(g2)), DerivativeStructure.atan2(p.getY(), p.getX()), DerivativeStructure.hypot(dr, dz).copySign(insideIfNegative));
}

Example 43 with Transform

use of org.orekit.frames.Transform in project Orekit by CS-SI.

the class SpinStabilized method getAttitude.

/**
 * {@inheritDoc}
 */
public Attitude getAttitude(final PVCoordinatesProvider pvProv, final AbsoluteDate date, final Frame frame) throws OrekitException {
    // get attitude from underlying non-rotating law
    final Attitude base = nonRotatingLaw.getAttitude(pvProv, date, frame);
    final Transform baseTransform = new Transform(date, base.getOrientation());
    // compute spin transform due to spin from reference to current date
    final Transform spinInfluence = new Transform(date, new Rotation(axis, rate * date.durationFrom(start), RotationConvention.FRAME_TRANSFORM), spin);
    // combine the two transforms
    final Transform combined = new Transform(date, baseTransform, spinInfluence);
    // build the attitude
    return new Attitude(date, frame, combined.getRotation(), combined.getRotationRate(), combined.getRotationAcceleration());
}

Example 44 with Transform

use of org.orekit.frames.Transform in project Orekit by CS-SI.

the class TargetPointing method getTargetPV.

/**
 * {@inheritDoc}
 */
@Override
public TimeStampedPVCoordinates getTargetPV(final PVCoordinatesProvider pvProv, final AbsoluteDate date, final Frame frame) throws OrekitException {
    final Transform t = getBodyFrame().getTransformTo(frame, date);
    final TimeStampedPVCoordinates pv = new TimeStampedPVCoordinates(date, target, Vector3D.ZERO, Vector3D.ZERO);
    return t.transformPVCoordinates(pv);
}

Example 45 with Transform

use of org.orekit.frames.Transform in project Orekit by CS-SI.

the class YawCompensation method getAttitude.

/**
 * {@inheritDoc}
 */
@Override
public Attitude getAttitude(final PVCoordinatesProvider pvProv, final AbsoluteDate date, final Frame frame) throws OrekitException {
    final Transform bodyToRef = getBodyFrame().getTransformTo(frame, date);
    // compute sliding target ground point
    final PVCoordinates slidingRef = getTargetPV(pvProv, date, frame);
    final PVCoordinates slidingBody = bodyToRef.getInverse().transformPVCoordinates(slidingRef);
    // compute relative position of sliding ground point with respect to satellite
    final PVCoordinates relativePosition = new PVCoordinates(pvProv.getPVCoordinates(date, frame), slidingRef);
    // compute relative velocity of fixed ground point with respect to sliding ground point
    // the velocity part of the transformPVCoordinates for the sliding point ps
    // from body frame to reference frame is:
    // d(ps_ref)/dt = r(d(ps_body)/dt + dq/dt) - Ω ⨯ ps_ref
    // where r is the rotation part of the transform, Ω is the corresponding
    // angular rate, and dq/dt is the derivative of the translation part of the
    // transform (the translation itself, without derivative, is hidden in the
    // ps_ref part in the cross product).
    // The sliding point ps is co-located to a fixed ground point pf (i.e. they have the
    // same position at time of computation), but this fixed point as zero velocity
    // with respect to the ground. So the velocity part of the transformPVCoordinates
    // for this fixed point can be computed using the same formula as above:
    // from body frame to reference frame is:
    // d(pf_ref)/dt = r(0 + dq/dt) - Ω ⨯ pf_ref
    // so remembering that the two points are at the same location at computation time,
    // i.e. that at t=0 pf_ref=ps_ref, the relative velocity between the fixed point
    // and the sliding point is given by the simple expression:
    // d(ps_ref)/dt - d(pf_ref)/dt = r(d(ps_body)/dt)
    // the acceleration is computed by differentiating the expression, which gives:
    // d²(ps_ref)/dt² - d²(pf_ref)/dt² = r(d²(ps_body)/dt²) - Ω ⨯ [d(ps_ref)/dt - d(pf_ref)/dt]
    final Vector3D v = bodyToRef.getRotation().applyTo(slidingBody.getVelocity());
    final Vector3D a = new Vector3D(+1, bodyToRef.getRotation().applyTo(slidingBody.getAcceleration()), -1, Vector3D.crossProduct(bodyToRef.getRotationRate(), v));
    final PVCoordinates relativeVelocity = new PVCoordinates(v, a, Vector3D.ZERO);
    final PVCoordinates relativeNormal = PVCoordinates.crossProduct(relativePosition, relativeVelocity).normalize();
    // . target relative velocity is in (Z, X) plane, in the -X half plane part
    return new Attitude(frame, new TimeStampedAngularCoordinates(date, relativePosition.normalize(), relativeNormal.normalize(), PLUS_K, PLUS_J, 1.0e-9));
}