BaseSRF.h

Go to the documentation of this file.

// SRM SDK Release 4.4.0 - December 7, 2009

// - SRM spec. 4.4

/*
 *                             NOTICE
 * 
 * This software is provided openly and freely for use in representing and
 * interchanging environmental data & databases.
 * 
 * This software was developed for use by the United States Government with
 * unlimited rights.  The software was developed under contract
 * DASG60-02-D-0006 TO-193 by Science Applications International Corporation.
 * The software is unclassified and is deemed as Distribution A, approved
 * for Public Release.
 * 
 * Use by others is permitted only upon the ACCEPTANCE OF THE TERMS AND
 * CONDITIONS, AS STIPULATED UNDER THE FOLLOWING PROVISIONS:
 * 
 *    1. Recipient may make unlimited copies of this software and give
 *       copies to other persons or entities as long as the copies contain
 *       this NOTICE, and as long as the same copyright notices that
 *       appear on, or in, this software remain.
 * 
 *    2. Trademarks. All trademarks belong to their respective trademark
 *       holders.  Third-Party applications/software/information are
 *       copyrighted by their respective owners.
 * 
 *    3. Recipient agrees to forfeit all intellectual property and
 *       ownership rights for any version created from the modification
 *       or adaptation of this software, including versions created from
 *       the translation and/or reverse engineering of the software design.
 * 
 *    4. Transfer.  Recipient may not sell, rent, lease, or sublicense
 *       this software.  Recipient may, however enable another person
 *       or entity the rights to use this software, provided that this
 *       AGREEMENT and NOTICE is furnished along with the software and
 *       /or software system utilizing this software.
 * 
 *       All revisions, modifications, created by the Recipient, to this
 *       software and/or related technical data shall be forwarded by the
 *       Recipient to the Government at the following address:
 * 
 *         SMDC
 *         Attention SEDRIS (TO193) TPOC
 *         P.O. Box 1500
 *         Hunstville, AL  35807-3801
 * 
 *         or via electronic mail to:  [email protected]
 * 
 *    5. No Warranty. This software is being delivered to you AS IS
 *       and there is no warranty, EXPRESS or IMPLIED, as to its use
 *       or performance.
 * 
 *       The RECIPIENT ASSUMES ALL RISKS, KNOWN AND UNKNOWN, OF USING
 *       THIS SOFTWARE.  The DEVELOPER EXPRESSLY DISCLAIMS, and the
 *       RECIPIENT WAIVES, ANY and ALL PERFORMANCE OR RESULTS YOU MAY
 *       OBTAIN BY USING THIS SOFTWARE OR DOCUMENTATION.  THERE IS
 *       NO WARRANTY, EXPRESS OR, IMPLIED, AS TO NON-INFRINGEMENT OF
 *       THIRD PARTY RIGHTS, MERCHANTABILITY, OR FITNESS FOR ANY
 *       PARTICULAR PURPOSE.  IN NO EVENT WILL THE DEVELOPER, THE
 *       UNITED STATES GOVERNMENT OR ANYONE ELSE ASSOCIATED WITH THE
 *       DEVELOPMENT OF THIS SOFTWARE BE HELD LIABLE FOR ANY CONSEQUENTIAL,
 *       INCIDENTAL OR SPECIAL DAMAGES, INCLUDING ANY LOST PROFITS
 *       OR LOST SAVINGS WHATSOEVER.
 */

// SRM_OTHERS_GOES_HERE

// $Id: BaseSRF.h,v 1.63 2009/11/05 21:17:12 worleym Exp $

#ifndef _BaseSRF_h
#define _BaseSRF_h

#if !defined(_WIN32)
#define EXPORT_SRM_CPP_DLL
#elif defined(BUILD_SRM_CPP) /* SRM CPP Case */
#if !defined(EXPORT_SRM_CPP_DLL)
#if defined(_LIB)
#define EXPORT_SRM_CPP_DLL
#elif defined(_USRDLL)
#define EXPORT_SRM_CPP_DLL __declspec(dllexport)
#else
#define EXPORT_SRM_CPP_DLL __declspec(dllimport)
#endif
#endif
#else /* SRM C Case */
#define EXPORT_SRM_CPP_DLL
#endif /* _WIN32 && EXPORT_DLL */

