geo_ops.c File Reference

#include "postgres.h"
#include <math.h>
#include <limits.h>
#include <float.h>
#include <ctype.h>
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "utils/fmgrprotos.h"
#include "utils/geo_decls.h"
#include "varatt.h"

Include dependency graph for geo_ops.c:

Go to the source code of this file.

Macros
#define	LDELIM   '('
#define	RDELIM   ')'
#define	DELIM   ','
#define	LDELIM_EP   '['
#define	RDELIM_EP   ']'
#define	LDELIM_C   '<'
#define	RDELIM_C   '>'
#define	LDELIM_L   '{'
#define	RDELIM_L   '}'
#define	POINT_ON_POLYGON   INT_MAX

Enumerations
enum	path_delim { PATH_NONE , PATH_OPEN , PATH_CLOSED }

Functions
static void	point_construct (Point *result, float8 x, float8 y)
static void	point_add_point (Point *result, Point *pt1, Point *pt2)
static void	point_sub_point (Point *result, Point *pt1, Point *pt2)
static void	point_mul_point (Point *result, Point *pt1, Point *pt2)
static void	point_div_point (Point *result, Point *pt1, Point *pt2)
static bool	point_eq_point (Point *pt1, Point *pt2)
static float8	point_dt (Point *pt1, Point *pt2)
static float8	point_sl (Point *pt1, Point *pt2)
static int	point_inside (Point *p, int npts, Point *plist)
static void	line_construct (LINE *result, Point *pt, float8 m)
static float8	line_sl (LINE *line)
static float8	line_invsl (LINE *line)
static bool	line_interpt_line (Point *result, LINE *l1, LINE *l2)
static bool	line_contain_point (LINE *line, Point *point)
static float8	line_closept_point (Point *result, LINE *line, Point *point)
static void	statlseg_construct (LSEG *lseg, Point *pt1, Point *pt2)
static float8	lseg_sl (LSEG *lseg)
static float8	lseg_invsl (LSEG *lseg)
static bool	lseg_interpt_line (Point *result, LSEG *lseg, LINE *line)
static bool	lseg_interpt_lseg (Point *result, LSEG *l1, LSEG *l2)
static int	lseg_crossing (float8 x, float8 y, float8 prev_x, float8 prev_y)
static bool	lseg_contain_point (LSEG *lseg, Point *pt)
static float8	lseg_closept_point (Point *result, LSEG *lseg, Point *pt)
static float8	lseg_closept_line (Point *result, LSEG *lseg, LINE *line)
static float8	lseg_closept_lseg (Point *result, LSEG *on_lseg, LSEG *to_lseg)
static void	box_construct (BOX *result, Point *pt1, Point *pt2)
static void	box_cn (Point *center, BOX *box)
static bool	box_ov (BOX *box1, BOX *box2)
static float8	box_ar (BOX *box)
static float8	box_ht (BOX *box)
static float8	box_wd (BOX *box)
static bool	box_contain_point (BOX *box, Point *point)
static bool	box_contain_box (BOX *contains_box, BOX *contained_box)
static bool	box_contain_lseg (BOX *box, LSEG *lseg)
static bool	box_interpt_lseg (Point *result, BOX *box, LSEG *lseg)
static float8	box_closept_point (Point *result, BOX *box, Point *pt)
static float8	box_closept_lseg (Point *result, BOX *box, LSEG *lseg)
static float8	circle_ar (CIRCLE *circle)
static void	make_bound_box (POLYGON *poly)
static void	poly_to_circle (CIRCLE *result, POLYGON *poly)
static bool	lseg_inside_poly (Point *a, Point *b, POLYGON *poly, int start)
static bool	poly_contain_poly (POLYGON *contains_poly, POLYGON *contained_poly)
static bool	plist_same (int npts, Point *p1, Point *p2)
static float8	dist_ppoly_internal (Point *pt, POLYGON *poly)
static bool	single_decode (char *num, float8 *x, char **endptr_p, const char *type_name, const char *orig_string, Node *escontext)
static void	single_encode (float8 x, StringInfo str)
static bool	pair_decode (char *str, float8 *x, float8 *y, char **endptr_p, const char *type_name, const char *orig_string, Node *escontext)
static void	pair_encode (float8 x, float8 y, StringInfo str)
static int	pair_count (char *s, char delim)
static bool	path_decode (char *str, bool opentype, int npts, Point *p, bool *isopen, char **endptr_p, const char *type_name, const char *orig_string, Node *escontext)
static char *	path_encode (enum path_delim path_delim, int npts, Point *pt)
static char *	path_encode (enum path_delim path_delim, int npts, Point *pt)
Datum	box_in (PG_FUNCTION_ARGS)
Datum	box_out (PG_FUNCTION_ARGS)
Datum	box_recv (PG_FUNCTION_ARGS)
Datum	box_send (PG_FUNCTION_ARGS)
Datum	box_same (PG_FUNCTION_ARGS)
Datum	box_overlap (PG_FUNCTION_ARGS)
Datum	box_left (PG_FUNCTION_ARGS)
Datum	box_overleft (PG_FUNCTION_ARGS)
Datum	box_right (PG_FUNCTION_ARGS)
Datum	box_overright (PG_FUNCTION_ARGS)
Datum	box_below (PG_FUNCTION_ARGS)
Datum	box_overbelow (PG_FUNCTION_ARGS)
Datum	box_above (PG_FUNCTION_ARGS)
Datum	box_overabove (PG_FUNCTION_ARGS)
Datum	box_contained (PG_FUNCTION_ARGS)
Datum	box_contain (PG_FUNCTION_ARGS)
Datum	box_below_eq (PG_FUNCTION_ARGS)
Datum	box_above_eq (PG_FUNCTION_ARGS)
Datum	box_lt (PG_FUNCTION_ARGS)
Datum	box_gt (PG_FUNCTION_ARGS)
Datum	box_eq (PG_FUNCTION_ARGS)
Datum	box_le (PG_FUNCTION_ARGS)
Datum	box_ge (PG_FUNCTION_ARGS)
Datum	box_area (PG_FUNCTION_ARGS)
Datum	box_width (PG_FUNCTION_ARGS)
Datum	box_height (PG_FUNCTION_ARGS)
Datum	box_distance (PG_FUNCTION_ARGS)
Datum	box_center (PG_FUNCTION_ARGS)
Datum	box_intersect (PG_FUNCTION_ARGS)
Datum	box_diagonal (PG_FUNCTION_ARGS)
static bool	line_decode (char *s, const char *str, LINE *line, Node *escontext)
Datum	line_in (PG_FUNCTION_ARGS)
Datum	line_out (PG_FUNCTION_ARGS)
Datum	line_recv (PG_FUNCTION_ARGS)
Datum	line_send (PG_FUNCTION_ARGS)
Datum	line_construct_pp (PG_FUNCTION_ARGS)
Datum	line_intersect (PG_FUNCTION_ARGS)
Datum	line_parallel (PG_FUNCTION_ARGS)
Datum	line_perp (PG_FUNCTION_ARGS)
Datum	line_vertical (PG_FUNCTION_ARGS)
Datum	line_horizontal (PG_FUNCTION_ARGS)
Datum	line_eq (PG_FUNCTION_ARGS)
Datum	line_distance (PG_FUNCTION_ARGS)
Datum	line_interpt (PG_FUNCTION_ARGS)
Datum	path_area (PG_FUNCTION_ARGS)
Datum	path_in (PG_FUNCTION_ARGS)
Datum	path_out (PG_FUNCTION_ARGS)
Datum	path_recv (PG_FUNCTION_ARGS)
Datum	path_send (PG_FUNCTION_ARGS)
Datum	path_n_lt (PG_FUNCTION_ARGS)
Datum	path_n_gt (PG_FUNCTION_ARGS)
Datum	path_n_eq (PG_FUNCTION_ARGS)
Datum	path_n_le (PG_FUNCTION_ARGS)
Datum	path_n_ge (PG_FUNCTION_ARGS)
Datum	path_isclosed (PG_FUNCTION_ARGS)
Datum	path_isopen (PG_FUNCTION_ARGS)
Datum	path_npoints (PG_FUNCTION_ARGS)
Datum	path_close (PG_FUNCTION_ARGS)
Datum	path_open (PG_FUNCTION_ARGS)
Datum	path_inter (PG_FUNCTION_ARGS)
Datum	path_distance (PG_FUNCTION_ARGS)
Datum	path_length (PG_FUNCTION_ARGS)
Datum	point_in (PG_FUNCTION_ARGS)
Datum	point_out (PG_FUNCTION_ARGS)
Datum	point_recv (PG_FUNCTION_ARGS)
Datum	point_send (PG_FUNCTION_ARGS)
Datum	point_left (PG_FUNCTION_ARGS)
Datum	point_right (PG_FUNCTION_ARGS)
Datum	point_above (PG_FUNCTION_ARGS)
Datum	point_below (PG_FUNCTION_ARGS)
Datum	point_vert (PG_FUNCTION_ARGS)
Datum	point_horiz (PG_FUNCTION_ARGS)
Datum	point_eq (PG_FUNCTION_ARGS)
Datum	point_ne (PG_FUNCTION_ARGS)
Datum	point_distance (PG_FUNCTION_ARGS)
Datum	point_slope (PG_FUNCTION_ARGS)
static float8	point_invsl (Point *pt1, Point *pt2)
Datum	lseg_in (PG_FUNCTION_ARGS)
Datum	lseg_out (PG_FUNCTION_ARGS)
Datum	lseg_recv (PG_FUNCTION_ARGS)
Datum	lseg_send (PG_FUNCTION_ARGS)
Datum	lseg_construct (PG_FUNCTION_ARGS)
Datum	lseg_length (PG_FUNCTION_ARGS)
Datum	lseg_intersect (PG_FUNCTION_ARGS)
Datum	lseg_parallel (PG_FUNCTION_ARGS)
Datum	lseg_perp (PG_FUNCTION_ARGS)
Datum	lseg_vertical (PG_FUNCTION_ARGS)
Datum	lseg_horizontal (PG_FUNCTION_ARGS)
Datum	lseg_eq (PG_FUNCTION_ARGS)
Datum	lseg_ne (PG_FUNCTION_ARGS)
Datum	lseg_lt (PG_FUNCTION_ARGS)
Datum	lseg_le (PG_FUNCTION_ARGS)
Datum	lseg_gt (PG_FUNCTION_ARGS)
Datum	lseg_ge (PG_FUNCTION_ARGS)
Datum	lseg_distance (PG_FUNCTION_ARGS)
Datum	lseg_center (PG_FUNCTION_ARGS)
Datum	lseg_interpt (PG_FUNCTION_ARGS)
Datum	dist_pl (PG_FUNCTION_ARGS)
Datum	dist_lp (PG_FUNCTION_ARGS)
Datum	dist_ps (PG_FUNCTION_ARGS)
Datum	dist_sp (PG_FUNCTION_ARGS)
static float8	dist_ppath_internal (Point *pt, PATH *path)
Datum	dist_ppath (PG_FUNCTION_ARGS)
Datum	dist_pathp (PG_FUNCTION_ARGS)
Datum	dist_pb (PG_FUNCTION_ARGS)
Datum	dist_bp (PG_FUNCTION_ARGS)
Datum	dist_sl (PG_FUNCTION_ARGS)
Datum	dist_ls (PG_FUNCTION_ARGS)
Datum	dist_sb (PG_FUNCTION_ARGS)
Datum	dist_bs (PG_FUNCTION_ARGS)
static float8	dist_cpoly_internal (CIRCLE *circle, POLYGON *poly)
Datum	dist_cpoly (PG_FUNCTION_ARGS)
Datum	dist_polyc (PG_FUNCTION_ARGS)
Datum	dist_ppoly (PG_FUNCTION_ARGS)
Datum	dist_polyp (PG_FUNCTION_ARGS)
Datum	close_pl (PG_FUNCTION_ARGS)
Datum	close_ps (PG_FUNCTION_ARGS)
Datum	close_lseg (PG_FUNCTION_ARGS)
Datum	close_pb (PG_FUNCTION_ARGS)
Datum	close_ls (PG_FUNCTION_ARGS)
Datum	close_sb (PG_FUNCTION_ARGS)
Datum	on_pl (PG_FUNCTION_ARGS)
Datum	on_ps (PG_FUNCTION_ARGS)
Datum	on_pb (PG_FUNCTION_ARGS)
Datum	box_contain_pt (PG_FUNCTION_ARGS)
Datum	on_ppath (PG_FUNCTION_ARGS)
Datum	on_sl (PG_FUNCTION_ARGS)
Datum	on_sb (PG_FUNCTION_ARGS)
Datum	inter_sl (PG_FUNCTION_ARGS)
Datum	inter_sb (PG_FUNCTION_ARGS)
Datum	inter_lb (PG_FUNCTION_ARGS)
Datum	poly_in (PG_FUNCTION_ARGS)
Datum	poly_out (PG_FUNCTION_ARGS)
Datum	poly_recv (PG_FUNCTION_ARGS)
Datum	poly_send (PG_FUNCTION_ARGS)
Datum	poly_left (PG_FUNCTION_ARGS)
Datum	poly_overleft (PG_FUNCTION_ARGS)
Datum	poly_right (PG_FUNCTION_ARGS)
Datum	poly_overright (PG_FUNCTION_ARGS)
Datum	poly_below (PG_FUNCTION_ARGS)
Datum	poly_overbelow (PG_FUNCTION_ARGS)
Datum	poly_above (PG_FUNCTION_ARGS)
Datum	poly_overabove (PG_FUNCTION_ARGS)
Datum	poly_same (PG_FUNCTION_ARGS)
static bool	poly_overlap_internal (POLYGON *polya, POLYGON *polyb)
Datum	poly_overlap (PG_FUNCTION_ARGS)
static bool	touched_lseg_inside_poly (Point *a, Point *b, LSEG *s, POLYGON *poly, int start)
Datum	poly_contain (PG_FUNCTION_ARGS)
Datum	poly_contained (PG_FUNCTION_ARGS)
Datum	poly_contain_pt (PG_FUNCTION_ARGS)
Datum	pt_contained_poly (PG_FUNCTION_ARGS)
Datum	poly_distance (PG_FUNCTION_ARGS)
Datum	construct_point (PG_FUNCTION_ARGS)
Datum	point_add (PG_FUNCTION_ARGS)
Datum	point_sub (PG_FUNCTION_ARGS)
Datum	point_mul (PG_FUNCTION_ARGS)
Datum	point_div (PG_FUNCTION_ARGS)
Datum	points_box (PG_FUNCTION_ARGS)
Datum	box_add (PG_FUNCTION_ARGS)
Datum	box_sub (PG_FUNCTION_ARGS)
Datum	box_mul (PG_FUNCTION_ARGS)
Datum	box_div (PG_FUNCTION_ARGS)
Datum	point_box (PG_FUNCTION_ARGS)
Datum	boxes_bound_box (PG_FUNCTION_ARGS)
Datum	path_add (PG_FUNCTION_ARGS)
Datum	path_add_pt (PG_FUNCTION_ARGS)
Datum	path_sub_pt (PG_FUNCTION_ARGS)
Datum	path_mul_pt (PG_FUNCTION_ARGS)
Datum	path_div_pt (PG_FUNCTION_ARGS)
Datum	path_poly (PG_FUNCTION_ARGS)
Datum	poly_npoints (PG_FUNCTION_ARGS)
Datum	poly_center (PG_FUNCTION_ARGS)
Datum	poly_box (PG_FUNCTION_ARGS)
Datum	box_poly (PG_FUNCTION_ARGS)
Datum	poly_path (PG_FUNCTION_ARGS)
Datum	circle_in (PG_FUNCTION_ARGS)
Datum	circle_out (PG_FUNCTION_ARGS)
Datum	circle_recv (PG_FUNCTION_ARGS)
Datum	circle_send (PG_FUNCTION_ARGS)
Datum	circle_same (PG_FUNCTION_ARGS)
Datum	circle_overlap (PG_FUNCTION_ARGS)
Datum	circle_overleft (PG_FUNCTION_ARGS)
Datum	circle_left (PG_FUNCTION_ARGS)
Datum	circle_right (PG_FUNCTION_ARGS)
Datum	circle_overright (PG_FUNCTION_ARGS)
Datum	circle_contained (PG_FUNCTION_ARGS)
Datum	circle_contain (PG_FUNCTION_ARGS)
Datum	circle_below (PG_FUNCTION_ARGS)
Datum	circle_above (PG_FUNCTION_ARGS)
Datum	circle_overbelow (PG_FUNCTION_ARGS)
Datum	circle_overabove (PG_FUNCTION_ARGS)
Datum	circle_eq (PG_FUNCTION_ARGS)
Datum	circle_ne (PG_FUNCTION_ARGS)
Datum	circle_lt (PG_FUNCTION_ARGS)
Datum	circle_gt (PG_FUNCTION_ARGS)
Datum	circle_le (PG_FUNCTION_ARGS)
Datum	circle_ge (PG_FUNCTION_ARGS)
Datum	circle_add_pt (PG_FUNCTION_ARGS)
Datum	circle_sub_pt (PG_FUNCTION_ARGS)
Datum	circle_mul_pt (PG_FUNCTION_ARGS)
Datum	circle_div_pt (PG_FUNCTION_ARGS)
Datum	circle_area (PG_FUNCTION_ARGS)
Datum	circle_diameter (PG_FUNCTION_ARGS)
Datum	circle_radius (PG_FUNCTION_ARGS)
Datum	circle_distance (PG_FUNCTION_ARGS)
Datum	circle_contain_pt (PG_FUNCTION_ARGS)
Datum	pt_contained_circle (PG_FUNCTION_ARGS)
Datum	dist_pc (PG_FUNCTION_ARGS)
Datum	dist_cpoint (PG_FUNCTION_ARGS)
Datum	circle_center (PG_FUNCTION_ARGS)
Datum	cr_circle (PG_FUNCTION_ARGS)
Datum	circle_box (PG_FUNCTION_ARGS)
Datum	box_circle (PG_FUNCTION_ARGS)
Datum	circle_poly (PG_FUNCTION_ARGS)
Datum	poly_circle (PG_FUNCTION_ARGS)
float8	pg_hypot (float8 x, float8 y)

