ImageExporter.cpp

#include "ImageExporter.h"

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

using namespace Isis;


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

    m_writeMethod = NULL;

    m_extension = "";
    m_world = "";

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

    m_dataMin = 0.0;
    m_dataMax = 255.0;
  }


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


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


  void ImageExporter::write(FileName outputName, int quality) {
    ProcessExport &p = getProcess();
    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::getInputMinimum(int channel) const {
    return m_process->GetInputMinimum(channel);
  }


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


  void ImageExporter::setOutputRange(double min, double max) {
    m_dataMin = min;
    m_dataMax = max;
  }


  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_world = extension.mid(0, 1) + extension.mid(last) + "w";
  }


  Cube * ImageExporter::setInput(ExportDescription &desc) {
    switch (desc.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(desc.channelCount()) +
            "] channels",
            _FILEINFO_);
    }

    ProcessExport &p = getProcess();
    Cube *cube = addChannel(desc, 0);
    m_samples = cube->sampleCount();
    m_lines = cube->lineCount();
    m_bands = desc.channelCount();

    for (int i = 1; i < desc.channelCount(); i++) addChannel(desc, i);

    p.SetOutputRange(1.0, 255.0);
    p.SetOutputNull(0.0);
    return cube;
  }


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


  int ImageExporter::getPixel(double dn) const {
    return (dn < m_dataMin) ? m_dataMin : (dn > m_dataMax) ? m_dataMax : dn;
  }


  Cube * ImageExporter::addChannel(ExportDescription &desc, int i) {
    ProcessExport &p = getProcess();

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

    if (channel.hasCustomRange())
      p.SetInputRange(channel.getInputMinimum(), channel.getInputMaximum(), i);

    return cube;
  }


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

    ProcessExport &p = getProcess();
    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 (QtExporter::canWriteFormat(format)) {
      exporter = new QtExporter(format);
    }
    else if (JP2Exporter::canWriteFormat(format)) {
      exporter = new JP2Exporter();
    }
    else {
      throw IException(IException::Programmer,
          "Cannot export image as format [" + format + "]",
          _FILEINFO_);
    }

    return exporter;
  }
};