spatmod/imagetileset.h

Go to the documentation of this file.

#ifndef  INC_SPATMOD_IMAGETILESET_H
#define  INC_SPATMOD_IMAGETILESET_H

#ifndef  INC_SPATMOD_IMAGEFORMAT_H
#include <spatmod/imageformat.h>
#endif

#ifndef  INC_MI32_SPATREF_H
#include <mi32/spatref.h>
#endif

#ifndef  INC_MI32_RECT_H
#include <mi32/rect.h>
#endif

#ifndef INC_MI32_XML_H
#include <mi32/xml.h>
#endif

#ifndef INC_MI32_MISTRINGLIST_H
#include <mi32/mistringlist.h>
#endif

#ifndef INC_MI32_BITSET_H
#include <mi32/bitset.h>
#endif

#ifndef INC_MI32_FILEPATH_H
#include <mi32/filepath.h>
#endif

#ifndef INC_MI32_ZIPFILE_H
#include <mi32/zipfile.h>
#endif

#ifndef INC_MI32_DATETIME_H
#include <mi32/datetime.h>
#endif

#ifndef INC_MI32_COLOR_H
#include <mi32/color.h>
#endif

#ifndef INC_MI32_POLYLINE_H
#include <mi32/polyline.h>
#endif

#ifndef INC_RVC_OBJITEM_H
#include <rvc/objitem.h>
#endif

#ifndef INC_MI32_MITHREAD_H
#include <mi32/mithread.h>
#endif

#ifndef INC_MI32_TEXTID_H
#include <mi32/textid.h>
#endif

#ifndef INC_MGUI_DLGGETOBJECTFILTER_H
#include <mgui/dlggetobjectfilter.h>
#endif

// Forward declarations
#ifndef GENERATING_DOXYGEN_OUTPUT
class REGION2D;
class TRANS2D_AFFINE;
class MISTATUSCONTEXT;
namespace SPATMOD {
   class GEOREFERENCE;
   namespace IMAGE {
      class SAMPLEITERATOR;
      class SOURCE_TILESET;
      }
   }
#endif

namespace SPATMOD {
namespace IMAGE {

class PIXEL;

//=====================================================================================================================

class TILESET {
   public:

      static void TSDFileTypeGetDescription (MISTRING& description, const RVC::OBJITEM& objitem);
      static void TSDFileTypeGetProperties (MISTRING& properties, const FILEPATH& filepath);
      static void TSDFileTypeGetProperties (MISTRING& properties, const RVC::OBJITEM& objitem);
      static void TSDFileTypeGetProperties (MISTRING& properties, const RVC::OBJITEM& objitem, bool ShowExtents);
      static void RegisterTSDFileType ();
      static void SaveAs (const MISTRING& url, const FILEPATH& filepath);
      enum PROFILE {
         PROFILE_None =                0,
         PROFILE_Local =                  1,
         PROFILE_Global_Geographic =         2,
         PROFILE_Global_WebMercator =     3
         };

      enum STRUCTURE {
         STRUCTURE_Hierarchical =         0,
         STRUCTURE_Flat =              1,
         STRUCTURE_WorldWind =            2
         };

      enum TARGET {
         TARGET_Undefined =               0,
         TARGET_GoogleMaps =              1,
         TARGET_GoogleEarth =          2,
         TARGET_BingMaps =             3,
         TARGET_NASAWorldWind =           4
         };

