Chip.cpp

Go to the documentation of this file.

#include "Chip.h"




#include "Camera.h"
#include "Cube.h"
#include "IException.h"
#include "Interpolator.h"
#include "IString.h"
#include "LineManager.h"
#include "PolygonTools.h"
#include "Portal.h"
#include "Projection.h"
#include "Statistics.h"
#include "TProjection.h"

#include <algorithm>
#include <cmath>
#include <string>
#include <vector>

#include <geos/geom/Point.h>
#include <tnt/tnt_array2d_utils.h>



using namespace std;
namespace Isis {

  Chip::Chip() {
    Init(3, 3);
  }

  Chip::Chip(const Chip &other) {
    m_chipSamples = other.m_chipSamples;
    m_chipLines = other.m_chipLines;
    m_buf = other.m_buf;
    m_tackSample = other.m_tackSample;
    m_tackLine = other.m_tackLine;

    m_cubeTackSample = other.m_cubeTackSample;
    m_cubeTackLine = other.m_cubeTackLine;

    m_validMinimum = other.m_validMinimum;
    m_validMaximum = other.m_validMaximum;

    m_chipSample = other.m_chipSample;
    m_chipLine = other.m_chipLine;
    m_cubeSample = other.m_cubeSample;
    m_cubeLine = other.m_cubeLine;

    if (other.m_clipPolygon) {
      m_clipPolygon = PolygonTools::MakeMultiPolygon(
          other.m_clipPolygon->clone());
    }
    else {
      m_clipPolygon = NULL;
    }

    m_affine = other.m_affine;
    m_readInterpolator = other.m_readInterpolator;
    m_filename = other.m_filename;
  }


  Chip::Chip(const int samples, const int lines) {
    Init(samples, lines);
  }


  Chip::~Chip() {
    if (m_clipPolygon != NULL) delete m_clipPolygon;
  }


  void Chip::SetAllValues(const double &d) {
    for (unsigned int i = 0; i < m_buf.size(); i++) {
      fill(m_buf[i].begin(), m_buf[i].end(), d);
    }
  }


  void Chip::Init(const int samples, const int lines) {
    SetReadInterpolator(Interpolator::CubicConvolutionType);
    SetSize(samples, lines);
    SetValidRange();
    m_clipPolygon = NULL;
  }


  void Chip::SetSize(const int samples, const int lines) {
    if ( samples <= 0.0 || lines <= 0.0 ) {
      QString msg;
      msg += "Unable to set chip size to [";
      msg += toString(samples) + ", ";
      msg += toString(lines) + "]. Samples and lines must be greater than zero.";
      throw IException(IException::User, msg, _FILEINFO_);
    }
    m_chipSamples = samples;
    m_chipLines = lines;
    m_buf.clear();
    m_buf.resize(lines);
    for (int i = 0; i < lines; i++) {
      m_buf[i].resize(samples);
    }
    m_affine.Identity();
    m_tackSample = ((samples - 1) / 2) + 1;
    m_tackLine = ((lines - 1) / 2) + 1;
  }


  bool Chip::IsInsideChip(double sample, double line) {
    double minSamp = m_cubeTackSample - ((m_chipSamples - 1) / 2);
    double maxSamp = m_cubeTackSample + ((m_chipSamples - 1) / 2);

    double minLine = m_cubeTackLine - ((m_chipLines - 1) / 2);
    double maxLine = m_cubeTackLine + ((m_chipLines - 1) / 2);

    if ( sample < minSamp || sample > maxSamp ) return false;
    if ( line < minLine || line > maxLine ) return false;
    return true;
  }


  void Chip::TackCube(const double cubeSample, const double cubeLine) {
    m_cubeTackSample = cubeSample;
    m_cubeTackLine = cubeLine;
    m_affine.Identity();
    m_affine.Translate(m_cubeTackSample, m_cubeTackLine);
  }


  void Chip::Load(Cube &cube, const double rotation, const double scale, const int band) {
    // Initialize our affine transform
    m_affine.Identity();

    // We want an affine which translates from chip to cube. Note that we want to give adjusted
    // chip coordinates such that (0,0) is at the chip tack point and maps to the cube tack point.
    m_affine.Scale(scale);
    m_affine.Rotate(rotation);
    m_affine.Translate(m_cubeTackSample, m_cubeTackLine);

    // Now go read the data from the cube into the chip
    Read(cube, band);

    // Store off the cube address in case someone wants to match this chip
    m_filename = cube.fileName();
  }


