GeomAdjacent(<geom>, <geom>, <tolerance>) : <value>
Given two geoms returns true if they are adjacent. A tolerance of zero means automatic tolerance. For the definition of adjacent see the Join topic.
GeomArea(<geom>, <tolerance>) : <value>
Given a geom that contains an area object, returns the area (Euclidean planar computation) of that area object in square units of measure used by the coordinate system. A tolerance of zero means automatic tolerance.
SELECT GeomArea([Geom], 0) AS [Computed Area] FROM [Mexico];
GeomAreaGeo(<geom>, <major>, <eccentricity>, <tolerance>): <value>
Given a geom that contains an area object, and values for major axis, eccentricity, and tolerance, returns the geodetic area (computed on the surface of the ellipsoid) of that area object. A tolerance of zero means automatic tolerance.
The geom value must be an area in Latitude / Longitude, with X (longitude) and Y (latitude) expressed in degrees. The returned value is in squared units of the major axis (typically, meters, for a returned value in square meters).
Looking at the Custom tab of the Base Coordinate System dialog for the WGS84 base used for Latitude / Longitude projection, we can see the major axis is 6378137.01 and the eccentricity is 0.08181919084262149
Given a Mexico drawing of provinces as areas in Latitude / Longitude coordinate system, we can write:
SELECT GeomAreaGeo([Geom], 6378137.01, 0.08181919084262149, 0) AS [Geodetic Area] FROM [Mexico];
GeomBearing(<geom>): <value>
Given a geom that contains a line object, returns the bearing (Euclidean planar computation) of that line object. The line must have a single branch.
The bearing is computed from the first to last coordinate of the line. The returned value is in degrees.
GeomBearingGeo(<geom>, <major>, <eccentricity>): <value>
Given a geom that contains a line object, and values for major axis, and eccentricity, returns the geodetic bearing (computed on the surface of the ellipsoid) of that line object.
The geom value must be a single-branch line in Latitude / Longitude, with X (longitude) and Y (latitude) expressed in degrees.
The geodetic bearing is computed from the first to last coordinate of the line, using Vincenty's formulae. The returned value is in degrees.
GeomBearingPoint(<valuex2>, <valuex2>): <value>
Given a pair of point (x2) values, returns the bearing (Euclidean planar computation) from the first point to the second point. The returned value is in degrees.
GeomBearingPointGeo(<valuex2>, <valuex2>, <major>, <eccentricity>): <value>
Given a pair of point (x2) values, and values for major axis, and eccentricity, returns the geodetic bearing (computed on the surface of the ellipsoid) from the first point to the second point, computed using Vincenty's formulae.
The point values must be in Latitude / Longitude, with X (longitude) and Y (latitude) expressed in degrees. The returned value is in degrees.
GeomBoundedAreas(<geom>, <tolerance>): <table>
Given line objects, creates areas in regions entirely enclosed by overlapping or otherwise touching lines. Areas and points are ignored. The Tolerance value specifies how close lines must be to each other to be considered "touching."
Line objects are normally merged before being used as the geom in this function, for example, as in:
GeomBoundedAreas(GeomMergeLines([Geom]), 0))
GeomBounds(<geom>) : <geom>
Given a geom, return a geom that in the case of areas is the border of the area and in the case of lines is the two end coordinates of the line as a multipoint. NULL is returned for points.
GeomBoundsCircle(<geom>, <tolerance>) : <geom>
Given a geom, return a geom for an area object that in the case of areas or lines is the minimal enclosing circle. NULL is returned for points. A tolerance of zero means automatic tolerance.
GeomBoundsRect(<geom>) : <valuex4>
Given a geom, return a float64x4 value that gives the location of diagonally opposite corners which define a vertically oriented rectangle that is the minimum enclosing rectangle for areas or lines. NULL is returned for points.
Use the GeomMakeRect function to create a rectangular area object from the float64x4 value returned by GeomBoundsRect, as in
UPDATE (
SELECT [mfd_id], [Geom],
GeomMakeRect(GeomBoundsRect([Geom])) AS [n_Geom]
FROM [Table Drawing]
) SET [Geom] = [n_Geom];
GeomBoundsRectRotated(<geom>, <tolerance>) : <geom>
Given a geom, return a float64x4 value that gives the location of diagonally opposite corners which define a rectangle of any orientation that is the minimum enclosing rectangle for areas or lines. NULL is returned for points. A tolerance of zero means automatic tolerance.
GeomBoundsX(<geom>): <minmaxx2>
Given a geometry value, reports the minimum and maximum X values of the geometry as an x2 value.
GeomBoundsY(<geom>): <minmaxx2>
Given a geometry value, reports the minimum and maximum Y values of the geometry as an x2 value.
GeomBoundsZ(<geom>): <minmaxx2>
Given a geometry value, reports the minimum and maximum Z values of the geometry as an x2 value.
GeomBranch(<geom>, <branch>) : <geom>
Takes a geom and a branch number (0 is the first branch) and returns the specified branch as a geom.
GeomBranchCount(<geom>) : <value>
Takes a geom and returns the number of branches in that geom.
GeomBranchFirst(<geom>, <branch>) : <value>
Given a geom and a branch number (0 is the first branch) returns the index of the first coordinate in the specified branch.
GeomBranchLast(<geom>, <branch>) : <value>
Given a geom and a branch number (0 is the first branch) returns the index of the last coordinate in the specified branch.
GeomBuffer(<geom>, <distance>, <tolerance>) : <geom>
Given a geom, a distance and a tolerance, returns a geom for an area object the border of which is the specified distance from any part of the object in the geom. A tolerance of zero means automatic tolerance.
GeomCenter(<geom>, <tolerance>) : <valuex2>
Given a geom returns a float64x2 value that specifies the location of the center of the minimum enclosing circle for areas and lines and which for points specifies the location of the point. A tolerance of zero means automatic tolerance.
GeomCenterInner(<geom>, <tolerance>) : <valuex2>
Given a geom returns a float64x2 value that specifies the location of the center of the minimum enclosing circle for areas, with the location adjusted so that it falls within the area object. NULL is returned for lines and points. A tolerance of zero means automatic tolerance.
GeomCenterWeight(<geom>, <tolerance>) : <valuex2>
Given a geom returns a float64x2 value that specifies the location of the balance point for areas NULL is returned for lines and points. A tolerance of zero means automatic tolerance.
GeomClip(<geom>, <geom>, <inner>, <tolerance>) : <geom>
Given two geoms, use the geom in the second argument to "cookie cut," that is, to clip, the geom in the first argument, returning the result as a geom. If the <inner> argument is true, leave the inner portion of the cut. If the <inner> argument is false, leave the outer portion. A tolerance of zero means automatic tolerance. See illustrations and discussion in the Example: Clip Areas with a Transform Expression topic.
GeomContains(<geom>, <geom>, <tolerance>) : <value>
Given two geoms returns true if the first geom contains the second geom. A tolerance of zero means automatic tolerance. For the definition of contains see the Join topic.
Example: A table contains a geom field called Buffer which are buffer areas that are larger than and were created from objects in the Geom field using the GeomBuffer function. The Buffer objects contain the Geom objects.
SELECT GeomContains([Buffer], [Geom], 0) FROM [Table];
The above returns a results table where all rows have 1 for true because all of the Buffer objects fully contain the corresponding Geom object.
SELECT GeomContains([Geom], [Buffer], 0) FROM [Table];
The above returns a results table where all rows have 0 for false, because none of the Geom objects contain the corresponding Buffer object.
GeomConvertToArea(<geom>) : <geom>
Takes a geom of arbitrary type and converts it to an area geom. Branches are auto-closed (if the starting coordinate of the branch does not coincide with the ending coordinate, the starting coordinate is added once again at the end). Curves and Z values are preserved. Points which are single-branched multipoints are converted to areas. Points that are not single-branched multipoints are converted into pathological areas defined by three coordinates that are all at the same location, of each point or point branch.
GeomConvertToLine(<geom>) : <geom>
Takes a geom of arbitrary type and converts it to a line geom. Curves and Z values are preserved. Points are converted into pathological lines defined by two coordinates that are both at the same location.
GeomConvertToPoint(<geom>, <keepBranches>) : <geom>
Takes a geom of arbitrary type and converts it to a point geom. Converting objects such as areas, lines or multipoints will result in a multipoint. The <keepBranches> argument is true or false, controlling whether to keep original branches (true) or join all coordinates into a single branch (false). Z values are preserved.
GeomConvexHull(<geom>, <allowSegmentPoint>, <tolerance>) : <geom>
Given a geom, return an area object geom that is the convex hull enclosing the geom. The allowSegmentPoint> boolean parameter specifies what is returned when the produced convex hull is a single point or a straight line segment. When false, NULL is returned. When true, an area with coincident coordinates is returned. A tolerance of zero means automatic tolerance.
GeomCoordCount(<geom>) : <value>
Given a geom returns the number of coordinates in the object the geom contains. A triangular area contains 4 coordinates because the last coordinate is the same as the first to close the area.
GeomCoordLine(<geom>, <position>) : <valuex2>
Given a geom and a distance position, returns the coordinate on the line at the specified distance from the start of the line. The function considers all line branches: If the first branch ends before the specified distance, the function moves on to check the second branch and so on, until the distance is reached. If the distance is negative or greater than the total length of all line branches, the function returns a NULL value.
GeomCoordX(<geom>, <coord>): <value>
Given a geom and the index of a coordinate in that geom (0 based numbering, the first coordinate is the 0 coordinate), returns the value of the X coordinate number for that geom coordinate.
Suppose we have a drawing with points. The drawing's table has X, Y, and Z float64 fields which we would like to populate with the X and Y coordinates in each point's geom, and the Z field with any Z value for each point:
UPDATE [Drawing Table] SET
[X] = GeomCoordX([Geom], 0),
[Y] = GeomCoordY([Geom], 0),
[Z] = GeomCoordZ([Geom], 0);
GeomCoordXY(<geom>, <coord>) : <valuex2>
Given a geom and the index of a coordinate in that geom (0 based numbering, the first coordinate is the 0 coordinate), returns the value of that coordinate as a float64x2 value, representing the X and the Y coordinate numbers.
GeomCoordXYZ(<geom>, <coord>) : <valuex3>
Given a geom and the index of a coordinate in that geom (0 based numbering, the first coordinate is the 0 coordinate), returns the value of that coordinate as a float64x3 value, representing the X, Y and Z coordinate numbers.
To test if a geom has a Z value, use GeomHasZ. To set the Z values for all coordinates of a geom to a specified value, use GeomSetZ. To remove all Z values, use GeomRemoveZ. To read the Z value of the first coordinate of a geom, use
VectorValue(GeomCoordXYZ([Geom],0),2)
GeomCoordY(<geom>, <coord>): <value>
Given a geom and the index of a coordinate in that geom (0 based numbering, the first coordinate is the 0 coordinate), returns the value of the Y coordinate number for that geom coordinate.
Suppose we have a drawing with points. The drawing's table has X, Y, and Z float64 fields which we would like to populate with the X and Y coordinates in each point's geom, and the Z field with any Z value for each point:
UPDATE [Drawing Table] SET
[X] = GeomCoordX([Geom], 0),
[Y] = GeomCoordY([Geom], 0),
[Z] = GeomCoordZ([Geom], 0);
GeomCoordZ(<geom>, <coord>): <value>
Given a geom and the index of a coordinate in that geom (0 based numbering, the first coordinate is the 0 coordinate), returns the value of the Z coordinate number for that geom coordinate.
Suppose we have a drawing with points. The drawing's table has X, Y, and Z float64 fields which we would like to populate with the X and Y coordinates in each point's geom, and the Z field with any Z value for each point:
UPDATE [Drawing Table] SET
[X] = GeomCoordX([Geom], 0),
[Y] = GeomCoordY([Geom], 0),
[Z] = GeomCoordZ([Geom], 0);
GeomCurveCount(<geom>, <curveType>): <value>
Given a geom and the type of curvilinear segment to count, returns the number of curvilinear segments in the geom.
<curveType> specifies the type of curvilinear segment: Negative values or a value of 0 = count any curvilinear segment. Positive values = count curvilinear segments of a specific type, with 1 = Circle, 2 = Ellipse, and 3 = Spline.
GeomDistance(<geom>, <geom>, <tolerance>) : <value>
Takes two geoms and returns the Euclidean distance between the geoms, reported in whatever units are used for the geoms. The geoms are assumed to be in the same coordinate system. A tolerance of zero means automatic tolerance.
GeomDistancePoint(<valuex2>, <valuex2>) : <value>
Takes a pair of point (x2) values and returns the Euclidean distance in the 2D plane between the locations defined by these values.
GeomDistancePoint3(<valuex3>, <valuex3>) : <value>
Takes a pair of point (x3) values and returns the Euclidean distance in 3D space between the locations defined by these values.
GeomDistancePointGeo(<valuex2>, <valuex2>, <major>, <eccentricity>): <value>
Takes a pair of point (x2) values, and values for major axis, and eccentricity, and returns the geodetic distance (computed on the surface of the ellipsoid) from the first point to the second point, computed using Vincenty's formulae.
The point values must be in Latitude / Longitude, with X (longitude) and Y (latitude) expressed in degrees. The returned value is in units of the major axis
GeomFlip(<geom>, <horz>, <vert>): <geom>
Takes a geom, a boolean to specify horizontal flipping, and a boolean to specify vertical flipping, and returns a geom flipped horizontally and vertically as specified, about the centroid of the object. Z values are preserved and 2D curvilinear segments are preserved, but 3D curvilinear segments are replaced with 3D straight line segments.
GeomGml(<geom>, <system>) : <gml>
Takes a geom and an optional coordinate system (pass an empty string for no optional coordinate system) and returns GML for the geom.
SELECT GeomGml([Geom],'') FROM [Table];
for no optional coordinate system, and
SELECT GeomGml([Geom],'EPSG:4200') FROM [Table];
to specify EPSG:4200 as the coordinate system.
GeomHasCurves(<geom>) : <value>
Takes a geom and returns true if the geom has any curvilinear segments.
GeomHasZ(<geom>) : <value>
Takes a geom and returns true if the geom has a Z value, that is, is 3D.
To set the Z values for all coordinates of a geom to a specified value, use GeomSetZ. To remove all Z values, use GeomRemoveZ. To read the Z value of the first coordinate of a geom, use
VectorValue(GeomCoordXYZ([Geom],0),2)
GeomInflateRect(<valuex4>, <inflatex2>): <valuex4>
GeomInflateRectTileSize(<valuex4>, <tilesizex2>): <valuex4>
A rect is a rectangular extent given by a four part (x4) number given the diagonally opposite corners of the rectangle as x1,y1, x2,y2 values. To inflate a rect means to increase the size of the rectangle, and to deflate a rect means to decrease the size of the rectangle.
See the discussion of rects in the SQL Example: Miscellaneous SQL Functions topic.
GeomInflateRect inflates a rect by increasing the size of the rectangle by the given X,Y values in the two part (x2) <inflatex2> value. If the X or Y values are negative, the rectangle will be deflated, that is reduced by those values.
Consider a rectangle defined by a lower left x1,y1 corner of 0,0 and an upper right x2, y2 corner of 10,10. We want to inflate the rectangle by two units in both X and Y.
In the Command Window we run the expression:
? GeomInflateRect(VectorMakeX4(0,0,10,10), VectorMakeX2(2,2))
That yields the result:
float64x4: [ -2, -2, 12, 12 ]
The result gives a new rect, with a new lower left corner of -2,-2 and a new upper right corner of 12,12. The overall size of the rectangle has been increased by 2 units in both X and Y direction.
Suppose we run the expression:
? GeomInflateRect(VectorMakeX4(0,0,10,10), VectorMakeX2(-2,-2))
That yields the result:
float64x4: [ 2, 2, 8, 8 ]
The new rect has been contracted by two units in X and Y dimension, with a new lower left corner of 2,2 and a new upper right corner of 8,8.
GeomInflateRectTileSize takes a <tilesizex2> argument giving the size of a tile, such as 128,128, and adjusts the rect size by inflating it to cover whole tiles of the given size.
Consider a rectangle defined by a lower left x1,y1 corner of 0,0 and an upper right x2, y2 corner of 1040,1040. We want to inflate the rectangle so the extent exactly covers a whole number of 128,128 tiles in both X and Y dimension
In the Command Window we run the expression:
? GeomInflateRectTileSize(VectorMakeX4(0,0,1040,1040),
VectorMakeX2(128,128))
That yields the result:
float64x4: [ 0, 0, 1152, 1152 ]
The result gives a new rect, with a new lower left corner of 0,0 and a new upper right corner of 1152,1152. Note that 1152 is exactly 9 tiles of width or height 128.
The GeomInflateRectTileSize function always inflates, increasing the size of the rect to the next whole number of tiles.
GeomIntersectLines(<geom>, <geom>, <tolerance>) : <geom>
Takes a set of lines and returns their intersection points as a geom. The geom will be one point, one intersection and will be a multipoint if there are multiple intersections. A tolerance of zero means automatic tolerance.
GeomIntersects(<geom>, <geom>, <tolerance>) : <value>
Given two geoms returns true if they intersect. A tolerance of zero means automatic tolerance. For the definition of intersect see the Join topic.
GeomIsArea(<geom>) : <value>
Returns true if the geom is an area.
GeomIsLine(<geom>) : <value>
Returns true if the geom is a line.
GeomIsLineClosed(<geom>): <value>
Returns true if each branch in a line geom is closed, that is, if each branch has the starting coordinate equal to the ending coordinate.
GeomIsNormalized(<geom>) : <value>
Returns true if the geom is normalized. Use within the Select pane's Expression template for geometry fields to select normalized geoms.
The system keeps track of geoms that have been normalized. Normalized geometry values store an explicit normalized flag plus additional normalize data which allows quickly transforming geometry either to normalized form required by OGC or to the different normalized form required by ESRI.
GeomIsPoint(<geom>) : <value>
Returns true if the geom is a point.
GeomJsonGeo(<geom>, <system>) : <json>
Takes a geom and an optional coordinate system (pass an empty string for no optional coordinate system) and returns GeoJSON for the geom.
SELECT GeomJsonGeo([Geom],'') FROM [Table];
for no optional coordinate system, and
SELECT GeomJsonGeo([Geom],'EPSG:4200') FROM [Table];
to specify EPSG:4200 as the coordinate system.
GeomLength(<geom>, <tolerance>) : <value>
Given a geom returns the length of lines and areas in native units of the coordinate system, using Euclidean measures in the plane of the coordinate system. NULL is returned for points. A tolerance of zero means automatic tolerance. The length of an area object is the length of its boundary, that is, the perimeter of the area. The length reported for a branched object is the sum of the lengths of the branches.
SELECT GeomLength([Geom], 0) FROM [Table];
GeomLengthGeo(<geom>, <major>, <eccentricity>, <tolerance>): <value>
Given a geom that contains an area or a line object, and values for major axis, eccentricity, and tolerance, returns the geodetic length (computed on the surface of the ellipsoid) of that object, computed using Vincenty's formulae A tolerance of zero means automatic tolerance.
The length of an area object is the length of its boundary, that is, the perimeter of the area. The length reported for a branched object is the sum of the lengths of the branches.
The geom value must be an area or line in Latitude / Longitude, with X (longitude) and Y (latitude) expressed in degrees. The returned value is in units of the major axis.
Looking at the Custom tab of the Base Coordinate System dialog for the WGS84 base used for Latitude / Longitude projection, we can see the major axis is 6378137.01 and the eccentricity is 0.08181919084262149
Given a Mexico drawing of provinces as areas in Latitude / Longitude coordinate system, we can write:
SELECT GeomLengthGeo([Geom], 6378137.01, 0.08181919084262149, 0) AS [Geodetic Length] FROM [Mexico];
GeomLinearize(<geom>, <tolerance>, <limit>) : <geom>
Convert curvilinear segments to straight line segments. Takes a geom, linearizes all curvilinear segments and returns the result. A tolerance of zero means automatic tolerance. The linearization process is guided by the tolerance value and the maximum number of coordinates, 1 or more specified as the <limit> argument, to which a single curve part (for example, between two control points of a spline) of a curvilinear segment will be expanded.
GeomMakeCircle(<valuex2>, <radius>) : <geom>
Takes an x2 value that defines the center and a radius value and returns a geom for a circular area object centered on that location with that radius.
GeomMakePoint(<valuex2>) : <geom>
Takes an x2 value that defines a location and returns a geom for a point object at that location.
GeomMakePoint3(<valuex3>) : <geom>
Takes an x3 value that defines a 3D location (X, Y and Z) and returns a geom for a 3D point object at that location.
GeomMakeRect(<valuex4>) : <geom>
Takes an x4 value that defines diagonally opposite corners of a rectangle and returns a geom for a rectangular area object defined by those corner locations. See the discussion of rects in the SQL Example: Miscellaneous SQL Functions topic.
GeomMakeRectDiagonal(<valuex2>, <valuex2>) : <geom>
Takes a pair of x2 values that define diagonally opposite corners of a rectangle and returns a geom for a rectangular area object defined by those corner locations. See the discussion of rects in the SQL Example: Miscellaneous SQL Functions topic.
GeomMakeSegment(<valuex2>, <valuex2>) : <geom>
Takes a pair of x2 values and returns a line geom consisting of a straight line segment between those two locations.
GeomMakeSegment3(<valuex3>, <valuex3>) : <geom>
Takes a pair of x3 values and returns a 3D line geom consisting of a straight line segment between those two 3D locations.
GeomMakeTriangle(<valuex2>, <valuex2>, <valuex2>) : <geom>
Takes three x2 values that define the corners of a triangle and returns a geom for a triangular area object defined by those corner locations.
GeomMakeTriangle3(<valuex3>, <valuex3>, <valuex3>) : <geom>
Takes three x3 values that define the corners of a triangle in 3D and returns a geom for a 3D triangular area object defined by those corner locations.
GeomMergeAreas
GeomMergeLines
GeomMergePoints
The GeomMergeAreas, GeomMergeLines, and GeomMergePoints functions are aggregate functions. See the Aggregate SQL Functions topic.
GeomNormalize(<geom>, <tolerance>) : <geom>
Normalize object metrics by removing redundant coordinates and note the geom has been normalized. A tolerance of zero means automatic tolerance. The function retains Z values if the object has Z values.
GeomNormalizeTopology(<drawing>, <tolerance>) : <table>
Takes a drawing and returns a table with the drawing's geoms normalized, providing a table with the same fields but with the values in the geom field altered. A tolerance of zero means automatic tolerance.
GeomOverlayAdjacent(<drawing>, <overlay>, <tolerance>) : <table>
Combines fields between a source drawing and an overlay drawing, finding cases where objects in the overlay are adjacent to objects in the source. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows: Every object in the source drawing that is not adjacent to an object in the overlay drawing will appear as a row in the table with values for the o_ fields set to NULL. Every object in the source drawing that is adjacent to one or more objects in the overlay drawing will appear in one or more rows in the table with values for the o_ fields populated from the corresponding object to which it is adjacent.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayAdjacent Function topic.
GeomOverlayAdjacentPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayAdjacent function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayAdjacent function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayAdjacentFilter(<drawing>, <overlay>, <tolerance>): <table>
Takes a source drawing and an overlay drawing, finds all objects in the source drawing that are adjacent to any object in the overlay drawing, and filters the source drawing leaving only objects which are adjacent to at least one object in the overlay drawing. Unlike the result table of GeomOverlayAdjacent, the result table of GeomOverlayAdjacentFilter includes all fields from the source drawing and no fields from the overlay drawing.
Result tables returned by GeomOverlayXxxFilter functions contain all indexes from the source table and are writable. It is possible to chain calls to these functions as well as calls to SelectionXxx functions.
Example: The following query returns all states touching selected parcels:
TABLE CALL GeomOverlayTouchingFilter(states,
CALL Selection(parcels, TRUE), 0);
GeomOverlayAdjacentFilterPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayAdjacentFilter function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayAdjacentFilter function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayContained(<drawing>, <overlay>, <tolerance>) : <table>
Combines fields between a source drawing and an overlay drawing, finding cases where objects in the overlay are contained by objects in the source. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows: Every object in the source drawing that does not contain an object in the overlay drawing will appear as a row in the table with values for the o_ fields set to NULL. Every object in the source drawing that does contain one or more objects in the overlay drawing will appear in one or more rows in the table with values for the o_ fields populated from the corresponding object to which it is adjacent.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayAdjacent Function topic for an example of how functions like this are used.
GeomOverlayContainedPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayContained function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayContained function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayContainedFilter(<drawing>, <overlay>, <tolerance>) : <table>
Takes a source drawing and an overlay drawing, finds all objects in the source drawing that are contained by any object in the overlay drawing, and filters the source drawing leaving only objects which are contained by at least one object in the overlay drawing. Unlike the result table of GeomOverlayContained, the result table of GeomOverlayContainedFilter includes all fields from the source drawing and no fields from the overlay drawing.
Result tables returned by GeomOverlayXxxFilter functions contain all indexes from the source table and are writable. It is possible to chain calls to these functions as well as calls to SelectionXxx functions.
Example: The following query returns all states touching selected parcels:
TABLE CALL GeomOverlayTouchingFilter(states,
CALL Selection(parcels, TRUE), 0);
GeomOverlayContainedFilterPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayContainedFilter function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayContainedFilter function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayContaining(<drawing>, <overlay>, <tolerance>) : <table>
Combines fields between a source drawing and an overlay drawing, finding cases where objects in the overlay are containing objects in the source. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows: Every object in the source drawing that is not contained by an object in the overlay drawing will appear as a row in the table with values for the o_ fields set to NULL. Every object in the source drawing that is contained by one or more objects in the overlay drawing will appear in one or more rows in the table with values for the o_ fields populated from the corresponding object to which it is adjacent.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayAdjacent Function topic for an example of how functions like this are used.
GeomOverlayContainingPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayContaining function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayContaining function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayContainingFilter(<drawing>, <overlay>, <tolerance>) : <table>
Takes a source drawing and an overlay drawing, finds all objects in the source drawing that contain any object in the overlay drawing, and filters the source drawing leaving only objects which contain at least one object in the overlay drawing. Unlike the result table of GeomOverlayContaining, the result table of GeomOverlayContainingFilter includes all fields from the source drawing and no fields from the overlay drawing.
Result tables returned by GeomOverlayXxxFilter functions contain all indexes from the source table and are writable. It is possible to chain calls to these functions as well as calls to SelectionXxx functions.
Example: The following query returns all states touching selected parcels:
TABLE CALL GeomOverlayTouchingFilter(states,
CALL Selection(parcels, TRUE), 0);
GeomOverlayContainingFilterPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayContainingFilter function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayContainingFilter function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayIntersecting(<drawing>, <overlay>, <tolerance>) : <table>
Combines fields between a source drawing and an overlay drawing, finding cases where objects in the overlay are intersecting objects in the source. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows: Every object in the source drawing that is not intersected by an object in the overlay drawing will appear as a row in the table with values for the o_ fields set to NULL. Every object in the source drawing that is intersected by one or more objects in the overlay drawing will appear in one or more rows in the table with values for the o_ fields populated from the corresponding object to which it is adjacent.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayAdjacent Function topic for an example of how functions like this are used.
GeomOverlayIntersectingPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayIntersecting function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayIntersecting function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayIntersectingFilter(<drawing>, <overlay>, <tolerance>) : <table>
Takes a source drawing and an overlay drawing, finds all objects in the source drawing that intersect any object in the overlay drawing, and filters the source drawing leaving only objects which intersect at least one object in the overlay drawing. Unlike the result table of GeomOverlayIntersecting, the result table of GeomOverlayIntersectingFilter includes all fields from the source drawing and no fields from the overlay drawing.
Result tables returned by GeomOverlayXxxFilter functions contain all indexes from the source table and are writable. It is possible to chain calls to these functions as well as calls to SelectionXxx functions.
Example: The following query returns all states touching selected parcels:
TABLE CALL GeomOverlayTouchingFilter(states,
CALL Selection(parcels, TRUE), 0);
GeomOverlayIntersectingFilterPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayIntersectingFilter function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayIntersectingFilter function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayTopologyIdentity(<drawing>, <overlay>, <tolerance>) : <table>
Using the area boundaries of objects in the overlay drawing, slice all objects in the source drawing into regions that are overlapped by objects in the overlay drawing and that are not overlapped by objects in the overlay drawing. Save all the pieces thus created as geoms into the result table. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows for non-intersecting objects: Every region of an object in the source drawing that is not intersected by an object in the overlay drawing will appear as a row in the table with values for the o_ fields set to NULL.
Rows for intersecting objects: Every region of an object in the source drawing that is intersected by one or more objects in the overlay drawing will appear as a single row in the table with s_ fields and o_ fields populated by the respective objects from the source and overlay drawings that intersected.
If the overlay drawing is empty (contains no objects), the result will be composed from only the source drawing.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayTopologyUnion Function topic for an example of how functions like this are used.
GeomOverlayTopologyIdentityPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayTopologyIdentity function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayTopologyIdentity function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayTopologyIntersect(<drawing>, <overlay>, <tolerance>) : <table>
Locate regions of intersection and save them into the results table. Slices all objects in each drawing with the area boundaries of objects in the other drawing and then places geoms for all regions of intersection, discarding duplicates, into the result table. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows: Each region of intersection will appear as a row in the table with s_ fields and o_ fields populated by the respective objects from the source and overlay drawings that intersected.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayTopologyUnion Function topic for an example of how functions like this are used.
GeomOverlayTopologyIntersectPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayTopologyIntersect function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayTopologyIntersect function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayTopologyUnion(<drawing>, <overlay>, <tolerance>) : <table>
Slices all objects in each drawing with the area boundaries of objects in the other drawing and then places geoms for all pieces, discarding duplicates, into the result table. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows for non-intersecting objects: Every object in the source drawing that is not intersected by an object in the overlay drawing will appear as a row in the table with values for the o_ fields set to NULL. Every object in the overlay drawing that is not intersected by an object in the source drawing will appear as a row in the table with values for the s_ fields set to NULL.
Rows for intersecting objects: Every object in the source drawing that is intersected by one or more objects in the overlay drawing will appear as a single row in the table with values for the o_ fields set to NULL but will have the geom altered to remove all regions of intersection from the object. Each region of intersection will appear as a row in the table with s_ fields and o_ fields populated by the respective objects from the source and overlay drawings that intersected.
If either the source drawing or the overlay drawing is empty (contains no objects), the result will be composed from only the other drawing.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayTopologyUnion Function topic for an example of how functions like this are used.
GeomOverlayTopologyUnionPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayTopologyUnion function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayTopologyUnion function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayTopologyUpdate(<drawing>, <overlay>, <tolerance>) : <table>
Keep all objects in the overlay drawing. In the source drawing cut out and discard any portions of objects in the source drawing that intersect with objects in the overlay drawing and leave the remaining portions. Place geoms for all objects in the overlay drawing plus non-intersecting portions of objects in the source drawing into the result table. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows for non-intersecting objects: Every object in the overlay drawing will appear as a row in the table with values for the s_ fields set to NULL. Every object in the source drawing that is not intersected by an object in the overlay drawing will appear as a row in the table with values for the o_ fields set to NULL.
Rows for intersecting objects: Every object in the source drawing that is intersected by one or more objects in the overlay drawing will appear as a single row in the table with values for the o_ fields set to NULL but will have the geom altered to remove all regions of intersection from the object.
If either the source drawing or the overlay drawing is empty (contains no objects), the result will be composed from only the other drawing.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayTopologyUnion Function topic for an example of how functions like this are used.
GeomOverlayTopologyUpdatePar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayTopologyUpdate function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayTopologyUpdate function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayTouching(<drawing>, <overlay>, <tolerance>) : <table>
Combines fields between a source drawing and an overlay drawing, finding cases where objects in the overlay are touching objects in the source. Given a drawing and an overlay drawing, returns a table with the following characteristics:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows: Every object in the source drawing that is not touched by an object in the overlay drawing will appear as a row in the table with values for the o_ fields set to NULL. Every object in the source drawing that is touched by one or more objects in the overlay drawing will appear in one or more rows in the table with values for the o_ fields populated from the corresponding object to which it is adjacent.
A tolerance of zero means automatic tolerance. The table supports all indexes of the source drawing. The overlay is performed in the coordinate system of the source drawing; objects in the overlay drawing are automatically converted to that coordinate system as necessary. We can use the table created by this function as desired in subsequent operations, for example, creating a drawing via a query that uses aggregates.
See the SQL Example: GeomOverlayAdjacent Function topic for an example of how functions like this are used.
GeomOverlayTouchingPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayTouching function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayTouching function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomOverlayTouchingFilter(<drawing>, <overlay>, <tolerance>) : <table>
Takes a source drawing and an overlay drawing, finds all objects in the source drawing that touches any object in the overlay drawing, and filters the source drawing leaving only objects which touch at least one object in the overlay drawing. Unlike the result table of GeomOverlayTouching, the result table of GeomOverlayTouchingFilter includes all fields from the source drawing and no fields from the overlay drawing.
Result tables returned by GeomOverlayXxxFilter functions contain all indexes from the source table and are writable. It is possible to chain calls to these functions as well as calls to SelectionXxx functions.
Example: The following query returns all states touching selected parcels:
TABLE CALL GeomOverlayTouchingFilter(states,
CALL Selection(parcels, TRUE), 0);
GeomOverlayTouchingFilterPar(<drawing>, <overlay>, <tolerance>, <config>) : <table>
A parallel form of the GeomOverlayTouchingFilter function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayTouchingFilter function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
Example: The following query returns all states touching selected parcels, using all available threads:
TABLE CALL GeomOverlayTouchingFilterPar(states,
CALL Selection(parcels, TRUE), 0, ThreadConfig(SystemCpuCount()));
GeomOverlayWithin(<drawing>, <overlay>, <distance>, <tolerance>): <table>
Given a source drawing, an overlay drawing, and a distance using the unit of measure for the coordinate system of the source drawing, return all pairs of geoms in the source drawing and the overlay drawing that are within the specified distance. A tolerance of zero means automatic tolerance. Distances are computed for area and line objects as the distance to the closest part of the object.
Contents of the results table:
Columns: The returned table will contain all fields from the source drawing and all fields from the overlay drawing. Fields from the source drawing will have their names prefixed with s_ for source. Fields from the overlay drawing will have their names prefixed with o_ for overlay.
Rows: Every object in the source drawing that does not have any objects in the overlay drawing within the specified distance will appear as a row in the table with values for the o_ fields set to NULL. Every object in the source drawing that does have one or more objects in the overlay drawing within the specified distance will appear in one or more rows in the table with values for the o_ fields populated from the corresponding object within the specified distance.
Example: Given two drawings, a drawing of airports as points using Pseudo-Mercator projection (units of measure are meters) and a drawing of cities as points, the following query returns a table where each row is an airport and a city within 150 kilometers of that airport. Airports that have no city within 150 kilometers will appear in the table with NULL values for the overlay fields.
TABLE CALL GeomOverlayWithin([Airports], [Cities], 150000, 0);
Example: Return all airports with selected cities within 150 kilometers. This is a way of finding which airports are within 150 km of selected cities. Airports that have no selected city within 150 kilometers will appear in the table with NULL values for the overlay fields.
TABLE CALL GeomOverlayWithin([Airports],
CALL Selection([Cities], TRUE), 150000, 0);
Example: Given two drawings, a drawing of airports as points using Pseudo-Mercator projection (units of measure are meters) and a drawing of provinces as polygonal areas, the following query returns a table where each row is an airport and a province where the closest part of the province is within 150 kilometers of that airport. Airports that have no part of any province within 150 kilometers will appear in the table with NULL values for the overlay fields.
TABLE CALL GeomOverlayWithin([Airports], [Provinces], 150000, 0);
Example: As above, but for selected provinces.
TABLE CALL GeomOverlayWithin([Airports],
CALL Selection([Provinces], TRUE), 150000, 0);
GeomOverlayWithinPar(<drawing>, <overlay>, <distance>, <tolerance>, <config>): <table>
A parallel form of the GeomOverlayWithin function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayWithin function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
Example: Return all pairs of airports and cities within 150 km, using all available threads:
TABLE CALL GeomOverlayWithin([Airports],
[Cities], 150000, 0, ThreadConfig(SystemCpuCount()));
Example: Return all airports with selected cities within 150 kilometers, using all available threads:
TABLE CALL GeomOverlayWithinPar([Airports],
CALL Selection([Cities], TRUE), 150000, 0, ThreadConfig(SystemCpuCount()));
GeomOverlayWithinFilter(<drawing>, <overlay>, <distance>, <tolerance>): <table>
Given a source drawing, an overlay drawing, and a distance using the unit of measure for the coordinate system of the source drawing, return all geoms in the source drawing for which there is at least one geom within the specified distance in the overlay drawing.. A tolerance of zero means automatic tolerance. Distances are computed for area and line objects as the distance to the closest part of the object.
Contents of the results table:
Columns: The returned table will contain all fields from the source drawing and no fields from the overlay drawing. Fields from the source drawing will have the same names as in the source table.
Rows: Only those objects in the source drawing that do have one or more objects in the overlay drawing within the specified distance will appear in the result table, each such object appearing in a single row.
Example: Given two drawings, a drawing of airports as points using Pseudo-Mercator projection (units of measure are meters) and a drawing of cities as points, the following query returns a table where each row is an airport that has one or more cities within 150 kilometers of that airport. Airports that have no city within 150 kilometers will not appear in the table
TABLE CALL GeomOverlayWithinFilter([Airports], [Cities], 150000, 0);
Example: Return all airports that have a selected city within 150 kilometers. This is a way of finding which airports are within 150 km of selected cities. Airports that have no selected city within 150 kilometers will not appear in the table.
TABLE CALL GeomOverlayWithinFilter([Airports],
CALL Selection([Cities], TRUE), 150000, 0);
GeomOverlayWithinFilterPar(<drawing>, <overlay>, <distance>, <tolerance>, <config>): <table>
A parallel form of the GeomOverlayWithinFilter function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomOverlayWithinFilter function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
Example: Return all airports with one or more cities within 150 km, using all available threads:
TABLE CALL GeomOverlayWithinFilter([Airports],
[Cities], 150000, 0, ThreadConfig(SystemCpuCount()));
Example: Return all airports with one or more selected cities within 150 kilometers, using all available threads:
TABLE CALL GeomOverlayWithinFilterPar([Airports],
CALL Selection([Cities], TRUE), 150000, 0, ThreadConfig(SystemCpuCount()));
GeomPartLine(<line>, <begin>, <end>): <geom>
Given a geom that is a line, and beginning and end distances, return a line that is the part of the line between the two specified distances. If the begin distance is larger than the end distance, the returned line goes in the direction opposite to the original line.
GeomRemoveCurves(<geom>) : <geom>
Returns a geom where each curved segment of an area or line object in the source geom has been replaced with a single straight segment. Geoms without curved segments are unchanged.
GeomRemoveZ(<geom>) : <geom>
Takes a geom and returns the same geom without Z values. Geoms without Z values are left unchanged. For geoms with Z values curves are replaced with straight line segments, because 3D curves can not be used with a 2D geom.
To test if a geom has a Z value, use GeomHasZ. To set the Z values for all coordinates of a geom to a specified value, use GeomSetZ. To read the Z value of the first coordinate of a geom, use
VectorValue(GeomCoordXYZ([Geom],0),2)
GeomReverseLine(<geom>): <geom>
Takes a geom for a line and reverses the order of coordinates defining the line. Preserves curvilinear segments and Z values.
GeomRotate(<geom>, <centerx2>, <angle>) : <geom>
Takes a geom, a rotation center as an x2 vector value, a rotation angle in degrees, and returns a rotated geom. The rotation direction is counterclockwise. Z values are preserved but curves are replaced with straight line segments.
GeomScale(<geom>, <scalex2>): <geom>
A version of GeomScaleShift with shift set to 0 for both X and Y. Takes a geom, an x2 vector for scale values in X and Y direction, and returns a geom with no shift and with those scale values applied. Z values are preserved and 2D curvilinear segments are preserved, but 3D curvilinear segments are replaced with 3D straight line segments.
Caveat: attempting to apply uneven XY scales to a circular arc will currently not convert it to an ellipse arc, and will instead compose a new circular arc that passes through the scaled ends and the scaled control point. Future builds will address that with a slight rework of curves in geoms.
GeomScaleCentered(<geom>, <scalex2>, <centerx2>) : <geom>
Takes a geom, an x2 vector for scale factor values in X and Y direction, an x2 vector for X and Y location of a center in the units of the coordinate system used, and returns a geom with the scale applied around the specified center location. Z values are preserved and 2D curvilinear segments are preserved, but 3D curvilinear segments are replaced with 3D straight line segments.
Caveat: attempting to apply uneven XY scales to a circular arc will currently not convert it to an ellipse arc, and will instead compose a new circular arc that passes through the scaled ends and the scaled control point. Future builds will address that with a slight rework of curves in geoms.
GeomScaleRev(<geom>, <scalex2>): <geom>
An inverse version of GeomScale. A version of GeomScaleShift with shift set to 0 for both X and Y. Takes a geom, an x2 vector for scale values in X and Y direction, and returns a geom with no shift and with those scale values applied as 1/scale. Unscales back to the original scale a geom that previously was rescaled using GeomScale. Z values are preserved and 2D curvilinear segments are preserved, but 3D curvilinear segments are replaced with 3D straight line segments.
Caveat: attempting to apply uneven XY scales to a circular arc will currently not convert it to an ellipse arc, and will instead compose a new circular arc that passes through the scaled ends and the scaled control point. Future builds will address that with a slight rework of curves in geoms.
GeomScaleShift(<geom>, <scalex2>, <shiftx2>) : <geom>
Takes a geom, an x2 vector for scale factor values in X and Y direction, an x2 vector for shift values in X and Y direction in the units of the coordinate system used, and returns a geom with those scale and shift values applied. Z values are preserved and 2D curvilinear segments are preserved, but 3D curvilinear segments are replaced with 3D straight line segments.
Caveat: attempting to apply uneven XY scales to a circular arc will currently not convert it to an ellipse arc, and will instead compose a new circular arc that passes through the scaled ends and the scaled control point. Future builds will address that with a slight rework of curves in geoms.
GeomScaleShiftZ(<geom>, <scale>, <shift>) : <geom>
Takes a geom, a scale factor value in Z direction, a shift value in Z direction in the units of the coordinate system used, and returns a geom with those scale and shift values applied to the Z values. Geoms with no Z values are left unchanged. 3D curvilinear segments are replaced with 3D straight line segments.
GeomSegmentize(<geom>, <length>) : <geom>
Takes a geom and a length value and returns a geom where each segment is split to parts which are the same length or shorter than the specified length. Point geoms are left unchanged. Z values are preserved, but curvilinear segments are replaced with straight line segments.
GeomSetZ(<geom>, <z>) : <geom>
Takes a geom and a Z value, and returns the same geom with Z values for all coordinates set to the specified value. Curves are replaced with straight line segments.
To test if a geom has a Z value, use GeomHasZ. To remove all Z values, use GeomRemoveZ. To read the Z value of the first coordinate of a geom, use
VectorValue(GeomCoordXYZ([Geom],0),2)
GeomShift(<geom>, <shiftx2>): <geom>
A version of GeomScaleShift with scale set to 1 for both X and Y. Takes a geom, an x2 vector for shift values in X and Y direction in the units of the coordinate system used, and returns a geom at the same scale with those shift values applied. Z values are preserved and 2D curvilinear segments are preserved, but 3D curvilinear segments are replaced with 3D straight line segments.
GeomSmooth(<geom>, <length>) : <geom>
Takes a geom and a length value and returns a geom that removes detail shorter than the specified length by reducing the number of coordinates. Point geoms are left unchanged. Z values are eliminated. Curvilinear are replaced with straight line segments.
GeomSnapToGrid(<geom>, <stepsx2>) : <geom>
Takes a geom and an x2 vector for distance values in X and Y direction and returns a geom with coordinates rounded to a rectangular grid with the specified steps. Curvilinear segments are replaced with straight line segments. Any coordinates that end up the same are collapsed together.
GeomToConvex(<area>, <tolerance>) : <areas>
Takes an area geom and decomposes it into convex parts. A tolerance of zero means automatic tolerance.
GeomToConvexPar(<area>, <tolerance>, <config>) : <areas>
A parallel form of the GeomToConvex function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads". If the number of threads is less than or equal to 1 the GeomToConvex function will be executed. Use ThreadConfig to generate a JSON string with the desired number of threads.
GeomToBranches(<geom>) : <table>
Convert branched objects into a table of branches. Takes a geom and returns a table where each record contains a row for each branch of the object in the geom, with fields as follows:
Branch - index of the branch
Value - geom for that branch.
Example:
SELECT * FROM (
SELECT SPLIT
CALL GeomToBranches([Geom])
FROM [Table]);
GeomToCoords(<geom>) : <table>
Converts objects into their coordinates. Takes a geom and returns a table where each record contains a row for each coordinate of the object in the geom, with fields as follows:
- Branch - index of current branch.
- Coord - index of current coordinate from the beginning of geom.
- CoordInBranch - index of current coordinate within current branch.
- XY - X, Y coordinates as a float64x2 vector.
- XYZ - X, Y, Z coordinates as a float64x3 vector (NULL if there is no Z).
Example:
SELECT * FROM (
SELECT SPLIT
CALL GeomToCoords([Geom])
FROM [Table]);
GeomToCoordsLineSequence(<line>, <begin>, <end>, <step>): <table>
Given a geom, beginning and end distances and step (similar to ValueSequence), returns a sequence of coordinates at the specified distances on the line. The step can be positive or negative. For example, using begin = 0, end = 5, and step = 1, the function will return coordinates at 0, 1, 2, 3, 4, 5. Using begin = 5, end = 0, and step = -1, the function will return coordinates at 5, 4, 3, 2, 1, 0. Either begin or end can be outside of the line. For example, using begin = -2, end = 50, and step = 10, the function will return coordinates at 8, 18, 28, 38, 48. The coordinates are returned as a table with two fields: distance from the start (Value) and coordinate (XY).
GeomToParts(<geom>, <split>, <tolerance>): <table>
Given a geom and <split> geom that is an area or line, split the geom into parts using the <split> geom. Zero for a tolerance value is automatic tilerance. Use the Edit Query button with the Split : parts transform operation for examples of use.
GeomToPartsLineSequence(<line>, <begin>, <end>, <step>): <table>
Given a geom, beginning and end distances and step (similar to ValueSequence), returns a sequence of line objects between the specified distances on the line, in effect, splitting the line into parts between specified distances. If the begin distance is larger than the end distance, the returned parts go in the direction opposite to that of the line. The result table includes minimum and maximum distance for each part.
Example - Split lines into parts every 100 units long starting at the beginning of each line and going out to a distance of 900 units in each line:
SELECT * FROM (
SELECT SPLIT
CALL GeomToPartsLineSequence([Geom], 0, 900, 100)
FROM [Objects]);
GeomToSegments(<geom>) : <table>
Converts objects into their segments. Takes a geom and returns a table where each record contains a row for each segment of the object in the geom, with fields as follows:
- Branch - index of current branch.
- Coord - index of starting coordinate of the segment from the beginning of geom.
- CoordInBranch - index of starting coordinate of the segmment within current branch.
- XY - starting coordinate value of the segment in X, Y coordinates as a float64x2 vector.
- XYNext - ending coordinate value of the segment in X, Y coordinates as a float64x2 vector.
- XYZ - starting coordinate value of the segment in X, Y, Z coordinates as a float64x3 vector (NULL if there is no Z).
- XYZNext - ending coordinate value of the segment in X, Y, Z coordinates as a float64x3 vector (NULL if there is no Z).
- Type - segment type: 0 = straight line segment, 1 = circular arc, 2 = ellipsoidal arc, 3 = non-uniform b-spline.
Example:
SELECT * FROM (
SELECT SPLIT
CALL GeomToCoords([Geom])
FROM [Table]);
GeomToShapes(<geom>) : <table>
A shape is a branch of an area that forms an island. It is also referred to as an individual polygon within a multipolygon object. This function splits area objects into their constituent shapes using OGC rules for doing so. Use GeomToShapesEsri to split an area into shapes using ESRI rules. Takes a geom and returns a table where each record contains a row for each shape, with fields as follows:
- Shape - index of the shape within the original multipolygon.
- Branch - index of the original starting branch for this shape.
- BranchCount - number of branches in this shape.
- Value - the geom.
Points and lines are unchanged except that any curved segments in lines are replaced by straight segments. The function retains Z values if an area has Z values.
Consider a table that has one object, a branched area that has islands as seen in the drawing below.
That area overall has five branches which make up three shapes. Three of those branches are used to create the larger shape (one branch for the outer boundary and two branches for the inner holes) and two of the branches are used to create the islands.
SELECT * INTO [Shapes Table]
FROM (
SELECT SPLIT
CALL GeomToShapes([Geom])
FROM [Drawing Table]);
We can run the query above to use the GeomToShapes function to decompose the single area into three objects, one for each constituent shape.
The resulting table contains three rows, one for each of the objects that was created by splitting the original area into its constituent three shapes.
The first row is for the larger shape that has two holes. It is the first shape so the Shape value is 0. Branch is also 0 because this shape was started by the first branch in the original area. BranchCount is 3 because this shape contains three branches, one branch for the outer boundary and two branches for the inner holes.
Shape number 1, the second shape, was Branch number 3 of the original area. The BranchCount value for this shape is 1 because this shape contains only one branch.
Shape number 2, the third shape, was Branch number 4 of the original area. The BranchCount value for this shape also is 1 because this shape contains only one branch.
We can add an index to the Shapes Table, to make the table selectable, and then create a drawing from the table. We open the drawing above. It looks like the original, except it now shows three objects instead of just one. We Ctrl-click the middle object to select it.
We can see in the drawing's table that Shape number 1, as expected, is the object selected.
GeomToShapesEsri(<geom>) : <table>
Exactly like GeomToShapes except that it decomposes geoms into shapes based on ESRI rules. The function retains Z values if an area has Z values. To decompose geoms into shapes using OGC rules use GeomToShapes.
GeomTouches(<geom>, <geom>, <tolerance>) : <value>
Given two geoms returns true if they touch. A tolerance of zero means automatic tolerance. For the definition of touch see the Join topic.
GeomTriangulate(<geom>, <tolerance>) : <areas>
Triangulates objects. Given lines, areas or multipoints, performs a Delaunay triangulation of the geom coordinates of an object to create triangles as area objects. The borders of the triangles will be constrained by geom segments, that is, they will not cross segments within the geom.
GeomTriangulatePar(<geom>, <tolerance>. <config>) : <areas>
A parallel form of the GeomTriangulate function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads" and the minimum number of coordinates to allocate for a thread as "batch." The threads default is 1 and the batch default is 1000. Use ThreadConfig to generate a JSON string with the desired number of threads to see how values such as "threads" and "batch" are encoded in the JSON string used for the <config> value.
GeomTriangulateLines(<geom>, <tolerance>) : <lines>
Triangulates objects. Given lines, areas or multipoints, performs a Delaunay triangulation of the geom coordinates of an object to create triangles as line objects. The borders of the triangles will be constrained by geom segments, that is, they will not cross segments within the geom.
GeomTriangulateLinesPar(<geom>, <tolerance>, <config>) : <lines>
A parallel form of the GeomTriangulateLines function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads" and the minimum number of coordinates to allocate for a thread as "batch." The threads default is 1 and the batch default is 1000. Use ThreadConfig to generate a JSON string with the desired number of threads to see how values such as "threads" and "batch" are encoded in the JSON string used for the <config> value.
GeomType(<geom>) : <value>
Returns the object type of a geom as a number: 3 - area ; 2 - line; 1 - point
GeomVoronoi(<points>, <marginx2>, <tolerance>) : <areas>
Given a set of points create a Voronoi diagram and return a geom with the Voronoi cells as area objects. A tolerance of zero means automatic tolerance. The x2 value for margin gives the X, Y factors by which to increase the bounding box used for clipping infinite regions.
GeomVoronoiPar(<points>, <marginx2>, <tolerance>, <config>) : <lines>
A parallel form of the GeomVoronoi function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads" and the minimum number of coordinates to allocate for a thread as "batch." The threads default is 1 and the batch default is 1000. Use ThreadConfig to generate a JSON string with the desired number of threads to see how values such as "threads" and "batch" are encoded in the JSON string used for the <config> value.
GeomVoronoiLines(<points>, <marginx2>, <tolerance>) : <lines>
Given a set of points create a Voronoi diagram and return a geom with the borders of Voronoi cells as line objects. A tolerance of zero means automatic tolerance. The x2 value for margin gives the X, Y factors by which to increase the bounding box used for clipping infinite regions.
GeomVoronoiLinesPar(<points>, <marginx2>, <tolerance>, <config>) : <lines>
A parallel form of the GeomVoronoiLines function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads" and the minimum number of coordinates to allocate for a thread as "batch." The threads default is 1 and the batch default is 1000. Use ThreadConfig to generate a JSON string with the desired number of threads to see how values such as "threads" and "batch" are encoded in the JSON string used for the <config> value.
GeomVoronoiPoints(<points>, <marginx2>, <tolerance>) : <points>
Given a set of points create a Voronoi diagram and return a geom with points at the intersections of borders of Voronoi cells as line objects. A tolerance of zero means automatic tolerance. The x2 value for margin gives the X, Y factors by which to increase the bounding box used for clipping infinite regions.
GeomVoronoiPointsPar(<points>, <marginx2>, <tolerance>, <config>) : <points>
A parallel form of the GeomVoronoiPoints function that takes a parameter for the suggested number of threads as encoded in the JSON <config> string as "threads" and the minimum number of coordinates to allocate for a thread as "batch." The threads default is 1 and the batch default is 1000. Use ThreadConfig to generate a JSON string with the desired number of threads to see how values such as "threads" and "batch" are encoded in the JSON string used for the <config> value.
GeomWithin(<geom>, <geom>, <distance>, <tolerance>) : <value>
Given two geoms and a distance value returns True if the geoms are closer to each other than the specified distance. A tolerance of zero means automatic tolerance.
GeomWkb(<geom>) : <wkb>
Provides a way to extract geometry from a Manifold geometry type, a geom, into a well known binary representation of the geometry, WKB. Given a geom return a WKB binary representation for that object's geometry.
GeomWkt(<geom>) : <wkt>
Provides a way to extract geometry from a Manifold geometry type, a geom, into a well known binary representation of the geometry, WKT. Given a geom return a WKT text representation for that object's geometry.
