ImageOverlapSet.cpp

#include <string>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <cmath>

#include "geos/operation/distance/DistanceOp.h"
#include "geos/util/IllegalArgumentException.h"
#include "geos/geom/Point.h"
#include "geos/opOverlay.h"
#include "IException.h"
#include "Cube.h"
#include "SerialNumberList.h"
#include "PolygonTools.h"
#include "ImagePolygon.h"
#include "FileName.h"
#include "ImageOverlapSet.h"
#include "Progress.h"

using namespace std;

namespace Isis {
  ImageOverlapSet::ImageOverlapSet(bool continueOnError) {
    p_continueAfterError = continueOnError;
    p_writtenSoFar = 0;
    p_calculatedSoFar = -1;
    p_threadedCalculate = false;
    p_snlist = NULL;
  }


  ImageOverlapSet::~ImageOverlapSet() {
    for(int i = 0; i < Size(); i++) {
      if(p_lonLatOverlaps[i]) delete p_lonLatOverlaps[i];
    }

    // This class should not retain ownership of p_snlist,
    //   so this member should not need destroyed.
  };


  void ImageOverlapSet::FindImageOverlaps(SerialNumberList &sns) {
    // Create an ImageOverlap for each image boundary
    for(int i = 0; i < sns.Size(); i++) {
      // Open the cube
      Cube cube;
      try {
        cube.open(sns.FileName(i));
      }
      catch(IException &error) {
        QString msg = "Unable to open cube for serial number [";
        msg += sns.SerialNumber(i) + "] filename [" + sns.FileName(i) + "]";

        HandleError(error, &sns, msg);
      }

      // Read the bounding polygon
      ImagePolygon *poly = new ImagePolygon();
      cube.read(*poly);
      cube.close();

      // Create a ImageOverlap with the serial number and the bounding
      // polygon and save it
      geos::geom::MultiPolygon *tmp = PolygonTools::MakeMultiPolygon(
          poly->Polys());

      delete poly;
      poly = NULL;

      geos::geom::MultiPolygon *mp = NULL;

      // If footprint is invalid throw exception
      if(!tmp->isValid()) {
        delete tmp;
        tmp = NULL;
        IString msg = "The image [" + sns.FileName(sns.SerialNumber(i)) +
                      "] has an invalid footprint";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }

      try {
        mp = PolygonTools::Despike(tmp);
      }
      catch(IException &e) {
        if(tmp->isValid()) {
          mp = tmp;
          tmp = NULL;
        }
        else {
          delete tmp;
          tmp = NULL;
          HandleError(e, &sns);
          continue;
        }
      }

      p_lonLatOverlaps.push_back(CreateNewOverlap(sns.SerialNumber(i), mp));

      if(mp) {
        delete mp;
        mp = NULL;
      }

      if(tmp) {
        delete tmp;
        tmp = NULL;
      }
    }

    // Despikes the polygons from the Serial Numbers prior to overlap
    //   determination
    DespikeLonLatOverlaps();

    if(p_threadedCalculate) {
      // Call FindAllOverlaps in other thread
      start();
    }
    else {
      // Determine the overlap between each boundary polygon
      FindAllOverlaps(&sns);
    }
  }

