自学教程：C++ FLAGS_GET_Z函数代码示例

static LWPOLY* lwpoly_from_gserialized_buffer(uint8_t *data_ptr, uint8_t g_flags, size_t *g_size){	uint8_t *start_ptr = data_ptr;	LWPOLY *poly;	uint8_t *ordinate_ptr;	uint32_t nrings = 0;	int i = 0;	assert(data_ptr);	poly = (LWPOLY*)lwalloc(sizeof(LWPOLY));	poly->srid = SRID_UNKNOWN; /* Default */	poly->bbox = NULL;	poly->type = POLYGONTYPE;	poly->flags = g_flags;	data_ptr += 4; /* Skip past the polygontype. */	nrings = lw_get_uint32_t(data_ptr); /* Zero => empty geometry */	poly->nrings = nrings;	LWDEBUGF(4, "nrings = %d", nrings);	data_ptr += 4; /* Skip past the nrings. */	ordinate_ptr = data_ptr; /* Start the ordinate pointer. */	if ( nrings > 0)	{		poly->rings = (POINTARRAY**)lwalloc( sizeof(POINTARRAY*) * nrings );		ordinate_ptr += nrings * 4; /* Move past all the npoints values. */		if ( nrings % 2 ) /* If there is padding, move past that too. */			ordinate_ptr += 4;	}	else /* Empty polygon */	{		poly->rings = NULL;	}	for ( i = 0; i < nrings; i++ )	{		uint32_t npoints = 0;		/* Read in the number of points. */		npoints = lw_get_uint32_t(data_ptr);		data_ptr += 4;		/* Make a point array for the ring, and move the ordinate pointer past the ring ordinates. */		poly->rings[i] = ptarray_construct_reference_data(FLAGS_GET_Z(g_flags), FLAGS_GET_M(g_flags), npoints, ordinate_ptr);				ordinate_ptr += sizeof(double) * FLAGS_NDIMS(g_flags) * npoints;	}	if ( g_size )		*g_size = ordinate_ptr - start_ptr;	return poly;}

/* * Construct a triangle from a LWLINE being * the shell * Pointarray from intput geom are cloned. * Input line must have 4 points, and be closed. */LWTRIANGLE *lwtriangle_from_lwline(const LWLINE *shell){	LWTRIANGLE *ret;	POINTARRAY *pa;	if ( shell->points->npoints != 4 )		lwerror("lwtriangle_from_lwline: shell must have exactly 4 points");	if (   (!FLAGS_GET_Z(shell->flags) && !ptarray_is_closed_2d(shell->points)) ||	        (FLAGS_GET_Z(shell->flags) && !ptarray_is_closed_3d(shell->points)) )		lwerror("lwtriangle_from_lwline: shell must be closed");	pa = ptarray_clone_deep(shell->points);	ret = lwtriangle_construct(shell->srid, NULL, pa);	if (lwtriangle_is_repeated_points(ret))		lwerror("lwtriangle_from_lwline: some points are repeated in triangle");	return ret;}

static size_t gserialized_from_lwline(const LWLINE *line, uint8_t *buf){	uint8_t *loc;	int ptsize;	size_t size;	int type = LINETYPE;	assert(line);	assert(buf);	LWDEBUGF(2, "lwline_to_gserialized(%p, %p) called", line, buf);	if ( FLAGS_GET_Z(line->flags) != FLAGS_GET_Z(line->points->flags) )		lwerror("Dimensions mismatch in lwline");	ptsize = ptarray_point_size(line->points);	loc = buf;	/* Write in the type. */	memcpy(loc, &type, sizeof(uint32_t));	loc += sizeof(uint32_t);	/* Write in the npoints. */	memcpy(loc, &(line->points->npoints), sizeof(uint32_t));	loc += sizeof(uint32_t);	LWDEBUGF(3, "lwline_to_gserialized added npoints (%d)", line->points->npoints);	/* Copy in the ordinates. */	if ( line->points->npoints > 0 )	{		size = line->points->npoints * ptsize;		memcpy(loc, getPoint_internal(line->points, 0), size);		loc += size;	}	LWDEBUGF(3, "lwline_to_gserialized copied serialized_pointlist (%d bytes)", ptsize * line->points->npoints);	return (size_t)(loc - buf);}