      enum IMGFORMAT {
         IMGFORMAT_Invalid =        0x00000000,                   
         IMGFORMAT_8bit =        0x00000001,                   
         IMGFORMAT_16bit =       0x00000002,                   
         IMGFORMAT_16bitA =         0x00000004,                   
         IMGFORMAT_16bitOLD =    0x00000008,                   
         IMGFORMAT_24bit =       0x00000010,                   
         IMGFORMAT_32bit =       0x00000020,                   
         IMGFORMAT_Terrain =        0x00000040,                   
         IMGFORMAT_PNG =            0x00000080,                   
         IMGFORMAT_JPEG =        0x00000100,                   
         IMGFORMAT_TIFF =        0x00000200,                   
         IMGFORMAT_GIF =            0x00000400,                   
         IMGFORMAT_JP2 =            0x00000800,                   
         IMGFORMAT_SVG =            0x00001000,                   
         IMGFORMAT_SVGZ =        (IMGFORMAT_SVG|1),               
         IMGFORMAT_PNG8 =        (IMGFORMAT_PNG|IMGFORMAT_8bit),              
         IMGFORMAT_PNG24 =       (IMGFORMAT_PNG|IMGFORMAT_24bit),             
         IMGFORMAT_PNG16Terrain =   (IMGFORMAT_PNG|IMGFORMAT_16bit|IMGFORMAT_Terrain), 
         IMGFORMAT_PNG16TerrainA =  (IMGFORMAT_PNG|IMGFORMAT_16bitA|IMGFORMAT_Terrain),   
         IMGFORMAT_PNG16TerrainOLD =   (IMGFORMAT_PNG|IMGFORMAT_16bitOLD|IMGFORMAT_Terrain),
         IMGFORMAT_PNG24Terrain =   (IMGFORMAT_PNG|IMGFORMAT_24bit|IMGFORMAT_Terrain), 
         IMGFORMAT_PNG32Terrain =   (IMGFORMAT_PNG|IMGFORMAT_32bit|IMGFORMAT_Terrain), 
         IMGFORMAT_TIFF8 =       (IMGFORMAT_TIFF|IMGFORMAT_8bit),             
         IMGFORMAT_TIFF24 =         (IMGFORMAT_TIFF|IMGFORMAT_24bit),               
         IMGFORMAT_Auto_PNG8_JPEG = (IMGFORMAT_PNG8|IMGFORMAT_JPEG), 
         IMGFORMAT_Auto_PNG24_JPEG =   (IMGFORMAT_PNG24|IMGFORMAT_JPEG) 
         };

      enum TYPE {
         TYPE_None =    0x0000,
         TYPE_Image =   0x0001,
         TYPE_Terrain = 0x0002,
         TYPE_KML =     0x0004,
         TYPE_SVG =     0x0008,
         TYPE_DAE =     0x0010
         };

      struct TransparentColor {
         COLOR color;
         double distance;
         TransparentColor ()
            : distance(0) { }
         };

      class FILTER : public MGUI::DLG_GETOBJECT_FILTER {
         public:
            FILTER ();
            ~FILTER ();
            void AddType(TYPE type);
         private:
            TYPE m_Types;
            virtual bool v_IsFileSelectable(const FILEPATH& filepath, int position) const;
         };

      class LIST {
         public:
            enum GROUP {
               GROUP_Image = 0,
               GROUP_Terrain,
               GROUP_Server,
               GROUP_Mashup
               };

            enum ITEM {
               ITEM_Image = 0,
               ITEM_Terrain,
               ITEM_TerrainA,
               ITEM_KML,
               ITEM_Server
               };

            LIST ();

            ~LIST ();

            bool IsRead (
               ) const { return (m_bIsRead); }

            ERRVALUE Read (
               bool bIncludeArcIMS = false,
               bool bIncludeWMS = false,
               bool bIncludeProprietary = false
               );

            XMLNODE* FindGroup (
               const XMLNODE* node = 0 
               ) const;

            XMLNODE* FindGroup (
               const char* id,         
               const XMLNODE* node = 0 
               ) const;

            XMLNODE* FindGroup (
               GROUP group,         
               const XMLNODE* node = 0 
               ) const;

            XMLNODE* FindNextGroup (
               const XMLNODE* node 
               ) const;

            XMLNODE* FindNextGroup (
               const char* id,         
               const XMLNODE* node     
               ) const;

