GEOS 3.15.0dev
Envelope.h
1/**********************************************************************
2 *
3 * GEOS - Geometry Engine Open Source
4 * http://geos.osgeo.org
5 *
6 * Copyright (C) 2006 Refractions Research Inc.
7 *
8 * This is free software; you can redistribute and/or modify it under
9 * the terms of the GNU Lesser General Public Licence as published
10 * by the Free Software Foundation.
11 * See the COPYING file for more information.
12 *
13 **********************************************************************
14 *
15 * Last port: geom/Envelope.java rev 1.46 (JTS-1.10)
16 *
17 **********************************************************************/
18
19#pragma once
20
21
22#include <geos/export.h>
23#include <geos/geom/Coordinate.h>
24
25#include <string>
26#include <vector>
27#include <ostream> // for operator<<
28#include <memory>
29#include <cassert>
30#include <algorithm>
31
32namespace geos {
33namespace geom { // geos::geom
34
35class Envelope;
36
38GEOS_DLL std::ostream& operator<< (std::ostream& os, const Envelope& o);
39
40class Coordinate;
41
59class GEOS_DLL Envelope {
60
61public:
62
63 friend std::ostream& operator<< (std::ostream& os, const Envelope& o);
64
65 typedef std::unique_ptr<Envelope> Ptr;
66
71 : minx(DoubleNotANumber)
72 , maxx(DoubleNotANumber)
73 , miny(DoubleNotANumber)
74 , maxy(DoubleNotANumber)
75 {};
76
85 Envelope(double x1, double x2, double y1, double y2)
86 {
87 init(x1, x2, y1, y2);
88 }
89
96 Envelope(const CoordinateXY& p1, const CoordinateXY& p2)
97 {
98 init(p1, p2);
99 }
100
106 explicit Envelope(const CoordinateXY& p)
107 : minx(p.x)
108 , maxx(p.x)
109 , miny(p.y)
110 , maxy(p.y)
111 {
112 }
113
118 explicit Envelope(const std::string& str);
119
129 static bool intersects(const CoordinateXY& p1, const CoordinateXY& p2,
130 const CoordinateXY& q);
131
143 static bool intersects(
144 const CoordinateXY& p1, const CoordinateXY& p2,
145 const CoordinateXY& q1, const CoordinateXY& q2)
146 {
147 double minq = std::min(q1.x, q2.x);
148 double maxq = std::max(q1.x, q2.x);
149 double minp = std::min(p1.x, p2.x);
150 double maxp = std::max(p1.x, p2.x);
151 if(minp > maxq) {
152 return false;
153 }
154 if(maxp < minq) {
155 return false;
156 }
157 minq = std::min(q1.y, q2.y);
158 maxq = std::max(q1.y, q2.y);
159 minp = std::min(p1.y, p2.y);
160 maxp = std::max(p1.y, p2.y);
161 if(minp > maxq) {
162 return false;
163 }
164 if(maxp < minq) {
165 return false;
166 }
167 return true;
168 }
169
178 bool intersects(const CoordinateXY& a, const CoordinateXY& b) const;
179
183 void init()
184 {
185 setToNull();
186 };
187
196 void init(double x1, double x2, double y1, double y2)
197 {
198 if(x1 < x2) {
199 minx = x1;
200 maxx = x2;
201 }
202 else {
203 minx = x2;
204 maxx = x1;
205 }
206 if(y1 < y2) {
207 miny = y1;
208 maxy = y2;
209 }
210 else {
211 miny = y2;
212 maxy = y1;
213 }
214 };
215
222 void init(const CoordinateXY& p1, const CoordinateXY& p2)
223 {
224 init(p1.x, p2.x, p1.y, p2.y);
225 };
226
232 void init(const CoordinateXY& p)
233 {
234 init(p.x, p.x, p.y, p.y);
235 };
236
242 {
243 minx = maxx = miny = maxy = DoubleNotANumber;
244 };
245
252 bool isNull(void) const
253 {
254 return std::isnan(maxx);
255 };
256
262 double getWidth() const
263 {
264 if(isNull()) {
265 return 0;
266 }
267 return maxx - minx;
268 }
269
275 double getHeight() const
276 {
277 if(isNull()) {
278 return 0;
279 }
280 return maxy - miny;
281 }
282
289 double
290 getArea() const
291 {
292 return getWidth() * getHeight();
293 }
294
301 double
303 {
304 return 2*getWidth() + 2*getHeight();
305 }
306
310 bool
311 isFinite() const
312 {
313 return std::isfinite(getArea());
314 }
315
320 double getMaxY() const
321 {
322 assert(!isNull());
323 return maxy;
324 };
325
330 double getMaxX() const
331 {
332 assert(!isNull());
333 return maxx;
334 };
335
340 double getMinY() const
341 {
342 assert(!isNull());
343 return miny;
344 };
345
350 double getMinX() const
351 {
352 assert(!isNull());
353 return minx;
354 };
355
361 double getDiameter() const
362 {
363 if (isNull()) {
364 return 0.0;
365 }
366 double w = getWidth();
367 double h = getHeight();
368 return std::sqrt(w*w + h*h);
369 }
370
378 bool centre(CoordinateXY& centre) const;
379
389 bool intersection(const Envelope& env, Envelope& result) const;
390
399 Envelope intersection(const Envelope& env) const;
400
407 void translate(double transX, double transY);
408
416 void expandBy(double deltaX, double deltaY);
417
425 void
426 expandBy(double p_distance)
427 {
428 expandBy(p_distance, p_distance);
429 };
430
437 void expandToInclude(const CoordinateXY& p)
438 {
439 expandToInclude(p.x, p.y);
440 };
441
452 void expandToInclude(double x, double y)
453 {
454 if(isNull()) {
455 minx = x;
456 maxx = x;
457 miny = y;
458 maxy = y;
459 }
460 else {
461 if(x < minx) {
462 minx = x;
463 }
464 if(x > maxx) {
465 maxx = x;
466 }
467 if(y < miny) {
468 miny = y;
469 }
470 if(y > maxy) {
471 maxy = y;
472 }
473 }
474 };
475
483 void expandToInclude(const Envelope* other)
484 {
485 if(isNull()) {
486 minx = other->minx;
487 maxx = other->maxx;
488 miny = other->miny;
489 maxy = other->maxy;
490 }
491 else {
492 if(std::isless(other->minx, minx)) {
493 minx = other->minx;
494 }
495 if(std::isgreater(other->maxx, maxx)) {
496 maxx = other->maxx;
497 }
498 if(std::isless(other->miny, miny)) {
499 miny = other->miny;
500 }
501 if(std::isgreater(other->maxy, maxy)) {
502 maxy = other->maxy;
503 }
504 }
505 };
506
507 void expandToInclude(const Envelope& other)
508 {
509 return expandToInclude(&other);
510 };
511
524 bool
525 contains(const Envelope& other) const
526 {
527 return covers(other);
528 }
529
530 bool
531 contains(const Envelope* other) const
532 {
533 return contains(*other);
534 }
535
543 bool
544 contains(const CoordinateXY& p) const
545 {
546 return covers(p.x, p.y);
547 }
548
559 bool
560 contains(double x, double y) const
561 {
562 return covers(x, y);
563 }
564
571 bool intersects(const CoordinateXY& other) const
572 {
573 return (std::islessequal(other.x, maxx) && std::isgreaterequal(other.x, minx) &&
574 std::islessequal(other.y, maxy) && std::isgreaterequal(other.y, miny));
575 }
576
584 bool intersects(double x, double y) const
585 {
586 return std::islessequal(x, maxx) &&
587 std::isgreaterequal(x, minx) &&
588 std::islessequal(y, maxy) &&
589 std::isgreaterequal(y, miny);
590 }
591
598 bool intersects(const Envelope* other) const
599 {
600 return std::islessequal(other->minx, maxx) &&
601 std::isgreaterequal(other->maxx, minx) &&
602 std::islessequal(other->miny, maxy) &&
603 std::isgreaterequal(other->maxy, miny);
604 }
605
606 bool intersects(const Envelope& other) const
607 {
608 return intersects(&other);
609 }
610
618 bool disjoint(const Envelope& other) const
619 {
620 return !intersects(other);
621 }
622
623 bool disjoint(const Envelope* other) const
624 {
625 return !intersects(other);
626 }
627
635 bool covers(double x, double y) const {
636 return std::isgreaterequal(x, minx) &&
637 std::islessequal(x, maxx) &&
638 std::isgreaterequal(y, miny) &&
639 std::islessequal(y, maxy);
640 }
641
648 bool covers(const CoordinateXY* p) const
649 {
650 return covers(p->x, p->y);
651 }
652
659 bool covers(const Envelope& other) const;
660
661 bool
662 covers(const Envelope* other) const
663 {
664 return covers(*other);
665 }
666
667
674 bool equals(const Envelope* other) const;
675
681 bool isfinite() const;
682
688 std::string toString() const;
689
696 double distance(const Envelope& env) const
697 {
698 return std::sqrt(distanceSquared(env));
699 }
700
704 double maxDistance(const Envelope& other) const
705 {
706 Coordinate p(std::min(minx, other.minx), std::min(miny, other.miny));
707 Coordinate q(std::max(maxx, other.maxx), std::max(maxy, other.maxy));
708 return p.distance(q);
709 }
710
717 double distanceSquared(const Envelope& env) const
718 {
719 double dx = std::max(0.0,
720 std::max(maxx, env.maxx) - std::min(minx, env.minx) - (maxx - minx) -
721 (env.maxx - env.minx));
722 double dy = std::max(0.0,
723 std::max(maxy, env.maxy) - std::min(miny, env.miny) - (maxy - miny) -
724 (env.maxy - env.miny));
725
726 return dx * dx + dy * dy;
727 };
728
738 static double distanceToCoordinate(
739 const CoordinateXY& c,
740 const CoordinateXY& p0,
741 const CoordinateXY& p1)
742 {
743 return std::sqrt(distanceSquaredToCoordinate(c, p0, p1));
744 };
745
756 const CoordinateXY& c,
757 const CoordinateXY& p0,
758 const CoordinateXY& p1)
759 {
760 double xa = c.x - p0.x;
761 double xb = c.x - p1.x;
762 double ya = c.y - p0.y;
763 double yb = c.y - p1.y;
764
765 // If sign of a and b are not the same, then Envelope spans c and distance is zero.
766 double dx = (std::signbit(xa) == std::signbit(xb)) * std::min(std::abs(xa), std::abs(xb));
767 double dy = (std::signbit(ya) == std::signbit(yb)) * std::min(std::abs(ya), std::abs(yb));
768
769 return dx*dx + dy*dy;
770 }
771
772 std::size_t hashCode() const
773 {
774 auto hash = std::hash<double>{};
775
776 //Algorithm from Effective Java by Joshua Bloch [Jon Aquino]
777 std::size_t result = 17;
778 result = 37 * result + hash(minx);
779 result = 37 * result + hash(maxx);
780 result = 37 * result + hash(miny);
781 result = 37 * result + hash(maxy);
782 return result;
783 }
784
785 struct GEOS_DLL HashCode
786 {
787 std::size_t operator()(const Envelope& e) const
788 {
789 return e.hashCode();
790 };
791 };
792
794 // GEOS_DLL bool operator==(const Envelope& a, const Envelope& b);
795 GEOS_DLL friend bool
796 operator==(const Envelope& a, const Envelope& b)
797 {
798 return a.equals(&b);
799 }
800
801 // GEOS_DLL bool operator!=(const Envelope& a, const Envelope& b);
802 GEOS_DLL friend bool
803 operator!=(const Envelope& a, const Envelope& b)
804 {
805 return !(a == b);
806 }
807
810 GEOS_DLL friend bool
811 operator< (const Envelope& a, const Envelope& b);
812
813private:
814
821 static std::vector<std::string> split(const std::string& str,
822 const std::string& delimiters = " ");
823
824 static double distance(double x0, double y0, double x1, double y1)
825 {
826 double dx = x1 - x0;
827 double dy = y1 - y0;
828 return std::sqrt(dx * dx + dy * dy);
829 }
830
832 double minx;
833
835 double maxx;
836
838 double miny;
839
841 double maxy;
842};
843
844
845
846
847} // namespace geos::geom
848} // namespace geos
Coordinate is the lightweight class used to store coordinates.
Definition Coordinate.h:217
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition Envelope.h:59
double getMinX() const
Returns the Envelope minimum x-value. Null envelopes do not have maximum values.
Definition Envelope.h:350
void expandToInclude(const CoordinateXY &p)
Enlarges the boundary of the Envelope so that it contains p. Does nothing if p is already on or withi...
Definition Envelope.h:437
bool contains(const CoordinateXY &p) const
Returns true if the given point lies in or on the envelope.
Definition Envelope.h:544
bool intersection(const Envelope &env, Envelope &result) const
Computes the intersection of two Envelopes.
double distanceSquared(const Envelope &env) const
Computes the square of the distance between this and another Envelope.
Definition Envelope.h:717
bool contains(const Envelope &other) const
Tests if the Envelope other lies wholly inside this Envelope (inclusive of the boundary).
Definition Envelope.h:525
void expandToInclude(double x, double y)
Enlarges the boundary of the Envelope so that it contains (x,y).
Definition Envelope.h:452
bool intersects(double x, double y) const
Check if the point (x, y) intersects (lies inside) the region of this Envelope.
Definition Envelope.h:584
bool isfinite() const
double getDiameter() const
Definition Envelope.h:361
bool equals(const Envelope *other) const
Returns true if the Envelope other spatially equals this Envelope.
void setToNull()
Makes this Envelope a "null" envelope, that is, the envelope of the empty geometry.
Definition Envelope.h:241
bool covers(double x, double y) const
Tests if the given point lies in or on the envelope.
Definition Envelope.h:635
bool centre(CoordinateXY &centre) const
Computes the coordinate of the centre of this envelope (as long as it is non-null).
double distance(const Envelope &env) const
Computes the distance between this and another Envelope.
Definition Envelope.h:696
static double distanceToCoordinate(const CoordinateXY &c, const CoordinateXY &p0, const CoordinateXY &p1)
Computes the distance between one Coordinate and an Envelope defined by two other Coordinates....
Definition Envelope.h:738
double getArea() const
Gets the area of this envelope.
Definition Envelope.h:290
double getPerimeter() const
Gets the perimeter of this envelope.
Definition Envelope.h:302
void init(const CoordinateXY &p1, const CoordinateXY &p2)
Initialize an Envelope to a region defined by two Coordinates.
Definition Envelope.h:222
void expandBy(double deltaX, double deltaY)
Expands this envelope by a given distance in all directions. Both positive and negative distances are...
void init(double x1, double x2, double y1, double y2)
Initialize an Envelope for a region defined by maximum and minimum values.
Definition Envelope.h:196
static bool intersects(const CoordinateXY &p1, const CoordinateXY &p2, const CoordinateXY &q)
Test the point q to see whether it intersects the Envelope defined by p1-p2.
bool contains(double x, double y) const
Returns true if the given point lies in or on the envelope.
Definition Envelope.h:560
double getHeight() const
Returns the difference between the maximum and minimum y values.
Definition Envelope.h:275
Envelope()
Creates a null Envelope.
Definition Envelope.h:70
Envelope(const std::string &str)
Create an Envelope from an Envelope string representation produced by Envelope::toString()
bool isFinite() const
Returns true if this Envelope covers a finite region.
Definition Envelope.h:311
double getWidth() const
Returns the difference between the maximum and minimum x values.
Definition Envelope.h:262
double getMaxX() const
Returns the Envelope maximum x-value. Null envelopes do not have maximum values.
Definition Envelope.h:330
bool intersects(const CoordinateXY &a, const CoordinateXY &b) const
Check if the extent defined by two extremal points intersects the extent of this Envelope.
double getMaxY() const
Returns the Envelope maximum y-value. Null envelopes do not have maximum values.
Definition Envelope.h:320
bool isNull(void) const
Returns true if this Envelope is a "null" envelope.
Definition Envelope.h:252
void init(const CoordinateXY &p)
Initialize an Envelope to a region defined by a single Coordinate.
Definition Envelope.h:232
void expandBy(double p_distance)
Expands this envelope by a given distance in all directions.
Definition Envelope.h:426
bool covers(const CoordinateXY *p) const
Tests if the given point lies in or on the envelope.
Definition Envelope.h:648
void expandToInclude(const Envelope *other)
Enlarges the boundary of the Envelope so that it contains other.
Definition Envelope.h:483
static bool intersects(const CoordinateXY &p1, const CoordinateXY &p2, const CoordinateXY &q1, const CoordinateXY &q2)
Test the envelope defined by p1-p2 for intersection with the envelope defined by q1-q2.
Definition Envelope.h:143
Envelope(const CoordinateXY &p)
Creates an Envelope for a region defined by a single Coordinate.
Definition Envelope.h:106
Envelope intersection(const Envelope &env) const
Computes the intersection of two Envelopes.
bool disjoint(const Envelope &other) const
Definition Envelope.h:618
void init()
Initialize to a null Envelope.
Definition Envelope.h:183
friend bool operator==(const Envelope &a, const Envelope &b)
Checks if two Envelopes are equal (2D only check)
Definition Envelope.h:796
Envelope(const CoordinateXY &p1, const CoordinateXY &p2)
Creates an Envelope for a region defined by two Coordinates.
Definition Envelope.h:96
std::string toString() const
Returns a string of the form Env[minx:maxx,miny:maxy].
bool intersects(const Envelope *other) const
Check if the region defined by other Envelope intersects the region of this Envelope.
Definition Envelope.h:598
bool intersects(const CoordinateXY &other) const
Check if the point p intersects (lies inside) the region of this Envelope.
Definition Envelope.h:571
static double distanceSquaredToCoordinate(const CoordinateXY &c, const CoordinateXY &p0, const CoordinateXY &p1)
Computes the squared distance between one Coordinate and an Envelope defined by two other Coordinates...
Definition Envelope.h:755
void translate(double transX, double transY)
Translates this envelope by given amounts in the X and Y direction.
bool covers(const Envelope &other) const
Tests if the Envelope other lies wholly inside this Envelope (inclusive of the boundary).
double getMinY() const
Returns the Envelope minimum y-value. Null envelopes do not have maximum values.
Definition Envelope.h:340
Envelope(double x1, double x2, double y1, double y2)
Creates an Envelope for a region defined by maximum and minimum values.
Definition Envelope.h:85
double maxDistance(const Envelope &other) const
Computes the maximum distance between points in this and another Envelope.
Definition Envelope.h:704
Basic namespace for all GEOS functionalities.
Definition geos.h:38