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, Node *escontext)
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, Node *escontext)
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, Node *escontext)
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 POLYGON *	circle_poly_internal (int32 npts, const CIRCLE *circle, FunctionCallInfo fcinfo)
static void	poly_to_circle (CIRCLE *result, POLYGON *poly, Node *escontext)
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	circle_to_poly (PG_FUNCTION_ARGS)
Datum	poly_circle (PG_FUNCTION_ARGS)

Macro Definition Documentation

DELIM

#define DELIM   ','

Definition at line 160 of file geo_ops.c.

LDELIM

#define LDELIM   '('

Definition at line 158 of file geo_ops.c.

LDELIM_C

#define LDELIM_C   '<'

Definition at line 163 of file geo_ops.c.

LDELIM_EP

#define LDELIM_EP   '['

Definition at line 161 of file geo_ops.c.

LDELIM_L

#define LDELIM_L   '{'

Definition at line 165 of file geo_ops.c.

POINT_ON_POLYGON

#define POINT_ON_POLYGON   INT_MAX

Definition at line 5489 of file geo_ops.c.

RDELIM

#define RDELIM   ')'

Definition at line 159 of file geo_ops.c.

RDELIM_C

#define RDELIM_C   '>'

Definition at line 164 of file geo_ops.c.

RDELIM_EP

#define RDELIM_EP   ']'

Definition at line 162 of file geo_ops.c.

RDELIM_L

#define RDELIM_L   '}'