            XMLNODE* FindNextGroup (
               GROUP group,         
               const XMLNODE* node     
               ) const;

            XMLNODE* FindItem (
               const XMLNODE* node = 0 
               ) const;

            XMLNODE* FindItem (
               const char* id,         
               const XMLNODE* node = 0 
               ) const;

            XMLNODE* FindItem (
               ITEM item,        
               const XMLNODE* node = 0 
               ) const;

            XMLNODE* FindNextItem (
               const XMLNODE* node     
               ) const;

            XMLNODE* FindNextItem (
               const char* id,         
               const XMLNODE* node     
               ) const;

            XMLNODE* FindNextItem (
               ITEM item,        
               const XMLNODE* node     
               ) const;

            XMLNODE* FindItem (
               const REGION2D& region, 
               const XMLNODE* node 
               ) const;

            XMLNODE* FindItem (
               const char* id,         
               const REGION2D& region, 
               const XMLNODE* node 
               ) const;

            XMLNODE* FindItem (
               ITEM item,        
               const REGION2D& region, 
               const XMLNODE* node 
               ) const;

            XMLNODE* FindItem (
               ITEM item,        
               const REGION2D& region 
               ) const;

            XMLNODE* GetRootNode (
               ) { return (m_doc.GetRootNode()); }

            XMLDOC& GetDoc (
               ) { return (m_doc); }

            static INT32 GetMaxLevel (
               const XMLNODE* node 
               );

            static MISTRING GetURL (
               const XMLNODE* node  
               );

            static void GetObjItem (
               RVC::OBJITEM& objitem,  
               const XMLNODE* node     
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            bool m_bIsRead;
            XMLDOC m_doc;
            bool TestNode(const XMLNODE* node, const REGION2D& region) const;
            void IMAGE::TILESET::LIST::FindItem(
               ITEM item,
               const REGION2D& region,
               XMLNODE*& retnode,
               const XMLNODE* parentnode
               ) const;
            #endif
         };

      class POSN {
         public:
            POSN ();
            const LPOINT2D& GetTileIdx (
               ) const { return (m_TileIdx); }
            const LPOINT2D& GetPixelInTile (
               ) const { return (m_PixelInTile); }
            void Set (
               const LPOINT2D& TileIdx,      
               const LPOINT2D& PixelInTile   
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            LPOINT2D m_TileIdx;
            LPOINT2D m_PixelInTile;
            #endif
         };

      class RANGE {
         public:
            RANGE ();
            INT32 ComputeNumPixelsX (INT32 TileSize) const;
            INT32 ComputeNumPixelsY (INT32 TileSize) const;
            INT32 ComputeNumTilesX (
               ) const { return (m_BottomRight.GetTileIdx().x - m_TopLeft.GetTileIdx().x + 1); }
            INT32 ComputeNumTilesY (
               ) const { return (m_BottomRight.GetTileIdx().y - m_TopLeft.GetTileIdx().y + 1); }
            bool Contains (
               const LPOINT2D& TileIdx
               ) const;
            const POSN& GetBottomRight (
               ) const { return (m_BottomRight); }
            const POSN& GetTopLeft (
               ) const { return (m_TopLeft); }
            ERRVALUE Set (
               const POSN& TopLeft,
               const POSN& BottomRight
               );
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            POSN m_TopLeft;
            POSN m_BottomRight;
            #endif
         };

      TILESET ();

      ~TILESET ();

      void AddTileFormat (
         const IMAGE::FORMAT& format         
         );

      // Clear tileset, resetting all values.
      void Clear ();

      void CloseZipFiles();

      double ComputeCellSize (
         INT32 level,                        
         bool UseExtents   = false                 
         ) const;

      ERRVALUE ComputeExtents (
         DRECT2D& Extents,                   
         INT32 level                         
         ) const;

