ProcessExport.h

#ifndef ProcessExport_h
#define ProcessExport_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Process.h"
 
#include <fstream>
#include <iostream>
#include <string>
 
#include <QCryptographicHash>
#include <QString>
 
#include "Buffer.h"
#include "BufferManager.h"
#include "Endian.h"
#include "EndianSwapper.h"
#include "SpecialPixel.h"
#include "Stretch.h"
#include "UserInterface.h"
 
namespace Isis {
  class ProcessExport : public Isis::Process {
 
    public:
 
      enum ExportFormat {
        BSQ, 
        BIL, 
        BIP, 
        JP2  
      };
 
      ProcessExport();
      virtual ~ProcessExport();
      using Isis::Process::StartProcess;  // make parents virtual function visable
      virtual void StartProcess(void funct(Isis::Buffer &in));
      virtual void StartProcess(void funct(std::vector<Isis::Buffer *> &in));
      virtual void StartProcess(std::ofstream &fout);
      void SetOutputRange(const double minimum, const double maximum);
      void SetOutputNull(const double value);
      void SetOutputLis(const double value);
      void SetOutputLrs(const double value);
      void SetOutputHis(const double value);
      void SetOutputHrs(const double value);
      double OutputNull();
      double OutputLis();
      double OutputLrs();
      double OutputHis();
      double OutputHrs();
      bool HasInputRange() const;
      void SetInputRange();
      void SetInputRange(UserInterface &ui);
      void SetInputRange(const double minimum, const double maximum);
      void SetInputRange(const double minimum, const double maximum, const int index);
      void SetInputRange(const double minimum, const double middle,
                         const double maximum);
      void SetInputRange(const double minimum, const double middle,
                         const double maximum, const int index);
      void CreateWorldFile(const QString &worldFile);
      void SetOutputEndian(enum ByteOrder endianness);
      void SetOutputType(Isis::PixelType pixelIn);
 
      void setCanGenerateChecksum(bool flag);
      bool canGenerateChecksum();
      QString checksum();
 
      double GetInputMinimum(unsigned int n=0) const;
      double GetInputMaximum(unsigned int n=0) const;
 
      double GetOutputMinimum() {
        return (p_outputMinimum);
      };
      double GetOutputMaximum() {
        return (p_outputMaximum);
      };
 
      void setFormat(ExportFormat format) {
        p_format = format;
      };
 
 
      template <typename Functor> void ProcessCubes(const Functor & functor) {
 
        int samples = InputCubes[0]->sampleCount();
        int length = 0;
        if (p_format == BIP) {
          length = InputCubes[0]->bandCount();
        }
        else {
          length = InputCubes[0]->lineCount();
        }
 
        // Loop and let the app programmer fiddle with the lines
        std::vector<BufferManager *> imgrs = GetBuffers();
        for (int k = 1; k <= length; k++) {
          std::vector<Buffer *> ibufs;
 
          for (unsigned int cubeIndex = 0; cubeIndex < InputCubes.size(); cubeIndex++) {
            // Read a line of data from this cube
            InputCubes[cubeIndex]->read(*imgrs[cubeIndex]);
 
            // Stretch the pixels into the desired range
            for (int sampleIndex = 0; sampleIndex < samples; sampleIndex++) {
              (*imgrs[cubeIndex])[sampleIndex] =
                  p_str[cubeIndex]->Map((*imgrs[cubeIndex])[sampleIndex]);
            }
 
            ibufs.push_back(imgrs[cubeIndex]);
          }
 
          // Invoke the user function
          functor(ibufs);
 
          for (unsigned int i = 0; i < imgrs.size(); i++) imgrs[i]->next();
          p_progress->CheckStatus();
        }
      }
 
    protected:
 
      ExportFormat p_format;
 
      std::vector<BufferManager *> GetBuffers();
      std::vector<BufferManager *> GetBuffersBSQ();
      std::vector<BufferManager *> GetBuffersBIL();
      std::vector<BufferManager *> GetBuffersBIP();
 
      double p_outputMinimum; 
      double p_outputMiddle;  
      double p_outputMaximum; 
 
      std::vector<double> p_inputMinimum; 
      std::vector<double> p_inputMiddle;  
      std::vector<double> p_inputMaximum; 
      EndianSwapper *p_endianSwap; 
      ByteOrder p_endianType; 
 
      PixelType p_pixelType;  
      std::vector<Stretch *> p_str; 
      double p_Null; 
      double p_Lis;  
      double p_Lrs;  
      double p_His;  
      double p_Hrs;  
      bool p_Null_Set; 
      bool p_Lis_Set;  
      bool p_Lrs_Set;  
      bool p_His_Set;  
      bool p_Hrs_Set;  
      QCryptographicHash *m_cryptographicHash; 
      bool m_canGenerateChecksum;  
    private:
      void isisOut8(Buffer &in, std::ofstream &fout);
 
      void isisOut16s(Buffer &in, std::ofstream &fout);
 
      void isisOut16u(Buffer &in, std::ofstream &fout);
 
      void isisOut32(Buffer &in, std::ofstream &fout);
 
      void isisOut64(Buffer &in, std::ofstream &fout);
 
      void InitProcess();
 
 
  };
};
 
#endif