ImageImporter.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "ImageImporter.h"
 
#include <QImageReader>
 
#include "Buffer.h"
#include "CubeAttribute.h"
#include "FileName.h"
#include "History.h"
#include "JP2Decoder.h"
#include "JP2Importer.h"
#include "ProcessByLine.h"
#include "PvlGroup.h"
#include "QtImporter.h"
#include "SpecialPixel.h"
#include "TiffImporter.h"
 
using namespace Isis;
 
 
namespace Isis {
  ImageImporter::ImageImporter(FileName inputName) {
    m_inputName = NULL;
    m_outCube = NULL;
 
    m_inputName = new FileName(inputName);
    m_outCube = new Cube;
 
    m_nullMin = DBL_MAX;
    m_nullMax = DBL_MIN;
    m_lrsMin = DBL_MAX;
    m_lrsMax = DBL_MIN;
    m_hrsMin = DBL_MAX;
    m_hrsMax = DBL_MIN;
  }
  ImageImporter::ImageImporter(FileName inputName) {…}
 

  ImageImporter::~ImageImporter() {
    delete m_inputName;
    m_inputName = NULL;
 
    delete m_outCube;
    m_outCube = NULL;
  }
  ImageImporter::~ImageImporter() {…}
 

  PvlGroup ImageImporter::convertProjection() const {
    PvlGroup map("Mapping");
    return map;
  }
  PvlGroup ImageImporter::convertProjection() const  {…}
 

  void ImageImporter::operator()(Buffer &out) const {
    // Get the method responsible for finding the color component for the
    // current output pixel
    GetChannelMethod getChannel = getBandChannel(out.Band());
 
    // Updates the raw buffer of input data when only part of the image is
    // stored in memory at a time
    updateRawBuffer(out.Line(), out.Band());
 
    // Processing by line, so loop over every sample in the buffer and get its
    // color component for the current output band, filter based on our special
    // pixel ranges, then output the resulting DN
    int l = out.Line() - 1;
    for (int s = 0; s < out.SampleDimension(); s++) {
      out[s] = testSpecial((this->*getChannel)(getPixel(s, l)));
    }
  }
  void ImageImporter::operator()(Buffer &out) const  {…}
 

  Cube * ImageImporter::import(FileName outputName) {
    CubeAttributeOutput att;
    return import(outputName, att);
  }
  Cube * ImageImporter::import(FileName outputName) {…}
 

  Cube * ImageImporter::import(FileName outputName, CubeAttributeOutput &att) {
    ProcessByLine p;
    Cube *cube = createOutput(outputName, att);
 
    Pvl *label = cube->label();
    PvlGroup bandBin("BandBin");
 
    PvlKeyword name("Name");
    if (bands() == 1) {
      name += "Gray";
    }
    else if (bands() == 3 || bands() == 4) {
      name += "Red";
      name += "Green";
      name += "Blue";
      if (bands() == 4) name += "Alpha";
    }
    else {
      throw IException(IException::Programmer,
          "Cannot interpret BandBin for [" + IString(bands()) + "] band image",
          _FILEINFO_);
    }
    bandBin += name;
    PvlObject &cubeObj = label->findObject("IsisCube");
    cubeObj.addGroup(bandBin);
 
    PvlGroup mapping = convertProjection();
    if (mapping.keywords() > 0) {
      cubeObj.addGroup(mapping);
    }
 
    p.SetInputCube(cube);
    p.WriteHistory(*cube);
    p.SetProcessingDirection(ProcessByBrick::BandsFirst);
    p.ProcessCubeInPlace(*this, false);
    p.EndProcess();
 
    return cube;
  }
  Cube * ImageImporter::import(FileName outputName, CubeAttributeOutput &att) {…}
 