  void ImageOverlapSet::FindImageOverlaps(SerialNumberList &boundaries, QString outputFile) {
    // Do a common sense programmer check, this should be empty before we start
    if(!p_lonLatOverlaps.empty()) {
      string msg = "FindImageOverlaps(SerialNumberList&,QString) may not be called on " \
                   "an ImageOverlapSet which already contains overlaps.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    p_writtenSoFar = 0;
    p_calculatedSoFar = -1;

    p_snlist = &boundaries;

    // This will enable using mutexes and spawning threads where necessary.
    p_threadedCalculate = true;

    FindImageOverlaps(boundaries);

    // While our exit condition is not true, call WriteImageOverlaps with the filename. The
    //   WriteImageOverlaps call will block if it is waiting on calculations.
    while(p_calculatedSoFar != p_lonLatOverlaps.size()) {
      WriteImageOverlaps(outputFile);
    }

    // flush the output if we're still not done writing
    if(p_calculatedSoFar != p_writtenSoFar)
      WriteImageOverlaps(outputFile);

    // Wait for the calculation thread to actually exit, this has more than likely already occurred.
    wait();

    // re-initialize object to original state
    p_lonLatOverlaps.clear();
    p_writtenSoFar = 0;
    p_calculatedSoFar = -1;
    p_threadedCalculate = false;
    p_snlist = NULL;
  }


  void ImageOverlapSet::FindImageOverlaps(std::vector<QString> sns,
                                          std::vector<geos::geom::MultiPolygon *> polygons) {

    if(sns.size() != polygons.size()) {
      string message = "Invalid argument sizes. Sizes must match.";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }

    // Create one ImageOverlap for each image sn
    for(unsigned int i = 0; i < sns.size(); ++i) {
      p_lonLatOverlaps.push_back(CreateNewOverlap(sns[i], polygons[i]));
    }

    // Despikes the polygons from the Serial Numbers prior to overlap determination
    DespikeLonLatOverlaps();

    // Determine the overlap between each boundary polygon
    FindAllOverlaps();
  }

  void ImageOverlapSet::ReadImageOverlaps(const QString &filename) {
    IString file = FileName(filename).expanded();

    try {
      // Let's get an istream pointed at our file
      std::ifstream inStream;
      inStream.open(file.c_str(), fstream::in | fstream::binary);

      while(!inStream.eof()) {
        p_lonLatOverlaps.push_back(new ImageOverlap(inStream));
      }

      inStream.close();
    }
    catch(IException &e) {
      IString msg = "The overlap file [" + filename + "] does not contain a "
                    "valid list of image overlaps";
      throw IException(e, IException::Unknown, msg, _FILEINFO_);
    }
    catch(...) {
      IString msg = "The overlap file [" + filename + "] does not contain a "
                    "valid list of image overlaps";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }
  }


  bool ImageOverlapSet::SetPolygon(geos::geom::Geometry *poly, int position, ImageOverlap *sncopy,  bool insert) {
    bool success = false;
    geos::geom::MultiPolygon *multiPolygon = PolygonTools::MakeMultiPolygon(poly);
    delete poly;
    poly = NULL;

    if(!multiPolygon->isValid() || (multiPolygon->getArea() < 1.0e-10 && !multiPolygon->isEmpty())) {
      delete multiPolygon;
      multiPolygon = Isis::globalFactory.createMultiPolygon();
    }

    if(position > p_lonLatOverlaps.size()) {
      position = p_lonLatOverlaps.size();
    }

    try {
      if(!multiPolygon->isEmpty()) {
        geos::geom::MultiPolygon *despiked = PolygonTools::Despike(multiPolygon);
        delete multiPolygon;
        multiPolygon = despiked;
      }
    }
    catch(IException &) {
    }

    if(multiPolygon->isValid() && (multiPolygon->isEmpty() || multiPolygon->getArea() > 1.0e-14)) {
      if(!insert) {
        p_lonLatOverlaps.at(position)->SetPolygon(multiPolygon);

        if(sncopy) {
          AddSerialNumbers(p_lonLatOverlaps.at(position), sncopy);
        }
      }
      else if(!multiPolygon->isEmpty()) {
        ImageOverlap *imageOverlap = new ImageOverlap();
        imageOverlap->SetPolygon(multiPolygon);
        delete multiPolygon;
        multiPolygon = NULL;

        if(sncopy) {
          AddSerialNumbers(imageOverlap, sncopy);
        }

        // Insert could cause a reallocate of the overlap list, so lock it with
        //   the writing code so that we don't conflict
        QMutexLocker locker(&p_lonLatOverlapsMutex);
        p_lonLatOverlaps.insert(p_lonLatOverlaps.begin() + position, imageOverlap);
      }

      success = true;
    }

    return success;
  }


  void ImageOverlapSet::WriteImageOverlaps(const QString &filename) {
    IString file = FileName(filename).expanded();
    bool failed = false;
    if(p_threadedCalculate) p_calculatePolygonMutex.lock();

    if(p_lonLatOverlaps.size() == 0) {
      IString msg = "No overlaps were found.";
      throw IException(IException::User, msg, _FILEINFO_);
    }

    try {
      // Let's get an ostream pointed at our file
      std::ofstream outStream;

      if(p_writtenSoFar == 0) {
        outStream.open(file.c_str(), fstream::out | fstream::trunc | fstream::binary);
      }
      else {
        outStream.open(file.c_str(), fstream::out | fstream::app | fstream::binary);
      }

      failed |= outStream.fail();

      static bool overlapWritten = false;
      for(int overlap = p_writtenSoFar; !failed && overlap <= p_calculatedSoFar; overlap++) {
        // Let's not try anything during a possible reallocate
        QMutexLocker locker(&p_lonLatOverlapsMutex);

        if(overlap < p_lonLatOverlaps.size() && p_lonLatOverlaps[overlap]) {
          if(!p_lonLatOverlaps[overlap]->Polygon()->isEmpty()) {
            if(overlapWritten) {
              outStream << std::endl;
            }

            p_lonLatOverlaps[overlap]->Write(outStream);
            overlapWritten = true;
          }

          delete p_lonLatOverlaps[overlap];
          p_lonLatOverlaps[overlap] = NULL;
          p_writtenSoFar ++;
        }
      }

      failed |= outStream.fail();
      outStream.close();

      failed |= outStream.fail();
    }
    catch(...) {
      failed = true;
    }

    if(p_calculatedSoFar == p_lonLatOverlaps.size()) {
      if(p_threadedCalculate) p_calculatePolygonMutex.unlock();
    }

    if(failed) {
      IString msg = "Unable to write the image overlap list to [" + filename + "]";
      throw IException(IException::Io, msg, _FILEINFO_);
    }
  }


  void ImageOverlapSet::FindAllOverlaps(SerialNumberList *snlist) {
    if(p_lonLatOverlaps.size() <= 1) return;

    Progress p;
    p.SetText("Calculating Image Overlaps");
    p.SetMaximumSteps(p_lonLatOverlaps.size() - 1);
    p.CheckStatus();

    geos::geom::MultiPolygon *emptyPolygon = Isis::globalFactory.createMultiPolygon();

    // Compare each polygon with all of the others
    for(int outside = 0; outside < p_lonLatOverlaps.size() - 1; ++outside) {
      p_calculatedSoFar = outside - 1;

      // unblock the writing process after every 10 polygons if we need to write
      if(p_calculatedSoFar % 10 == 0 && (!snlist || p_lonLatOverlaps.size() > snlist->Size())) {
        if(p_threadedCalculate) p_calculatePolygonMutex.unlock();
      }

      // Intersect the current polygon (from the outside loop) with all others
      // below it
      for(int inside = outside + 1; inside < p_lonLatOverlaps.size(); ++inside) {
        try {
          if(p_lonLatOverlaps.at(outside)->HasAnySameSerialNumber(*p_lonLatOverlaps.at(inside))) continue;

          // We know these are valid because they were filtered early on
          const geos::geom::MultiPolygon *poly1 = p_lonLatOverlaps.at(outside)->Polygon();
          const geos::geom::MultiPolygon *poly2 = p_lonLatOverlaps.at(inside)->Polygon();

          // Check to see if the two poygons are equivalent.
          // If they are, then we can get rid of one of them
          if(PolygonTools::Equal(poly1, poly2)) {
            AddSerialNumbers(p_lonLatOverlaps[outside], p_lonLatOverlaps[inside]);
            p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);
            inside --;
            continue;
          }

          // We can get empty polygons in our list sometimes; try to avoid extra processing
          if(poly2->isEmpty() || poly2->getArea() < 1.0e-14) {
            p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);
            inside --;
            continue;
          }

          geos::geom::Geometry *intersected = NULL;
          try {
            intersected = PolygonTools::Intersect(poly1, poly2);
          }
          catch(IException &e) {
            intersected = NULL;
            QString error = "Intersection of overlaps failed.";

            // We never want to double seed, so we must delete one or both
            //   of these polygons because they more than likely have an intersection
            //   that we simply can't calculate.
            double outsideArea = poly1->getArea();
            double insideArea = poly2->getArea();
            double areaRatio = std::min(outsideArea, insideArea) / std::max(outsideArea, insideArea);

            // If one of the polygons is < 1% the area of the other, then only throw out the small one to
            //   try to minimize the impact of this failure.
            if(areaRatio < 0.1) {
              if(poly1->getArea() > poly2->getArea()) {
                error += " The first polygon will be removed.";
                HandleError(e, snlist, error, inside, outside);
                p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);
                inside --;
              }
              else {
                error += " The second polygon will be removed.";
                HandleError(e, snlist, error, inside, outside);
                p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + outside);
                inside = outside;
              }
            }
            else {
              error += " Both polygons will be removed to prevent the possibility of double counted areas.";
              HandleError(e, snlist, error, inside, outside);
              p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);
              p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + outside);
              inside = outside;
            }

