src/geom/Point.cpp

   1 /**********************************************************************
   2  *
   3  * GEOS - Geometry Engine Open Source
   4  * http://geos.osgeo.org
   5  *
   6  * Copyright (C) 2011 Sandro Santilli <strk@keybit.net>
   7  * Copyright (C) 2001-2002 Vivid Solutions Inc.
   8  * Copyright (C) 2005 2006 Refractions Research Inc.
   9  *
  10  * This is free software; you can redistribute and/or modify it under
  11  * the terms of the GNU Lesser General Public Licence as published
  12  * by the Free Software Foundation.
  13  * See the COPYING file for more information.
  14  *
  15  **********************************************************************
  16  *
  17  * Last port: geom/Point.java r320 (JTS-1.12)
  18  *
  19  **********************************************************************/
  20
  21 #include <geos/util/UnsupportedOperationException.h>
  22 #include <geos/util/IllegalArgumentException.h>
  23 #include <geos/geom/Coordinate.h>
  24 #include <geos/geom/Point.h>
  25 #include <geos/geom/CoordinateSequence.h>
  26 #include <geos/geom/CoordinateSequenceFilter.h>
  27 #include <geos/geom/CoordinateFilter.h>
  28 #include <geos/geom/GeometryFilter.h>
  29 #include <geos/geom/GeometryComponentFilter.h>
  30 #include <geos/geom/CoordinateSequenceFactory.h>
  31 #include <geos/geom/Dimension.h>
  32 #include <geos/geom/Envelope.h>
  33 #include <geos/geom/GeometryCollection.h>
  34 #include <geos/geom/GeometryFactory.h>
  35
  36 #include <string>
  37 #include <memory>
  38
  39 using namespace std;
  40
  41 namespace geos {
  42 namespace geom { // geos::geom
  43
  44
  45 /*protected*/
  46 Point::Point(CoordinateSequence *newCoords, const GeometryFactory *factory)
  47         :
  48         Geometry(factory),
  49         coordinates(newCoords)
  50 {
  51         if (coordinates.get()==NULL) {
  52                 coordinates.reset(factory->getCoordinateSequenceFactory()->create(NULL));
  53                 return;
  54         }
  55         if (coordinates->getSize() != 1)
  56         {
  57                 throw util::IllegalArgumentException("Point coordinate list must contain a single element");
  58         }
  59 }
  60
  61 /*protected*/
  62 Point::Point(const Point &p)
  63         :
  64         Geometry(p),
  65         coordinates(p.coordinates->clone())
  66 {
  67 }
  68
  69 CoordinateSequence *
  70 Point::getCoordinates() const
  71 {
  72         return coordinates->clone();
  73 }
  74
  75 size_t
  76 Point::getNumPoints() const
  77 {
  78         return isEmpty() ? 0 : 1;
  79 }
  80
  81 bool
  82 Point::isEmpty() const
  83 {
  84         return coordinates->isEmpty();
  85 }
  86
  87 bool
  88 Point::isSimple() const
  89 {
  90         return true;
  91 }
  92
  93 Dimension::DimensionType
  94 Point::getDimension() const
  95 {
  96         return Dimension::P; // point
  97 }
  98
  99 int
 100 Point::getCoordinateDimension() const
 101 {
 102     return (int) coordinates->getDimension();
 103 }
 104
 105 int
 106 Point::getBoundaryDimension() const
 107 {
 108         return Dimension::False;
 109 }
 110
 111 double
 112 Point::getX() const
 113 {
 114         if (isEmpty()) {
 115                 throw util::UnsupportedOperationException("getX called on empty Point\n");
 116         }
 117         return getCoordinate()->x;
 118 }
 119
 120 double
 121 Point::getY() const
 122 {
 123         if (isEmpty()) {
 124                 throw util::UnsupportedOperationException("getY called on empty Point\n");
 125         }
 126         return getCoordinate()->y;
 127 }
 128
 129 const Coordinate *
 130 Point::getCoordinate() const
 131 {
 132         return coordinates->getSize()!=0 ? &(coordinates->getAt(0)) : NULL;
 133 }
 134
 135 string
 136 Point::getGeometryType() const
 137 {
 138         return "Point";
 139 }
 140
 141 Geometry *
 142 Point::getBoundary() const
 143 {
 144         return getFactory()->createGeometryCollection(NULL);
 145 }
 146
 147 Envelope::AutoPtr
 148 Point::computeEnvelopeInternal() const
 149 {
 150         if (isEmpty()) {
 151                 return Envelope::AutoPtr(new Envelope());
 152         }
 153
 154         return Envelope::AutoPtr(new Envelope(getCoordinate()->x,
 155                         getCoordinate()->x, getCoordinate()->y,
 156                         getCoordinate()->y));
 157 }
 158
 159 void
 160 Point::apply_ro(CoordinateFilter *filter) const
 161 {
 162         if (isEmpty()) {return;}
 163         filter->filter_ro(getCoordinate());
 164 }
 165
 166 void
 167 Point::apply_rw(const CoordinateFilter *filter)
 168 {
 169         if (isEmpty()) {return;}
 170         Coordinate newcoord = coordinates->getAt(0);
 171         filter->filter_rw(&newcoord);
 172         coordinates->setAt(newcoord, 0);
 173 }
 174
 175 void
 176 Point::apply_rw(GeometryFilter *filter)
 177 {
 178         filter->filter_rw(this);
 179 }
 180
 181 void
 182 Point::apply_ro(GeometryFilter *filter) const
 183 {
 184         filter->filter_ro(this);
 185 }
 186
 187 void
 188 Point::apply_rw(GeometryComponentFilter *filter)
 189 {
 190         filter->filter_rw(this);
 191 }
 192
 193 void
 194 Point::apply_ro(GeometryComponentFilter *filter) const
 195 {
 196         filter->filter_ro(this);
 197 }
 198
 199 void
 200 Point::apply_rw(CoordinateSequenceFilter& filter)
 201 {
 202         if (isEmpty()) return;
 203         filter.filter_rw(*coordinates, 0);
 204         if (filter.isGeometryChanged()) geometryChanged();
 205 }
 206
 207 void
 208 Point::apply_ro(CoordinateSequenceFilter& filter) const
 209 {
 210         if (isEmpty()) return;
 211         filter.filter_ro(*coordinates, 0);
 212         //if (filter.isGeometryChanged()) geometryChanged();
 213 }
 214
 215 bool
 216 Point::equalsExact(const Geometry *other, double tolerance) const
 217 {
 218         if (!isEquivalentClass(other)) {
 219                 return false;
 220         }
 221
 222         // assume the isEquivalentClass would return false
 223         // if other is not a point
 224         assert(dynamic_cast<const Point*>(other));
 225
 226         if ( isEmpty() ) return other->isEmpty();
 227         else if ( other->isEmpty() ) return false;
 228
 229         const Coordinate* this_coord = getCoordinate();
 230         const Coordinate* other_coord = other->getCoordinate();
 231
 232         // assume the isEmpty checks above worked :)
 233         assert(this_coord && other_coord);
 234
 235         return equal(*this_coord, *other_coord, tolerance);
 236 }
 237
 238 int
 239 Point::compareToSameClass(const Geometry *g) const
 240 {
 241         const Point* p = dynamic_cast<const Point*>(g);
 242         return getCoordinate()->compareTo(*(p->getCoordinate()));
 243 }
 244
 245 Point::~Point()
 246 {
 247         //delete coordinates;
 248 }
 249
 250 GeometryTypeId
 251 Point::getGeometryTypeId() const
 252 {
 253         return GEOS_POINT;
 254 }
 255
 256 /*public*/
 257 const CoordinateSequence*
 258 Point::getCoordinatesRO() const
 259 {
 260         return coordinates.get();
 261 }
 262
 263 } // namespace geos::geom
 264 } // namesapce geos