ImageOverlap.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#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).release());
  }
 
 
  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;
  }
}