Macro Definition Documentation

DELIM

#define DELIM   ','

Definition at line 159 of file geo_ops.c.

LDELIM

#define LDELIM   '('

Definition at line 157 of file geo_ops.c.

LDELIM_C

#define LDELIM_C   '<'

Definition at line 162 of file geo_ops.c.

LDELIM_EP

#define LDELIM_EP   '['

Definition at line 160 of file geo_ops.c.

LDELIM_L

#define LDELIM_L   '{'

Definition at line 164 of file geo_ops.c.

POINT_ON_POLYGON

#define POINT_ON_POLYGON   INT_MAX

Definition at line 5337 of file geo_ops.c.

RDELIM

#define RDELIM   ')'

Definition at line 158 of file geo_ops.c.

RDELIM_C

#define RDELIM_C   '>'

Definition at line 163 of file geo_ops.c.

RDELIM_EP

#define RDELIM_EP   ']'

Definition at line 161 of file geo_ops.c.

RDELIM_L

#define RDELIM_L   '}'

Definition at line 165 of file geo_ops.c.

Enumeration Type Documentation

path_delim

enum path_delim

Enumerator
PATH_NONE
PATH_OPEN
PATH_CLOSED

Definition at line 73 of file geo_ops.c.

{
    PATH_NONE, PATH_OPEN, PATH_CLOSED
};

Function Documentation

box_above()

Datum box_above

(

PG_FUNCTION_ARGS

)

Definition at line 658 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPgt(box1->low.y, box2->high.y));
}

References FPgt(), BOX::high, BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::y.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_above_eq()

Datum box_above_eq

(

PG_FUNCTION_ARGS

)

Definition at line 731 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPge(box1->low.y, box2->high.y));
}

References FPge(), BOX::high, BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::y.

box_add()

Datum box_add

(

PG_FUNCTION_ARGS

)

Definition at line 4231 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    Point      *p = PG_GETARG_POINT_P(1);
    BOX        *result;
 
    result = (BOX *) palloc(sizeof(BOX));
 
    point_add_point(&result->high, &box->high, p);
    point_add_point(&result->low, &box->low, p);
 
    PG_RETURN_BOX_P(result);
}

References BOX::high, BOX::low, palloc(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_BOX_P, and point_add_point().

box_ar()

static float8 box_ar ( BOX *  box )

static

Definition at line 863 of file geo_ops.c.

{
    return float8_mul(box_wd(box), box_ht(box));
}

References box_ht(), box_wd(), and float8_mul().

Referenced by box_area(), box_eq(), box_ge(), box_gt(), box_le(), and box_lt().

box_area()

Datum box_area

(

PG_FUNCTION_ARGS

)

Definition at line 796 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
 
    PG_RETURN_FLOAT8(box_ar(box));
}

References box_ar(), PG_GETARG_BOX_P, and PG_RETURN_FLOAT8.

box_below()

Datum box_below

(

PG_FUNCTION_ARGS

)

Definition at line 635 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPlt(box1->high.y, box2->low.y));
}

References FPlt(), BOX::high, BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::y.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_below_eq()

Datum box_below_eq

(

PG_FUNCTION_ARGS

)

Definition at line 722 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPle(box1->high.y, box2->low.y));
}

References FPle(), BOX::high, BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::y.

box_center()

Datum box_center

(

PG_FUNCTION_ARGS

)

Definition at line 849 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    Point      *result = (Point *) palloc(sizeof(Point));
 
    box_cn(result, box);
 
    PG_RETURN_POINT_P(result);
}

References box_cn(), palloc(), PG_GETARG_BOX_P, and PG_RETURN_POINT_P.

box_circle()

Datum box_circle

(

PG_FUNCTION_ARGS

)

Definition at line 5208 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    CIRCLE     *circle;
 
    circle = (CIRCLE *) palloc(sizeof(CIRCLE));
 
    circle->center.x = float8_div(float8_pl(box->high.x, box->low.x), 2.0);
    circle->center.y = float8_div(float8_pl(box->high.y, box->low.y), 2.0);
 
    circle->radius = point_dt(&circle->center, &box->high);
 
    PG_RETURN_CIRCLE_P(circle);
}

References CIRCLE::center, float8_div(), float8_pl(), BOX::high, BOX::low, palloc(), PG_GETARG_BOX_P, PG_RETURN_CIRCLE_P, point_dt(), CIRCLE::radius, Point::x, and Point::y.

box_closept_lseg()

static float8 box_closept_lseg ( Point *  result, BOX *  box, LSEG *  lseg  )

static

Definition at line 3013 of file geo_ops.c.

{
    float8      dist,
                d;
    Point       point,
                closept;
    LSEG        bseg;
 
    if (box_interpt_lseg(result, box, lseg))
        return 0.0;
 
    /* pairwise check lseg distances */
    point.x = box->low.x;
    point.y = box->high.y;
    statlseg_construct(&bseg, &box->low, &point);
    dist = lseg_closept_lseg(result, &bseg, lseg);
 
    statlseg_construct(&bseg, &box->high, &point);
    d = lseg_closept_lseg(&closept, &bseg, lseg);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = closept;
    }
 
    point.x = box->high.x;
    point.y = box->low.y;
    statlseg_construct(&bseg, &box->low, &point);
    d = lseg_closept_lseg(&closept, &bseg, lseg);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = closept;
    }
 
    statlseg_construct(&bseg, &box->high, &point);
    d = lseg_closept_lseg(&closept, &bseg, lseg);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = closept;
    }
 
    return dist;
}

References box_interpt_lseg(), float8_lt(), BOX::high, BOX::low, lseg_closept_lseg(), statlseg_construct(), Point::x, and Point::y.

Referenced by close_sb(), dist_bs(), and dist_sb().

box_closept_point()

static float8 box_closept_point ( Point *  result, BOX *  box, Point *  pt  )

static

Definition at line 2878 of file geo_ops.c.

{
    float8      dist,
                d;
    Point       point,
                closept;
    LSEG        lseg;
 
    if (box_contain_point(box, pt))
    {
        if (result != NULL)
            *result = *pt;
 
        return 0.0;
    }
 
    /* pairwise check lseg distances */
    point.x = box->low.x;
    point.y = box->high.y;
    statlseg_construct(&lseg, &box->low, &point);
    dist = lseg_closept_point(result, &lseg, pt);
 
    statlseg_construct(&lseg, &box->high, &point);
    d = lseg_closept_point(&closept, &lseg, pt);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = closept;
    }
 
    point.x = box->high.x;
    point.y = box->low.y;
    statlseg_construct(&lseg, &box->low, &point);
    d = lseg_closept_point(&closept, &lseg, pt);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = closept;
    }
 
    statlseg_construct(&lseg, &box->high, &point);
    d = lseg_closept_point(&closept, &lseg, pt);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = closept;
    }
 
    return dist;
}

References box_contain_point(), float8_lt(), BOX::high, BOX::low, lseg_closept_point(), statlseg_construct(), Point::x, and Point::y.

Referenced by close_pb(), dist_bp(), and dist_pb().

box_cn()

static void box_cn ( Point *  center, BOX *  box  )

static

Definition at line 872 of file geo_ops.c.

{
    center->x = float8_div(float8_pl(box->high.x, box->low.x), 2.0);
    center->y = float8_div(float8_pl(box->high.y, box->low.y), 2.0);
}

References float8_div(), float8_pl(), BOX::high, BOX::low, Point::x, and Point::y.

Referenced by box_center(), box_distance(), and box_interpt_lseg().

box_construct()

static void box_construct ( BOX *  result, Point *  pt1, Point *  pt2  )

inlinestatic

Definition at line 518 of file geo_ops.c.

{
    if (float8_gt(pt1->x, pt2->x))
    {
        result->high.x = pt1->x;
        result->low.x = pt2->x;
    }
    else
    {
        result->high.x = pt2->x;
        result->low.x = pt1->x;
    }
    if (float8_gt(pt1->y, pt2->y))
    {
        result->high.y = pt1->y;
        result->low.y = pt2->y;
    }
    else
    {
        result->high.y = pt2->y;
        result->low.y = pt1->y;
    }
}

References float8_gt(), BOX::high, BOX::low, Point::x, and Point::y.

Referenced by box_div(), box_mul(), box_poly(), and points_box().

box_contain()

Datum box_contain

(

PG_FUNCTION_ARGS

)

Definition at line 692 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(box_contain_box(box1, box2));
}

References box_contain_box(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_contain_box()

static bool box_contain_box ( BOX *  contains_box, BOX *  contained_box  )

static

Definition at line 704 of file geo_ops.c.

{
    return FPge(contains_box->high.x, contained_box->high.x) &&
        FPle(contains_box->low.x, contained_box->low.x) &&
        FPge(contains_box->high.y, contained_box->high.y) &&
        FPle(contains_box->low.y, contained_box->low.y);
}

References FPge(), FPle(), BOX::high, BOX::low, Point::x, and Point::y.

Referenced by box_contain(), box_contained(), and poly_contain_poly().

box_contain_lseg()

static bool box_contain_lseg ( BOX *  box, LSEG *  lseg  )

static

Definition at line 3217 of file geo_ops.c.

{
    return box_contain_point(box, &lseg->p[0]) &&
        box_contain_point(box, &lseg->p[1]);
}

References box_contain_point(), and LSEG::p.

Referenced by on_sb().

box_contain_point()

static bool box_contain_point ( BOX *  box, Point *  point  )

static

Definition at line 3130 of file geo_ops.c.

{
    return box->high.x >= point->x && box->low.x <= point->x &&
        box->high.y >= point->y && box->low.y <= point->y;
}

References BOX::high, BOX::low, Point::x, and Point::y.

Referenced by box_closept_point(), box_contain_lseg(), box_contain_pt(), box_interpt_lseg(), and on_pb().

box_contain_pt()

Datum box_contain_pt

(

PG_FUNCTION_ARGS

)

Definition at line 3146 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    Point      *pt = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(box_contain_point(box, pt));
}

References box_contain_point(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, and PG_RETURN_BOOL.

Referenced by spg_quad_inner_consistent(), and spg_quad_leaf_consistent().

box_contained()

Datum box_contained

(

PG_FUNCTION_ARGS

)

Definition at line 681 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(box_contain_box(box2, box1));
}

References box_contain_box(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

Referenced by gist_box_leaf_consistent(), and spg_box_quad_leaf_consistent().

box_diagonal()

Datum box_diagonal

(

PG_FUNCTION_ARGS

)

Definition at line 933 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    LSEG       *result = (LSEG *) palloc(sizeof(LSEG));
 
    statlseg_construct(result, &box->high, &box->low);
 
    PG_RETURN_LSEG_P(result);
}

References BOX::high, BOX::low, palloc(), PG_GETARG_BOX_P, PG_RETURN_LSEG_P, and statlseg_construct().

box_distance()

Datum box_distance

(

PG_FUNCTION_ARGS

)

Definition at line 832 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
    Point       a,
                b;
 
    box_cn(&a, box1);
    box_cn(&b, box2);
 
    PG_RETURN_FLOAT8(point_dt(&a, &b));
}

References a, b, box_cn(), PG_GETARG_BOX_P, PG_RETURN_FLOAT8, and point_dt().

box_div()

Datum box_div

(

PG_FUNCTION_ARGS

)

Definition at line 4280 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    Point      *p = PG_GETARG_POINT_P(1);
    BOX        *result;
    Point       high,
                low;
 
    result = (BOX *) palloc(sizeof(BOX));
 
    point_div_point(&high, &box->high, p);
    point_div_point(&low, &box->low, p);
 
    box_construct(result, &high, &low);
 
    PG_RETURN_BOX_P(result);
}

References box_construct(), BOX::high, BOX::low, palloc(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_BOX_P, and point_div_point().

box_eq()

Datum box_eq

(

PG_FUNCTION_ARGS

)

Definition at line 762 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPeq(box_ar(box1), box_ar(box2)));
}

References box_ar(), FPeq(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_ge()

Datum box_ge

(

PG_FUNCTION_ARGS

)

Definition at line 780 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPge(box_ar(box1), box_ar(box2)));
}

References box_ar(), FPge(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_gt()

Datum box_gt

(

PG_FUNCTION_ARGS

)

Definition at line 753 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPgt(box_ar(box1), box_ar(box2)));
}

References box_ar(), FPgt(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_height()

Datum box_height

(

PG_FUNCTION_ARGS

)

Definition at line 820 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
 
    PG_RETURN_FLOAT8(box_ht(box));
}

References box_ht(), PG_GETARG_BOX_P, and PG_RETURN_FLOAT8.

box_ht()

static float8 box_ht ( BOX *  box )

static

Definition at line 893 of file geo_ops.c.

{
    return float8_mi(box->high.y, box->low.y);
}

References float8_mi(), BOX::high, BOX::low, and Point::y.

Referenced by box_ar(), and box_height().

box_in()

Datum box_in

(

PG_FUNCTION_ARGS

)

Definition at line 422 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    BOX        *box = (BOX *) palloc(sizeof(BOX));
    bool        isopen;
    float8      x,
                y;
 
    if (!path_decode(str, false, 2, &(box->high), &isopen, NULL, "box", str,
                     escontext))
        PG_RETURN_NULL();
 
    /* reorder corners if necessary... */
    if (float8_lt(box->high.x, box->low.x))
    {
        x = box->high.x;
        box->high.x = box->low.x;
        box->low.x = x;
    }
    if (float8_lt(box->high.y, box->low.y))
    {
        y = box->high.y;
        box->high.y = box->low.y;
        box->low.y = y;
    }
 
    PG_RETURN_BOX_P(box);
}

References float8_lt(), BOX::high, BOX::low, palloc(), path_decode(), PG_GETARG_CSTRING, PG_RETURN_BOX_P, PG_RETURN_NULL, str, x, Point::x, y, and Point::y.

box_interpt_lseg()

static bool box_interpt_lseg ( Point *  result, BOX *  box, LSEG *  lseg  )

static

Definition at line 3263 of file geo_ops.c.