Definition at line 166 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 659 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 fb(), FPgt(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

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 732 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 fb(), FPge(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_add()

Datum box_add

(

PG_FUNCTION_ARGS

)

Definition at line 4287 of file geo_ops.c.

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

References fb(), palloc_object, PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_BOX_P, point_add_point(), and result.

box_ar()

static float8 box_ar ( BOX *  box )

static

Definition at line 866 of file geo_ops.c.

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

References box_ht(), box_wd(), fb(), 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 797 of file geo_ops.c.

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

References box_ar(), fb(), PG_GETARG_BOX_P, and PG_RETURN_FLOAT8.

box_below()

Datum box_below

(

PG_FUNCTION_ARGS

)

Definition at line 636 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 fb(), FPlt(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

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 723 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 fb(), FPle(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_center()

Datum box_center

(

PG_FUNCTION_ARGS

)

Definition at line 850 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    Point      *result = palloc_object(Point);
 
    box_cn(result, box, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References box_cn(), fb(), palloc_object, PG_GETARG_BOX_P, PG_RETURN_NULL, PG_RETURN_POINT_P, result, and SOFT_ERROR_OCCURRED.

box_circle()

Datum box_circle

(

PG_FUNCTION_ARGS

)

Definition at line 5283 of file geo_ops.c.

{
    BOX        *box = PG_GETARG_BOX_P(0);
    CIRCLE     *circle;
    float8      x;
    float8      y;
 
    circle = palloc_object(CIRCLE);
 
    x = float8_pl_safe(box->high.x, box->low.x, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    circle->center.x = float8_div_safe(x, 2.0, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    y = float8_pl_safe(box->high.y, box->low.y, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    circle->center.y = float8_div_safe(y, 2.0, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    circle->radius = point_dt(&circle->center, &box->high,
                              fcinfo->context);
 
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    PG_RETURN_CIRCLE_P(circle);
 
fail:
    PG_RETURN_NULL();
}

References fb(), float8_div_safe(), float8_pl_safe(), palloc_object, PG_GETARG_BOX_P, PG_RETURN_CIRCLE_P, PG_RETURN_NULL, point_dt(), SOFT_ERROR_OCCURRED, x, and y.

box_closept_lseg()

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

static

Definition at line 3060 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(), fb(), float8_lt(), lseg_closept_lseg(), result, and statlseg_construct().

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 2925 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(), fb(), float8_lt(), lseg_closept_point(), result, and statlseg_construct().

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

box_cn()

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

static

Definition at line 875 of file geo_ops.c.

{
    float8      x;
    float8      y;
 
    x = float8_pl_safe(box->high.x, box->low.x, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
 
    center->x = float8_div_safe(x, 2.0, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
 
    y = float8_pl_safe(box->high.y, box->low.y, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
 
    center->y = float8_div_safe(y, 2.0, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
}

References fb(), float8_div_safe(), float8_pl_safe(), SOFT_ERROR_OCCURRED, x, Point::x, y, 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 519 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 fb(), float8_gt(), and result.

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

box_contain()

Datum box_contain

(

PG_FUNCTION_ARGS

)

Definition at line 693 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(), fb(), 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 705 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 fb(), FPge(), and FPle().

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 3264 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 fb().

Referenced by on_sb().

box_contain_point()

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

static

Definition at line 3177 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 fb().

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 3193 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(), fb(), 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 682 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(), fb(), 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 951 of file geo_ops.c.

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

References fb(), palloc_object, PG_GETARG_BOX_P, PG_RETURN_LSEG_P, result, and statlseg_construct().

box_distance()

Datum box_distance

(

PG_FUNCTION_ARGS

)

Definition at line 833 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, NULL);
    box_cn(&b, box2, NULL);
 
    PG_RETURN_FLOAT8(point_dt(&a, &b, NULL));
}

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

box_div()

Datum box_div

(

PG_FUNCTION_ARGS

)

Definition at line 4336 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 = palloc_object(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(), fb(), palloc_object, PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_BOX_P, point_div_point(), and result.

box_eq()

Datum box_eq

(

PG_FUNCTION_ARGS

)

Definition at line 763 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(), fb(), FPeq(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_ge()

Datum box_ge

(

PG_FUNCTION_ARGS

)

Definition at line 781 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(), fb(), FPge(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_gt()

Datum box_gt

(

PG_FUNCTION_ARGS

)

Definition at line 754 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(), fb(), FPgt(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_height()

Datum box_height

(

PG_FUNCTION_ARGS

)

Definition at line 821 of file geo_ops.c.

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

References box_ht(), fb(), PG_GETARG_BOX_P, and PG_RETURN_FLOAT8.

box_ht()

static float8 box_ht ( BOX *  box )

static

Definition at line 911 of file geo_ops.c.

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

References fb(), and float8_mi().

Referenced by box_ar(), and box_height().

box_in()

Datum box_in

(

PG_FUNCTION_ARGS

)

Definition at line 423 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    BOX        *box = palloc_object(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 fb(), float8_lt(), palloc_object, path_decode(), PG_GETARG_CSTRING, PG_RETURN_BOX_P, PG_RETURN_NULL, str, x, and y.

box_interpt_lseg()

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

static

Definition at line 3310 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, NULL);
        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(), fb(), float8_max(), float8_min(), lseg_closept_point(), lseg_interpt_lseg(), result, statlseg_construct(), and Point::x.

Referenced by box_closept_lseg(), and inter_sb().

box_intersect()

Datum box_intersect

(

PG_FUNCTION_ARGS

)

Definition at line 926 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 = palloc_object(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(), fb(), float8_max(), float8_min(), palloc_object, PG_GETARG_BOX_P, PG_RETURN_BOX_P, PG_RETURN_NULL, and result.

box_le()

Datum box_le

(

PG_FUNCTION_ARGS

)

Definition at line 772 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(), fb(), FPle(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_left()

Datum box_left

(

PG_FUNCTION_ARGS

)

Definition at line 584 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 fb(), FPlt(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

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 745 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(), fb(), FPlt(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

box_mul()

Datum box_mul

(

PG_FUNCTION_ARGS

)

Definition at line 4317 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 = palloc_object(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(), fb(), palloc_object, PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_BOX_P, point_mul_point(), and result.

box_out()

Datum box_out

(

PG_FUNCTION_ARGS

)

Definition at line 456 of file geo_ops.c.

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

References fb(), 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 573 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 fb(), and FPle().

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 671 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 fb(), FPge(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

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 648 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 fb(), FPle(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

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 564 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(), fb(), 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 599 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 fb(), FPle(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

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 625 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 fb(), FPge(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

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 4594 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 box_construct(), fb(), palloc(), PG_GETARG_BOX_P, PG_RETURN_POLYGON_P, and SET_VARSIZE().

box_recv()

Datum box_recv

(

PG_FUNCTION_ARGS

)

Definition at line 467 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    BOX        *box;
    float8      x,
                y;
 
    box = palloc_object(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, fb(), float8_lt(), palloc_object, PG_GETARG_POINTER, PG_RETURN_BOX_P, pq_getmsgfloat8(), x, and y.

box_right()

Datum box_right

(

PG_FUNCTION_ARGS

)

Definition at line 610 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 fb(), FPgt(), PG_GETARG_BOX_P, and PG_RETURN_BOOL.

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 552 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 fb(), 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 502 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, fb(), PG_GETARG_BOX_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendfloat8().

box_sub()

Datum box_sub

(

PG_FUNCTION_ARGS

)

Definition at line 4302 of file geo_ops.c.

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

References fb(), palloc_object, PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_BOX_P, point_sub_point(), and result.

box_wd()

static float8 box_wd ( BOX *  box )

static

Definition at line 901 of file geo_ops.c.

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

References fb(), and float8_mi().

Referenced by box_ar(), and box_width().

box_width()

Datum box_width

(

PG_FUNCTION_ARGS

)

Definition at line 809 of file geo_ops.c.

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

References box_wd(), fb(), PG_GETARG_BOX_P, and PG_RETURN_FLOAT8.

boxes_bound_box()

Datum boxes_bound_box

(

PG_FUNCTION_ARGS

)

Definition at line 4377 of file geo_ops.c.

{
    BOX        *box1 = PG_GETARG_BOX_P(0),
               *box2 = PG_GETARG_BOX_P(1),
               *container;
 
    container = palloc_object(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 fb(), float8_max(), float8_min(), palloc_object, PG_GETARG_BOX_P, and PG_RETURN_BOX_P.

circle_above()

Datum circle_above

(

PG_FUNCTION_ARGS

)

Definition at line 4922 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 fb(), float8_mi(), float8_pl(), FPgt(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_add_pt()

Datum circle_add_pt

(

PG_FUNCTION_ARGS

)

Definition at line 5024 of file geo_ops.c.

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

References fb(), palloc_object, PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, point_add_point(), and result.

circle_ar()

static float8 circle_ar ( CIRCLE *  circle )

static

Definition at line 5218 of file geo_ops.c.

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

References fb(), float8_mul(), and M_PI.

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 5091 of file geo_ops.c.

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

References circle_ar(), fb(), PG_GETARG_CIRCLE_P, and PG_RETURN_FLOAT8.

circle_below()

Datum circle_below

(

PG_FUNCTION_ARGS

)

Definition at line 4910 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 fb(), float8_mi(), float8_pl(), FPlt(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_box()

Datum circle_box

(

PG_FUNCTION_ARGS

)

Definition at line 5245 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    BOX        *box;
    float8      delta;
 
    box = palloc_object(BOX);
 
    delta = float8_div_safe(circle->radius, sqrt(2.0), fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    box->high.x = float8_pl_safe(circle->center.x, delta, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    box->low.x = float8_mi_safe(circle->center.x, delta, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    box->high.y = float8_pl_safe(circle->center.y, delta, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    box->low.y = float8_mi_safe(circle->center.y, delta, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    PG_RETURN_BOX_P(box);
 
fail:
    PG_RETURN_NULL();
}

References fb(), float8_div_safe(), float8_mi_safe(), float8_pl_safe(), palloc_object, PG_GETARG_CIRCLE_P, PG_RETURN_BOX_P, PG_RETURN_NULL, and SOFT_ERROR_OCCURRED.

circle_center()

Datum circle_center

(

PG_FUNCTION_ARGS

)

Definition at line 5202 of file geo_ops.c.

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

References fb(), palloc_object, PG_GETARG_CIRCLE_P, PG_RETURN_POINT_P, and result.

circle_contain()

Datum circle_contain

(

PG_FUNCTION_ARGS

)

Definition at line 4897 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, NULL),
                        float8_mi(circle1->radius, circle2->radius)));
}

References fb(), float8_mi(), FPle(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, and point_dt().

circle_contain_pt()

Datum circle_contain_pt

(

PG_FUNCTION_ARGS

)

Definition at line 5141 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, NULL);
    PG_RETURN_BOOL(d <= circle->radius);
}

References fb(), 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 4885 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, NULL),
                        float8_mi(circle2->radius, circle1->radius)));
}

References fb(), float8_mi(), FPle(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, and point_dt().

circle_diameter()

Datum circle_diameter

(

PG_FUNCTION_ARGS

)

Definition at line 5102 of file geo_ops.c.

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

References fb(), float8_mul(), PG_GETARG_CIRCLE_P, and PG_RETURN_FLOAT8.

circle_distance()

Datum circle_distance

(

PG_FUNCTION_ARGS

)

Definition at line 5125 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, NULL),
                       float8_pl(circle1->radius, circle2->radius));
    if (result < 0.0)
        result = 0.0;
 
    PG_RETURN_FLOAT8(result);
}

References fb(), float8_mi(), float8_pl(), PG_GETARG_CIRCLE_P, PG_RETURN_FLOAT8, point_dt(), and result.

circle_div_pt()

Datum circle_div_pt

(

PG_FUNCTION_ARGS

)

Definition at line 5073 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
    CIRCLE     *result;
 
    result = palloc_object(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 fb(), float8_div(), palloc_object, PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, point_div_point(), and result.

circle_eq()

Datum circle_eq

(

PG_FUNCTION_ARGS

)

Definition at line 4962 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(), fb(), FPeq(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_ge()

Datum circle_ge

(

PG_FUNCTION_ARGS

)

Definition at line 5007 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(), fb(), FPge(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_gt()

Datum circle_gt

(

PG_FUNCTION_ARGS

)

Definition at line 4989 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(), fb(), FPgt(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_in()

Datum circle_in

(

PG_FUNCTION_ARGS

)

Definition at line 4670 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    CIRCLE     *circle = palloc_object(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 DELIM, ereturn, errcode(), errmsg, fb(), LDELIM, LDELIM_C, pair_decode(), palloc_object, PG_GETARG_CSTRING, PG_RETURN_CIRCLE_P, PG_RETURN_NULL, RDELIM, RDELIM_C, single_decode(), and str.

circle_le()

Datum circle_le

(

PG_FUNCTION_ARGS

)

Definition at line 4998 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(), fb(), FPle(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_left()

Datum circle_left

(

PG_FUNCTION_ARGS

)

Definition at line 4848 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 fb(), float8_mi(), float8_pl(), FPlt(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_lt()

Datum circle_lt

(

PG_FUNCTION_ARGS

)

Definition at line 4980 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(), fb(), FPlt(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_mul_pt()

Datum circle_mul_pt

(

PG_FUNCTION_ARGS

)

Definition at line 5058 of file geo_ops.c.

{
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
    Point      *point = PG_GETARG_POINT_P(1);
    CIRCLE     *result;
 
    result = palloc_object(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 fb(), float8_mul(), palloc_object, PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, point_mul_point(), and result.

circle_ne()

Datum circle_ne

(

PG_FUNCTION_ARGS

)

Definition at line 4971 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(), fb(), FPne(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_out()

Datum circle_out

(

PG_FUNCTION_ARGS

)

Definition at line 4740 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(), DELIM, fb(), initStringInfo(), LDELIM, LDELIM_C, pair_encode(), PG_GETARG_CIRCLE_P, PG_RETURN_CSTRING, RDELIM, RDELIM_C, single_encode(), and str.

circle_overabove()

Datum circle_overabove

(

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(float8_mi(circle1->center.y, circle1->radius),
                        float8_mi(circle2->center.y, circle2->radius)));
}

References fb(), float8_mi(), FPge(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_overbelow()

Datum circle_overbelow

(

PG_FUNCTION_ARGS

)

Definition at line 4935 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 fb(), float8_pl(), FPle(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_overlap()

Datum circle_overlap

(

PG_FUNCTION_ARGS

)

Definition at line 4823 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, NULL),
                        float8_pl(circle1->radius, circle2->radius)));
}

References fb(), float8_pl(), FPle(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, and point_dt().

circle_overleft()

Datum circle_overleft

(

PG_FUNCTION_ARGS

)

Definition at line 4836 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 fb(), float8_pl(), FPle(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_overright()

Datum circle_overright

(

PG_FUNCTION_ARGS

)

Definition at line 4873 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 fb(), float8_mi(), FPge(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_poly()

Datum circle_poly

(

PG_FUNCTION_ARGS

)

Definition at line 5387 of file geo_ops.c.

{
    int32       npts = PG_GETARG_INT32(0);
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(1);
 
    PG_RETURN_POLYGON_P(circle_poly_internal(npts, circle, fcinfo));
}

References circle_poly_internal(), fb(), PG_GETARG_CIRCLE_P, PG_GETARG_INT32, and PG_RETURN_POLYGON_P.

circle_poly_internal()

static POLYGON * circle_poly_internal ( int32  npts, const CIRCLE *  circle, FunctionCallInfo  fcinfo  )

static

Definition at line 5322 of file geo_ops.c.

{
    POLYGON    *poly;
    int         base_size,
                size;
    int         i;
    float8      angle;
    float8      anglestep;
 
    if (FPzero(circle->radius))
        ereturn(fcinfo->context, NULL,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot convert circle with radius zero to polygon")));
 
    if (npts < 2)
        ereturn(fcinfo->context, NULL,
                (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)
        ereturn(fcinfo->context, NULL,
                (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++)
    {
        float8      temp;
 
        angle = float8_mul_safe(anglestep, i, fcinfo->context);
        if (SOFT_ERROR_OCCURRED(fcinfo->context))
            return NULL;
 
        temp = float8_mul_safe(circle->radius, cos(angle), fcinfo->context);
        if (SOFT_ERROR_OCCURRED(fcinfo->context))
            return NULL;
 
        poly->p[i].x = float8_mi_safe(circle->center.x, temp, fcinfo->context);
        if (SOFT_ERROR_OCCURRED(fcinfo->context))
            return NULL;
 
        temp = float8_mul_safe(circle->radius, sin(angle), fcinfo->context);
        if (SOFT_ERROR_OCCURRED(fcinfo->context))
            return NULL;
 
        poly->p[i].y = float8_pl_safe(circle->center.y, temp, fcinfo->context);
        if (SOFT_ERROR_OCCURRED(fcinfo->context))
            return NULL;
    }
 
    make_bound_box(poly);
 
    return poly;
}

References FunctionCallInfoBaseData::context, ereturn, errcode(), errmsg, fb(), float8_div(), float8_mi_safe(), float8_mul_safe(), float8_pl_safe(), FPzero, i, M_PI, make_bound_box(), palloc0(), SET_VARSIZE(), and SOFT_ERROR_OCCURRED.

Referenced by circle_poly(), and circle_to_poly().

circle_radius()

Datum circle_radius

(

PG_FUNCTION_ARGS

)

Definition at line 5113 of file geo_ops.c.

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

References fb(), PG_GETARG_CIRCLE_P, and PG_RETURN_FLOAT8.

circle_recv()

Datum circle_recv

(

PG_FUNCTION_ARGS

)

Definition at line 4762 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    CIRCLE     *circle;
 
    circle = palloc_object(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, ereport, errcode(), errmsg, ERROR, fb(), palloc_object, PG_GETARG_POINTER, PG_RETURN_CIRCLE_P, and pq_getmsgfloat8().

circle_right()

Datum circle_right

(

PG_FUNCTION_ARGS

)

Definition at line 4860 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 fb(), float8_mi(), float8_pl(), FPgt(), PG_GETARG_CIRCLE_P, and PG_RETURN_BOOL.

circle_same()

Datum circle_same

(

PG_FUNCTION_ARGS

)

Definition at line 4810 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 fb(), FPeq(), PG_GETARG_CIRCLE_P, PG_RETURN_BOOL, and point_eq_point().

circle_send()

Datum circle_send

(

PG_FUNCTION_ARGS

)

Definition at line 4786 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, fb(), PG_GETARG_CIRCLE_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendfloat8().

circle_sub_pt()

Datum circle_sub_pt

(

PG_FUNCTION_ARGS

)

Definition at line 5039 of file geo_ops.c.

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

References fb(), palloc_object, PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, point_sub_point(), and result.

circle_to_poly()

Datum circle_to_poly

(

PG_FUNCTION_ARGS

)

Definition at line 5397 of file geo_ops.c.

{
    int32       npts = 12;
    CIRCLE     *circle = PG_GETARG_CIRCLE_P(0);
 
    PG_RETURN_POLYGON_P(circle_poly_internal(npts, circle, fcinfo));
}

References circle_poly_internal(), fb(), PG_GETARG_CIRCLE_P, and PG_RETURN_POLYGON_P.

close_ls()

Datum close_ls

(

PG_FUNCTION_ARGS

)

Definition at line 3035 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 = palloc_object(Point);
 
    if (isnan(lseg_closept_line(result, lseg, line)))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References fb(), line_sl(), lseg_closept_line(), lseg_sl(), palloc_object, PG_GETARG_LINE_P, PG_GETARG_LSEG_P, PG_RETURN_NULL, PG_RETURN_POINT_P, and result.

close_lseg()

Datum close_lseg

(

PG_FUNCTION_ARGS

)

Definition at line 2900 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 = palloc_object(Point);
 
    if (isnan(lseg_closept_lseg(result, l2, l1)))
        PG_RETURN_NULL();
 
    PG_RETURN_POINT_P(result);
}

References fb(), lseg_closept_lseg(), lseg_sl(), palloc_object, PG_GETARG_LSEG_P, PG_RETURN_NULL, PG_RETURN_POINT_P, and result.

close_pb()

Datum close_pb

(

PG_FUNCTION_ARGS

)

Definition at line 2980 of file geo_ops.c.

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

References box_closept_point(), fb(), palloc_object, PG_GETARG_BOX_P, PG_GETARG_POINT_P, PG_RETURN_NULL, PG_RETURN_POINT_P, and result.

close_pl()

Datum close_pl

(

PG_FUNCTION_ARGS

)

Definition at line 2797 of file geo_ops.c.

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

References fb(), line_closept_point(), palloc_object, PG_GETARG_LINE_P, PG_GETARG_POINT_P, PG_RETURN_NULL, PG_RETURN_POINT_P, and result.

close_ps()

Datum close_ps

(

PG_FUNCTION_ARGS

)

Definition at line 2838 of file geo_ops.c.

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

References fb(), lseg_closept_point(), palloc_object, PG_GETARG_LSEG_P, PG_GETARG_POINT_P, PG_RETURN_NULL, PG_RETURN_POINT_P, and result.

close_sb()

Datum close_sb

(

PG_FUNCTION_ARGS

)

Definition at line 3110 of file geo_ops.c.

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

References box_closept_lseg(), fb(), palloc_object, PG_GETARG_BOX_P, PG_GETARG_LSEG_P, PG_RETURN_NULL, PG_RETURN_POINT_P, and result.

construct_point()

Datum construct_point

(

PG_FUNCTION_ARGS

)

Definition at line 4143 of file geo_ops.c.

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

References palloc_object, PG_GETARG_FLOAT8, PG_RETURN_POINT_P, point_construct(), result, x, and y.

cr_circle()

Datum cr_circle

(

PG_FUNCTION_ARGS

)

Definition at line 5229 of file geo_ops.c.

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

References palloc_object, PG_GETARG_FLOAT8, PG_GETARG_POINT_P, PG_RETURN_CIRCLE_P, result, Point::x, and Point::y.

dist_bp()

Datum dist_bp

(

PG_FUNCTION_ARGS

)

Definition at line 2561 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(), fb(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_bs()

Datum dist_bs

(

PG_FUNCTION_ARGS

)

Definition at line 2609 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(), fb(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, and PG_RETURN_FLOAT8.

dist_cpoint()

Datum dist_cpoint

(

PG_FUNCTION_ARGS

)

Definition at line 5186 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, NULL), circle->radius);
    if (result < 0.0)
        result = 0.0;
 
    PG_RETURN_FLOAT8(result);
}

References fb(), float8_mi(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_FLOAT8, point_dt(), and result.

dist_cpoly()

Datum dist_cpoly

(

PG_FUNCTION_ARGS

)

Definition at line 2635 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(), fb(), 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 2618 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 dist_ppoly_internal(), fb(), float8_mi(), and result.

Referenced by dist_cpoly(), and dist_polyc().

dist_lp()

Datum dist_lp

(

PG_FUNCTION_ARGS

)

Definition at line 2449 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 fb(), 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 2585 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 fb(), 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 2537 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(), fb(), PG_GETARG_PATH_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_pb()

Datum dist_pb

(

PG_FUNCTION_ARGS

)

Definition at line 2549 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(), fb(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, and PG_RETURN_FLOAT8.

dist_pc()

Datum dist_pc

(

PG_FUNCTION_ARGS

)

Definition at line 5168 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, NULL),
                       circle->radius);
    if (result < 0.0)
        result = 0.0;
 
    PG_RETURN_FLOAT8(result);
}

References fb(), float8_mi(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_FLOAT8, point_dt(), and result.

dist_pl()

Datum dist_pl

(

PG_FUNCTION_ARGS

)

Definition at line 2437 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 fb(), 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 2647 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(), fb(), PG_GETARG_CIRCLE_P, PG_GETARG_POLYGON_P, and PG_RETURN_FLOAT8.

dist_polyp()

Datum dist_polyp

(

PG_FUNCTION_ARGS

)

Definition at line 2668 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(), fb(), PG_GETARG_POINT_P, PG_GETARG_POLYGON_P, and PG_RETURN_FLOAT8.

dist_ppath()

Datum dist_ppath

(

PG_FUNCTION_ARGS

)

Definition at line 2525 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(), fb(), 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 2482 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, fb(), float8_lt(), i, lseg_closept_point(), PATH::npts, PATH::p, result, and statlseg_construct().

Referenced by dist_pathp(), and dist_ppath().

dist_ppoly()

Datum dist_ppoly

(

PG_FUNCTION_ARGS

)

Definition at line 2659 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(), fb(), 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 2677 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 fb(), float8_lt(), i, lseg_closept_point(), LSEG::p, point_inside(), result, 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 2461 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 fb(), 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 2597 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(), fb(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, and PG_RETURN_FLOAT8.

dist_sl()

Datum dist_sl

(

PG_FUNCTION_ARGS

)

Definition at line 2573 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 fb(), 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 2473 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 fb(), 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 3375 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 fb(), lseg_interpt_line(), PG_GETARG_BOX_P, PG_GETARG_LINE_P, PG_RETURN_BOOL, statlseg_construct(), and Point::x.

inter_sb()

Datum inter_sb

(

PG_FUNCTION_ARGS

)

Definition at line 3362 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(), fb(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

inter_sl()

Datum inter_sl

(

PG_FUNCTION_ARGS

)

Definition at line 3285 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 fb(), 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 2771 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, NULL);
}

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

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 1101 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 fb(), float8_mi(), float8_mul(), and result.

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 1133 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
    LINE       *result = palloc_object(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, fb(), line_construct(), palloc_object, PG_GETARG_POINT_P, PG_RETURN_LINE_P, point_eq_point(), point_sl(), and result.

line_contain_point()

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

static

Definition at line 3134 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, fb(), float8_mul(), float8_pl(), and FPzero.

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 968 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, fb(), RDELIM_L, single_decode(), and str.

Referenced by line_in().

line_distance()

Datum line_distance

(

PG_FUNCTION_ARGS

)

Definition at line 1279 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, fb(), float8_div(), float8_mi(), float8_mul(), FPzero, line_interpt_line(), PG_GETARG_LINE_P, and PG_RETURN_FLOAT8.

line_eq()

Datum line_eq

(

PG_FUNCTION_ARGS

)

Definition at line 1212 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, fb(), 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 1200 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 997 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    LINE       *line = palloc_object(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, fb(), FPzero, LDELIM_L, line_construct(), line_decode(), lseg_sl(), palloc_object, 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 1304 of file geo_ops.c.

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

References line_interpt_line(), palloc_object, PG_GETARG_LINE_P, PG_RETURN_NULL, PG_RETURN_POINT_P, and result.

line_interpt_line()

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

static

Definition at line 1332 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, fb(), float8_div(), float8_mi(), float8_mul(), float8_pl(), FPeq(), FPzero, point_construct(), result, 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 1155 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 fb(), line_interpt_line(), PG_GETARG_LINE_P, and PG_RETURN_BOOL.

line_invsl()

static float8 line_invsl ( LINE *  line )

inlinestatic

Definition at line 1265 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 1041 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, fb(), 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 1164 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 fb(), line_interpt_line(), PG_GETARG_LINE_P, and PG_RETURN_BOOL.

line_perp()

Datum line_perp

(

PG_FUNCTION_ARGS

)

Definition at line 1173 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 1056 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    LINE       *line;
 
    line = palloc_object(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, fb(), FPzero, palloc_object, PG_GETARG_POINTER, PG_RETURN_LINE_P, and pq_getmsgfloat8().

line_send()

Datum line_send

(

PG_FUNCTION_ARGS

)

Definition at line 1079 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 1251 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 1192 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 2345 of file geo_ops.c.

{
    LSEG       *lseg = PG_GETARG_LSEG_P(0);
    Point      *result;
    float8      x;
    float8      y;
 
    result = palloc_object(Point);
 
    x = float8_pl_safe(lseg->p[0].x, lseg->p[1].x, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    result->x = float8_div_safe(x, 2.0, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    y = float8_pl_safe(lseg->p[0].y, lseg->p[1].y, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    result->y = float8_div_safe(y, 2.0, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        goto fail;
 
    PG_RETURN_POINT_P(result);
 
fail:
    PG_RETURN_NULL();
}

References fb(), float8_div_safe(), float8_pl_safe(), palloc_object, PG_GETARG_LSEG_P, PG_RETURN_NULL, PG_RETURN_POINT_P, result, SOFT_ERROR_OCCURRED, x, and y.

lseg_closept_line()

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

static

Definition at line 3007 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 fb(), line_closept_point(), lseg_interpt_line(), and result.

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 2857 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 fb(), float8_lt(), lseg_closept_point(), lseg_interpt_lseg(), and result.

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 2819 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, NULL);
}

References fb(), line_construct(), lseg_closept_line(), point_dt(), point_invsl(), and result.

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 2158 of file geo_ops.c.

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

References fb(), palloc_object, PG_GETARG_POINT_P, PG_RETURN_LSEG_P, result, and statlseg_construct().

lseg_contain_point()

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

static

Definition at line 3156 of file geo_ops.c.

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

References fb(), FPeq(), 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 5549 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 fb(), 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 2335 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 fb(), lseg_closept_lseg(), PG_GETARG_LSEG_P, and PG_RETURN_FLOAT8.

lseg_eq()

Datum lseg_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2265 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 2315 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], NULL),
                        point_dt(&l2->p[0], &l2->p[1], NULL)));
}

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

lseg_gt()

Datum lseg_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2305 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], NULL),
                        point_dt(&l2->p[0], &l2->p[1], NULL)));
}

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

lseg_horizontal()

Datum lseg_horizontal

(

PG_FUNCTION_ARGS

)

Definition at line 2256 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 fb(), FPeq(), PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

lseg_in()

Datum lseg_in

(

PG_FUNCTION_ARGS

)

Definition at line 2094 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    LSEG       *lseg = palloc_object(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 fb(), palloc_object, 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 3913 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(), fb(), float8_div(), float8_pl(), i, lseg_contain_point(), lseg_inside_poly(), lseg_interpt_lseg(), LSEG::p, point_inside(), 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 2408 of file geo_ops.c.

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

References lseg_interpt_lseg(), palloc_object, PG_GETARG_LSEG_P, PG_RETURN_NULL, PG_RETURN_POINT_P, and result.

Referenced by interpt_pp().

lseg_interpt_line()

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

static

Definition at line 2722 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 fb(), line_construct(), line_interpt_line(), lseg_contain_point(), lseg_sl(), point_eq_point(), and result.

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 2385 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 fb(), line_construct(), lseg_contain_point(), lseg_interpt_line(), lseg_sl(), LSEG::p, and result.

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 2217 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 fb(), 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 2194 of file geo_ops.c.

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

References fb(), and point_invsl().

Referenced by lseg_perp().

lseg_le()

Datum lseg_le

(

PG_FUNCTION_ARGS

)

Definition at line 2295 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], NULL),
                        point_dt(&l2->p[0], &l2->p[1], NULL)));
}

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

lseg_length()

Datum lseg_length

(

PG_FUNCTION_ARGS

)

Definition at line 2201 of file geo_ops.c.

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

References fb(), PG_GETARG_LSEG_P, PG_RETURN_FLOAT8, and point_dt().

lseg_lt()

Datum lseg_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2285 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], NULL),
                        point_dt(&l2->p[0], &l2->p[1], NULL)));
}

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

lseg_ne()

Datum lseg_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2275 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 2110 of file geo_ops.c.

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

References fb(), path_encode(), PATH_OPEN, PG_GETARG_LSEG_P, and PG_RETURN_CSTRING.

lseg_parallel()

Datum lseg_parallel

(

PG_FUNCTION_ARGS

)

Definition at line 2227 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 2239 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 2121 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    LSEG       *lseg;
 
    lseg = palloc_object(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, fb(), palloc_object, PG_GETARG_POINTER, PG_RETURN_LSEG_P, and pq_getmsgfloat8().

lseg_send()

Datum lseg_send

(

PG_FUNCTION_ARGS

)

Definition at line 2140 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, fb(), PG_GETARG_LSEG_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendfloat8().

lseg_sl()

static float8 lseg_sl ( LSEG *  lseg )

inlinestatic

Definition at line 2184 of file geo_ops.c.

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

References fb(), 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 2248 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 fb(), FPeq(), PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

make_bound_box()

static void make_bound_box ( POLYGON *  poly )

static

Definition at line 3423 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, fb(), float8_gt(), float8_lt(), and i.

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

on_pb()

Datum on_pb

(

PG_FUNCTION_ARGS

)

Definition at line 3184 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(), fb(), PG_GETARG_BOX_P, PG_GETARG_POINT_P, and PG_RETURN_BOOL.

on_pl()

Datum on_pl

(

PG_FUNCTION_ARGS

)

Definition at line 3142 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 fb(), 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 3213 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], NULL);
        for (i = 0; i < n; i++)
        {
            b = point_dt(pt, &path->p[i + 1], NULL);
            if (FPeq(float8_pl(a, b), point_dt(&path->p[i], &path->p[i + 1], NULL)))
                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, fb(), 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 3164 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 fb(), 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 3271 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(), fb(), PG_GETARG_BOX_P, PG_GETARG_LSEG_P, and PG_RETURN_BOOL.

on_sl()

Datum on_sl

(

PG_FUNCTION_ARGS

)

Definition at line 3248 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 fb(), line_contain_point(), 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 393 of file geo_ops.c.

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

References fb().

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 213 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, fb(), 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 256 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(), fb(), 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 4404 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 ereport, errcode(), errmsg, ERROR, fb(), i, palloc(), PG_GETARG_PATH_P, PG_RETURN_NULL, PG_RETURN_PATH_P, result, and SET_VARSIZE().

path_add_pt()

Datum path_add_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4452 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, NULL);
 
    PG_RETURN_PATH_P(path);
}

References fb(), 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 1398 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, fb(), 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 1645 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 267 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, fb(), 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 1748 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 fb(), float8_lt(), i, j, lseg_closept_lseg(), 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 4494 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 fb(), 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 341 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, fb(), i, initStringInfo(), LDELIM, LDELIM_EP, pair_encode(), PATH_CLOSED, PATH_NONE, PATH_OPEN, RDELIM, RDELIM_EP, and str.

path_in()

Datum path_in

(

PG_FUNCTION_ARGS

)

Definition at line 1420 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, fb(), LDELIM, PATH::npts, PATH::p, pair_count(), palloc(), path_decode(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_PATH_P, RDELIM, SET_VARSIZE(), and str.

path_inter()

Datum path_inter

(

PG_FUNCTION_ARGS

)

Definition at line 1671 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(), fb(), float8_max(), float8_min(), i, j, lseg_interpt_lseg(), PG_GETARG_PATH_P, PG_RETURN_BOOL, and statlseg_construct().

path_isclosed()

Datum path_isclosed

(

PG_FUNCTION_ARGS

)

Definition at line 1620 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 1628 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 1810 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], NULL));
    }
 
    PG_RETURN_FLOAT8(result);
}

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

path_mul_pt()

Datum path_mul_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4481 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_mul_point(&path->p[i], &path->p[i], point);
 
    PG_RETURN_PATH_P(path);
}

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

path_n_eq()

Datum path_n_eq

(

PG_FUNCTION_ARGS

)

Definition at line 1589 of file geo_ops.c.

{
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
 
    PG_RETURN_BOOL(p1->npts == p2->npts);
}

References fb(), PG_GETARG_PATH_P, and PG_RETURN_BOOL.

path_n_ge()

Datum path_n_ge

(

PG_FUNCTION_ARGS

)

Definition at line 1607 of file geo_ops.c.

{
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
 
    PG_RETURN_BOOL(p1->npts >= p2->npts);
}

References fb(), PG_GETARG_PATH_P, and PG_RETURN_BOOL.

path_n_gt()

Datum path_n_gt

(

PG_FUNCTION_ARGS

)

Definition at line 1580 of file geo_ops.c.

{
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
 
    PG_RETURN_BOOL(p1->npts > p2->npts);
}

References fb(), PG_GETARG_PATH_P, and PG_RETURN_BOOL.

path_n_le()

Datum path_n_le

(

PG_FUNCTION_ARGS

)

Definition at line 1598 of file geo_ops.c.

{
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
 
    PG_RETURN_BOOL(p1->npts <= p2->npts);
}

References fb(), PG_GETARG_PATH_P, and PG_RETURN_BOOL.

path_n_lt()

Datum path_n_lt

(

PG_FUNCTION_ARGS

)

Definition at line 1571 of file geo_ops.c.

{
    PATH       *p1 = PG_GETARG_PATH_P(0);
    PATH       *p2 = PG_GETARG_PATH_P(1);
 
    PG_RETURN_BOOL(p1->npts < p2->npts);
}

References fb(), PG_GETARG_PATH_P, and PG_RETURN_BOOL.

path_npoints()

Datum path_npoints

(

PG_FUNCTION_ARGS

)

Definition at line 1636 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
 
    PG_RETURN_INT32(path->npts);
}

References PATH::npts, PG_GETARG_PATH_P, and PG_RETURN_INT32.

path_open()

Datum path_open

(

PG_FUNCTION_ARGS

)

Definition at line 1655 of file geo_ops.c.

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

References PATH::closed, PG_GETARG_PATH_P_COPY, and PG_RETURN_PATH_P.

path_out()

Datum path_out

(

PG_FUNCTION_ARGS

)

Definition at line 1492 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
 
    PG_RETURN_CSTRING(path_encode(path->closed ? PATH_CLOSED : PATH_OPEN, path->npts, path->p));
}

References PATH::closed, PATH::npts, PATH::p, PATH_CLOSED, path_encode(), PATH_OPEN, PG_GETARG_PATH_P, and PG_RETURN_CSTRING.

path_poly()

Datum path_poly

(

PG_FUNCTION_ARGS

)

Definition at line 4508 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
    POLYGON    *poly;
    int         size;
    int         i;
 
    /* This is not very consistent --- other similar cases return NULL ... */
    if (!path->closed)
        ereturn(fcinfo->context, (Datum) 0,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("open path cannot be converted to polygon")));
 
    /*
     * Never overflows: the old size fit in MaxAllocSize, and the new size is
     * just a small constant larger.
     */
    size = offsetof(POLYGON, p) + sizeof(poly->p[0]) * path->npts;
    poly = (POLYGON *) palloc(size);
 
    SET_VARSIZE(poly, size);
    poly->npts = path->npts;
 
    for (i = 0; i < path->npts; i++)
    {
        poly->p[i].x = path->p[i].x;
        poly->p[i].y = path->p[i].y;
    }
 
    make_bound_box(poly);
 
    PG_RETURN_POLYGON_P(poly);
}

References PATH::closed, ereturn, errcode(), errmsg, fb(), i, make_bound_box(), PATH::npts, PATH::p, palloc(), PG_GETARG_PATH_P, PG_RETURN_POLYGON_P, SET_VARSIZE(), Point::x, and Point::y.

path_recv()

Datum path_recv

(

PG_FUNCTION_ARGS

)

Definition at line 1506 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    PATH       *path;
    int         closed;
    int32       npts;
    int32       i;
    int         size;
 
    closed = pq_getmsgbyte(buf);
    npts = pq_getmsgint(buf, sizeof(int32));
    if (npts <= 0 || npts >= (int32) ((INT_MAX - offsetof(PATH, p)) / sizeof(Point)))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid number of points in external \"path\" value")));
 
    size = offsetof(PATH, p) + sizeof(path->p[0]) * npts;
    path = (PATH *) palloc(size);
 
    SET_VARSIZE(path, size);
    path->npts = npts;
    path->closed = (closed ? 1 : 0);
    /* prevent instability in unused pad bytes */
    path->dummy = 0;
 
    for (i = 0; i < npts; i++)
    {
        path->p[i].x = pq_getmsgfloat8(buf);
        path->p[i].y = pq_getmsgfloat8(buf);
    }
 
    PG_RETURN_PATH_P(path);
}

References buf, PATH::closed, PATH::dummy, ereport, errcode(), errmsg, ERROR, fb(), i, PATH::npts, PATH::p, palloc(), PG_GETARG_POINTER, PG_RETURN_PATH_P, pq_getmsgbyte(), pq_getmsgfloat8(), pq_getmsgint(), SET_VARSIZE(), Point::x, and Point::y.

path_send()

Datum path_send

(

PG_FUNCTION_ARGS

)

Definition at line 1544 of file geo_ops.c.

{
    PATH       *path = PG_GETARG_PATH_P(0);
    StringInfoData buf;
    int32       i;
 
    pq_begintypsend(&buf);
    pq_sendbyte(&buf, path->closed ? 1 : 0);
    pq_sendint32(&buf, path->npts);
    for (i = 0; i < path->npts; i++)
    {
        pq_sendfloat8(&buf, path->p[i].x);
        pq_sendfloat8(&buf, path->p[i].y);
    }
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, PATH::closed, i, PATH::npts, PATH::p, PG_GETARG_PATH_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbyte(), pq_sendfloat8(), pq_sendint32(), Point::x, and Point::y.

path_sub_pt()

Datum path_sub_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4465 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_sub_point(&path->p[i], &path->p[i], point);
 
    PG_RETURN_PATH_P(path);
}

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

plist_same()

static bool plist_same ( int  npts, Point *  p1, Point *  p2  )

static

Definition at line 5609 of file geo_ops.c.

{
    int         i,
                ii,
                j;
 
    /* find match for first point */
    for (i = 0; i < npts; i++)
    {
        if (point_eq_point(&p2[i], &p1[0]))
        {
 
            /* match found? then look forward through remaining points */
            for (ii = 1, j = i + 1; ii < npts; ii++, j++)
            {
                if (j >= npts)
                    j = 0;
                if (!point_eq_point(&p2[j], &p1[ii]))
                    break;
            }
            if (ii == npts)
                return true;
 
            /* match not found forwards? then look backwards */
            for (ii = 1, j = i - 1; ii < npts; ii++, j--)
            {
                if (j < 0)
                    j = (npts - 1);
                if (!point_eq_point(&p2[j], &p1[ii]))
                    break;
            }
            if (ii == npts)
                return true;
        }
    }
 
    return false;
}

References fb(), i, j, and point_eq_point().

Referenced by poly_same().

point_above()

Datum point_above

(

PG_FUNCTION_ARGS

)

Definition at line 1937 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(FPgt(pt1->y, pt2->y));
}

References fb(), FPgt(), PG_GETARG_POINT_P, and PG_RETURN_BOOL.

Referenced by getQuadrant(), spg_quad_inner_consistent(), and spg_quad_leaf_consistent().

point_add()

Datum point_add

(

PG_FUNCTION_ARGS

)

Definition at line 4175 of file geo_ops.c.

{
    Point      *p1 = PG_GETARG_POINT_P(0);
    Point      *p2 = PG_GETARG_POINT_P(1);
    Point      *result;
 
    result = palloc_object(Point);
 
    point_add_point(result, p1, p2, NULL);
 
    PG_RETURN_POINT_P(result);
}

References fb(), palloc_object, PG_GETARG_POINT_P, PG_RETURN_POINT_P, point_add_point(), and result.

point_add_point()

static void point_add_point ( Point *  result, Point *  pt1, Point *  pt2, Node *  escontext  )

inlinestatic

Definition at line 4158 of file geo_ops.c.

{
    float8      x;
    float8      y;
 
    x = float8_pl_safe(pt1->x, pt2->x, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
 
    y = float8_pl_safe(pt1->y, pt2->y, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
 
    point_construct(result, x, y);
}

References fb(), float8_pl_safe(), point_construct(), result, SOFT_ERROR_OCCURRED, x, and y.

Referenced by box_add(), circle_add_pt(), path_add_pt(), point_add(), and poly_to_circle().

point_below()

Datum point_below

(

PG_FUNCTION_ARGS

)

Definition at line 1946 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(FPlt(pt1->y, pt2->y));
}

References fb(), FPlt(), PG_GETARG_POINT_P, and PG_RETURN_BOOL.

Referenced by getQuadrant(), spg_quad_inner_consistent(), and spg_quad_leaf_consistent().

point_box()

Datum point_box

(

PG_FUNCTION_ARGS

)

Definition at line 4358 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    BOX        *box;
 
    box = palloc_object(BOX);
 
    box->high.x = pt->x;
    box->low.x = pt->x;
    box->high.y = pt->y;
    box->low.y = pt->y;
 
    PG_RETURN_BOX_P(box);
}

References fb(), palloc_object, PG_GETARG_POINT_P, and PG_RETURN_BOX_P.

point_construct()

static void point_construct ( Point *  result, float8  x, float8  y  )

inlinestatic

Definition at line 1902 of file geo_ops.c.

{
    result->x = x;
    result->y = y;
}

References result, x, and y.

Referenced by construct_point(), line_interpt_line(), point_add_point(), point_div_point(), point_mul_point(), and point_sub_point().

point_distance()

Datum point_distance

(

PG_FUNCTION_ARGS

)

Definition at line 2011 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_FLOAT8(point_dt(pt1, pt2, NULL));
}

References fb(), PG_GETARG_POINT_P, PG_RETURN_FLOAT8, and point_dt().

Referenced by pt_in_widget().

point_div()

Datum point_div

(

PG_FUNCTION_ARGS

)

Definition at line 4252 of file geo_ops.c.

{
    Point      *p1 = PG_GETARG_POINT_P(0);
    Point      *p2 = PG_GETARG_POINT_P(1);
    Point      *result;
 
    result = palloc_object(Point);
 
    point_div_point(result, p1, p2);
 
    PG_RETURN_POINT_P(result);
}

References fb(), palloc_object, PG_GETARG_POINT_P, PG_RETURN_POINT_P, point_div_point(), and result.

point_div_point()

static void point_div_point ( Point *  result, Point *  pt1, Point *  pt2  )

inlinestatic

Definition at line 4238 of file geo_ops.c.

{
    float8      div;
 
    div = float8_pl(float8_mul(pt2->x, pt2->x), float8_mul(pt2->y, pt2->y));
 
    point_construct(result,
                    float8_div(float8_pl(float8_mul(pt1->x, pt2->x),
                                         float8_mul(pt1->y, pt2->y)), div),
                    float8_div(float8_mi(float8_mul(pt1->y, pt2->x),
                                         float8_mul(pt1->x, pt2->y)), div));
}

References fb(), float8_div(), float8_mi(), float8_mul(), float8_pl(), point_construct(), and result.

Referenced by box_div(), circle_div_pt(), path_div_pt(), and point_div().

point_dt()

static float8 point_dt ( Point *  pt1, Point *  pt2, Node *  escontext  )

inlinestatic

Definition at line 2020 of file geo_ops.c.

{
    float8      x;
    float8      y;
 
    x = float8_mi_safe(pt1->x, pt2->x, escontext);
    if (unlikely(SOFT_ERROR_OCCURRED(escontext)))
        return 0.0;
 
    y = float8_mi_safe(pt1->y, pt2->y, escontext);
    if (unlikely(SOFT_ERROR_OCCURRED(escontext)))
        return 0.0;
 
    return hypot(x, y);
}

References fb(), float8_mi_safe(), SOFT_ERROR_OCCURRED, unlikely, x, and y.

Referenced by box_circle(), box_distance(), circle_contain(), circle_contain_pt(), circle_contained(), circle_distance(), circle_overlap(), dist_cpoint(), dist_pc(), line_closept_point(), lseg_closept_point(), lseg_contain_point(), lseg_ge(), lseg_gt(), lseg_le(), lseg_length(), lseg_lt(), on_ppath(), path_length(), point_distance(), poly_to_circle(), and pt_contained_circle().

point_eq()

Datum point_eq

(

PG_FUNCTION_ARGS

)

Definition at line 1973 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(point_eq_point(pt1, pt2));
}

References fb(), PG_GETARG_POINT_P, PG_RETURN_BOOL, and point_eq_point().

Referenced by spg_quad_leaf_consistent().

point_eq_point()

static bool point_eq_point ( Point *  pt1, Point *  pt2  )

inlinestatic

Definition at line 1995 of file geo_ops.c.

{
    /* If any NaNs are involved, insist on exact equality */
    if (unlikely(isnan(pt1->x) || isnan(pt1->y) ||
                 isnan(pt2->x) || isnan(pt2->y)))
        return (float8_eq(pt1->x, pt2->x) && float8_eq(pt1->y, pt2->y));
 
    return (FPeq(pt1->x, pt2->x) && FPeq(pt1->y, pt2->y));
}

References fb(), float8_eq(), FPeq(), and unlikely.

Referenced by box_same(), circle_same(), line_construct_pp(), line_in(), lseg_eq(), lseg_interpt_line(), lseg_ne(), plist_same(), point_eq(), point_ne(), and touched_lseg_inside_poly().

point_horiz()

Datum point_horiz

(

PG_FUNCTION_ARGS

)

Definition at line 1964 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(FPeq(pt1->y, pt2->y));
}

References fb(), FPeq(), PG_GETARG_POINT_P, and PG_RETURN_BOOL.

Referenced by getQuadrant().

point_in()

Datum point_in

(

PG_FUNCTION_ARGS

)

Definition at line 1849 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Point      *point = palloc_object(Point);
 
    /* Ignore failure from pair_decode, since our return value won't matter */
    pair_decode(str, &point->x, &point->y, NULL, "point", str, fcinfo->context);
    PG_RETURN_POINT_P(point);
}

References fb(), pair_decode(), palloc_object, PG_GETARG_CSTRING, PG_RETURN_POINT_P, and str.

point_inside()

static int point_inside ( Point *  p, int  npts, Point *  plist  )

static

Definition at line 5492 of file geo_ops.c.

{
    float8      x0,
                y0;
    float8      prev_x,
                prev_y;
    int         i = 0;
    float8      x,
                y;
    int         cross,
                total_cross = 0;
 
    Assert(npts > 0);
 
    /* compute first polygon point relative to single point */
    x0 = float8_mi(plist[0].x, p->x);
    y0 = float8_mi(plist[0].y, p->y);
 
    prev_x = x0;
    prev_y = y0;
    /* loop over polygon points and aggregate total_cross */
    for (i = 1; i < npts; i++)
    {
        /* compute next polygon point relative to single point */
        x = float8_mi(plist[i].x, p->x);
        y = float8_mi(plist[i].y, p->y);
 
        /* compute previous to current point crossing */
        if ((cross = lseg_crossing(x, y, prev_x, prev_y)) == POINT_ON_POLYGON)
            return 2;
        total_cross += cross;
 
        prev_x = x;
        prev_y = y;
    }
 
    /* now do the first point */
    if ((cross = lseg_crossing(x0, y0, prev_x, prev_y)) == POINT_ON_POLYGON)
        return 2;
    total_cross += cross;
 
    if (total_cross != 0)
        return 1;
    return 0;
}

References Assert, fb(), float8_mi(), i, lseg_crossing(), POINT_ON_POLYGON, x, Point::x, y, and Point::y.

Referenced by dist_ppoly_internal(), lseg_inside_poly(), on_ppath(), poly_contain_pt(), poly_overlap_internal(), and pt_contained_poly().

point_invsl()

static float8 point_invsl ( Point *  pt1, Point *  pt2  )

inlinestatic

Definition at line 2068 of file geo_ops.c.

{
    if (FPeq(pt1->x, pt2->x))
        return 0.0;
    if (FPeq(pt1->y, pt2->y))
        return get_float8_infinity();
    return float8_div(float8_mi(pt1->x, pt2->x), float8_mi(pt2->y, pt1->y));
}

References fb(), float8_div(), float8_mi(), FPeq(), and get_float8_infinity().

Referenced by lseg_closept_point(), and lseg_invsl().

point_left()

Datum point_left

(

PG_FUNCTION_ARGS

)

Definition at line 1919 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(FPlt(pt1->x, pt2->x));
}