/** * @brief Add a point in a pointarray. * * @param pa the source POINTARRAY * @param p the point to add * @param pdims number of ordinates in p (2..4) * @param where to insert the point. 0 prepends, pa->npoints appends * * @returns a newly constructed POINTARRAY using a newly allocated buffer *          for the actual points, or NULL on error. */POINTARRAY *ptarray_addPoint(const POINTARRAY *pa, uint8_t *p, size_t pdims, uint32_t where){	POINTARRAY *ret;	POINT4D pbuf;	size_t ptsize = ptarray_point_size(pa);	LWDEBUGF(3, "pa %x p %x size %d where %d",	         pa, p, pdims, where);	if ( pdims < 2 || pdims > 4 )	{		lwerror("ptarray_addPoint: point dimension out of range (%d)",		        pdims);		return NULL;	}	if ( where > pa->npoints )	{		lwerror("ptarray_addPoint: offset out of range (%d)",		        where);		return NULL;	}	LWDEBUG(3, "called with a %dD point");	pbuf.x = pbuf.y = pbuf.z = pbuf.m = 0.0;	memcpy((uint8_t *)&pbuf, p, pdims*sizeof(double));	LWDEBUG(3, "initialized point buffer");	ret = ptarray_construct(FLAGS_GET_Z(pa->flags),	                        FLAGS_GET_M(pa->flags), pa->npoints+1);	if ( where == -1 ) where = pa->npoints;	if ( where )	{		memcpy(getPoint_internal(ret, 0), getPoint_internal(pa, 0), ptsize*where);	}	memcpy(getPoint_internal(ret, where), (uint8_t *)&pbuf, ptsize);	if ( where+1 != ret->npoints )	{		memcpy(getPoint_internal(ret, where+1),		       getPoint_internal(pa, where),		       ptsize*(pa->npoints-where));	}	return ret;}

static size_tasgeojson_line_size(const LWLINE *line, char *srs, GBOX *bbox, int precision){	int size;	size = sizeof("{'type':'LineString',");	if (srs) size += asgeojson_srs_size(srs);	if (bbox) size += asgeojson_bbox_size(FLAGS_GET_Z(line->flags), precision);	size += sizeof("'coordinates':[]}");	size += pointArray_geojson_size(line->points, precision);	return size;}

LWLINE *lwcircstring_segmentize(const LWCIRCSTRING *icurve, uint32_t perQuad){	LWLINE *oline;	POINTARRAY *ptarray;	POINTARRAY *tmp;	uint32_t i, j;	POINT4D p1, p2, p3, p4;	LWDEBUGF(2, "lwcircstring_segmentize called., dim = %d", icurve->points->flags);	ptarray = ptarray_construct_empty(FLAGS_GET_Z(icurve->points->flags), FLAGS_GET_M(icurve->points->flags), 64);	for (i = 2; i < icurve->points->npoints; i+=2)	{		LWDEBUGF(3, "lwcircstring_segmentize: arc ending at point %d", i);		getPoint4d_p(icurve->points, i - 2, &p1);		getPoint4d_p(icurve->points, i - 1, &p2);		getPoint4d_p(icurve->points, i, &p3);		tmp = lwcircle_segmentize(&p1, &p2, &p3, perQuad);		if (tmp)		{			LWDEBUGF(3, "lwcircstring_segmentize: generated %d points", tmp->npoints);			for (j = 0; j < tmp->npoints; j++)			{				getPoint4d_p(tmp, j, &p4);				ptarray_append_point(ptarray, &p4, LW_TRUE);			}			ptarray_free(tmp);		}		else		{			LWDEBUG(3, "lwcircstring_segmentize: points are colinear, returning curve points as line");			for (j = i - 1 ; j <= i ; j++)			{				getPoint4d_p(icurve->points, j, &p4);				ptarray_append_point(ptarray, &p4, LW_TRUE);			}		}	}	getPoint4d_p(icurve->points, icurve->points->npoints-1, &p1);	ptarray_append_point(ptarray, &p1, LW_TRUE);			oline = lwline_construct(icurve->srid, NULL, ptarray);	return oline;}