{
    BOX         lbox;
    LSEG        bseg;
    Point       point;
 
    lbox.low.x = float8_min(lseg->p[0].x, lseg->p[1].x);
    lbox.low.y = float8_min(lseg->p[0].y, lseg->p[1].y);
    lbox.high.x = float8_max(lseg->p[0].x, lseg->p[1].x);
    lbox.high.y = float8_max(lseg->p[0].y, lseg->p[1].y);
 
    /* nothing close to overlap? then not going to intersect */
    if (!box_ov(&lbox, box))
        return false;
 
    if (result != NULL)
    {
        box_cn(&point, box);
        lseg_closept_point(result, lseg, &point);
    }
 
    /* an endpoint of segment is inside box? then clearly intersects */
    if (box_contain_point(box, &lseg->p[0]) ||
        box_contain_point(box, &lseg->p[1]))
        return true;
 
    /* pairwise check lseg intersections */
    point.x = box->low.x;
    point.y = box->high.y;
    statlseg_construct(&bseg, &box->low, &point);
    if (lseg_interpt_lseg(NULL, &bseg, lseg))
        return true;
 
    statlseg_construct(&bseg, &box->high, &point);
    if (lseg_interpt_lseg(NULL, &bseg, lseg))
        return true;
 
    point.x = box->high.x;
    point.y = box->low.y;
    statlseg_construct(&bseg, &box->low, &point);
    if (lseg_interpt_lseg(NULL, &bseg, lseg))
        return true;
 
    statlseg_construct(&bseg, &box->high, &point);
    if (lseg_interpt_lseg(NULL, &bseg, lseg))
        return true;
 
    /* if we dropped through, no two segs intersected */
    return false;
}

References box_cn(), box_contain_point(), box_ov(), float8_max(), float8_min(), BOX::high, BOX::low, lseg_closept_point(), lseg_interpt_lseg(), LSEG::p, statlseg_construct(), Point::x, and Point::y.

Referenced by box_closept_lseg(), and inter_sb().

box_intersect()

Datum box_intersect

(

PG_FUNCTION_ARGS

)

Definition at line 908 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
    BOX        *result;
 
    if (!box_ov(box1, box2))
        PG_RETURN_NULL();
 
    result = (BOX *) palloc(sizeof(BOX));
 
    result->high.x = float8_min(box1->high.x, box2->high.x);
    result->low.x = float8_max(box1->low.x, box2->low.x);
    result->high.y = float8_min(box1->high.y, box2->high.y);
    result->low.y = float8_max(box1->low.y, box2->low.y);
 
    PG_RETURN_BOX_P(result);
}

References box_ov(), float8_max(), float8_min(), BOX::high, BOX::low, palloc(), PG_GETARG_BOX_P, PG_RETURN_BOX_P, PG_RETURN_NULL, Point::x, and Point::y.

box_le()

Datum box_le

(

PG_FUNCTION_ARGS

)

Definition at line 771 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPle(box_ar(box1), box_ar(box2)));
}

References box_ar(), FPle(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_left()

Datum box_left

(

PG_FUNCTION_ARGS

)

Definition at line 583 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPlt(box1->high.x, box2->low.x));
}

References FPlt(), BOX::high, BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::x.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_lt()

Datum box_lt

(

PG_FUNCTION_ARGS

)

Definition at line 744 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPlt(box_ar(box1), box_ar(box2)));
}

References box_ar(), FPlt(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_mul()

Datum box_mul

(

PG_FUNCTION_ARGS

)

Definition at line 4261 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    Point      *p = PG_GETARG_POINT_P(1);
    BOX        *result;
    Point       high,
                low;
 
    result = (BOX *) palloc(sizeof(BOX));
 
    point_mul_point(&high, &box->high, p);
    point_mul_point(&low, &box->low, p);
 
    box_construct(result, &high, &low);
 
    PG_RETURN_BOX_P(result);
}

References box_construct(), BOX::high, BOX::low, palloc(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_BOX_P, and point_mul_point().

box_out()

Datum box_out

(

PG_FUNCTION_ARGS

)

Definition at line 455 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
 
    PG_RETURN_CSTRING(path_encode(PATH_NONE, 2, &(box->high)));
}

References BOX::high, path_encode(), PATH_NONE, PG_GETARG_BOX_P, and PG_RETURN_CSTRING.

box_ov()

static bool box_ov ( BOX *  box1, BOX *  box2  )

static

Definition at line 572 of file geo_ops.c.

{
    return (FPle(box1->low.x, box2->high.x) &&
            FPle(box2->low.x, box1->high.x) &&
            FPle(box1->low.y, box2->high.y) &&
            FPle(box2->low.y, box1->high.y));
}

References FPle(), BOX::high, BOX::low, Point::x, and Point::y.

Referenced by box_interpt_lseg(), box_intersect(), box_overlap(), path_inter(), and poly_overlap_internal().

box_overabove()

Datum box_overabove

(

PG_FUNCTION_ARGS

)

Definition at line 670 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPge(box1->low.y, box2->low.y));
}

References FPge(), BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::y.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_overbelow()

Datum box_overbelow

(

PG_FUNCTION_ARGS

)

Definition at line 647 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPle(box1->high.y, box2->high.y));
}

References FPle(), BOX::high, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::y.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_overlap()

Datum box_overlap

(

PG_FUNCTION_ARGS

)

Definition at line 563 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(box_ov(box1, box2));
}

References box_ov(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_overleft()

Datum box_overleft

(

PG_FUNCTION_ARGS

)

Definition at line 598 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPle(box1->high.x, box2->high.x));
}

References FPle(), BOX::high, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::x.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_overright()

Datum box_overright

(

PG_FUNCTION_ARGS

)

Definition at line 624 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPge(box1->low.x, box2->low.x));
}

References FPge(), BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::x.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_poly()

Datum box_poly

(

PG_FUNCTION_ARGS

)

Definition at line 4535 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    POLYGON    *poly;
    int         size;
 
    /* map four corners of the box to a polygon */
    size = offsetof(POLYGON, p) + sizeof(poly->p[0]) * 4;
    poly = (POLYGON *) palloc(size);
 
    SET_VARSIZE(poly, size);
    poly->npts = 4;
 
    poly->p[0].x = box->low.x;
    poly->p[0].y = box->low.y;
    poly->p[1].x = box->low.x;
    poly->p[1].y = box->high.y;
    poly->p[2].x = box->high.x;
    poly->p[2].y = box->high.y;
    poly->p[3].x = box->high.x;
    poly->p[3].y = box->low.y;
 
    box_construct(&poly->boundbox, &box->high, &box->low);
 
    PG_RETURN_POLYGON_P(poly);
}

References POLYGON::boundbox, box_construct(), BOX::high, BOX::low, POLYGON::npts, POLYGON::p, palloc(), PG_GETARG_BOX_P, PG_RETURN_POLYGON_P, SET_VARSIZE, size, Point::x, and Point::y.

box_recv()

Datum box_recv

(

PG_FUNCTION_ARGS

)

Definition at line 466 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    BOX        *box;
    float8      x,
                y;
 
    box = (BOX *) palloc(sizeof(BOX));
 
    box->high.x = pq_getmsgfloat8(buf);
    box->high.y = pq_getmsgfloat8(buf);
    box->low.x = pq_getmsgfloat8(buf);
    box->low.y = pq_getmsgfloat8(buf);
 
    /* reorder corners if necessary... */
    if (float8_lt(box->high.x, box->low.x))
    {
        x = box->high.x;
        box->high.x = box->low.x;
        box->low.x = x;
    }
    if (float8_lt(box->high.y, box->low.y))
    {
        y = box->high.y;
        box->high.y = box->low.y;
        box->low.y = y;
    }
 
    PG_RETURN_BOX_P(box);
}

References buf, float8_lt(), BOX::high, BOX::low, palloc(), PG_GETARG_POINTER, PG_RETURN_BOX_P, pq_getmsgfloat8(), x, Point::x, y, and Point::y.

box_right()

Datum box_right

(

PG_FUNCTION_ARGS

)

Definition at line 609 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(FPgt(box1->low.x, box2->high.x));
}

References FPgt(), BOX::high, BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and Point::x.

Referenced by gist_box_leaf_consistent(), rtree_internal_consistent(), and spg_box_quad_leaf_consistent().

box_same()

Datum box_same

(

PG_FUNCTION_ARGS

)

Definition at line 551 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0);
    BOX        *box2 = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(point_eq_point(&box1->high, &box2->high) &&
                   point_eq_point(&box1->low, &box2->low));
}

References BOX::high, BOX::low, PG_GETARG_BOX_P, PG_RETURN_BOOL, and point_eq_point().

Referenced by gist_box_leaf_consistent(), and spg_box_quad_leaf_consistent().

box_send()

Datum box_send

(

PG_FUNCTION_ARGS

)

Definition at line 501 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendfloat8(&buf, box->high.x);
    pq_sendfloat8(&buf, box->high.y);
    pq_sendfloat8(&buf, box->low.x);
    pq_sendfloat8(&buf, box->low.y);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, BOX::high, BOX::low, PG_GETARG_BOX_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendfloat8(), Point::x, and Point::y.

box_sub()

Datum box_sub

(

PG_FUNCTION_ARGS

)

Definition at line 4246 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    Point      *p = PG_GETARG_POINT_P(1);
    BOX        *result;
 
    result = (BOX *) palloc(sizeof(BOX));
 
    point_sub_point(&result->high, &box->high, p);
    point_sub_point(&result->low, &box->low, p);
 
    PG_RETURN_BOX_P(result);
}

References BOX::high, BOX::low, palloc(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_BOX_P, and point_sub_point().

box_wd()

static float8 box_wd ( BOX *  box )

static

Definition at line 883 of file geo_ops.c.

{
    return float8_mi(box->high.x, box->low.x);
}

References float8_mi(), BOX::high, BOX::low, and Point::x.

Referenced by box_ar(), and box_width().

box_width()

Datum box_width

(

PG_FUNCTION_ARGS

)

Definition at line 808 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
 
    PG_RETURN_FLOAT8(box_wd(box));
}

References box_wd(), PG_GETARG_BOX_P, and PG_RETURN_FLOAT8.

boxes_bound_box()

Datum boxes_bound_box

(

PG_FUNCTION_ARGS

)

Definition at line 4321 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0),
               *box2 = PG_GETARG_BOX_P(1),
               *container;
 
    container = (BOX *) palloc(sizeof(BOX));
 
    container->high.x = float8_max(box1->high.x, box2->high.x);
    container->low.x = float8_min(box1->low.x, box2->low.x);
    container->high.y = float8_max(box1->high.y, box2->high.y);
    container->low.y = float8_min(box1->low.y, box2->low.y);
 
    PG_RETURN_BOX_P(container);
}

References float8_max(), float8_min(), BOX::high, BOX::low, palloc(), PG_GETARG_BOX_P, PG_RETURN_BOX_P, Point::x, and Point::y.

circle_above()

Datum circle_above

(

PG_FUNCTION_ARGS

)

Definition at line 4863 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPgt(float8_mi(circle1->center.y, circle1->radius),
                        float8_pl(circle2->center.y, circle2->radius)));
}

References CIRCLE::center, float8_mi(), float8_pl(), FPgt(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, CIRCLE::radius, and Point::y.

circle_add_pt()

Datum circle_add_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4965 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
    CIRCLE     *result;
 
    result = (CIRCLE *) palloc(sizeof(CIRCLE));
 
    point_add_point(&result->center, &circle->center, point);
    result->radius = circle->radius;
 
    PG_RETURN_CIRCLE_P(result);
}

References CIRCLE::center, palloc(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, point_add_point(), and CIRCLE::radius.

circle_ar()

static float8 circle_ar ( CIRCLE *  circle )

static

Definition at line 5159 of file geo_ops.c.

{
    return float8_mul(float8_mul(circle->radius, circle->radius), M_PI);
}

References float8_mul(), M_PI, and CIRCLE::radius.

Referenced by circle_area(), circle_eq(), circle_ge(), circle_gt(), circle_le(), circle_lt(), and circle_ne().

circle_area()

Datum circle_area

(

PG_FUNCTION_ARGS

)

Definition at line 5032 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
 
    PG_RETURN_FLOAT8(circle_ar(circle));
}

References circle_ar(), PG_GETARG_CIRCLE_P, and PG_RETURN_FLOAT8.

circle_below()

Datum circle_below

(

PG_FUNCTION_ARGS

)

Definition at line 4851 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPlt(float8_pl(circle1->center.y, circle1->radius),
                        float8_mi(circle2->center.y, circle2->radius)));
}

References CIRCLE::center, float8_mi(), float8_pl(), FPlt(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, CIRCLE::radius, and Point::y.

circle_box()

Datum circle_box

(

PG_FUNCTION_ARGS

)

Definition at line 5186 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    BOX        *box;
    float8      delta;
 
    box = (BOX *) palloc(sizeof(BOX));
 
    delta = float8_div(circle->radius, sqrt(2.0));
 
    box->high.x = float8_pl(circle->center.x, delta);
    box->low.x = float8_mi(circle->center.x, delta);
    box->high.y = float8_pl(circle->center.y, delta);
    box->low.y = float8_mi(circle->center.y, delta);
 
    PG_RETURN_BOX_P(box);
}

References CIRCLE::center, float8_div(), float8_mi(), float8_pl(), BOX::high, BOX::low, palloc(), PG_GETARG_CIRCLE_P, PG_RETURN_BOX_P, CIRCLE::radius, Point::x, and Point::y.

circle_center()

Datum circle_center

(

PG_FUNCTION_ARGS

)

Definition at line 5143 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
    result->x = circle->center.x;
    result->y = circle->center.y;
 
    PG_RETURN_POINT_P(result);
}

References CIRCLE::center, palloc(), PG_GETARG_CIRCLE_P, PG_RETURN_POINT_P, Point::x, and Point::y.

circle_contain()

Datum circle_contain

(

PG_FUNCTION_ARGS

)

Definition at line 4838 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPle(point_dt(&circle1->center, &circle2->center),
                        float8_mi(circle1->radius, circle2->radius)));
}

References CIRCLE::center, float8_mi(), FPle(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, point_dt(), and CIRCLE::radius.

circle_contain_pt()

Datum circle_contain_pt

(

PG_FUNCTION_ARGS

)

Definition at line 5082 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
    float8      d;
 
    d = point_dt(&circle->center, point);
    PG_RETURN_BOOL(d <= circle->radius);
}

References CIRCLE::center, PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_BOOL, and point_dt().

Referenced by gist_point_consistent().

circle_contained()

Datum circle_contained

(

PG_FUNCTION_ARGS

)

Definition at line 4826 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPle(point_dt(&circle1->center, &circle2->center),
                        float8_mi(circle2->radius, circle1->radius)));
}

References CIRCLE::center, float8_mi(), FPle(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, point_dt(), and CIRCLE::radius.

circle_diameter()

Datum circle_diameter

(

PG_FUNCTION_ARGS

)

Definition at line 5043 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
 
    PG_RETURN_FLOAT8(float8_mul(circle->radius, 2.0));
}

References float8_mul(), PG_GETARG_CIRCLE_P, PG_RETURN_FLOAT8, and CIRCLE::radius.

circle_distance()

Datum circle_distance

(

PG_FUNCTION_ARGS

)

Definition at line 5066 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
    float8      result;
 
    result = float8_mi(point_dt(&circle1->center, &circle2->center),
                       float8_pl(circle1->radius, circle2->radius));
    if (result < 0.0)
        result = 0.0;
 
    PG_RETURN_FLOAT8(result);
}

References CIRCLE::center, float8_mi(), float8_pl(), PG_GETARG_CIRCLE_P, PG_RETURN_FLOAT8, point_dt(), and CIRCLE::radius.

circle_div_pt()

Datum circle_div_pt

(

PG_FUNCTION_ARGS

)

Definition at line 5014 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
    CIRCLE     *result;
 
    result = (CIRCLE *) palloc(sizeof(CIRCLE));
 
    point_div_point(&result->center, &circle->center, point);
    result->radius = float8_div(circle->radius, HYPOT(point->x, point->y));
 
    PG_RETURN_CIRCLE_P(result);
}

References CIRCLE::center, float8_div(), HYPOT, palloc(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, point_div_point(), CIRCLE::radius, Point::x, and Point::y.

circle_eq()

Datum circle_eq

(

PG_FUNCTION_ARGS

)

Definition at line 4903 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPeq(circle_ar(circle1), circle_ar(circle2)));
}

References circle_ar(), FPeq(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_ge()

Datum circle_ge

(

PG_FUNCTION_ARGS

)

Definition at line 4948 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPge(circle_ar(circle1), circle_ar(circle2)));
}