References fb(), FPlt(), PG_GETARG_POINT_P, and PG_RETURN_BOOL.

Referenced by getQuadrant(), spg_quad_inner_consistent(), and spg_quad_leaf_consistent().

point_mul()

Datum point_mul

(

PG_FUNCTION_ARGS

)

Definition at line 4223 of file geo_ops.c.

{
    Point      *p1 = PG_GETARG_POINT_P(0);
    Point      *p2 = PG_GETARG_POINT_P(1);
    Point      *result;
 
    result = palloc_object(Point);
 
    point_mul_point(result, p1, p2);
 
    PG_RETURN_POINT_P(result);
}

References fb(), palloc_object, PG_GETARG_POINT_P, PG_RETURN_POINT_P, point_mul_point(), and result.

point_mul_point()

static void point_mul_point ( Point *  result, Point *  pt1, Point *  pt2  )

inlinestatic

Definition at line 4213 of file geo_ops.c.

{
    point_construct(result,
                    float8_mi(float8_mul(pt1->x, pt2->x),
                              float8_mul(pt1->y, pt2->y)),
                    float8_pl(float8_mul(pt1->x, pt2->y),
                              float8_mul(pt1->y, pt2->x)));
}

References fb(), float8_mi(), float8_mul(), float8_pl(), point_construct(), and result.