/* * @param icurve input curve * @param tol tolerance, semantic driven by tolerance_type * @param tolerance_type see LW_LINEARIZE_TOLERANCE_TYPE * @param flags see flags in lwarc_linearize * * @return a newly allocated LWLINE */static LWLINE *lwcircstring_linearize(const LWCIRCSTRING *icurve, double tol,                        LW_LINEARIZE_TOLERANCE_TYPE tolerance_type,                        int flags){	LWLINE *oline;	POINTARRAY *ptarray;	uint32_t i, j;	POINT4D p1, p2, p3, p4;	int ret;	LWDEBUGF(2, "lwcircstring_linearize called., dim = %d", icurve->points->flags);	ptarray = ptarray_construct_empty(FLAGS_GET_Z(icurve->points->flags), FLAGS_GET_M(icurve->points->flags), 64);	for (i = 2; i < icurve->points->npoints; i+=2)	{		LWDEBUGF(3, "lwcircstring_linearize: arc ending at point %d", i);		getPoint4d_p(icurve->points, i - 2, &p1);		getPoint4d_p(icurve->points, i - 1, &p2);		getPoint4d_p(icurve->points, i, &p3);		ret = lwarc_linearize(ptarray, &p1, &p2, &p3, tol, tolerance_type, flags);		if ( ret > 0 )		{			LWDEBUGF(3, "lwcircstring_linearize: generated %d points", ptarray->npoints);		}		else if ( ret == 0 )		{			LWDEBUG(3, "lwcircstring_linearize: points are colinear, returning curve points as line");			for (j = i - 2 ; j < i ; j++)			{				getPoint4d_p(icurve->points, j, &p4);				ptarray_append_point(ptarray, &p4, LW_TRUE);			}		}		else		{			/* An error occurred, lwerror should have been called by now */			ptarray_free(ptarray);			return NULL;		}	}	getPoint4d_p(icurve->points, icurve->points->npoints-1, &p1);	ptarray_append_point(ptarray, &p1, LW_TRUE);	oline = lwline_construct(icurve->srid, NULL, ptarray);	return oline;}

/* * Stick an array of points to the given gridspec. * Return "gridded" points in *outpts and their number in *outptsn. * * Two consecutive points falling on the same grid cell are collapsed * into one single point. * */POINTARRAY *ptarray_grid(POINTARRAY *pa, gridspec *grid){	POINT4D pbuf;	int ipn, opn; /* point numbers (input/output) */	POINTARRAY *dpa;	POSTGIS_DEBUGF(2, "ptarray_grid called on %p", pa);	dpa = ptarray_construct_empty(FLAGS_GET_Z(pa->flags),FLAGS_GET_M(pa->flags), pa->npoints);	for (ipn=0, opn=0; ipn<pa->npoints; ++ipn)	{		getPoint4d_p(pa, ipn, &pbuf);		if ( grid->xsize )			pbuf.x = rint((pbuf.x - grid->ipx)/grid->xsize) *			         grid->xsize + grid->ipx;		if ( grid->ysize )			pbuf.y = rint((pbuf.y - grid->ipy)/grid->ysize) *			         grid->ysize + grid->ipy;		if ( FLAGS_GET_Z(pa->flags) && grid->zsize )			pbuf.z = rint((pbuf.z - grid->ipz)/grid->zsize) *			         grid->zsize + grid->ipz;		if ( FLAGS_GET_M(pa->flags) && grid->msize )			pbuf.m = rint((pbuf.m - grid->ipm)/grid->msize) *			         grid->msize + grid->ipm;		ptarray_append_point(dpa, &pbuf, LW_FALSE);	}	return dpa;}

/* * Stick an array of points to the given gridspec. * Return "gridded" points in *outpts and their number in *outptsn. * * Two consecutive points falling on the same grid cell are collapsed * into one single point. * */POINTARRAY *ptarray_grid(const POINTARRAY *pa, const gridspec *grid){	POINT4D pt;	int ipn; /* input point numbers */	POINTARRAY *dpa;	LWDEBUGF(2, "ptarray_grid called on %p", pa);	dpa = ptarray_construct_empty(FLAGS_GET_Z(pa->flags),FLAGS_GET_M(pa->flags), pa->npoints);	for (ipn=0; ipn<pa->npoints; ++ipn)	{		getPoint4d_p(pa, ipn, &pt);		if ( grid->xsize )			pt.x = rint((pt.x - grid->ipx)/grid->xsize) *			         grid->xsize + grid->ipx;		if ( grid->ysize )			pt.y = rint((pt.y - grid->ipy)/grid->ysize) *			         grid->ysize + grid->ipy;		if ( FLAGS_GET_Z(pa->flags) && grid->zsize )			pt.z = rint((pt.z - grid->ipz)/grid->zsize) *			         grid->zsize + grid->ipz;		if ( FLAGS_GET_M(pa->flags) && grid->msize )			pt.m = rint((pt.m - grid->ipm)/grid->msize) *			         grid->msize + grid->ipm;		ptarray_append_point(dpa, &pt, LW_FALSE);	}	return dpa;}