      ERRVALUE ComputeExtents (
         DRECT2D& Extents,                   
         const LPOINT3D& TileIdx             
         ) const { return (ComputeExtents(Extents,TileIdx.z,TileIdx.x,TileIdx.y,TileIdx.x,TileIdx.y)); }

      ERRVALUE ComputeExtents (
         DRECT2D& Extents,                   
         INT32 level,                        
         INT32 TileColumn,                   
         INT32 TileRow                       
         ) const { return (ComputeExtents(Extents,level,TileColumn,TileRow,TileColumn,TileRow)); }

      ERRVALUE ComputeExtents (
         DRECT2D& Extents,                   
         INT32 level,                        
         INT32 TileColumn1,                  
         INT32 TileRow1,                     
         INT32 TileColumn2,                  
         INT32 TileRow2                      
         ) const;

      ERRVALUE ComputeGeoreference (
         INT32 level,                        
         GEOREFERENCE& Georeference          
         ) const;

      INT32 ComputeMaxLevel (
         const LPOINT2D& SrcImageSize,       
         const GEOREFERENCE& SrcGeoreference 
         ) const;

      INT32 ComputeMinLevel (
         const REGION2D& MapRegion,          
         INT32 MaxLevel = -1                 
         ) const;

      ERRVALUE ComputeTileRange (
         const DRECT2D& Extents,             
         INT32 level,                        
         TILESET::RANGE& TileRange,          
         bool IsOnBorder   = false              
         ) const;

      ERRVALUE ComputeTileRangeGeog (
         const DRECT2D& GeogExtents,         
         INT32 level,                        
         TILESET::RANGE& TileRange,          
         bool IsOnBorder   = false              
         ) const;

      ERRVALUE Create (
         PROFILE profile,                    
         INT32 TileSize                      
         );

      ERRVALUE Create (
         const SPATREF::COORDREFSYS& crs,    
         INT32 TileSize,                     
         double CellSize = 0                 
         );

      ERRVALUE CreateAuxiliaryFiles (
         bool bOverwriteExisting = true,                 
         TILESET::TARGET Target = TILESET::TARGET_Undefined,   
         INT32 MinLevel = -1                          
         );

      ERRVALUE CreateAuxiliaryFiles (
         const MISTRING& BaseURL,                     
         bool bOverwriteExisting = true,                 
         TILESET::TARGET Target = TILESET::TARGET_Undefined,   
         INT32 MinLevel = -1                          
         );

      ERRVALUE CreateReducedLevel (
         INT32 level,                                 
         IMGFORMAT ImgFormat = IMGFORMAT_Invalid,           
         UINT16 QualityJPEG = 75,                        
         TILESET::TARGET Target = TILESET::TARGET_Undefined,      
         MISTRING message = TEXTID_Creating_ResolutionLevelN,  
         bool bZipOutput = false                         
         );

      ERRVALUE CreateReducedLevel (
         const FILEPATH& SourcePath,                        
         const FILEPATH& TargetPath,                        
         INT32 level,                                 
         IMGFORMAT ImgFormat = IMGFORMAT_Invalid,           
         UINT16 QualityJPEG = 75,                        
         TILESET::TARGET Target = TILESET::TARGET_Undefined,      
         MISTRING message = TEXTID_Creating_ResolutionLevelN,  
         bool bZipOutput = false                         
         );

      bool FindKMLFile (
         const FILEPATH& PathBaseFolder,        
         INT32 level,                     
         const LPOINT2D& TileIdx,            
         FILEPATH& PathTileFile,             
         MISTRING& TileName                  
         );

      const FORMAT* FindTileFile (
         const FILEPATH& PathBaseFolder,     
         INT32 level,                        
         const LPOINT2D& TileIdx,            
         FILEPATH& PathTileFile              
         ) const;

      const FORMAT* FindTileFile (
         INT32 level,                        
         const LPOINT2D& TileIdx,            
         FILEPATH& PathTileFile              
         );

