ProcessMosaic.h

#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