Index Page
getfov_c
A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X 

Procedure
Abstract
Required_Reading
Keywords
Brief_I/O
Detailed_Input
Detailed_Output
Parameters
Exceptions
Files
Particulars
Examples
Restrictions
Literature_References
Author_and_Institution
Version
Index_Entries

Procedure

   void getfov_c ( SpiceInt        instid,
                   SpiceInt        room,
                   SpiceInt        shapelen,
                   SpiceInt        framelen,
                   SpiceChar     * shape,
                   SpiceChar     * frame,
                   SpiceDouble     bsight [3],
                   SpiceInt      * n,
                   SpiceDouble     bounds [][3] ) 

Abstract

 
   Return the field-of-view (FOV) parameters for a specified 
   instrument. The instrument is specified by its NAIF ID code.
 

Required_Reading

 
   None. 
 

Keywords

 
   INSTRUMENT
   FOV
 

Brief_I/O

 
   VARIABLE  I/O  DESCRIPTION 
   --------  ---  -------------------------------------------------- 
   instid     I   NAIF ID of an instrument.
   room       I   Maximum number of vectors that can be returned. 
   shapelen   I   Space available in the string `shape'.
   framelen   I   Space available in the string `frame'.
   shape      O   Instrument FOV shape. 
   frame      O   Name of the frame in which FOV vectors are defined. 
   bsight     O   Boresight vector. 
   n          O   Number of boundary vectors returned. 
   bounds     O   FOV boundary vectors. 
 

