Changeset 18693 for trunk/ossim


Ignore:
Timestamp:
Jan 17, 2011 10:49:15 AM (6 years ago)
Author:
dburken
Message:

Ticket #2154 - Merges from GeoEye? -> OSGEO baseline. See ticket for more.

Location:
trunk/ossim
Files:
28 edited

Legend:

Unmodified
Added
Removed
  • trunk/ossim/include/ossim/base/ossimConstants.h

    r17194 r18693  
    382382{
    383383   OSSIM_STATUS_UNKNOWN = 0,
    384    OSSIM_NULL           = 1,
    385    OSSIM_EMPTY          = 2,
    386    OSSIM_PARTIAL        = 3,
    387    OSSIM_FULL           = 4
     384   OSSIM_NULL           = 1, // not initialized
     385   OSSIM_EMPTY          = 2, // initialized but blank or empty
     386   OSSIM_PARTIAL        = 3, // contains some null/invalid values
     387   OSSIM_FULL           = 4  // all valid data
    388388};
    389389
  • trunk/ossim/include/ossim/base/ossimDatum.h

    r17932 r18693  
    5656   virtual const ossimString& code()const{return theCode;}
    5757   virtual const ossimString& name()const{return theName;}
    58    virtual ossim_uint32 epsgGcsCode()const{return theEpsgGcsCode;}
     58   virtual ossim_uint32 epsgCode()const{return theEpsgCode;}
    5959   virtual const ossimEllipsoid* ellipsoid()const{return theEllipsoid;}
    6060   virtual ossim_float64 sigmaX()const{return theSigmaX;}
     
    7676
    7777   virtual bool isInside(ossim_float64 latitude, ossim_float64 longitude)const
    78       {
    79          return ((theSouthLatitude <= latitude) &&
    80                  (latitude <= theNorthLatitude) &&
    81                  (theWestLongitude <= longitude) &&
    82                  (longitude <= theEastLongitude));
    83       }
     78   {
     79      return ((theSouthLatitude <= latitude) &&
     80              (latitude <= theNorthLatitude) &&
     81              (theWestLongitude <= longitude) &&
     82              (longitude <= theEastLongitude));
     83   }
    8484
    85    bool operator ==(const ossimDatum& rhs)const
    86       {
    87          return ( (theCode == rhs.theCode)&&
    88                   (theName == rhs.theName)&&
    89                   (*theEllipsoid == *rhs.theEllipsoid)&&
    90                   (theSigmaX == rhs.theSigmaX)&&
    91                   (theSigmaY == rhs.theSigmaY)&&
    92                   (theSigmaZ == rhs.theSigmaZ)&&
    93                   (theWestLongitude == rhs.theWestLongitude)&&
    94                   (theEastLongitude == rhs.theEastLongitude)&&
    95                   (theSouthLatitude == rhs.theSouthLatitude)&&
    96                   (theNorthLatitude == rhs.theNorthLatitude));
    97       }
     85   bool operator==(const ossimDatum& rhs)const
     86   {
     87      return ( (theCode == rhs.theCode)&&
     88               (theName == rhs.theName)&&
     89               (*theEllipsoid == *rhs.theEllipsoid)&&
     90               (theSigmaX == rhs.theSigmaX)&&
     91               (theSigmaY == rhs.theSigmaY)&&
     92               (theSigmaZ == rhs.theSigmaZ)&&
     93               (theWestLongitude == rhs.theWestLongitude)&&
     94               (theEastLongitude == rhs.theEastLongitude)&&
     95               (theSouthLatitude == rhs.theSouthLatitude)&&
     96               (theNorthLatitude == rhs.theNorthLatitude));
     97   }
     98
     99   bool operator!=(const ossimDatum& rhs)const
     100   {
     101      return ( (theCode != rhs.theCode)||
     102               (theName != rhs.theName)||
     103               (*theEllipsoid != *rhs.theEllipsoid)||
     104               (theSigmaX != rhs.theSigmaX)||
     105               (theSigmaY != rhs.theSigmaY)||
     106               (theSigmaZ != rhs.theSigmaZ)||
     107               (theWestLongitude != rhs.theWestLongitude)||
     108               (theEastLongitude != rhs.theEastLongitude)||
     109               (theSouthLatitude != rhs.theSouthLatitude)||
     110               (theNorthLatitude != rhs.theNorthLatitude));
     111   }
     112
    98113protected:
    99114   //! Only friend ossimDatumFactory is permitted to delete
     
    135150private:
    136151   ossimString           theCode;
    137    ossim_uint32          theEpsgGcsCode;
     152   ossim_uint32          theEpsgCode;
    138153   ossimString           theName;
    139154   const ossimEllipsoid *theEllipsoid;
  • trunk/ossim/include/ossim/base/ossimDblGrid.h

    r14799 r18693  
    3232#include <ossim/base/ossimDpt.h>
    3333#include <ossim/base/ossimIpt.h>
     34#include <ossim/base/ossimDrect.h>
    3435#include <ossim/base/ossimCommon.h>
    3536
     
    8485                           const ossimDpt&    spacing,
    8586                           double null_value = OSSIM_DEFAULT_NULL_PIX_DOUBLE);
    86   void deallocate();
     87   /*!
     88   * Enables extrapolation functionality. If extrapolation is enabled, then calls to operator() will
     89   * handle points outside of the grid. The grid must be initialized before calling this method
     90   * since it checks if enough nodes are available for extrapolation.
     91   */
     92   void enableExtrapolation();
     93
     94   void deallocate();
    8795   /*!
    8896    * Fills the current grid with the value specified.
     
    126134    * quantities. The kernel sizes should be odd numbers. To avoid shrinking
    127135    * the grid by the kernel radius, the edge nodes outside of the filter's
    128     * reach are set equal to the nearest filtered node. X is the contiguous
     136    * reach are computed by extrapolation. X is the contiguous
    129137    * axis in the kernel array, i.e., kernel(x,y) = kernel[y*size_x + x].
    130138    */
     
    140148   void  setInterpolationType (InterpType interp);
    141149
     150   enum DomainType
     151   {
     152      CONTINUOUS = 0, // Default continuous grid with no limits on values
     153      SAWTOOTH_90= 1, // For angles between -90 and 90 deg such as latitude
     154      WRAP_180   = 2, // For angles between -180 and 180 with discontinuity at limits (typically used for longitude)
     155      WRAP_360   = 3  // For angles between 0 and 360 with discontinuity at limits (typically used for rotations)
     156   };
     157   void setDomainType(DomainType dt) { theDomainType = dt; }
     158
    142159   /*!
    143160    * Access an interpolated value in the U/V (output) coordinate system.
    144161    */
    145    double operator() (const ossimDpt& p) const {return (*this)(p.u,p.v);}
    146    double value      (const ossimDpt& p) const {return (*this)(p.u,p.v);}
     162   double operator() (const ossimDpt& uv_point) const {return (*this)(uv_point.u, uv_point.v);}
     163   double value      (const ossimDpt& uv_point) const {return (*this)(uv_point.u, uv_point.v);}
    147164
    148165   double operator() (const double& u, const double& v) const;
     
    172189   const ossimDpt& origin()  const { return theOrigin; }
    173190   const ossimDpt& spacing() const { return theSpacing; }
    174    unsigned long   getSizeInBytes() const
    175       { return theSize.x*theSize.y*sizeof(double); }
     191   unsigned long   getSizeInBytes() const { return theSize.x*theSize.y*sizeof(double); }
    176192   
    177193   /*!
     
    186202   bool  save(std::ostream& os, const char* descr) const;
    187203   bool  load(std::istream& is);
    188      
    189    
    190    friend std::ostream& operator << (std::ostream& os,
    191                                      const ossimDblGrid& grid);
     204   
     205   friend std::ostream& operator << (std::ostream& os, const ossimDblGrid& grid);
    192206   
    193207private:
    194208   
    195209   void  computeMean();
    196    int   index(int x, int y) const { return y*theSize.x + x; }
     210   double interpolate(double x, double y) const;
     211   double extrapolate(double x, double y) const;
     212
     213   //! Constrains the value to the numerical domain specified in theDomainType.
     214   void constrain(double& value) const;
     215
     216   ossim_uint32   index(int x, int y) const { return y*theSize.x + x; }
    197217   
    198218   double*      theGridData;
     
    206226   double       theDeviation;
    207227   bool         theMeanIsComputed;
     228   bool         theExtrapIsEnabled;
     229   DomainType   theDomainType;
    208230   
    209231};
  • trunk/ossim/include/ossim/base/ossimEllipsoid.h

    r17815 r18693  
    150150      return ( (theName == rhs.theName)&&
    151151               (theCode == rhs.theCode)&&
     152               (theA    == rhs.theA)&&
    152153               (theB    == rhs.theB)&&
    153154               (theFlattening == rhs.theFlattening));
     155   }
     156
     157   bool operator!=(const ossimEllipsoid& rhs) const
     158   {
     159      return ( (theName != rhs.theName)||
     160               (theCode != rhs.theCode)||
     161               (theA    != rhs.theA)||               
     162               (theB    != rhs.theB)||
     163               (theFlattening != rhs.theFlattening));
    154164   }
    155165
     
    158168   bool saveState(ossimKeywordlist& kwl,
    159169                  const char* prefix=0)const;
     170
     171   const ossimEllipsoid& operator=(const ossimEllipsoid& copy_me);
     172
    160173protected:
    161174   void computeFlattening()
  • trunk/ossim/include/ossim/base/ossimKeywordNames.h

    r17609 r18693  
    141141   static const char* PROJECTION_KW;
    142142   static const char* QUALITY_KW;
     143   static const char* QUERY_KW;
    143144   static const char* RADIOMETRY_KW;
    144145   static const char* REDUCED_RES_LEVEL_KW;
     
    189190   static const char* VERTICAL_SIZE_KW;
    190191   static const char* ZONE_KW;
    191    
    192192
    193193protected:
  • trunk/ossim/include/ossim/imaging/ossimImageGeometry.h

    r18515 r18693  
    156156   const ossimDpt& getMetersPerPixel() const;
    157157
     158   //! Assigns the ossimGpts with the ground coordinates of the four corresponding image
     159   //! corner points. Returns true if points are valid.
     160   bool getCornerGpts(ossimGpt& ul, ossimGpt& ur, ossimGpt& lr, ossimGpt& ll) const;
     161
    158162   //! Prints contents to output stream.
    159163   std::ostream& print(std::ostream& out) const;
     
    241245   ossim_uint32 getTargetRrds() const;
    242246
    243 protected:
    244 
    245247   //! When either the projection or the transform changes, this method recomputes the GSD.
    246248   void computeGsd()const;
    247249
     250protected:
    248251   //! @brief Method to back out decimation of a point.
    249252   //! @param rnPt Is a point in resolution n.
  • trunk/ossim/include/ossim/projection/ossimCoarseGridModel.h

    r17815 r18693  
    143143
    144144   
    145 private:
     145protected:
    146146   /**
    147147    * METHOD: reallocateGrid()
     
    151151   void reallocateGrid(const ossimIpt& size);
    152152   
     153   //! Initializes base class data members after grids have been assigned.
     154   void initializeModelParams(ossimIrect irect);
     155
     156   //! Implements its own extrapolation since this can be handled by ossimDblGrid.
     157   virtual ossimGpt extrapolate (const ossimDpt& imgPt, const double& height=ossim::nan()) const;
     158
    153159   /**
    154160    * Data Members:
  • trunk/ossim/include/ossim/projection/ossimEpsgProjectionDatabase.h

    r18181 r18693  
    3434
    3535   //! Destructor
    36    ~ossimEpsgProjectionDatabase();
     36   virtual ~ossimEpsgProjectionDatabase();
    3737
    3838   //! Returns a projection corresponding to the projection specified, or NULL if no entry found.
     
    116116
    117117#endif
    118 
  • trunk/ossim/include/ossim/support_data/ossimFgdcXmlDoc.h

    r17816 r18693  
    1010//
    1111//----------------------------------------------------------------------------
    12 // $Id: ossimFgdcXmlDoc.h 1204 2010-08-02 18:48:46Z david.burken $
     12// $Id: ossimFgdcXmlDoc.h 2049 2011-01-15 16:44:47Z david.burken $
    1313#ifndef ossimFgdcXmlDoc_HEADER
    1414#define ossimFgdcXmlDoc_HEADER 1
    1515
    1616#include <ossim/base/ossimConstants.h>
    17 #include <ossim/base/ossimDrect.h>
    1817#include <ossim/base/ossimFilename.h>
    1918#include <ossim/base/ossimRefPtr.h>
     
    2221#include <ossim/projection/ossimProjection.h>
    2322
     23class ossimDatum;
     24class ossimDrect;
     25
    2426/** @brief Class for FGDC XML doc parsing. */
    2527class OSSIMDLLEXPORT ossimFgdcXmlDoc
     
    2729public:
    2830   /** @brief default constructor */
    29    ossimFgdcXmlDoc(const ossimFilename& xmlFileName);
     31   ossimFgdcXmlDoc();
    3032   
    3133   /** @brief destructor */
    3234   ~ossimFgdcXmlDoc();
     35
     36   /**
     37    * @brief Open method.
     38    * @return true on success, false on error.
     39    */
     40   bool open(const ossimFilename& xmlFileName);
     41
     42   /** @return true if m_xmlDocument is open; false if not. */
     43   bool isOpen() const;
     44
     45   /** @brief close method. */
     46   void close();
     47
     48   /** @brief Gets projection from document. */
     49   ossimRefPtr<ossimProjection> getProjection();
     50
     51   /** @return Unit type. Note meters is the default if not found in doc. */
     52   ossimUnitType getUnitType() const;
     53
     54   /**
     55    * @return text for path "/metadata/spref/horizsys/cordsysn/geogcsn"
     56    */
     57   bool getGeoCsn(ossimString& s) const;
     58
     59   /**
     60    * @return text for path "/metadata/spref/horizsys/cordsysn/projcsn"
     61    */
     62   bool getProjCsn(ossimString& s) const;
     63
     64   /**
     65    * @brief Get the Altitude Distance Units
     66    *
     67    * Path: "/metadata/spref/vertdef/altsys/altunits"
     68    *
     69    * Domain: "meters" "feet"
     70    *
     71    * @return Text for path.
     72    */
     73   bool getAltitudeDistantUnits(ossimString& s) const;
     74
     75   /**
     76    * @brief Get the Grid Coordinate system
     77    *
     78    * Path: "/metadata/spref/horizsys/planar/gridsys/gridsysn"
     79    *
     80    * @return Text for path.
     81    */
     82   bool getGridCoordinateSystem(ossimString& s) const;
     83
     84   /**
     85    * @brief Gets projection from Grid Coordinate system node.
     86    *
     87    * Throws ossimException on error.
     88    *
     89    * @return Refptr with projection pointer.  Underlying pointer may be null.
     90    */
     91   ossimRefPtr<ossimProjection> getGridCoordSysProjection();
     92
     93   /**
     94    * @brief Get the Grid Coordinate system
     95    *
     96    * Path: "/metadata/spref/horizsys/planar/gridsys/gridsysn"
     97    *
     98    * @return Text for path.
     99    */
     100   bool getHorizontalDatum(ossimString& s) const;
     101
     102   /**
     103    * @brief Get the Planar Distant Units
     104    *
     105    * Path: "/metadata/spref/horizsys/planar/planci/plandu"
     106    *
     107    * Domain: "meters" "international feet" "survey feet"
     108    *
     109    * @return Text for path.
     110    */
     111   bool getPlanarDistantUnits(ossimString& s) const;
     112
     113   /**
     114    * @brief Get UTM false Northing.
     115    *
     116    * Path: "/metadata/spref/horizsys/planar/gridsys/utm/transmer/fnorth"
     117    *
     118    * @return Text for path.
     119    */
     120   bool getUtmFalseNorthing(ossimString& s) const;
    33121   
    34    ossimProjection* getProjection();
     122   /**
     123    * @brief Get UTM zone.
     124    *
     125    * Path: "/metadata/spref/horizsys/planar/gridsys/utm/utmzone"
     126    *
     127    * Domain: 1 <= UTM Zone Number <= 60 for the northern hemisphere;
     128    * -60 <= UTM Zone Number <= -1 for the southern hemisphere
     129     *
     130    * @return Text for path.
     131    */
     132   bool getUtmZone(ossimString& s) const;
    35133   
     134
    36135private:
     136
     137   bool getXRes(ossim_float64& v) const;
    37138   
    38    bool isOpen();
     139   bool getYRes(ossim_float64& v) const;
     140
     141   bool getImageSize(ossimIpt& size) const;
    39142   
    40    ossimString getGeoCsn();
    41    
    42    ossimString getProjCsn();
    43    
    44    ossimString getUnits();
    45    
    46    double getXRes();
    47    
    48    double getYRes();
    49    
    50    ossim_uint32 getNumberOfSamples();
    51    
    52    ossim_uint32 getNumberOfLines();
    53    
    54    ossimDrect getBoundingBox();
     143   void getBoundingBox(ossimDrect& rect) const;
     144
     145   /**
     146    * @brief Gets path from doc and initializes string.
     147    *
     148    * This method errors if multiple nodes are found for path.
     149    *
     150    * @param path Xml path to look for.
     151    * @param s String to initialize.
     152    * @return true on success and false if path is not found or if there
     153    * are more than one of path.
     154    */
     155   bool getPath(const ossimString& path, ossimString& s) const;
     156
     157   /**
     158    * @brief Gets path from doc and initializes string.
     159    * @param path Xml path to look for.
     160    * @param v Value to initialize.
     161    * @return true on success and false if path is not found or if there
     162    * are more than one of path.
     163    */
     164   bool getPath(const ossimString& path, ossim_float64& v) const;
     165
     166   /**
     167    * Gets the ossimDatum from string.
     168    */
     169   const ossimDatum* createOssimDatum(const ossimString& s) const;
    55170   
    56171   ossimFilename                 m_xmlFilename;
  • trunk/ossim/include/ossim/support_data/ossimSrcRecord.h

    r17815 r18693  
    1212#include <ossim/base/ossimConstants.h>
    1313#include <ossim/base/ossimFilename.h>
     14#include <ossim/base/ossimKeywordlist.h>
    1415#include <vector>
    15 
    16 class ossimKeywordlist;
    1716
    1817//*************************************************************************************************
     
    3029//!   image0.support: <path_to_support_files>
    3130//!   image0.rgb: R,G,rgbB  (unsigned integers starting with 1)
     31//!
     32//!   vector0.file: <image_filename> 
     33//!   vector0.entry: <image_index_in_multi_image_file> (unsigned integer)
     34//!   vector0.query: <select query>
     35//!   vector0.line.color: <R, G, B> (255,255,255)
     36//!   vector0.line.width: <line width> (unsigned integer)
     37//!   vector0.fill.color: <R, G, B>   (255,0,0)
     38//!   vector0.fill.opacity: <opacity> (unsigned integer)
     39//!
    3240//!
    3341//! The "support" keyword can be specified in lieu of "ovr" and "hist" when the latter reside in
     
    6573   const ossimString&               getHistogramOp() const { return m_histogramOp;}
    6674   const std::vector<ossim_uint32>& getBands()       const { return m_bandList; }
     75   const double&                    getWeight()      const { return m_weight; } 
    6776   
    6877   //! See note below on these data members.
     
    7079   const ossimFilename& getHistogramPath() const { return m_histogramPath; }
    7180   const ossimFilename& getMaskPath() const { return m_maskPath; }
    72 
    73    void setFilename(const ossimFilename& f)          { m_filename = f; }
    74    void setEntryIndex(ossim_int32 i)                 { m_entryIndex = i; }
    75    void setOverview(const ossimFilename& f)          { m_overviewPath = f; }
     81   
     82   void setFilename(const ossimFilename& f);         
     83   void setEntryIndex(ossim_int32 i);                 
     84   void setOverview(const ossimFilename& f);         
    7685   void setMask(const ossimFilename& f)              { m_maskPath = f; }
    7786   void setHistogram(const ossimFilename& f)         { m_histogramPath = f; }
    7887   void setHistogramOp(const ossimString& s)         { m_histogramOp = s; }
    7988   void setBands(const std::vector<ossim_uint32>& v) { m_bandList = v; }
     89   void setWeight(const double& weight)              {m_weight = weight; }
     90   void setRgbDataBool(bool isRgbData)               { m_isRgbData = isRgbData; }
    8091
    8192   //! Sets supplementary data files dir. If the OVR and/or hist dirs are undefined, they are also
     
    8394   void setSupportDir(const ossimFilename& f);
    8495
     96   //! Returns TRUE if the record represents a vector data set:
     97   bool isVectorData() const { return m_isVectorData; }
     98
     99   //! Returns TRUE if the record represents a rgb data set:
     100   std::vector<ossimString> getRgbFilenames() const { return m_rgbFilenames; }
     101   std::vector<ossimString> getRgbHistogramPaths() const { return m_rgbHistogramPaths; }
     102   std::vector<ossimString> getRgbHistogramOps() const { return m_rgbHistogramOps; }
     103   std::vector<ossimString> getRgbOverviewPaths() const { return m_rgbOverviewPaths; }
     104   bool isRgbData() const { return m_isRgbData; }
     105
     106   //! Returns the KWL containing the desired vector representation properties. In the future we
     107   //! should stuff many of the members in ossimSrcRecord in a KWL (similar to what is currently
     108   //! done with vector properties) so that the handler is initialized via loadState() instead of
     109   //! individual calls to set methods. OLK 10/10
     110   const ossimKeywordlist& getAttributesKwl() const { return m_attributesKwl; }
     111
    85112private:
    86 
    87113   ossimFilename m_filename;
    88114   ossim_int32   m_entryIndex;
    89115   ossimFilename m_supportDir;
    90116   std::vector<ossim_uint32> m_bandList;
    91    ossimString m_histogramOp;
     117   ossimString   m_histogramOp;
     118   double        m_weight;
    92119
    93120   //! The following data members are usually just a copy of m_supportDir, but are provided in
     
    96123   ossimFilename m_histogramPath;
    97124   ossimFilename m_maskPath;
     125
     126   //! The following data members allow users to render vector data
     127   bool m_isVectorData;
     128   ossimKeywordlist m_attributesKwl;
     129
     130   std::vector<ossimString> m_rgbFilenames;
     131   std::vector<ossimString> m_rgbHistogramPaths;
     132   std::vector<ossimString> m_rgbHistogramOps;
     133   std::vector<ossimString> m_rgbOverviewPaths;
     134   bool m_isRgbData;
    98135};
    99136
  • trunk/ossim/include/ossim/support_data/ossimTiffWorld.h

    r9094 r18693  
    3333   
    3434   ~ossimTiffWorld();
    35 
    36   bool saveToOssimGeom(ossimKeywordlist& kwl, const char* prefix=NULL)const;
    37   bool loadFromOssimGeom(const ossimKeywordlist& kwl, const char* prefix=NULL);
    38 
    39   std::ostream& print(std::ostream& out) const;
    40 
    41   friend OSSIMDLLEXPORT std::ostream& operator<<(std::ostream& out,
    42                                                  const ossimTiffWorld& obj);
    43 
     35   
     36   bool open(const ossimFilename& file,
     37             ossimPixelType ptype,
     38             ossimUnitType unit);
     39   
     40   bool saveToOssimGeom(ossimKeywordlist& kwl, const char* prefix=NULL)const;
     41   bool loadFromOssimGeom(const ossimKeywordlist& kwl, const char* prefix=NULL);
     42   
     43   std::ostream& print(std::ostream& out) const;
     44   
     45   friend OSSIMDLLEXPORT std::ostream& operator<<(std::ostream& out,
     46                                                  const ossimTiffWorld& obj);
     47   
    4448   /*!
    4549    * transformed.x =
     
    5256                ossimDpt& transformedPoint);
    5357   
    54    double theXScale;     // xscale
    55    double the2ndValue;   // rotation term
    56    double the3rdValue;   // rotaion term
    57    double theYScale;     // yscale
    58    double theTranslateX; //
    59    double theTranslateY; //
     58   //! Converts world file parameters into x, y scale (for use in affine transform)
     59   const ossimDpt& getScale() const { return theComputedScale; }
     60   
     61   //! Converts world file parameters into RH rotation in radians (for use in affine transform)
     62   double getRotation() const { return theComputedRotation; }
     63   
     64   //! Provides access to the translation (for use in affine transform)
     65   const ossimDpt& getTranslation() const { return theTranslation; }
    6066
    6167protected:
     68   double theXform1;     
     69   double theXform2;   
     70   double theXform3;   
     71   double theXform4;   
     72   ossimDpt theTranslation;
     73
    6274   ossimPixelType thePixelType;
    6375   ossimUnitType  theUnit;
     76   ossimDpt theComputedScale;
     77   double   theComputedRotation;  //!< Radians
    6478};
    6579
  • trunk/ossim/src/ossim/base/ossimDatum.cpp

    r17815 r18693  
    3131theNorthLatitude(northLatitude)
    3232{
    33    theEpsgGcsCode = ossimEpsgDatumFactory::instance()->findEpsgCode(alpha_code);
     33   theEpsgCode = ossimEpsgDatumFactory::instance()->findEpsgCode(alpha_code);
    3434};
    3535
  • trunk/ossim/src/ossim/base/ossimDblGrid.cpp

    r12953 r18693  
    3636
    3737/*!****************************************************************************
    38  *  DEFAULT CONSTRUCTOR: ossimDblGrid
    39  
    40  *****************************************************************************/
     38*  DEFAULT CONSTRUCTOR: ossimDblGrid
     39
     40*****************************************************************************/
    4141ossimDblGrid::ossimDblGrid()
    42    :
    43       theGridData       (0),
    44       theSize           (0, 0),
    45       theOrigin         (0.0, 0.0),
    46       theSpacing        (0.0, 0.0),
    47       theMinValue       (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
    48       theMaxValue       (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
    49       theNullValue      (OSSIM_DEFAULT_NULL_PIX_DOUBLE),
    50       theMeanIsComputed (false)
     42:
     43theGridData       (0),
     44theSize           (0, 0),
     45theOrigin         (0.0, 0.0),
     46theSpacing        (0.0, 0.0),
     47theMinValue       (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
     48theMaxValue       (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
     49theNullValue      (OSSIM_DEFAULT_NULL_PIX_DOUBLE),
     50theMeanIsComputed (false),
     51theExtrapIsEnabled (false),
     52theDomainType     (CONTINUOUS)
    5153{ }
    5254
    5355
    5456/*!****************************************************************************
    55  *  COPY CONSTRUCTOR: ossimDblGrid
    56  
    57  *****************************************************************************/
     57*  COPY CONSTRUCTOR: ossimDblGrid
     58
     59*****************************************************************************/
    5860ossimDblGrid::ossimDblGrid(const ossimDblGrid&  source)
    59    :
    60       theGridData(NULL),
    61       theSize           (source.theSize),
    62       theOrigin         (source.theOrigin),
    63       theSpacing        (source.theSpacing),
    64       theMinValue       (source.theMinValue),
    65       theMaxValue       (source.theMaxValue),
    66       theNullValue      (source.theNullValue),
    67       theMeanValue      (source.theMeanValue),
    68       theDeviation      (source.theDeviation),
    69       theMeanIsComputed (source.theMeanIsComputed)
     61:
     62theGridData   (0),
     63theMinValue   (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
     64theMaxValue   (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
     65theExtrapIsEnabled (false),
     66theDomainType (CONTINUOUS)
    7067{
    7168   static const char MODULE[] = "ossimDblGrid Constructor";
     
    7471   *this = source;
    7572   /*!
    76     * Allocate mem for the grid, and initialize:
    77     */
    78 //    int buflen = theSize.x * theSize.y;
    79 //    theGridData = new double [buflen];
    80 
    81 //    for (int i=0; i<buflen; i++)
    82 //       theGridData[i] = source.theGridData[i];
    83    
     73   * Allocate mem for the grid, and initialize:
     74   */
     75   //    int buflen = theSize.x * theSize.y;
     76   //    theGridData = new double [buflen];
     77
     78   //    for (int i=0; i<buflen; i++)
     79   //       theGridData[i] = source.theGridData[i];
     80
    8481   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
    8582}
    8683
    8784/*!****************************************************************************
    88  *  CONSTRUCTOR: ossimDblGrid
    89  
    90  *****************************************************************************/
     85*  CONSTRUCTOR: ossimDblGrid
     86
     87*****************************************************************************/
    9188ossimDblGrid::ossimDblGrid(const ossimIpt&  size,
    9289                           const ossimDpt&  origin,
    9390                           const ossimDpt&  spacing,
    9491                           double           null_value)
    95    :
    96       theGridData (0)
     92                           :
     93theGridData   (0),
     94theMinValue   (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
     95theMaxValue   (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
     96theExtrapIsEnabled (false),
     97theDomainType (CONTINUOUS)
    9798{
    9899   static const char MODULE[] = "ossimDblGrid Constructor";
     
    100101
    101102   initialize(size, origin, spacing, null_value);
    102    
     103
    103104   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
    104105}
    105106
    106107/*!****************************************************************************
    107  *  CONSTRUCTOR: ossimDblGrid
    108  
    109  *****************************************************************************/
     108*  CONSTRUCTOR: ossimDblGrid
     109
     110*****************************************************************************/
    110111ossimDblGrid::ossimDblGrid(const ossimDrect&  rect,
    111112                           const ossimDpt&    spacing,
    112113                           double             null_value)
    113    :
    114       theGridData (0)
     114                           :
     115theGridData   (0),
     116theMinValue   (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
     117theMaxValue   (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
     118theExtrapIsEnabled (false),
     119theDomainType (CONTINUOUS)
    115120{
    116121   static const char MODULE[] = "ossimDblGrid Constructor";
     
    118123
    119124   ossimIpt size ((int) (rect.width()/spacing.x)  + 1,
    120                   (int) (rect.height()/spacing.y) + 1);
    121    
     125      (int) (rect.height()/spacing.y) + 1);
     126
    122127   initialize(size, rect.ul(), spacing, null_value);
    123    
     128
    124129   if (traceExec())  ossimNotify(ossimNotifyLevel_WARN) << MODULE << " returning...\n";
    125130}
     
    156161   //***
    157162   if (theGridData)
    158     {
    159        delete [] theGridData;
    160        theGridData = 0;
    161     }
    162    
     163   {
     164      delete [] theGridData;
     165      theGridData = 0;
     166   }
     167
    163168   //***
    164169   // Initialize data members:
     
    167172   theOrigin         = origin;
    168173   theSpacing        = spacing;
    169    theMinValue       = OSSIM_DEFAULT_MAX_PIX_DOUBLE;
    170    theMaxValue       =  OSSIM_DEFAULT_MIN_PIX_DOUBLE;
    171174   theNullValue      = null_value;
     175   theMinValue       = OSSIM_DEFAULT_MIN_PIX_DOUBLE;
     176   theMaxValue       = OSSIM_DEFAULT_MAX_PIX_DOUBLE;
    172177   theMeanIsComputed = false;
    173178
    174179   /*!
    175     * Allocate mem for the grid, and initialize:
    176     */
    177    int buflen = theSize.x * theSize.y;
     180   * Allocate mem for the grid, and initialize:
     181   */
     182   ossim_uint32 buflen = theSize.x * theSize.y;
    178183   if(buflen > 0)
    179      {
    180        theGridData = new double [buflen];
    181 
    182        for (int i=0; i<buflen; i++)
    183         theGridData[i] = theNullValue;
    184      }   
     184   {
     185      theGridData = new double [buflen];
     186
     187      for (ossim_uint32 i=0; i<buflen; i++)
     188        theGridData[i] = theNullValue;
     189   }   
    185190   if (traceExec())  ossimNotify(ossimNotifyLevel_WARN) << MODULE << " returning...\n";
    186191
     
    202207
    203208   ossimIpt size ((int) (uv_rect.width()/spacing.x)  + 1,
    204                   (int) (uv_rect.height()/spacing.y) + 1);
    205    
     209      (int) (uv_rect.height()/spacing.y) + 1);
     210
    206211   initialize(size, uv_rect.ul(), spacing, null_value);
    207212
     
    210215}
    211216
     217//**************************************************************************************************
     218//  Computes quantities referenced for extrapolation. This only needs to be called if extrapolation
     219//  service is needed. The grid initialization must be completed before calling this method.
     220//
     221//  Note, the partials are computed using only adjacent grid points. In the future we may want to
     222//  use the filter() function to smooth out local noise.
     223//**************************************************************************************************
     224void ossimDblGrid::enableExtrapolation()
     225{
     226   // Clear out prior data:
     227   theExtrapIsEnabled = false;
     228   if ((theSize.x > 2) && (theSize.y > 2))
     229      theExtrapIsEnabled = true;
     230}
     231
     232//**************************************************************************************************
    212233void ossimDblGrid::deallocate()
    213234{
    214   if(theGridData)
    215     {
     235   if(theGridData)
     236   {
    216237      delete [] theGridData;
    217238      theGridData = 0;
    218     }
    219   theSize = ossimIpt(0,0);
     239   }
     240   theSize = ossimIpt(0,0);
    220241}
    221242
    222243/*!****************************************************************************
    223  * METHOD: ossimDblGrid::setNode(x, y) NON-CONST
    224  *
    225  *  This method is used to assign the grid data values.
    226  * 
    227  *****************************************************************************/
    228 void ossimDblGrid::setNode (int x, int y,
    229                             const double&   value)
    230 {
    231   if(!theGridData) return;
     244* METHOD: ossimDblGrid::setNode(x, y) NON-CONST
     245*
     246*  This method is used to assign the grid data values.
     247
     248*****************************************************************************/
     249void ossimDblGrid::setNode (int x, int y, const double& input)
     250{
     251   if(!theGridData) return;
     252
     253   // Insure the value passed in is allowed:
     254   double value = input;
     255   constrain(value);
    232256
    233257   if ((x>=0)&&(x<theSize.x)&&(y>=0)&&(y<theSize.y))
     
    242266            theMaxValue = value;
    243267      }
    244      
     268
    245269      theMeanIsComputed = false;
    246270   }
     271
     272   return;
     273}
     274
     275/*!****************************************************************************
     276* METHOD: ossimDblGrid::setNearestNode(uv)
     277*
     278* Sets the node nearest the U,V point specified to the value given. This is
     279* different from setNode() in that the UV coordinate system is used to
     280* address a node instead of an XY grid point.
     281
     282*****************************************************************************/
     283void ossimDblGrid::setNearestNode (const ossimDpt& uv_point,
     284                                   const double&   input)
     285{
     286   if(!theGridData) return;
    247287   
    248    return;
    249 }
    250 
    251 /*!****************************************************************************
    252  * METHOD: ossimDblGrid::setNearestNode(uv)
    253  *
    254  * Sets the node nearest the U,V point specified to the value given. This is
    255  * different from setNode() in that the UV coordinate system is used to
    256  * address a node instead of an XY grid point.
    257  * 
    258  *****************************************************************************/
    259 void ossimDblGrid::setNearestNode (const ossimDpt& uv_point,
    260                                    const double&   value)
    261 {
    262   if(!theGridData) return;
     288   // Insure the value passed in is allowed:
     289   double value = input;
     290   constrain(value);
     291
    263292   //***
    264293   // Establish the grid indexes:
     
    277306
    278307   setNode (xi, yi, value);
    279    
     308
    280309   return;
    281310}
    282311
    283312/*!****************************************************************************
    284  * METHOD: ossimDblGrid::getNode(x, y) CONST
    285  *
    286  *  This method is used to return the grid data values.
    287  
    288  *****************************************************************************/
     313* METHOD: ossimDblGrid::getNode(x, y) CONST
     314*
     315*  This method is used to return the grid data values.
     316
     317*****************************************************************************/
    289318double ossimDblGrid::getNode (int x, int y) const
    290319{
    291   if(!theGridData) return theNullValue;
     320   if(!theGridData) return theNullValue;
    292321   if ((x>=0)&&(x<theSize.x)&&(y>=0)&&(y<theSize.y))
    293       return theGridData[index(x, y)];
    294 
     322   {
     323      ossim_uint32 i = index(x, y);
     324      double val = theGridData[i];
     325      return val;
     326   }
    295327   return theNullValue;
    296328}
    297329
    298330/*!****************************************************************************
    299  * METHOD: ossimDblGrid::operator(double, double)
    300  *
    301  *  This method interpolates between grid points given a fractional location
    302  *  in UV (external) world space.
    303  * 
    304  *****************************************************************************/
    305 double ossimDblGrid::operator() (const double& u,
    306                                  const double& v) const
    307 {
    308   if(!theGridData) return theNullValue;
    309 
    310    if (isInside(u, v))
    311    {
    312       /*!
    313        * Establish the grid indexes:
    314        */
    315       double xi = (u - theOrigin.u)/theSpacing.x;
    316       double yi = (v - theOrigin.v)/theSpacing.y;
    317 
    318      
    319       int x0 = (int) xi;
    320       int y0 = (int) yi;
    321 
    322       x0 = (x0<theSize.x)?x0:(theSize.x-1);
    323       y0 = (y0<theSize.y)?y0:(theSize.y-1);
    324       xi = (xi<theSize.x)?xi:(theSize.x-1);
    325       yi = (yi<theSize.y)?yi:(theSize.y-1);
    326       /*!
    327        * Perform bilinear interpolation:
    328        */
    329       double wx1 = xi - x0;
    330       double wy1 = yi - y0;
    331 
    332      
    333        double wx0 = 1.0 - wx1;
    334        double wy0 = 1.0 - wy1;
    335 
    336        int index00;
    337        int index10;
    338        int index11;
    339        int index01;
    340 
    341        
    342        index00  = theSize.x*y0 + x0;
    343        if(x0 < (theSize.x-1))
    344        {
    345           index10  = index00 + 1;
    346        }
    347        else
    348        {
    349           index10  = index00;
    350        }
    351        if(y0 < (theSize.y-1))
    352        {
    353           index01  = index00 + theSize.x;
    354        }
    355        else
    356        {
    357           index01  = index00;
    358        }
    359        if(y0 < (theSize.y-1))
    360        {
    361           index01  = index00 + theSize.x;
    362        }
    363        else
    364        {
    365           index01  = index00;
    366        }
    367        
    368        if(x0 < (theSize.x-1))
    369        {
    370           index11  = index01 + 1;
    371        }
    372        else
    373        {
    374           index11  = index01;
    375        }
    376 
    377 
    378       double p00   = (double) theGridData[index00];
    379       double p01   = (double) theGridData[index01];
    380       double p10   = (double) theGridData[index10];
    381       double p11   = (double) theGridData[index11];
    382      
    383       double w00   = wx0*wy0;
    384       double w01   = wx0*wy1;
    385       double w10   = wx1*wy0;
    386       double w11   = wx1*wy1;
    387      
    388       return (p00*w00 + p01*w01 + p10*w10 + p11*w11) /
    389          (w00 + w01 + w10 + w11);
    390    }
    391 
    392    // else
     331* METHOD: ossimDblGrid::operator(double, double)
     332*
     333*  This method interpolates between grid points given a fractional location
     334*  in UV (external) world space.
     335
     336*****************************************************************************/
     337double ossimDblGrid::operator() (const double& u, const double& v) const
     338{
     339   if(!theGridData) return theNullValue;
     340
     341   double xi = (u - theOrigin.u)/theSpacing.x;
     342   double yi = (v - theOrigin.v)/theSpacing.y;
     343
     344   if ((xi >= 0.0) && (xi <= (double)theSize.x-1) && (yi >= 0.0) && (yi <= (double)theSize.y-1))
     345      return interpolate(xi, yi);
     346
     347   else if (theExtrapIsEnabled)
     348      return extrapolate(xi, yi);
     349
    393350   return theNullValue;
    394351}
    395352
     353//*************************************************************************************************
     354//! Interpolates given non-integral point x, y
     355//*************************************************************************************************
     356double ossimDblGrid::interpolate(double xi, double yi) const
     357{
     358
     359   // Establish the grid cell origin indices:
     360   int x0 = (int) xi;
     361   int y0 = (int) yi;
     362
     363   // Compute bilinear interpolation weights:
     364   double wx1 = xi - x0;
     365   double wy1 = yi - y0;
     366   double wx0 = 1.0 - wx1;
     367   double wy0 = 1.0 - wy1;
     368   double w00 = wx0 * wy0;
     369   double w01 = wx0 * wy1;
     370   double w10 = wx1 * wy0;
     371   double w11 = wx1 * wy1;
     372
     373   // Establish grid indices for 4 surrounding points:
     374   int index00  = theSize.x*y0 + x0;
     375   int index10 = index00;
     376   int index11 = index00;
     377   int index01 = index00;
     378
     379   if (x0 < (theSize.x-1)) index10 = index00 + 1;
     380   if (y0 < (theSize.y-1)) index01 = index00 + theSize.x;
     381   if (y0 < (theSize.y-1)) index01 = index00 + theSize.x;
     382   if (x0 < (theSize.x-1)) index11 = index01 + 1;
     383
     384   // Safety check:
     385   int max_idx = theSize.x * theSize.y;
     386   if ((index00 > max_idx) || (index10 > max_idx) || (index11 > max_idx) || (index01 > max_idx))
     387      return ossim::nan();
     388
     389   // Extract the four data points:
     390   double p00 = theGridData[index00];
     391   double p01 = theGridData[index01];
     392   double p10 = theGridData[index10];
     393   double p11 = theGridData[index11];
     394
     395   // Consider the numerical domain to catch any wrap condition:
     396   if (theDomainType >= WRAP_180)
     397   {
     398      double dp01_00 = p01 - p00;
     399      double dp10_00 = p10 - p00;
     400      double dp11_00 = p11 - p00;
     401
     402      if (dp01_00 > 180.0)
     403         p01 -= 360.0;
     404      else if (dp01_00 < -180.0)
     405         p01 += 360.0;
     406
     407      if (dp10_00 > 180.0)
     408         p10 -= 360.0;
     409      else if (dp10_00 < -180.0)
     410         p10 += 360.0;
     411
     412      if (dp11_00 > 180.0)
     413         p11 -= 360.0;
     414      else if (dp11_00 < -180.0)
     415         p11 += 360.0;
     416   }
     417
     418   // Perform interpolation:
     419   double value = (p00*w00 + p01*w01 + p10*w10 + p11*w11) / (w00 + w01 + w10 + w11);
     420   constrain(value);
     421
     422   return value;
     423}
     424
     425//**************************************************************************************************
     426//  METHOD: ossimDblGrid::extrapolate()
     427// 
     428//  Establishes bilinear extrapolation value for point outside of the grid.
     429//
     430//**************************************************************************************************
     431double ossimDblGrid::extrapolate(double x, double y) const
     432{
     433   double dx=0, dy=0, dR_dx=0, dR_dy=0, R0;
     434
     435   // Decide which extra-grid region contains the input point:
     436   if (y < 0)
     437   {
     438      // The point is above the top edge of grid space:
     439      dy = y;
     440      if (x < 0)
     441      {
     442         // The point is in the top-left region. Use UL corner alone as reference, and compute first
     443         // and second partials:
     444         R0 = getNode(0, 0);
     445         dx = x;
     446         dR_dx = getNode(1, 0) - R0;
     447         dR_dy = getNode(0, 1) - R0;
     448      }
     449      else if (x <= theSize.x-1)
     450      {
     451         // The point directly above the grid, use the dR_dy of the edge pixel:
     452         R0 = interpolate(x, 0);
     453         dR_dy = interpolate(x, 1.0) - R0;
     454      }
     455      else
     456      {
     457         // The point is in the top-right region:
     458         R0 = getNode(theSize.x - 1, 0);
     459         dx = x - theSize.x + 1;
     460         dR_dx = R0 - getNode(theSize.x-2, 0);
     461         dR_dy = getNode(theSize.x-1, 1) - R0;
     462      }
     463   }
     464   else if (y <= theSize.y-1)
     465   {
     466      // The point is either to the left, the right, or inside of the grid:
     467      if (x < 0)
     468      {
     469         // The point is directly to the left of the grid:
     470         R0 = interpolate(0, y);
     471         dx = x;
     472         dR_dx = interpolate(1.0, y) - R0;
     473      }
     474      else if (x <= theSize.x-1)
     475      {
     476         // The point is inside the grid. This should never happen, but handle just in case:
     477         return interpolate(x, y);
     478      }
     479      else
     480      {
     481         // The point directly to the right of the grid:
     482         R0 = interpolate((double)theSize.x-1, y);
     483         dx = x - theSize.x + 1;
     484         dR_dx = R0 - interpolate((double)theSize.x-2, y);
     485      }
     486   }
     487   else
     488   {
     489      // The point is below the bottom edge of grid space:
     490      dy = y - theSize.y + 1;
     491      if (x < 0)
     492      {
     493         // The point is in the bottom-left region:
     494         R0 = getNode(0, theSize.y-1);
     495         dx = x;
     496         dR_dx = getNode(1, theSize.y-1) - R0;
     497         dR_dy = R0 - getNode(0, theSize.y-2);
     498      }
     499      else if (x < theSize.x-1)
     500      {
     501         // The point directly below the grid:
     502         R0 = interpolate(x, (double)theSize.y-1);
     503         dR_dy = R0 - interpolate(x, (double)theSize.y-2);
     504      }
     505      else
     506      {
     507         // The point is in the bottom-right region:
     508         R0 = getNode(theSize.x - 1, theSize.y-1);
     509         dx = x - theSize.x + 1;
     510         dR_dx = R0 - getNode(theSize.x-2, theSize.y-1);
     511         dR_dy = R0 - getNode(theSize.x-1, theSize.y-2);
     512      }
     513   }
     514
     515   // Consider the numerical domain and adjust potential wrap conditions in the differences:
     516   if (theDomainType >= WRAP_180)
     517   {
     518      if (dR_dx > 180.0) dR_dx -= 360.0;
     519      else if (dR_dx < -180.0) dR_dx += 360.0;
     520
     521      if (dR_dy > 180.0) dR_dy -= 360.0;
     522      else if (dR_dy < -180.0) dR_dy += 360.0;
     523   }
     524
     525   double R = R0 + dR_dx*dx + dR_dy*dy;
     526   constrain(R);
     527   return R;
     528}
     529
    396530//*****************************************************************************
    397531//  OPERATOR: =
     
    401535{
    402536   if(&source == this) return *this;
    403    
     537
    404538   if (theGridData)
    405      {
    406        delete [] theGridData;
    407        theGridData = 0;
    408      }
     539   {
     540      delete [] theGridData;
     541      theGridData = 0;
     542   }
    409543
    410544   //***
     
    420554   theDeviation      = source.theDeviation;
    421555   theMeanIsComputed = source.theMeanIsComputed;
     556   theDomainType     = source.theDomainType;
     557   theExtrapIsEnabled = source.theExtrapIsEnabled;
    422558
    423559   //***
     
    426562   int buflen = theSize.x * theSize.y;
    427563   if(buflen>0)
    428      {
    429        theGridData = new double [buflen];
    430        
    431        for (int i=0; i<buflen; i++)
    432          {
    433            theGridData[i] = source.theGridData[i];
    434          }
    435      }
     564   {
     565      theGridData = new double [buflen];
     566
     567      for (int i=0; i<buflen; i++)
     568      {
     569         theGridData[i] = source.theGridData[i];
     570      }
     571   }
     572
    436573   return *this;
    437574}
     
    439576
    440577/*!****************************************************************************
    441  * METHOD: ossimDblGrid::meanValue()
    442  
    443  *****************************************************************************/
     578* METHOD: ossimDblGrid::meanValue()
     579
     580*****************************************************************************/
    444581double  ossimDblGrid::meanValue()
    445582{
    446583   static const char MODULE[] = "ossimDblGrid::meanValue()";
    447584   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";
    448    
     585
    449586   if (!theMeanIsComputed)
    450      {
    451        computeMean();
    452      }
     587   {
     588      computeMean();
     589   }
    453590
    454591   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
     
    457594
    458595/*!****************************************************************************
    459  * METHOD: ossimDblGrid::meanStdDev()
    460  
    461  *****************************************************************************/
     596* METHOD: ossimDblGrid::meanStdDev()
     597
     598*****************************************************************************/
    462599double  ossimDblGrid::meanStdDev()
    463600{
    464601   static const char MODULE[] = "ossimDblGrid::meanStdDev()";
    465602   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";
    466    
     603
    467604   if (!theMeanIsComputed)
    468605      computeMean();
     
    473610
    474611/*!****************************************************************************
    475  * METHOD: ossimDblGrid::computeMean()
    476  
    477  *****************************************************************************/
     612* METHOD: ossimDblGrid::computeMean()
     613
     614*****************************************************************************/
    478615void ossimDblGrid::computeMean()
    479616{
    480617   static const char MODULE[] = "ossimDblGrid::meanStdDev()";
    481   if(!theGridData) return;
     618   if(!theGridData) return;
    482619   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << "entering...\n";
    483620
     
    488625
    489626      /*!
    490        * Loop to compute mean:
    491        */
     627      * Loop to compute mean:
     628      */
    492629      for (int i=0; i<(theSize.x*theSize.y); i++)
    493630      {
     
    501638
    502639      /*!
    503        * Loop again to compute deviation:
    504        */
     640      * Loop again to compute deviation:
     641      */
    505642      accum = 0.0;
    506643      double diff;
     
    517654      theMeanIsComputed = true;
    518655   }
    519      
     656
    520657   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
    521658   return;
     
    523660
    524661/*!****************************************************************************
    525  * INLINE METHOD: ossimDblGrid::isInside(const ossimDpt& pt) const
    526  *****************************************************************************/
    527 bool ossimDblGrid::isInside(const double& u,
    528                                    const double& v) const
     662* INLINE METHOD: ossimDblGrid::isInside(const ossimDpt& pt) const
     663*****************************************************************************/
     664bool ossimDblGrid::isInside(const double& u, const double& v) const
    529665{
    530666   double xi = (u - theOrigin.u)/theSpacing.x;
    531667   double yi = (v - theOrigin.v)/theSpacing.y;
    532 //   return ((xi >= 0.0) && (xi <= ((double)theSize.x - 1.0)) &&
    533 //           (yi >= 0.0) && (yi <= ((double)theSize.y - 1.0)));
    534    return ((xi >= 0.0) && (xi < ((double)theSize.x)) &&
    535            (yi >= 0.0) && (yi < ((double)theSize.y)));
    536 }
    537                    
     668   return ((xi >= 0.0) && (xi <= ((double)theSize.x - 1.0)) &&
     669      (yi >= 0.0) && (yi <= ((double)theSize.y - 1.0)));
     670   //return ((xi >= 0.0) && (xi < ((double)theSize.x)) &&
     671   //        (yi >= 0.0) && (yi < ((double)theSize.y)));
     672}
     673
    538674
    539675//*****************************************************************************
     
    555691   //ios::streamsize new_precision = 12;
    556692   int new_precision = 12;
    557    
     693
    558694   ios::fmtflags old_options = os.flags(new_options);
    559695   int old_precision = os.precision(new_precision);
     
    565701   std::strncpy(descr_buf, descr, 80);
    566702   descr_buf[80] = '\0';
    567    
     703
    568704   //***
    569705   // write magic number tag and the grid size X, Y, num params:
     
    579715
    580716   if(theGridData)
    581      {
    582        //***
    583        // Loop to write grid points:
    584        //***
    585        int max_index = theSize.x*theSize.y;
    586        for (int i=0; i<max_index; i++)
    587         os << theGridData[i] << "  ";
    588      }
     717   {
     718      //***
     719      // Loop to write grid points:
     720      //***
     721      int max_index = theSize.x*theSize.y;
     722      for (int i=0; i<max_index; i++)
     723        os << theGridData[i] << "  ";
     724   }
    589725   os << "\n";
    590    
     726
    591727   //***
    592728   // Restore the stream's state:
     
    594730   os.flags(old_options);
    595731   os.precision(old_precision);
    596      
     732
    597733   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
    598734   return true;
     
    612748
    613749   char strbuf[128];
    614    
     750
    615751   //***
    616752   // Read magic number tag to insure it is an ossimDblGrid record:
     
    620756   {
    621757      ossimNotify(ossimNotifyLevel_FATAL) << MODULE << "Error reading OSSIM_DBL_GRID magic number from stream. "
    622                                           << "Aborting...\n";
     758         << "Aborting...\n";
    623759      return false;
    624760   }
     
    632768   theMeanIsComputed = false;
    633769
    634    
     770
    635771   //***
    636772   // Read the grid size, origin, and spacing:
     
    646782      >> spacing.v
    647783      >> null_value;
    648    
     784
    649785   initialize(size, origin, spacing, null_value);
    650    
     786
    651787   //***
    652788   // Loop to read grid points:
     
    654790   int max_index = theSize.x*theSize.y;
    655791   for (int i=0; i<max_index; i++)
    656      {
    657        is >> theGridData[i];
    658      }
     792   {
     793      is >> theGridData[i];
     794   }
    659795
    660796   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
    661    
     797
    662798   return true;
    663799}
     
    688824      return blocked[12];
    689825   }
    690    
     826
    691827   double r = x/y;
    692828   int c = 0;
     
    708844
    709845   if (i > 15) i -= 16;  // modulo 16
    710    
     846
    711847   return blocked[i];
    712848}
     
    752888   if (i > 15) i -= 16;  // modulo 16
    753889   blocked[i] = true;
    754    
     890
    755891   return;
    756892}
    757      
     893
    758894//*****************************************************************************
    759895//   METHOD: ossimDblGrid::interpolateNullValuedNodes(decay_rate)
     
    831967            for (int i=0; i<16; i++)
    832968               blocked[i] = false;
    833            
     969
    834970            //***
    835971            // Loop collecting contributions from non-null neighbors. Begin with
     
    850986               end_y = start_y + diameter;
    851987               end_x = start_x + diameter;
    852                
     988
    853989               for (int yn=start_y; yn<=end_y; yn++)
    854990               {
     
    9331069
    9341070   delete [] resampled_grid;
    935                
     1071
    9361072   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
    9371073   return;
     
    9511087   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << "entering...\n";
    9521088   if(!theGridData) return;
    953 
    954    //***
    955    // Allocate buffer to store resampled nodes:
    956    //***
    957    int      buf_size          = theSize.x*theSize.y;
    958    double*  resampled_grid    = new double [buf_size];
    959    for (int i=0; i<buf_size; i++)
    960       resampled_grid[i] = 0.0;
    9611089
    9621090   int      rx      = (size_x - 1)/2;     // kernel radii
     
    9671095   int      end_y   = theSize.y - ry;
    9681096   int      knl_ctr = ry*size_x + rx;     // offset to center of kernel buffer
    969    double   node_value;
    970    double   kernel_value;
    971    int      node_idx;
     1097   double   node_value, kernel_value;
     1098   int      node_idx, resample_node_idx;
    9721099   
    973    //***
     1100   // The resampled data is accumulated and stored in a temporary ossimDblGrid object so that we
     1101   // can take advantage of the extrapolation feature later in this method.
     1102   ossimIpt resample_grid_size(end_x-start_x, end_y-start_y);
     1103   ossimDpt resample_grid_origin(start_x, start_y);
     1104   ossimDpt resample_grid_spacing(1,1);
     1105   ossimDblGrid resample_grid(resample_grid_size, resample_grid_origin, resample_grid_spacing);
     1106   resample_grid.enableExtrapolation();
     1107   resample_grid.fill(0.0);
     1108
    9741109   // Loop over the entire grid to resample all NULL nodes:
    975    //***
    9761110   for (int y=start_y; y<end_y; y++)
    9771111   {
     
    9791113      {
    9801114         node_idx = index(x, y);
    981          
    982          //***
     1115         resample_node_idx = resample_grid.index(x-start_x, y-start_y);
     1116     
    9831117         // Fetch samples for each kernel element, apply gain, then accumulate
    9841118         // in output buffer:
    985          //***
    9861119         for (int ky=-ry; ky<=ry; ky++)
    9871120         {
     
    9901123               node_value = theGridData[index(x+kx, y+ky)];
    9911124               kernel_value = kernel[knl_ctr + ky*size_x + kx];
    992                resampled_grid[node_idx] += kernel_value*node_value;
     1125               resample_grid.theGridData[resample_node_idx] += kernel_value*node_value;
    9931126            }
    9941127         }
    9951128      }
    9961129   }
    997 
    998    //***
    999    // The grid margin has unfiltered data due to the kernel radius. Set these
    1000    // nodes equal to the nearest filtered nodes:
    1001    //***
     1130   
     1131   // Copy the resampled data to the original grid.
     1132   // Note: the grid margin has unfiltered data due to the kernel radius. Use the resample_grid's
     1133   // inherent extrapolator to fill in these unfiltered border nodes:
    10021134   for (int y=0; y<theSize.y; y++)
    10031135   {
    10041136      for (int x=0; x<theSize.x; x++)
    10051137      {
    1006          //***
    1007          // Top edge:
    1008          //***
    1009          if (y < start_y)
    1010          {
    1011             if (x < start_x)      // top-left corner
    1012                resampled_grid[index(x, y)] = resampled_grid[index(rx, ry)];
    1013             else if (x >= end_x)  // top-right corner
    1014                resampled_grid[index(x, y)] = resampled_grid[index(end_x-1, ry)];
    1015             else                  // top region
    1016                resampled_grid[index(x, y)] = resampled_grid[index(x, ry)];
    1017          }
    1018 
    1019          //***
    1020          // Middle:
    1021          //***
    1022          else if (y < end_y)
    1023          {
    1024             if (x < start_x)      // left edge
    1025                resampled_grid[index(x, y)] = resampled_grid[index(rx, y)];
    1026             else if (x >= end_x)  // right edge
    1027                resampled_grid[index(x, y)] = resampled_grid[index(end_x-1, y)];
    1028          }
    1029 
    1030          //***
    1031          // Bottom:
    1032          //***
    1033          else
    1034          {
    1035             if (x < start_x)      // bottom-left corner
    1036                resampled_grid[index(x, y)] = resampled_grid[index(rx, end_y-1)];
    1037             else if (x >= end_x)  // bottom-right corner
    1038                resampled_grid[index(x, y)] = resampled_grid[index(end_x-1,
    1039                                                                   end_y-1)];
    1040             else                  // bottom region
    1041                resampled_grid[index(x, y)] = resampled_grid[index(x, end_y-1)];
    1042          }
    1043       }
    1044    }
    1045    
    1046    //***
    1047    // Now copy the resampled grid back into the original buffer:
    1048    //***
    1049    for (node_idx=0; node_idx<buf_size; node_idx++)
    1050       theGridData[node_idx] = resampled_grid[node_idx];
    1051 
    1052    delete [] resampled_grid;
    1053                
     1138         theGridData[index(x, y)] = resample_grid(x, y); // automatically extrapolates if necessary
     1139      }
     1140   }
     1141
    10541142   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
    10551143   return;
     
    10661154{
    10671155   if (!theGridData)
    1068      {
    1069        return;
    1070      }
    1071    
     1156   {
     1157      return;
     1158   }
     1159
    10721160   int size = theSize.x * theSize.y;
    10731161   for (int i=0; i<size; i++)
    10741162      theGridData[i] = fill_value;
    1075    
     1163
    10761164   return;
    10771165}
    10781166
     1167//*************************************************************************************************
     1168// Constrains the value to the numerical domain specified in theDomainType.
     1169//*************************************************************************************************
     1170void ossimDblGrid::constrain(double& value) const
     1171{
     1172   if ((theDomainType == CONTINUOUS) || (value == theNullValue))
     1173      return;
     1174     
     1175   // Consider again the domain to verify the value is within allowable range:
     1176   if (theDomainType == WRAP_180)
     1177   {
     1178      if (value <= -180.0)
     1179         value += 360.0;
     1180      else if (value > 180.0)
     1181         value -= 360.0;
     1182   }
     1183   else if (theDomainType == WRAP_360)
     1184   {
     1185      if (value < 0.0)
     1186         value += 360.0;
     1187      else if (value >= 360.0)
     1188         value -= 360.0;
     1189   }
     1190   //else if (theDomainType == SAWTOOTH_90)
     1191   //{
     1192   //   // Any adjustment here corrupts the data value since it is clipped:
     1193   //   if (value < -90.0)
     1194   //      value = -90.0;
     1195   //   else if (value > 90.0)
     1196   //      value = 90.0;
     1197   //}
     1198}
    10791199
    10801200//*****************************************************************************
     
    10971217
    10981218   if(grid.theGridData)
    1099      {
    1100        
    1101        for (int y=0; y<grid.theSize.y; y++)
    1102         {
    1103            for (int x=0; x<grid.theSize.x; x++)
    1104              {
    1105                os << "\n  node(" << x << ", " << y << "): " << grid.getNode(x,y);
    1106              }
    1107         }
    1108      }
     1219   {
     1220
     1221      for (int y=0; y<grid.theSize.y; y++)
     1222      {
     1223         for (int x=0; x<grid.theSize.x; x++)
     1224         {
     1225            os << "\n  node(" << x << ", " << y << "): " << grid.getNode(x,y);
     1226         }
     1227      }
     1228   }
    11091229
    11101230   return os;
  • trunk/ossim/src/ossim/base/ossimEllipsoid.cpp

    r17941 r18693  
    4141      theName(ellipsoid.theName),
    4242      theCode(ellipsoid.theCode),
     43      theEpsgCode(ellipsoid.theEpsgCode),
    4344      theA(ellipsoid.theA),
    4445      theB(ellipsoid.theB),
     
    4849      theEccentricitySquared(ellipsoid.theEccentricitySquared)
    4950{
    50    theEpsgCode = ossimEllipsoidFactory::instance()->findEpsgCode(theCode);
     51   if ( theEpsgCode == 0 )
     52   {
     53      theEpsgCode = ossimEllipsoidFactory::instance()->findEpsgCode(theCode);
     54   }
    5155}
    5256
     
    9599      theB_squared(b*b)
    96100{
    97    computeFlattening();
    98 
    99    theEccentricitySquared = 2*theFlattening - theFlattening*theFlattening;
    100  }
     101   // First check if this is just WGS84:
     102   const ossimEllipsoid* wgs84 = ossimEllipsoidFactory::instance()->wgs84();
     103   if ((theA == wgs84->theA) && (theB == wgs84->theB))
     104   {
     105      *this = *wgs84;
     106   }
     107   else
     108   {
     109      computeFlattening();
     110      theEccentricitySquared = 2*theFlattening - theFlattening*theFlattening;
     111   }
     112}
    101113
    102114//*****************************************************************************
     
    606618   return theEpsgCode;
    607619}
     620
     621const ossimEllipsoid& ossimEllipsoid::operator=(const ossimEllipsoid& copy_me)
     622{
     623   if (this != &copy_me)
     624   {
     625      theName = copy_me.theName;
     626      theCode = copy_me.theCode;
     627      theEpsgCode = copy_me.theEpsgCode;
     628      theA = copy_me.theA; 
     629      theB = copy_me.theB; 
     630      theFlattening = copy_me.theFlattening;
     631      theA_squared = copy_me.theA_squared;
     632      theB_squared = copy_me.theB_squared;
     633      theEccentricitySquared = copy_me.theEccentricitySquared;
     634   }
     635   return *this;
     636}
  • trunk/ossim/src/ossim/base/ossimEpsgDatumFactory.cpp

    r17816 r18693  
    4343ossimEpsgDatumFactory::ossimEpsgDatumFactory()
    4444{
    45    m_epsgToAlphaMap.insert(std::make_pair(4135, ossimString("OHI-M")));
    46    m_epsgToAlphaMap.insert(std::make_pair(4139, ossimString("PUR")));
    47    m_epsgToAlphaMap.insert(std::make_pair(4152, ossimString("NAR")));
    48    m_epsgToAlphaMap.insert(std::make_pair(4154, ossimString("EUR-M"))); // QUESTIONABLE 
    49    m_epsgToAlphaMap.insert(std::make_pair(4155, ossimString("DAL")));
    50    m_epsgToAlphaMap.insert(std::make_pair(4156, ossimString("CCD")));
    51    m_epsgToAlphaMap.insert(std::make_pair(4158, ossimString("NAP")));
    52    m_epsgToAlphaMap.insert(std::make_pair(4165, ossimString("BID")));
    53    m_epsgToAlphaMap.insert(std::make_pair(4169, ossimString("AMA")));
    54    m_epsgToAlphaMap.insert(std::make_pair(4175, ossimString("SRL")));   // QUESTIONABLE
    55    m_epsgToAlphaMap.insert(std::make_pair(4201, ossimString("ADI-M")));
    56    m_epsgToAlphaMap.insert(std::make_pair(4202, ossimString("AUA")));
    57    m_epsgToAlphaMap.insert(std::make_pair(4203, ossimString("AUG")));
    58    m_epsgToAlphaMap.insert(std::make_pair(4204, ossimString("AIN-A"))); // QUESTIONABLE
    59    m_epsgToAlphaMap.insert(std::make_pair(4205, ossimString("AFG")));
    60    m_epsgToAlphaMap.insert(std::make_pair(4209, ossimString("ARF-M")));
    61    m_epsgToAlphaMap.insert(std::make_pair(4210, ossimString("ARS-M")));
    62    m_epsgToAlphaMap.insert(std::make_pair(4216, ossimString("BER")));
    63    m_epsgToAlphaMap.insert(std::make_pair(4218, ossimString("BOO")));   // QUESTIONABLE
    64    m_epsgToAlphaMap.insert(std::make_pair(4219, ossimString("BUR")));
    65    m_epsgToAlphaMap.insert(std::make_pair(4221, ossimString("CAI")));
    66    m_epsgToAlphaMap.insert(std::make_pair(4222, ossimString("CAP")));
    67    m_epsgToAlphaMap.insert(std::make_pair(4223, ossimString("CGE")));
    68    m_epsgToAlphaMap.insert(std::make_pair(4224, ossimString("CHU")));
    69    m_epsgToAlphaMap.insert(std::make_pair(4236, ossimString("HTN")));
    70    m_epsgToAlphaMap.insert(std::make_pair(4238, ossimString("IDN")));
    71    m_epsgToAlphaMap.insert(std::make_pair(4239, ossimString("INF-A"))); // QUESTIONABLE
    72    m_epsgToAlphaMap.insert(std::make_pair(4240, ossimString("INH-A"))); // QUESTIONABLE
    73    m_epsgToAlphaMap.insert(std::make_pair(4244, ossimString("KAN")));
    74    m_epsgToAlphaMap.insert(std::make_pair(4245, ossimString("KEA")));
    75    m_epsgToAlphaMap.insert(std::make_pair(4248, ossimString("PRP-M"))); // QUESTIONABLE
    76    m_epsgToAlphaMap.insert(std::make_pair(4250, ossimString("LEH")));
    77    m_epsgToAlphaMap.insert(std::make_pair(4251, ossimString("LIB")));
    78    m_epsgToAlphaMap.insert(std::make_pair(4253, ossimString("LUZ-A"))); // QUESTIONABLE
    79    m_epsgToAlphaMap.insert(std::make_pair(4255, ossimString("HEN")));
    80    m_epsgToAlphaMap.insert(std::make_pair(4256, ossimString("MIK")));
    81    m_epsgToAlphaMap.insert(std::make_pair(4261, ossimString("MER")));
    82    m_epsgToAlphaMap.insert(std::make_pair(4262, ossimString("MAS")));
    83    m_epsgToAlphaMap.insert(std::make_pair(4263, ossimString("MIN-A"))); // QUESTIONABLE
    84    m_epsgToAlphaMap.insert(std::make_pair(4266, ossimString("MPO")));
    85    m_epsgToAlphaMap.insert(std::make_pair(4267, ossimString("NAS-C")));
    86    m_epsgToAlphaMap.insert(std::make_pair(4269, ossimString("NAR-C")));
    87    m_epsgToAlphaMap.insert(std::make_pair(4270, ossimString("NAH-C"))); // QUESTIONABLE
    88    m_epsgToAlphaMap.insert(std::make_pair(4282, ossimString("PTN")));
    89    m_epsgToAlphaMap.insert(std::make_pair(4284, ossimString("PUK")));
    90    m_epsgToAlphaMap.insert(std::make_pair(4285, ossimString("QAT")));   // QUESTIONABLE
    91    m_epsgToAlphaMap.insert(std::make_pair(4287, ossimString("QUO")));
    92    m_epsgToAlphaMap.insert(std::make_pair(4292, ossimString("SAP")));
    93    m_epsgToAlphaMap.insert(std::make_pair(4293, ossimString("SCK")));
    94    m_epsgToAlphaMap.insert(std::make_pair(4297, ossimString("TAN")));
    95    m_epsgToAlphaMap.insert(std::make_pair(4298, ossimString("TIL")));
    96    m_epsgToAlphaMap.insert(std::make_pair(4301, ossimString("TOY-M")));
    97    m_epsgToAlphaMap.insert(std::make_pair(4304, ossimString("VOI")));   // QUESTIONABLE
    98    m_epsgToAlphaMap.insert(std::make_pair(4307, ossimString("NSD")));
    99    m_epsgToAlphaMap.insert(std::make_pair(4309, ossimString("YAC")));
    100    m_epsgToAlphaMap.insert(std::make_pair(4311, ossimString("ZAN")));
    101    m_epsgToAlphaMap.insert(std::make_pair(4322, ossimString("WGD")));
    102    m_epsgToAlphaMap.insert(std::make_pair(4326, ossimString("WGE")));
    103    m_epsgToAlphaMap.insert(std::make_pair(4601, ossimString("AIA")));
    104    m_epsgToAlphaMap.insert(std::make_pair(4604, ossimString("ASM")));
    105    m_epsgToAlphaMap.insert(std::make_pair(4611, ossimString("HKD")));   // QUESTIONABLE
    106    m_epsgToAlphaMap.insert(std::make_pair(4613, ossimString("GSE")));
    107    m_epsgToAlphaMap.insert(std::make_pair(4615, ossimString("POS")));
    108    m_epsgToAlphaMap.insert(std::make_pair(4616, ossimString("SGM")));
    109    m_epsgToAlphaMap.insert(std::make_pair(4618, ossimString("SAN-M")));
    110    m_epsgToAlphaMap.insert(std::make_pair(4658, ossimString("HJO")));
    111    m_epsgToAlphaMap.insert(std::make_pair(4668, ossimString("EUS")));
    112    m_epsgToAlphaMap.insert(std::make_pair(4807, ossimString("NTF")));
     45   m_epsgToAlphaMap.insert(std::make_pair(6135, ossimString("OHI-M")));
     46   m_epsgToAlphaMap.insert(std::make_pair(6139, ossimString("PUR")));
     47   m_epsgToAlphaMap.insert(std::make_pair(6152, ossimString("NAR")));
     48   m_epsgToAlphaMap.insert(std::make_pair(6154, ossimString("EUR-M"))); // QUESTIONABLE 
     49   m_epsgToAlphaMap.insert(std::make_pair(6155, ossimString("DAL")));
     50   m_epsgToAlphaMap.insert(std::make_pair(6156, ossimString("CCD")));
     51   m_epsgToAlphaMap.insert(std::make_pair(6158, ossimString("NAP")));
     52   m_epsgToAlphaMap.insert(std::make_pair(6165, ossimString("BID")));
     53   m_epsgToAlphaMap.insert(std::make_pair(6169, ossimString("AMA")));
     54   m_epsgToAlphaMap.insert(std::make_pair(6175, ossimString("SRL")));   // QUESTIONABLE
     55   m_epsgToAlphaMap.insert(std::make_pair(6201, ossimString("ADI-M")));
     56   m_epsgToAlphaMap.insert(std::make_pair(6202, ossimString("AUA")));
     57   m_epsgToAlphaMap.insert(std::make_pair(6203, ossimString("AUG")));
     58   m_epsgToAlphaMap.insert(std::make_pair(6204, ossimString("AIN-A"))); // QUESTIONABLE
     59   m_epsgToAlphaMap.insert(std::make_pair(6205, ossimString("AFG")));
     60   m_epsgToAlphaMap.insert(std::make_pair(6209, ossimString("ARF-M")));
     61   m_epsgToAlphaMap.insert(std::make_pair(6210, ossimString("ARS-M")));
     62   m_epsgToAlphaMap.insert(std::make_pair(6216, ossimString("BER")));
     63   m_epsgToAlphaMap.insert(std::make_pair(6218, ossimString("BOO")));   // QUESTIONABLE
     64   m_epsgToAlphaMap.insert(std::make_pair(6219, ossimString("BUR")));
     65   m_epsgToAlphaMap.insert(std::make_pair(6221, ossimString("CAI")));
     66   m_epsgToAlphaMap.insert(std::make_pair(6222, ossimString("CAP")));
     67   m_epsgToAlphaMap.insert(std::make_pair(6223, ossimString("CGE")));
     68   m_epsgToAlphaMap.insert(std::make_pair(6224, ossimString("CHU")));
     69   m_epsgToAlphaMap.insert(std::make_pair(6236, ossimString("HTN")));
     70   m_epsgToAlphaMap.insert(std::make_pair(6238, ossimString("IDN")));
     71   m_epsgToAlphaMap.insert(std::make_pair(6239, ossimString("INF-A"))); // QUESTIONABLE
     72   m_epsgToAlphaMap.insert(std::make_pair(6240, ossimString("INH-A"))); // QUESTIONABLE
     73   m_epsgToAlphaMap.insert(std::make_pair(6244, ossimString("KAN")));
     74   m_epsgToAlphaMap.insert(std::make_pair(6245, ossimString("KEA")));
     75   m_epsgToAlphaMap.insert(std::make_pair(6248, ossimString("PRP-M"))); // QUESTIONABLE
     76   m_epsgToAlphaMap.insert(std::make_pair(6250, ossimString("LEH")));
     77   m_epsgToAlphaMap.insert(std::make_pair(6251, ossimString("LIB")));
     78   m_epsgToAlphaMap.insert(std::make_pair(6253, ossimString("LUZ-A"))); // QUESTIONABLE
     79   m_epsgToAlphaMap.insert(std::make_pair(6255, ossimString("HEN")));
     80   m_epsgToAlphaMap.insert(std::make_pair(6256, ossimString("MIK")));
     81   m_epsgToAlphaMap.insert(std::make_pair(6261, ossimString("MER")));
     82   m_epsgToAlphaMap.insert(std::make_pair(6262, ossimString("MAS")));
     83   m_epsgToAlphaMap.insert(std::make_pair(6263, ossimString("MIN-A"))); // QUESTIONABLE
     84   m_epsgToAlphaMap.insert(std::make_pair(6266, ossimString("MPO")));
     85   m_epsgToAlphaMap.insert(std::make_pair(6267, ossimString("NAS-C")));
     86   m_epsgToAlphaMap.insert(std::make_pair(6269, ossimString("NAR-C")));
     87   m_epsgToAlphaMap.insert(std::make_pair(6270, ossimString("NAH-C"))); // QUESTIONABLE
     88   m_epsgToAlphaMap.insert(std::make_pair(6282, ossimString("PTN")));
     89   m_epsgToAlphaMap.insert(std::make_pair(6284, ossimString("PUK")));
     90   m_epsgToAlphaMap.insert(std::make_pair(6285, ossimString("QAT")));   // QUESTIONABLE
     91   m_epsgToAlphaMap.insert(std::make_pair(6287, ossimString("QUO")));
     92   m_epsgToAlphaMap.insert(std::make_pair(6292, ossimString("SAP")));
     93   m_epsgToAlphaMap.insert(std::make_pair(6293, ossimString("SCK")));
     94   m_epsgToAlphaMap.insert(std::make_pair(6297, ossimString("TAN")));
     95   m_epsgToAlphaMap.insert(std::make_pair(6298, ossimString("TIL")));
     96   m_epsgToAlphaMap.insert(std::make_pair(6301, ossimString("TOY-M")));
     97   m_epsgToAlphaMap.insert(std::make_pair(6304, ossimString("VOI")));   // QUESTIONABLE
     98   m_epsgToAlphaMap.insert(std::make_pair(6307, ossimString("NSD")));
     99   m_epsgToAlphaMap.insert(std::make_pair(6309, ossimString("YAC")));
     100   m_epsgToAlphaMap.insert(std::make_pair(6311, ossimString("ZAN")));
     101   m_epsgToAlphaMap.insert(std::make_pair(6322, ossimString("WGD")));
     102   m_epsgToAlphaMap.insert(std::make_pair(6326, ossimString("WGE")));
     103   m_epsgToAlphaMap.insert(std::make_pair(6601, ossimString("AIA")));
     104   m_epsgToAlphaMap.insert(std::make_pair(6604, ossimString("ASM")));
     105   m_epsgToAlphaMap.insert(std::make_pair(6611, ossimString("HKD")));   // QUESTIONABLE
     106   m_epsgToAlphaMap.insert(std::make_pair(6613, ossimString("GSE")));
     107   m_epsgToAlphaMap.insert(std::make_pair(6615, ossimString("POS")));
     108   m_epsgToAlphaMap.insert(std::make_pair(6616, ossimString("SGM")));
     109   m_epsgToAlphaMap.insert(std::make_pair(6618, ossimString("SAN-M")));
     110   m_epsgToAlphaMap.insert(std::make_pair(6658, ossimString("HJO")));
     111   m_epsgToAlphaMap.insert(std::make_pair(6668, ossimString("EUS")));
     112   m_epsgToAlphaMap.insert(std::make_pair(6807, ossimString("NTF")));
    113113}
    114114
     
    163163//! Creates given an EPSG spec in the form "EPSG:<datum_code>".
    164164//*************************************************************************************************
    165 const ossimDatum* ossimEpsgDatumFactory::create(ossim_uint32 gcs_code) const
    166 {
     165const ossimDatum* ossimEpsgDatumFactory::create(ossim_uint32 datum_code) const
     166{
     167   // Geographic coordinate system codes (4XXX) are sometimes used in place of their corresponding
     168   // datum code (6XXX). Check for this possibility and transpose the code if so:
     169   if ((datum_code >= 4135) && (datum_code <= 4807))
     170      datum_code += 2000;
     171
    167172   // Find the datum code in the map in order to determine the corresponding OSSIM/Geotrans alpha
    168173   // code. Then use the datum factory to create the datum.
    169    ossimString alphaCode = findAlphaCode(gcs_code);
     174   ossimString alphaCode = findAlphaCode(datum_code);
    170175   if (!alphaCode.empty())
    171176      return ossimDatumFactory::instance()->create(alphaCode);
  • trunk/ossim/src/ossim/base/ossimKeywordNames.cpp

    r17609 r18693  
    132132const char* ossimKeywordNames::PROJECTION_KW     = "projection";
    133133const char* ossimKeywordNames::QUALITY_KW        = "quality";
     134const char* ossimKeywordNames::QUERY_KW = "query";
    134135const char* ossimKeywordNames::RADIOMETRY_KW = "radiometry";
    135136const char* ossimKeywordNames::REDUCED_RES_LEVEL_KW = "reduced_res_level";
  • trunk/ossim/src/ossim/imaging/ossimImageGeometry.cpp

    r18575 r18693  
    584584}
    585585
     586//**************************************************************************************************
     587//! Returns the ossimGpts for the four image corner points
     588//**************************************************************************************************
     589bool ossimImageGeometry::getCornerGpts(ossimGpt& gul, ossimGpt& gur,
     590                                       ossimGpt& glr, ossimGpt& gll) const
     591{
     592   ossimDpt iul (0,0);
     593   ossimDpt iur (m_imageSize.x-1, 0);
     594   ossimDpt ilr (m_imageSize.x-1, m_imageSize.y-1);
     595   ossimDpt ill (0, m_imageSize.y-1);
     596
     597   bool status = true;
     598
     599   status &= localToWorld(iul, gul);
     600   status &= localToWorld(iur, gur);
     601   status &= localToWorld(ilr, glr);
     602   status &= localToWorld(ill, gll);
     603
     604   return status;
     605}
     606
     607//**************************************************************************************************
    586608void ossimImageGeometry::undecimatePoint(const ossimDpt& rnPt,
    587609                                         ossim_uint32 resolutionLevel,
     
    613635}
    614636
     637//**************************************************************************************************
    615638void ossimImageGeometry::decimatePoint(const ossimDpt& inPt,
    616639                                       ossim_uint32 resolutionLevel,
  • trunk/ossim/src/ossim/imaging/ossimImageHandlerFactory.cpp

    r18002 r18693  
    149149      if (copyFilename.ext() != "ovr")
    150150      {
    151          // Note:  SRTM should be in front of general raster...
     151         // Note:  SRTM should be in front of general raster..
    152152         if (traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG)<<M<< "Trying SRTM...";
    153153         result = new ossimSrtmTileSource;
     
    604604   }
    605605   
    606    if(traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG)<<M<<"Testing RAS or RAW..."<<std::endl;
    607    if ( (testExt == "ras") || (testExt == "raw") )
     606   if(traceDebug()) ossimNotify(ossimNotifyLevel_DEBUG)<<M<<"Testing RAS or RAW or General Raster..."<<std::endl;
     607   if ( (testExt == "ras") || (testExt == "raw") || (testExt == "bil"))
    608608   {
    609609      result.push_back(new ossimGeneralRasterTileSource);
  • trunk/ossim/src/ossim/projection/ossimCoarseGridModel.cpp

    r17815 r18693  
    6363      << std::endl;
    6464
     65   theLatGrid.setDomainType(ossimDblGrid::SAWTOOTH_90);
     66   theLonGrid.setDomainType(ossimDblGrid::WRAP_180);
     67   theLatGrid.enableExtrapolation();
     68   theLonGrid.enableExtrapolation();
     69
    6570   setErrorStatus();
    6671
     
    8287      theDlatDhGrid     (model.theDlatDhGrid),
    8388      theDlonDhGrid     (model.theDlonDhGrid),
     89      theDlatDparamGrid (0),
     90      theDlonDparamGrid (0),
    8491      theHeightEnabledFlag(true)
    8592{
     
    124131   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimCoarseGridModel::ossimCoarseGridModel(geom_file): entering..." << std::endl;
    125132   
     133   theLatGrid.setDomainType(ossimDblGrid::SAWTOOTH_90);
     134   theLonGrid.setDomainType(ossimDblGrid::WRAP_180);
     135   theLatGrid.enableExtrapolation();
     136   theLonGrid.enableExtrapolation();
     137
    126138   ossimKeywordlist kwl (geom_file);
    127139   loadState(kwl);
     
    146158   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimCoarseGridModel::ossimCoarseGridModel(geom_kwl): entering..." << std::endl;
    147159
    148    // Parse keywordlist for geometry:
     160   theLatGrid.setDomainType(ossimDblGrid::SAWTOOTH_90);
     161   theLonGrid.setDomainType(ossimDblGrid::WRAP_180);
     162   theLatGrid.enableExtrapolation();
     163   theLonGrid.enableExtrapolation();
     164
     165  // Parse keywordlist for geometry:
    149166   loadState(geom_kwl);
    150167}
     
    176193   theHeightEnabledFlag =  enableHeightFlag;
    177194   
    178    if(geom->getProjection()&&(!imageBounds.hasNans()))
    179    {
    180      // don't let it get any smaller than 100, 100 pixels
    181      // on the input projector
    182      //
    183      // may want this to be adjusted by outside
    184      //
    185      const ossimDatum* targetDatum = ossimDatumFactory::instance()->wgs84();
    186      ossimIpt gridSize(2,2);
    187      ossimDpt gridOrigin(0,0);
    188      ossimGpt gpt;
    189      ossimGpt gpt2;
    190      ossimGpt bilinearGpt;
    191      resizeAdjustableParameterArray(0);
    192      double normSplit = 1.0;
    193      ossimDpt imageSize(imageBounds.width(),
    194                         imageBounds.height());
    195      double error = 0.0;
    196 
    197      // int y=0;
    198      // int x=0;
    199      // double ht=0, vt=0;
    200      // double w = imageBounds.width();
    201      // double h = imageBounds.height();
    202      ossimIpt imageOrigin = imageBounds.ul();
    203      // ossimDpt metersPerPixel = proj->getMetersPerPixel();
    204      ossimDpt spacing ((double)(imageBounds.width()-1)/(gridSize.x-1),
    205                        (double)(imageBounds.height()-1)/(gridSize.y-1));
    206 
    207      if(theDlatDparamGrid)
    208      {
    209         delete [] theDlatDparamGrid;
    210         theDlatDparamGrid = NULL;
    211      }
    212      if(theDlonDparamGrid)
    213      {
    214         delete [] theDlonDparamGrid;
    215         theDlonDparamGrid = NULL;
    216      }
    217      
    218      geom->localToWorld(imageBounds.midPoint(), gpt);
    219 
    220      do
    221      {
    222         if(traceDebug())
    223         {
    224            ossimNotify(ossimNotifyLevel_DEBUG) << "Checking grid size " << gridSize << std::endl;
    225         }
    226        
    227         spacing = ossimDpt((double)(imageBounds.width()-1)/(gridSize.x-1),
    228                            (double)(imageBounds.height()-1)/(gridSize.y-1));
    229 
    230         theLatGrid.setNullValue(ossim::nan());
    231         theLonGrid.setNullValue(ossim::nan());
    232         theDlatDhGrid.setNullValue(0.0);
    233         theDlonDhGrid.setNullValue(0.0);
    234         theLatGrid.initialize(gridSize, gridOrigin, spacing);
    235         theLonGrid.initialize(gridSize, gridOrigin, spacing);
    236         theDlatDhGrid.initialize(gridSize, gridOrigin, spacing);
    237         theDlonDhGrid.initialize(gridSize, gridOrigin, spacing);
    238         ossim_int32 x, y;
    239        
    240         for(y = 0; y < gridSize.y; ++y)
    241         {
    242            for(x = 0; x < gridSize.x; ++x)
    243            {
    244               ossimDpt norm((double)x/(double)(gridSize.x-1),
    245                             (double)y/(double)(gridSize.y-1));
    246              
    247               ossimDpt pt(imageOrigin.x + norm.x*(imageSize.x-1),
    248                           imageOrigin.y + norm.y*(imageSize.y-1));
    249              
    250               geom->localToWorld(pt, gpt);
    251               double h = gpt.height();
    252               if(ossim::isnan(h))
    253               {
    254                  h += heightDelta;
    255               }
    256               ossimDpt fullPt;
    257               geom->rnToFull(pt, 0, fullPt);
    258               geom->getProjection()->lineSampleHeightToWorld(fullPt, h, gpt2);
    259               gpt.changeDatum(targetDatum);
    260               gpt2.changeDatum(targetDatum);
    261              
    262               theLatGrid.setNode(x, y, gpt.latd());
    263               theLonGrid.setNode(x, y, gpt.lond());
    264 
    265               theDlatDhGrid.setNode(x, y, (gpt2.latd() - gpt.latd())/heightDelta);
    266               theDlonDhGrid.setNode(x, y, (gpt2.lond() - gpt.lond())/heightDelta);
    267            }
    268         }
    269         ossim_int32 upperY = 2*gridSize.y;
    270         ossim_int32 upperX = 2*gridSize.x;
    271         error = 0.0;
    272 
    273         ossimDpt v[4];
    274         v[0].lat = theLatGrid.getNode(0,0);
    275         v[0].lon = theLonGrid.getNode(0,0);
    276         v[1].lat = theLatGrid.getNode(gridSize.x-1, 0);
    277         v[1].lon = theLonGrid.getNode(gridSize.x-1, 0);
    278         v[2].lat = theLatGrid.getNode(gridSize.x-1, gridSize.y-1);
    279         v[2].lon = theLonGrid.getNode(gridSize.x-1, gridSize.y-1);
    280         v[3].lat = theLatGrid.getNode(0, gridSize.y-1);
    281         v[3].lon = theLonGrid.getNode(0, gridSize.y-1);
    282         theBoundGndPolygon = ossimPolygon(4, v);
    283        
    284        
    285         theImageSize  = ossimDpt(imageBounds.width(), imageBounds.height());
    286         theRefImgPt   = imageBounds.midPoint();
    287         theRefGndPt   = ossimGpt(theLatGrid(theRefImgPt),
    288                                  theLonGrid(theRefImgPt));
    289         ossimDpt ref_ip_dx(theRefImgPt.x+1.0, theRefImgPt.y);
    290         ossimDpt ref_ip_dy(theRefImgPt.x, theRefImgPt.y+1.0);
    291         ossimGpt ref_gp_dx(theLatGrid(ref_ip_dx), theLonGrid(ref_ip_dx));
    292         ossimGpt ref_gp_dy(theLatGrid(ref_ip_dy), theLonGrid(ref_ip_dy));
    293 
    294         theGSD.x   = theRefGndPt.distanceTo(ref_gp_dx);
    295         theGSD.y   = theRefGndPt.distanceTo(ref_gp_dy);
    296 
    297         theMeanGSD = (theGSD.line + theGSD.samp)/2.0;
    298         theImageClipRect  = imageBounds;
    299         theSubImageOffset = ossimIpt(0,0);
    300 
    301         for(y = 0; ((y < upperY)&&(error < theInterpolationError)); ++y)
    302         {
    303            for(x = 0; ((x < upperX)&&(error<theInterpolationError)); ++x)
    304            {
    305               ossimDpt norm((double)x/(double)(upperX-1),
    306                             (double)y/(double)(upperY-1));
    307              
    308               ossimDpt imagePoint(imageOrigin.x + norm.x*(imageSize.x-1),
    309                                   imageOrigin.y + norm.y*(imageSize.y-1));
    310               ossimDpt testIpt;
    311 
    312                geom->localToWorld(imagePoint, gpt);
    313                worldToLineSample(gpt, testIpt);
    314                error = (testIpt-imagePoint).length();
    315            }
    316         }
    317 
    318         gridSize.x *= 2;
    319         gridSize.y *= 2;
    320         normSplit *= .5;
    321      }while((error > theInterpolationError)&&
    322             ((imageSize.x*normSplit) > theMinGridSpacing)&&
    323             ((imageSize.y*normSplit) > theMinGridSpacing));
    324 
    325 
    326      gridSize = theLatGrid.size();
    327 
    328      ossimAdjustableParameterInterface* adjustableParameters = PTR_CAST(ossimAdjustableParameterInterface,
    329                                                                         geom->getProjection());
    330      removeAllAdjustments();
    331      if(adjustableParameters&&makeAdjustableFlag)
    332      {
    333         if(adjustableParameters->getNumberOfAdjustableParameters() > 0)
    334         {
    335            newAdjustment(adjustableParameters->getNumberOfAdjustableParameters());
    336 
    337            int numberOfParams = getNumberOfAdjustableParameters();
    338            if(numberOfParams)
    339            {
    340               //***
    341               // Allocate adjustable parameter partials grids then assign:
    342               //***
    343               theDlatDparamGrid = new ossimDblGrid [numberOfParams];
    344               theDlonDparamGrid = new ossimDblGrid [numberOfParams];
    345               ossim_uint32 paramIdx = 0;
    346               for(paramIdx = 0; paramIdx < getNumberOfAdjustableParameters(); ++ paramIdx)
    347               {
    348                  theDlonDparamGrid[paramIdx].setNullValue(0.0);
    349                  theDlatDparamGrid[paramIdx].setNullValue(0.0);
    350                  theDlatDparamGrid[paramIdx].initialize(gridSize, gridOrigin, spacing);
    351                  theDlonDparamGrid[paramIdx].initialize(gridSize, gridOrigin, spacing);
    352                  setAdjustableParameter(paramIdx,
    353                                         0.0);
    354                  setParameterSigma(paramIdx,
    355                                    adjustableParameters->getParameterSigma(paramIdx));
    356                  setParameterUnit(paramIdx,
    357                                   adjustableParameters->getParameterUnit(paramIdx));
    358                  setParameterCenter(paramIdx,
    359                                     0.0);
    360                  setParameterDescription(paramIdx,
    361                                          adjustableParameters->getParameterDescription(paramIdx));
    362 
    363                  double oldParameter = adjustableParameters->getAdjustableParameter(paramIdx);
    364                  adjustableParameters->setAdjustableParameter(paramIdx, 1.0, true);
    365                  double adjust = adjustableParameters->computeParameterOffset(paramIdx);
    366                  double deltaLat = 0;
    367                  double deltaLon = 0;
    368                  if(adjust != 0.0)
    369                  {
    370                     for(int y = 0; y < gridSize.y; ++y)
    371                     {
    372                        for(int x = 0; x < gridSize.x; ++x)
    373                        {
    374                           ossimDpt norm((double)x/(double)(gridSize.x-1),
    375                                         (double)y/(double)(gridSize.y-1));
    376                          
    377                           ossimDpt pt(imageOrigin.x + norm.x*(imageSize.x-1),
    378                                       imageOrigin.y + norm.y*(imageSize.y-1));
    379                           geom->localToWorld(pt, gpt);
    380 
    381                           gpt.changeDatum(targetDatum);
    382                           gpt2.latd(theLatGrid(pt));
    383                           gpt2.lond(theLonGrid(pt));
    384                           deltaLat = gpt.latd()-gpt2.latd();
    385                           deltaLon = gpt.lond()-gpt2.lond();
    386 
    387                           theDlatDparamGrid[paramIdx].setNode(x, y,
    388                                                               deltaLat/adjust);
    389                           theDlonDparamGrid[paramIdx].setNode(x, y,
    390                                                               deltaLon/adjust);
    391                        }
    392                     }
    393                  }
    394                  adjustableParameters->setAdjustableParameter(paramIdx, oldParameter, true);
    395               }
    396            }
    397         }
    398      }
    399      getAdjustment(theInitialAdjustment);
    400   }
     195   if (!geom->getProjection() || !imageBounds.hasNans())
     196      return;
     197
     198   // don't let it get any smaller than 100, 100 pixels
     199   // on the input projector
     200   //
     201   // may want this to be adjusted by outside
     202   //
     203   const ossimDatum* targetDatum = ossimDatumFactory::instance()->wgs84();
     204   ossimIpt gridSize(2,2);
     205   ossimDpt gridOrigin(0,0);
     206   ossimGpt gpt;
     207   ossimGpt gpt2;
     208   ossimGpt bilinearGpt;
     209   resizeAdjustableParameterArray(0);
     210   double normSplit = 1.0;
     211   ossimIpt imageSize = ossimIpt(imageBounds.width(), imageBounds.height());
     212   double error = 0.0;
     213
     214   ossimIpt imageOrigin = imageBounds.ul();
     215   ossimDpt spacing ((double)(imageBounds.width()-1)/(gridSize.x-1),
     216      (double)(imageBounds.height()-1)/(gridSize.y-1));
     217
     218   if(theDlatDparamGrid)
     219   {
     220      delete [] theDlatDparamGrid;
     221      theDlatDparamGrid = NULL;
     222   }
     223   if(theDlonDparamGrid)
     224   {
     225      delete [] theDlonDparamGrid;
     226      theDlonDparamGrid = NULL;
     227   }
     228
     229   geom->localToWorld(imageBounds.midPoint(), gpt);
     230
     231   do
     232   {
     233      if(traceDebug())
     234      {
     235         ossimNotify(ossimNotifyLevel_DEBUG) << "Checking grid size " << gridSize << std::endl;
     236      }
     237
     238      spacing = ossimDpt((double)(imageBounds.width()-1)/(gridSize.x-1),
     239         (double)(imageBounds.height()-1)/(gridSize.y-1));
     240
     241      theLatGrid.setNullValue(ossim::nan());
     242      theLonGrid.setNullValue(ossim::nan());
     243      theDlatDhGrid.setNullValue(0.0);
     244      theDlonDhGrid.setNullValue(0.0);
     245      theLatGrid.setDomainType(ossimDblGrid::SAWTOOTH_90);
     246      theLonGrid.setDomainType(ossimDblGrid::WRAP_180);
     247      theLatGrid.initialize(gridSize, gridOrigin, spacing);
     248      theLonGrid.initialize(gridSize, gridOrigin, spacing);
     249      theDlatDhGrid.initialize(gridSize, gridOrigin, spacing);
     250      theDlonDhGrid.initialize(gridSize, gridOrigin, spacing);
     251      ossim_int32 x, y;
     252
     253      for(y = 0; y < gridSize.y; ++y)
     254      {
     255         for(x = 0; x < gridSize.x; ++x)
     256         {
     257            ossimDpt norm((double)x/(double)(gridSize.x-1),
     258               (double)y/(double)(gridSize.y-1));
     259
     260            ossimDpt pt(imageOrigin.x + norm.x*(imageSize.x-1),
     261               imageOrigin.y + norm.y*(imageSize.y-1));
     262
     263            geom->localToWorld(pt, gpt);
     264            double h = gpt.height();
     265            if(ossim::isnan(h))
     266            {
     267               h += heightDelta;
     268            }
     269            ossimDpt fullPt;
     270            geom->rnToFull(pt, 0, fullPt);
     271            geom->getProjection()->lineSampleHeightToWorld(fullPt, h, gpt2);
     272            gpt.changeDatum(targetDatum);
     273            gpt2.changeDatum(targetDatum);
     274
     275            theLatGrid.setNode(x, y, gpt.latd());
     276            theLonGrid.setNode(x, y, gpt.lond());
     277
     278            theDlatDhGrid.setNode(x, y, (gpt2.latd() - gpt.latd())/heightDelta);
     279            theDlonDhGrid.setNode(x, y, (gpt2.lond() - gpt.lond())/heightDelta);
     280         }
     281      }
     282      ossim_int32 upperY = 2*gridSize.y;
     283      ossim_int32 upperX = 2*gridSize.x;
     284      error = 0.0;
     285
     286      // Set all base-class data members needed for subsequent calls to projection code:
     287      initializeModelParams(imageBounds);
     288
     289      for(y = 0; ((y < upperY)&&(error < theInterpolationError)); ++y)
     290      {
     291         for(x = 0; ((x < upperX)&&(error<theInterpolationError)); ++x)
     292         {
     293            ossimDpt norm((double)x/(double)(upperX-1),
     294               (double)y/(double)(upperY-1));
     295
     296            ossimDpt imagePoint(imageOrigin.x + norm.x*(imageSize.x-1),
     297               imageOrigin.y + norm.y*(imageSize.y-1));
     298            ossimDpt testIpt;
     299
     300            geom->localToWorld(imagePoint, gpt);
     301            worldToLineSample(gpt, testIpt);
     302            error = (testIpt-imagePoint).length();
     303         }
     304      }
     305
     306      gridSize.x *= 2;
     307      gridSize.y *= 2;
     308      normSplit *= .5;
     309   } while((error > theInterpolationError) &&
     310           ((imageSize.x*normSplit) > theMinGridSpacing) &&
     311           ((imageSize.y*normSplit) > theMinGridSpacing));
     312
     313   gridSize = theLatGrid.size();
     314
     315   ossimAdjustableParameterInterface* adjustableParameters =
     316      PTR_CAST(ossimAdjustableParameterInterface, geom->getProjection());
     317   removeAllAdjustments();
     318   if(adjustableParameters&&makeAdjustableFlag)
     319   {
     320      if(adjustableParameters->getNumberOfAdjustableParameters() > 0)
     321      {
     322         newAdjustment(adjustableParameters->getNumberOfAdjustableParameters());
     323
     324         int numberOfParams = getNumberOfAdjustableParameters();
     325         if(numberOfParams)
     326         {
     327            //***
     328            // Allocate adjustable parameter partials grids then assign:
     329            //***
     330            theDlatDparamGrid = new ossimDblGrid [numberOfParams];
     331            theDlonDparamGrid = new ossimDblGrid [numberOfParams];
     332            for(int paramIdx = 0; paramIdx < numberOfParams; ++ paramIdx)
     333            {
     334               theDlonDparamGrid[paramIdx].setNullValue(0.0);
     335               theDlatDparamGrid[paramIdx].setNullValue(0.0);
     336               theDlatDparamGrid[paramIdx].initialize(gridSize, gridOrigin, spacing);
     337               theDlonDparamGrid[paramIdx].initialize(gridSize, gridOrigin, spacing);
     338               setAdjustableParameter(paramIdx, 0.0);
     339               setParameterSigma(paramIdx, adjustableParameters->getParameterSigma(paramIdx));
     340               setParameterUnit(paramIdx, adjustableParameters->getParameterUnit(paramIdx));
     341               setParameterCenter(paramIdx, 0.0);
     342               setParameterDescription(paramIdx,
     343                  adjustableParameters->getParameterDescription(paramIdx));
     344
     345               double oldParameter = adjustableParameters->getAdjustableParameter(paramIdx);
     346               adjustableParameters->setAdjustableParameter(paramIdx, 1.0, true);
     347               double adjust = adjustableParameters->computeParameterOffset(paramIdx);
     348               double deltaLat = 0;
     349               double deltaLon = 0;
     350               if(adjust != 0.0)
     351               {
     352                  for(int y = 0; y < gridSize.y; ++y)
     353                  {
     354                     for(int x = 0; x < gridSize.x; ++x)
     355                     {
     356                        ossimDpt norm((double)x/(double)(gridSize.x-1),
     357                           (double)y/(double)(gridSize.y-1));
     358
     359                        ossimDpt pt(imageOrigin.x + norm.x*(imageSize.x-1),
     360                           imageOrigin.y + norm.y*(imageSize.y-1));
     361                        geom->localToWorld(pt, gpt);
     362
     363                        gpt.changeDatum(targetDatum);
     364                        gpt2.latd(theLatGrid(pt));
     365                        gpt2.lond(theLonGrid(pt));
     366                        deltaLat = gpt.latd()-gpt2.latd();
     367                        deltaLon = gpt.lond()-gpt2.lond();
     368
     369                        theDlatDparamGrid[paramIdx].setNode(x, y, deltaLat/adjust);
     370                        theDlonDparamGrid[paramIdx].setNode(x, y, deltaLon/adjust);
     371                     }
     372                  }
     373
     374                  // The partials grids for this parameter are initialized, now initialize the
     375                  // grid's extrapolator:
     376                  theDlatDparamGrid[paramIdx].enableExtrapolation();
     377                  theDlonDparamGrid[paramIdx].enableExtrapolation();
     378               }
     379               adjustableParameters->setAdjustableParameter(paramIdx, oldParameter, true);
     380            }
     381         }
     382      }
     383   }
     384   getAdjustment(theInitialAdjustment);
     385
     386
    401387}
    402388
     
    409395{
    410396   theMinGridSpacing = minSpacing;
     397}
     398
     399//*************************************************************************************************
     400//! Initializes base class data members after grids have been assigned.
     401//! It is assumed that theImageSize and the origin image point were already set.
     402//*************************************************************************************************
     403void ossimCoarseGridModel::initializeModelParams(ossimIrect imageBounds)
     404{
     405   // NOTE: it is assumed that the grid size and spacing is the same for ALL grids:
     406   ossimIpt gridSize (theLatGrid.size());
     407   ossimDpt spacing  (theLatGrid.spacing());
     408   ossimDpt v[4];
     409   v[0].lat = theLatGrid.getNode(0,0);
     410   v[0].lon = theLonGrid.getNode(0,0);
     411   v[1].lat = theLatGrid.getNode(gridSize.x-1, 0);
     412   v[1].lon = theLonGrid.getNode(gridSize.x-1, 0);
     413   v[2].lat = theLatGrid.getNode(gridSize.x-1, gridSize.y-1);
     414   v[2].lon = theLonGrid.getNode(gridSize.x-1, gridSize.y-1);
     415   v[3].lat = theLatGrid.getNode(0, gridSize.y-1);
     416   v[3].lon = theLonGrid.getNode(0, gridSize.y-1);
     417
     418   // Guaranty longitude values are -180 to 180
     419   for (int i=0; i<4; i++)
     420   {
     421      if (v[i].lon > 180.0)
     422         v[i].lon -= 360.0;
     423   }
     424
     425   theBoundGndPolygon = ossimPolygon(4, v);
     426   
     427   theImageSize  = ossimDpt(imageBounds.width(), imageBounds.height());
     428   theRefImgPt   = imageBounds.midPoint();
     429   theRefGndPt.lat = theLatGrid(theRefImgPt);
     430   theRefGndPt.lon = theLonGrid(theRefImgPt);
     431   
     432   ossimDpt ref_ip_dx (theRefImgPt.x+1.0, theRefImgPt.y    );
     433   ossimDpt ref_ip_dy (theRefImgPt.x    , theRefImgPt.y+1.0);
     434   ossimGpt ref_gp_dx (theLatGrid(ref_ip_dx), theLonGrid(ref_ip_dx));
     435   ossimGpt ref_gp_dy (theLatGrid(ref_ip_dy), theLonGrid(ref_ip_dy));
     436
     437   theGSD.x   = theRefGndPt.distanceTo(ref_gp_dx);
     438   theGSD.y   = theRefGndPt.distanceTo(ref_gp_dy);
     439
     440   theMeanGSD = (theGSD.line + theGSD.samp)/2.0;
     441   theImageClipRect  = imageBounds;
     442   theSubImageOffset = imageBounds.ul();
    411443}
    412444
     
    484516   double height = (ossim::isnan(arg_hgt_above_ellipsoid)) ? 0.0 : arg_hgt_above_ellipsoid;
    485517
    486    // Extrapolate if point is outside image:
    487    if (!insideImage(lineSampPt))
    488    {
    489       worldPt = extrapolate(lineSampPt, height);
    490       if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimCoarseGridModel::lineSampleHeightToWorld: returning..." << std::endl;
    491       return;
    492    }
     518   // Note that there is no check for image point outside of valid image rect because this model
     519   // uses the extrapolation inherent to the ossimDblGrid.
    493520
    494521   // The image point may correspond to an offset sub-image. Need to convert
     
    515542       worldPt.lon += (theDlonDparamGrid[p](ip) * computeParameterOffset(p));
    516543   }
     544
     545   worldPt.limitLonTo180();
    517546
    518547   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimCoarseGridModel::lineSampleHeightToWorld: returning..." << std::endl;
     
    867896
    868897   //***
    869    // Initialize the bounging ground rectangle:
     898   // Initialize the bounding ground rectangle:
    870899   //***
    871900   grid_size = theLatGrid.size();
    872 
    873901
    874902   v[0].lat = theLatGrid(0,0);
     
    881909   v[3].lon = theLonGrid(0, theImageSize.y-1);
    882910
    883 
    884 //     ossimGpt gpt;
    885 //     lineSampleHeightToWorld(ossimDpt(0,0), 0, gpt);
    886 //     v[0].lat = gpt.latd();
    887 //     v[0].lon = gpt.lond();
    888 //     lineSampleHeightToWorld(ossimDpt(grid_size.x-1,0), 0.0, gpt);
    889 //     v[1].lat = gpt.latd();
    890 //     v[1].lon = gpt.lond();
    891 //     lineSampleHeightToWorld(ossimDpt(grid_size.x-1, grid_size.y-1), 0.0, gpt);
    892 //     v[2].lat = gpt.latd();
    893 //     v[2].lon = gpt.lond();
    894 //     lineSampleHeightToWorld(ossimDpt(0,grid_size.y-1), 0.0,gpt);
    895 //     v[3].lat = gpt.latd();
    896 //     v[3].lon = gpt.lond();
    897    
    898911   theBoundGndPolygon = ossimPolygon(4, v);
    899 
    900912   
    901913   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimCoarseGridModel::loadCoarseGrid: returning..." << std::endl;
    902914   return true;
    903 
    904    if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG rossimCoarseGridModel::loadCoarseGrid: eturning with error..." << std::endl;
    905    return false;
    906915}
    907916
     
    949958   theDlatDhGrid.initialize(grid_size, grid_origin, spacing);
    950959   theDlonDhGrid.initialize(grid_size, grid_origin, spacing);
    951 
    952960   
    953961   int numberOfParams = getNumberOfAdjustableParameters();
     
    9971005}
    9981006   
    999 
    1000      
     1007//*************************************************************************************************
     1008// Overrides base-class extrapolation code. Uses extrapolation inherent to ossimDbleGrid
     1009//*************************************************************************************************
     1010ossimGpt ossimCoarseGridModel::extrapolate(const ossimDpt& local_ip, const double& height) const
     1011{
     1012   ossimGpt gpt;
     1013   lineSampleHeightToWorld(local_ip, height, gpt);
     1014   return gpt;
     1015}
  • trunk/ossim/src/ossim/projection/ossimEpsgProjectionDatabase.cpp

    r18189 r18693  
    481481{
    482482   ossimString lost_type (lost_proj.getClassName());
     483
     484   // Shortcut for EPSG:4326 (WGS-85 geographic rectangular -- very common):
     485   if ((lost_type == "ossimEquDistCylProjection") && (lost_proj.getDatum()->epsgCode() == 6326))
     486      return 4326;
     487
    483488   ossimString lookup;
    484489   ossimRefPtr<ossimMapProjection> found_proj = 0;
     
    599604   {
    600605      // Default to WGS 84 -- this may throw an exception:
    601       datum = ossimEpsgDatumFactory::instance()->create(ossimString("EPSG:4326"));
     606      datum = ossimDatumFactory::instance()->create(ossimString("WGE"));
    602607      datum_valid = false;
    603608   }
  • trunk/ossim/src/ossim/projection/ossimEquDistCylProjection.cpp

    r18299 r18693  
    9292   ossimMapProjection::update();
    9393
    94    if (thePcsCode == 0)
     94   // Check if the origin is at (0,0). This implies EPSG:4326
     95   if ((theOrigin.lat == 0.0) && (theOrigin.lon == 0.0) && (theGcsCode == 4326))
     96      thePcsCode = 4326;
     97   else if (thePcsCode == 0)
    9598      thePcsCode = theGcsCode;
    9699}
     
    182185         // -90 <-> +90 handling wrapping, e.g. longitude of 181 becomes -179.
    183186         //---
    184 //        gpt.wrap();
     187         // gpt.wrap();
    185188         
    186189         // Finally assign the specified height:
  • trunk/ossim/src/ossim/projection/ossimMapProjection.cpp

    r18049 r18693  
    127127   // See comments in getPcsCode()
    128128   if ((theGcsCode == 0) && theDatum)
    129       theGcsCode = theDatum->epsgGcsCode();
     129      theGcsCode = theDatum->epsgCode() - 2000;
    130130   return theGcsCode;
    131131}
     
    202202      theDatum = datum;
    203203      setEllipsoid( *(datum->ellipsoid()));
    204       theGcsCode = datum->epsgGcsCode();
     204      theGcsCode = datum->epsgCode() - 2000;
    205205      update();
    206206   }
     
    553553                                                 ossimGpt&      gpt)const
    554554{
    555    //
    556555   // make sure that the passed in lineSample is good and
    557556   // check to make sure our easting northing is good so
    558557   // we can compute the line sample.
    559    //
    560    //
    561558   if(lineSample.hasNans())
    562559   {
     
    961958      // Let's assign a proper GCS code from the EPSG database if needed and available:
    962959      if (theGcsCode == 0)
    963          theGcsCode = theDatum->epsgGcsCode();
     960         theGcsCode = theDatum->epsgCode() - 2000;
    964961   }
    965962   else
     
    13811378       << "\n" << ossimKeywordNames::CENTRAL_MERIDIAN_KW   << ":  "
    13821379       << theOrigin.lond()
     1380       << "\norigin: " << theOrigin
    13831381       << "\n" << ossimKeywordNames::DATUM_KW              << ":  "
    13841382       << (theDatum?theDatum->code().c_str():"unknown")
     
    14001398          << "\n" << ossimKeywordNames::TIE_POINT_UNITS_KW << ": "
    14011399          << ossimUnitTypeLut::instance()->getEntryString(OSSIM_DEGREES)
     1400          << "\n" << ossimKeywordNames::PIXEL_SCALE_XY_KW << ": "
     1401          << theDegreesPerPixel.toString().c_str()
     1402          << "\n" << ossimKeywordNames::PIXEL_SCALE_UNITS_KW << ": "
     1403          << ossimUnitTypeLut::instance()->getEntryString(OSSIM_DEGREES)
    14021404          << std::endl;
    14031405   }
     
    14071409          << theUlEastingNorthing.toString().c_str()
    14081410          << "\n" << ossimKeywordNames::TIE_POINT_UNITS_KW << ": "
     1411          << ossimUnitTypeLut::instance()->getEntryString(OSSIM_METERS)
     1412          << "\n" << ossimKeywordNames::PIXEL_SCALE_XY_KW << ": "
     1413          << theMetersPerPixel.toString().c_str()
     1414          << "\n" << ossimKeywordNames::PIXEL_SCALE_UNITS_KW << ": "
    14091415          << ossimUnitTypeLut::instance()->getEntryString(OSSIM_METERS)
    14101416          << std::endl;
     
    14681474   ossimDpt downMeters  = forward(down);
    14691475
    1470 
    14711476   metersPerPixel.x = (rightMeters - centerMeters).length();
    14721477   metersPerPixel.y = (downMeters  - centerMeters).length();
    1473 
    14741478}
    14751479
     
    15091513   }
    15101514
    1511    if (theDatum != mapProj->theDatum)
     1515   if ( *theDatum != *(mapProj->theDatum) )
    15121516      return false;
    15131517   
  • trunk/ossim/src/ossim/projection/ossimUtmProjection.cpp

    r17815 r18693  
    902902bool ossimUtmProjection::operator==(const ossimProjection& proj) const
    903903{
    904    if (!ossimMapProjection::operator==(proj))
    905       return false;
    906 
    907    ossimUtmProjection* p = PTR_CAST(ossimUtmProjection, &proj);
    908    if (!p) return false;
    909 
    910    if (theZone != p->theZone) return false;
    911    if (theHemisphere != p->theHemisphere) return false;
    912 
    913    return true;
    914 }
     904   bool result = false;
     905   if ( this == &proj )
     906   {
     907      result = true; // Pointer addresses the same.
     908   }
     909   else
     910   {
     911      //---
     912      // Check our stuff first.  No sense going onto ossimMapProjection::operator==
     913      // if we are not a utm projection.
     914      //---
     915      const ossimUtmProjection* p = dynamic_cast<const ossimUtmProjection*>(&proj);
     916      if ( p )
     917      {
     918         if ( theZone == p->theZone )
     919         {
     920            if ( theHemisphere == p->theHemisphere )
     921            {
     922               result = ossimMapProjection::operator==(proj);
     923            }
     924         }
     925      }
     926   }
     927   return result;   
     928}
  • trunk/ossim/src/ossim/support_data/ossimFgdcXmlDoc.cpp

    r17816 r18693  
    88//
    99//----------------------------------------------------------------------------
    10 // $Id: ossimFgdcXmlDoc.cpp 1204 2010-08-02 18:48:46Z david.burken $
     10// $Id: ossimFgdcXmlDoc.cpp 2049 2011-01-15 16:44:47Z david.burken $
    1111
    1212#include <ossim/support_data/ossimFgdcXmlDoc.h>
    13 
     13#include <ossim/base/ossimDatum.h>
     14#include <ossim/base/ossimDatumFactoryRegistry.h>
     15#include <ossim/base/ossimDrect.h>
     16#include <ossim/base/ossimException.h>
     17#include <ossim/base/ossimTrace.h>
    1418#include <ossim/base/ossimXmlNode.h>
    1519#include <ossim/base/ossimKeywordNames.h>
     
    1721#include <ossim/projection/ossimEpsgProjectionFactory.h>
    1822#include <ossim/projection/ossimProjectionFactoryRegistry.h>
    19 
    20 static double METER_PER_FOOT = 0.304801;
    21 
    22 ossimFgdcXmlDoc::ossimFgdcXmlDoc(const ossimFilename& xmlFileName)
    23    : m_xmlFilename(xmlFileName),
     23#include <ossim/projection/ossimUtmProjection.h>
     24
     25#include <cmath> /* for std::fabs */
     26
     27// Static trace for debugging
     28static ossimTrace traceDebug("ossimFgdcXmlDoc:debug");
     29
     30ossimFgdcXmlDoc::ossimFgdcXmlDoc()
     31   : m_xmlFilename(ossimFilename::NIL),
    2432     m_xmlDocument(0),
    2533     m_projection(0)
     
    3139}
    3240
    33 ossimProjection* ossimFgdcXmlDoc::getProjection()
    34 {
    35    if ( m_projection.valid() )
    36    {
    37       return m_projection.get();
     41bool ossimFgdcXmlDoc::open(const ossimFilename& xmlFileName)
     42{
     43   bool result = false;
     44   if ( isOpen() )
     45   {
     46      close();
    3847   }
    3948   
    40    ossimDrect rect = getBoundingBox();
    41    ossimString projName (getProjCsn());
     49   if (xmlFileName.size())
     50   {
     51      m_xmlDocument = new ossimXmlDocument(xmlFileName);
     52      if ( m_xmlDocument.valid() )
     53      {
     54         // May want to add a test for valid FGDC here??? (drb)
     55         m_xmlFilename = xmlFileName;
     56         result = true;
     57      }
     58   }
     59   return result;
     60}
     61
     62void ossimFgdcXmlDoc::close()
     63{
     64   m_xmlFilename = ossimFilename::NIL;
     65   m_xmlDocument = 0;
     66   m_projection  = 0;
     67}
     68
     69ossimRefPtr<ossimProjection> ossimFgdcXmlDoc::getProjection()
     70{
     71   if ( (m_projection.valid() == false) && isOpen() )
     72   {
     73      ossimString projName;
     74      if ( getProjCsn(projName) )
     75      {
     76         if (!projName.empty())
     77         {
     78            m_projection = ossimEpsgProjectionFactory::instance()->createProjection(projName);
     79           
     80            if ( m_projection.valid() )
     81            {
     82               ossimDpt gsd;
     83               gsd.makeNan();
     84               ossim_float64 d;
     85               if ( getXRes(d) )
     86               {
     87                  gsd.x = std::fabs(d);
     88               }
     89               if ( getYRes(d) )
     90               {
     91                  gsd.y = std::fabs(d);
     92               }
     93               ossimMapProjection* mapProj = dynamic_cast<ossimMapProjection*>(m_projection.get());
     94               if (mapProj)
     95               {
     96                  ossimDrect rect;
     97                  getBoundingBox(rect);
     98                  if (mapProj->isGeographic())
     99                  {
     100                     ossimGpt tie(rect.ul().lat, rect.ul().lon);
     101                     mapProj->setUlTiePoints(tie);
     102                     mapProj->setDecimalDegreesPerPixel(gsd);
     103                  }
     104                  else
     105                  {
     106                     ossimDpt tie(rect.ul().x, rect.ul().y);
     107                     ossimUnitType unitType = getUnitType();
     108                     if ( unitType == OSSIM_US_SURVEY_FEET)
     109                     {
     110                        gsd = gsd * US_METERS_PER_FT;
     111                        tie = tie * US_METERS_PER_FT;
     112                     }
     113                     else if ( unitType == OSSIM_FEET )
     114                     {
     115                        gsd = gsd * MTRS_PER_FT;
     116                        tie = tie * MTRS_PER_FT;
     117                     }
     118                       
     119                     mapProj->setUlTiePoints(tie);
     120                     mapProj->setMetersPerPixel(gsd);
     121                  }
     122               }
     123            }
     124         }
     125      }
     126   }
     127   return m_projection;
     128}
     129
     130ossimUnitType ossimFgdcXmlDoc::getUnitType() const
     131{
     132   ossimUnitType result = OSSIM_METERS; // default
     133   ossimString units;
     134   if ( getPlanarDistantUnits(units) )
     135   {
     136      units.downcase();
     137      if ( units.contains("feet") )
     138      {
     139         if ( units.contains("international") )
     140         {
     141            result = OSSIM_FEET;
     142         }
     143         else
     144         {
     145            result = OSSIM_US_SURVEY_FEET; // Default for feet.
     146         }
     147      }
     148   }
     149   return result;
     150}
     151
     152bool ossimFgdcXmlDoc::isOpen() const
     153{
     154   return m_xmlDocument.valid();
     155}
     156
     157bool ossimFgdcXmlDoc::getGeoCsn(ossimString& s) const
     158{
     159   ossimString xpath = "/metadata/spref/horizsys/cordsysn/geogcsn";
     160   return getPath(xpath, s);
     161}
     162
     163bool ossimFgdcXmlDoc::getProjCsn(ossimString& s) const
     164{
     165   ossimString xpath = "/metadata/spref/horizsys/cordsysn/projcsn";
     166   return getPath(xpath, s);
     167}
     168
     169bool ossimFgdcXmlDoc::getAltitudeDistantUnits(ossimString& s) const
     170{
     171   ossimString xpath = "/metadata/spref/vertdef/altsys/altunits";
     172   return getPath(xpath, s);
     173}
     174
     175bool ossimFgdcXmlDoc::getGridCoordinateSystem(ossimString& s) const
     176{
     177   ossimString xpath = "/metadata/spref/horizsys/planar/gridsys/gridsysn";
     178   return getPath(xpath, s);
     179}
     180
     181ossimRefPtr<ossimProjection> ossimFgdcXmlDoc::getGridCoordSysProjection()
     182{
     183   static const char M[] = "ossimFgdcXmlDoc::getGridCoordSysProjection";
     184   if ( traceDebug() )
     185   {
     186      ossimNotify(ossimNotifyLevel_DEBUG) << M << " entered...\n";
     187   }
     188
     189   if ( m_projection.valid() == false )
     190   {
     191      ossimString s;
     192      if ( getGridCoordinateSystem(s) )
     193      {
     194         ossimString gridsysn = s.downcase();
     195         if ( getHorizontalDatum(s) )
     196         {
     197            ossimString horizdn = s.downcase();
     198            const ossimDatum* datum = createOssimDatum(s); // throws exception
     199           
     200            if ( gridsysn == "universal transverse mercator" )
     201            {
     202               // Get the zone:
     203               if ( getUtmZone(s) )
     204               {
     205                  ossim_int32 zone = s.toInt32();
     206
     207                  //---
     208                  // Note: Contruct with an origin with our datum.
     209                  // "proj->setDatum" does not change the origin's datum.
     210                  // This ensures theossimEpsgProjectionDatabase::findProjectionCode
     211                  // sets the psc code correctly down the line.
     212                  //---
     213                  ossimRefPtr<ossimUtmProjection> utmProj =
     214                     new ossimUtmProjection( *(datum->ellipsoid()), ossimGpt(0.0,0.0,0.0,datum) );
     215                  utmProj->setDatum(datum);
     216                  utmProj->setZone(zone);
     217                 
     218                  // Hemisphere( North false easting = 0.0, South = 10000000):
     219                  bool tmpResult = getUtmFalseNorthing(s);
     220                  if ( tmpResult && ( s != "0.0" ) )
     221                  {
     222                     utmProj->setHemisphere('S');
     223                  }
     224                  else
     225                  {
     226                     utmProj->setHemisphere('N');
     227                  }
     228                  utmProj->setPcsCode(0);
     229                  m_projection = utmProj.get(); // Capture projection.
     230               }
     231               else
     232               {
     233                  std::string errMsg = M;
     234                  errMsg += " ERROR: Could not determine utm zone!";
     235                  throw ossimException(errMsg);
     236               }
     237            }
     238         }
     239      }
     240   }
    42241   
    43    if (!projName.empty())
    44    {
    45       m_projection = ossimEpsgProjectionFactory::instance()->createProjection(projName);
    46      
     242   if ( traceDebug() )
     243   {
    47244      if ( m_projection.valid() )
    48245      {
    49          ossimDpt gsd(fabs(getXRes()), fabs(getYRes()));
    50          ossimMapProjection* mapProj = dynamic_cast<ossimMapProjection*>(m_projection.get());
    51          if (mapProj)
    52          {
    53             if (mapProj->isGeographic())
    54             {
    55                ossimGpt tie(rect.ul().lat, rect.ul().lon);
    56                mapProj->setUlTiePoints(tie);
    57                mapProj->setDecimalDegreesPerPixel(gsd);
    58             }
    59             else
    60             {
    61                ossimDpt tie(rect.ul().x, rect.ul().y);
    62                if (getUnits().upcase() == "FEET")
    63                {
    64                   gsd = gsd * METER_PER_FOOT;
    65                   tie = tie * METER_PER_FOOT;
    66                }
    67                mapProj->setUlTiePoints(tie);
    68                mapProj->setMetersPerPixel(gsd);
    69             }
    70          }
    71       }
    72    }
    73    return m_projection.get();
    74 }
    75 
    76 bool ossimFgdcXmlDoc::isOpen()
    77 {
    78    if ( m_xmlDocument.valid() )
    79    {
    80       return true;
    81    }
    82    else
    83    {
    84       if (!m_xmlFilename.empty())
    85       {
    86          m_xmlDocument = new ossimXmlDocument(m_xmlFilename);
    87          
    88          if ( m_xmlDocument.valid() )
    89          {
    90             return true;
    91          }
    92       }
    93    }
    94    return false;
    95 }
    96 
    97 ossimString ossimFgdcXmlDoc::getGeoCsn()
    98 {
    99    if (isOpen())
    100    {
    101       ossimString xpath = "/metadata/spref/horizsys/cordsysn/geogcsn";
    102       vector<ossimRefPtr<ossimXmlNode> > xml_nodes;
    103       m_xmlDocument->findNodes(xpath, xml_nodes);
    104       if (xml_nodes.size() > 0)
    105       {
    106          ossimString geoProjStr = xml_nodes[0]->getText();
    107          return geoProjStr;
    108       }
    109    }
    110    return "";
    111 }
    112 
    113 ossimString ossimFgdcXmlDoc::getProjCsn()
    114 {
    115    if (isOpen())
    116    {
    117       ossimString xpath = "/metadata/spref/horizsys/cordsysn/projcsn";
    118       vector<ossimRefPtr<ossimXmlNode> > xml_nodes;
    119       m_xmlDocument->findNodes(xpath, xml_nodes);
    120       if (xml_nodes.size() > 0)
    121       {
    122          ossimString projStr = xml_nodes[0]->getText();
    123          return projStr;
    124       }
    125    }
    126    return "";
    127 }
    128 
    129 ossimString ossimFgdcXmlDoc::getUnits()
    130 {
    131    if (isOpen())
    132    {
    133       ossimString xpath = "/metadata/spref/vertdef/altsys/altunits";
    134       vector<ossimRefPtr<ossimXmlNode> > xml_nodes;
    135       m_xmlDocument->findNodes(xpath, xml_nodes);
    136       if (xml_nodes.size() > 0)
    137       {
    138          ossimString units = xml_nodes[0]->getText();
    139          return units;
    140       }
    141    }
    142    return "";
    143 }
    144 
    145 double ossimFgdcXmlDoc::getXRes()
    146 {
    147    if (isOpen())
    148    {
    149       ossimString xpath = "/metadata/spdoinfo/rastinfo/rastxsz";
    150       vector<ossimRefPtr<ossimXmlNode> > xml_nodes;
    151       m_xmlDocument->findNodes(xpath, xml_nodes);
    152       if (xml_nodes.size() > 0)
    153       {
    154          double rastXRes = xml_nodes[0]->getText().toDouble();
    155          return rastXRes;
    156       }
    157    }
    158    return 0;
    159 }
    160 
    161 double ossimFgdcXmlDoc::getYRes()
    162 {
    163    if (isOpen())
    164    {
    165       ossimString xpath = "/metadata/spdoinfo/rastinfo/rastysz";
    166       vector<ossimRefPtr<ossimXmlNode> > xml_nodes;
    167       m_xmlDocument->findNodes(xpath, xml_nodes);
    168       if (xml_nodes.size() > 0)
    169       {
    170          double rastYRes = xml_nodes[0]->getText().toDouble();
    171          return rastYRes;
    172       }
    173    }
    174    return 0;
    175 }
    176 
    177 ossim_uint32 ossimFgdcXmlDoc::getNumberOfSamples()
    178 {
    179    if (isOpen())
    180    {
    181       ossimString xpath = "/metadata/spatRepInfo/GridSpatRep/axDimProps/Dimen/dimSize";
    182       vector<ossimRefPtr<ossimXmlNode> > xml_nodes;
    183       m_xmlDocument->findNodes(xpath, xml_nodes);
    184       if (xml_nodes.size() > 0)
    185       {
    186          ossim_uint32 numOfSamples = xml_nodes[0]->getText().toInt();
    187          return numOfSamples;
    188       }
    189    }
    190    return 0;
    191 }
    192 
    193 ossim_uint32 ossimFgdcXmlDoc::getNumberOfLines()
    194 {
    195    if (isOpen())
     246         m_projection->print(ossimNotify(ossimNotifyLevel_DEBUG));
     247      }
     248      ossimNotify(ossimNotifyLevel_DEBUG) << M << " exiting...\n";
     249   }
     250   return m_projection;
     251}
     252
     253
     254bool ossimFgdcXmlDoc::getHorizontalDatum(ossimString& s) const
     255{
     256   ossimString xpath = "/metadata/spref/horizsys/geodetic/horizdn";
     257   return getPath(xpath, s);
     258}
     259
     260bool ossimFgdcXmlDoc::getPlanarDistantUnits(ossimString& s) const
     261{
     262   ossimString xpath = "/metadata/spref/horizsys/planar/planci/plandu";
     263   return getPath(xpath, s);
     264}
     265
     266bool ossimFgdcXmlDoc::getUtmFalseNorthing(ossimString& s) const
     267{
     268   ossimString xpath = "/metadata/spref/horizsys/planar/gridsys/utm/transmer/fnorth";
     269   return getPath(xpath, s);
     270}
     271
     272bool ossimFgdcXmlDoc::getUtmZone(ossimString& s) const
     273{
     274   ossimString xpath = "/metadata/spref/horizsys/planar/gridsys/utm/utmzone";
     275   return getPath(xpath, s);
     276}
     277
     278bool ossimFgdcXmlDoc::getXRes(ossim_float64& v) const
     279{
     280   ossimString xpath = "/metadata/spdoinfo/rastinfo/rastxsz";
     281   return getPath(xpath, v);
     282}
     283
     284bool ossimFgdcXmlDoc::getYRes(ossim_float64& v) const
     285{
     286   ossimString xpath = "/metadata/spdoinfo/rastinfo/rastysz";
     287   return getPath(xpath, v);
     288}
     289
     290bool ossimFgdcXmlDoc::getImageSize(ossimIpt& size) const
     291{
     292   bool result = false;
     293   if (  m_xmlDocument.valid() )
    196294   {
    197295      ossimString xpath = "/metadata/spatRepInfo/GridSpatRep/axDimProps/Dimen/dimSize";
     
    200298      if (xml_nodes.size() > 1)
    201299      {
    202          ossim_uint32 numOfLines = xml_nodes[1]->getText().toInt();
    203          return numOfLines;
    204       }
    205    }
    206    return 0;
    207 }
    208 
    209 ossimDrect ossimFgdcXmlDoc::getBoundingBox()
    210 {
     300         size.x = xml_nodes[0]->getText().toInt32();
     301         size.y = xml_nodes[1]->getText().toInt32();
     302         result = true;
     303      }
     304   }
     305   return result;
     306}
     307
     308void ossimFgdcXmlDoc::getBoundingBox(ossimDrect& rect) const
     309{
     310   rect.makeNan();
     311   
    211312   if (isOpen())
    212313   {
     
    256357      }
    257358     
    258       ossimDrect rect(ossimDpt(ul_lon, ul_lat),
    259                       ossimDpt(ur_lon, ur_lat),
    260                       ossimDpt(lr_lon, lr_lat),
    261                       ossimDpt(ll_lon, ll_lat), OSSIM_RIGHT_HANDED);
    262      
    263       return rect;
    264    }
     359      rect = ossimDrect(ossimDpt(ul_lon, ul_lat),
     360                        ossimDpt(ur_lon, ur_lat),
     361                        ossimDpt(lr_lon, lr_lat),
     362                        ossimDpt(ll_lon, ll_lat), OSSIM_RIGHT_HANDED);
     363   }
     364}
     365
     366bool ossimFgdcXmlDoc::getPath(const ossimString& path, ossimString& s) const
     367{
     368   static const char M[] = "ossimFgdcXmlDoc::getPath";
    265369   
    266    return ossimDrect();
    267 }
     370   bool result = false;
     371   if ( m_xmlDocument.valid() )
     372   {
     373      std::vector<ossimRefPtr<ossimXmlNode> > xnodes;
     374      m_xmlDocument->findNodes(path, xnodes);
     375      if ( xnodes.size() == 1 ) // Error if more than one.
     376      {
     377         if ( xnodes[0].valid() )
     378         {
     379            s = xnodes[0]->getText();
     380            result = true;
     381         }
     382         else
     383         {
     384            if(traceDebug())
     385            {
     386               
     387               ossimNotify(ossimNotifyLevel_WARN)
     388                  << M << " ERROR:\n"
     389                  << "Node not found: " << path
     390                  << std::endl;
     391            }
     392         }
     393      }
     394      else if ( xnodes.size() == 0 )
     395      {
     396         if(traceDebug())
     397         {
     398            ossimNotify(ossimNotifyLevel_WARN) << M << " ERROR:\nNode not found: " << path
     399               << std::endl;
     400         }
     401      }
     402      else
     403      {
     404         if(traceDebug())
     405         {
     406           
     407            ossimNotify(ossimNotifyLevel_WARN)
     408               << M << " ERROR:\nMultiple nodes found: " << path << std::endl;
     409         }
     410      }
     411   }
     412   if (!result)
     413   {
     414      s.clear();
     415   }
     416   return result;     
     417}
     418   
     419bool ossimFgdcXmlDoc::getPath(const ossimString& path, ossim_float64& v) const
     420{
     421   ossimString s;
     422   bool result = getPath(path, s);
     423   if ( result )
     424   {
     425      v = s.toFloat64();
     426   }
     427   return result;
     428}
     429
     430const ossimDatum* ossimFgdcXmlDoc::createOssimDatum(const ossimString& s) const
     431{
     432   ossimString horizdn = s.downcase();
     433   ossimString datumCode;
     434   if ( horizdn == "north american datum of 1983" )
     435   {
     436      datumCode = "NAR-C";
     437   }
     438   else if ( horizdn == "north american datum of 1927" )
     439   {
     440      datumCode = "NAS-C";
     441   }
     442   else
     443   {
     444      std::string errMsg = "ossimFgdcXmlDoc::createOssimDatum ERROR: Unhandled datum: ";
     445      errMsg += horizdn;
     446      throw ossimException(errMsg);
     447   }
     448   return ossimDatumFactoryRegistry::instance()->create(datumCode);   
     449}
  • trunk/ossim/src/ossim/support_data/ossimGeoTiff.cpp

    r17839 r18693  
    280280      if (datum)
    281281      {
    282          datum_code = (int) datum->epsgGcsCode();
     282         datum_code = (int) datum->epsgCode();
    283283         const ossimEllipsoid* ellipsoid = datum->ellipsoid();
    284284         if (ellipsoid)
  • trunk/ossim/src/ossim/support_data/ossimSrcRecord.cpp

    r17815 r18693  
    1212
    1313#include <ossim/support_data/ossimSrcRecord.h>
    14 #include <ossim/base/ossimKeywordlist.h>
     14#include <ossim/base/ossimKeywordNames.h>
     15#include <ossim/base/ossimNotify.h>
    1516
    1617//*************************************************************************************************
     
    1819//*************************************************************************************************
    1920ossimSrcRecord::ossimSrcRecord()
    20 :  m_entryIndex(-1)
     21:  m_entryIndex(-1),
     22   m_weight(0.0)
    2123{}
    2224
     
    2527//*************************************************************************************************
    2628ossimSrcRecord::ossimSrcRecord(const ossimKeywordlist& src_kwl, ossim_uint32 index)
    27 :  m_entryIndex(-1)
     29:  m_entryIndex(-1),
     30   m_weight(0.0),
     31   m_isRgbData(false)
    2832{
    2933   ossimString prefix_str = "image";
     
    3438}
    3539
     40//*************************************************************************************************
     41// METHOD
     42//*************************************************************************************************
    3643bool ossimSrcRecord::loadState(const ossimKeywordlist& kwl, const char* prefix)
    3744{
    3845   // Read image filename entry (required):
    39    const char* lookup = kwl.find(prefix, "file");
     46   m_rgbFilenames.clear();
     47   m_rgbHistogramPaths.clear();
     48   m_rgbHistogramOps.clear();
     49   m_rgbOverviewPaths.clear();
     50   const char* lookup = kwl.find(prefix, "r");
    4051   if (lookup)
    4152   {
    4253      m_filename = lookup;
     54      m_isRgbData = true;
     55      m_rgbFilenames.push_back(ossimString(lookup));
     56
     57      lookup = kwl.find(prefix, "r.hist");
     58      if (lookup)
     59      {
     60         m_rgbHistogramPaths.push_back(ossimString(lookup).downcase());
     61      }
     62     
     63      lookup = kwl.find(prefix, "r.hist-op");
     64      if (lookup)
     65      {
     66         m_rgbHistogramOps.push_back(ossimString(lookup).downcase());
     67      }
     68      lookup = kwl.find(prefix, "r.ovr");
     69      if (lookup)
     70      {
     71         m_rgbOverviewPaths.push_back(ossimFilename(lookup));
     72      }
     73     
     74      lookup = kwl.find(prefix, "g");
     75      if (lookup)
     76      {
     77         m_rgbFilenames.push_back(ossimString(lookup));
     78      }
     79      lookup = kwl.find(prefix, "g.hist");
     80      if (lookup)
     81      {
     82         m_rgbHistogramPaths.push_back(ossimString(lookup).downcase());
     83      }
     84      lookup = kwl.find(prefix, "g.ovr");
     85      if (lookup)
     86      {
     87         m_rgbOverviewPaths.push_back(ossimFilename(lookup));
     88      }
     89
     90      lookup = kwl.find(prefix, "g.hist-op");
     91      if (lookup)
     92      {
     93         m_rgbHistogramOps.push_back(ossimString(lookup).downcase());
     94      }
     95
     96      lookup = kwl.find(prefix, "b");
     97      if (lookup)
     98      {
     99         m_rgbFilenames.push_back(ossimString(lookup));
     100      }
     101      lookup = kwl.find(prefix, "b.hist");
     102      if (lookup)
     103      {
     104         m_rgbHistogramPaths.push_back(ossimString(lookup).downcase());
     105      }
     106
     107      lookup = kwl.find(prefix, "b.hist-op");
     108      if (lookup)
     109      {
     110         m_rgbHistogramOps.push_back(ossimString(lookup).downcase());
     111      }
     112      lookup = kwl.find(prefix, "b.ovr");
     113      if (lookup)
     114      {
     115         m_rgbOverviewPaths.push_back(ossimFilename(lookup));
     116      }
     117
     118      return true;
     119   }
     120     
     121   lookup = kwl.find(prefix, "file");
     122   if (lookup)
     123   {
     124      m_filename = lookup;
     125      m_attributesKwl.add(ossimKeywordNames::FILENAME_KW, m_filename.chars());
     126
    43127   }
    44128   else
     
    53137   {
    54138      m_entryIndex = ossimString(lookup).toInt32();
     139      m_attributesKwl.add(ossimKeywordNames::ENTRY_KW, m_entryIndex);
    55140   }
    56141   else
     
    64149   {
    65150      m_overviewPath = ossimFilename(lookup);
     151      m_attributesKwl.add(ossimKeywordNames::OVERVIEW_FILE_KW, m_overviewPath.chars());
    66152   }
    67153   else
     
    107193   {
    108194      setSupportDir(ossimFilename(lookup));
    109    }
     195  }
    110196   else
    111197   {
     
    137223   }
    138224
     225   lookup = kwl.find(prefix, "opacity");
     226   if (lookup)
     227      m_weight =  ossimString(lookup).toDouble();
     228
     229   // Look for vector data info:
     230   m_isVectorData = false;
     231   ossimString vector_prefix (prefix);
     232   vector_prefix += "vector.";
     233   ossimKeywordlist vectorKwl;
     234
     235#define DIRECT_KW_MAPPING false
     236   if (DIRECT_KW_MAPPING)
     237   {
     238      // This method of stuffing the attributes KWL is presented here as an example of the way we
     239      // should do it:
     240      m_attributesKwl.add(kwl, vector_prefix.chars());
     241   }
     242   else
     243   {
     244      // Need to translate SRC keywords to KWs expected by OSSIM:
     245      lookup = kwl.find(vector_prefix, "line.color");
     246      if (lookup)
     247         vectorKwl.add(ossimKeywordNames::PEN_COLOR_KW, lookup);
     248      lookup = kwl.find(vector_prefix, "line.width");
     249      if (lookup)
     250         vectorKwl.add(ossimKeywordNames::THICKNESS_KW, lookup);
     251      lookup = kwl.find(vector_prefix, "fill.color");
     252      if (lookup)
     253      {
     254         vectorKwl.add(ossimKeywordNames::FILL_FLAG_KW, true);
     255         vectorKwl.add(ossimKeywordNames::BRUSH_COLOR_KW, lookup);
     256      }
     257      lookup = kwl.find(vector_prefix, "query");
     258      if (lookup)
     259        vectorKwl.add(ossimKeywordNames::QUERY_KW, lookup);
     260   }
     261
     262   if (vectorKwl.getSize())
     263   {
     264      m_isVectorData = true;
     265      m_attributesKwl.add(0, vectorKwl);
     266   }
     267
    139268   return true;
    140269}
     
    148277   m_supportDir = f;
    149278   if (m_overviewPath.empty())
    150       m_overviewPath = m_supportDir;
     279      setOverview(m_supportDir);
    151280   if (m_histogramPath.empty())
    152281      m_histogramPath = m_supportDir;
     
    154283      m_maskPath = m_supportDir;
    155284}
     285
     286//*************************************************************************************************
     287// METHOD
     288//*************************************************************************************************
     289void ossimSrcRecord::setFilename(const ossimFilename& f)         
     290{
     291   m_filename = f;
     292   m_attributesKwl.add(ossimKeywordNames::FILENAME_KW, m_filename.chars());
     293}
     294
     295//*************************************************************************************************
     296// METHOD
     297//*************************************************************************************************
     298void ossimSrcRecord::setEntryIndex(ossim_int32 i)                 
     299{
     300   m_entryIndex = i;
     301   m_attributesKwl.add(ossimKeywordNames::ENTRY_KW, m_entryIndex);
     302}
     303
     304//*************************************************************************************************
     305// METHOD
     306//*************************************************************************************************
     307void ossimSrcRecord::setOverview(const ossimFilename& f)         
     308{
     309   m_overviewPath = f;
     310   m_attributesKwl.add(ossimKeywordNames::OVERVIEW_FILE_KW, m_overviewPath.chars());
     311}
     312
  • trunk/ossim/src/ossim/support_data/ossimSrtmSupportData.cpp

    r17815 r18693  
    260260   //---
    261261   const ossimDatum* datum = ossimDatumFactory::instance()->wgs84();
    262    ossimRefPtr<ossimEquDistCylProjection> eq =
    263       new ossimEquDistCylProjection(*(datum->ellipsoid()),
    264                                     ossimGpt(0.0, 0.0, 0.0, datum),
    265                                     0.0,   // false easting
    266                                     0.0);  // false northing
     262   ossimRefPtr<ossimEquDistCylProjection> eq = new ossimEquDistCylProjection(*(datum->ellipsoid()));
    267263   
    268264   //---
     
    274270   // Set the scale:
    275271   eq->setDecimalDegreesPerPixel( ossimDpt(theLonSpacing, theLatSpacing) );
    276 
    277    // Set the pcs code.
    278    eq->setPcsCode(6326);   
    279272
    280273   ossimRefPtr<ossimProjection> proj = eq.get();
  • trunk/ossim/src/ossim/support_data/ossimTiffWorld.cpp

    r15833 r18693  
    1616#include <iomanip>
    1717using namespace std;
     18#include <math.h>
    1819
    1920#include <ossim/base/ossimConstants.h>
     
    2324#include <ossim/base/ossimUnitConversionTool.h>
    2425#include <ossim/support_data/ossimTiffWorld.h>
     26#include <ossim/base/ossimNotify.h>
    2527
    2628//**************************************************************************
     
    2931ossimTiffWorld::ossimTiffWorld()
    3032   :
    31       theXScale(1.0),
    32       the2ndValue(0.0),
    33       the3rdValue(0.0),
    34       theYScale(1.0),
    35       theTranslateX(0.0),
    36       theTranslateY(0.0),
     33      theXform1(1.0),
     34      theXform2(0.0),
     35      theXform3(0.0),
     36      theXform4(-1.0),
     37      theTranslation(0.0,0.0),
    3738      thePixelType(OSSIM_PIXEL_IS_AREA),
    38       theUnit(OSSIM_METERS)
     39      theUnit(OSSIM_METERS),
     40      theComputedScale(0.0, 0.0),
     41      theComputedRotation(0.0)
    3942{}
    4043
     
    4649                               ossimUnitType  scaleUnits)
    4750   :
    48       theXScale(1.0),
    49       the2ndValue(0.0),
    50       the3rdValue(0.0),
    51       theYScale(-1.0),
    52       theTranslateX(0.0),
    53       theTranslateY(0.0),
     51      theXform1(1.0),
     52      theXform2(0.0),
     53      theXform3(0.0),
     54      theXform4(-1.0),
     55      theTranslation(0.0,0.0),
    5456      thePixelType(ptype),
    55       theUnit(scaleUnits)
    56 {
     57      theUnit(scaleUnits),
     58      theComputedScale(0.0, 0.0),
     59      theComputedRotation(0.0)
     60{
     61   open(ossimFilename(file), ptype, scaleUnits);
     62}
     63
     64bool ossimTiffWorld::open(const ossimFilename& file, ossimPixelType ptype, ossimUnitType  unit)
     65{
     66   bool result = false;
     67
    5768   ifstream is;
    5869   is.open(file);
     
    8091         }
    8192      }
    82      
    83       if ( !is.is_open() )
    84       {
    85          return;
    86       }
    87    }
    88 
    89    is >> theXScale
    90       >> the2ndValue
    91       >> the3rdValue
    92       >> theYScale
    93       >> theTranslateX
    94       >> theTranslateY;
    95 
    96    is.close();
     93   }
     94     
     95   if ( is.is_open() )
     96   {
     97      double x,y;
     98      is >> theXform1 >> theXform2 >> theXform3 >> theXform4 >> x >> y;
     99      theTranslation = ossimDpt(x,y);
     100     
     101      // Compute the affine parameters from the transform:
     102      theComputedRotation = atan2(theXform2,theXform1);
     103      double angle2 = atan2(theXform4,theXform3);
     104
     105/*
     106 * Commented out warning.
     107 * Used all the time for tie and scale, NOT for affine. We could wrap around trace
     108 * if we added trace to class. (drb - 20110115)
     109 */
     110#if 0
     111      if ((theComputedRotation - angle2) > 0.00001)
     112      {
     113         ossimNotify(ossimNotifyLevel_WARN)
     114            << "ossimTiffWorld -- Non-affine transform encountered."
     115            << " Use of an affine transform to represent this world file geometry will result in errors."
     116            << endl;
     117      }
     118#endif
     119     
     120      double cos_rot = cos(theComputedRotation);
     121      if (cos_rot != 0.0)
     122      {
     123         theComputedScale.x = theXform1/cos_rot;
     124         theComputedScale.y = theXform4/cos_rot;
     125      }
     126      else
     127      {
     128         theComputedScale.x = theXform4;
     129         theComputedScale.y = theXform1;
     130      }
     131      thePixelType = ptype;
     132      theUnit = unit;
     133      is.close();
     134      result = true;
     135   }
     136   return result;
    97137}
    98138
     
    101141}
    102142
    103 void ossimTiffWorld::forward(const ossimDpt& imagePoint,
     143void ossimTiffWorld::forward(const ossimDpt& ip,
    104144                             ossimDpt& transformedPoint)
    105145{
    106    transformedPoint.x =
    107       imagePoint.x*theXScale   + imagePoint.y*the3rdValue + theTranslateX;
    108    transformedPoint.y =
    109       imagePoint.x*the2ndValue + imagePoint.y*theYScale   + theTranslateY;
    110 }
    111 
    112 
    113 bool ossimTiffWorld::saveToOssimGeom(ossimKeywordlist& kwl,
    114                                      const char* prefix)const
    115 {
    116    ossimDpt scale(fabs(theXScale), fabs(theYScale));
    117    ossimDpt tie(theTranslateX, theTranslateY);
     146   transformedPoint.x = ip.x*theXform1 + ip.y*theXform2 + theTranslation.x;
     147   transformedPoint.y = ip.x*theXform3 + ip.y*theXform4 + theTranslation.y;
     148}
     149
     150bool ossimTiffWorld::saveToOssimGeom(ossimKeywordlist& kwl, const char* prefix)const
     151{
     152   ossimDpt scale(fabs(theXform1), fabs(theXform4));
     153   ossimDpt tie(theTranslation.x, theTranslation.y);
    118154
    119155   if ( (theUnit == OSSIM_FEET) || (theUnit == OSSIM_US_SURVEY_FEET) )
     
    169205}
    170206
    171 bool ossimTiffWorld::loadFromOssimGeom(const ossimKeywordlist& kwl,
    172                                        const char* prefix)
    173 {
    174    the2ndValue = 0.0;
    175    the3rdValue = 0.0;
     207bool ossimTiffWorld::loadFromOssimGeom(const ossimKeywordlist& kwl, const char* prefix)
     208{
     209   theXform2 = 0.0;
     210   theXform3 = 0.0;
    176211
    177212   const char* lookup;
     
    183218      ossimDpt scale;
    184219      scale.toPoint(std::string(lookup));
    185       theXScale      = scale.x;
    186       theYScale      = -(scale.y);
     220      theXform1      = scale.x;
     221      theXform4      = -(scale.y);
    187222   }
    188223   else // BACKWARDS COMPATIBILITY LOOKUPS...
    189224   {
    190       ossimString xscale   =
    191          kwl.find(prefix, ossimKeywordNames::METERS_PER_PIXEL_X_KW);
    192       ossimString yscale   =
    193          kwl.find(prefix, ossimKeywordNames::METERS_PER_PIXEL_Y_KW);
    194       theXScale      = xscale.toDouble();
    195       theYScale      = -(yscale.toDouble());
     225      ossimString xscale = kwl.find(prefix, ossimKeywordNames::METERS_PER_PIXEL_X_KW);
     226      ossimString yscale = kwl.find(prefix, ossimKeywordNames::METERS_PER_PIXEL_Y_KW);
     227      theXform1 = xscale.toDouble();
     228      theXform4 = -(yscale.toDouble());
    196229   }
    197230
     
    202235      ossimDpt tie;
    203236      tie.toPoint(std::string(lookup));
    204       theTranslateX  = tie.x;
    205       theTranslateY  = tie.y;
     237      theTranslation.x  = tie.x;
     238      theTranslation.y  = tie.y;
    206239   }
    207240   else // BACKWARDS COMPATIBILITY LOOKUPS...
     
    211244      ossimString northing =
    212245         kwl.find(prefix, ossimKeywordNames::TIE_POINT_NORTHING_KW);
    213       theTranslateX  = easting.toDouble();
    214       theTranslateY  = northing.toDouble();
     246      theTranslation.x  = easting.toDouble();
     247      theTranslation.y  = northing.toDouble();
    215248   }
    216249   
     
    221254{
    222255   out << setiosflags(ios::fixed) << setprecision(15)
    223        << theXScale     << "\n"
    224        << the2ndValue   << "\n"
    225        << the3rdValue   << "\n"
    226        << theYScale     << "\n"
    227        << theTranslateX << "\n"
    228        << theTranslateY
     256       << theXform1     << "\n"
     257       << theXform2     << "\n"
     258       << theXform3     << "\n"
     259       << theXform4     << "\n"
     260       << theTranslation
    229261       << endl;
    230262   return out;
Note: See TracChangeset for help on using the changeset viewer.