#include "srm_types.h"

// global variable - controls whether SRF cache is used to speed
// up coordinate conversion operations
extern bool g_fast_mode;

namespace srm
{

class Coord;
class Coord2D;
class CoordSurf;
class Coord3D;
class Direction;
class Orientation;
class SRF_LocalTangentSpaceEuclidean;
class SRF_LococentricEuclidean3D;

class EXPORT_SRM_CPP_DLL BaseSRF
{
public:

    enum SRF_ClassType
    {
        SRF_TYP_TWO_D,
        SRF_TYP_THREE_D,
        SRF_TYP_WITH_TANGENT_PLANE_SURFACE,
        SRF_TYP_WITH_ELLIPSOIDAL_HEIGHT,
        SRF_TYP_MAP_PROJECTION,
        SRF_TYP_LSA,
        SRF_TYP_CC,
        SRF_TYP_CD,
        SRF_TYP_CM,
        SRF_TYP_EC,
        SRF_TYP_EI,
        SRF_TYP_HAEC,
        SRF_TYP_HEEC,
        SRF_TYP_HEEQ,
        SRF_TYP_LCC,
        SRF_TYP_LCE_3D,
        SRF_TYP_LSR_2D,
        SRF_TYP_LSR_3D,
        SRF_TYP_LTSAS,
        SRF_TYP_LTSC,
        SRF_TYP_LTSE,
        SRF_TYP_M,
        SRF_TYP_OMS,
        SRF_TYP_PD,
        SRF_TYP_LSP,
        SRF_TYP_PS,
        SRF_TYP_SEC,
        SRF_TYP_SEQ,
        SRF_TYP_SME,
        SRF_TYP_SMD,
        SRF_TYP_TM
    };

    static BaseSRF *createStandardSRF( SRM_SRF_Code srf_code,
                                       SRM_RT_Code rt_code );

    static BaseSRF *createSRFSetMember( SRM_SRFS_Info srfs_info,
                                        SRM_RT_Code rt );

    virtual void release();

    virtual void getCodes( SRM_SRFT_Code &t_code,
                           SRM_SRF_Code  &srf_code,
                           SRM_SRFS_Code_Info  &srfs_code_info ) const;

    virtual SRM_CS_Code getCSCode() const;

    virtual SRM_ORM_Code get_orm() const;

    virtual SRM_ORM_Code getOrm() const;

    virtual SRM_RT_Code get_rt() const;

    virtual SRM_RT_Code getRt() const;

    virtual SRM_Long_Float getA() const;

    virtual SRM_Long_Float getF() const;

    static bool querySRFTSupport( SRM_SRFT_Code srft_code );

    static bool queryORMSupport( SRM_ORM_Code orm_code,
                                 SRM_RT_Code rt_code );

    virtual SRF_ClassType getClassType() const = 0;

    virtual bool isA( SRF_ClassType type ) const;

    virtual SRM_Coordinate_Valid_Region changeCoordinateSRF( const Coord &src_coord, Coord &des_coord );

    virtual SRM_Coordinate_Valid_Region checkCoordinate( const Coord &src );

    virtual void freeCoordinate( Coord *coord );

    static SRM_Long_Float calculateEuclideanDistance( const Coord &coord1,
                                                      const Coord &coord2 );

    void setCoordinateValidationOn();

    void setCoordinateValidationOff();

    bool coordinateValidationIsOn();

    virtual const char *toString() = 0;

    virtual BaseSRF *clone();

    SRM_Integer getId() const
    {
        return _id;
    }

protected:
    friend class Coord3D;

    BaseSRF( void *impl ); 
    BaseSRF &operator =( const BaseSRF & ) { return *this; } 
    virtual ~BaseSRF() {} 

    unsigned int _ref_cnt;
    SRM_Integer _id;
    void *_impl, *_cache;
    bool _validate_coords;