References circle_ar(), FPge(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_gt()

Datum circle_gt

(

PG_FUNCTION_ARGS

)

Definition at line 4930 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPgt(circle_ar(circle1), circle_ar(circle2)));
}

References circle_ar(), FPgt(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_in()

Datum circle_in

(

PG_FUNCTION_ARGS

)

Definition at line 4611 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    CIRCLE     *circle = (CIRCLE *) palloc(sizeof(CIRCLE));
    char       *s,
               *cp;
    int         depth = 0;
 
    s = str;
    while (isspace((unsigned char) *s))
        s++;
    if (*s == LDELIM_C)
        depth++, s++;
    else if (*s == LDELIM)
    {
        /* If there are two left parens, consume the first one */
        cp = (s + 1);
        while (isspace((unsigned char) *cp))
            cp++;
        if (*cp == LDELIM)
            depth++, s = cp;
    }
 
    /* pair_decode will consume parens around the pair, if any */
    if (!pair_decode(s, &circle->center.x, &circle->center.y, &s, "circle", str,
                     escontext))
        PG_RETURN_NULL();
 
    if (*s == DELIM)
        s++;
 
    if (!single_decode(s, &circle->radius, &s, "circle", str, escontext))
        PG_RETURN_NULL();
 
    /* We have to accept NaN. */
    if (circle->radius < 0.0)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        "circle", str)));
 
    while (depth > 0)
    {
        if ((*s == RDELIM) || ((*s == RDELIM_C) && (depth == 1)))
        {
            depth--;
            s++;
            while (isspace((unsigned char) *s))
                s++;
        }
        else
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            "circle", str)));
    }
 
    if (*s != '\0')
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        "circle", str)));
 
    PG_RETURN_CIRCLE_P(circle);
}

References CIRCLE::center, DELIM, ereturn, errcode(), errmsg(), LDELIM, LDELIM_C, pair_decode(), palloc(), PG_GETARG_CSTRING, PG_RETURN_CIRCLE_P, PG_RETURN_NULL, CIRCLE::radius, RDELIM, RDELIM_C, single_decode(), str, Point::x, and Point::y.

circle_le()

Datum circle_le

(

PG_FUNCTION_ARGS

)

Definition at line 4939 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPle(circle_ar(circle1), circle_ar(circle2)));
}

References circle_ar(), FPle(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_left()

Datum circle_left

(

PG_FUNCTION_ARGS

)

Definition at line 4789 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPlt(float8_pl(circle1->center.x, circle1->radius),
                        float8_mi(circle2->center.x, circle2->radius)));
}

References CIRCLE::center, float8_mi(), float8_pl(), FPlt(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, CIRCLE::radius, and Point::x.

circle_lt()

Datum circle_lt

(

PG_FUNCTION_ARGS

)

Definition at line 4921 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPlt(circle_ar(circle1), circle_ar(circle2)));
}

References circle_ar(), FPlt(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_mul_pt()

Datum circle_mul_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4999 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
    CIRCLE     *result;
 
    result = (CIRCLE *) palloc(sizeof(CIRCLE));
 
    point_mul_point(&result->center, &circle->center, point);
    result->radius = float8_mul(circle->radius, HYPOT(point->x, point->y));
 
    PG_RETURN_CIRCLE_P(result);
}

References CIRCLE::center, float8_mul(), HYPOT, palloc(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, point_mul_point(), CIRCLE::radius, Point::x, and Point::y.

circle_ne()

Datum circle_ne

(

PG_FUNCTION_ARGS

)

Definition at line 4912 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPne(circle_ar(circle1), circle_ar(circle2)));
}

References circle_ar(), FPne(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_out()

Datum circle_out

(

PG_FUNCTION_ARGS

)

Definition at line 4681 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    StringInfoData str;
 
    initStringInfo(&str);
 
    appendStringInfoChar(&str, LDELIM_C);
    appendStringInfoChar(&str, LDELIM);
    pair_encode(circle->center.x, circle->center.y, &str);
    appendStringInfoChar(&str, RDELIM);
    appendStringInfoChar(&str, DELIM);
    single_encode(circle->radius, &str);
    appendStringInfoChar(&str, RDELIM_C);
 
    PG_RETURN_CSTRING(str.data);
}

References appendStringInfoChar(), CIRCLE::center, DELIM, initStringInfo(), LDELIM, LDELIM_C, pair_encode(), PG_GETARG_CIRCLE_P, PG_RETURN_CSTRING, CIRCLE::radius, RDELIM, RDELIM_C, single_encode(), str, Point::x, and Point::y.

circle_overabove()

Datum circle_overabove

(

PG_FUNCTION_ARGS

)

Definition at line 4889 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPge(float8_mi(circle1->center.y, circle1->radius),
                        float8_mi(circle2->center.y, circle2->radius)));
}

References CIRCLE::center, float8_mi(), FPge(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, CIRCLE::radius, and Point::y.

circle_overbelow()

Datum circle_overbelow

(

PG_FUNCTION_ARGS

)

Definition at line 4876 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPle(float8_pl(circle1->center.y, circle1->radius),
                        float8_pl(circle2->center.y, circle2->radius)));
}

References CIRCLE::center, float8_pl(), FPle(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, CIRCLE::radius, and Point::y.

circle_overlap()

Datum circle_overlap

(

PG_FUNCTION_ARGS

)

Definition at line 4764 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPle(point_dt(&circle1->center, &circle2->center),
                        float8_pl(circle1->radius, circle2->radius)));
}

References CIRCLE::center, float8_pl(), FPle(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, point_dt(), and CIRCLE::radius.

circle_overleft()

Datum circle_overleft

(

PG_FUNCTION_ARGS

)

Definition at line 4777 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPle(float8_pl(circle1->center.x, circle1->radius),
                        float8_pl(circle2->center.x, circle2->radius)));
}

References CIRCLE::center, float8_pl(), FPle(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, CIRCLE::radius, and Point::x.

circle_overright()

Datum circle_overright

(

PG_FUNCTION_ARGS

)

Definition at line 4814 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPge(float8_mi(circle1->center.x, circle1->radius),
                        float8_mi(circle2->center.x, circle2->radius)));
}

References CIRCLE::center, float8_mi(), FPge(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, CIRCLE::radius, and Point::x.

circle_poly()

Datum circle_poly

(

PG_FUNCTION_ARGS

)

Definition at line 5225 of file geo_ops.c.

{
    int32       npts = PG_GETARG_INT32(0);
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(1);
    POLYGON    *poly;
    int         base_size,
                size;
    int         i;
    float8      angle;
    float8      anglestep;
 
    if (FPzero(circle->radius))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot convert circle with radius zero to polygon")));
 
    if (npts < 2)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("must request at least 2 points")));
 
    base_size = sizeof(poly->p[0]) * npts;
    size = offsetof(POLYGON, p) + base_size;
 
    /* Check for integer overflow */
    if (base_size / npts != sizeof(poly->p[0]) || size <= base_size)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("too many points requested")));
 
    poly = (POLYGON *) palloc0(size);   /* zero any holes */
    SET_VARSIZE(poly, size);
    poly->npts = npts;
 
    anglestep = float8_div(2.0 * M_PI, npts);
 
    for (i = 0; i < npts; i++)
    {
        angle = float8_mul(anglestep, i);
 
        poly->p[i].x = float8_mi(circle->center.x,
                                 float8_mul(circle->radius, cos(angle)));
        poly->p[i].y = float8_pl(circle->center.y,
                                 float8_mul(circle->radius, sin(angle)));
    }
 
    make_bound_box(poly);
 
    PG_RETURN_POLYGON_P(poly);
}

References CIRCLE::center, ereport, errcode(), errmsg(), ERROR, float8_div(), float8_mi(), float8_mul(), float8_pl(), FPzero, i, M_PI, make_bound_box(), POLYGON::npts, POLYGON::p, palloc0(), PG_GETARG_CIRCLE_P, PG_GETARG_INT32, PG_RETURN_POLYGON_P, CIRCLE::radius, SET_VARSIZE, size, Point::x, and Point::y.

circle_radius()

Datum circle_radius

(

PG_FUNCTION_ARGS

)

Definition at line 5054 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
 
    PG_RETURN_FLOAT8(circle->radius);
}

References PG_GETARG_CIRCLE_P, PG_RETURN_FLOAT8, and CIRCLE::radius.

circle_recv()

Datum circle_recv

(

PG_FUNCTION_ARGS

)

Definition at line 4703 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    CIRCLE     *circle;
 
    circle = (CIRCLE *) palloc(sizeof(CIRCLE));
 
    circle->center.x = pq_getmsgfloat8(buf);
    circle->center.y = pq_getmsgfloat8(buf);
    circle->radius = pq_getmsgfloat8(buf);
 
    /* We have to accept NaN. */
    if (circle->radius < 0.0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid radius in external \"circle\" value")));
 
    PG_RETURN_CIRCLE_P(circle);
}

References buf, CIRCLE::center, ereport, errcode(), errmsg(), ERROR, palloc(), PG_GETARG_POINTER, PG_RETURN_CIRCLE_P, pq_getmsgfloat8(), CIRCLE::radius, Point::x, and Point::y.

circle_right()

Datum circle_right

(

PG_FUNCTION_ARGS

)

Definition at line 4801 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(FPgt(float8_mi(circle1->center.x, circle1->radius),
                        float8_pl(circle2->center.x, circle2->radius)));
}

References CIRCLE::center, float8_mi(), float8_pl(), FPgt(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, CIRCLE::radius, and Point::x.

circle_same()

Datum circle_same

(

PG_FUNCTION_ARGS

)

Definition at line 4751 of file geo_ops.c.

{
    CIRCLE     *circle1 = PG_GETARG_CIRCLE_P(0);
    CIRCLE     *circle2 = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_BOOL(((isnan(circle1->radius) && isnan(circle2->radius)) ||
                    FPeq(circle1->radius, circle2->radius)) &&
                   point_eq_point(&circle1->center, &circle2->center));
}

References CIRCLE::center, FPeq(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, point_eq_point(), and CIRCLE::radius.

circle_send()

Datum circle_send

(

PG_FUNCTION_ARGS

)

Definition at line 4727 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendfloat8(&buf, circle->center.x);
    pq_sendfloat8(&buf, circle->center.y);
    pq_sendfloat8(&buf, circle->radius);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, CIRCLE::center, PG_GETARG_CIRCLE_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendfloat8(), CIRCLE::radius, Point::x, and Point::y.

circle_sub_pt()

Datum circle_sub_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4980 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
    CIRCLE     *result;
 
    result = (CIRCLE *) palloc(sizeof(CIRCLE));
 
    point_sub_point(&result->center, &circle->center, point);
    result->radius = circle->radius;
 
    PG_RETURN_CIRCLE_P(result);
}

References CIRCLE::center, palloc(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, point_sub_point(), and CIRCLE::radius.

close_ls()

Datum close_ls

(

PG_FUNCTION_ARGS

)

Definition at line 2988 of file geo_ops.c.

{
    LINE       *line = PG_GETARG_LINE_P(0);
    LSEG       *lseg = PG_GETARG_LSEG_P(1);
    Point      *result;
 
    if (lseg_sl(lseg) == line_sl(line))
        PG_RETURN_NULL();
 
    result = (Point *) palloc(sizeof(Point));
 
    if (isnan(lseg_closept_line(result, lseg, line)))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References line_sl(), lseg_closept_line(), lseg_sl(), palloc(), PG_GETARG_LINE_P, PG_GETARG_LSEG_P, PG_RETURN_NULL, and PG_RETURN_POINT_P.

close_lseg()

Datum close_lseg

(

PG_FUNCTION_ARGS

)

Definition at line 2853 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
    Point      *result;
 
    if (lseg_sl(l1) == lseg_sl(l2))
        PG_RETURN_NULL();
 
    result = (Point *) palloc(sizeof(Point));
 
    if (isnan(lseg_closept_lseg(result, l2, l1)))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References lseg_closept_lseg(), lseg_sl(), palloc(), PG_GETARG_LSEG_P, PG_RETURN_NULL, and PG_RETURN_POINT_P.

close_pb()

Datum close_pb

(

PG_FUNCTION_ARGS

)

Definition at line 2933 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    BOX        *box = PG_GETARG_BOX_P(1);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
 
    if (isnan(box_closept_point(result, box, pt)))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References box_closept_point(), palloc(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_NULL, and PG_RETURN_POINT_P.

close_pl()

Datum close_pl

(

PG_FUNCTION_ARGS

)

Definition at line 2750 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    LINE       *line = PG_GETARG_LINE_P(1);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
 
    if (isnan(line_closept_point(result, line, pt)))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References line_closept_point(), palloc(), PG_GETARG_LINE_P, PG_GETARG_POINT_P, PG_RETURN_NULL, and PG_RETURN_POINT_P.

close_ps()

Datum close_ps

(

PG_FUNCTION_ARGS

)

Definition at line 2791 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    LSEG       *lseg = PG_GETARG_LSEG_P(1);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
 
    if (isnan(lseg_closept_point(result, lseg, pt)))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References lseg_closept_point(), palloc(), PG_GETARG_LSEG_P, PG_GETARG_POINT_P, PG_RETURN_NULL, and PG_RETURN_POINT_P.

close_sb()

Datum close_sb

(

PG_FUNCTION_ARGS

)

Definition at line 3063 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    BOX        *box = PG_GETARG_BOX_P(1);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
 
    if (isnan(box_closept_lseg(result, box, lseg)))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References box_closept_lseg(), palloc(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, PG_RETURN_NULL, and PG_RETURN_POINT_P.

construct_point()

Datum construct_point

(

PG_FUNCTION_ARGS

)

Definition at line 4096 of file geo_ops.c.

{
    float8      x = PG_GETARG_FLOAT8(0);
    float8      y = PG_GETARG_FLOAT8(1);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
 
    point_construct(result, x, y);
 
    PG_RETURN_POINT_P(result);
}

References palloc(), PG_GETARG_FLOAT8, PG_RETURN_POINT_P, point_construct(), x, and y.

cr_circle()

Datum cr_circle

(

PG_FUNCTION_ARGS

)

Definition at line 5170 of file geo_ops.c.

{
    Point      *center = PG_GETARG_POINT_P(0);
    float8      radius = PG_GETARG_FLOAT8(1);
    CIRCLE     *result;
 
    result = (CIRCLE *) palloc(sizeof(CIRCLE));
 
    result->center.x = center->x;
    result->center.y = center->y;
    result->radius = radius;
 
    PG_RETURN_CIRCLE_P(result);
}

References CIRCLE::center, palloc(), PG_GETARG_FLOAT8, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, CIRCLE::radius, Point::x, and Point::y.

dist_bp()

Datum dist_bp

(

PG_FUNCTION_ARGS

)

Definition at line 2514 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    Point      *pt = PG_GETARG_POINT_P(1);
 
    PG_RETURN_FLOAT8(box_closept_point(NULL, box, pt));
}

References box_closept_point(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_bs()

Datum dist_bs

(

PG_FUNCTION_ARGS

)

Definition at line 2562 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    LSEG       *lseg = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_FLOAT8(box_closept_lseg(NULL, box, lseg));
}

References box_closept_lseg(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, and PG_RETURN_FLOAT8.

dist_cpoint()

Datum dist_cpoint

(

PG_FUNCTION_ARGS

)

Definition at line 5127 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
    float8      result;
 
    result = float8_mi(point_dt(point, &circle->center), circle->radius);
    if (result < 0.0)
        result = 0.0;
 
    PG_RETURN_FLOAT8(result);
}

References CIRCLE::center, float8_mi(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_FLOAT8, point_dt(), and CIRCLE::radius.

dist_cpoly()

Datum dist_cpoly

(

PG_FUNCTION_ARGS

)

Definition at line 2588 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    POLYGON    *poly = PG_GETARG_POLYGON_P(1);
 
    PG_RETURN_FLOAT8(dist_cpoly_internal(circle, poly));
}

References dist_cpoly_internal(), PG_GETARG_CIRCLE_P, PG_GETARG_POLYGON_P, and PG_RETURN_FLOAT8.

dist_cpoly_internal()

static float8 dist_cpoly_internal ( CIRCLE *  circle, POLYGON *  poly  )

static

Definition at line 2571 of file geo_ops.c.

{
    float8      result;
 
    /* calculate distance to center, and subtract radius */
    result = float8_mi(dist_ppoly_internal(&circle->center, poly),
                       circle->radius);
    if (result < 0.0)
        result = 0.0;
 
    return result;
}

References CIRCLE::center, dist_ppoly_internal(), float8_mi(), and CIRCLE::radius.

Referenced by dist_cpoly(), and dist_polyc().

dist_lp()

Datum dist_lp

(

PG_FUNCTION_ARGS

)

Definition at line 2402 of file geo_ops.c.

{
    LINE       *line = PG_GETARG_LINE_P(0);
    Point      *pt = PG_GETARG_POINT_P(1);
 
    PG_RETURN_FLOAT8(line_closept_point(NULL, line, pt));
}

References line_closept_point(), PG_GETARG_LINE_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_ls()

Datum dist_ls

(

PG_FUNCTION_ARGS

)

Definition at line 2538 of file geo_ops.c.

{
    LINE       *line = PG_GETARG_LINE_P(0);
    LSEG       *lseg = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_FLOAT8(lseg_closept_line(NULL, lseg, line));
}

References lseg_closept_line(), PG_GETARG_LINE_P, PG_GETARG_LSEG_P, and PG_RETURN_FLOAT8.

dist_pathp()

Datum dist_pathp

(

PG_FUNCTION_ARGS

)

Definition at line 2490 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
    Point      *pt = PG_GETARG_POINT_P(1);
 
    PG_RETURN_FLOAT8(dist_ppath_internal(pt, path));
}

References dist_ppath_internal(), PG_GETARG_PATH_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_pb()

Datum dist_pb

(

PG_FUNCTION_ARGS

)

Definition at line 2502 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    BOX        *box = PG_GETARG_BOX_P(1);
 
    PG_RETURN_FLOAT8(box_closept_point(NULL, box, pt));
}

References box_closept_point(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_pc()

Datum dist_pc

(

PG_FUNCTION_ARGS

)

Definition at line 5109 of file geo_ops.c.

{
    Point      *point = PG_GETARG_POINT_P(0);
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(1);
    float8      result;
 
    result = float8_mi(point_dt(point, &circle->center),
                       circle->radius);
    if (result < 0.0)
        result = 0.0;
 
    PG_RETURN_FLOAT8(result);
}

References CIRCLE::center, float8_mi(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_FLOAT8, point_dt(), and CIRCLE::radius.

dist_pl()

Datum dist_pl

(

PG_FUNCTION_ARGS

)

Definition at line 2390 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    LINE       *line = PG_GETARG_LINE_P(1);
 
    PG_RETURN_FLOAT8(line_closept_point(NULL, line, pt));
}

References line_closept_point(), PG_GETARG_LINE_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_polyc()

Datum dist_polyc

(

PG_FUNCTION_ARGS

)

Definition at line 2600 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_FLOAT8(dist_cpoly_internal(circle, poly));
}

References dist_cpoly_internal(), PG_GETARG_CIRCLE_P, PG_GETARG_POLYGON_P, and PG_RETURN_FLOAT8.

dist_polyp()

Datum dist_polyp

(

PG_FUNCTION_ARGS

)

Definition at line 2621 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
 
    PG_RETURN_FLOAT8(dist_ppoly_internal(point, poly));
}

References dist_ppoly_internal(), PG_GETARG_POINT_P, PG_GETARG_POLYGON_P, and PG_RETURN_FLOAT8.

dist_ppath()

Datum dist_ppath

(

PG_FUNCTION_ARGS

)

Definition at line 2478 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    PATH       *path = PG_GETARG_PATH_P(1);
 
    PG_RETURN_FLOAT8(dist_ppath_internal(pt, path));
}