Referenced by box_mul(), circle_mul_pt(), path_mul_pt(), and point_mul().

point_ne()

Datum point_ne

(

PG_FUNCTION_ARGS

)

Definition at line 1982 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(!point_eq_point(pt1, pt2));
}

References fb(), PG_GETARG_POINT_P, PG_RETURN_BOOL, and point_eq_point().

point_out()

Datum point_out

(

PG_FUNCTION_ARGS

)

Definition at line 1860 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
 
    PG_RETURN_CSTRING(path_encode(PATH_NONE, 1, pt));
}

References fb(), path_encode(), PATH_NONE, PG_GETARG_POINT_P, and PG_RETURN_CSTRING.

point_recv()

Datum point_recv

(

PG_FUNCTION_ARGS

)

Definition at line 1871 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    Point      *point;
 
    point = palloc_object(Point);
    point->x = pq_getmsgfloat8(buf);
    point->y = pq_getmsgfloat8(buf);
    PG_RETURN_POINT_P(point);
}

References buf, fb(), palloc_object, PG_GETARG_POINTER, PG_RETURN_POINT_P, and pq_getmsgfloat8().

point_right()

Datum point_right

(

PG_FUNCTION_ARGS

)

Definition at line 1928 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(FPgt(pt1->x, pt2->x));
}

