Hello! @luc please help me

I used it code for determination of pitch, roll and yaw angles:

```
// Create target point and target pointing law towards that point
final GeodeticPoint targetDef = new GeodeticPoint(FastMath.toRadians(5.), FastMath.toRadians(-40.), 0.);
final TargetPointing targetLaw = new TargetPointing(orbit.getFrame(), targetDef, earthSpheric);
// Get roll, pitch, yaw angles corresponding to this pointing law
final LofOffset lofAlignedLaw = new LofOffset(orbit.getFrame(), LOFType.VVLH);
final Rotation lofAlignedRot = lofAlignedLaw.getAttitude(orbit, date, orbit.getFrame()).getRotation();
final Attitude targetAttitude = targetLaw.getAttitude(orbit, date, orbit.getFrame());
final Rotation rollPitchYaw = targetAttitude.getRotation().applyTo(lofAlignedRot.revert()).revert();
final double[] angles = rollPitchYaw.getAngles(RotationOrder.ZYX);
final double yaw = angles[0];
final double pitch = angles[1];
final double roll = angles[2];
```

How will it be correct to build a turn in any STK-type visualization system, so that when turning at these angles I see the correct picture of the turn? What Iâ€™m doing now shows me outside the line of sight of the targetDef point - projections on the ground close to the satellite route - and in the areas of line of sight of the targetDef point - smooth aiming at this point.

Here is the accounting of a smooth change in speeds and derivatives of speeds - or am I turning and building something wrong? After all, the reverse code for checking the rotation for the calculated angles of the roll and yaw pitch gives a point on the Earth targetDef - I checked it, everything converges here:

```
// Create a lof offset law from those values
final LofOffset lofOffsetLaw = new LofOffset(orbit.getFrame(), LOFType.VVLH, RotationOrder.ZYX, yaw, pitch,
roll);
final LofOffsetPointing lofOffsetPtLaw = new LofOffsetPointing(orbit.getFrame(), earthSpheric, lofOffsetLaw,
Vector3D.PLUS_K);
// Check target pointed by this law : shall be the same as defined
final Vector3D pTargetRes = lofOffsetPtLaw.getTargetPV(orbit, date, earthSpheric.getBodyFrame())
.getPosition();
final GeodeticPoint targetRes = earthSpheric.transform(pTargetRes, earthSpheric.getBodyFrame(), date);
```

Gives me the correct aiming point equal to targetDef, but I donâ€™t see it on the display.

To display to map I use this code:

```
Transform inertToBody = currentState.getFrame().getTransformTo(earth.getBodyFrame(), currentState.getDate());
Transform fovToBody = new Transform(currentState.getDate(),
currentState.toTransform().getInverse(),
inertToBody);
Rotation rotation = new Rotation(RotationOrder.ZYX, RotationConvention.VECTOR_OPERATOR, yaw, pitch, roll);
CircularFieldOfView cov = new CircularFieldOfViewâ€‹(rotation.applyTo(Vector3D.PLUS_K),
FastMath.toRadians(0.1),
0);
List<List<GeodeticPoint>> sensorPointsAfterRotation = cov.getFootprint(fovToBody, earth, FastMath.toRadians(30));
```

However, my trace of sensorPointsAfterRotation on the map is, as I wrote above, in the line of sight of the targetDef point - smooth aiming at this point, and outside the line of sight of the targetDef point - projections next to the subsatellite point.

I would like to see direct aiming at the targetDef point - even if the point is not in the line of sight of the spacecraft and must pass through the ground - how to do it?