    void *getImpl() const { return _impl; }
};


inline BaseSRF *BaseSRF::clone()
{
    ++_ref_cnt;
    return this;
}

inline bool BaseSRF::isA( SRF_ClassType type ) const
{
    return false;
}


class EXPORT_SRM_CPP_DLL BaseSRF_2D : public BaseSRF
{
public:

    virtual bool isA( SRF_ClassType type ) const;

    virtual Coord2D *createCoordinate2D( SRM_Long_Float coord_comp1,
                                         SRM_Long_Float coord_comp2 ) = 0;

    virtual void getCoordinate2DValues( const Coord2D &coord,
                                        SRM_Long_Float &coord_comp1,
                                        SRM_Long_Float &coord_comp2 ) const;

    virtual void freeCoordinate2D( Coord2D *coord );

    virtual void changeCoordinate2DSRF( const Coord2D &src_coord,
                                              Coord2D &des_coord );

    virtual void changeCoordinate2DArraySRF( Coord2D                     **src_coord_array,
                                             SRM_Integer_Positive        *index,
                                             Coord2D                     **des_coord_array );

    virtual void changeCoordinate2DSRFObject( const Coord2D                              &src_coord,
                                              const SRM_ORM_Transformation_2D_Parameters hst,
                                                    Coord2D                              &des_coord );

    virtual void changeCoordinate2DArraySRFObject( Coord2D                                    **src_coord_array,
                                                   const SRM_ORM_Transformation_2D_Parameters hst,
                                                   SRM_Integer_Positive                       *index,
                                                   Coord2D                                    **des_coord_array );


    static SRM_Long_Float calculateEuclideanDistance( const Coord2D &coord1,
                                                      const Coord2D &coord2 );

protected:
    BaseSRF_2D( void *impl ) : BaseSRF(impl) {} 
    BaseSRF_2D &operator =( const BaseSRF_2D & ) { return *this; } 
    virtual ~BaseSRF_2D() {} 
};


inline bool BaseSRF_2D::isA( SRF_ClassType type ) const
{
    if (type == BaseSRF::SRF_TYP_TWO_D)
        return true;
    else
        return BaseSRF::isA(type);
}


class EXPORT_SRM_CPP_DLL BaseSRF_3D : public BaseSRF
{
public:

    virtual bool isA( SRF_ClassType type ) const;

    virtual Coord3D *createCoordinate3D( SRM_Long_Float coord_comp1,
                                         SRM_Long_Float coord_comp2,
                                         SRM_Long_Float coord_comp3 ) = 0;

    virtual void freeCoordinate3D( Coord3D *coord );

    virtual void getCoordinate3DValues( const Coord3D &coord,
                                        SRM_Long_Float &coord_comp1,
                                        SRM_Long_Float &coord_comp2,
                                        SRM_Long_Float &coord_comp3 ) const;

    virtual SRM_Coordinate_Valid_Region changeCoordinate3DSRF( const Coord3D &src_coord,
                                                                     Coord3D &des_coord );

    virtual void changeCoordinate3DArraySRF( Coord3D                                    **src_coord_array,
                                             SRM_Integer_Positive                       *index,
                                             Coord3D                                    **des_coord_array,
                                             SRM_Coordinate_Valid_Region                *region_array );

    virtual SRM_Coordinate_Valid_Region changeCoordinate3DSRFObject( const Coord3D &src_coord,
                                                                     const SRM_ORM_Transformation_3D_Parameters hst,
                                                                           Coord3D &des_coord );

    virtual void changeCoordinate3DArraySRFObject( Coord3D                                    **src_coord_array,
                                                   const SRM_ORM_Transformation_3D_Parameters hst,
                                                   SRM_Integer_Positive                       *index,
                                                   Coord3D                                    **des_coord_array,
                                                   SRM_Coordinate_Valid_Region                *region_array );

    virtual void setValidRegion( const SRM_Integer component,
                                 const SRM_Interval_Type type,
                                 const SRM_Long_Float lower,
                                 const SRM_Long_Float upper );

    virtual void setExtendedValidRegion( const SRM_Integer component,
                                         const SRM_Interval_Type type,
                                         const SRM_Long_Float extended_lower,
                                         const SRM_Long_Float lower,
                                         const SRM_Long_Float upper,
                                         const SRM_Long_Float extended_upper );