References fb(), FPgt(), PG_GETARG_POINT_P, and PG_RETURN_BOOL.

Referenced by getQuadrant(), spg_quad_inner_consistent(), and spg_quad_leaf_consistent().

point_send()

Datum point_send

(

PG_FUNCTION_ARGS

)

Definition at line 1886 of file geo_ops.c.

{
    Point      *pt = PG_GETARG_POINT_P(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendfloat8(&buf, pt->x);
    pq_sendfloat8(&buf, pt->y);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, fb(), PG_GETARG_POINT_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendfloat8().

point_sl()

static float8 point_sl ( Point *  pt1, Point *  pt2  )

inlinestatic

Definition at line 2052 of file geo_ops.c.

{
    if (FPeq(pt1->x, pt2->x))
        return get_float8_infinity();
    if (FPeq(pt1->y, pt2->y))
        return 0.0;
    return float8_div(float8_mi(pt1->y, pt2->y), float8_mi(pt1->x, pt2->x));
}

References fb(), float8_div(), float8_mi(), FPeq(), and get_float8_infinity().

Referenced by line_construct_pp(), lseg_sl(), and point_slope().

point_slope()

Datum point_slope

(

PG_FUNCTION_ARGS

)

Definition at line 2037 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_FLOAT8(point_sl(pt1, pt2));
}

References fb(), PG_GETARG_POINT_P, PG_RETURN_FLOAT8, and point_sl().

point_sub()

Datum point_sub

(

PG_FUNCTION_ARGS

)

Definition at line 4198 of file geo_ops.c.

{
    Point      *p1 = PG_GETARG_POINT_P(0);
    Point      *p2 = PG_GETARG_POINT_P(1);
    Point      *result;
 
    result = palloc_object(Point);
 
    point_sub_point(result, p1, p2);
 
    PG_RETURN_POINT_P(result);
}

References fb(), palloc_object, PG_GETARG_POINT_P, PG_RETURN_POINT_P, point_sub_point(), and result.

point_sub_point()

static void point_sub_point ( Point *  result, Point *  pt1, Point *  pt2  )

inlinestatic

Definition at line 4190 of file geo_ops.c.

{
    point_construct(result,
                    float8_mi(pt1->x, pt2->x),
                    float8_mi(pt1->y, pt2->y));
}

References fb(), float8_mi(), point_construct(), and result.

Referenced by box_sub(), circle_sub_pt(), path_sub_pt(), and point_sub().

point_vert()

Datum point_vert

(

PG_FUNCTION_ARGS

)

Definition at line 1955 of file geo_ops.c.

{
    Point      *pt1 = PG_GETARG_POINT_P(0);
    Point      *pt2 = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(FPeq(pt1->x, pt2->x));
}

References fb(), FPeq(), PG_GETARG_POINT_P, and PG_RETURN_BOOL.

Referenced by getQuadrant().

points_box()

Datum points_box

(

PG_FUNCTION_ARGS

)

Definition at line 4273 of file geo_ops.c.

{
    Point      *p1 = PG_GETARG_POINT_P(0);
    Point      *p2 = PG_GETARG_POINT_P(1);
    BOX        *result;
 
    result = palloc_object(BOX);
 
    box_construct(result, p1, p2);
 
    PG_RETURN_BOX_P(result);
}

References box_construct(), fb(), palloc_object, PG_GETARG_POINT_P, PG_RETURN_BOX_P, and result.

poly_above()

Datum poly_above

(

PG_FUNCTION_ARGS

)

Definition at line 3718 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = polya->boundbox.low.y > polyb->boundbox.high.y;
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and result.

poly_below()

Datum poly_below

(

PG_FUNCTION_ARGS

)

Definition at line 3672 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = polya->boundbox.high.y < polyb->boundbox.low.y;
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and result.

poly_box()

Datum poly_box

(

PG_FUNCTION_ARGS

)

Definition at line 4578 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
    BOX        *box;
 
    box = palloc_object(BOX);
    *box = poly->boundbox;
 
    PG_RETURN_BOX_P(box);
}

