ImageOverlap.cpp

#include <iostream>
#include <sstream>

#include "geos/io/WKBReader.h"
#include "geos/io/WKBWriter.h"

#include "PolygonTools.h"
#include "IException.h"
#include "FileName.h"
#include "ImageOverlap.h"
#include "IString.h"

namespace Isis {

  ImageOverlap::ImageOverlap() {
    Init();
  }


  ImageOverlap::ImageOverlap(QString serialNumber,
                             geos::geom::MultiPolygon &polygon) {
    Init();
    SetPolygon(polygon);
    Add(serialNumber);
  }

  
  ImageOverlap::ImageOverlap(std::istream &inputStream) {
    geos::io::WKBReader geosReader;

    std::string fileData;
    getline(inputStream, fileData);

    QString serialNums = fileData.c_str();
    foreach (QString serialNum, serialNums.split(",")) {
      Add(serialNum);
    }

    // now get the multipolygon on the next line
    getline(inputStream, fileData);

    std::stringstream multiPolygon;
    multiPolygon << fileData;
    multiPolygon.seekg(0, std::ios::beg);

    p_polygon = PolygonTools::MakeMultiPolygon(
        geosReader.readHEX(multiPolygon));
  }


  ImageOverlap::~ImageOverlap() {
    delete p_polygon;
  };


  void ImageOverlap::Init() {
    p_serialNumbers.clear();
    p_polygon = NULL;
  }


  void ImageOverlap::SetPolygon(const geos::geom::MultiPolygon &polygon) {
    if(p_polygon != NULL) {
      delete p_polygon;
      p_polygon = NULL;
    }

    p_polygon = PolygonTools::CopyMultiPolygon(polygon);
  }


  void ImageOverlap::SetPolygon(const geos::geom::MultiPolygon *polygon) {
    if(p_polygon != NULL) {
      delete p_polygon;
      p_polygon = NULL;
    }

    p_polygon = PolygonTools::CopyMultiPolygon(polygon);
  }


  void ImageOverlap::Write(std::ostream &outputStream) {
    
    geos::io::WKBWriter geosWriter;

    QString serialNums;

    for(unsigned int sn = 0; sn < p_serialNumbers.size(); sn++) {
      if(sn != 0) {
        serialNums += ",";
      }

      serialNums += p_serialNumbers[sn];
    }

    serialNums += "\n";

    outputStream << serialNums;

    geosWriter.writeHEX(*p_polygon, outputStream);
  }
  
  
  void ImageOverlap::Add(QString &sn) {
    for(unsigned int s = 0; s < p_serialNumbers.size(); ++s) {
      if(sn == p_serialNumbers[s]) {
        QString msg = "Duplicate SN added to [" +
            QString::fromStdString(p_polygon->toString()) + "]";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
    }

    p_serialNumbers.push_back(sn);
    return;
  }


  double ImageOverlap::Area() {
    return p_polygon->getArea();
  }

  
  bool ImageOverlap::HasAnySameSerialNumber(ImageOverlap &other) const {
    for(int thisSn = 0; thisSn < this->Size(); ++thisSn) {
      for(int otherSn = 0; otherSn < other.Size(); ++otherSn) {
        if(p_serialNumbers[thisSn] == other.p_serialNumbers[otherSn]) {
          return true;
        }
      }
    }
    return false;
  }


  bool ImageOverlap::HasSerialNumber(QString &sn) const {
    for(int thisSn = 0; thisSn < Size(); ++thisSn) {
      if(p_serialNumbers[thisSn] == sn) {
        return true;
      }
    }
    return false;
  }
}