References dist_ppath_internal(), PG_GETARG_PATH_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_ppath_internal()

static float8 dist_ppath_internal ( Point *  pt, PATH *  path  )

static

Definition at line 2435 of file geo_ops.c.

{
    float8      result = 0.0;   /* keep compiler quiet */
    bool        have_min = false;
    float8      tmp;
    int         i;
    LSEG        lseg;
 
    Assert(path->npts > 0);
 
    /*
     * The distance from a point to a path is the smallest distance from the
     * point to any of its constituent segments.
     */
    for (i = 0; i < path->npts; i++)
    {
        int         iprev;
 
        if (i > 0)
            iprev = i - 1;
        else
        {
            if (!path->closed)
                continue;
            iprev = path->npts - 1; /* Include the closure segment */
        }
 
        statlseg_construct(&lseg, &path->p[iprev], &path->p[i]);
        tmp = lseg_closept_point(NULL, &lseg, pt);
        if (!have_min || float8_lt(tmp, result))
        {
            result = tmp;
            have_min = true;
        }
    }
 
    return result;
}

References Assert, PATH::closed, float8_lt(), i, lseg_closept_point(), PATH::npts, PATH::p, and statlseg_construct().

Referenced by dist_pathp(), and dist_ppath().

dist_ppoly()

Datum dist_ppoly

(

PG_FUNCTION_ARGS

)

Definition at line 2612 of file geo_ops.c.

{
    Point      *point = PG_GETARG_POINT_P(0);
    POLYGON    *poly = PG_GETARG_POLYGON_P(1);
 
    PG_RETURN_FLOAT8(dist_ppoly_internal(point, poly));
}

References dist_ppoly_internal(), PG_GETARG_POINT_P, PG_GETARG_POLYGON_P, and PG_RETURN_FLOAT8.

dist_ppoly_internal()

static float8 dist_ppoly_internal ( Point *  pt, POLYGON *  poly  )

static

Definition at line 2630 of file geo_ops.c.

{
    float8      result;
    float8      d;
    int         i;
    LSEG        seg;
 
    if (point_inside(pt, poly->npts, poly->p) != 0)
        return 0.0;
 
    /* initialize distance with segment between first and last points */
    seg.p[0].x = poly->p[0].x;
    seg.p[0].y = poly->p[0].y;
    seg.p[1].x = poly->p[poly->npts - 1].x;
    seg.p[1].y = poly->p[poly->npts - 1].y;
    result = lseg_closept_point(NULL, &seg, pt);
 
    /* check distances for other segments */
    for (i = 0; i < poly->npts - 1; i++)
    {
        seg.p[0].x = poly->p[i].x;
        seg.p[0].y = poly->p[i].y;
        seg.p[1].x = poly->p[i + 1].x;
        seg.p[1].y = poly->p[i + 1].y;
        d = lseg_closept_point(NULL, &seg, pt);
        if (float8_lt(d, result))
            result = d;
    }
 
    return result;
}

References float8_lt(), i, lseg_closept_point(), POLYGON::npts, LSEG::p, POLYGON::p, point_inside(), Point::x, and Point::y.

Referenced by dist_cpoly_internal(), dist_polyp(), and dist_ppoly().

dist_ps()

Datum dist_ps

(

PG_FUNCTION_ARGS

)

Definition at line 2414 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    LSEG       *lseg = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_FLOAT8(lseg_closept_point(NULL, lseg, pt));
}

References lseg_closept_point(), PG_GETARG_LSEG_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_sb()

Datum dist_sb

(

PG_FUNCTION_ARGS

)

Definition at line 2550 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    BOX        *box = PG_GETARG_BOX_P(1);
 
    PG_RETURN_FLOAT8(box_closept_lseg(NULL, box, lseg));
}

References box_closept_lseg(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, and PG_RETURN_FLOAT8.

dist_sl()

Datum dist_sl

(

PG_FUNCTION_ARGS

)

Definition at line 2526 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    LINE       *line = PG_GETARG_LINE_P(1);
 
    PG_RETURN_FLOAT8(lseg_closept_line(NULL, lseg, line));
}

References lseg_closept_line(), PG_GETARG_LINE_P, PG_GETARG_LSEG_P, and PG_RETURN_FLOAT8.

dist_sp()

Datum dist_sp

(

PG_FUNCTION_ARGS

)

Definition at line 2426 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    Point      *pt = PG_GETARG_POINT_P(1);
 
    PG_RETURN_FLOAT8(lseg_closept_point(NULL, lseg, pt));
}

References lseg_closept_point(), PG_GETARG_LSEG_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

inter_lb()

Datum inter_lb

(

PG_FUNCTION_ARGS

)

Definition at line 3328 of file geo_ops.c.

{
    LINE       *line = PG_GETARG_LINE_P(0);
    BOX        *box = PG_GETARG_BOX_P(1);
    LSEG        bseg;
    Point       p1,
                p2;
 
    /* pairwise check lseg intersections */
    p1.x = box->low.x;
    p1.y = box->low.y;
    p2.x = box->low.x;
    p2.y = box->high.y;
    statlseg_construct(&bseg, &p1, &p2);
    if (lseg_interpt_line(NULL, &bseg, line))
        PG_RETURN_BOOL(true);
    p1.x = box->high.x;
    p1.y = box->high.y;
    statlseg_construct(&bseg, &p1, &p2);
    if (lseg_interpt_line(NULL, &bseg, line))
        PG_RETURN_BOOL(true);
    p2.x = box->high.x;
    p2.y = box->low.y;
    statlseg_construct(&bseg, &p1, &p2);
    if (lseg_interpt_line(NULL, &bseg, line))
        PG_RETURN_BOOL(true);
    p1.x = box->low.x;
    p1.y = box->low.y;
    statlseg_construct(&bseg, &p1, &p2);
    if (lseg_interpt_line(NULL, &bseg, line))
        PG_RETURN_BOOL(true);
 
    /* if we dropped through, no intersection */
    PG_RETURN_BOOL(false);
}

References BOX::high, BOX::low, lseg_interpt_line(), p2, PG_GETARG_BOX_P, PG_GETARG_LINE_P, PG_RETURN_BOOL, statlseg_construct(), Point::x, and Point::y.

inter_sb()

Datum inter_sb

(

PG_FUNCTION_ARGS

)

Definition at line 3315 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    BOX        *box = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(box_interpt_lseg(NULL, box, lseg));
}

References box_interpt_lseg(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

inter_sl()

Datum inter_sl

(

PG_FUNCTION_ARGS

)

Definition at line 3238 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    LINE       *line = PG_GETARG_LINE_P(1);
 
    PG_RETURN_BOOL(lseg_interpt_line(NULL, lseg, line));
}

References lseg_interpt_line(), PG_GETARG_LINE_P, PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

line_closept_point()

static float8 line_closept_point ( Point *  result, LINE *  line, Point *  point  )

static

Definition at line 2724 of file geo_ops.c.

{
    Point       closept;
    LINE        tmp;
 
    /*
     * We drop a perpendicular to find the intersection point.  Ordinarily we
     * should always find it, but that can fail in the presence of NaN
     * coordinates, and perhaps even from simple roundoff issues.
     */
    line_construct(&tmp, point, line_invsl(line));
    if (!line_interpt_line(&closept, &tmp, line))
    {
        if (result != NULL)
            *result = *point;
 
        return get_float8_nan();
    }
 
    if (result != NULL)
        *result = closept;
 
    return point_dt(&closept, point);
}

References get_float8_nan(), line_construct(), line_interpt_line(), line_invsl(), and point_dt().

Referenced by close_pl(), dist_lp(), dist_pl(), and lseg_closept_line().

line_construct()

static void line_construct ( LINE *  result, Point *  pt, float8  m  )

inlinestatic

Definition at line 1083 of file geo_ops.c.

{
    if (isinf(m))
    {
        /* vertical - use "x = C" */
        result->A = -1.0;
        result->B = 0.0;
        result->C = pt->x;
    }
    else if (m == 0)
    {
        /* horizontal - use "y = C" */
        result->A = 0.0;
        result->B = -1.0;
        result->C = pt->y;
    }
    else
    {
        /* use "mx - y + yinter = 0" */
        result->A = m;
        result->B = -1.0;
        result->C = float8_mi(pt->y, float8_mul(m, pt->x));
        /* on some platforms, the preceding expression tends to produce -0 */
        if (result->C == 0.0)
            result->C = 0.0;
    }
}

References LINE::A, LINE::B, LINE::C, float8_mi(), float8_mul(), Point::x, and Point::y.

Referenced by line_closept_point(), line_construct_pp(), line_in(), lseg_closept_point(), lseg_interpt_line(), and lseg_interpt_lseg().

line_construct_pp()

Datum line_construct_pp

(

PG_FUNCTION_ARGS

)

Definition at line 1115 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
    LINE       *result = (LINE *) palloc(sizeof(LINE));
 
    if (point_eq_point(pt1, pt2))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid line specification: must be two distinct points")));
 
    line_construct(result, pt1, point_sl(pt1, pt2));
 
    PG_RETURN_LINE_P(result);
}

References ereport, errcode(), errmsg(), ERROR, line_construct(), palloc(), PG_GETARG_POINT_P, PG_RETURN_LINE_P, point_eq_point(), and point_sl().

line_contain_point()

static bool line_contain_point ( LINE *  line, Point *  point  )

static

Definition at line 3087 of file geo_ops.c.

{
    return FPzero(float8_pl(float8_pl(float8_mul(line->A, point->x),
                                      float8_mul(line->B, point->y)),
                            line->C));
}

References LINE::A, LINE::B, LINE::C, float8_mul(), float8_pl(), FPzero, Point::x, and Point::y.

Referenced by on_pl(), and on_sl().

line_decode()

static bool line_decode ( char *  s, const char *  str, LINE *  line, Node *  escontext  )

static

Definition at line 950 of file geo_ops.c.

{
    /* s was already advanced over leading '{' */
    if (!single_decode(s, &line->A, &s, "line", str, escontext))
        return false;
    if (*s++ != DELIM)
        goto fail;
    if (!single_decode(s, &line->B, &s, "line", str, escontext))
        return false;
    if (*s++ != DELIM)
        goto fail;
    if (!single_decode(s, &line->C, &s, "line", str, escontext))
        return false;
    if (*s++ != RDELIM_L)
        goto fail;
    while (isspace((unsigned char) *s))
        s++;
    if (*s != '\0')
        goto fail;
    return true;
 
fail:
    ereturn(escontext, false,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "line", str)));
}

References LINE::A, LINE::B, LINE::C, DELIM, ereturn, errcode(), errmsg(), RDELIM_L, single_decode(), and str.

Referenced by line_in().

line_distance()

Datum line_distance

(

PG_FUNCTION_ARGS

)

Definition at line 1261 of file geo_ops.c.

{
    LINE       *l1 = PG_GETARG_LINE_P(0);
    LINE       *l2 = PG_GETARG_LINE_P(1);
    float8      ratio;
 
    if (line_interpt_line(NULL, l1, l2))    /* intersecting? */
        PG_RETURN_FLOAT8(0.0);
 
    if (!FPzero(l1->A) && !isnan(l1->A) && !FPzero(l2->A) && !isnan(l2->A))
        ratio = float8_div(l1->A, l2->A);
    else if (!FPzero(l1->B) && !isnan(l1->B) && !FPzero(l2->B) && !isnan(l2->B))
        ratio = float8_div(l1->B, l2->B);
    else
        ratio = 1.0;
 
    PG_RETURN_FLOAT8(float8_div(fabs(float8_mi(l1->C,
                                               float8_mul(ratio, l2->C))),
                                HYPOT(l1->A, l1->B)));
}

References LINE::A, LINE::B, LINE::C, float8_div(), float8_mi(), float8_mul(), FPzero, HYPOT, line_interpt_line(), PG_GETARG_LINE_P, and PG_RETURN_FLOAT8.

line_eq()

Datum line_eq

(

PG_FUNCTION_ARGS

)

Definition at line 1194 of file geo_ops.c.

{
    LINE       *l1 = PG_GETARG_LINE_P(0);
    LINE       *l2 = PG_GETARG_LINE_P(1);
    float8      ratio;
 
    /* If any NaNs are involved, insist on exact equality */
    if (unlikely(isnan(l1->A) || isnan(l1->B) || isnan(l1->C) ||
                 isnan(l2->A) || isnan(l2->B) || isnan(l2->C)))
    {
        PG_RETURN_BOOL(float8_eq(l1->A, l2->A) &&
                       float8_eq(l1->B, l2->B) &&
                       float8_eq(l1->C, l2->C));
    }
 
    /* Otherwise, lines whose parameters are proportional are the same */
    if (!FPzero(l2->A))
        ratio = float8_div(l1->A, l2->A);
    else if (!FPzero(l2->B))
        ratio = float8_div(l1->B, l2->B);
    else if (!FPzero(l2->C))
        ratio = float8_div(l1->C, l2->C);
    else
        ratio = 1.0;
 
    PG_RETURN_BOOL(FPeq(l1->A, float8_mul(ratio, l2->A)) &&
                   FPeq(l1->B, float8_mul(ratio, l2->B)) &&
                   FPeq(l1->C, float8_mul(ratio, l2->C)));
}

