Object/Developer/_process_mosaic_8h_source.html

#ifndef ProcessMosaic_h

#define ProcessMosaic_h


/* SPDX-License-Identifier: CC0-1.0 */

#include "Process.h"


namespace Isis {

  class Portal;


  class ProcessMosaic : public Process {


    public:

      static const char *TRACKING_TABLE_NAME;


      // see http://blog.stata.com/tag/binary/

      static const int FLOAT_STORE_INT_PRECISELY_MAX_VALUE = 16777216;

      static const int FLOAT_STORE_INT_PRECISELY_MIN_VALUE = -16777215;


      enum ImageOverlay {

        PlaceImagesOnTop,

        PlaceImagesBeneath,

        UseBandPlacementCriteria,

        AverageImageWithMosaic,

        NumImageOverlayOptions

      };


      // Constructs a Mosaic object

      ProcessMosaic();


      //  Destroys the Mosaic object. It will close all opened cubes.

      virtual ~ProcessMosaic();


      using Isis::Process::StartProcess; // make parent funtions visable


      // Line Processing method for one input and output cube

      virtual void StartProcess(const int &piOutSample, const int &piOutLine, const int &piOutBand);


      // Finish with tracking cube

      virtual void EndProcess();


      // Accessor for the placed images.

      PvlObject imagePositions();


      using Process::SetInputCube;


      // Set input cube to specified image name at the starting and count of

      // samples, lines, bands

      virtual Isis::Cube *SetInputCube(const QString &parameter,

                               const int ss, const int sl,

                               const int sb,

                               const int ns, const int nl,

                               const int nb);


      // Set input cube to specified image name with specified attributes at the

      // starting and count of samples, lines, bands

      virtual Isis::Cube *SetInputCube(const QString &fname,

                               Isis::CubeAttributeInput &att,

                               const int ss = 1, const int sl = 1,

                               const int sb = 1,

                               const int ns = -1, const int nl = -1,

                               const int nb = -1);


      // SetOutputCube() is not virtual in the Process class, so the following

      // definitions for this method are the only ones that are allowed for

      // ProcessMosaic objects and child objects, unless redifined in the

      // child class

      Isis::Cube *SetOutputCube(const QString &psParameter);

      Isis::Cube *SetOutputCube(const QString &psParameter, UserInterface &ui);


      void SetBandBinMatch(bool enforceBandBinMatch);


      void SetBandKeyword(QString bandPriorityKeyName, QString bandPriorityKeyValue);

      void SetBandNumber(int bandPriorityBandNumber);

      void SetBandUseMaxValue(bool useMax);

      void SetCreateFlag(bool createOutputMosaic);

      void SetHighSaturationFlag(bool placeHighSatPixels);

      void SetImageOverlay(ImageOverlay placement);

      void SetLowSaturationFlag(bool placeLowSatPixels);

      void SetMatchDEM(bool matchDEM);

      void SetNullFlag(bool placeNullPixels);

      void SetTrackFlag(bool trackingEnabled);


      bool GetHighSaturationFlag() const;

      ImageOverlay GetImageOverlay() const;

      bool GetLowSaturationFlag() const;

      bool GetNullFlag() const;

      bool GetTrackFlag() const;


      int GetInputStartLineInMosaic() const;

      int GetInputStartSampleInMosaic() const;

      int GetInputStartBandInMosaic() const;


      static QString OverlayToString(ImageOverlay);

      static ImageOverlay StringToOverlay(QString);


    private:


      //Compare the input and mosaic for the specified band based on the criteria and update the

      //  mosaic origin band.

      void BandComparison(int iss, int isl, int ins, int inl,

                          int bandPriorityInputBandNumber, int bandPriorityOutputBandNumber,

                          int index);


      // Mosaicking for Band Priority with no Tracking

      void BandPriorityWithNoTracking(int iss, int isl, int isb,

                                      int ins, int inl, int inb,

                                      int bandPriorityInputBandNumber,

                                      int bandPriorityOutputBandNumber);


      // Get the default origin value based on pixel type for the origin band

      int GetOriginDefaultByPixelType();


      // Get the Band Index in an image of type (input/output)

      int GetBandIndex(bool inputFile);


      // Checks for the table with name "InputImage"

      bool GetTrackStatus();


      // New mosaic, add the Band Bin group specific to the mosaic

      void AddBandBinGroup(int origIsb);


      // Default BandBin group if Match BandBin is set to False

      void AddDefaultBandBinGroup();


      // Mosaic exists, match the band with the input image

      void MatchBandBinGroup(int origIsb, int &inb);


      bool ProcessAveragePriority(int piPixel, Portal& pInPortal, Portal& pOutPortal,

                                  Portal& pOrigPortal);


      void ResetCountBands();


      // Match DEM between Input & Mosaic if MatchDEM Flag is enabled

      void MatchDEMShapeModel();


      bool m_trackingEnabled;

      Cube *m_trackingCube;

      bool m_createOutputMosaic;

      int  m_bandPriorityBandNumber;

      QString m_bandPriorityKeyName;

      QString m_bandPriorityKeyValue;

      bool m_bandPriorityUseMaxValue;


      int m_iss;

      int m_isl;

      int m_isb;

      int m_ins;

      int m_inl;

      int m_inb;


      int m_oss;

      int m_osl;

      int m_osb;

      int m_onb;


      bool m_enforceBandBinMatch;

      bool m_enforceMatchDEM;


      ImageOverlay m_imageOverlay;


      PvlObject m_imagePositions;


      /*

       * Set the Special Pixels Flags to True/False.

       * True- allow the special pixel to be passed onto the mosaic.

       * Holds good for input and band priority

       */

      bool m_placeHighSatPixels;

      bool m_placeLowSatPixels;

      bool m_placeNullPixels;

  };

};


#endif