int gbox_overlaps(const GBOX *g1, const GBOX *g2){	/* Make sure our boxes are consistent */	if ( FLAGS_GET_GEODETIC(g1->flags) != FLAGS_GET_GEODETIC(g2->flags) )		lwerror("gbox_overlaps: cannot compare geodetic and non-geodetic boxes");	/* Check X/Y first */	if ( g1->xmax < g2->xmin || g1->ymax < g2->ymin ||	     g1->xmin > g2->xmax || g1->ymin > g2->ymax )		return LW_FALSE;	/* Deal with the geodetic case special: we only compare the geodetic boxes (x/y/z) */	/* Never the M dimension */	if ( FLAGS_GET_GEODETIC(g1->flags) && FLAGS_GET_GEODETIC(g2->flags) )	{		if ( g1->zmax < g2->zmin || g1->zmin > g2->zmax )			return LW_FALSE;		else			return LW_TRUE;			}			/* If both geodetic or both have Z, check Z */	if ( FLAGS_GET_Z(g1->flags) && FLAGS_GET_Z(g2->flags) )	{		if ( g1->zmax < g2->zmin || g1->zmin > g2->zmax )			return LW_FALSE;	}		/* If both have M, check M */	if ( FLAGS_GET_M(g1->flags) && FLAGS_GET_M(g2->flags) )	{		if ( g1->mmax < g2->mmin || g1->mmin > g2->mmax )			return LW_FALSE;	}		return LW_TRUE;}

/**We calculate the effective area for the first time*/void ptarray_calc_areas(EFFECTIVE_AREAS *ea, int avoid_collaps, int set_area, double trshld){	LWDEBUG(2, "Entered  ptarray_calc_areas");	int i;	int npoints=ea->inpts->npoints;	int is3d = FLAGS_GET_Z(ea->inpts->flags);	double area;		const double *P1;	const double *P2;	const double *P3;				P1 = (double*)getPoint_internal(ea->inpts, 0);	P2 = (double*)getPoint_internal(ea->inpts, 1);		/*The first and last point shall always have the maximum effective area. We use float max to not make trouble for bbox*/	ea->initial_arealist[0].area=ea->initial_arealist[npoints-1].area=FLT_MAX;	ea->res_arealist[0]=ea->res_arealist[npoints-1]=FLT_MAX;		ea->initial_arealist[0].next=1;	ea->initial_arealist[0].prev=0;		for (i=1;i<(npoints)-1;i++)	{		ea->initial_arealist[i].next=i+1;		ea->initial_arealist[i].prev=i-1;		P3 = (double*)getPoint_internal(ea->inpts, i+1);		if(is3d)			area=triarea3d(P1, P2, P3);		else			area=triarea2d(P1, P2, P3);				LWDEBUGF(4,"Write area %lf to point %d on address %p",area,i,&(ea->initial_arealist[i].area));		ea->initial_arealist[i].area=area;		P1=P2;		P2=P3;			}			ea->initial_arealist[npoints-1].next=npoints-1;		ea->initial_arealist[npoints-1].prev=npoints-2;		for (i=1;i<(npoints)-1;i++)	{		ea->res_arealist[i]=FLT_MAX;	}		tune_areas(ea,avoid_collaps,set_area, trshld);	return ;}

static size_tasgeojson_point_size(const LWPOINT *point, char *srs, GBOX *bbox, int precision){	int size;	size = pointArray_geojson_size(point->point, precision);	size += sizeof("{'type':'Point',");	size += sizeof("'coordinates':}");	if (srs) size += asgeojson_srs_size(srs);	if (bbox) size += asgeojson_bbox_size(FLAGS_GET_Z(point->flags), precision);	return size;}

int gbox_same(const GBOX *g1, const GBOX *g2){	if (FLAGS_GET_ZM(g1->flags) != FLAGS_GET_ZM(g2->flags))		return LW_FALSE;	if (!gbox_same_2d(g1, g2)) return LW_FALSE;	if (FLAGS_GET_Z(g1->flags) && (g1->zmin != g2->zmin || g1->zmax != g2->zmax))		return LW_FALSE;	if (FLAGS_GET_M(g1->flags) && (g1->mmin != g2->mmin || g1->mmax != g2->mmax))		return LW_FALSE;	return LW_TRUE;}