      const FORMAT* FindTileFile (
         const FILEPATH& PathBaseFolder,        
         INT32 level,                     
         const LPOINT2D& TileIdx,            
         FILEPATH& PathTileFile,             
         MISTRING& TileName                  
         );

      const FORMAT* FindTileFile (
         INT32 level,                     
         const LPOINT2D& TileIdx,            
         FILEPATH& PathTileFile,             
         MISTRING& TileName                  
         );

      ERRVALUE GenerateTileFilePath (
         const FILEPATH& PathBaseFolder,        
         INT32 level,                     
         const LPOINT2D& TileIdx,            
         FILEPATH& PathTileFile,             
         const FORMAT *pFormat = 0,          
         bool MakeFolder = false             
         ) const;
      
      ERRVALUE GeneratePixelRangeMap (
         INT32 level = -1
         );

      ERRVALUE GenerateRegionTileMap (
         );

      ERRVALUE GenerateTileMap (
         INT32 level = -1
         );

      ERRVALUE GenerateTilesetTest ();

      ERRVALUE ScanTilesetTest ();

      ERRVALUE GenerateTerrainXML (
         );

      double GetBaseCellSize (
         ) const { return (m_BaseCellSize); }

      INT32 GetBaseLevel (
         ) const { return (m_BaseLevel); }

      INT32 GetBaseTileCount (
         ) const { return (m_BaseTileCount); }

      MISTRING GetCellSizeDisplayStr (
         INT32 level                         
         ) const;

      const SPATREF::COORDREFSYS& GetCRS (
         ) const { return (m_crs); }

      XMLNODE* GetDateList () const { return (m_DateList); }

      XMLNODE* GetDateRange () const { return (m_DateRange); }

      const DRECT2D& GetExtentsInCRS (
         ) const { return (m_ExtentsInCRS); }

      void GetCacheLocationPath (
         FILEPATH& CacheLocationPath
         );

      void GetImgFormat (
         IMGFORMAT& ImgFormat
         );

      void GetImgFormat (
         IMGFORMAT& ImgFormat,
         PIXEL& PixelProperties
         );

      MISTRING GetLocalLocationString (
         INT32 level = -1        
         );

      const MISTRINGLIST& GetLocalLocationStrings () const {return m_LocalLocationStrings;}

      const MISTRINGLIST& GetLocalLocationLevelStrings () const {return m_LocalLocationLevelStrings;}

      void GetLocalLocationPath (
         FILEPATH& LocationPath,
         INT32 level = -1        
         );

      double GetMargin (
         ) const { return m_Margin; }

      MISTRING GetRemoteLocationString (
         INT32 level = -1        
         );

      const MISTRINGLIST& GetRemoteLocationStrings () const {return m_RemoteLocationStrings;}

      const MISTRINGLIST& GetRemoteLocationLevelStrings () const {return m_RemoteLocationLevelStrings;}

      INT32 GetMaxLevel (
         ) const { return (m_MaxLevel); }

      INT32 GetMinLevel (
         ) const { return (m_MinLevel); }

      MISTRING GetMetadata (
         ) const { return (m_metadata); }

      const RVC::OBJITEM& GetObjItem() {return m_objitem;}

      void GetPath (
         FILEPATH& path
         ) { path = m_TSDPath; }

      double GetPixelValueMin (
         ) const { return (m_PixelValueMin); }

      double GetPixelValueMax (
         ) const { return (m_PixelValueMax); }

      PROFILE GetProfile (
         ) const { return (m_profile); }

      void GetProperties (
         MISTRING& properties,
         bool ShowExtents = true
         );

      MISTRING GetReferenceLocation (
         ) const { return (m_Reference); }

      double GetScale (
         ) const { return (m_Scale); }

      INT32 GetScaleNumerator (
         ) const { return (m_ScaleNumerator); }

      INT32 GetScaleDenominator (
         ) const { return (m_ScaleDenominator); }

