Index Page
pjelpl_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 pjelpl_c ( ConstSpiceEllipse  * elin,
                   ConstSpicePlane    * plane,
                   SpiceEllipse       * elout  ) 

Abstract

 
   Project an ellipse onto a plane, orthogonally. 
 

Required_Reading

 
   ELLIPSES 
   PLANES 
 

Keywords

 
   ELLIPSE 
   GEOMETRY 
   MATH 
 

Brief_I/O

 
   Variable  I/O  Description 
   --------  ---  -------------------------------------------------- 
   elin       I   A CSPICE ellipse to be projected. 
   plane      I   A plane onto which elin is to be projected. 
   elout      O   A CSPICE ellipse resulting from the projection. 
 

Detailed_Input

 
   elin, 
   plane          are, respectively, a cspice ellipse and a 
                  cspice plane.  The geometric ellipse represented 
                  by elin is to be orthogonally projected onto the 
                  geometric plane represented by plane. 
 

Detailed_Output

 
   elout          is a cspice ellipse that represents the geometric 
                  ellipse resulting from orthogonally projecting the 
                  ellipse represented by inel onto the plane 
                  represented by plane. 
 

Parameters

 
   None. 
 

Exceptions

 
   1)  If the input plane is invalid, the error will be diagnosed 
       by routines called by this routine. 
 
   2)  The input ellipse may be degenerate--its semi-axes may be 
       linearly dependent.  Such ellipses are allowed as inputs. 
 
   3)  The ellipse resulting from orthogonally projecting the input 
       ellipse onto a plane may be degenerate, even if the input 
       ellipse is not. 
 

Files

 
   None. 
 

Particulars

 
   Projecting an ellipse orthogonally onto a plane can be thought of 
   finding the points on the plane that are `under' or `over' the 
   ellipse, with the `up' direction considered to be perpendicular 
   to the plane.  More mathematically, the orthogonal projection is 
   the set of points Y in the plane such that for some point X in 
   the ellipse, the vector Y - X is perpendicular to the plane. 
   The orthogonal projection of an ellipse onto a plane yields 
   another ellipse. 
 

Examples

 
   1)  With  center  = { 1.,  1.,  1. }, 
             vect1   = { 2.,  0.,  0. }, 
             vect2   = { 0.,  1.,  1. }, 
             normal  = { 0.,  0.,  1. }
 
       the code fragment 
 
             nvc2pl_c ( normal,  0.,      plane           ); 
             cgv2el_c ( center,  vect1,   vect2,   elin   ); 
             pjelpl_c ( elin,    plane,   elout           ); 
             el2cgv_c ( elout,   prjctr,  prjmaj,  prjmin ); 
 
       returns 
 
             prjctr  = { 1.,  1.,  0. },
             prjmaj  = { 2.,  0.,  0. },
             prjmin  = { 0.,  1.,  0. } 
 
 
   2)  With  vect1   = { 2.,  0.,  0. },
             vect2   = { 1.,  1.,  1. }, 
             center  = { 0.,  0.,  0. }, 
             normal  = { 0.,  0.,  1. }, 
 
       the code fragment 
 
             nvc2pl_c ( normal,  0.,      plane           ); 
             cgv2el_c ( center,  vect1,   vect2,   elin   ); 
             pjelpl_c ( elin,    plane,   elout           ); 
             el2cgv_c ( elout,   prjctr,  prjmaj,  prjmin ); 
 
       returns 
 
             prjctr  = { 0.,  0.,  0. };
 
             prjmaj  = { -2.227032728823213, 
                         -5.257311121191336e-1, 
                          0.                  };
 
             prjmin  = {  2.008114158862273e-1, 
                         -8.506508083520399e-1, 
                          0.                  };
 
 
 
   3)    An example of actual use:   Suppose we wish to compute the 
         distance from an ellipsoid to a line.   Let the line be 
         defined by a point P and a direction vector DIRECT; the 
         line is the set of points 
 
            P   +   t * DIRECT, 
 
         where t is any real number.  Let the ellipsoid have semi- 
         axis lengths A, B, and C. 
 
         We can reduce the problem to that of finding the distance 
         between the line and an ellipse on the ellipsoid surface by 
         considering the fact that the surface normal at the nearest 
         point to the line will be orthogonal to DIRECT; the set of 
         surface points where this condition holds lies in a plane, 
         and hence is an ellipse on the surface.  The problem can be 
         further simplified by projecting the ellipse orthogonally 
         onto the plane defined by 
 
            < X, DIRECT >  =  0. 
 
         The problem is then a two dimensional one:  find the 
         distance of the projected ellipse from the intersection of 
         the line and this plane (which is necessarily one point). 
         A `paraphrase' of the relevant code is: 
 
            #include "SpiceUsr.h"
                 .
                 .
                 .
            /.
            Step 1.   Find the candidate ellipse cand. 
                      normal is a normal vector to the plane 
                      containing the candidate ellipse.  The 
                      ellipse must exist, since it's the 
                      intersection of an ellipsoid centered at 
                      the origin and a plane containing the 
                      origin.  For this reason, we don't check 
                      inedpl_c's "found flag" found below. 
            ./
            
            normal[0]  =  direct[0] / (a*a); 
            normal[1]  =  direct[1] / (b*b);
            normal[2]  =  direct[2] / (c*c);

            nvc2pl_c ( normal, 0., &candpl );

            inedpl_c ( a, b, c, &candpl, cand, &found );
 
 
            /.
            Step 2.   Project the candidate ellipse onto a 
                      plane orthogonal to the line.  We'll 
                      call the plane prjpl and the 
                      projected ellipse prjel. 
            ./ 
            nvc2pl_c ( direct,  0.,     &prjpl ); 
            pjelpl_c ( &cand,   &prjpl, &prjel );
 
 
            /.
            Step 3.   Find the point on the line lying in the 
                      projection plane, and then find the 
                      near point pjnear on the projected 
                      ellipse.  Here prjpt is the point on the 
                      input line that lies in the projection 
                      plane.  The distance between prjpt and 
                      pjnear is dist. 
            ./
            
            vprjp_c  ( linept,  &prjpl,  prjpt          );
            npelpt_c ( &prjel,   prjpt,  pjnear,  &dist );
 
              
            /.
            Step 4.  Find the near point pnear on the 
                     ellipsoid by taking the inverse 
                     orthogonal projection of PJNEAR; this is 
                     the point on the candidate ellipse that 
                     projects to pjnear.  Note that the output 
                     dist was computed in step 3. 
        
                     The inverse projection of pjnear is 
                     guaranteed to exist, so we don't have to 
                     check found. 
            ./
            vprjpi_c ( pjnear, &prjpl, &candpl, pnear, &found ); 
 
  
            /.
            The value of dist returned is the distance we're looking 
            for. 
 
            The procedure described here is carried out in the routine 
            npedln_c. 
            ./
            
 

Restrictions

 
   None. 
 

Literature_References

 
   None. 
 

Author_and_Institution

 
   N.J. Bachman   (JPL) 
 

Version

 
   -CSPICE Version 1.0.0, 02-SEP-1999 (NJB)

Index_Entries

 
   project ellipse onto plane 
 
Wed Apr  5 17:54:40 2017