src/geom/GeometryCollection.cpp

   1 /**********************************************************************
   2  *
   3  * GEOS - Geometry Engine Open Source
   4  * http://geos.osgeo.org
   5  *
   6  * Copyright (C) 2001-2002 Vivid Solutions Inc.
   7  * Copyright (C) 2005 2006 Refractions Research Inc.
   8  *
   9  * This is free software; you can redistribute and/or modify it under
  10  * the terms of the GNU Lesser General Public Licence as published
  11  * by the Free Software Foundation.
  12  * See the COPYING file for more information.
  13  *
  14  **********************************************************************
  15  *
  16  * Last port: geom/GeometryCollection.java rev. 1.41
  17  *
  18  **********************************************************************/
  19
  20 #include <geos/geom/GeometryCollection.h>
  21 #include <geos/algorithm/CGAlgorithms.h>
  22 #include <geos/util/IllegalArgumentException.h>
  23 #include <geos/geom/CoordinateSequence.h>
  24 #include <geos/geom/CoordinateSequenceFilter.h>
  25 #include <geos/geom/CoordinateArraySequenceFactory.h>
  26 #include <geos/geom/Dimension.h>
  27 #include <geos/geom/GeometryFilter.h>
  28 #include <geos/geom/GeometryComponentFilter.h>
  29 #include <geos/geom/Envelope.h>
  30
  31 #ifndef GEOS_INLINE
  32 # include <geos/geom/GeometryCollection.inl>
  33 #endif
  34
  35 #include <algorithm>
  36 #include <vector>
  37 #include <memory>
  38
  39 using namespace std;
  40
  41 namespace geos {
  42 namespace geom { // geos::geom
  43
  44 /*protected*/
  45 GeometryCollection::GeometryCollection(const GeometryCollection &gc)
  46         :
  47         Geometry(gc)
  48 {
  49         size_t ngeoms=gc.geometries->size();
  50
  51         geometries=new vector<Geometry *>(ngeoms);
  52         for(size_t i=0; i<ngeoms; ++i)
  53         {
  54                 (*geometries)[i]=(*gc.geometries)[i]->clone();
  55     // Drop SRID from inner geoms
  56                 (*geometries)[i]->setSRID(0);
  57         }
  58 }
  59
  60 /*protected*/
  61 GeometryCollection::GeometryCollection(vector<Geometry *> *newGeoms, const GeometryFactory *factory):
  62         Geometry(factory)
  63 {
  64         if (newGeoms==NULL) {
  65                 geometries=new vector<Geometry *>();
  66                 return;
  67         }
  68         if (hasNullElements(newGeoms)) {
  69                 throw  util::IllegalArgumentException("geometries must not contain null elements\n");
  70                 return;
  71         }
  72         geometries=newGeoms;
  73
  74   // Drop SRID from inner geoms
  75         size_t ngeoms=geometries->size();
  76         for(size_t i=0; i<ngeoms; ++i)
  77         {
  78                 (*geometries)[i]->setSRID(0);
  79         }
  80 }
  81
  82 /*
  83  * Collects all coordinates of all subgeometries into a CoordinateSequence.
  84  *
  85  * Returns a newly the collected coordinates
  86  *
  87  */
  88 CoordinateSequence *
  89 GeometryCollection::getCoordinates() const
  90 {
  91         vector<Coordinate> *coordinates = new vector<Coordinate>(getNumPoints());
  92
  93         int k = -1;
  94         for (size_t i=0; i<geometries->size(); ++i) {
  95                 CoordinateSequence* childCoordinates=(*geometries)[i]->getCoordinates();
  96                 size_t npts=childCoordinates->getSize();
  97                 for (size_t j=0; j<npts; ++j) {
  98                         k++;
  99                         (*coordinates)[k] = childCoordinates->getAt(j);
 100                 }
 101                 delete childCoordinates;
 102         }
 103         return CoordinateArraySequenceFactory::instance()->create(coordinates);
 104 }
 105
 106 bool
 107 GeometryCollection::isEmpty() const
 108 {
 109         for (size_t i=0; i<geometries->size(); ++i) {
 110                 if (!(*geometries)[i]->isEmpty()) {
 111                         return false;
 112                 }
 113         }
 114         return true;
 115 }
 116
 117 Dimension::DimensionType
 118 GeometryCollection::getDimension() const
 119 {
 120         Dimension::DimensionType dimension=Dimension::False;
 121         for (size_t i=0, n=geometries->size(); i<n; ++i)
 122         {
 123                 dimension=max(dimension,(*geometries)[i]->getDimension());
 124         }
 125         return dimension;
 126 }
 127
 128 int
 129 GeometryCollection::getBoundaryDimension() const
 130 {
 131         int dimension=Dimension::False;
 132         for(size_t i=0; i<geometries->size(); ++i) {
 133                 dimension=max(dimension,(*geometries)[i]->getBoundaryDimension());
 134         }
 135         return dimension;
 136 }
 137
 138 int
 139 GeometryCollection::getCoordinateDimension() const
 140 {
 141         int dimension=2;
 142
 143         for (size_t i=0, n=geometries->size(); i<n; ++i)
 144         {
 145                 dimension=max(dimension,(*geometries)[i]->getCoordinateDimension());
 146         }
 147         return dimension;
 148 }
 149
 150 size_t
 151 GeometryCollection::getNumGeometries() const
 152 {
 153         return geometries->size();
 154 }
 155
 156 const Geometry*
 157 GeometryCollection::getGeometryN(size_t n) const
 158 {
 159         return (*geometries)[n];
 160 }
 161
 162 size_t
 163 GeometryCollection::getNumPoints() const
 164 {
 165         size_t numPoints = 0;
 166         for (size_t i=0, n=geometries->size(); i<n; ++i)
 167         {
 168                 numPoints +=(*geometries)[i]->getNumPoints();
 169         }
 170         return numPoints;
 171 }
 172
 173 string
 174 GeometryCollection::getGeometryType() const
 175 {
 176         return "GeometryCollection";
 177 }
 178
 179 Geometry*
 180 GeometryCollection::getBoundary() const
 181 {
 182         throw util::IllegalArgumentException("Operation not supported by GeometryCollection\n");
 183 }
 184
 185 bool
 186 GeometryCollection::equalsExact(const Geometry *other, double tolerance) const
 187 {
 188         if (!isEquivalentClass(other)) return false;
 189
 190         const GeometryCollection* otherCollection=dynamic_cast<const GeometryCollection *>(other);
 191         if ( ! otherCollection ) return false;
 192
 193         if (geometries->size()!=otherCollection->geometries->size()) {
 194                 return false;
 195         }
 196         for (size_t i=0; i<geometries->size(); ++i) {
 197                 if (!((*geometries)[i]->equalsExact((*(otherCollection->geometries))[i],tolerance)))
 198                 {
 199                         return false;
 200                 }
 201         }
 202         return true;
 203 }
 204
 205 void
 206 GeometryCollection::apply_rw(const CoordinateFilter *filter)
 207 {
 208         for (size_t i=0; i<geometries->size(); ++i)
 209         {
 210                 (*geometries)[i]->apply_rw(filter);
 211         }
 212 }
 213
 214 void
 215 GeometryCollection::apply_ro(CoordinateFilter *filter) const
 216 {
 217         for (size_t i=0; i<geometries->size(); ++i)
 218         {
 219                 (*geometries)[i]->apply_ro(filter);
 220         }
 221 }
 222
 223 void
 224 GeometryCollection::apply_ro(GeometryFilter *filter) const
 225 {
 226         filter->filter_ro(this);
 227         for(size_t i=0; i<geometries->size(); ++i)
 228         {
 229                 (*geometries)[i]->apply_ro(filter);
 230         }
 231 }
 232
 233 void
 234 GeometryCollection::apply_rw(GeometryFilter *filter)
 235 {
 236         filter->filter_rw(this);
 237         for(size_t i=0; i<geometries->size(); ++i)
 238         {
 239                 (*geometries)[i]->apply_rw(filter);
 240         }
 241 }
 242
 243 void
 244 GeometryCollection::normalize()
 245 {
 246         for (size_t i=0; i<geometries->size(); ++i) {
 247                 (*geometries)[i]->normalize();
 248         }
 249         sort(geometries->begin(), geometries->end(), GeometryGreaterThen());
 250 }
 251
 252 Envelope::AutoPtr
 253 GeometryCollection::computeEnvelopeInternal() const
 254 {
 255         Envelope::AutoPtr envelope(new Envelope());
 256         for (size_t i=0; i<geometries->size(); i++) {
 257                 const Envelope *env=(*geometries)[i]->getEnvelopeInternal();
 258                 envelope->expandToInclude(env);
 259         }
 260         return envelope;
 261 }
 262
 263 int
 264 GeometryCollection::compareToSameClass(const Geometry *g) const
 265 {
 266   const GeometryCollection* gc = dynamic_cast<const GeometryCollection*>(g);
 267         return compare(*geometries, *(gc->geometries));
 268 }
 269
 270 const Coordinate*
 271 GeometryCollection::getCoordinate() const
 272 {
 273         // should use auto_ptr here or return NULL or throw an exception !
 274         //      --strk;
 275         if (isEmpty()) return new Coordinate();
 276         return (*geometries)[0]->getCoordinate();
 277 }
 278
 279 /**
 280  * @return the area of this collection
 281  */
 282 double
 283 GeometryCollection::getArea() const
 284 {
 285         double area=0.0;
 286         for(size_t i=0; i<geometries->size(); ++i)
 287         {
 288                 area+=(*geometries)[i]->getArea();
 289         }
 290         return area;
 291 }
 292
 293 /**
 294  * @return the total length of this collection
 295  */
 296 double
 297 GeometryCollection::getLength() const
 298 {
 299         double sum=0.0;
 300         for(size_t i=0; i<geometries->size(); ++i)
 301         {
 302                 sum+=(*geometries)[i]->getLength();
 303         }
 304         return sum;
 305 }
 306
 307 void
 308 GeometryCollection::apply_rw(GeometryComponentFilter *filter)
 309 {
 310         filter->filter_rw(this);
 311         for(size_t i=0; i<geometries->size(); ++i)
 312         {
 313                 (*geometries)[i]->apply_rw(filter);
 314         }
 315 }
 316
 317 void
 318 GeometryCollection::apply_ro(GeometryComponentFilter *filter) const
 319 {
 320         filter->filter_ro(this);
 321         for(size_t i=0; i<geometries->size(); ++i)
 322         {
 323                 (*geometries)[i]->apply_ro(filter);
 324         }
 325 }
 326
 327 void
 328 GeometryCollection::apply_rw(CoordinateSequenceFilter& filter)
 329 {
 330         size_t ngeoms = geometries->size();
 331         if (ngeoms == 0 ) return;
 332         for (size_t i = 0; i < ngeoms; ++i)
 333         {
 334                 (*geometries)[i]->apply_rw(filter);
 335                 if (filter.isDone()) break;
 336         }
 337         if (filter.isGeometryChanged()) geometryChanged();
 338 }
 339
 340 void
 341 GeometryCollection::apply_ro(CoordinateSequenceFilter& filter) const
 342 {
 343         size_t ngeoms = geometries->size();
 344         if (ngeoms == 0 ) return;
 345         for (size_t i = 0; i < ngeoms; ++i)
 346         {
 347                 (*geometries)[i]->apply_ro(filter);
 348                 if (filter.isDone()) break;
 349         }
 350
 351         assert(!filter.isGeometryChanged()); // read-only filter...
 352         //if (filter.isGeometryChanged()) geometryChanged();
 353 }
 354
 355 GeometryCollection::~GeometryCollection()
 356 {
 357         for(size_t i=0; i<geometries->size(); ++i)
 358         {
 359                 delete (*geometries)[i];
 360         }
 361         delete geometries;
 362 }
 363
 364 GeometryTypeId
 365 GeometryCollection::getGeometryTypeId() const
 366 {
 367         return GEOS_GEOMETRYCOLLECTION;
 368 }
 369
 370 } // namespace geos::geom
 371 } // namespace geos