References LINE::A, LINE::B, LINE::C, float8_div(), float8_eq(), float8_mul(), FPeq(), FPzero, PG_GETARG_LINE_P, PG_RETURN_BOOL, and unlikely.

line_horizontal()

Datum line_horizontal

(

PG_FUNCTION_ARGS

)

Definition at line 1182 of file geo_ops.c.

{
    LINE       *line = PG_GETARG_LINE_P(0);
 
    PG_RETURN_BOOL(FPzero(line->A));
}

References LINE::A, FPzero, PG_GETARG_LINE_P, and PG_RETURN_BOOL.

line_in()

Datum line_in

(

PG_FUNCTION_ARGS

)

Definition at line 979 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    LINE       *line = (LINE *) palloc(sizeof(LINE));
    LSEG        lseg;
    bool        isopen;
    char       *s;
 
    s = str;
    while (isspace((unsigned char) *s))
        s++;
    if (*s == LDELIM_L)
    {
        if (!line_decode(s + 1, str, line, escontext))
            PG_RETURN_NULL();
        if (FPzero(line->A) && FPzero(line->B))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid line specification: A and B cannot both be zero")));
    }
    else
    {
        if (!path_decode(s, true, 2, &lseg.p[0], &isopen, NULL, "line", str,
                         escontext))
            PG_RETURN_NULL();
        if (point_eq_point(&lseg.p[0], &lseg.p[1]))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid line specification: must be two distinct points")));
 
        /*
         * XXX lseg_sl() and line_construct() can throw overflow/underflow
         * errors.  Eventually we should allow those to be soft, but the
         * notational pain seems to outweigh the value for now.
         */
        line_construct(line, &lseg.p[0], lseg_sl(&lseg));
    }
 
    PG_RETURN_LINE_P(line);
}

References LINE::A, LINE::B, ereturn, errcode(), errmsg(), FPzero, LDELIM_L, line_construct(), line_decode(), lseg_sl(), LSEG::p, palloc(), path_decode(), PG_GETARG_CSTRING, PG_RETURN_LINE_P, PG_RETURN_NULL, point_eq_point(), and str.

line_interpt()

Datum line_interpt

(

PG_FUNCTION_ARGS

)

Definition at line 1286 of file geo_ops.c.

{
    LINE       *l1 = PG_GETARG_LINE_P(0);
    LINE       *l2 = PG_GETARG_LINE_P(1);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
 
    if (!line_interpt_line(result, l1, l2))
        PG_RETURN_NULL();
    PG_RETURN_POINT_P(result);
}

References line_interpt_line(), palloc(), PG_GETARG_LINE_P, PG_RETURN_NULL, and PG_RETURN_POINT_P.

line_interpt_line()

static bool line_interpt_line ( Point *  result, LINE *  l1, LINE *  l2  )

static

Definition at line 1314 of file geo_ops.c.

{
    float8      x,
                y;
 
    if (!FPzero(l1->B))
    {
        if (FPeq(l2->A, float8_mul(l1->A, float8_div(l2->B, l1->B))))
            return false;
 
        x = float8_div(float8_mi(float8_mul(l1->B, l2->C),
                                 float8_mul(l2->B, l1->C)),
                       float8_mi(float8_mul(l1->A, l2->B),
                                 float8_mul(l2->A, l1->B)));
        y = float8_div(-float8_pl(float8_mul(l1->A, x), l1->C), l1->B);
    }
    else if (!FPzero(l2->B))
    {
        if (FPeq(l1->A, float8_mul(l2->A, float8_div(l1->B, l2->B))))
            return false;
 
        x = float8_div(float8_mi(float8_mul(l2->B, l1->C),
                                 float8_mul(l1->B, l2->C)),
                       float8_mi(float8_mul(l2->A, l1->B),
                                 float8_mul(l1->A, l2->B)));
        y = float8_div(-float8_pl(float8_mul(l2->A, x), l2->C), l2->B);
    }
    else
        return false;
 
    /* On some platforms, the preceding expressions tend to produce -0. */
    if (x == 0.0)
        x = 0.0;
    if (y == 0.0)
        y = 0.0;
 
    if (result != NULL)
        point_construct(result, x, y);
 
    return true;
}

References LINE::A, LINE::B, LINE::C, float8_div(), float8_mi(), float8_mul(), float8_pl(), FPeq(), FPzero, point_construct(), x, and y.

Referenced by line_closept_point(), line_distance(), line_interpt(), line_intersect(), line_parallel(), and lseg_interpt_line().

line_intersect()

Datum line_intersect

(

PG_FUNCTION_ARGS

)

Definition at line 1137 of file geo_ops.c.

{
    LINE       *l1 = PG_GETARG_LINE_P(0);
    LINE       *l2 = PG_GETARG_LINE_P(1);
 
    PG_RETURN_BOOL(line_interpt_line(NULL, l1, l2));
}

References line_interpt_line(), PG_GETARG_LINE_P, and PG_RETURN_BOOL.

line_invsl()

static float8 line_invsl ( LINE *  line )

inlinestatic

Definition at line 1247 of file geo_ops.c.

{
    if (FPzero(line->A))
        return get_float8_infinity();
    if (FPzero(line->B))
        return 0.0;
    return float8_div(line->B, line->A);
}

References LINE::A, LINE::B, float8_div(), FPzero, and get_float8_infinity().

Referenced by line_closept_point().

line_out()

Datum line_out

(

PG_FUNCTION_ARGS

)

Definition at line 1023 of file geo_ops.c.

{
    LINE       *line = PG_GETARG_LINE_P(0);
    char       *astr = float8out_internal(line->A);
    char       *bstr = float8out_internal(line->B);
    char       *cstr = float8out_internal(line->C);
 
    PG_RETURN_CSTRING(psprintf("%c%s%c%s%c%s%c", LDELIM_L, astr, DELIM, bstr,
                               DELIM, cstr, RDELIM_L));
}

References LINE::A, LINE::B, LINE::C, DELIM, float8out_internal(), LDELIM_L, PG_GETARG_LINE_P, PG_RETURN_CSTRING, psprintf(), and RDELIM_L.

line_parallel()

Datum line_parallel

(

PG_FUNCTION_ARGS

)

Definition at line 1146 of file geo_ops.c.

{
    LINE       *l1 = PG_GETARG_LINE_P(0);
    LINE       *l2 = PG_GETARG_LINE_P(1);
 
    PG_RETURN_BOOL(!line_interpt_line(NULL, l1, l2));
}

References line_interpt_line(), PG_GETARG_LINE_P, and PG_RETURN_BOOL.

line_perp()

Datum line_perp

(

PG_FUNCTION_ARGS

)

Definition at line 1155 of file geo_ops.c.

{
    LINE       *l1 = PG_GETARG_LINE_P(0);
    LINE       *l2 = PG_GETARG_LINE_P(1);
 
    if (FPzero(l1->A))
        PG_RETURN_BOOL(FPzero(l2->B));
    if (FPzero(l2->A))
        PG_RETURN_BOOL(FPzero(l1->B));
    if (FPzero(l1->B))
        PG_RETURN_BOOL(FPzero(l2->A));
    if (FPzero(l2->B))
        PG_RETURN_BOOL(FPzero(l1->A));
 
    PG_RETURN_BOOL(FPeq(float8_div(float8_mul(l1->A, l2->A),
                                   float8_mul(l1->B, l2->B)), -1.0));
}

References LINE::A, LINE::B, float8_div(), float8_mul(), FPeq(), FPzero, PG_GETARG_LINE_P, and PG_RETURN_BOOL.

line_recv()

Datum line_recv

(

PG_FUNCTION_ARGS

)

Definition at line 1038 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    LINE       *line;
 
    line = (LINE *) palloc(sizeof(LINE));
 
    line->A = pq_getmsgfloat8(buf);
    line->B = pq_getmsgfloat8(buf);
    line->C = pq_getmsgfloat8(buf);
 
    if (FPzero(line->A) && FPzero(line->B))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid line specification: A and B cannot both be zero")));
 
    PG_RETURN_LINE_P(line);
}

References LINE::A, LINE::B, buf, LINE::C, ereport, errcode(), errmsg(), ERROR, FPzero, palloc(), PG_GETARG_POINTER, PG_RETURN_LINE_P, and pq_getmsgfloat8().

line_send()

Datum line_send

(

PG_FUNCTION_ARGS

)

Definition at line 1061 of file geo_ops.c.

{
    LINE       *line = PG_GETARG_LINE_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendfloat8(&buf, line->A);
    pq_sendfloat8(&buf, line->B);
    pq_sendfloat8(&buf, line->C);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References LINE::A, LINE::B, buf, LINE::C, PG_GETARG_LINE_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendfloat8().

line_sl()

static float8 line_sl ( LINE *  line )

inlinestatic

Definition at line 1233 of file geo_ops.c.

{
    if (FPzero(line->A))
        return 0.0;
    if (FPzero(line->B))
        return get_float8_infinity();
    return float8_div(line->A, -line->B);
}

References LINE::A, LINE::B, float8_div(), FPzero, and get_float8_infinity().

Referenced by close_ls().

line_vertical()

Datum line_vertical

(

PG_FUNCTION_ARGS

)

Definition at line 1174 of file geo_ops.c.

{
    LINE       *line = PG_GETARG_LINE_P(0);
 
    PG_RETURN_BOOL(FPzero(line->B));
}

References LINE::B, FPzero, PG_GETARG_LINE_P, and PG_RETURN_BOOL.

lseg_center()

Datum lseg_center

(

PG_FUNCTION_ARGS

)

Definition at line 2316 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
 
    result->x = float8_div(float8_pl(lseg->p[0].x, lseg->p[1].x), 2.0);
    result->y = float8_div(float8_pl(lseg->p[0].y, lseg->p[1].y), 2.0);
 
    PG_RETURN_POINT_P(result);
}

References float8_div(), float8_pl(), LSEG::p, palloc(), PG_GETARG_LSEG_P, PG_RETURN_POINT_P, Point::x, and Point::y.

lseg_closept_line()

static float8 lseg_closept_line ( Point *  result, LSEG *  lseg, LINE *  line  )

static

Definition at line 2960 of file geo_ops.c.

{
    float8      dist1,
                dist2;
 
    if (lseg_interpt_line(result, lseg, line))
        return 0.0;
 
    dist1 = line_closept_point(NULL, line, &lseg->p[0]);
    dist2 = line_closept_point(NULL, line, &lseg->p[1]);
 
    if (dist1 < dist2)
    {
        if (result != NULL)
            *result = lseg->p[0];
 
        return dist1;
    }
    else
    {
        if (result != NULL)
            *result = lseg->p[1];
 
        return dist2;
    }
}

References line_closept_point(), lseg_interpt_line(), and LSEG::p.

Referenced by close_ls(), dist_ls(), dist_sl(), and lseg_closept_point().

lseg_closept_lseg()

static float8 lseg_closept_lseg ( Point *  result, LSEG *  on_lseg, LSEG *  to_lseg  )

static

Definition at line 2810 of file geo_ops.c.

{
    Point       point;
    float8      dist,
                d;
 
    /* First, we handle the case when the line segments are intersecting. */
    if (lseg_interpt_lseg(result, on_lseg, to_lseg))
        return 0.0;
 
    /*
     * Then, we find the closest points from the endpoints of the second line
     * segment, and keep the closest one.
     */
    dist = lseg_closept_point(result, on_lseg, &to_lseg->p[0]);
    d = lseg_closept_point(&point, on_lseg, &to_lseg->p[1]);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = point;
    }
 
    /* The closest point can still be one of the endpoints, so we test them. */
    d = lseg_closept_point(NULL, to_lseg, &on_lseg->p[0]);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = on_lseg->p[0];
    }
    d = lseg_closept_point(NULL, to_lseg, &on_lseg->p[1]);
    if (float8_lt(d, dist))
    {
        dist = d;
        if (result != NULL)
            *result = on_lseg->p[1];
    }
 
    return dist;
}

References float8_lt(), lseg_closept_point(), lseg_interpt_lseg(), and LSEG::p.

Referenced by box_closept_lseg(), close_lseg(), lseg_distance(), path_distance(), and poly_distance().

lseg_closept_point()

static float8 lseg_closept_point ( Point *  result, LSEG *  lseg, Point *  pt  )

static

Definition at line 2772 of file geo_ops.c.

{
    Point       closept;
    LINE        tmp;
 
    /*
     * To find the closest point, we draw a perpendicular line from the point
     * to the line segment.
     */
    line_construct(&tmp, pt, point_invsl(&lseg->p[0], &lseg->p[1]));
    lseg_closept_line(&closept, lseg, &tmp);
 
    if (result != NULL)
        *result = closept;
 
    return point_dt(&closept, pt);
}

References line_construct(), lseg_closept_line(), LSEG::p, point_dt(), and point_invsl().

Referenced by box_closept_point(), box_interpt_lseg(), close_ps(), dist_ppath_internal(), dist_ppoly_internal(), dist_ps(), dist_sp(), and lseg_closept_lseg().

lseg_construct()

Datum lseg_construct

(

PG_FUNCTION_ARGS

)

Definition at line 2129 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
    LSEG       *result = (LSEG *) palloc(sizeof(LSEG));
 
    statlseg_construct(result, pt1, pt2);
 
    PG_RETURN_LSEG_P(result);
}

References palloc(), PG_GETARG_POINT_P, PG_RETURN_LSEG_P, and statlseg_construct().

lseg_contain_point()

static bool lseg_contain_point ( LSEG *  lseg, Point *  pt  )

static

Definition at line 3109 of file geo_ops.c.

{
    return FPeq(point_dt(pt, &lseg->p[0]) +
                point_dt(pt, &lseg->p[1]),
                point_dt(&lseg->p[0], &lseg->p[1]));
}

References FPeq(), LSEG::p, and point_dt().

Referenced by lseg_inside_poly(), lseg_interpt_line(), lseg_interpt_lseg(), on_ps(), and touched_lseg_inside_poly().

lseg_crossing()

static int lseg_crossing ( float8  x, float8  y, float8  prev_x, float8  prev_y  )

static

Definition at line 5397 of file geo_ops.c.

{
    float8      z;
    int         y_sign;
 
    if (FPzero(y))
    {                           /* y == 0, on X axis */
        if (FPzero(x))          /* (x,y) is (0,0)? */
            return POINT_ON_POLYGON;
        else if (FPgt(x, 0))
        {                       /* x > 0 */
            if (FPzero(prev_y)) /* y and prev_y are zero */
                /* prev_x > 0? */
                return FPgt(prev_x, 0.0) ? 0 : POINT_ON_POLYGON;
            return FPlt(prev_y, 0.0) ? 1 : -1;
        }
        else
        {                       /* x < 0, x not on positive X axis */
            if (FPzero(prev_y))
                /* prev_x < 0? */
                return FPlt(prev_x, 0.0) ? 0 : POINT_ON_POLYGON;
            return 0;
        }
    }
    else
    {                           /* y != 0 */
        /* compute y crossing direction from previous point */
        y_sign = FPgt(y, 0.0) ? 1 : -1;
 
        if (FPzero(prev_y))
            /* previous point was on X axis, so new point is either off or on */
            return FPlt(prev_x, 0.0) ? 0 : y_sign;
        else if ((y_sign < 0 && FPlt(prev_y, 0.0)) ||
                 (y_sign > 0 && FPgt(prev_y, 0.0)))
            /* both above or below X axis */
            return 0;           /* same sign */
        else
        {                       /* y and prev_y cross X-axis */
            if (FPge(x, 0.0) && FPgt(prev_x, 0.0))
                /* both non-negative so cross positive X-axis */
                return 2 * y_sign;
            if (FPlt(x, 0.0) && FPle(prev_x, 0.0))
                /* both non-positive so do not cross positive X-axis */
                return 0;
 
            /* x and y cross axes, see URL above point_inside() */
            z = float8_mi(float8_mul(float8_mi(x, prev_x), y),
                          float8_mul(float8_mi(y, prev_y), x));
            if (FPzero(z))
                return POINT_ON_POLYGON;
            if ((y_sign < 0 && FPlt(z, 0.0)) ||
                (y_sign > 0 && FPgt(z, 0.0)))
                return 0;
            return 2 * y_sign;
        }
    }
}