      INT64 GetPrescaleOffset (
         ) const { return (m_PrescaleOffset); }

      INT64 GetPostscaleOffset (
         ) const { return (m_PostscaleOffset); }

      STRUCTURE GetStructure ();

      TARGET GetTarget ();

      TYPE GetType () {return m_type;}

      const FORMAT& GetTileFormat (
         bool HasNullCells
         ) const;

      const MILIST<FORMAT>& GetTileFormatList (
         ) const { return (m_TileFormatList); }

      ERRVALUE GetTileRange (
         INT32 level,                        
         TILESET::RANGE& TileRange           
         ) const;

      INT32 GetTileSize (
         ) const { return (m_TileSize); }

      MISTRING GetTitle (
         ) const { return (m_title); }

      ERRVALUE GetTopLeftTile (
         INT32 level,                     
         LPOINT2D& TileIdx                
         ) const;

      void GetTransparentColorList(MILIST<TransparentColor>& TransparentColors) {TransparentColors = m_TransparentColorsList;}

      const DATETIME& GetTSDLastMod () {return m_TSDLastMod;}

      INT32 HasDate () const;

      bool HasSourceTiles (
         const FILEPATH& PathBaseFolder,
         INT32 level,
         const LPOINT2D& TileIdx
         );

      bool HasSourceTiles (
         INT32 level,
         const LPOINT2D& TileIdx
         );

      bool HasSourceTiles (
         const FILEPATH& PathBaseFolder,
         INT32 level,
         INT32 row
         );

      bool HasSourceTiles (
         INT32 level,
         INT32 row
         );

      bool HasTile (
         const FILEPATH& PathBaseFolder,
         INT32 level,
         const LPOINT2D& TileIdx
         );

      bool HasTile (
         INT32 level,
         const LPOINT2D& TileIdx
         );

      bool HasTiles (
         const FILEPATH& PathBaseFolder,
         INT32 level,
         INT32 row,
         bool bClear = false
         );

      bool HasTiles (
         INT32 level,
         INT32 row,
         bool bClear = false
         );

      ERRVALUE ReadTSD (
         const RVC::OBJITEM& objitem
         );

      ERRVALUE ReadTSD (
         const FILEPATH& filepath
         );

      ERRVALUE ReadTSD (
         const MISTRING& URL
         );

      ERRVALUE ReadTSD (
         const XMLDOC& doc
         );

      void SetBaseCellSize (
         double BaseCellSize
         ) { m_BaseCellSize = BaseCellSize; }

      void SetBaseTileCount (
         INT32 TileCount
         ) { m_BaseTileCount = TileCount; }

      ERRVALUE SetExtents (
         const DRECT2D& ExtentsInCRS,        
         INT32 MinLevel,                     
         INT32 MaxLevel,                        
         bool IsOnBorder   = false              
         );

      void SetMargin (
         double margin
         ) { m_Margin = margin; }

      ERRVALUE SetMaxTileRange (
         const TILESET::RANGE& TileRange     
         );

      void SetMetadata (
         const MISTRING& metadata
         ) { m_metadata = metadata; }

      void SetPath (
         const FILEPATH& path
         ) { m_TSDPath = path; }

      void SetPixelValueRange(
         double PixelValueMin,
         double PixelValueMax
         ) { m_PixelValueMin = PixelValueMin;  m_PixelValueMax = PixelValueMax; }

      void SetRemoteLocationStrings (const MISTRINGLIST& RemoteLocationStrings) {m_RemoteLocationStrings = RemoteLocationStrings;}

      void SetScale (
         double Scale
         ) { m_Scale = Scale; }

      void SetScaleRational (
         INT32 Numerator,
         INT32 Denominator
         ) { m_ScaleNumerator = Numerator; m_ScaleDenominator = Denominator; m_Scale = (double)Numerator/(double)Denominator; }

      void SetPrescaleOffset (
         INT64 offset
         ) { m_PrescaleOffset = offset; }