  void Chip::Load(Cube &cube, const Affine &affine, const bool &keepPoly, const int band) {

    //  Set the tackpoint center to the cube location
    SetTransform(affine);
    SetChipPosition(TackSample(), TackLine());

    //  Remove the clipping polygon if requested
    if (!keepPoly) {
      delete m_clipPolygon;
      m_clipPolygon = 0;
    }

    // Now go read the data from the cube into the chip
    Read(cube, band);

    // Store off the cube address in case someone wants to match this chip
    m_filename = cube.fileName();
  }


  void Chip::Load(Cube &cube, Chip &match, Cube &matchChipCube, const double scale, const int band)
  {
    // See if the match cube has a camera or projection
    Camera *matchCam = NULL;
    TProjection *matchProj = NULL;
    try {
      matchCam = matchChipCube.camera();
    }
    catch (IException &error1) {
      try {
        matchProj = (TProjection *) matchChipCube.projection();
      }
      catch (IException &error2) {
        QString msg = "Can not geom chip. ";
        msg += "Match chip cube [" + matchChipCube.fileName();
        msg += "] is not a camera or map projection";

        IException fullError(IException::User, msg, _FILEINFO_);
        fullError.append(error1);
        fullError.append(error2);

        throw fullError;
      }
    }

    // See if the cube we are loading has a camera/projection
    Camera *cam = NULL;
    Projection *proj = NULL;
    try {
      cam = cube.camera();
    }
    catch (IException &error1) {
      try {
        proj = cube.projection();
      }
      catch (IException &error2) {
        QString msg = "Can not geom chip. ";
        msg += "Chip cube [" + cube.fileName();
        msg += "] is not a camera or map projection";

        IException fullError(IException::User, msg, _FILEINFO_);
        fullError.append(error1);
        fullError.append(error2);

        throw fullError;
      }
    }

    // Ok we can attempt to create an affine transformation that maps our chip to the match chip.
    // We will need a set of at least 3 control points so we can fit the affine transform.
    // We will try to find 4 points, one from each corner of the chip.
    vector<double> x(4), y(4);
    vector<double> xp(4), yp(4);

    // Choose these control points by beginning at each corner and moving inward in the chip
    // until an acceptable point is found
    // i = 0, start at upper left corner  (1, 1)
    // i = 1, start at lower left corner  (1, Lines()-1)
    // i = 2, start at upper right corner (Samples()-1, 1)
    // i = 3, start at lower right corner (Samples()-1, Lines()-1)
    for (int i = 0; i < (int) xp.size(); i++) {
      // define initial values for starting/ending sample/line for each index
      int startSamp = 1;
      int startLine = 1;
      int endSamp = Samples() - 1;
      int endLine = Lines() - 1;

      bool pointfound = false;
      while (!pointfound) {
        // start and end may cross (see MovePoints())
        // if we move outside chip, break out of loop
        if (startSamp < 1 || startSamp > Samples() - 1 ||
            endSamp   < 1 || endSamp   > Samples() - 1 ||
            startLine < 1 || startLine > Lines() - 1   ||
            endLine   < 1 || endLine   > Lines() - 1) {
          // unable to find acceptable control point from this corner
          // erase point and go to the next corner
          x.erase(x.begin() + i);
          y.erase(y.begin() + i);
          xp.erase(xp.begin() + i);
          yp.erase(yp.begin() + i);
          i--;
          break;
        }
        int chipSamp, chipLine;
        if (i < 2) {
          chipSamp = startSamp;
        }
        else {
          chipSamp = endSamp;
        }
        if (i % 2 == 0) {
          chipLine = startLine;
        }
        else {
          chipLine = endLine;
        }
        // Determine the offset from the tack point in our chip to one of the four corners.
        int sampOffset = chipSamp - TackSample();
        int lineOffset = chipLine - TackLine();

        // Use this offset to compute a chip position in the match chip.
        double matchChipSamp = match.TackSample() + sampOffset;
        double matchChipLine = match.TackLine() + lineOffset;

        // Now get the lat/lon at that chip position.
        match.SetChipPosition(matchChipSamp, matchChipLine);
        double lat, lon;
        if (matchCam != NULL) {
          matchCam->SetImage(match.CubeSample(), match.CubeLine());
          if (!matchCam->HasSurfaceIntersection() ) {
            vector<int> newlocation = MovePoints(startSamp, startLine, endSamp, endLine);
            startSamp = newlocation[0];
            startLine = newlocation[1];
            endSamp = newlocation[2];
            endLine = newlocation[3];
            continue;
          }
          lat = matchCam->UniversalLatitude();
          lon = matchCam->UniversalLongitude();
        }
        else {
          matchProj->SetWorld(match.CubeSample(), match.CubeLine() );
          if (!matchProj->IsGood() ) {
            vector<int> newlocation = MovePoints(startSamp, startLine, endSamp, endLine);
            startSamp = newlocation[0];
            startLine = newlocation[1];
            endSamp = newlocation[2];
            endLine = newlocation[3];
            continue;
          }
          lat = matchProj->UniversalLatitude();
          lon = matchProj->UniversalLongitude();
        }

        // Now use that lat/lon to find a line/sample in our chip
        double line, samp;
        if (cam != NULL) {
          cam->SetUniversalGround(lat, lon);
          if (!cam->HasSurfaceIntersection() ) {
            vector<int> newlocation = MovePoints(startSamp, startLine, endSamp, endLine);
            startSamp = newlocation[0];
            startLine = newlocation[1];
            endSamp = newlocation[2];
            endLine = newlocation[3];
            continue;
          }
          samp = cam->Sample();    // getting negative sample?!?!?!
          line = cam->Line();
        }
        else {
          proj->SetUniversalGround(lat, lon);
          if (!proj->IsGood()) {
            vector<int> newlocation = MovePoints(startSamp, startLine, endSamp, endLine);
            startSamp = newlocation[0];
            startLine = newlocation[1];
            endSamp = newlocation[2];
            endLine = newlocation[3];
            continue;
          }
          samp = proj->WorldX();
          line = proj->WorldY();
        }

        //     if (line < 1 || line > cube.lineCount()) continue;
        //     if (samp < 1 || samp > cube.sampleCount()) continue;

        // Ok save this control point
        pointfound = true;
        x[i] = sampOffset;
        y[i] = lineOffset;
        xp[i] = samp;
        yp[i] = line;

        // If we get 3 points on the same line, affine transform will fail.
        // Choose a one degree default tolerance for linearity check method.
        double tol = 1.0;
        // If we have already removed a point, use a stricter tolerance of 2 degrees.
        if (xp.size() == 3) {
          tol = 2.0;
        }
        if (i > 1) {
          if ( PointsColinear(xp[0], yp[0], xp[1], yp[1], xp[i], yp[i], tol) ) {
            // try to find a point further along that is not colinear
            pointfound = false;
            vector<int> newlocation = MovePoints(startSamp, startLine, endSamp, endLine);
            startSamp = newlocation[0];
            startLine = newlocation[1];
            endSamp = newlocation[2];
            endLine = newlocation[3];
            continue;
          }
        }
      }
    }

    if (xp.size() < 3) {
      QString msg = "Cannot find enough points to perform Affine transformation. ";
      msg += "Unable to load chip from [" + cube.fileName();
      msg += "] to match chip from [" + matchChipCube.fileName() + "].";
      throw IException(IException::User, msg, _FILEINFO_);
    }

    // Now take our control points and create the affine map
    m_affine.Solve(&x[0], &y[0], &xp[0], &yp[0], (int)x.size());

    //  TLS  8/3/06  Apply scale
    m_affine.Scale(scale);

    // Finally we need to make the affine map the tack point to the requested cube sample/line
    m_affine.Compute(0.0, 0.0);
    double cubeSampleOffset = m_cubeTackSample - m_affine.xp();
    double cubeLineOffset = m_cubeTackLine - m_affine.yp();
    m_affine.Translate(cubeSampleOffset, cubeLineOffset);

    // Now go read the data from the cube into the chip
    Read(cube, band);

    // Store off the cube address in case someone wants to match
    // this chip
    m_filename = cube.fileName();
  }


