FieldOfView.java
/* Copyright 2002-2020 CS Group
* Licensed to CS Group (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* CS licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.orekit.propagation.events;
import org.hipparchus.exception.LocalizedCoreFormats;
import org.hipparchus.geometry.enclosing.EnclosingBall;
import org.hipparchus.geometry.euclidean.threed.Rotation;
import org.hipparchus.geometry.euclidean.threed.RotationConvention;
import org.hipparchus.geometry.euclidean.threed.Vector3D;
import org.hipparchus.geometry.partitioning.Region;
import org.hipparchus.geometry.partitioning.RegionFactory;
import org.hipparchus.geometry.spherical.twod.S2Point;
import org.hipparchus.geometry.spherical.twod.Sphere2D;
import org.hipparchus.geometry.spherical.twod.SphericalPolygonsSet;
import org.hipparchus.util.FastMath;
import org.orekit.errors.OrekitException;
import org.orekit.geometry.fov.PolygonalFieldOfView;
/** Class representing a spacecraft sensor Field Of View.
* <p>Fields Of View are zones defined on the unit sphere centered on the
* spacecraft. They can have any shape, they can be split in several
* non-connected patches and can have holes.</p>
* @see org.orekit.propagation.events.FootprintOverlapDetector
* @author Luc Maisonobe
* @since 7.1
* @deprecated as of 10.1, replaced by {@link PolygonalFieldOfView}
*/
@Deprecated
public class FieldOfView extends PolygonalFieldOfView {
/** Build a new instance.
* @param zone interior of the Field Of View, in spacecraft frame
* @param margin angular margin to apply to the zone (if positive,
* the Field Of View will consider points slightly outside of the
* zone are still visible)
*/
public FieldOfView(final SphericalPolygonsSet zone, final double margin) {
super(zone, margin);
}
/** Build a Field Of View with dihedral shape (i.e. rectangular shape).
* @param center Direction of the FOV center, in spacecraft frame
* @param axis1 FOV dihedral axis 1, in spacecraft frame
* @param halfAperture1 FOV dihedral half aperture angle 1,
* must be less than π/2, i.e. full dihedra must be smaller then
* an hemisphere
* @param axis2 FOV dihedral axis 2, in spacecraft frame
* @param halfAperture2 FOV dihedral half aperture angle 2,
* must be less than π/2, i.e. full dihedra must be smaller then
* an hemisphere
* @param margin angular margin to apply to the zone (if positive,
* the Field Of View will consider points slightly outside of the
* zone are still visible)
*/
public FieldOfView(final Vector3D center,
final Vector3D axis1, final double halfAperture1,
final Vector3D axis2, final double halfAperture2,
final double margin) {
super(createPolygon(center, axis1, halfAperture1, axis2, halfAperture2), margin);
}
/** Build Field Of View with a regular polygon shape.
* @param center center of the polygon (the center is in the inside part)
* @param meridian point defining the reference meridian for middle of first edge
* @param insideRadius distance of the edges middle points to the center
* (the polygon vertices will therefore be farther away from the center)
* @param n number of sides of the polygon
* @param margin angular margin to apply to the zone (if positive,
* the Field Of View will consider points slightly outside of the
* zone are still visible)
*/
public FieldOfView(final Vector3D center, final Vector3D meridian,
final double insideRadius, final int n, final double margin) {
super(center,
PolygonalFieldOfView.DefiningConeType.INSIDE_CONE_TOUCHING_POLYGON_AT_EDGES_MIDDLE,
meridian, insideRadius, n, margin);
}
/** Get the angular offset of target point with respect to the Field Of View Boundary.
* <p>
* The offset is roughly an angle with respect to the closest boundary point,
* corrected by the margin and using some approximation far from the Field Of View.
* It is positive if the target is outside of the Field Of view, negative inside,
* and zero if the point is exactly on the boundary (always taking the margin
* into account).
* </p>
* <p>
* As Field Of View can have complex shapes that may require long computation,
* when the target point can be proven to be outside of the Field Of View, a
* faster but approximate computation is done, that underestimates the offset.
* This approximation is only performed about 0.01 radians outside of the zone
* and is designed to still return a positive value if the full accurate computation
* would return a positive value. When target point is close to the zone (and
* furthermore when it is inside the zone), the full accurate computation is
* performed. This setup allows this offset to be used as a reliable way to
* detect Field Of View boundary crossings, which correspond to sign changes of
* the offset.
* </p>
* @param lineOfSight line of sight from the center of the Field Of View support
* unit sphere to the target in Field Of View canonical frame
* @return an angular offset negative if the target is visible within the Field Of
* View and positive if it is outside of the Field Of View, including the margin
* (note that this cannot take into account interposing bodies)
* @deprecated as of 10.1, replaced by {@link org.orekit.geometry.fov.FieldOfView#offsetFromBoundary(Vector3D, double, VisibilityTrigger)}
*/
@Deprecated
public double offsetFromBoundary(final Vector3D lineOfSight) {
final S2Point los = new S2Point(lineOfSight);
final SphericalPolygonsSet zone = getZone();
final EnclosingBall<Sphere2D, S2Point> cap = zone.getEnclosingCap();
final double margin = getMargin();
// for faster computation, we start using only the surrounding cap, to filter out
// far away points (which correspond to most of the points if the Field Of View is small)
final double crudeDistance = cap.getCenter().distance(los) - cap.getRadius();
if (crudeDistance - margin > FastMath.max(FastMath.abs(margin), 0.01)) {
// we know we are strictly outside of the zone,
// use the crude distance to compute the (positive) return value
return crudeDistance - margin;
}
// we are close, we need to compute carefully the exact offset;
// we project the point to the closest zone boundary
return zone.projectToBoundary(los).getOffset() - margin;
}
/** Create polygon.
* @param center Direction of the FOV center, in spacecraft frame
* @param axis1 FOV dihedral axis 1, in spacecraft frame
* @param halfAperture1 FOV dihedral half aperture angle 1,
* must be less than π/2, i.e. full dihedra must be smaller then
* an hemisphere
* @param axis2 FOV dihedral axis 2, in spacecraft frame
* @param halfAperture2 FOV dihedral half aperture angle 2,
* must be less than π/2, i.e. full dihedra must be smaller then
* an hemisphere
* @return built polygon
*/
private static SphericalPolygonsSet createPolygon(final Vector3D center,
final Vector3D axis1, final double halfAperture1,
final Vector3D axis2, final double halfAperture2) {
final RegionFactory<Sphere2D> factory = new RegionFactory<Sphere2D>();
final double tolerance = FastMath.max(FastMath.ulp(2.0 * FastMath.PI),
1.0e-12 * FastMath.max(halfAperture1, halfAperture2));
final Region<Sphere2D> dihedra1 = buildDihedra(factory, tolerance, center, axis1, halfAperture1);
final Region<Sphere2D> dihedra2 = buildDihedra(factory, tolerance, center, axis2, halfAperture2);
return (SphericalPolygonsSet) factory.intersection(dihedra1, dihedra2);
}
/** Build a dihedra.
* @param factory factory for regions
* @param tolerance tolerance below which points are considered equal
* @param center Direction of the FOV center, in spacecraft frame
* @param axis FOV dihedral axis, in spacecraft frame
* @param halfAperture FOV dihedral half aperture angle,
* must be less than π/2, i.e. full dihedra must be smaller then
* an hemisphere
* @return dihedra
*/
private static Region<Sphere2D> buildDihedra(final RegionFactory<Sphere2D> factory,
final double tolerance, final Vector3D center,
final Vector3D axis, final double halfAperture) {
if (halfAperture > 0.5 * FastMath.PI) {
throw new OrekitException(LocalizedCoreFormats.OUT_OF_RANGE_SIMPLE,
halfAperture, 0.0, 0.5 * FastMath.PI);
}
final Rotation r = new Rotation(axis, halfAperture, RotationConvention.VECTOR_OPERATOR);
final Vector3D normalCenterPlane = Vector3D.crossProduct(axis, center);
final Vector3D normalSidePlus = r.applyInverseTo(normalCenterPlane);
final Vector3D normalSideMinus = r.applyTo(normalCenterPlane.negate());
return factory.intersection(new SphericalPolygonsSet(normalSidePlus, tolerance),
new SphericalPolygonsSet(normalSideMinus, tolerance));
}
}