GisTopology.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "GisTopology.h"
 
// std library
#include <cstdio>
 
// Qt library
#include <QByteArray>
#include <QCoreApplication>
#include <QString>
 
// geos library
#include <geos_c.h>
 
// other ISIS
#include "IException.h"
 
using namespace std;
 
namespace Isis {
 
  GisTopology *GisTopology::m_gisfactory = 0;
  
 
  GisTopology::GisTopology() : m_WKTreader(0), m_WKTwriter(0), 
                               m_WKBreader(0), m_WKBwriter(0) {
    geosInit();
    //  This ensures this singleton is shut down when the application exists,
    //  so the GEOS system can be shut down cleanly.
    qAddPostRoutine(dieAtExit);
  }
  
 
  GisTopology::~GisTopology() {
    if (m_WKTreader) {  
      GEOSWKTReader_destroy(m_WKTreader);   
      m_WKTreader = 0;
    }
  
    if (m_WKTwriter) {  
      GEOSWKTWriter_destroy(m_WKTwriter);   
      m_WKTwriter = 0;
    }
  
    if (m_WKBreader) {  
      GEOSWKBReader_destroy(m_WKBreader);   
      m_WKBreader = 0;
    }
  
    if (m_WKBwriter) {  
      GEOSWKBWriter_destroy(m_WKBwriter);   
      m_WKBwriter = 0;
    }
  
    geosFinish();
  }
  
 
  GisTopology *GisTopology::instance() { 
    if (!m_gisfactory) {
      m_gisfactory = new GisTopology();
    }
    return (m_gisfactory);
  }
  
 
  GEOSGeometry *GisTopology::geomFromWKB(const QString &wkb) {
  #if 0
    QByteArray wkb_data = wkb.toLatin1();
    const unsigned char *footy = reinterpret_cast<const unsigned char *> (wkb_data.data());
    GEOSGeometry *geom = GEOSWKBReader_readHEX(wkbReader(), footy, wkb.size()); 
  #else
    GEOSGeometry *geom = GEOSWKBReader_readHEX(wkbReader(),
                 reinterpret_cast<const unsigned char *> (wkb.toLatin1().data()),
                                               wkb.size());
  #endif
    if (!geom) {
      QString mess = "Unable convert the given WKB string [" + wkb + "] to a GEOSGeometry";
      throw IException(IException::Programmer, mess, _FILEINFO_);
  
    }
    return (geom);
  }
  
 
  GEOSGeometry *GisTopology::geomFromWKT(const QString &wkt) {
    QByteArray wkt_data = wkt.toLatin1();
    const char *footy = wkt_data.data();
    GEOSGeometry *geom = GEOSWKTReader_read(wktReader(), footy);
    if (!geom) {
      QString mess = "Unable convert the given WKT string [" + wkt + "] to a GEOSGeometry";
      throw IException(IException::Programmer, mess, _FILEINFO_);
  
    }
    return (geom);
  }
  
 
  GEOSGeometry *GisTopology::clone(const GEOSGeometry *geom) const {
    if (!geom) return (0);
    return (GEOSGeom_clone(geom));
  }
  
  
  const GEOSPreparedGeometry *GisTopology::preparedGeometry(const GEOSGeometry *geom) const {
    const GEOSPreparedGeometry *ppgeom = GEOSPrepare(geom);
    if (!ppgeom) {
      throw IException(IException::Programmer, 
                       "Unable convert the given GEOSGeometry to a GEOSPreparedGeometry",
                       _FILEINFO_);
  
    }
    return (ppgeom);
  }
  
 
  QString GisTopology::wkt(const GEOSGeometry *geom, 
                           const GisTopology::Disposition &disp) {
    char *wkt_h = GEOSWKTWriter_write(wktWriter(), geom);
    QString thegeom = QString::fromLatin1(reinterpret_cast<const char *> (wkt_h));
  
    if (disp == DestroyGeometry) { 
      destroy(geom); 
    }
    destroy(wkt_h);
  
    return (thegeom);
  }
  
 
  QString GisTopology::wkb(const GEOSGeometry *geom, 
                           const GisTopology::Disposition &disp) {
    size_t length;
    unsigned char *wkt_h = GEOSWKBWriter_writeHEX(wkbWriter(), geom, &length);
    QString thegeom = QString::fromLatin1(reinterpret_cast<const char *> (wkt_h), length);
  
    if (disp == DestroyGeometry) { 
      destroy(geom); 
    }
    destroy(wkt_h);
  
    return (thegeom);
  }
  
  
  void GisTopology::destroy(GEOSGeometry *geom) const {
    if (geom) { 
      GEOSGeom_destroy(geom); 
    }
    return;
  }
  
 
  void GisTopology::destroy(const GEOSGeometry *geom) const {
    if (geom) { 
      destroy(const_cast<GEOSGeometry *> (geom)); 
    }
    return;
  }
  
 
  void GisTopology::destroy(const GEOSPreparedGeometry *geom) const {
    if (geom) { 
      GEOSPreparedGeom_destroy(geom); 
    }
    return;
  }
  
 
  void GisTopology::destroy(GEOSCoordSequence *sequence) const {
    if (sequence) { 
      GEOSCoordSeq_destroy(sequence); 
    }
    return;
  }
  
  
  void GisTopology::destroy(const char *geos_text) const {
    if (geos_text) {
      GEOSFree(const_cast<char *> (geos_text));
    }
    return;
  }
  
 
  void GisTopology::destroy(const unsigned char *geos_text) const {
    if (geos_text) {
      GEOSFree(const_cast<unsigned char *> (geos_text));
    }
    return;
  }
  
 
  void GisTopology::geosInit() {
    initGEOS(GisTopology::notice, GisTopology::error);
  }
  
 
  void GisTopology::geosFinish() {
    finishGEOS();
  }
  
 
  void GisTopology::notice(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    char buffer[1024];
    vsprintf(buffer, fmt, ap);
    va_end(ap);
    throw IException(IException::Programmer, buffer, _FILEINFO_);
  }
  
 
  void GisTopology::error(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    char buffer[1024];
    vsprintf(buffer, fmt, ap);
    va_end(ap);
    throw IException(IException::Programmer, buffer, _FILEINFO_);
  }
  
 
  GEOSWKTReader *GisTopology::wktReader() {
    if (!m_WKTreader) {
      m_WKTreader = GEOSWKTReader_create();
    }
    return (m_WKTreader);
  }
  
 
  GEOSWKTWriter *GisTopology::wktWriter() {
    if (!m_WKTwriter) {
      m_WKTwriter = GEOSWKTWriter_create();
    }
    return (m_WKTwriter);
  }
  
 
  GEOSWKBReader *GisTopology::wkbReader() {
    if (!m_WKBreader) {
      m_WKBreader = GEOSWKBReader_create();
    }
    return (m_WKBreader);
  }
  
 
  GEOSWKBWriter *GisTopology::wkbWriter() {
    if (!m_WKBwriter) {
      m_WKBwriter = GEOSWKBWriter_create();
    }
    return (m_WKBwriter);
  }
 
  void GisTopology::dieAtExit() {
    delete  m_gisfactory;
    m_gisfactory = 0;
    return;
  }
 
} // namespace Isis