  bool Chip::PointsColinear(const double x0, const double y0, const double x1, const double y1,
                            const double x2, const double y2, const double tol) {
    // check angles at each point of the triangle composed of the 3 points
    //  if any angle is near 0 or 180 degrees, then the points are almost colinear

    // we have the following property:
    // sin(theta) = |v x w|/(|v|*|w|) where
    //     v=(vx,vy) and w=(wx,wy) are the vectors that define the angle theta
    //     |v| is the magnitude (norm) of the vector. In 2D, this is |v| = sqrt(vx^2 + vy^2)
    //     v x w is the cross product of the vectors. In 2D, this is v x w = vx*wy-vy*wx
    // See equations (5) and (6) at http://mathworld.wolfram.com/CrossProduct.html


    // first find the vectors that define the angles at each point
    // For example, if we shift the point P0 to the origin,
    //     the vectors defining the angle at P0
    //     are v01 = (x1-x0, y1-y0) and v02 = (x2-x0, y2-y0)
    // Note: v10 = -v01 and |v x w| = |w x v|
    // so we only need 3 vectors and the order we use these doesn't matter
    vector<double> v01, v12, v20;
    v01.push_back(x1 - x0);
    v01.push_back(y1 - y0);
    v12.push_back(x2 - x1);
    v12.push_back(y2 - y1);
    v20.push_back(x0 - x2);
    v20.push_back(y0 - y2);

    // sin(angle at P0) = |v01 x v02|/(|v01|*|v02|) =
    //      |v01x*v02y-v01y*v02x|/(sqrt(v01x^2+v01y^2)*sqrt(v01x^2+v02y^2))
    double sinP0 = fabs(v01[0] * v20[1] - v01[1] * v20[0]) /
            sqrt((pow(v01[0], 2) + pow(v01[1], 2)) * (pow(v12[0], 2) + pow(v12[1], 2)));
    // sin(angle at P1)
    double sinP1 = fabs(v12[0] * v20[1] - v12[1] * v20[0]) /
            sqrt((pow(v12[0], 2) + pow(v12[1], 2)) * (pow(v20[0], 2) + pow(v20[1], 2)));
    // sin(angle at P2)
    double sinP2 = fabs(v20[0] * v01[1] - v20[1] * v01[0]) /
            sqrt((pow(v20[0], 2) + pow(v20[1], 2)) * (pow(v01[0], 2) + pow(v01[1], 2)));

    // We will seek angles with sine near 0 (thus a multiple of 180 degrees or pi radians)
    // We will use a tolerance of tol degrees (tol*pi/180 radians)
    // Compare the smallest sine value to the sine of tol,
    // if it is less, then the angle is less than tol degrees or
    // greater than 180-tol degrees, so points are almost colinear
    double minSinValue = min(sinP0, min(sinP1, sinP2));
    if ( minSinValue < sin(tol * PI / 180) ) {
      return true;
    }
    else {
      return false;
    }
  }