    virtual void getValidRegion( const SRM_Integer component,
                                       SRM_Interval_Type &type,
                                       SRM_Long_Float &lower,
                                       SRM_Long_Float &upper );

    virtual void getExtendedValidRegion( const SRM_Integer component,
                                               SRM_Interval_Type &type,
                                               SRM_Long_Float &extended_lower,
                                               SRM_Long_Float &lower,
                                               SRM_Long_Float &upper,
                                               SRM_Long_Float &extended_upper );

    virtual Direction *createDirection( const Coord3D &ref_coord,
                                        const SRM_Vector_3D vec );

    virtual Direction *createDirection( const Coord3D &ref_coord,
                                        const SRM_Long_Float vectorComp1,
                                        const SRM_Long_Float vectorComp2,
                                        const SRM_Long_Float vectorComp3 );

    virtual Direction *createDirection();


    virtual void freeDirection( Direction *direction );

    virtual void getDirectionValues( const Direction &direction,
                                     Coord3D &ref_coord,
                                     SRM_Vector_3D vec ) const;

    virtual SRM_Coordinate_Valid_Region changeDirectionSRF( const Direction &src_dir, Direction &des_dir );

    void changeDirectionArraySRF( Direction                   **src_direction_array,
                                  SRM_Integer_Positive        *index,
                                  Direction                   **des_direction_array,
                                  SRM_Coordinate_Valid_Region *region_array );

    virtual SRM_Coordinate_Valid_Region changeDirectionSRFObject
    (
        const Direction                            &src_dir,
        const SRM_ORM_Transformation_3D_Parameters  hst,
              Direction                            &des_dir
    );

    void changeDirectionArraySRFObject
    (
              Direction                            **src_direction_array,
        const SRM_ORM_Transformation_3D_Parameters   hst,
              SRM_Integer_Positive                  *index,
              Direction                            **des_direction_array,
              SRM_Coordinate_Valid_Region           *region_array
    );

    virtual SRM_Coordinate_Valid_Region checkDirection( const Direction &direction );

    void computeSRFOrientation( const Coord3D &src_ref_loc,
                                const Coord3D &tgt_ref_loc,
                                Orientation &out_ori );

    void getLocalTangentFrameSRFParameters ( const Coord3D &ref_loc,
                                             SRM_LCE_3D_Parameters &ltf );


    virtual SRF_LococentricEuclidean3D
       *createLococentricEuclidean3DSRF ( const Coord3D &lococentre,
                                          const Direction &primary_axis,
                                          const Direction &secondary_axis );


    void transformOrientation(const Coord3D     &src_ref_loc,
                                    Orientation &src_ori,
                              const Coord3D     &tgt_ref_loc,
                                    Orientation &tgt_ori );

    SRM_Coordinate_Valid_Region transformOrientationCommonOrigin
                (const Coord3D     &src_ref_loc,
                       Orientation &src_ori,
                       Coord3D     &tgt_ref_loc,
                       Orientation &tgt_ori );

    void transformVectorInBodyFrame( const Coord3D       &src_ref_loc,
                                           Orientation   &src_ori,
                                     const SRM_Vector_3D &input_vec,
                                     const Coord3D       &tgt_ref_loc,
                                           SRM_Vector_3D &tgt_vec );

    SRM_Coordinate_Valid_Region transformVectorInBodyFrameCommonOrigin
                (const Coord3D       &src_ref_loc,
                       Orientation   &src_ori,
                 const SRM_Vector_3D &input_vec,
                       Coord3D       &tgt_ref_loc,
                       SRM_Vector_3D &tgt_vec );

    void transformVector(const Coord3D       &src_ref_loc,
                         const SRM_Vector_3D &src_vec,
                         const Coord3D       &tgt_ref_loc,
                               SRM_Vector_3D &tgt_vec );

    SRM_Coordinate_Valid_Region transformVectorCommonOrigin
                (const Coord3D       &src_ref_loc,
                 const SRM_Vector_3D &src_vec,
                       Coord3D       &tgt_ref_loc,
                       SRM_Vector_3D &tgt_vec );

