ProcessExport.h

Go to the documentation of this file.

#ifndef ProcessExport_h
#define ProcessExport_h

#include <iostream>
#include <string>
#include <fstream>
#include "Process.h"
#include "Buffer.h"
#include "BufferManager.h"
#include "SpecialPixel.h"
#include "Endian.h"
#include "EndianSwapper.h"
#include "Stretch.h"

namespace Isis {
  class ProcessExport : public Isis::Process {

    public:

      enum ExportFormat { 
        BSQ, 
        BIL, 
        BIP, 
        JP2  
      };

      ProcessExport();
      ~ProcessExport();
      void StartProcess(void funct(Isis::Buffer &in));
      void StartProcess(void funct(std::vector<Isis::Buffer *> &in));
      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);

      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 length = (p_format == BIP) ?
          InputCubes[0]->bandCount() : InputCubes[0]->lineCount();

        int samples = InputCubes[0]->sampleCount();

        // 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 j = 0; j < InputCubes.size(); j++) {
            // Read a line of data
            InputCubes[j]->read(*imgrs[j]);

            // Stretch the pixels into the desired range
            for (int i = 0; i < samples; i++)
              (*imgrs[j])[i] = p_str[j]->Map((*imgrs[j])[i]);

            ibufs.push_back(imgrs[j]);
          }

          // 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;  

    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 InitProcess();


  };
};

#endif