duckdb::GeometryExtent Class Reference

Public Member Functions
bool	HasXY () const
bool	HasZ () const
bool	HasM () const
void	Extend (const VertexXY &vertex)
void	Extend (const VertexXYZ &vertex)
void	Extend (const VertexXYM &vertex)
void	Extend (const VertexXYZM &vertex)
void	Merge (const GeometryExtent &other)
bool	IntersectsXY (const GeometryExtent &other) const
bool	IntersectsXYZM (const GeometryExtent &other) const
bool	ContainsXY (const GeometryExtent &other) const

Static Public Member Functions
static GeometryExtent	Unknown ()
static GeometryExtent	Empty ()

Public Attributes
double	x_min
double	y_min
double	z_min
double	m_min
double	x_max
double	y_max
double	z_max
double	m_max

Static Public Attributes
static constexpr auto	UNKNOWN_MIN = -std::numeric_limits<double>::infinity()
static constexpr auto	UNKNOWN_MAX = +std::numeric_limits<double>::infinity()
static constexpr auto	EMPTY_MIN = +std::numeric_limits<double>::infinity()
static constexpr auto	EMPTY_MAX = -std::numeric_limits<double>::infinity()

Member Function Documentation

Unknown()

static GeometryExtent duckdb::GeometryExtent::Unknown ( )

inlinestatic

                                    {
        return GeometryExtent {UNKNOWN_MIN, UNKNOWN_MIN, UNKNOWN_MIN, UNKNOWN_MIN,
                               UNKNOWN_MAX, UNKNOWN_MAX, UNKNOWN_MAX, UNKNOWN_MAX};
    }

Empty()

static GeometryExtent duckdb::GeometryExtent::Empty ( )

inlinestatic

                                  {
        return GeometryExtent {EMPTY_MIN, EMPTY_MIN, EMPTY_MIN, EMPTY_MIN, EMPTY_MAX, EMPTY_MAX, EMPTY_MAX, EMPTY_MAX};
    }

HasXY()

bool duckdb::GeometryExtent::HasXY ( ) const

inline

                       {
        return std::isfinite(x_min) && std::isfinite(y_min) && std::isfinite(x_max) && std::isfinite(y_max);
    }

HasZ()

bool duckdb::GeometryExtent::HasZ ( ) const

inline

                      {
        return std::isfinite(z_min) && std::isfinite(z_max);
    }

HasM()

bool duckdb::GeometryExtent::HasM ( ) const

inline

                      {
        return std::isfinite(m_min) && std::isfinite(m_max);
    }

Extend() [1/4]

void duckdb::GeometryExtent::Extend ( const VertexXY &  vertex )

inline

                                        {
        x_min = MinValue(x_min, vertex.x);
        x_max = MaxValue(x_max, vertex.x);
        y_min = MinValue(y_min, vertex.y);
        y_max = MaxValue(y_max, vertex.y);
    }

Extend() [2/4]

void duckdb::GeometryExtent::Extend ( const VertexXYZ &  vertex )

inline

                                         {
        x_min = MinValue(x_min, vertex.x);
        x_max = MaxValue(x_max, vertex.x);
        y_min = MinValue(y_min, vertex.y);
        y_max = MaxValue(y_max, vertex.y);
        z_min = MinValue(z_min, vertex.z);
        z_max = MaxValue(z_max, vertex.z);
    }

Extend() [3/4]

void duckdb::GeometryExtent::Extend ( const VertexXYM &  vertex )

inline

                                         {
        x_min = MinValue(x_min, vertex.x);
        x_max = MaxValue(x_max, vertex.x);
        y_min = MinValue(y_min, vertex.y);
        y_max = MaxValue(y_max, vertex.y);
        m_min = MinValue(m_min, vertex.m);
        m_max = MaxValue(m_max, vertex.m);
    }

Extend() [4/4]

void duckdb::GeometryExtent::Extend ( const VertexXYZM &  vertex )

inline

                                          {
        x_min = MinValue(x_min, vertex.x);
        x_max = MaxValue(x_max, vertex.x);
        y_min = MinValue(y_min, vertex.y);
        y_max = MaxValue(y_max, vertex.y);
        z_min = MinValue(z_min, vertex.z);
        z_max = MaxValue(z_max, vertex.z);
        m_min = MinValue(m_min, vertex.m);
        m_max = MaxValue(m_max, vertex.m);
    }

Merge()

void duckdb::GeometryExtent::Merge ( const GeometryExtent &  other )

inline

                                            {
        x_min = MinValue(x_min, other.x_min);
        y_min = MinValue(y_min, other.y_min);
        z_min = MinValue(z_min, other.z_min);
        m_min = MinValue(m_min, other.m_min);
 
        x_max = MaxValue(x_max, other.x_max);
        y_max = MaxValue(y_max, other.y_max);
        z_max = MaxValue(z_max, other.z_max);
        m_max = MaxValue(m_max, other.m_max);
    }

IntersectsXY()

bool duckdb::GeometryExtent::IntersectsXY ( const GeometryExtent &  other ) const

inline

                                                         {
        return !(x_min > other.x_max || x_max < other.x_min || y_min > other.y_max || y_max < other.y_min);
    }

IntersectsXYZM()

bool duckdb::GeometryExtent::IntersectsXYZM ( const GeometryExtent &  other ) const

inline

                                                           {
        return !(x_min > other.x_max || x_max < other.x_min || y_min > other.y_max || y_max < other.y_min ||
                 z_min > other.z_max || z_max < other.z_min || m_min > other.m_max || m_max < other.m_min);
    }

ContainsXY()

bool duckdb::GeometryExtent::ContainsXY ( const GeometryExtent &  other ) const

inline

                                                       {
        return x_min <= other.x_min && x_max >= other.x_max && y_min <= other.y_min && y_max >= other.y_max;
    }

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.hpp