  Cube * ImageImporter::createOutput(
      FileName outputName, CubeAttributeOutput &att) {
 
    m_outCube->setDimensions(samples(), lines(), bands());
    m_outCube->create(outputName.expanded(), att);
    return m_outCube;
  }
  Cube * ImageImporter::createOutput( {…}
 

  void ImageImporter::setDefaultBands() {
    setBands((isGrayscale()) ? 1 : (isArgb()) ? 4 : 3);
  }
  void ImageImporter::setDefaultBands() {…}
 

  void ImageImporter::setNullRange(double min, double max) {
    m_nullMin = min;
    m_nullMax = max;
  }
  void ImageImporter::setNullRange(double min, double max) {…}
 

  void ImageImporter::setLrsRange(double min, double max) {
    m_lrsMin = min;
    m_lrsMax = max;
  }
  void ImageImporter::setLrsRange(double min, double max) {…}
 

  void ImageImporter::setHrsRange(double min, double max) {
    m_hrsMin = min;
    m_hrsMax = max;
  }
  void ImageImporter::setHrsRange(double min, double max) {…}
 

  void ImageImporter::setSamples(int s) {
    m_samples = s;
  }
  void ImageImporter::setSamples(int s) {…}
 

  void ImageImporter::setLines(int l) {
    m_lines = l;
  }
  void ImageImporter::setLines(int l) {…}
 

  void ImageImporter::setBands(int b) {
    if (b == 2 || b > 4)
      throw IException(IException::Programmer,
          "Cannot create an image with [" + IString(b) + "] bands",
          _FILEINFO_);
 
    m_bands = b;
  }
  void ImageImporter::setBands(int b) {…}
 

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

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

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

  FileName ImageImporter::filename() const {
    return *m_inputName;
  }
  FileName ImageImporter::filename() const  {…}
 

  double ImageImporter::testSpecial(double pixel) const {
    if (pixel <= m_nullMax && pixel >= m_nullMin) {
      return Isis::NULL8;
    }
    else if (pixel <= m_hrsMax && pixel >= m_hrsMin) {
      return Isis::HIGH_REPR_SAT8;
    }
    else if (pixel <= m_lrsMax && pixel >= m_lrsMin) {
      return Isis::LOW_REPR_SAT8;
    }
    else {
      return pixel;
    }
  }
  double ImageImporter::testSpecial(double pixel) const  {…}
 

  ImageImporter::GetChannelMethod
    ImageImporter::getBandChannel(int band) const {
 
    GetChannelMethod getChannel;
    if (bands() == 1) {
      getChannel = &ImageImporter::getGray;
    }
    else {
      switch (band) {
        case 1:
          getChannel = &ImageImporter::getRed;
          break;
        case 2:
          getChannel = &ImageImporter::getGreen;
          break;
        case 3:
          getChannel = &ImageImporter::getBlue;
          break;
        case 4:
          getChannel = &ImageImporter::getAlpha;
          break;
        default:
          throw IException(IException::Programmer,
              "Cannot determine channel for band [" + IString(band) + "]",
              _FILEINFO_);
      }
    }
    return getChannel;
  }
    ImageImporter::getBandChannel(int band) const  {…}
 

  int ImageImporter::convertRgbToGray(int pixel) const {
    int red = getRed(pixel);
    int green = getBlue(pixel);
    int blue = getGreen(pixel);
    return (red * 11 + green * 16 + blue * 5) / 32;
  }
  int ImageImporter::convertRgbToGray(int pixel) const  {…}
 

  ImageImporter * ImageImporter::fromFileName(FileName inputName) {
    ImageImporter *importer = NULL;
 
    QString format = QImageReader::imageFormat(inputName.expanded());
    if (format == "tiff") {
      importer = new TiffImporter(inputName);
    }
    else if (format != "" && format != "jp2") {
      importer = new QtImporter(inputName);
    }
    else if (JP2Decoder::IsJP2(inputName.expanded().toLatin1().data())) {
      importer = new JP2Importer(inputName);
    }
    else {
      throw IException(IException::Programmer,
          "Cannot determine image format for [" + inputName.expanded() + "]",
          _FILEINFO_);
    }
 
    return importer;
  }
  ImageImporter * ImageImporter::fromFileName(FileName inputName) {…}
};