  vector<int> Chip::MovePoints(const int startSamp, const int startLine,
                               const int endSamp, const int endLine) {
    vector<int> newlocations(4);
    int sinc = (endSamp - startSamp) / 4;
    // Ensures that the inc can cause start and end to cross
    if (sinc < 1) {
      sinc = 1;
    }
    int linc = (endLine - startLine) / 3;
    // Ensures that the inc can cause start and end to cross
    if (linc < 1) {
      linc = 1;
    }
    newlocations[0] = startSamp + sinc;
    newlocations[1] = startLine + linc;
    newlocations[2] = endSamp - sinc;
    newlocations[3] = endLine - linc;
    return newlocations;
  }

  void Chip::SetChipPosition(const double sample, const double line) {
    m_chipSample = sample;
    m_chipLine = line;
    m_affine.Compute(sample - TackSample(), line - TackLine());
    m_cubeSample = m_affine.xp();
    m_cubeLine = m_affine.yp();
  }


  void Chip::SetCubePosition(const double sample, const double line) {
    m_cubeSample = sample;
    m_cubeLine = line;
    m_affine.ComputeInverse(sample, line);
    m_chipSample = m_affine.x() + TackSample();
    m_chipLine = m_affine.y() + TackLine();
  }


  void Chip::SetValidRange(const double minimum, const double maximum) {
    if (minimum >= maximum) {
      QString msg = "Unable to set valid chip range to [" + toString(minimum);
      msg += ", " + toString(maximum) + "]. First parameter must be smaller than the second.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    m_validMinimum = minimum;
    m_validMaximum = maximum;
  }


  /* bool Chip::IsValid(int sample, int line) {
     double value = (*this)(sample,line);
     if (value < m_validMinimum) return false;
     if (value > m_validMaximum) return false;
     return true;
   }*/


  bool Chip::IsValid(double percentage) {
    int validCount = 0;
    for (int samp = 1; samp <= Samples(); samp++) {
      for (int line = 1; line <= Lines(); line++) {
        if (IsValid(samp, line)) validCount++;
      }
    }
    double validPercentage = 100.0 * (double) validCount /
                             (double)(Samples() * Lines());
    if (validPercentage < percentage) return false;
    return true;
  }


  Chip Chip::Extract(int samples, int lines, int samp, int line) {
    if ( samples > Samples() || lines > Lines() ) {
      QString msg = "Cannot extract sub-chip of size [" + toString(samples);
      msg += ", " + toString(lines) + "] from chip of size [" + toString(Samples());
      msg += ", " + toString(Lines()) + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    Chip chipped(samples, lines);
    for (int oline = 1; oline <= lines; oline++) {
      for (int osamp = 1; osamp <= samples; osamp++) {
        int thisSamp = samp + (osamp - chipped.TackSample());
        int thisLine = line + (oline - chipped.TackLine());
        if ((thisSamp < 1) ||
            (thisLine < 1) ||
            (thisSamp > Samples()) ||
            (thisLine > Lines()) ) {
          chipped.SetValue(osamp, oline, Isis::Null);
        }
        else {
          chipped.SetValue(osamp, oline, GetValue(thisSamp, thisLine));
        }
      }
    }

    chipped.m_affine = m_affine;
    chipped.m_validMinimum = m_validMinimum;
    chipped.m_validMaximum = m_validMaximum;
    chipped.m_tackSample = chipped.TackSample() + TackSample() - samp;
    chipped.m_tackLine = chipped.TackLine() + TackLine() - line;

    return chipped;
  }

  void Chip::Extract(int samp, int line, Chip &chipped) {
    int samples = chipped.Samples();
    int lines = chipped.Lines();
    //chipped.Init(samples, lines);
    chipped.m_tackSample = ((samples - 1) / 2) + 1;
    chipped.m_tackLine = ((lines - 1) / 2) + 1;

    for (int oline = 1; oline <= lines; oline++) {
      for (int osamp = 1; osamp <= samples; osamp++) {
        int thisSamp = samp + (osamp - chipped.TackSample());
        int thisLine = line + (oline - chipped.TackLine());
        if ((thisSamp < 1) ||
            (thisLine < 1) ||
            (thisSamp > Samples()) ||
            (thisLine > Lines()) ) {
          chipped.SetValue(osamp, oline, Isis::Null);
        }
        else {
          chipped.SetValue(osamp, oline, GetValue(thisSamp, thisLine));
        }
      }
    }

    chipped.m_affine = m_affine;
    chipped.m_validMinimum = m_validMinimum;
    chipped.m_validMaximum = m_validMaximum;
    chipped.m_tackSample = chipped.TackSample() + TackSample() - samp;
    chipped.m_tackLine = chipped.TackLine() + TackLine() - line;

    return;
  }


  void Chip::Extract(Chip &chipped, Affine &affine) {
    // Create an interpolator and portal for interpolation
    Interpolator interp(Interpolator::BiLinearType);
    Portal port(interp.Samples(), interp.Lines(), Isis::Double,
                interp.HotSample(), interp.HotLine());

    int samples = chipped.Samples();
    int lines = chipped.Lines();

    for (int oline = 1; oline <= lines; oline++) {
      int relativeLine = oline - chipped.TackLine();
      for (int osamp = 1; osamp <= samples; osamp++) {
        int relativeSamp = osamp - chipped.TackSample();
        affine.Compute(relativeSamp, relativeLine);
        double xp = affine.xp() + TackSample();
        double yp = affine.yp() + TackLine();
        port.SetPosition(xp, yp, 1);
        for (int i = 0; i < port.size(); i++) {
          int csamp = port.Sample(i);
          int cline = port.Line(i);
          if ((csamp < 1) ||
              (cline < 1) ||
              (csamp > Samples()) ||
              (cline > Lines()) ) {
            port[i] = Isis::Null;
          }
          else {
            port[i] = GetValue(csamp, cline);
          }
        }
        chipped.SetValue(osamp, oline, interp.Interpolate(xp, yp, port.DoubleBuffer()));
      }
    }

    chipped.m_validMinimum = m_validMinimum;
    chipped.m_validMaximum = m_validMaximum;
    chipped.m_filename = m_filename;

    // Make necessary adjustments to remaining chip elements. Note that this matrix multiply
    // acheives a completed transform of two Affine matrices.
    // No translations are required - only update tack points.
    chipped.m_affine = Affine(TNT::matmult(affine.Forward(), m_affine.Forward()));

    affine.Compute(0.0, 0.0);
    chipped.m_cubeTackSample = m_cubeTackSample + affine.xp();
    chipped.m_cubeTackLine = m_cubeTackLine + affine.yp();

    chipped.m_chipSample = chipped.TackSample();
    chipped.m_chipLine   = chipped.TackLine();
    chipped.m_cubeSample = chipped.m_cubeTackSample;
    chipped.m_cubeLine   = chipped.m_cubeTackLine;

    return;
  }


  Isis::Statistics *Chip::Statistics() {
    Isis::Statistics *stats = new Isis::Statistics();

    stats->SetValidRange(m_validMinimum, m_validMaximum);

    for (int i = 0; i < m_chipSamples; i++) {
      stats->AddData(&m_buf[i][0], m_chipLines);
    }

    return stats;
  }


  void Chip::Read(Cube &cube, const int band) {
    // Create an interpolator and portal for geoming
    Interpolator interp(m_readInterpolator);
    Portal port(interp.Samples(), interp.Lines(), cube.pixelType(),
                interp.HotSample(), interp.HotLine());
    // Loop through the pixels in the chip and geom them
    for (int line = 1; line <= Lines(); line++) {
      for (int samp = 1; samp <= Samples(); samp++) {
        SetChipPosition((double)samp, (double)line);
        if ((CubeSample() < 0.5) ||
            (CubeLine() < 0.5) ||
            (CubeSample() > cube.sampleCount() + 0.5) ||
            (CubeLine() > cube.lineCount() + 0.5)) {

          m_buf[line-1][samp-1] = Isis::NULL8;
        }
        else if (m_clipPolygon == NULL) {
          port.SetPosition(CubeSample(), CubeLine(), band);
          cube.read(port);
          m_buf[line-1][samp-1] =
            interp.Interpolate(CubeSample(), CubeLine(), port.DoubleBuffer());
        }
        else {
          geos::geom::Point *pnt = globalFactory.createPoint(
                                     geos::geom::Coordinate(CubeSample(), CubeLine()));
          if (pnt->within(m_clipPolygon)) {
            port.SetPosition(CubeSample(), CubeLine(), band);
            cube.read(port);
            m_buf[line-1][samp-1] =
              interp.Interpolate(CubeSample(), CubeLine(), port.DoubleBuffer());
          }
          else {
            m_buf[line-1][samp-1] = Isis::NULL8;
          }
          delete pnt;
        }
      }
    }
  }


  void Chip::Write(const QString &filename) {
    Cube c;
    c.setDimensions(Samples(), Lines(), 1);
    c.create(filename);
    LineManager line(c);
    for (int i = 1; i <= Lines(); i++) {
      line.SetLine(i);
      for (int j = 1; j <= Samples(); j++) {
        line[j-1] = GetValue(j, i);
      }
      c.write(line);
    }
    c.close();
  }


  void Chip::SetClipPolygon(const geos::geom::MultiPolygon &clipPolygon) {
    if (m_clipPolygon != NULL) delete m_clipPolygon;
    m_clipPolygon = PolygonTools::CopyMultiPolygon(clipPolygon);
  }


  Chip &Chip::operator=(const Chip &other) {
    m_chipSamples = other.m_chipSamples;
    m_chipLines = other.m_chipLines;
    m_buf = other.m_buf;
    m_tackSample = other.m_tackSample;
    m_tackLine = other.m_tackLine;

    m_cubeTackSample = other.m_cubeTackSample;
    m_cubeTackLine = other.m_cubeTackLine;

    m_validMinimum = other.m_validMinimum;
    m_validMaximum = other.m_validMaximum;

    m_chipSample = other.m_chipSample;
    m_chipLine = other.m_chipLine;
    m_cubeSample = other.m_cubeSample;
    m_cubeLine = other.m_cubeLine;

    // Free allocated memory.
    if (m_clipPolygon) {
      delete m_clipPolygon;
      m_clipPolygon = NULL;
    }

    if (other.m_clipPolygon) {
      m_clipPolygon = PolygonTools::MakeMultiPolygon(
          other.m_clipPolygon->clone());
    }

    m_affine = other.m_affine;
    m_readInterpolator = other.m_readInterpolator;
    m_filename = other.m_filename;

    return *this;
  }
} // end namespace isis