ProcessExport.h

Go to the documentation of this file.

#ifndef ProcessExport_h
#define ProcessExport_h

#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"

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(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