References fb(), palloc_object, PG_GETARG_POLYGON_P, and PG_RETURN_BOX_P.

poly_center()

Datum poly_center

(

PG_FUNCTION_ARGS

)

Definition at line 4559 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
    Point      *result;
    CIRCLE      circle;
 
    result = palloc_object(Point);
 
    poly_to_circle(&circle, poly, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        PG_RETURN_NULL();
 
    *result = circle.center;
 
    PG_RETURN_POINT_P(result);
}

References fb(), palloc_object, PG_GETARG_POLYGON_P, PG_RETURN_NULL, PG_RETURN_POINT_P, poly_to_circle(), result, and SOFT_ERROR_OCCURRED.

poly_circle()

Datum poly_circle

(

PG_FUNCTION_ARGS

)

Definition at line 5457 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
    CIRCLE     *result;
 
    result = palloc_object(CIRCLE);
 
    poly_to_circle(result, poly, fcinfo->context);
    if (SOFT_ERROR_OCCURRED(fcinfo->context))
        PG_RETURN_NULL();
 
    PG_RETURN_CIRCLE_P(result);
}

References fb(), palloc_object, PG_GETARG_POLYGON_P, PG_RETURN_CIRCLE_P, PG_RETURN_NULL, poly_to_circle(), result, and SOFT_ERROR_OCCURRED.

