Chip.cpp

Go to the documentation of this file.

#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include "Camera.h"
#include "Chip.h"
#include "Cube.h"
#include "IException.h"
#include "Interpolator.h"
#include "LineManager.h"
#include "PolygonTools.h"
#include "Portal.h"
#include "Projection.h"
#include "TProjection.h"
#include "Statistics.h"
#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) {
    p_chipSamples = other.p_chipSamples;
    p_chipLines = other.p_chipLines;
    p_buf = other.p_buf;
    p_tackSample = other.p_tackSample;
    p_tackLine = other.p_tackLine;

    p_cubeTackSample = other.p_cubeTackSample;
    p_cubeTackLine = other.p_cubeTackLine;

    p_validMinimum = other.p_validMinimum;
    p_validMaximum = other.p_validMaximum;

    p_chipSample = other.p_chipSample;
    p_chipLine = other.p_chipLine;
    p_cubeSample = other.p_cubeSample;
    p_cubeLine = other.p_cubeLine;

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

    p_affine = other.p_affine;
    p_readInterpolator = other.p_readInterpolator;
    p_filename = other.p_filename;
  }

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


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


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

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


  void Chip::SetSize(const int samples, const int lines) {
    if(samples <= 0.0 || lines <= 0.0) {
      string msg = "Unable to set chip size to [" + IString(samples);
      msg += ", " + IString(lines) + "].  Samples and lines must be greater than zero.";
      throw IException(IException::User, msg, _FILEINFO_);
    }
    p_chipSamples = samples;
    p_chipLines = lines;
    p_buf.clear();
    p_buf.resize(lines);
    for(int i = 0; i < lines; i++) {
      p_buf[i].resize(samples);
    }
    p_affine.Identity();
    p_tackSample = ((samples - 1) / 2) + 1;
    p_tackLine = ((lines - 1) / 2) + 1;
  }

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

    double minLine = p_cubeTackLine - ((p_chipLines - 1) / 2);
    double maxLine = p_cubeTackLine + ((p_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) {
    p_cubeTackSample = cubeSample;
    p_cubeTackLine = cubeLine;
    p_affine.Identity();
    p_affine.Translate(p_cubeTackSample, p_cubeTackLine);
  }


  void Chip::Load(Cube &cube, const double rotation, const double scale,
                  const int band) {
    // Initialize our affine transform
    p_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.
    p_affine.Scale(scale);
    p_affine.Rotate(rotation);
    p_affine.Translate(p_cubeTackSample, p_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
    p_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 p_clipPolygon;
      p_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
    p_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
    p_affine.Solve(&x[0], &y[0], &xp[0], &yp[0], (int)x.size());

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

    // Finally we need to make the affine map the tack point
    // to the requested cube sample/line
    p_affine.Compute(0.0, 0.0);
    double cubeSampleOffset = p_cubeTackSample - p_affine.xp();
    double cubeLineOffset = p_cubeTackLine - p_affine.yp();
    p_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
    p_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) {
    p_chipSample = sample;
    p_chipLine = line;
    p_affine.Compute(sample - TackSample(), line - TackLine());
    p_cubeSample = p_affine.xp();
    p_cubeLine = p_affine.yp();
  }


  void Chip::SetCubePosition(const double sample, const double line) {
    p_cubeSample = sample;
    p_cubeLine = line;
    p_affine.ComputeInverse(sample, line);
    p_chipSample = p_affine.x() + TackSample();
    p_chipLine = p_affine.y() + TackLine();
  }


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

    p_validMinimum = minimum;
    p_validMaximum = maximum;
  }


  /* bool Chip::IsValid(int sample, int line) {
     double value = (*this)(sample,line);
     if (value < p_validMinimum) return false;
     if (value > p_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()) {
      string msg = "Cannot extract sub-chip of size [" + IString(samples);
      msg += ", " + IString(lines) + "] from chip of size [" + IString(Samples());
      msg += ", " + IString(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.p_affine = p_affine;
    chipped.p_validMinimum = p_validMinimum;
    chipped.p_validMaximum = p_validMaximum;
    chipped.p_tackSample = chipped.TackSample() + TackSample() - samp;
    chipped.p_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.p_tackSample = ((samples - 1) / 2) + 1;
    chipped.p_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.p_affine = p_affine;
    chipped.p_validMinimum = p_validMinimum;
    chipped.p_validMaximum = p_validMaximum;
    chipped.p_tackSample = chipped.TackSample() + TackSample() - samp;
    chipped.p_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.p_validMinimum = p_validMinimum;
    chipped.p_validMaximum = p_validMaximum;
    chipped.p_filename = p_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.p_affine = Affine(TNT::matmult(affine.Forward(), p_affine.Forward()));

    affine.Compute(0.0, 0.0);
    chipped.p_cubeTackSample = p_cubeTackSample + affine.xp();
    chipped.p_cubeTackLine = p_cubeTackLine + affine.yp();

    chipped.p_chipSample = chipped.TackSample();
    chipped.p_chipLine   = chipped.TackLine();
    chipped.p_cubeSample = chipped.p_cubeTackSample;
    chipped.p_cubeLine   = chipped.p_cubeTackLine;

    return;
  }


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

    stats->SetValidRange(p_validMinimum, p_validMaximum);

    for(int i = 0; i < p_chipSamples; i++) {
      stats->AddData(&p_buf[i][0], p_chipLines);
    }

    return stats;
  }


  void Chip::Read(Cube &cube, const int band) {
    // Create an interpolator and portal for geoming
    Interpolator interp(p_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)) {
          p_buf[line-1][samp-1] = Isis::NULL8;
        }
        else if(p_clipPolygon == NULL) {
          port.SetPosition(CubeSample(), CubeLine(), band);
          cube.read(port);
          p_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(p_clipPolygon)) {
            port.SetPosition(CubeSample(), CubeLine(), band);
            cube.read(port);
            p_buf[line-1][samp-1] =
              interp.Interpolate(CubeSample(), CubeLine(), port.DoubleBuffer());
          }
          else {
            p_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(p_clipPolygon != NULL) delete p_clipPolygon;
    p_clipPolygon = PolygonTools::CopyMultiPolygon(clipPolygon);
  }

  Chip &Chip::operator=(const Chip &other) {
    p_chipSamples = other.p_chipSamples;
    p_chipLines = other.p_chipLines;
    p_buf = other.p_buf;
    p_tackSample = other.p_tackSample;
    p_tackLine = other.p_tackLine;

    p_cubeTackSample = other.p_cubeTackSample;
    p_cubeTackLine = other.p_cubeTackLine;

    p_validMinimum = other.p_validMinimum;
    p_validMaximum = other.p_validMaximum;

    p_chipSample = other.p_chipSample;
    p_chipLine = other.p_chipLine;
    p_cubeSample = other.p_cubeSample;
    p_cubeLine = other.p_cubeLine;

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

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

    p_affine = other.p_affine;
    p_readInterpolator = other.p_readInterpolator;
    p_filename = other.p_filename;

    return *this;
  }
} // end namespace isis