References float8_mi(), float8_mul(), FPge(), FPgt(), FPle(), FPlt(), FPzero, POINT_ON_POLYGON, x, and y.

Referenced by point_inside().

lseg_distance()

Datum lseg_distance

(

PG_FUNCTION_ARGS

)

Definition at line 2306 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_FLOAT8(lseg_closept_lseg(NULL, l1, l2));
}

References lseg_closept_lseg(), PG_GETARG_LSEG_P, and PG_RETURN_FLOAT8.

lseg_eq()

Datum lseg_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2236 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(point_eq_point(&l1->p[0], &l2->p[0]) &&
                   point_eq_point(&l1->p[1], &l2->p[1]));
}

References LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BOOL, and point_eq_point().

lseg_ge()

Datum lseg_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2286 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(FPge(point_dt(&l1->p[0], &l1->p[1]),
                        point_dt(&l2->p[0], &l2->p[1])));
}

References FPge(), LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BOOL, and point_dt().

lseg_gt()

Datum lseg_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2276 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(FPgt(point_dt(&l1->p[0], &l1->p[1]),
                        point_dt(&l2->p[0], &l2->p[1])));
}

References FPgt(), LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BOOL, and point_dt().

lseg_horizontal()

Datum lseg_horizontal

(

PG_FUNCTION_ARGS

)

Definition at line 2227 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
 
    PG_RETURN_BOOL(FPeq(lseg->p[0].y, lseg->p[1].y));
}

References FPeq(), LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BOOL, and Point::y.

lseg_in()

Datum lseg_in

(

PG_FUNCTION_ARGS

)

Definition at line 2065 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    LSEG       *lseg = (LSEG *) palloc(sizeof(LSEG));
    bool        isopen;
 
    if (!path_decode(str, true, 2, &lseg->p[0], &isopen, NULL, "lseg", str,
                     escontext))
        PG_RETURN_NULL();
 
    PG_RETURN_LSEG_P(lseg);
}

References LSEG::p, palloc(), path_decode(), PG_GETARG_CSTRING, PG_RETURN_LSEG_P, PG_RETURN_NULL, and str.

lseg_inside_poly()

static bool lseg_inside_poly ( Point *  a, Point *  b, POLYGON *  poly, int  start  )

static

Definition at line 3866 of file geo_ops.c.

{
    LSEG        s,
                t;
    int         i;
    bool        res = true,
                intersection = false;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    t.p[0] = *a;
    t.p[1] = *b;
    s.p[0] = poly->p[(start == 0) ? (poly->npts - 1) : (start - 1)];
 
    for (i = start; i < poly->npts && res; i++)
    {
        Point       interpt;
 
        CHECK_FOR_INTERRUPTS();
 
        s.p[1] = poly->p[i];
 
        if (lseg_contain_point(&s, t.p))
        {
            if (lseg_contain_point(&s, t.p + 1))
                return true;    /* t is contained by s */
 
            /* Y-cross */
            res = touched_lseg_inside_poly(t.p, t.p + 1, &s, poly, i + 1);
        }
        else if (lseg_contain_point(&s, t.p + 1))
        {
            /* Y-cross */
            res = touched_lseg_inside_poly(t.p + 1, t.p, &s, poly, i + 1);
        }
        else if (lseg_interpt_lseg(&interpt, &t, &s))
        {
            /*
             * segments are X-crossing, go to check each subsegment
             */
 
            intersection = true;
            res = lseg_inside_poly(t.p, &interpt, poly, i + 1);
            if (res)
                res = lseg_inside_poly(t.p + 1, &interpt, poly, i + 1);
        }
 
        s.p[0] = s.p[1];
    }
 
    if (res && !intersection)
    {
        Point       p;
 
        /*
         * if X-intersection wasn't found, then check central point of tested
         * segment. In opposite case we already check all subsegments
         */
        p.x = float8_div(float8_pl(t.p[0].x, t.p[1].x), 2.0);
        p.y = float8_div(float8_pl(t.p[0].y, t.p[1].y), 2.0);
 
        res = point_inside(&p, poly->npts, poly->p);
    }
 
    return res;
}

References a, b, CHECK_FOR_INTERRUPTS, check_stack_depth(), float8_div(), float8_pl(), i, lseg_contain_point(), lseg_inside_poly(), lseg_interpt_lseg(), POLYGON::npts, LSEG::p, POLYGON::p, point_inside(), res, start, touched_lseg_inside_poly(), Point::x, and Point::y.

Referenced by lseg_inside_poly(), poly_contain_poly(), and touched_lseg_inside_poly().

lseg_interpt()

Datum lseg_interpt

(

PG_FUNCTION_ARGS

)

Definition at line 2361 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
    Point      *result;
 
    result = (Point *) palloc(sizeof(Point));
 
    if (!lseg_interpt_lseg(result, l1, l2))
        PG_RETURN_NULL();
    PG_RETURN_POINT_P(result);
}

References lseg_interpt_lseg(), palloc(), PG_GETARG_LSEG_P, PG_RETURN_NULL, and PG_RETURN_POINT_P.

Referenced by interpt_pp().

lseg_interpt_line()

static bool lseg_interpt_line ( Point *  result, LSEG *  lseg, LINE *  line  )

static

Definition at line 2675 of file geo_ops.c.

{
    Point       interpt;
    LINE        tmp;
 
    /*
     * First, we promote the line segment to a line, because we know how to
     * find the intersection point of two lines.  If they don't have an
     * intersection point, we are done.
     */
    line_construct(&tmp, &lseg->p[0], lseg_sl(lseg));
    if (!line_interpt_line(&interpt, &tmp, line))
        return false;
 
    /*
     * Then, we check whether the intersection point is actually on the line
     * segment.
     */
    if (!lseg_contain_point(lseg, &interpt))
        return false;
    if (result != NULL)
    {
        /*
         * If there is an intersection, then check explicitly for matching
         * endpoints since there may be rounding effects with annoying LSB
         * residue.
         */
        if (point_eq_point(&lseg->p[0], &interpt))
            *result = lseg->p[0];
        else if (point_eq_point(&lseg->p[1], &interpt))
            *result = lseg->p[1];
        else
            *result = interpt;
    }
 
    return true;
}

References line_construct(), line_interpt_line(), lseg_contain_point(), lseg_sl(), LSEG::p, and point_eq_point().

Referenced by inter_lb(), inter_sl(), lseg_closept_line(), and lseg_interpt_lseg().

lseg_interpt_lseg()

static bool lseg_interpt_lseg ( Point *  result, LSEG *  l1, LSEG *  l2  )

static

Definition at line 2338 of file geo_ops.c.

{
    Point       interpt;
    LINE        tmp;
 
    line_construct(&tmp, &l2->p[0], lseg_sl(l2));
    if (!lseg_interpt_line(&interpt, l1, &tmp))
        return false;
 
    /*
     * If the line intersection point isn't within l2, there is no valid
     * segment intersection point at all.
     */
    if (!lseg_contain_point(l2, &interpt))
        return false;
 
    if (result != NULL)
        *result = interpt;
 
    return true;
}

References line_construct(), lseg_contain_point(), lseg_interpt_line(), lseg_sl(), and LSEG::p.

Referenced by box_interpt_lseg(), lseg_closept_lseg(), lseg_inside_poly(), lseg_interpt(), lseg_intersect(), path_inter(), and poly_overlap_internal().

lseg_intersect()

Datum lseg_intersect

(

PG_FUNCTION_ARGS

)

Definition at line 2188 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(lseg_interpt_lseg(NULL, l1, l2));
}

References lseg_interpt_lseg(), PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

Referenced by interpt_pp().

lseg_invsl()

static float8 lseg_invsl ( LSEG *  lseg )

inlinestatic

Definition at line 2165 of file geo_ops.c.

{
    return point_invsl(&lseg->p[0], &lseg->p[1]);
}

References LSEG::p, and point_invsl().

Referenced by lseg_perp().

lseg_le()

Datum lseg_le

(

PG_FUNCTION_ARGS

)

Definition at line 2266 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(FPle(point_dt(&l1->p[0], &l1->p[1]),
                        point_dt(&l2->p[0], &l2->p[1])));
}

References FPle(), LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BOOL, and point_dt().

lseg_length()

Datum lseg_length

(

PG_FUNCTION_ARGS

)

Definition at line 2172 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
 
    PG_RETURN_FLOAT8(point_dt(&lseg->p[0], &lseg->p[1]));
}

References LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_FLOAT8, and point_dt().

lseg_lt()

Datum lseg_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2256 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(FPlt(point_dt(&l1->p[0], &l1->p[1]),
                        point_dt(&l2->p[0], &l2->p[1])));
}

References FPlt(), LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BOOL, and point_dt().

lseg_ne()

Datum lseg_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2246 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(!point_eq_point(&l1->p[0], &l2->p[0]) ||
                   !point_eq_point(&l1->p[1], &l2->p[1]));
}

References LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BOOL, and point_eq_point().

lseg_out()

Datum lseg_out

(

PG_FUNCTION_ARGS

)

Definition at line 2081 of file geo_ops.c.

{
    LSEG       *ls = PG_GETARG_LSEG_P(0);
 
    PG_RETURN_CSTRING(path_encode(PATH_OPEN, 2, &ls->p[0]));
}

References LSEG::p, path_encode(), PATH_OPEN, PG_GETARG_LSEG_P, and PG_RETURN_CSTRING.

lseg_parallel()

Datum lseg_parallel

(

PG_FUNCTION_ARGS

)

Definition at line 2198 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(FPeq(lseg_sl(l1), lseg_sl(l2)));
}

References FPeq(), lseg_sl(), PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

lseg_perp()

Datum lseg_perp

(

PG_FUNCTION_ARGS

)

Definition at line 2210 of file geo_ops.c.

{
    LSEG       *l1 = PG_GETARG_LSEG_P(0);
    LSEG       *l2 = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(FPeq(lseg_sl(l1), lseg_invsl(l2)));
}

References FPeq(), lseg_invsl(), lseg_sl(), PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

lseg_recv()

Datum lseg_recv

(

PG_FUNCTION_ARGS

)

Definition at line 2092 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    LSEG       *lseg;
 
    lseg = (LSEG *) palloc(sizeof(LSEG));
 
    lseg->p[0].x = pq_getmsgfloat8(buf);
    lseg->p[0].y = pq_getmsgfloat8(buf);
    lseg->p[1].x = pq_getmsgfloat8(buf);
    lseg->p[1].y = pq_getmsgfloat8(buf);
 
    PG_RETURN_LSEG_P(lseg);
}

References buf, LSEG::p, palloc(), PG_GETARG_POINTER, PG_RETURN_LSEG_P, pq_getmsgfloat8(), Point::x, and Point::y.

lseg_send()

Datum lseg_send

(

PG_FUNCTION_ARGS

)

Definition at line 2111 of file geo_ops.c.

{
    LSEG       *ls = PG_GETARG_LSEG_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendfloat8(&buf, ls->p[0].x);
    pq_sendfloat8(&buf, ls->p[0].y);
    pq_sendfloat8(&buf, ls->p[1].x);
    pq_sendfloat8(&buf, ls->p[1].y);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendfloat8(), Point::x, and Point::y.

lseg_sl()

static float8 lseg_sl ( LSEG *  lseg )

inlinestatic

Definition at line 2155 of file geo_ops.c.

{
    return point_sl(&lseg->p[0], &lseg->p[1]);
}

References LSEG::p, and point_sl().

Referenced by close_ls(), close_lseg(), line_in(), lseg_interpt_line(), lseg_interpt_lseg(), lseg_parallel(), and lseg_perp().

lseg_vertical()

Datum lseg_vertical

(

PG_FUNCTION_ARGS

)

Definition at line 2219 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
 
    PG_RETURN_BOOL(FPeq(lseg->p[0].x, lseg->p[1].x));
}

References FPeq(), LSEG::p, PG_GETARG_LSEG_P, PG_RETURN_BOOL, and Point::x.

make_bound_box()

static void make_bound_box ( POLYGON *  poly )

static

Definition at line 3376 of file geo_ops.c.

{
    int         i;
    float8      x1,
                y1,
                x2,
                y2;
 
    Assert(poly->npts > 0);
 
    x1 = x2 = poly->p[0].x;
    y2 = y1 = poly->p[0].y;
    for (i = 1; i < poly->npts; i++)
    {
        if (float8_lt(poly->p[i].x, x1))
            x1 = poly->p[i].x;
        if (float8_gt(poly->p[i].x, x2))
            x2 = poly->p[i].x;
        if (float8_lt(poly->p[i].y, y1))
            y1 = poly->p[i].y;
        if (float8_gt(poly->p[i].y, y2))
            y2 = poly->p[i].y;
    }
 
    poly->boundbox.low.x = x1;
    poly->boundbox.high.x = x2;
    poly->boundbox.low.y = y1;
    poly->boundbox.high.y = y2;
}

References Assert, POLYGON::boundbox, float8_gt(), float8_lt(), BOX::high, i, BOX::low, POLYGON::npts, POLYGON::p, Point::x, and Point::y.

Referenced by circle_poly(), path_poly(), poly_in(), and poly_recv().

on_pb()

Datum on_pb

(

PG_FUNCTION_ARGS

)

Definition at line 3137 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    BOX        *box = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(box_contain_point(box, pt));
}

References box_contain_point(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, and PG_RETURN_BOOL.

on_pl()

Datum on_pl

(

PG_FUNCTION_ARGS

)

Definition at line 3095 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    LINE       *line = PG_GETARG_LINE_P(1);
 
    PG_RETURN_BOOL(line_contain_point(line, pt));
}

References line_contain_point(), PG_GETARG_LINE_P, PG_GETARG_POINT_P, and PG_RETURN_BOOL.

on_ppath()

Datum on_ppath

(

PG_FUNCTION_ARGS

)

Definition at line 3166 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    PATH       *path = PG_GETARG_PATH_P(1);
    int         i,
                n;
    float8      a,
                b;
 
    /*-- OPEN --*/
    if (!path->closed)
    {
        n = path->npts - 1;
        a = point_dt(pt, &path->p[0]);
        for (i = 0; i < n; i++)
        {
            b = point_dt(pt, &path->p[i + 1]);
            if (FPeq(float8_pl(a, b), point_dt(&path->p[i], &path->p[i + 1])))
                PG_RETURN_BOOL(true);
            a = b;
        }
        PG_RETURN_BOOL(false);
    }
 
    /*-- CLOSED --*/
    PG_RETURN_BOOL(point_inside(pt, path->npts, path->p) != 0);
}

References a, b, PATH::closed, float8_pl(), FPeq(), i, PATH::npts, PATH::p, PG_GETARG_PATH_P, PG_GETARG_POINT_P, PG_RETURN_BOOL, point_dt(), and point_inside().

on_ps()

Datum on_ps

(

PG_FUNCTION_ARGS

)

Definition at line 3117 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    LSEG       *lseg = PG_GETARG_LSEG_P(1);
 
    PG_RETURN_BOOL(lseg_contain_point(lseg, pt));
}

References lseg_contain_point(), PG_GETARG_LSEG_P, PG_GETARG_POINT_P, and PG_RETURN_BOOL.

on_sb()

Datum on_sb

(

PG_FUNCTION_ARGS

)

Definition at line 3224 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    BOX        *box = PG_GETARG_BOX_P(1);
 
    PG_RETURN_BOOL(box_contain_lseg(box, lseg));
}

References box_contain_lseg(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

on_sl()

Datum on_sl

(

PG_FUNCTION_ARGS

)

Definition at line 3201 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    LINE       *line = PG_GETARG_LINE_P(1);
 
    PG_RETURN_BOOL(line_contain_point(line, &lseg->p[0]) &&
                   line_contain_point(line, &lseg->p[1]));
}

References line_contain_point(), LSEG::p, PG_GETARG_LINE_P, PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

pair_count()