poly_contain()

Datum poly_contain

(

PG_FUNCTION_ARGS

)

Definition at line 4013 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = poly_contain_poly(polya, polyb);
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, poly_contain_poly(), and result.

poly_contain_poly()

static bool poly_contain_poly ( POLYGON *  contains_poly, POLYGON *  contained_poly  )

static

Definition at line 3985 of file geo_ops.c.

{
    int         i;
    LSEG        s;
 
    Assert(contains_poly->npts > 0 && contained_poly->npts > 0);
 
    /*
     * Quick check to see if contained's bounding box is contained in
     * contains' bb.
     */
    if (!box_contain_box(&contains_poly->boundbox, &contained_poly->boundbox))
        return false;
 
    s.p[0] = contained_poly->p[contained_poly->npts - 1];
 
    for (i = 0; i < contained_poly->npts; i++)
    {
        s.p[1] = contained_poly->p[i];
        if (!lseg_inside_poly(s.p, s.p + 1, contains_poly, 0))
            return false;
        s.p[0] = s.p[1];
    }
 
    return true;
}

References Assert, box_contain_box(), fb(), i, lseg_inside_poly(), and LSEG::p.

Referenced by poly_contain(), and poly_contained().

poly_contain_pt()

Datum poly_contain_pt

(

PG_FUNCTION_ARGS

)

Definition at line 4055 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
    Point      *p = PG_GETARG_POINT_P(1);
 
    PG_RETURN_BOOL(point_inside(p, poly->npts, poly->p) != 0);
}

References fb(), PG_GETARG_POINT_P, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and point_inside().

Referenced by gist_point_consistent().

poly_contained()

Datum poly_contained

(

PG_FUNCTION_ARGS

)

Definition at line 4035 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    /* Just switch the arguments and pass it off to poly_contain */
    result = poly_contain_poly(polyb, polya);
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, poly_contain_poly(), and result.

poly_distance()

Datum poly_distance

(

PG_FUNCTION_ARGS

)

Definition at line 4074 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    float8      min = 0.0;      /* initialize to keep compiler quiet */
    bool        have_min = false;
    float8      tmp;
    int         i,
                j;
    LSEG        seg1,
                seg2;
 
    /*
     * Distance is zero if polygons overlap.  We must check this because the
     * path distance will not give the right answer if one poly is entirely
     * within the other.
     */
    if (poly_overlap_internal(polya, polyb))
        PG_RETURN_FLOAT8(0.0);
 
    /*
     * When they don't overlap, the distance calculation is identical to that
     * for closed paths (i.e., we needn't care about the fact that polygons
     * include their contained areas).  See path_distance().
     */
    for (i = 0; i < polya->npts; i++)
    {
        int         iprev;
 
        if (i > 0)
            iprev = i - 1;
        else
            iprev = polya->npts - 1;
 
        for (j = 0; j < polyb->npts; j++)
        {
            int         jprev;
 
            if (j > 0)
                jprev = j - 1;
            else
                jprev = polyb->npts - 1;
 
            statlseg_construct(&seg1, &polya->p[iprev], &polya->p[i]);
            statlseg_construct(&seg2, &polyb->p[jprev], &polyb->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 fb(), float8_lt(), i, j, lseg_closept_lseg(), PG_GETARG_POLYGON_P, PG_RETURN_FLOAT8, PG_RETURN_NULL, poly_overlap_internal(), and statlseg_construct().

poly_in()

Datum poly_in

(

PG_FUNCTION_ARGS

)

Definition at line 3462 of file geo_ops.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    POLYGON    *poly;
    int         npts;
    int         size;
    int         base_size;
    bool        isopen;
 
    if ((npts = pair_count(str, ',')) <= 0)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        "polygon", str)));
 
    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)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("too many points requested")));
 
    poly = (POLYGON *) palloc0(size);   /* zero any holes */
 
    SET_VARSIZE(poly, size);
    poly->npts = npts;
 
    if (!path_decode(str, false, npts, &(poly->p[0]), &isopen, NULL, "polygon",
                     str, escontext))
        PG_RETURN_NULL();
 
    make_bound_box(poly);
 
    PG_RETURN_POLYGON_P(poly);
}

References ereturn, errcode(), errmsg, fb(), make_bound_box(), pair_count(), palloc0(), path_decode(), PG_GETARG_CSTRING, PG_RETURN_NULL, PG_RETURN_POLYGON_P, SET_VARSIZE(), and str.

poly_left()

Datum poly_left

(

PG_FUNCTION_ARGS

)

Definition at line 3580 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = polya->boundbox.high.x < polyb->boundbox.low.x;
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and result.

poly_npoints()

Datum poly_npoints

(

PG_FUNCTION_ARGS

)

Definition at line 4550 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
 
    PG_RETURN_INT32(poly->npts);
}

References fb(), PG_GETARG_POLYGON_P, and PG_RETURN_INT32.

poly_out()

Datum poly_out

(

PG_FUNCTION_ARGS

)

Definition at line 3506 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
 
    PG_RETURN_CSTRING(path_encode(PATH_CLOSED, poly->npts, poly->p));
}

References fb(), PATH_CLOSED, path_encode(), PG_GETARG_POLYGON_P, and PG_RETURN_CSTRING.

poly_overabove()

Datum poly_overabove

(

PG_FUNCTION_ARGS

)

Definition at line 3741 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = polya->boundbox.low.y >= polyb->boundbox.low.y;
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and result.

poly_overbelow()

Datum poly_overbelow

(

PG_FUNCTION_ARGS

)

Definition at line 3695 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = polya->boundbox.high.y <= polyb->boundbox.high.y;
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and result.

poly_overlap()

Datum poly_overlap

(

PG_FUNCTION_ARGS

)

Definition at line 3848 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = poly_overlap_internal(polya, polyb);
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, poly_overlap_internal(), and result.

poly_overlap_internal()

static bool poly_overlap_internal ( POLYGON *  polya, POLYGON *  polyb  )

static

Definition at line 3791 of file geo_ops.c.

{
    bool        result;
 
    Assert(polya->npts > 0 && polyb->npts > 0);
 
    /* Quick check by bounding box */
    result = box_ov(&polya->boundbox, &polyb->boundbox);
 
    /*
     * Brute-force algorithm - try to find intersected edges, if so then
     * polygons are overlapped else check is one polygon inside other or not
     * by testing single point of them.
     */
    if (result)
    {
        int         ia,
                    ib;
        LSEG        sa,
                    sb;
 
        /* Init first of polya's edge with last point */
        sa.p[0] = polya->p[polya->npts - 1];
        result = false;
 
        for (ia = 0; ia < polya->npts && !result; ia++)
        {
            /* Second point of polya's edge is a current one */
            sa.p[1] = polya->p[ia];
 
            /* Init first of polyb's edge with last point */
            sb.p[0] = polyb->p[polyb->npts - 1];
 
            for (ib = 0; ib < polyb->npts && !result; ib++)
            {
                sb.p[1] = polyb->p[ib];
                result = lseg_interpt_lseg(NULL, &sa, &sb);
                sb.p[0] = sb.p[1];
            }
 
            /*
             * move current endpoint to the first point of next edge
             */
            sa.p[0] = sa.p[1];
        }
 
        if (!result)
        {
            result = (point_inside(polya->p, polyb->npts, polyb->p) ||
                      point_inside(polyb->p, polya->npts, polya->p));
        }
    }
 
    return result;
}

