ImageExporter.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#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"
#include "UserInterface.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;
  }
  ImageExporter::ImageExporter() {…}
 

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

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

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

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

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

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

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

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

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

  void ImageExporter::setOutputPixelRange(double outputPixelMinimum, double outputPixelMaximum) {
    m_outputPixelMinimum = outputPixelMinimum;
    m_outputPixelMaximum = outputPixelMaximum;
  }
  void ImageExporter::setOutputPixelRange(double outputPixelMinimum, double 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";
  }
  void ImageExporter::setExtension(QString extension) {…}
 

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

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

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

  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;
  }
  Cube *ImageExporter::initializeProcess() {…}
 

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

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

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

  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;
  }
  Cube * ImageExporter::addChannel(int i) {…}
 

  void ImageExporter::createWorldFile(FileName outputName) {
    outputName = outputName.removeExtension();
    outputName = outputName.addExtension(m_worldExtension);
 
    ProcessExport &p = process();
    p.CreateWorldFile(outputName.expanded());
    p.EndProcess();
  }
  void ImageExporter::createWorldFile(FileName outputName) {…}
 

  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;
  }
  ImageExporter * ImageExporter::fromFormat(QString format) {…}
};