lti_mosaicFilter.h

Go to the documentation of this file.

/* $Id$ */
/* //////////////////////////////////////////////////////////////////////////
//                                                                         //
// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //
// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //
// prohibited.  Access to and use of this code is permitted only under     //
// license from LizardTech, Inc.  Portions of the code are protected by    //
// US and foreign patents and other filings. All Rights Reserved.          //
//                                                                         //
/* PUBLIC */

#ifndef LTI_MOSAIC_FILTER_H
#define LTI_MOSAIC_FILTER_H

// lt_lib_mrsid_core
#include "lti_imageStage.h"
#include "lti_imageStageOverrides.h"
#include "lti_imageStageManager.h"
#include "lti_sceneBuffer.h"



LT_BEGIN_NAMESPACE(LizardTech)

class LTIRTree;
class LTIEmbeddedImage;
class LTIPipelineBuilder;

#ifdef SWIG
class LTIMosaicFilter : public LTIImageStage
#else
class LTIMosaicFilter : public LTIOverrideDimensions
                               <LTIOverridePixelProps
                               <LTIOverrideBackgroundPixel
                               <LTIOverrideGeoCoord
                               <LTIOverrideMagnification
                               <LTIOverrideIsSelective
                               <LTIOverrideStripHeight
                               <LTIOverrideDelegates
                               <LTIOverridePixelLookupTables
                               <LTIOverrideMetadata
                               <LTIImageStage> > > > > > > > > >
#endif
{
   LTI_REFERENCE_COUNTED_BOILERPLATE(LTIMosaicFilter);
public:
   LT_STATUS initialize(LTIImageStageManager *imageStageManager,
                        const LTIPixel* backgroundPixel,
                        bool useMultires);

   static LT_STATUS checkResolutionConformance(LTIImageStageManager *imageStageManager,
                                               bool useMultires);

   // LTIImage
   LT_STATUS getDimsAtMag(double mag,
                          lt_uint32 &width,
                          lt_uint32 &height) const;
   LTIMaskSource *getMask() const;

   // LTIImageStage
   lt_int64 getEncodingCost(const LTIScene& scene) const;
   bool getReaderScene(const LTIScene &decodeScene,
                       LTIScene &readerScene) const;
   virtual lt_uint32 getModifications(const LTIScene &scene) const;

   void setFillMethod(LTIPixelFillMethod method,
                      double fuzzyThreshold /*= LTISceneBuffer::DefaultFuzzyThreshold*/);
   
   LTIPixelFillMethod getFillMethod(void) const;
   double getFuzzyThreshold(void) const;

   void setResampleMethod(LTIResampleMethod resampleMethod);

   void setMagSnapThreshold(double threshold);
   
   LTIResampleMethod getResampleMethod(void) const;
   
   // for LizardTech internal use only
   bool getReaderScene(lt_uint32 child,
                       const LTIScene &decodeScene,
                       LTIScene &mosaicScene,
                       LTIScene &readerScene) const;
   // for LizardTech internal use only
   bool getOverviewReaderScene(const LTIScene &decodeScene,
                               LTIScene &mosaicScene,
                               LTIScene &readerScene) const;

   // for LizardTech internal use only
   class InSceneCallback
   {
   public:
      virtual LT_STATUS found(const LTIScene &scene,
                              lt_uint32 imageNum,
                              LTIEmbeddedImage &embedded,
                              LTIImageStage &image) = 0;
   };

   // for LizardTech internal use only
   LT_STATUS forEachImageStageInScene(const LTIScene &scene,
                                      InSceneCallback &callback);

   // for LizardTech internal use only
   void setDeleteImages(bool deleteImages);
   // for LizardTech internal use only
   bool getDeleteImages(void) const;

   // for LizardTech internal use only
   LT_STATUS loadImage(lt_uint32 i,
                       LTIEmbeddedImage *&embedded,
                       LTIImageStage *&raw);
   // for LizardTech internal use only
   LT_STATUS closeImage(lt_uint32 i);

   // for LizardTech internal use only
   // does not take ownship of pipelineBuilder
   // don't call this function in inside a decodeBegin()/decodeStrip()/decodeEnd() loop
   LT_STATUS setPipelineBuilder(LTIPipelineBuilder *pipelineBuilder);

   // for LizardTech internal use only
   const LTIRTree &getRTree(void) const;
   // for LizardTech internal use only
   LTIImageStageManager &getImageStageManager(void) const;

   // for LizardTech internal use only
   bool hasOverviewImage(void) const;
   // for LizardTech internal use only
   double getOverviewMag(void) const;
   
protected:
   LT_STATUS decodeBegin(const LTIPixel &pixelProps,
                         const LTIScene &fullScene);
   LT_STATUS decodeStrip(LTISceneBuffer &stripBuffer,
                         const LTIScene &stripScene);
   LT_STATUS decodeEnd(void);

private:
   class ListImageStagesInSceneCallback;
   struct TileInfo;

   LT_STATUS setupPixelProps(TileInfo *tiles, lt_uint32 numTiles,
                             const LTIPixel *background);

   LT_STATUS setupGeoProps(TileInfo *tiles, lt_uint32 numTiles,
                           bool useMultires);

   LT_STATUS setupBuffers(lt_uint32 numTiles);
   LT_STATUS setupOverview(void);
   
   LTIImageStageManager *m_imageStageManager;

   LTIRTree *m_rtree;

   // open image book keeping
   LTIImageStage **m_rImage;
   LTIEmbeddedImage **m_fImage;
   int *m_sImage;
   LTIPixelFillMethod m_fillMethod;
   double m_fuzzyThreshold;
   LTIResampleMethod m_resampleMethod;
   double m_magSnapThreshold;
   bool m_deleteImages;

   LTIPipelineBuilder *m_pipelineBuilder;

   // imageInScene
   lt_uint32 *m_inSceneList;

   LTIEmbeddedImage *m_overview;
   double m_overviewMag;
};

#ifndef DOXYGEN_EXCLUDE

class LTIPipelineBuilder
{
public:
   virtual LT_STATUS buildPipeline(lt_uint32 tileId,
                                   LTIImageStage *&pipeline) = 0;
};

#endif

LT_END_NAMESPACE(LizardTech)


#endif // LTI_MOSAIC_FILTER_H

---

LizardTech