LWCOLLECTION *lwcollection_construct(uint8_t type, int srid, GBOX *bbox,                       uint32_t ngeoms, LWGEOM **geoms){	LWCOLLECTION *ret;	int hasz, hasm;#ifdef CHECK_LWGEOM_ZM	char zm;	uint32_t i;#endif	LWDEBUGF(2, "lwcollection_construct called with %d, %d, %p, %d, %p.", type, srid, bbox, ngeoms, geoms);	if( ! lwtype_is_collection(type) )		lwerror("Non-collection type specified in collection constructor!");	hasz = 0;	hasm = 0;	if ( ngeoms > 0 )	{		hasz = FLAGS_GET_Z(geoms[0]->flags);		hasm = FLAGS_GET_M(geoms[0]->flags);#ifdef CHECK_LWGEOM_ZM		zm = FLAGS_GET_ZM(geoms[0]->flags);		LWDEBUGF(3, "lwcollection_construct type[0]=%d", geoms[0]->type);		for (i=1; i<ngeoms; i++)		{			LWDEBUGF(3, "lwcollection_construct type=[%d]=%d", i, geoms[i]->type);			if ( zm != FLAGS_GET_ZM(geoms[i]->flags) )				lwerror("lwcollection_construct: mixed dimension geometries: %d/%d", zm, FLAGS_GET_ZM(geoms[i]->flags));		}#endif	}	ret = lwalloc(sizeof(LWCOLLECTION));	ret->type = type;	ret->flags = gflags(hasz,hasm,0);	FLAGS_SET_BBOX(ret->flags, bbox?1:0);	ret->srid = srid;	ret->ngeoms = ngeoms;	ret->maxgeoms = ngeoms;	ret->geoms = geoms;	ret->bbox = bbox;	return ret;}

static size_tasgeojson_line_buf(const LWLINE *line, char *srs, char *output, GBOX *bbox, int precision){	char *ptr=output;	ptr += sprintf(ptr, "{/"type/":/"LineString/",");	if (srs) ptr += asgeojson_srs_buf(ptr, srs);	if (bbox) ptr += asgeojson_bbox_buf(ptr, bbox, FLAGS_GET_Z(line->flags), precision);	ptr += sprintf(ptr, "/"coordinates/":[");	ptr += pointArray_to_geojson(line->points, ptr, precision);	ptr += sprintf(ptr, "]}");	return (ptr-output);}

static size_tasgeojson_point_buf(const LWPOINT *point, char *srs, char *output, GBOX *bbox, int precision){	char *ptr = output;	ptr += sprintf(ptr, "{/"type/":/"Point/",");	if (srs) ptr += asgeojson_srs_buf(ptr, srs);	if (bbox) ptr += asgeojson_bbox_buf(ptr, bbox, FLAGS_GET_Z(point->flags), precision);	ptr += sprintf(ptr, "/"coordinates/":");	ptr += pointArray_to_geojson(point->point, ptr, precision);	ptr += sprintf(ptr, "}");	return (ptr-output);}

static POINTARRAY * ptarray_set_effective_area(POINTARRAY *inpts,int avoid_collaps,int set_area, double trshld){	LWDEBUG(2, "Entered  ptarray_set_effective_area");	int p;	POINT4D pt;	EFFECTIVE_AREAS *ea;	POINTARRAY *opts;	int set_m;	if(set_area)		set_m=1;	else		set_m=FLAGS_GET_M(inpts->flags);	ea=initiate_effectivearea(inpts);	opts = ptarray_construct_empty(FLAGS_GET_Z(inpts->flags), set_m, inpts->npoints);	ptarray_calc_areas(ea,avoid_collaps,set_area,trshld);			if(set_area)	{		/*Only return points with an effective area above the threashold*/		for (p=0;p<ea->inpts->npoints;p++)		{			if(ea->res_arealist[p]>=trshld)			{				pt=getPoint4d(ea->inpts, p);				pt.m=ea->res_arealist[p];				ptarray_append_point(opts, &pt, LW_TRUE);			}		}	}	else	{			/*Only return points with an effective area above the threashold*/		for (p=0;p<ea->inpts->npoints;p++)		{			if(ea->res_arealist[p]>=trshld)			{				pt=getPoint4d(ea->inpts, p);				ptarray_append_point(opts, &pt, LW_TRUE);			}		}		}	destroy_effectivearea(ea);		return opts;	}

/* * @param icompound input compound curve * @param tol tolerance, semantic driven by tolerance_type * @param tolerance_type see LW_LINEARIZE_TOLERANCE_TYPE * @param flags see flags in lwarc_linearize * * @return a newly allocated LWLINE */static LWLINE *lwcompound_linearize(const LWCOMPOUND *icompound, double tol,                      LW_LINEARIZE_TOLERANCE_TYPE tolerance_type,                      int flags){	LWGEOM *geom;	POINTARRAY *ptarray = NULL, *ptarray_out = NULL;	LWLINE *tmp = NULL;	uint32_t i, j;	POINT4D p;	LWDEBUG(2, "lwcompound_stroke called.");	ptarray = ptarray_construct_empty(FLAGS_GET_Z(icompound->flags), FLAGS_GET_M(icompound->flags), 64);	for (i = 0; i < icompound->ngeoms; i++)	{		geom = icompound->geoms[i];		if (geom->type == CIRCSTRINGTYPE)		{			tmp = lwcircstring_linearize((LWCIRCSTRING *)geom, tol, tolerance_type, flags);			for (j = 0; j < tmp->points->npoints; j++)			{				getPoint4d_p(tmp->points, j, &p);				ptarray_append_point(ptarray, &p, LW_TRUE);			}			lwline_free(tmp);		}		else if (geom->type == LINETYPE)		{			tmp = (LWLINE *)geom;			for (j = 0; j < tmp->points->npoints; j++)			{				getPoint4d_p(tmp->points, j, &p);				ptarray_append_point(ptarray, &p, LW_TRUE);			}		}		else		{			lwerror("Unsupported geometry type %d found.",			        geom->type, lwtype_name(geom->type));			return NULL;		}	}	ptarray_out = ptarray_remove_repeated_points(ptarray, 0.0);	ptarray_free(ptarray);	return lwline_construct(icompound->srid, NULL, ptarray_out);}

LWCOLLECTION* lwcollection_simplify(const LWCOLLECTION *igeom, double dist){ 	int i;	LWCOLLECTION *out = lwcollection_construct_empty(igeom->type, igeom->srid, FLAGS_GET_Z(igeom->flags), FLAGS_GET_M(igeom->flags));	if( lwcollection_is_empty(igeom) )		return out; /* should we return NULL instead ? */	for( i = 0; i < igeom->ngeoms; i++ )	{		LWGEOM *ngeom = lwgeom_simplify(igeom->geoms[i], dist);		if ( ngeom ) out = lwcollection_add_lwgeom(out, ngeom);	}	return out;}

/* * Construct a LWCIRCSTRING from an array of LWPOINTs * LWCIRCSTRING dimensions are large enough to host all input dimensions. */LWCIRCSTRING *lwcircstring_from_lwpointarray(int srid, uint32_t npoints, LWPOINT **points){	int zmflag=0;	uint32_t i;	POINTARRAY *pa;	uint8_t *newpoints, *ptr;	size_t ptsize, size;	/*	 * Find output dimensions, check integrity	 */	for (i = 0; i < npoints; i++)	{		if (points[i]->type != POINTTYPE)		{			lwerror("lwcurve_from_lwpointarray: invalid input type: %s",			        lwtype_name(points[i]->type));			return NULL;		}		if (FLAGS_GET_Z(points[i]->flags)) zmflag |= 2;		if (FLAGS_GET_M(points[i]->flags)) zmflag |= 1;		if (zmflag == 3) break;	}	if (zmflag == 0) ptsize = 2 * sizeof(double);	else if (zmflag == 3) ptsize = 4 * sizeof(double);	else ptsize = 3 * sizeof(double);	/*	 * Allocate output points array	 */	size = ptsize * npoints;	newpoints = lwalloc(size);	memset(newpoints, 0, size);	ptr = newpoints;	for (i = 0; i < npoints; i++)	{		size = ptarray_point_size(points[i]->point);		memcpy(ptr, getPoint_internal(points[i]->point, 0), size);		ptr += ptsize;	}	pa = ptarray_construct_reference_data(zmflag&2, zmflag&1, npoints, newpoints);		return lwcircstring_construct(srid, NULL, pa);}

/** * Affine transform a pointarray. */voidptarray_affine(POINTARRAY *pa, const AFFINE *a){	int i;	double x,y,z;	POINT4D p4d;	LWDEBUG(2, "lwgeom_affine_ptarray start");	if ( FLAGS_GET_Z(pa->flags) )	{		LWDEBUG(3, " has z");		for (i=0; i<pa->npoints; i++)		{			getPoint4d_p(pa, i, &p4d);			x = p4d.x;			y = p4d.y;			z = p4d.z;			p4d.x = a->afac * x + a->bfac * y + a->cfac * z + a->xoff;			p4d.y = a->dfac * x + a->efac * y + a->ffac * z + a->yoff;			p4d.z = a->gfac * x + a->hfac * y + a->ifac * z + a->zoff;			ptarray_set_point4d(pa, i, &p4d);			LWDEBUGF(3, " POINT %g %g %g => %g %g %g", x, y, x, p4d.x, p4d.y, p4d.z);		}	}	else	{		LWDEBUG(3, " doesn't have z");		for (i=0; i<pa->npoints; i++)		{			getPoint4d_p(pa, i, &p4d);			x = p4d.x;			y = p4d.y;			p4d.x = a->afac * x + a->bfac * y + a->xoff;			p4d.y = a->dfac * x + a->efac * y + a->yoff;			ptarray_set_point4d(pa, i, &p4d);			LWDEBUGF(3, " POINT %g %g %g => %g %g %g", x, y, x, p4d.x, p4d.y, p4d.z);		}	}	LWDEBUG(3, "lwgeom_affine_ptarray end");}

/** Compute the X3D coordinates of the polygon **/static size_tasx3d3_poly_buf(const LWPOLY *poly, char *srs, char *output, int precision, int opts, int is_patch, const char *defid){	int i;	char *ptr=output;	int dimension=2;	if (FLAGS_GET_Z(poly->flags))		dimension = 3;	ptr += pointArray_toX3D3(poly->rings[0], ptr, precision, opts, 1);	for (i=1; i<poly->nrings; i++)	{		ptr += sprintf(ptr, " "); //inner ring points start		ptr += pointArray_toX3D3(poly->rings[i], ptr, precision, opts,1);	}	return (ptr-output);}

void gbox_expand(GBOX *g, double d){	g->xmin -= d;	g->xmax += d;	g->ymin -= d;	g->ymax += d;	if ( FLAGS_GET_Z(g->flags) )	{		g->zmin -= d;		g->zmax += d;	}	if ( FLAGS_GET_M(g->flags) )	{		g->mmin -= d;		g->mmax += d;	}}

LWGEOM* wkt_parser_curvepolygon_new(LWGEOM *ring) {	LWGEOM *poly;		LWDEBUG(4,"entered");	/* Toss error on null geometry input */	if( ! ring )	{		SET_PARSER_ERROR(PARSER_ERROR_OTHER);		return NULL;	}		/* Construct poly and add the ring. */	poly = lwcurvepoly_as_lwgeom(lwcurvepoly_construct_empty(SRID_UNKNOWN, FLAGS_GET_Z(ring->flags), FLAGS_GET_M(ring->flags)));	/* Return the result. */	return wkt_parser_curvepolygon_add_ring(poly,ring);}

/*** Create a new LWGEOM of the appropriate MULTI* type.*/LWGEOM *lwgeom_as_multi(const LWGEOM *lwgeom){	LWGEOM **ogeoms;	LWGEOM *ogeom = NULL;	GBOX *box = NULL;	int type;	/*	** This funx is a no-op only if a bbox cache is already present	** in input.	*/	if ( lwgeom_is_collection(lwgeom) )	{		return lwgeom_clone(lwgeom);	}	type = lwgeom->type;	if ( ! MULTITYPE[type] ) return lwgeom_clone(lwgeom);	if( lwgeom_is_empty(lwgeom) )	{		ogeom = (LWGEOM *)lwcollection_construct_empty(			MULTITYPE[type],			lwgeom->srid,			FLAGS_GET_Z(lwgeom->flags),			FLAGS_GET_M(lwgeom->flags)		);	}	else	{		ogeoms = lwalloc(sizeof(LWGEOM*));		ogeoms[0] = lwgeom_clone(lwgeom);		/* Sub-geometries are not allowed to have bboxes or SRIDs, move the bbox to the collection */		box = ogeoms[0]->bbox;		ogeoms[0]->bbox = NULL;		ogeoms[0]->srid = SRID_UNKNOWN;		ogeom = (LWGEOM *)lwcollection_construct(MULTITYPE[type], lwgeom->srid, box, 1, ogeoms);	}	return ogeom;}

static LWGEOM*lwline_split_by_point(const LWLINE* lwline_in, const LWPOINT* blade_in){	LWMLINE* out;	out = lwmline_construct_empty(lwline_in->srid,		FLAGS_GET_Z(lwline_in->flags),		FLAGS_GET_M(lwline_in->flags));	if ( lwline_split_by_point_to(lwline_in, blade_in, out) < 2 )	{		lwmline_add_lwline(out, lwline_clone_deep(lwline_in));	}	/* Turn multiline into collection */	out->type = COLLECTIONTYPE;	return (LWGEOM*)out;}

/* Convert a gidx to a gbox */static void gbox_from_gidx(GIDX *a, GBOX *gbox, int flags){	gbox->xmin = (double)GIDX_GET_MIN(a,0);	gbox->xmax = (double)GIDX_GET_MAX(a,0);	gbox->ymin = (double)GIDX_GET_MIN(a,1);	gbox->ymax = (double)GIDX_GET_MAX(a,1);	if ( FLAGS_GET_Z(flags) ) {		gbox->zmin = (double)GIDX_GET_MIN(a,2);		gbox->zmax = (double)GIDX_GET_MAX(a,2);	}	if ( FLAGS_GET_M(flags) ) {		gbox->mmin = (double)GIDX_GET_MIN(a,3);		gbox->mmax = (double)GIDX_GET_MAX(a,3);	}}

/* * Returns a POINTARRAY with consecutive equal points * removed. Equality test on all dimensions of input. * * Always returns a newly allocated object. * */POINTARRAY *ptarray_remove_repeated_points(POINTARRAY *in){	POINTARRAY* out;	size_t ptsize;	size_t ipn, opn;	LWDEBUG(3, "ptarray_remove_repeated_points called.");	/* Single or zero point arrays can't have duplicates */	if ( in->npoints < 3 ) return ptarray_clone_deep(in);	ptsize = ptarray_point_size(in);	LWDEBUGF(3, "ptsize: %d", ptsize);	/* Allocate enough space for all points */	out = ptarray_construct(FLAGS_GET_Z(in->flags),	                        FLAGS_GET_M(in->flags), in->npoints);	/* Now fill up the actual points (NOTE: could be optimized) */	opn=1;	memcpy(getPoint_internal(out, 0), getPoint_internal(in, 0), ptsize);	LWDEBUGF(3, " first point copied, out points: %d", opn);	for (ipn=1; ipn<in->npoints; ++ipn)	{		if ( (ipn==in->npoints-1 && opn==1) || memcmp(getPoint_internal(in, ipn-1),		        getPoint_internal(in, ipn), ptsize) )		{			/* The point is different from the previous,			 * we add it to output */			memcpy(getPoint_internal(out, opn++),			       getPoint_internal(in, ipn), ptsize);			LWDEBUGF(3, " Point %d differs from point %d. Out points: %d",			         ipn, ipn-1, opn);		}	}	LWDEBUGF(3, " in:%d out:%d", out->npoints, opn);	out->npoints = opn;	return out;}

Datum ST_LocateBetweenElevations(PG_FUNCTION_ARGS){	GSERIALIZED *geom_in = (GSERIALIZED *)PG_DETOAST_DATUM(PG_GETARG_DATUM(0));	double from = PG_GETARG_FLOAT8(1);	double to = PG_GETARG_FLOAT8(2);	LWCOLLECTION *geom_out = NULL;	LWGEOM *line_in = NULL;	char geomtype = gserialized_get_type(geom_in);	static int ordinate = 2; /* Z */	if ( ! ( geomtype == LINETYPE || geomtype == MULTILINETYPE ) )	{		elog(ERROR,"This function only accepts LINESTRING or MULTILINESTRING as arguments.");		PG_RETURN_NULL();	}	line_in = lwgeom_from_gserialized(geom_in);	if ( ! FLAGS_GET_Z(line_in->flags) )	{		elog(ERROR,"This function only accepts LINESTRING or MULTILINESTRING with Z values as arguments.");		PG_RETURN_NULL();	}	if ( geomtype == LINETYPE )	{		geom_out = lwline_clip_to_ordinate_range((LWLINE*)line_in, ordinate, from, to);	}	else if ( geomtype == MULTILINETYPE )	{		geom_out = lwmline_clip_to_ordinate_range((LWMLINE*)line_in, ordinate, from, to);	}	lwgeom_free(line_in);	if ( ! geom_out )	{		elog(ERROR,"The lwline_clip_to_ordinate_range returned null.");		PG_RETURN_NULL();	}	PG_FREE_IF_COPY(geom_in, 0);	PG_RETURN_POINTER(geometry_serialize((LWGEOM*)geom_out));}

int ptarray_calculate_gbox_cartesian(const POINTARRAY *pa, GBOX *gbox ){	int i;	POINT4D p;	int has_z, has_m;	if ( ! pa ) return LW_FAILURE;	if ( ! gbox ) return LW_FAILURE;	if ( pa->npoints < 1 ) return LW_FAILURE;	has_z = FLAGS_GET_Z(pa->flags);	has_m = FLAGS_GET_M(pa->flags);	gbox->flags = gflags(has_z, has_m, 0);	LWDEBUGF(4, "ptarray_calculate_gbox Z: %d M: %d", has_z, has_m);	getPoint4d_p(pa, 0, &p);	gbox->xmin = gbox->xmax = p.x;	gbox->ymin = gbox->ymax = p.y;	if ( has_z )		gbox->zmin = gbox->zmax = p.z;	if ( has_m )		gbox->mmin = gbox->mmax = p.m;	for ( i = 1 ; i < pa->npoints; i++ )	{		getPoint4d_p(pa, i, &p);		gbox->xmin = FP_MIN(gbox->xmin, p.x);		gbox->xmax = FP_MAX(gbox->xmax, p.x);		gbox->ymin = FP_MIN(gbox->ymin, p.y);		gbox->ymax = FP_MAX(gbox->ymax, p.y);		if ( has_z )		{			gbox->zmin = FP_MIN(gbox->zmin, p.z);			gbox->zmax = FP_MAX(gbox->zmax, p.z);		}		if ( has_m )		{			gbox->mmin = FP_MIN(gbox->mmin, p.m);			gbox->mmax = FP_MAX(gbox->mmax, p.m);		}	}	return LW_SUCCESS;}