References Assert, box_ov(), fb(), lseg_interpt_lseg(), point_inside(), and result.

Referenced by poly_distance(), and poly_overlap().

poly_overleft()

Datum poly_overleft

(

PG_FUNCTION_ARGS

)

Definition at line 3603 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = polya->boundbox.high.x <= polyb->boundbox.high.x;
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and result.

poly_overright()

Datum poly_overright

(

PG_FUNCTION_ARGS

)

Definition at line 3649 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = polya->boundbox.low.x >= polyb->boundbox.low.x;
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and result.

poly_path()

Datum poly_path

(

PG_FUNCTION_ARGS

)

Definition at line 4623 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
    PATH       *path;
    int         size;
    int         i;
 
    /*
     * Never overflows: the old size fit in MaxAllocSize, and the new size is
     * smaller by a small constant.
     */
    size = offsetof(PATH, p) + sizeof(path->p[0]) * poly->npts;
    path = (PATH *) palloc(size);
 
    SET_VARSIZE(path, size);
    path->npts = poly->npts;
    path->closed = true;
    /* prevent instability in unused pad bytes */
    path->dummy = 0;
 
    for (i = 0; i < poly->npts; i++)
    {
        path->p[i].x = poly->p[i].x;
        path->p[i].y = poly->p[i].y;
    }
 
    PG_RETURN_PATH_P(path);
}

References PATH::closed, PATH::dummy, fb(), i, PATH::npts, PATH::p, palloc(), PG_GETARG_POLYGON_P, PG_RETURN_PATH_P, SET_VARSIZE(), Point::x, and Point::y.

poly_recv()

Datum poly_recv

(

PG_FUNCTION_ARGS

)

Definition at line 3522 of file geo_ops.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    POLYGON    *poly;
    int32       npts;
    int32       i;
    int         size;
 
    npts = pq_getmsgint(buf, sizeof(int32));
    if (npts <= 0 || npts >= (int32) ((INT_MAX - offsetof(POLYGON, p)) / sizeof(Point)))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid number of points in external \"polygon\" value")));
 
    size = offsetof(POLYGON, p) + sizeof(poly->p[0]) * npts;
    poly = (POLYGON *) palloc0(size);   /* zero any holes */
 
    SET_VARSIZE(poly, size);
    poly->npts = npts;
 
    for (i = 0; i < npts; i++)
    {
        poly->p[i].x = pq_getmsgfloat8(buf);
        poly->p[i].y = pq_getmsgfloat8(buf);
    }
 
    make_bound_box(poly);
 
    PG_RETURN_POLYGON_P(poly);
}

References buf, ereport, errcode(), errmsg, ERROR, fb(), i, make_bound_box(), palloc0(), PG_GETARG_POINTER, PG_RETURN_POLYGON_P, pq_getmsgfloat8(), pq_getmsgint(), and SET_VARSIZE().

poly_right()

Datum poly_right

(

PG_FUNCTION_ARGS

)

Definition at line 3626 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    result = polya->boundbox.low.x > polyb->boundbox.high.x;
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and result.

poly_same()

Datum poly_same

(

PG_FUNCTION_ARGS

)

Definition at line 3767 of file geo_ops.c.

{
    POLYGON    *polya = PG_GETARG_POLYGON_P(0);
    POLYGON    *polyb = PG_GETARG_POLYGON_P(1);
    bool        result;
 
    if (polya->npts != polyb->npts)
        result = false;
    else
        result = plist_same(polya->npts, polya->p, polyb->p);
 
    /*
     * Avoid leaking memory for toasted inputs ... needed for rtree indexes
     */
    PG_FREE_IF_COPY(polya, 0);
    PG_FREE_IF_COPY(polyb, 1);
 
    PG_RETURN_BOOL(result);
}

References fb(), PG_FREE_IF_COPY, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, plist_same(), and result.

poly_send()

Datum poly_send

(

PG_FUNCTION_ARGS

)

Definition at line 3557 of file geo_ops.c.

{
    POLYGON    *poly = PG_GETARG_POLYGON_P(0);
    StringInfoData buf;
    int32       i;
 
    pq_begintypsend(&buf);
    pq_sendint32(&buf, poly->npts);
    for (i = 0; i < poly->npts; i++)
    {
        pq_sendfloat8(&buf, poly->p[i].x);
        pq_sendfloat8(&buf, poly->p[i].y);
    }
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, fb(), i, PG_GETARG_POLYGON_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendfloat8(), and pq_sendint32().

poly_to_circle()

static void poly_to_circle ( CIRCLE *  result, POLYGON *  poly, Node *  escontext  )

static

Definition at line 5414 of file geo_ops.c.

{
    int         i;
    float8      x;
 
    Assert(poly->npts > 0);
 
    result->center.x = 0;
    result->center.y = 0;
    result->radius = 0;
 
    for (i = 0; i < poly->npts; i++)
    {
        point_add_point(&result->center, &result->center, &poly->p[i], escontext);
        if (SOFT_ERROR_OCCURRED(escontext))
            return;
    }
 
    result->center.x = float8_div_safe(result->center.x, poly->npts, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
 
    result->center.y = float8_div_safe(result->center.y, poly->npts, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
 
    for (i = 0; i < poly->npts; i++)
    {
        x = point_dt(&poly->p[i], &result->center, escontext);
        if (SOFT_ERROR_OCCURRED(escontext))
            return;
 
        result->radius = float8_pl_safe(result->radius, x, escontext);
        if (SOFT_ERROR_OCCURRED(escontext))
            return;
    }
 
    result->radius = float8_div_safe(result->radius, poly->npts, escontext);
    if (SOFT_ERROR_OCCURRED(escontext))
        return;
}

References Assert, fb(), float8_div_safe(), float8_pl_safe(), i, point_add_point(), point_dt(), result, SOFT_ERROR_OCCURRED, and x.

Referenced by poly_center(), and poly_circle().

pt_contained_circle()

Datum pt_contained_circle

(

PG_FUNCTION_ARGS

)

Definition at line 5153 of file geo_ops.c.

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

References fb(), PG_GETARG_CIRCLE_P, PG_GETARG_POINT_P, PG_RETURN_BOOL, and point_dt().

pt_contained_poly()

Datum pt_contained_poly

(

PG_FUNCTION_ARGS

)

Definition at line 4064 of file geo_ops.c.

{
    Point      *p = PG_GETARG_POINT_P(0);
    POLYGON    *poly = PG_GETARG_POLYGON_P(1);
 
    PG_RETURN_BOOL(point_inside(p, poly->npts, poly->p) != 0);
}

References fb(), PG_GETARG_POINT_P, PG_GETARG_POLYGON_P, PG_RETURN_BOOL, and point_inside().

single_decode()

static bool single_decode ( char *  num, float8 *  x, char **  endptr_p, const char *  type_name, const char *  orig_string, Node *  escontext  )

static

Definition at line 195 of file geo_ops.c.

{
    *x = float8in_internal(num, endptr_p, type_name, orig_string, escontext);
    return (!SOFT_ERROR_OCCURRED(escontext));
}                               /* single_decode() */

References fb(), float8in_internal(), SOFT_ERROR_OCCURRED, and x.

Referenced by circle_in(), line_decode(), and pair_decode().

single_encode()

static void single_encode ( float8  x, StringInfo  str  )

static

Definition at line 204 of file geo_ops.c.

{
    char       *xstr = float8out_internal(x);
 
    appendStringInfoString(str, xstr);
    pfree(xstr);
}                               /* single_encode() */

References appendStringInfoString(), fb(), float8out_internal(), pfree(), str, and x.

Referenced by circle_out().

statlseg_construct()

static void statlseg_construct ( LSEG *  lseg, Point *  pt1, Point *  pt2  )

inlinestatic

Definition at line 2171 of file geo_ops.c.

{
    lseg->p[0].x = pt1->x;
    lseg->p[0].y = pt1->y;
    lseg->p[1].x = pt2->x;
    lseg->p[1].y = pt2->y;
}

References fb().

Referenced by box_closept_lseg(), box_closept_point(), box_diagonal(), box_interpt_lseg(), dist_ppath_internal(), inter_lb(), lseg_construct(), path_distance(), path_inter(), and poly_distance().

touched_lseg_inside_poly()

static bool touched_lseg_inside_poly ( Point *  a, Point *  b, LSEG *  s, POLYGON *  poly, int  start  )

static

Definition at line 3877 of file geo_ops.c.

{
    /* point a is on s, b is not */
    LSEG        t;
 
    t.p[0] = *a;
    t.p[1] = *b;
 
    if (point_eq_point(a, s->p))
    {
        if (lseg_contain_point(&t, s->p + 1))
            return lseg_inside_poly(b, s->p + 1, poly, start);
    }
    else if (point_eq_point(a, s->p + 1))
    {
        if (lseg_contain_point(&t, s->p))
            return lseg_inside_poly(b, s->p, poly, start);
    }
    else if (lseg_contain_point(&t, s->p))
    {
        return lseg_inside_poly(b, s->p, poly, start);
    }
    else if (lseg_contain_point(&t, s->p + 1))
    {
        return lseg_inside_poly(b, s->p + 1, poly, start);
    }
 
    return true;                /* may be not true, but that will check later */
}

References a, b, fb(), lseg_contain_point(), lseg_inside_poly(), LSEG::p, point_eq_point(), and start.

Referenced by lseg_inside_poly().