      void SetPostscaleOffset (
         INT64 offset
         ) { m_PostscaleOffset = offset; }

      void SetTileFormat (
         const IMAGE::FORMAT& format         
         );

      void SetTileSize (
         INT32 TileSize
         ) { m_TileSize = TileSize; }

      void SetTitle (
         const MISTRING& title
         ) { m_title = title; }

      void SetType (
         TYPE type
         ) { m_type = type; }

      void SetURL (
         const MISTRING& URL
         ) { m_TSDURL = URL; }

      ERRVALUE WriteKML (
         const FILEPATH& PathBaseFolder,        
         INT32 level,                     
         const LPOINT2D& TileIdx             
         );

      ERRVALUE WriteTSD (
         const FILEPATH& filepath,           
         const FILEPATH& PathBaseFolder,        
         INT32 MinLevel = -1                 
         );

      ERRVALUE WriteTSD (
         const FILEPATH& filepath,           
         const MISTRINGLIST& LocationList,      
         INT32 MinLevel = -1                 
         );

      ERRVALUE WriteTSD (
         const FILEPATH& filepath,           
         const FILEPATH& PathBaseFolder,        
         const MISTRINGLIST& LocalLevelLocationList,  
         const MISTRINGLIST& RemoteLevelLocationList,
         INT32 MinLevel = -1                 
         );

      ERRVALUE WriteTSD (
         const FILEPATH& filepath,           
         const MISTRINGLIST& LocationList,      
         const MISTRINGLIST& LocalLevelLocationList,  
         const MISTRINGLIST& RemoteLevelLocationList,
         INT32 MinLevel = -1                 
         );

      ERRVALUE WriteTSD (
         const FILEPATH& filepath,           
         INT32 MinLevel = -1                 
         );

      ERRVALUE Unzip (
         const FILEPATH& TileFolderBasePath,    
         bool bDeleteAfterUnzip = false         
         );

      ERRVALUE Unzip (
         const FILEPATH& TileFolderBasePath,    
         const FILEPATH& TargetPath,            
         bool bDeleteAfterUnzip = false         
         );

      ERRVALUE Zip (
         const FILEPATH& TileFolderBasePath,    
         bool bDeleteAfterZip = false        
         );

      ERRVALUE Zip (
         const FILEPATH& TileFolderBasePath,    
         const FILEPATH& TargetPath,            
         bool bDeleteAfterZip = false        
         );

      ERRVALUE ZipLevel (
         const FILEPATH& TileFolderBasePath,    
         INT32 level,                     
         bool bDeleteAfterZip = false        
         );