Detailed_Input

 
   instid     is the NAIF ID of an instrument. 
 
   room       is the maximum number of 3D vectors that can be returned 
              in `bounds'. 

   shapelen   is the available space in the `shape' string, counting
              room for the terminating null.  Up to shapelen-1 "data"
              characters will be assigned to the output string `shape'.
 
   framelen   is the available space in the `frame' string, counting
              room for the terminating null.  Up to framelen-1 "data"
              characters will be assigned to the output string `frame'.

Detailed_Output

 
   shape      is a character string that describes the "shape" of 
              the field of view.  Possible values returned are: 
 
                 "POLYGON"
                 "RECTANGLE"
                 "CIRCLE"
                 "ELLIPSE" 
 
              If the value of `shape' is "POLYGON" the field of view of
              the instrument is a pyramidal polyhedron. The vertex of
              the pyramid is at the instrument focal point. The rays
              along the edges of the pyramid are parallel to the
              vectors returned in `bounds'.
 
              If the value of `shape' is "RECTANGLE" the field of view
              of the instrument is a rectangular pyramid. The vertex of
              the pyramid is at the instrument focal point.  The rays
              along the edges of the pyramid are parallel to the
              vectors returned in `bounds'.  Moreover, in this case,
              the boresight points along the axis of symmetry of the
              rectangular pyramid.
 
              If the value of `shape' is "CIRCLE" the field of view of
              the instrument is a circular cone centered on the
              boresight vector. The vertex of the cone is at the
              instrument focal point. A single vector will be
              returned in `bounds'. This vector will be parallel to a
              ray that lies in the cone that makes up the boundary
              of the field of view.
 
              If the value of `shape' is "ELLIPSE" the field of view of
              the instrument is an elliptical cone with the boresight
              vector as the axis of the cone.  The vertex of the cone
              is at the instrument focal point. Two vectors are
              returned in `bounds'. One of the vectors points to the
              end of the semi-major axis of a perpendicular cross
              section of the elliptic cone.  The other vector points to
              the end of the semi-minor axis of a perpendicular cross
              section of the cone.
 
  
   frame      is the name of the reference frame in which the field of 
              view boundary vectors are defined. 
 
   bsight     is a vector representing the principal instrument view
              direction that can be

                 -  the central pixel view direction,
                 -  the optical axis direction,
                 -  the FOV geometric center view direction,
                 -  an axis of the FOV frame,

              or any other vector specified for this purpose
              in the IK FOV definition. The length of `bsight'
              is not specified other than being non-zero. 
 
   n          is the number of boundary vectors returned. 
 
   bounds     is an array of vectors that point to the "corners" 
              of the instrument field of view.  (See the discussion 
              accompanying `shape' for an expansion of the term 
              "corner of the field of view.")  Note that the vectors 
              returned in `bounds' are not necessarily unit vectors. 
               Their magnitudes will be as set in the IK (for
              'CORNER'-style FOV specifications) or the same as the
              magnitude of the boresight (for 'ANGLES'-style FOV
              specifications.)

Parameters

   MINCOS     This parameter is the lower limit on the value of the
              cosine of the cross or reference angles in the ANGLES
              specification cases (see Particulars for further
              discussion). The parameter and its current value,
              1.0x10^(-15), are employed in the C code derived from the
              Fortran version of GETFOV that this wrapper invokes.

Exceptions

   1) If either the `shape' or `frame' string pointers are null, the 
      error SPICE(NULLPOINTER) is signaled. 

   2) The user must pass values indicating the length of the `shape' 
      and `frame' strings.  If these values are not at least 2, the
      error SPICE(STRINGTOOSHORT) is signaled.

   3) If the `frame' associated with the instrument can not be found,
      the error SPICE(FRAMEMISSING) is signaled.

   4) If the `shape' of the instrument field of view can not be found
      in the kernel pool, the error SPICE(SHAPEMISSING) is signaled
      signaled.

   5) If the `shape' specified by the instrument kernel is not one of
      the four values: "CIRCLE", "POLYGON", "ELLIPSE", or
      "RECTANGLE", the error 'SPICE(SHAPENOTSUPPORTED)' is 
      signaled. If the ANGLES specification is used, `shape' must be
      one of the three values: "CIRCLE", "ELLIPSE", or "RECTANGLE".

   6) If the direction of the boresight cannot be located in the
      kernel pool, the error 'SPICE(BORESIGHTMISSING)' is signaled.

   7) If the number of components for the boresight vector in the
      kernel pool is not 3, the error 'SPICE(BADBORESIGHTSPEC)' is 
      signaled.

   8) If the ANGLES specification is not present in the kernel pool
      and the boundary vectors for the edge of the field of view
      cannot be found in the kernel pool, the error
      'SPICE(BOUNDARYMISSING)' is signaled. 

   9) If there is insufficient room (as specified by the variable
      `room') to return all of the vectors associated with the
      boundary of the field of view, the error
      'SPICE(BOUNDARYTOOBIG)' is signaled.

  10) If the number of components of vectors making up the field of
      view is not a multiple of 3, the error 'SPICE(BADBOUNDARY)' is
      signaled. 

  11) If the number of components of vectors making up the field of
      view is not compatible with the shape specified for the field
      of view, the error 'SPICE(BADBOUNDARY)' is signaled.

  12) If the reference vector for the ANGLES specification can not be
      found in the kernel pool, the error 'SPICE(REFVECTORMISSING)'
      is signaled. 

  13) If the reference vector stored in the kernel pool to support
      the ANGLES specification contains an incorrect number of
      components, contains 3 character components, or is parallel to
      the boresight, the error 'SPICE(BADREFVECTORSPEC)' is signaled.

  14) If the ANGLES specification is present in the kernel pool and
      the reference angle stored in the kernel pool to support the
      ANGLES specification is absent from the kernel pool, the error 
      'SPICE(REFANGLEMISSING)' is signaled.

  15) If the keyword that stores the angular units for the angles
      used in the ANGLES specification is absent from the kernel
      pool, the error 'SPICE(UNITSMISSING)' is signaled.

  16) If the keyword that stores the cross angle for the ANGLES 
      specification is needed and is absent from the kernel pool, the
      error 'SPICE(CROSSANGLEMISSING)' is signaled.

  17) If the angles for the RECTANGLE/ANGLES specification case have
      cosines that are less than those stored in the parameter 
      MICOS, the error 'SPICE(BADBOUNDARY)' is signaled.

  18) If the class specification contains something other than
      'ANGLES' or 'CORNERS', the error 'SPICE(UNSUPPORTEDSPEC)' is
      signaled.

Files

 
   This routine relies upon having successfully loaded an instrument
   kernel (IK-file) via the routine furnsh_c prior to calling this
   routine.
 

Particulars

   This routine provides a common interface for retrieving from the
   kernel pool the geometric characteristics of an instrument field
   of view for a wide variety of remote sensing instruments
   across many different space missions.

   Given the NAIF instrument ID, (and having "loaded" the
   instrument field of view description via the routine furnsh_c)
   this routine returns the boresight of the instrument, the
   "shape" of the field of view, a collection of vectors
   that point along the edges of the field of view, and the
   name of the reference frame in which these vectors are defined.

   Currently this routine supports two classes of specifications
   for FOV definitions: "corners" and "angles".

   The "corners" specification requires that the following keywords
   defining the shape, boresight, boundary vectors, and reference
   frame of the FOV be provided in one of the text kernel files
   (normally an IK file) loaded into the kernel pool (in the
   keywords below <INSTID> is replaced with the instrument ID as
   passed into the module):

      INS<INSTID>_FOV_CLASS_SPEC         must be set to 'CORNERS' or
                                         omitted to indicate the
                                         "corners"-class
                                         specification.

      INS<INSTID>_FOV_SHAPE              must be set to one of these
                                         values:

                                            'CIRCLE'
                                            'ELLIPSE'
                                            'RECTANGLE'
                                            'POLYGON'

      INS<INSTID>_FOV_FRAME              must contain the name of
                                         the frame in which the
                                         boresight and boundary
                                         corner vectors are defined.

      INS<INSTID>_BORESIGHT              must be set to a 3D vector
                                         defining the boresight in
                                         the FOV frame specified in
                                         the FOV_FRAME keyword.

      INS<INSTID>_FOV_BOUNDARY   or      
      INS<INSTID>_FOV_BOUNDARY_CORNERS   must be set to one (for
                                         FOV_SHAPE = 'CIRCLE'), two
                                         (for FOV_SHAPE =
                                         'ELLIPSE'), four (for
                                         FOV_SHAPE = 'RECTANGLE'),
                                         or three or more (for
                                         'POLYGON') 3D vectors
                                         defining the corners of the
                                         FOV in the FOV frame
                                         specified in the FOV_FRAME
                                         keyword. The vectors should
                                         be listed in either
                                         clockwise or 
                                         counterclockwise order.
                                         This is required by some
                                         SPICE routines that make
                                         use of FOV specifications.

   The "angles" specification requires the following keywords
   defining the shape, boresight, reference vector, reference and
   cross angular extents of the FOV be provided in one of the text
   kernel files (normally an IK file) loaded into the kernel
   pool (in the keywords below <INSTID> is replaced with the
   instrument ID as passed into the module):

      INS<INSTID>_FOV_CLASS_SPEC         must be set to  'ANGLES' to
                                         indicate the "angles"-class
                                         specification.

      INS<INSTID>_FOV_SHAPE              must be set to one of these
                                         values:

                                            'CIRCLE'
                                            'ELLIPSE'
                                            'RECTANGLE'

      INS<INSTID>_FOV_FRAME              must contain the name of
                                         the frame in which the 
                                         boresight and the computed
                                         boundary corner vectors are
                                         defined.

      INS<INSTID>_BORESIGHT              must be set to a 3D vector
                                         defining the boresight in
                                         the FOV frame specified in
                                         the FOV_FRAME keyword.

      INS<INSTID>_FOV_REF_VECTOR         must be set to a 3D vector
                                         that together with the
                                         boresight vector defines
                                         the plane in which the
                                         first angular extent of the
                                         FOV specified in the
                                         FOV_REF_ANGLE keyword is
                                         measured.

      INS<INSTID>_FOV_REF_ANGLE          must be set to the angle
                                         that is 1/2 of the total
                                         FOV angular extent in the 
                                         plane defined by the 
                                         boresight and the vector
                                         specified in the
                                         FOV_REF_VECTOR keyword. The
                                         the FOV angular half-extents
                                         are measured from the
                                         boresight vector.

      INS<INSTID>_FOV_CROSS_ANGLE        must be set to the angle
                                         that is 1/2 of the total
                                         FOV angular extent in the
                                         plane containing the
                                         boresight and perpendicular
                                         to the plane defined by the
                                         boresight and the vector
                                         specified in the
                                         FOV_REF_VECTOR keyword. The
                                         the FOV angular half-extents
                                         are measured from the
                                         boresight vector. This
                                         keyword is not required for 
                                         FOV_SHAPE = 'CIRCLE'.

      INS<INSTID>_FOV_ANGLE_UNITS        must specify units for the
                                         angles given in the
                                         FOV_REF_ANGLE and
                                         FOV_CROSS_ANGLE keywords.
                                         Any angular units recognized
                                         by convrt_c are acceptable.

   This routine is intended to be an intermediate level routine.
   It is expected that users of this routine will be familiar
   with the SPICE frames subsystem and will be comfortable writing
   software to further manipulate the vectors retrieved by this
   routine.

Examples

   The numerical results shown for this example may differ across 
   platforms. The results depend on the SPICE kernels used as input, 
   the compiler and supporting libraries, and the machine specific 
   arithmetic implementation.

   The example program in this section loads the IK file
   'example.ti' with the following contents defining four FOVs of
   various shapes and sizes:

      KPL/IK
      
      The keywords below define a circular, 10-degree wide FOV with
      the boresight along the +Z axis of the 'SC999_INST001' frame
      for an instrument with ID -999001 using the "angles"-class
      specification.
      
      \begindata
         INS-999001_FOV_CLASS_SPEC       = 'ANGLES'
         INS-999001_FOV_SHAPE            = 'CIRCLE'
         INS-999001_FOV_FRAME            = 'SC999_INST001'
         INS-999001_BORESIGHT            = ( 0.0, 0.0, 1.0 )
         INS-999001_FOV_REF_VECTOR       = ( 1.0, 0.0, 0.0 )
         INS-999001_FOV_REF_ANGLE        = ( 5.0 )
         INS-999001_FOV_ANGLE_UNITS      = ( 'DEGREES' )
      \begintext
      
      The keywords below define an elliptical FOV with 2- and
      4-degree angular extents in the XZ and XY planes and the
      boresight along the +X axis of the 'SC999_INST002' frame for
      an instrument with ID -999002 using the "corners"-class
      specification.
      
      \begindata
         INS-999002_FOV_SHAPE            = 'ELLIPSE'
         INS-999002_FOV_FRAME            = 'SC999_INST002'
         INS-999002_BORESIGHT            = ( 1.0, 0.0, 0.0 )
         INS-999002_FOV_BOUNDARY_CORNERS = ( 1.0, 0.0, 0.01745506,
                                             1.0, 0.03492077, 0.0 )
      \begintext
      
      The keywords below define a rectangular FOV with 1.2- and
      0.2-degree angular extents in the ZX and ZY planes and the
      boresight along the +Z axis of the 'SC999_INST003' frame for
      an instrument with ID -999003 using the "angles"-class
      specification.
      
      \begindata
         INS-999003_FOV_CLASS_SPEC       = 'ANGLES'
         INS-999003_FOV_SHAPE            = 'RECTANGLE'
         INS-999003_FOV_FRAME            = 'SC999_INST003'
         INS-999003_BORESIGHT            = ( 0.0, 0.0, 1.0 )
         INS-999003_FOV_REF_VECTOR       = ( 1.0, 0.0, 0.0 )
         INS-999003_FOV_REF_ANGLE        = ( 0.6 )
         INS-999003_FOV_CROSS_ANGLE      = ( 0.1 )
         INS-999003_FOV_ANGLE_UNITS      = ( 'DEGREES' )
      \begintext
      
      The keywords below define a triangular FOV with the boresight
      along the +Y axis of the 'SC999_INST004' frame for an
      instrument with ID -999004 using the "corners"-class
      specification.
      
      \begindata
         INS-999004_FOV_SHAPE            = 'POLYGON'
         INS-999004_FOV_FRAME            = 'SC999_INST004'
         INS-999004_BORESIGHT            = (  0.0,  1.0,  0.0 )
         INS-999004_FOV_BOUNDARY_CORNERS = (  0.0,  0.8,  0.5,
                                              0.4,  0.8, -0.2,
                                             -0.4,  0.8, -0.2 )
      \begintext

   The program shown below loads the IK, fetches parameters for each
   of the four FOVs and prints these parameters to the screen.

      #include <stdio.h>
      #include "SpiceUsr.h"

      #define      MAXBND            4
      #define      NUMINS            4
      #define      WDSIZE            32

      int main (void)
      {

         SpiceChar    frame  [WDSIZE];
         SpiceChar    shape  [WDSIZE];

         SpiceDouble  bounds [MAXBND][3];
         SpiceDouble  bsight [3]; 

         SpiceInt     i; 
         SpiceInt     insids [NUMINS] = 
                          { -999001, -999002, -999003, -999004}; 
         SpiceInt     j; 
         SpiceInt     n; 

         furnsh_c( "example.ti" );

         printf( "--------------------------------------\n" );
         for ( i = 0; i < NUMINS; i++ ) {

            getfov_c ( insids[i], MAXBND, WDSIZE, WDSIZE, 
                       shape, frame, bsight, &n, bounds );

            printf( "Instrument ID: %d\n", insids[i] );
            printf( "    FOV shape: %s\n",  shape     );
            printf( "    FOV frame: %s\n",  frame     );
            printf( "FOV boresight: %9.6f %9.6f %f9.6\n", 
                      bsight[0], bsight[1], bsight[2] );
            printf( "  FOV corners: \n" );
            for ( j = 0; j < n; j++ ) {
               printf( "               %9.6f %9.6f %9.6f\n", 
                       bounds[j][0], bounds[j][1], bounds[j][2] );
            }      
            printf( "--------------------------------------\n" );
         }
         return(0);
      }

   The program produces the following output:

      --------------------------------------
      Instrument ID: -999001
          FOV shape: CIRCLE
          FOV frame: SC999_INST001
      FOV boresight:  0.000000  0.000000  1.000000
        FOV corners:
                      0.087156  0.000000  0.996195
      --------------------------------------
      Instrument ID: -999002
          FOV shape: ELLIPSE
          FOV frame: SC999_INST002
      FOV boresight:  1.000000  0.000000  0.000000
        FOV corners:
                      1.000000  0.000000  0.017455
                      1.000000  0.034921  0.000000
      --------------------------------------
      Instrument ID: -999003
          FOV shape: RECTANGLE
          FOV frame: SC999_INST003
      FOV boresight:  0.000000  0.000000  1.000000
        FOV corners:
                      0.010472  0.001745  0.999944
                     -0.010472  0.001745  0.999944
                     -0.010472 -0.001745  0.999944
                      0.010472 -0.001745  0.999944
      --------------------------------------
      Instrument ID: -999004
          FOV shape: POLYGON
          FOV frame: SC999_INST004
      FOV boresight:  0.000000  1.000000  0.000000
        FOV corners:
                      0.000000  0.800000  0.500000
                      0.400000  0.800000 -0.200000
                     -0.400000  0.800000 -0.200000
      --------------------------------------
 

Restrictions

 
   This function will not operate unless an I-kernel for the 
   instrument with the NAIF ID specified in INSTID have been
   loaded via a call to FURNSH prior to calling this routine and
   this IK contains the specification for the instrument field of 
   view consistent with the expectations of this routine.
 

Literature_References

 
   None. 
 

Author_and_Institution

 
   C.H. Acton      (JPL)
   N.J. Bachman    (JPL)
   J. Diaz del Rio (ODC Space)
   B.V. Semenov    (JPL) 
   W.L. Taber      (JPL) 
   F.S. Turner     (JPL)
 

Version

   -CSPICE Version 1.0.6, 22-MAR-2017 (JDR) (BVS)
   
      Header updates: made various header changes to make it 
      compliant with the SPICE standard header format; updated 
      BSIGHT description; added explanation of output boundary 
      vector magnitudes; made other minor header corrections.
      
      Added call to return_c as part of the error tracing.
      
   -CSPICE Version 1.0.5, 05-FEB-2009 (BVS)

      Header update: added information about required IK keywords;
      replaced old example with a new one more focused on getfov_c and
      IK keywords.

   -CSPICE Version 1.0.4, 27-OCT-2005 (NJB)

      Header update:  replaced reference to bodvar_c with 
      reference to bodvcd_c.

   -CSPICE Version 1.0.3, 28-DEC-2004 (BVS)

      Fixed typo in the header example.

   -CSPICE Version 1.0.2, 29-JUL-2003 (NJB) (CHA)

      Various header changes were made to improve clarity.  Some
      minor header corrections were made.

   -CSPICE Version 1.0.1, 18-DEC-2001 (FST)

      Updated the header of this wrapper to document the changes
      in GETFOV regarding the addition of support for the ANGLES
      specification.
 
   -CSPICE Version 1.0.0, 13-APR-2000 (FST)

Index_Entries

 
   return instrument's FOV parameters 
 
Wed Apr  5 17:54:35 2017