    static SRM_SRFS_Code_Info getNaturalSRFSetMemberCode(const Coord3D &src_coord,
                                                               SRM_ORM_Code  orm_dst,
                                                               SRM_RT_Code   rt_dst,
                                                               SRM_SRFS_Code tgt_srfs);

    static BaseSRF_3D* getNaturalSRFSetMember( Coord3D &src_coord,
                                               SRM_ORM_Code orm_dst,
                                               SRM_RT_Code rt_dst,
                                               SRM_SRFS_Code tgt_srfs);

    static SRM_Long_Float calculateEuclideanDistance( const Coord3D &coord1,
                                                      const Coord3D &coord2 );

protected:
    BaseSRF_3D( void *impl ) : BaseSRF(impl) {} 
    BaseSRF_3D &operator =( const BaseSRF_3D & ) { return *this; } 
    virtual ~BaseSRF_3D() {} 
};


inline bool BaseSRF_3D::isA( SRF_ClassType type ) const
{
    if (type == BaseSRF::SRF_TYP_THREE_D)
        return true;
    else
        return BaseSRF::isA(type);
}


class EXPORT_SRM_CPP_DLL BaseSRF_WithTangentPlaneSurface : public BaseSRF_3D
{
public:

    virtual bool isA( SRF_ClassType type ) const;

    virtual CoordSurf *createSurfaceCoordinate( SRM_Long_Float coord_surf_comp1,
                                                SRM_Long_Float coord_surf_comp2 ) = 0;

    virtual void getSurfaceCoordinateValues( const CoordSurf &coord_surf,
                                             SRM_Long_Float &coord_surf_comp1,
                                             SRM_Long_Float &coord_surf_comp2 ) const;

    virtual void freeSurfaceCoordinate( CoordSurf *coord_surf );

    virtual void getAssociatedSurfaceCoordinate( const Coord3D &coord,
                                                 CoordSurf &on_surface_coord );

    virtual void getPromotedSurfaceCoordinate( const CoordSurf &surf_coord,
                                               Coord3D &three_d_coord );

    static SRM_Long_Float calculateEuclideanDistance( const CoordSurf &coord1,
                                                      const CoordSurf &coord2 );

protected:
    BaseSRF_WithTangentPlaneSurface( void *impl ) : BaseSRF_3D(impl) {} 
    BaseSRF_WithTangentPlaneSurface &operator =( const BaseSRF_WithTangentPlaneSurface & ) { return *this; } 
    virtual ~BaseSRF_WithTangentPlaneSurface() {} 
};


inline bool BaseSRF_WithTangentPlaneSurface::isA( SRF_ClassType type ) const
{
    if (type == BaseSRF::SRF_TYP_WITH_TANGENT_PLANE_SURFACE)
        return true;
    else
        return BaseSRF_3D::isA(type);
}


class EXPORT_SRM_CPP_DLL BaseSRF_WithEllipsoidalHeight : public BaseSRF_3D
{
public:

    virtual bool isA( SRF_ClassType type ) const;

    virtual CoordSurf *createSurfaceCoordinate( SRM_Long_Float coord_surf_comp1,
                                                SRM_Long_Float coord_surf_comp2 ) = 0;

    virtual void getSurfaceCoordinateValues( const CoordSurf &coord_surf,
                                             SRM_Long_Float &coord_surf_comp1,
                                             SRM_Long_Float &coord_surf_comp2 ) const;

    virtual void freeSurfaceCoordinate( CoordSurf *coord_surf );

    virtual void getAssociatedSurfaceCoordinate( const Coord3D &coord,
                                                 CoordSurf &on_surface_coord );

    virtual void getPromotedSurfaceCoordinate( const CoordSurf &surf_coord,
                                               Coord3D &three_d_coord );

    virtual SRF_LocalTangentSpaceEuclidean
      *createLocalTangentSpaceEuclideanSRF(
                                           const CoordSurf &surf_coord,
                                           SRM_Long_Float azimuth,
                                           SRM_Long_Float false_x_origin,
                                           SRM_Long_Float false_y_origin,
                                           SRM_Long_Float offset_height );

