ExportDescription.cpp

#include "ExportDescription.h"

#include <float.h>

#include <QList>

#include "CubeAttribute.h"
#include "FileName.h"
#include "IString.h"
#include "IException.h"
#include "PixelType.h"

namespace Isis {
  ExportDescription::ExportDescription() {
    m_channels = NULL;
    m_channels = new QList<ChannelDescription *>;

    m_type = Isis::None;

    m_outputPixelNull = 0.0;
    m_outputPixelValidMin = 0.0;
    m_outputPixelValidMax = 255.0;
    m_outputPixelAbsoluteMin = 0.0;
    m_outputPixelAbsoluteMax = 255.0;
  }


  ExportDescription::ExportDescription(const ExportDescription &descriptionToCopy) {
    m_channels = NULL;

    if(descriptionToCopy.m_channels) {
      m_channels = new QList<ChannelDescription *>();
      for (int i = 0; i < descriptionToCopy.channelCount(); i++) {
        const ExportDescription::ChannelDescription &channel = descriptionToCopy.channel(i);
        CubeAttributeInput att = channel.attributes();
        if (channel.hasCustomRange()) {
          addChannel(channel.filename(), att, channel.inputMinimum(), channel.inputMaximum());
        }
        else {
          addChannel(channel.filename(), att);
        }
      }
    }

    setPixelType(descriptionToCopy.m_type);
  }

  ExportDescription &ExportDescription::operator=(const ExportDescription &descriptionToCopy) {
    if (m_channels) {
      delete m_channels;
      m_channels = NULL;
    }

    if(descriptionToCopy.m_channels) {
      m_channels = new QList<ChannelDescription *>();
      for (int i = 0; i < descriptionToCopy.channelCount(); i++) {
        const ExportDescription::ChannelDescription &channel = descriptionToCopy.channel(i);
        CubeAttributeInput att = channel.attributes();
        if (channel.hasCustomRange()) {
          addChannel(channel.filename(), att, channel.inputMinimum(), channel.inputMaximum());
        }
        else {
          addChannel(channel.filename(), att);
        }
      }
    }

    setPixelType(descriptionToCopy.m_type);
    return *this;
  }

  ExportDescription::~ExportDescription() {
    for (int i = 0; i < m_channels->size(); i++) delete (*m_channels)[i];
    delete m_channels;
    m_channels = NULL;
  }


  void ExportDescription::setPixelType(PixelType type) {
    m_type = type;
    switch (type) {
      case UnsignedByte:
        m_outputPixelNull = 0.0;
        m_outputPixelValidMin = 1.0;
        m_outputPixelValidMax = 255.0;
        break;
      case SignedWord:
        m_outputPixelNull = -32768.0;
        m_outputPixelValidMin = -32767.0; // Changed from -32752.0 since this variable represents 
                                          // the smallest valid exported pixel value, not our 
                                          // special pixel min valid value
        m_outputPixelValidMax = 32767.0;
        break;
      case UnsignedWord:
        m_outputPixelNull = 0.0;
        m_outputPixelValidMin = 1.0; // Changed from 3.0 since this variable is used to set the 
                                     // smallest valid exported pixel value, not our special pixel 
                                     // min valid value
        m_outputPixelValidMax = 65535.0; // Changed from 65522.0 since this variable represents the 
                                         // largest valid exported pixel value, not our special 
                                         // pixel max valid value
        break;
      default:
        throw IException(IException::Programmer,
            "Invalid export pixel type [" + toString(type) + "]",
            _FILEINFO_);
    }
    // in each case above, the smallest possible output pixel value is the null value
    m_outputPixelAbsoluteMin = m_outputPixelNull;
    // in each case above, the largest possible output pixel value is the maximum value
    m_outputPixelAbsoluteMax = m_outputPixelValidMax;

  }


  PixelType ExportDescription::pixelType() const {
    return m_type;
  }


  double ExportDescription::outputPixelNull() const {
    return m_outputPixelNull;
  }


  double ExportDescription::outputPixelValidMin() const {
    return m_outputPixelValidMin;
  }


  double ExportDescription::outputPixelValidMax() const {
    return m_outputPixelValidMax;
  }


  double ExportDescription::outputPixelAbsoluteMin() const {
    return m_outputPixelAbsoluteMin;
  }


  double ExportDescription::outputPixelAbsoluteMax() const {
    return m_outputPixelAbsoluteMax;
  }


  int ExportDescription::addChannel(FileName filename, CubeAttributeInput &att) {

    m_channels->append(new ChannelDescription(filename, att));
    return m_channels->size() - 1;
  }


  int ExportDescription::addChannel(FileName filename, CubeAttributeInput &att, 
                                    double min, double max) {

    ChannelDescription *desc = new ChannelDescription(filename, att);
    desc->setInputRange(min, max);
    m_channels->append(desc);
    return m_channels->size() - 1;
  }


  const ExportDescription::ChannelDescription &ExportDescription::channel(int i) const {

    return *(*m_channels)[i];
  }


  int ExportDescription::channelCount() const {
    return m_channels->size();
  }


  ExportDescription::ChannelDescription::ChannelDescription(FileName &filename, 
                                                            CubeAttributeInput &att) {

    m_filename = filename;
    m_att = att;

    m_customRange = false;
    m_inputMin = DBL_MIN;
    m_inputMax = DBL_MAX;
  }


  FileName ExportDescription::ChannelDescription::filename() const {
    return m_filename;
  }


  CubeAttributeInput ExportDescription::ChannelDescription::attributes() const {
    return m_att;
  }


  void ExportDescription::ChannelDescription::setInputRange(double min, double max) {

    m_inputMin = min;
    m_inputMax = max;
    m_customRange = true;
  }


  double ExportDescription::ChannelDescription::inputMinimum() const {
    return m_inputMin;
  }


  double ExportDescription::ChannelDescription::inputMaximum() const {
    return m_inputMax;
  }


  bool ExportDescription::ChannelDescription::hasCustomRange() const {
    return m_customRange;
  }
};