      ERRVALUE ZipLevel (
         const FILEPATH& TileFolderBasePath,    
         const FILEPATH& TargetPath,            
         INT32 level,                     
         bool bDeleteAfterZip = false,       
         MITHREAD::QUEUE* Queue = NULL       
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      RVC::OBJITEM m_objitem;
      PROFILE m_profile;
      TYPE m_type;
      INT32 m_TileSize;
      SPATREF::COORDREFSYS m_crs;
      double m_BaseCellSize;                 // Base cell size used in local profile
      INT32 m_BaseLevel;                     // Level corresponding to base cell size for local profile
      INT32 m_BaseTileCount;
      INT32 m_MaxLevel;
      INT32 m_MinLevel;
      INT32 m_BitsetTargetLevel;
      INT32 m_BitsetSourceLevel;
      INT32 m_BitsetTargetRow;
      INT32 m_BitsetSourceRow;
      INT32 m_LastLocationIndex;
      double m_PixelValueMin;
      double m_PixelValueMax;
      double m_Scale;
      INT32 m_ScaleNumerator;
      INT32 m_ScaleDenominator;
      INT64 m_PrescaleOffset;
      INT64 m_PostscaleOffset;
      MISTRING m_title;
      MISTRING m_metadata;
      MISTRING m_Reference;
      DRECT2D m_ExtentsInCRS;
      DRECT2D m_GeogExtents;
      XMLNODE* m_DateList;
      XMLNODE* m_DateRange;
      XMLDOC m_DateDoc;
      MILIST<TransparentColor> m_TransparentColorsList;
      FILEPATH m_TSDPath;
      MISTRING m_TSDURL;
      DATETIME m_TSDLastMod;

      MISTATUSCONTEXT *m_Context;
      INT32 m_JobCount;

      MISTRINGLIST m_RemoteLocationStrings;
      MISTRINGLIST m_LocalLocationStrings;
      MISTRINGLIST m_RemoteLocationLevelStrings;
      MISTRINGLIST m_LocalLocationLevelStrings;
      MISTRING m_CacheLocationString;

      MILIST<IMAGE::FORMAT> m_TileFormatList;
      TILESET::RANGE *m_TileRangeArray;
      BITSET m_TargetTileExistsBitset;
      BITSET m_SourceTilesExistBitset;

      ZIPFILE m_LastZipFile;
      FILEPATH m_LastZipFilePath;

      double m_Margin; //currently only used for svgs a margin outside of which the data may render inspite of tile size (required for html rendering)
      
      ERRVALUE ComputeTileValues (
         const DPOINT2D& pt,
         INT32 level,
         TILESET::POSN& TilePosn,
         bool IsBottomRight,
         bool IsOnBorder
         ) const;

      ERRVALUE ComputeTileValuesGeog (
         const DPOINT2D& ptGeog,
         INT32 level,
         TILESET::POSN& TilePosn,
         bool IsBottomRight,
         bool IsOnBorder
         ) const;

      ERRVALUE CreateTilesetMap (
         const RVC::OBJITEM& objitem,
         INT32 level,
         const TRANS2D_AFFINE& SrcTransAffine,
         const MISTRING& name,
         const MISTRING& description,
         const IMGFORMAT& ImgFormat
         );

      bool FilterDelegate16ToRGBA (
         const SPATMOD::IMAGE::SAMPLEITERATOR *ittgt,
         const SPATMOD::IMAGE::SAMPLEITERATOR *itsrc,
         bool valid
         );

      MISTRING GetRelativePathString (
         const FILEPATH& TSDPath,      
         const FILEPATH& PathBaseFolder   
         ) const;

      MISTRING GetNextLocationString (
         const MISTRINGLIST& LocationList
         );

      MISTRING GetLocationString (
         INT32 level,
         const MISTRINGLIST& LocationStrings,
         const MISTRINGLIST& LocationLevelStrings
         );

      void OnJobDone (MITHREAD::ID id);
      void SetupTargetBitsets (const FILEPATH& PathBaseFolder, INT32 level, INT32 row, bool bClearRow = false);
      void SetupSourcesBitsets (const FILEPATH& PathBaseFolder, INT32 level, INT32 row);
      MISTRING GetPathStructureComment (const MISTRING& BasePath) const;
      ERRVALUE WriteTSDBase (MISTRING& string);
      ERRVALUE WriteTSDZoomLevels (MISTRING& string, INT32 MinLevel);
      ERRVALUE WriteTSDZoomLevels (MISTRING& string, INT32 MinLevel, const MISTRINGLIST& LocalLevelLocationList, const MISTRINGLIST& RemoteLevelLocationList);
      ERRVALUE WriteTSDLocations (MISTRING& string, const FILEPATH& filepath, const FILEPATH& PathBaseFolder) const;
      ERRVALUE WriteTSDLocations (MISTRING& string, const MISTRINGLIST& LocationList) const;

      #endif // GENERATING_DOXYGEN_OUTPUT

   };

#ifndef  GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(TILESET::TYPE)
#endif

//=====================================================================================================================

}  // End namespace IMAGE
}  // End namespace SPATMOD

#endif   // INC_SPATMOD_IMAGETILESET_H

---