            continue;
          }

          if(intersected->isEmpty() || intersected->getArea() < 1.0e-14) {
            delete intersected;
            intersected = NULL;
            continue;
          }

          // We are only interested in overlaps that result in polygon(s)
          // and not any that are lines or points, so create a new multipolygon
          // with only the polygons of overlap
          geos::geom::MultiPolygon *overlap = NULL;
          try {
            overlap = PolygonTools::Despike(intersected);

            delete intersected;
            intersected = NULL;
          }
          catch(IException &e) {
            if(!intersected->isValid()) {
              delete intersected;
              intersected = NULL;

              HandleError(e, snlist, "", inside, outside);
              continue;
            }
            else {
              overlap = PolygonTools::MakeMultiPolygon(intersected);

              delete intersected;
              intersected = NULL;
            }
          }
          catch(geos::util::GEOSException *exc) {
            delete intersected;
            intersected = NULL;
            HandleError(exc, snlist, "", inside, outside);
            continue;
          }

          if(!overlap->isValid()) {
            delete overlap;
            overlap = NULL;
            HandleError(snlist, "Intersection produced invalid overlap area", inside, outside);
            continue;
          }

          // is there really overlap?
          if(overlap->isEmpty() || overlap->getArea() < 1.0e-14) {
            delete overlap;
            overlap = NULL;
            continue;
          }

          // poly1 is completly inside poly2
          if(PolygonTools::Equal(poly1, overlap)) {
            geos::geom::Geometry *tmpGeom = NULL;
            try {
              tmpGeom = PolygonTools::Difference(poly2, poly1);
            }
            catch(IException &e) {
              HandleError(e, snlist, "Differencing overlap polygons failed. The first polygon will be removed.", inside, outside);

              // Delete outside polygon directly and reset outside loop
              //   - current outside is thrown out!
              p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + outside);
              inside = outside;

              continue;
            }

            SetPolygon(tmpGeom, inside);
            SetPolygon(overlap, outside, p_lonLatOverlaps[inside]);
          }

          // poly2 is completly inside poly1
          else if(PolygonTools::Equal(poly2, overlap)) {
            geos::geom::Geometry *tmpGeom = NULL;
            try {
              tmpGeom = PolygonTools::Difference(poly1, poly2);
            }
            catch(IException &e) {
              HandleError(e, snlist, "Differencing overlap polygons failed. The second polygon will be removed.", inside, outside);


              // Delete inside polygon directly and process next inside
              p_lonLatOverlaps.erase(p_lonLatOverlaps.begin() + inside);
              inside --;

              continue;
            }

            SetPolygon(tmpGeom, outside);
            SetPolygon(overlap, inside, p_lonLatOverlaps[outside]);
          }
          // There is partial overlap
          else {
            // Subtract overlap from poly1 and set poly1 to the result
            geos::geom::Geometry *tmpGeom = NULL;
            try {
              tmpGeom = PolygonTools::Difference(poly1, overlap);
            }
            catch(IException &e) {
              tmpGeom = NULL;
            }

            // If we failed to subtract overlap, try to subtract poly2 from poly1 and set poly1 to the result
            try {
              if(tmpGeom == NULL) {
                tmpGeom = PolygonTools::Difference(poly1, poly2);
              }
            }
            catch(IException &e) {
              tmpGeom = NULL;
              HandleError(e, snlist, "Differencing overlap polygons failed", inside, outside);
              continue;
            }

            if(!SetPolygon(tmpGeom, outside)) {
              SetPolygon(Isis::globalFactory.createMultiPolygon(), outside);
            }

            int oldSize = p_lonLatOverlaps.size();
            if(SetPolygon(overlap, inside + 1, p_lonLatOverlaps[outside], true)) {
              int newSize = p_lonLatOverlaps.size();
              int newSteps = newSize - oldSize;
              p.AddSteps(newSteps);

              if(newSize != oldSize) inside++;
            }
          } // End of partial overlap else
        }
        // Collections are illegal as intersection argument
        catch(IException &e) {
          HandleError(e, snlist, "Unable to find overlap.", inside, outside);
        }
        // Collections are illegal as intersection argument
        catch(geos::util::IllegalArgumentException *ill) {
          HandleError(NULL, snlist, "Unable to find overlap", inside, outside);
        }
        catch(geos::util::GEOSException *exc) {
          HandleError(exc, snlist, "Unable to find overlap", inside, outside);
        }
        catch(...) {
          HandleError(snlist, "Unknown Error: Unable to find overlap", inside, outside);
        }
      }

      p.CheckStatus();
    }

    p_calculatedSoFar = p_lonLatOverlaps.size();
    delete emptyPolygon;

    // Do not write empty overlap files
    if(snlist) {
      if(p_lonLatOverlaps.size() == snlist->Size()) {
        p_lonLatOverlaps.clear();
      }
    }

    // unblock the writing process
    p_calculatePolygonMutex.unlock();
  }


  void ImageOverlapSet::AddSerialNumbers(ImageOverlap *to, ImageOverlap *from) {
    for(int i = 0; i < from->Size(); i++) {
      QString s = (*from)[i];
      to->Add(s);
    }
  }


  ImageOverlap *ImageOverlapSet::CreateNewOverlap(QString serialNumber,
      geos::geom::MultiPolygon *latLonPolygon) {

    return new ImageOverlap(serialNumber, *latLonPolygon);
  }


  std::vector<ImageOverlap *> ImageOverlapSet::operator[](QString serialNumber) {
    vector<ImageOverlap *> matches;

    // Look at all the ImageOverlaps we have and return the ones that
    // have this sn
    for(int ov = 0; ov < p_lonLatOverlaps.size(); ++ov) {
      for(int sn = 0; sn < p_lonLatOverlaps[ov]->Size(); ++sn) {
        if((*p_lonLatOverlaps[ov])[sn] == serialNumber) {
          matches.push_back(p_lonLatOverlaps[ov]);
        }
      }
    }

    return matches;
  }

  void ImageOverlapSet::HandleError(IException &e, SerialNumberList *snlist, QString msg, int overlap1, int overlap2) {
    PvlGroup err("ImageOverlapError");

    if(overlap1 >= 0 && overlap1 < p_lonLatOverlaps.size()) {
      PvlKeyword serialNumbers("PolySerialNumbers");
      PvlKeyword filename("FileNames");
      PvlKeyword polygon("Polygon");

      for(int i = 0; i < p_lonLatOverlaps.at(overlap1)->Size(); i++) {
        serialNumbers += (*p_lonLatOverlaps.at(overlap1))[i];

        if(snlist != NULL) {
          filename += snlist->FileName((*p_lonLatOverlaps.at(overlap1))[i]);
        }
      }
      polygon += p_lonLatOverlaps.at(overlap1)->Polygon()->toString().c_str();

      err += serialNumbers;

      if(filename.size() != 0) {
        err += filename;
      }

      err += polygon;
    }

    if(overlap2 >= 0 && overlap1 < p_lonLatOverlaps.size() && overlap2 < p_lonLatOverlaps.size()) {
      PvlKeyword serialNumbers("PolySerialNumbers");
      PvlKeyword filename("FileNames");
      PvlKeyword polygon("Polygon");

      for(int i = 0; i < p_lonLatOverlaps.at(overlap2)->Size(); i++) {
        serialNumbers += (*p_lonLatOverlaps.at(overlap2))[i];

        if(snlist != NULL) {
          filename += snlist->FileName((*p_lonLatOverlaps.at(overlap2))[i]);
        }
      }
      polygon += p_lonLatOverlaps.at(overlap2)->Polygon()->toString().c_str();

      err += serialNumbers;

      if(filename.size() != 0) {
        err += filename;
      }

      err += polygon;
    }

    err += PvlKeyword("Error", e.what());

    if(!msg.isEmpty()) {
      err += PvlKeyword("Description", msg);
    }

    p_errorLog.push_back(err);

    if(!p_continueAfterError) throw;
  }

  void ImageOverlapSet::HandleError(geos::util::GEOSException *exc, SerialNumberList *snlist, QString msg, int overlap1, int overlap2) {
    PvlGroup err("ImageOverlapError");

    if(overlap1 >= 0 && overlap1 < p_lonLatOverlaps.size()) {
      PvlKeyword serialNumbers("PolySerialNumbers");
      PvlKeyword filename("FileNames");

      for(int i = 0; i < p_lonLatOverlaps.at(overlap1)->Size(); i++) {
        serialNumbers += (*p_lonLatOverlaps.at(overlap1))[i];

        if(snlist != NULL) {
          filename += snlist->FileName((*p_lonLatOverlaps.at(overlap1))[i]);
        }
      }

      err += serialNumbers;

      if(filename.size() != 0) {
        err += filename;
      }
    }

    if(overlap2 >= 0 && overlap1 < p_lonLatOverlaps.size() && overlap2 < p_lonLatOverlaps.size()) {
      PvlKeyword serialNumbers("PolySerialNumbers");
      PvlKeyword filename("FileNames");

      for(int i = 0; i < p_lonLatOverlaps.at(overlap2)->Size(); i++) {
        serialNumbers += (*p_lonLatOverlaps.at(overlap2))[i];

        if(snlist != NULL) {
          filename += snlist->FileName((*p_lonLatOverlaps.at(overlap2))[i]);
        }
      }

      err += serialNumbers;

      if(filename.size() != 0) {
        err += filename;
      }
    }

    err += PvlKeyword("Error", exc->what());

    if(!msg.isEmpty()) {
      err += PvlKeyword("Description", msg);
    }

    p_errorLog.push_back(err);

    delete exc;

    if(!p_continueAfterError) {
      throw IException(IException::Programmer,
                       err["Description"][0],
                       _FILEINFO_);
    }
  }


  void ImageOverlapSet::HandleError(SerialNumberList *snlist, QString msg, int overlap1, int overlap2) {
    PvlGroup err("ImageOverlapError");

    if(overlap1 >= 0 && overlap1 < p_lonLatOverlaps.size()) {
      PvlKeyword serialNumbers("PolySerialNumbers");
      PvlKeyword filename("FileNames");

      for(int i = 0; i < p_lonLatOverlaps.at(overlap1)->Size(); i++) {
        serialNumbers += (*p_lonLatOverlaps.at(overlap1))[i];

        if(snlist != NULL) {
          filename += snlist->FileName((*p_lonLatOverlaps.at(overlap1))[i]);
        }
      }

      err += serialNumbers;

      if(filename.size() != 0) {
        err += filename;
      }
    }

    if(overlap2 >= 0 && overlap1 < p_lonLatOverlaps.size() && overlap2 < p_lonLatOverlaps.size()) {
      PvlKeyword serialNumbers("PolySerialNumbers");
      PvlKeyword filename("FileNames");

      for(int i = 0; i < p_lonLatOverlaps.at(overlap2)->Size(); i++) {
        serialNumbers += (*p_lonLatOverlaps.at(overlap2))[i];

        if(snlist != NULL) {
          filename += snlist->FileName((*p_lonLatOverlaps.at(overlap2))[i]);
        }
      }

      err += serialNumbers;

      if(filename.size() != 0) {
        err += filename;
      }
    }

    err += PvlKeyword("Description", msg);

    p_errorLog.push_back(err);

    if(!p_continueAfterError) {
      throw IException(IException::Programmer,
                       err["Description"][0],
                       _FILEINFO_);
    }
  }


  void ImageOverlapSet::DespikeLonLatOverlaps() {
    for(int i = 0; i < Size(); i++) {
      try {
        p_lonLatOverlaps[i]->SetPolygon(
          PolygonTools::Despike(p_lonLatOverlaps[i]->Polygon()));
      }
      catch(IException &e) {
      }
    }
  }


}