ImageExporter.cpp

#include "ImageExporter.h"

#include "Buffer.h"
#include "Cube.h"
#include "CubeAttribute.h"
#include "ExportDescription.h"
#include "FileName.h"
#include "JP2Exporter.h"
#include "PixelType.h"
#include "ProcessExport.h"
#include "QtExporter.h"
#include "TiffExporter.h"

using namespace Isis;
using namespace std;


namespace Isis {
  ImageExporter::ImageExporter() {
    m_process = NULL;
    m_process = new ProcessExport;

    m_writeMethod = NULL;

    m_exportDescription = NULL;
    m_exportDescription = new ExportDescription();

    m_extension = "";
    m_worldExtension = "";

    m_samples = 0;
    m_lines = 0;
    m_bands = 0;

    m_outputPixelMinimum = 0.0;
    m_outputPixelMaximum = 0.0;
  }


  void ImageExporter::initialize(ExportDescription &desc) {
    setExportDescription(desc);
    initializeProcess();
  }

  ImageExporter::~ImageExporter() {
    delete m_process;
    m_process = NULL;
    delete m_exportDescription;
    m_exportDescription = NULL;
  }


  void ImageExporter::operator()(vector<Buffer *> &in) const {
    (this->*m_writeMethod)(in);
  }


  void ImageExporter::write(FileName outputName, int quality,
                            QString compression) {
    ProcessExport &p = process();
    if (!p.HasInputRange()) p.SetInputRange();
    p.ProcessCubes(*this);
    
    outputName = outputName.addExtension(m_extension);
    
    createWorldFile(outputName);
  }


  int ImageExporter::samples() const {
    return m_samples;
  }


  int ImageExporter::lines() const {
    return m_lines;
  }


  int ImageExporter::bands() const {
    return m_bands;
  }


  double ImageExporter::inputMinimum(int channel) const {
    return m_process->GetInputMinimum(channel);
  }


  double ImageExporter::inputMaximum(int channel) const {
    return m_process->GetInputMaximum(channel);
  }


  void ImageExporter::setOutputPixelRange(double outputPixelMinimum, double outputPixelMaximum) {
    m_outputPixelMinimum = outputPixelMinimum;
    m_outputPixelMaximum = outputPixelMaximum;
  }


  void ImageExporter::setExtension(QString extension) {
    m_extension = extension;

    // World file extension is the first and last characters of the extension
    // with an added 'w' at the end
    int last = extension.length() - 1;
    m_worldExtension = extension.mid(0, 1) + extension.mid(last) + "w";
  }


  QString ImageExporter::extension() const {
    return m_extension;
  }

  void ImageExporter::setExportDescription(ExportDescription &desc) {
    *m_exportDescription = desc;
  }

  ExportDescription &ImageExporter::exportDescription() const {
    return *m_exportDescription;
  }


  Cube *ImageExporter::initializeProcess() {
    switch (m_exportDescription->channelCount()) {
      case 1:
        m_writeMethod = &ImageExporter::writeGrayscale;
        break;
      case 3:
        m_writeMethod = &ImageExporter::writeRgb;
        break;
      case 4:
        m_writeMethod = &ImageExporter::writeRgba;
        break;
      default:
        throw IException(IException::Programmer,
            "Cannot export an image with [" + QString(m_exportDescription->channelCount()) +
            "] channels",
            _FILEINFO_);
    }

    ProcessExport &p = process();
    Cube *cube = addChannel(0);
    m_samples = cube->sampleCount();
    m_lines = cube->lineCount();
    m_bands = m_exportDescription->channelCount();

    for (int i = 1; i < m_exportDescription->channelCount(); i++) addChannel(i);

    p.setFormat(ProcessExport::BIL);// why BIL and not default to BSQ??? Doesn't appear to make a 
                                    // difference in output images

    // set up the output pixel type, special pixels and valid output range for
    // the stretch that will be performed by ProcessExport
    p.SetOutputType(exportDescription().pixelType());
    p.SetOutputRange(m_exportDescription->outputPixelValidMin(), 
                     m_exportDescription->outputPixelValidMax());
    
    // the dafault value for the null 
    p.SetOutputNull(m_exportDescription->outputPixelNull());

    // set the absolute min/max values for all pixels (including specials) in the output image 
    setOutputPixelRange(m_exportDescription->outputPixelAbsoluteMin(), 
                        m_exportDescription->outputPixelAbsoluteMax());
    return cube;
  }


  ProcessExport &ImageExporter::process() const {
    return *m_process;
  }


  PixelType ImageExporter::pixelType() const {
    if (m_exportDescription) {
      return m_exportDescription->pixelType();
    }
    else {
      return Isis::None;
    }   
  }


  int ImageExporter::outputPixelValue(double dn) const {
    if (dn < m_outputPixelMinimum) {
      return m_outputPixelMinimum;
    }
    else if (dn > m_outputPixelMaximum) {
      return m_outputPixelMaximum;
    }
    else {
      return dn;
    }
  }


  Cube * ImageExporter::addChannel(int i) {
    ProcessExport &p = process();

    const ExportDescription::ChannelDescription &channel = m_exportDescription->channel(i);
    Cube *cube = p.SetInputCube(channel.filename().expanded(), channel.attributes(), Isis::OneBand);

    if (channel.hasCustomRange())
      p.SetInputRange(channel.inputMinimum(), channel.inputMaximum(), i);

    return cube;
  }


  void ImageExporter::createWorldFile(FileName outputName) {
    outputName = outputName.removeExtension();
    outputName = outputName.addExtension(m_worldExtension);

    ProcessExport &p = process();
    p.CreateWorldFile(outputName.expanded());
    p.EndProcess();
  }


  ImageExporter * ImageExporter::fromFormat(QString format) {
    ImageExporter *exporter = NULL;

    format = format.toLower();
    if (TiffExporter::canWriteFormat(format)) {
      exporter = new TiffExporter();
    }
    else if (JP2Exporter::canWriteFormat(format)) {
      exporter = new JP2Exporter();
    }
    else if (QtExporter::canWriteFormat(format)) {
      exporter = new QtExporter(format);
    }
    else {
      throw IException(IException::Programmer,
          "Cannot export image as format [" + format + "]",
          _FILEINFO_);
    }

    return exporter;
  }
};