static int pair_count ( char *  s, char  delim  )

static

Definition at line 392 of file geo_ops.c.

{
    int         ndelim = 0;
 
    while ((s = strchr(s, delim)) != NULL)
    {
        ndelim++;
        s++;
    }
    return (ndelim % 2) ? ((ndelim + 1) / 2) : -1;
}

Referenced by path_in(), and poly_in().

pair_decode()

static bool pair_decode ( char *  str, float8 *  x, float8 *  y, char **  endptr_p, const char *  type_name, const char *  orig_string, Node *  escontext  )

static

Definition at line 212 of file geo_ops.c.

{
    bool        has_delim;
 
    while (isspace((unsigned char) *str))
        str++;
    if ((has_delim = (*str == LDELIM)))
        str++;
 
    if (!single_decode(str, x, &str, type_name, orig_string, escontext))
        return false;
 
    if (*str++ != DELIM)
        goto fail;
 
    if (!single_decode(str, y, &str, type_name, orig_string, escontext))
        return false;
 
    if (has_delim)
    {
        if (*str++ != RDELIM)
            goto fail;
        while (isspace((unsigned char) *str))
            str++;
    }
 
    /* report stopping point if wanted, else complain if not end of string */
    if (endptr_p)
        *endptr_p = str;
    else if (*str != '\0')
        goto fail;
    return true;
 
fail:
    ereturn(escontext, false,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    type_name, orig_string)));
}

References DELIM, ereturn, errcode(), errmsg(), LDELIM, RDELIM, single_decode(), str, x, and y.

Referenced by circle_in(), path_decode(), and point_in().

pair_encode()

static void pair_encode ( float8  x, float8  y, StringInfo  str  )

static

Definition at line 255 of file geo_ops.c.

{
    char       *xstr = float8out_internal(x);
    char       *ystr = float8out_internal(y);
 
    appendStringInfo(str, "%s,%s", xstr, ystr);
    pfree(xstr);
    pfree(ystr);
}

References appendStringInfo(), float8out_internal(), pfree(), str, x, and y.

Referenced by circle_out(), and path_encode().

path_add()

Datum path_add

(

PG_FUNCTION_ARGS

)

Definition at line 4348 of file geo_ops.c.

{
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
    PATH       *result;
    int         size,
                base_size;
    int         i;
 
    if (p1->closed || p2->closed)
        PG_RETURN_NULL();
 
    base_size = sizeof(p1->p[0]) * (p1->npts + p2->npts);
    size = offsetof(PATH, p) + base_size;
 
    /* Check for integer overflow */
    if (base_size / sizeof(p1->p[0]) != (p1->npts + p2->npts) ||
        size <= base_size)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("too many points requested")));
 
    result = (PATH *) palloc(size);
 
    SET_VARSIZE(result, size);
    result->npts = (p1->npts + p2->npts);
    result->closed = p1->closed;
    /* prevent instability in unused pad bytes */
    result->dummy = 0;
 
    for (i = 0; i < p1->npts; i++)
    {
        result->p[i].x = p1->p[i].x;
        result->p[i].y = p1->p[i].y;
    }
    for (i = 0; i < p2->npts; i++)
    {
        result->p[i + p1->npts].x = p2->p[i].x;
        result->p[i + p1->npts].y = p2->p[i].y;
    }
 
    PG_RETURN_PATH_P(result);
}

References PATH::closed, PATH::dummy, ereport, errcode(), errmsg(), ERROR, i, PATH::npts, PATH::p, p2, palloc(), PG_GETARG_PATH_P, PG_RETURN_NULL, PG_RETURN_PATH_P, SET_VARSIZE, size, Point::x, and Point::y.

path_add_pt()

Datum path_add_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4396 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P_COPY(0);
    Point      *point = PG_GETARG_POINT_P(1);
    int         i;
 
    for (i = 0; i < path->npts; i++)
        point_add_point(&path->p[i], &path->p[i], point);
 
    PG_RETURN_PATH_P(path);
}

References i, PATH::npts, PATH::p, PG_GETARG_PATH_P_COPY, PG_GETARG_POINT_P, PG_RETURN_PATH_P, and point_add_point().

path_area()

Datum path_area

(

PG_FUNCTION_ARGS

)

Definition at line 1380 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
    float8      area = 0.0;
    int         i,
                j;
 
    if (!path->closed)
        PG_RETURN_NULL();
 
    for (i = 0; i < path->npts; i++)
    {
        j = (i + 1) % path->npts;
        area = float8_pl(area, float8_mul(path->p[i].x, path->p[j].y));
        area = float8_mi(area, float8_mul(path->p[i].y, path->p[j].x));
    }
 
    PG_RETURN_FLOAT8(float8_div(fabs(area), 2.0));
}

References PATH::closed, float8_div(), float8_mi(), float8_mul(), float8_pl(), i, j, PATH::npts, PATH::p, PG_GETARG_PATH_P, PG_RETURN_FLOAT8, PG_RETURN_NULL, Point::x, and Point::y.

path_close()

Datum path_close

(

PG_FUNCTION_ARGS

)

Definition at line 1627 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P_COPY(0);
 
    path->closed = true;
 
    PG_RETURN_PATH_P(path);
}

References PATH::closed, PG_GETARG_PATH_P_COPY, and PG_RETURN_PATH_P.

path_decode()

static bool path_decode ( char *  str, bool  opentype, int  npts, Point *  p, bool *  isopen, char **  endptr_p, const char *  type_name, const char *  orig_string, Node *  escontext  )

static

Definition at line 266 of file geo_ops.c.

{
    int         depth = 0;
    char       *cp;
    int         i;
 
    while (isspace((unsigned char) *str))
        str++;
    if ((*isopen = (*str == LDELIM_EP)))
    {
        /* no open delimiter allowed? */
        if (!opentype)
            goto fail;
        depth++;
        str++;
    }
    else if (*str == LDELIM)
    {
        cp = (str + 1);
        while (isspace((unsigned char) *cp))
            cp++;
        if (*cp == LDELIM)
        {
            depth++;
            str = cp;
        }
        else if (strrchr(str, LDELIM) == str)
        {
            depth++;
            str = cp;
        }
    }
 
    for (i = 0; i < npts; i++)
    {
        if (!pair_decode(str, &(p->x), &(p->y), &str, type_name, orig_string,
                         escontext))
            return false;
        if (*str == DELIM)
            str++;
        p++;
    }
 
    while (depth > 0)
    {
        if (*str == RDELIM || (*str == RDELIM_EP && *isopen && depth == 1))
        {
            depth--;
            str++;
            while (isspace((unsigned char) *str))
                str++;
        }
        else
            goto fail;
    }
 
    /* report stopping point if wanted, else complain if not end of string */
    if (endptr_p)
        *endptr_p = str;
    else if (*str != '\0')
        goto fail;
    return true;
 
fail:
    ereturn(escontext, false,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    type_name, orig_string)));
}                               /* path_decode() */

References DELIM, ereturn, errcode(), errmsg(), i, LDELIM, LDELIM_EP, pair_decode(), RDELIM, RDELIM_EP, str, Point::x, and Point::y.

Referenced by box_in(), line_in(), lseg_in(), path_in(), and poly_in().

path_distance()

Datum path_distance

(

PG_FUNCTION_ARGS

)

Definition at line 1730 of file geo_ops.c.

{
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
    float8      min = 0.0;      /* initialize to keep compiler quiet */
    bool        have_min = false;
    float8      tmp;
    int         i,
                j;
    LSEG        seg1,
                seg2;
 
    for (i = 0; i < p1->npts; i++)
    {
        int         iprev;
 
        if (i > 0)
            iprev = i - 1;
        else
        {
            if (!p1->closed)
                continue;
            iprev = p1->npts - 1;   /* include the closure segment */
        }
 
        for (j = 0; j < p2->npts; j++)
        {
            int         jprev;
 
            if (j > 0)
                jprev = j - 1;
            else
            {
                if (!p2->closed)
                    continue;
                jprev = p2->npts - 1;   /* include the closure segment */
            }
 
            statlseg_construct(&seg1, &p1->p[iprev], &p1->p[i]);
            statlseg_construct(&seg2, &p2->p[jprev], &p2->p[j]);
 
            tmp = lseg_closept_lseg(NULL, &seg1, &seg2);
            if (!have_min || float8_lt(tmp, min))
            {
                min = tmp;
                have_min = true;
            }
        }
    }
 
    if (!have_min)
        PG_RETURN_NULL();
 
    PG_RETURN_FLOAT8(min);
}

References PATH::closed, float8_lt(), i, j, lseg_closept_lseg(), PATH::npts, PATH::p, p2, PG_GETARG_PATH_P, PG_RETURN_FLOAT8, PG_RETURN_NULL, and statlseg_construct().

path_div_pt()

Datum path_div_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4438 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P_COPY(0);
    Point      *point = PG_GETARG_POINT_P(1);
    int         i;
 
    for (i = 0; i < path->npts; i++)
        point_div_point(&path->p[i], &path->p[i], point);
 
    PG_RETURN_PATH_P(path);
}

References i, PATH::npts, PATH::p, PG_GETARG_PATH_P_COPY, PG_GETARG_POINT_P, PG_RETURN_PATH_P, and point_div_point().

path_encode() [1/2]

static char * path_encode ( enum path_delim  path_delim, int  npts, Point *  pt  )

static

Referenced by box_out(), lseg_out(), path_out(), point_out(), and poly_out().

path_encode() [2/2]

static char * path_encode ( enum path_delim  path_delim, int  npts, Point *  pt  )

static

Definition at line 340 of file geo_ops.c.

{
    StringInfoData str;
    int         i;
 
    initStringInfo(&str);
 
    switch (path_delim)
    {
        case PATH_CLOSED:
            appendStringInfoChar(&str, LDELIM);
            break;
        case PATH_OPEN:
            appendStringInfoChar(&str, LDELIM_EP);
            break;
        case PATH_NONE:
            break;
    }
 
    for (i = 0; i < npts; i++)
    {
        if (i > 0)
            appendStringInfoChar(&str, DELIM);
        appendStringInfoChar(&str, LDELIM);
        pair_encode(pt->x, pt->y, &str);
        appendStringInfoChar(&str, RDELIM);
        pt++;
    }
 
    switch (path_delim)
    {
        case PATH_CLOSED:
            appendStringInfoChar(&str, RDELIM);
            break;
        case PATH_OPEN:
            appendStringInfoChar(&str, RDELIM_EP);
            break;
        case PATH_NONE:
            break;
    }
 
    return str.data;
}                               /* path_encode() */

References appendStringInfoChar(), DELIM, i, initStringInfo(), LDELIM, LDELIM_EP, pair_encode(), PATH_CLOSED, PATH_NONE, PATH_OPEN, RDELIM, RDELIM_EP, str, Point::x, and Point::y.

path_in()

Datum path_in

(

PG_FUNCTION_ARGS

)

Definition at line 1402 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    PATH       *path;
    bool        isopen;
    char       *s;
    int         npts;
    int         size;
    int         base_size;
    int         depth = 0;
 
    if ((npts = pair_count(str, ',')) <= 0)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        "path", str)));
 
    s = str;
    while (isspace((unsigned char) *s))
        s++;
 
    /* skip single leading paren */
    if ((*s == LDELIM) && (strrchr(s, LDELIM) == s))
    {
        s++;
        depth++;
    }
 
    base_size = sizeof(path->p[0]) * npts;
    size = offsetof(PATH, p) + base_size;
 
    /* Check for integer overflow */
    if (base_size / npts != sizeof(path->p[0]) || size <= base_size)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("too many points requested")));
 
    path = (PATH *) palloc(size);
 
    SET_VARSIZE(path, size);
    path->npts = npts;
 
    if (!path_decode(s, true, npts, &(path->p[0]), &isopen, &s, "path", str,
                     escontext))
        PG_RETURN_NULL();
 
    if (depth >= 1)
    {
        if (*s++ != RDELIM)
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            "path", str)));
        while (isspace((unsigned char) *s))
            s++;
    }
    if (*s != '\0')
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        "path", str)));
 
    path->closed = (!isopen);
    /* prevent instability in unused pad bytes */
    path->dummy = 0;
 
    PG_RETURN_PATH_P(path);
}

References PATH::closed, PATH::dummy, ereturn, errcode(), errmsg(), LDELIM, PATH::npts, PATH::p, pair_count(), palloc(), path_decode(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_PATH_P, RDELIM, SET_VARSIZE, size, and str.

path_inter()

Datum path_inter

(

PG_FUNCTION_ARGS

)

Definition at line 1653 of file geo_ops.c.

{
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
    BOX         b1,
                b2;
    int         i,
                j;
    LSEG        seg1,
                seg2;
 
    Assert(p1->npts > 0 && p2->npts > 0);
 
    b1.high.x = b1.low.x = p1->p[0].x;
    b1.high.y = b1.low.y = p1->p[0].y;
    for (i = 1; i < p1->npts; i++)
    {
        b1.high.x = float8_max(p1->p[i].x, b1.high.x);
        b1.high.y = float8_max(p1->p[i].y, b1.high.y);
        b1.low.x = float8_min(p1->p[i].x, b1.low.x);
        b1.low.y = float8_min(p1->p[i].y, b1.low.y);
    }
    b2.high.x = b2.low.x = p2->p[0].x;
    b2.high.y = b2.low.y = p2->p[0].y;
    for (i = 1; i < p2->npts; i++)
    {
        b2.high.x = float8_max(p2->p[i].x, b2.high.x);
        b2.high.y = float8_max(p2->p[i].y, b2.high.y);
        b2.low.x = float8_min(p2->p[i].x, b2.low.x);
        b2.low.y = float8_min(p2->p[i].y, b2.low.y);
    }
    if (!box_ov(&b1, &b2))
        PG_RETURN_BOOL(false);
 
    /* pairwise check lseg intersections */
    for (i = 0; i < p1->npts; i++)
    {
        int         iprev;
 
        if (i > 0)
            iprev = i - 1;
        else
        {
            if (!p1->closed)
                continue;
            iprev = p1->npts - 1;   /* include the closure segment */
        }
 
        for (j = 0; j < p2->npts; j++)
        {
            int         jprev;
 
            if (j > 0)
                jprev = j - 1;
            else
            {
                if (!p2->closed)
                    continue;
                jprev = p2->npts - 1;   /* include the closure segment */
            }
 
            statlseg_construct(&seg1, &p1->p[iprev], &p1->p[i]);
            statlseg_construct(&seg2, &p2->p[jprev], &p2->p[j]);
            if (lseg_interpt_lseg(NULL, &seg1, &seg2))
                PG_RETURN_BOOL(true);
        }
    }
 
    /* if we dropped through, no two segs intersected */
    PG_RETURN_BOOL(false);
}

References Assert, box_ov(), PATH::closed, float8_max(), float8_min(), BOX::high, i, j, BOX::low, lseg_interpt_lseg(), PATH::npts, PATH::p, p2, PG_GETARG_PATH_P, PG_RETURN_BOOL, statlseg_construct(), Point::x, and Point::y.

path_isclosed()

Datum path_isclosed

(

PG_FUNCTION_ARGS

)

Definition at line 1602 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
 
    PG_RETURN_BOOL(path->closed);
}

References PATH::closed, PG_GETARG_PATH_P, and PG_RETURN_BOOL.

path_isopen()

Datum path_isopen

(

PG_FUNCTION_ARGS

)

Definition at line 1610 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
 
    PG_RETURN_BOOL(!path->closed);
}

References PATH::closed, PG_GETARG_PATH_P, and PG_RETURN_BOOL.

path_length()

Datum path_length

(

PG_FUNCTION_ARGS

)

Definition at line 1792 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
    float8      result = 0.0;
    int         i;
 
    for (i = 0; i < path->npts; i++)
    {
        int         iprev;
 
        if (i > 0)
            iprev = i - 1;
        else
        {
            if (!path->closed)
                continue;
            iprev = path->npts - 1; /* include the closure segment */
        }
 
        result = float8_pl(result, point_dt(&path->p[iprev], &path->p[i]));
    }
 
    PG_RETURN_FLOAT8(result);
}

References PATH::closed, float8_pl(), i, PATH::npts, PATH::p, PG_GETARG_PATH_P, PG_RETURN_FLOAT8, and point_dt().

path_mul_pt()

Datum path_mul_pt

(