Enlarge.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Enlarge.h"
 
#include <cmath>
 
#include "Cube.h"
#include "IException.h"
#include "PvlGroup.h"
#include "SubArea.h"
 
using namespace std;
 
namespace Isis {

  Enlarge::Enlarge(Cube *pInCube, const double sampleScale,
                   const double lineScale) {
    // Input Cube
    mInCube = pInCube;
 
    // Set input image area to defaults
    mdStartSample = 1;
    mdEndSample   = mInCube->sampleCount();
    mdStartLine   = 1;
    mdEndLine     = mInCube->lineCount();
 
    // Save off the sample and line magnification
    mdSampleScale = sampleScale;
    mdLineScale   = lineScale;
 
    miOutputSamples = (int)ceil(mInCube->sampleCount() * mdSampleScale);
    miOutputLines   = (int)ceil(mInCube->lineCount() * mdLineScale);
  }
  Enlarge::Enlarge(Cube *pInCube, const double sampleScale, {…}

  bool Enlarge::Xform(double &inSample, double &inLine,
                      const double outSample, const double outLine) {
    inSample = (outSample - 0.5) / mdSampleScale + 0.5 + (mdStartSample - 1);
    inLine   = (outLine - 0.5) / mdLineScale + 0.5 + (mdStartLine - 1);
 
    return true;
  }
  bool Enlarge::Xform(double &inSample, double &inLine, {…}

  void Enlarge::SetInputArea(double pdStartSample, double pdEndSample,
                             double pdStartLine, double pdEndLine) {
    // Check for the right image dimensions
    if (pdStartSample > pdEndSample || pdStartLine > pdEndLine) {
      string sErrMsg = "Error in Input Area Dimesions";
      throw IException(IException::Programmer, sErrMsg, _FILEINFO_);
    }
 
    if (pdStartSample >= 1) {
      mdStartSample = pdStartSample;
    }
    if (pdEndSample <= mInCube->sampleCount()) {
      mdEndSample = pdEndSample;
    }
    if (pdStartLine >= 1) {
      mdStartLine = pdStartLine;
    }
    if (pdEndLine <= mInCube->lineCount()) {
      mdEndLine = pdEndLine;
    }
 
    miOutputSamples = (int)ceil((mdEndSample - mdStartSample + 1) * mdSampleScale);
    miOutputLines   = (int)ceil((mdEndLine - mdStartLine + 1) * mdLineScale);
  }
  void Enlarge::SetInputArea(double pdStartSample, double pdEndSample, {…}

  PvlGroup Enlarge::UpdateOutputLabel(Cube *pOutCube) {
    int iNumSamples= mInCube->sampleCount();
    int iNumLines  = mInCube->lineCount();
    // Construct a label with the results
    // This is the Results group that will go into the application
    // log file. This group must be created by the calling application.
    // Information will be added to it if the Mapping or Instrument
    // groups are deleted from the output image label
    PvlGroup resultsGrp("Results");
    resultsGrp += PvlKeyword("InputLines",      toString(iNumLines));
    resultsGrp += PvlKeyword("InputSamples",    toString(iNumSamples));
    resultsGrp += PvlKeyword("StartingLine",    toString((int)mdStartLine));
    resultsGrp += PvlKeyword("StartingSample",  toString((int)mdStartSample));
    resultsGrp += PvlKeyword("EndingLine",      toString((int)mdEndLine));
    resultsGrp += PvlKeyword("EndingSample",    toString((int)mdEndSample));
    resultsGrp += PvlKeyword("LineIncrement",   toString(1. / mdLineScale));
    resultsGrp += PvlKeyword("SampleIncrement", toString(1. / mdSampleScale));
    resultsGrp += PvlKeyword("OutputLines",     toString(miOutputLines));
    resultsGrp += PvlKeyword("OutputSamples",   toString(miOutputSamples));
 
    SubArea subArea;
    subArea.SetSubArea(mInCube->lineCount(), mInCube->sampleCount(), (int)mdStartLine, (int)mdStartSample,
                       (int)mdEndLine, (int)mdEndSample, 1.0 / mdLineScale, 1.0 / mdSampleScale);
    subArea.UpdateLabel(mInCube, pOutCube, resultsGrp);
 
    return resultsGrp;
  }
  PvlGroup Enlarge::UpdateOutputLabel(Cube *pOutCube) {…}
}