    static SRM_SRFS_Code_Info getNaturalSRFSetMemberCode( CoordSurf &src_coord,
                                                          SRM_ORM_Code orm_dst,
                                                          SRM_RT_Code rt_dst,
                                                          SRM_SRFS_Code tgt_srfs);


    static BaseSRF_3D* getNaturalSRFSetMember( CoordSurf &src_coord,
                                               SRM_ORM_Code orm_dst,
                                               SRM_RT_Code rt_dst,
                                               SRM_SRFS_Code tgt_srfs);

    static SRM_Long_Float calculateEuclideanDistance( const CoordSurf &coord1,
                                                      const CoordSurf &coord2 );

    static SRM_Long_Float calculateGeodesicDistance( const CoordSurf &src_coord,
                                                     const CoordSurf &des_coord );

    virtual SRM_Long_Float calculateVerticalSeparationOffset( SRM_DSS_Code vos,
                                                              const CoordSurf &surf_coord );

protected:
    BaseSRF_WithEllipsoidalHeight( void *impl ) : BaseSRF_3D(impl) {} 
    BaseSRF_WithEllipsoidalHeight &operator =( const BaseSRF_WithEllipsoidalHeight & ) { return *this; } 
    virtual ~BaseSRF_WithEllipsoidalHeight() {} 
};


inline bool BaseSRF_WithEllipsoidalHeight::isA( SRF_ClassType type ) const
{
    if (type == BaseSRF::SRF_TYP_WITH_ELLIPSOIDAL_HEIGHT)
        return true;
    else
        return BaseSRF_3D::isA(type);
}


class EXPORT_SRM_CPP_DLL BaseSRF_MapProjection : public BaseSRF_WithEllipsoidalHeight
{
public:

    virtual bool isA( SRF_ClassType type ) const;

    virtual void setValidGeodeticRegion( const SRM_Integer component,
                                         const SRM_Interval_Type type,
                                         const SRM_Long_Float lower,
                                         const SRM_Long_Float upper );

    virtual void setExtendedValidGeodeticRegion( const SRM_Integer component,
                                                 const SRM_Interval_Type type,
                                                 const SRM_Long_Float extended_lower,
                                                 const SRM_Long_Float lower,
                                                 const SRM_Long_Float upper,
                                                 const SRM_Long_Float extended_upper );

    virtual void getValidGeodeticRegion( const SRM_Integer component,
                                         SRM_Interval_Type &type,
                                         SRM_Long_Float &lower,
                                         SRM_Long_Float &upper );

    virtual void getExtendedValidGeodeticRegion( const SRM_Integer component,
                                                 SRM_Interval_Type &type,
                                                 SRM_Long_Float &extended_lower,
                                                 SRM_Long_Float &lower,
                                                 SRM_Long_Float &upper,
                                                 SRM_Long_Float &extended_upper );

    virtual SRM_Long_Float calculateConvergenceOfTheMeridian( const CoordSurf &surf_coord );

    virtual SRM_Long_Float calculatePointDistortion( const CoordSurf &surf_coord );

    virtual SRM_Long_Float calculateMapAzimuth( const CoordSurf &src_coord,
                                                const CoordSurf &des_coord );

protected:
    BaseSRF_MapProjection( void *impl ) : BaseSRF_WithEllipsoidalHeight(impl) {} 
    BaseSRF_MapProjection &operator =( const BaseSRF_MapProjection & ) { return *this; } 
    virtual ~BaseSRF_MapProjection() {} 
};


inline bool BaseSRF_MapProjection::isA( SRF_ClassType type ) const
{
    if (type == BaseSRF::SRF_TYP_MAP_PROJECTION)
        return true;
    else
        return BaseSRF_WithEllipsoidalHeight::isA(type);
}

} // namespace srm

#endif // _BaseSRF_h

---

Spatial Reference Model C++ API	Version 4.4 - December 7, 2009
Copyright © 2009 SEDRIS™	Docs by Doxygen 1.3.2