Geometry Generator Vs Geometry By Expression: When To Use Each For Polygon Creation

The Core Difference Between the Two Tools

Geometry Generator and Geometry by Expression are two powerful spatial analysis tools in ArcGIS Pro. They enable users to create and manipulate geometries dynamically. The core difference lies in their complexity and performance.

Geometry Generator offers a visual, non-coding way to create basic geometries from existing features. It performs spatial analysis using predefined geoprocessing tools. Operations rely on the graphics card, allowing fast display and rendering. Geometry Generator works across browsers and devices, making it widely accessible.

In contrast, Geometry by Expression uses Python or VBScript syntax to execute more advanced spatial analysis. Users write code expressions to create complex custom polygons, lines, and points. Operations take place in the CPU, which provides extra functionality but slower rendering. Geometry by Expression enables greater flexibility through coding.

Typical Use Cases for Geometry Generator

Creating Basic Shapes

The visual workflow of Geometry Generator lends itself well to making simple buffers, hulls, and standard shapes. Drag-and-drop tools generate polygons around existing features according to set distances or parameters. For example, creating square buffers around points for cartographic visibility.

Performing Spatial Analysis

Predefined overlay and proximity tools in Geometry Generator facilitate basic spatial analysis like intersections and unions. Users can find edges where features interact and derive new geometries. For instance, intersecting parcel centroids with zoning polygons for housing density statistics.

Symbolizing Features Dynamically

The responsive display of Geometry Generator allows efficient visualization of dynamic attributes. Users can design symbols that change size, color, opacity, etc. based on numeric field values. For example, scaling marker symbols for cities proportional to population numbers.

Typical Use Cases for Geometry by Expression

Performing Complex Spatial Analysis

For advanced analysis, Geometry by Expression provides the full capabilities of scripting languages. Users can perform customized overlays, proximity analysis, shape manipulations beyond the constraints of predefined tools. This enables spatial problem-solving not possible in Geometry Generator.

Creating Custom Shapes

Coding expressions in Geometry by Expression gives complete control over polygon, line, and point creation. Users can build specialized shapes, trace features with complex curves, designs bounded areas according to mathematical parameters. The scripts offer versatility not feasible visually.

Manipulating Existing Geometries

Users can write efficient scripts to automatically reshape, simplify, smooth, embellish existing features. Running processes in the CPU facilitates rapid bulk geometry edits. For example, generalizing building footprints to clean up digitizing errors for better cartographic quality.

Example Codes

Creating a Buffer in Geometry Generator

Drag the Buffer tool onto the feature. Specify the buffer distance and segments. The tool generates a new polygon geometry surrounding the input feature according to set parameters. Simple and fast.

Creating a Custom Grid in Geometry by Expression

Use a script like this to build a vector grid from scratch based on x,y coordinates, cell size, and feature count:

print('Creating grid...')
dx=1000 #cell size
x0=0 #x coord origin
y0=0 #y coord origin  
ncols=10 #number of columns
nrows=10 #number of rows
  
def gridPolygon(x, y):
  ring = arcpy.Array()
  ring.add(arcpy.Point(x, y))
  ring.add(arcpy.Point(x + dx, y))
  ring.add(arcpy.Point(x + dx, y - dx)) 
  ring.add(arcpy.Point(x, y - dx))
  ring.add(arcpy.Point(x, y))
  return ring
   
polygons = []  
for row in range(ncols):
  for col in range(nrows):
    x = x0 + (col * dx)
    y = y0 + (row * dx)
    polygon = arcpy.Polygon(gridPolygon(x, y))
    polygons.append(polygon)
     
arcpy.CopyFeatures_management(polygons, 'grid') 

print('Grid created successfully!')

This script loops through coordinate pairs to construct each grid cell polygon, then batches them as a new feature class output. The coding allows customization not available through visual tools.

Key Considerations for Choosing Between the Two

Performance and Rendering Time

Geometry Generator loads results using graphics card acceleration, allowing fast map rendering. Geometry by Expression runs processes on the CPU, so complex scripts can cause sluggish display. Simpler visual workflows are better for interactivity and cartography.

Level of Complexity Needed

Geometry Generator has user-friendly predefined tools for standard shapes and basic analysis. Geometry by Expression enables advanced customization through coding but requires scripting knowledge. Choose ease-of-use over complexity where possible.

Browser Support and Output Formats

Geometry Generator works across desktop and mobile, supporting more workflows. Geometry by Expression requires Desktop as scripts don’t work in browsers. Both output feature classes for further analysis, but Geometry Generator also allows dynamic rendering for better visualization.

Conclusion and Summary – When Each Tool Shines

Geometry Generator excels where ease-of-use, speed, and dynamic rendering matter – basic spatial analysis, simple shapes, and cartographic symbolization. Geometry by Expression tackles advanced customization unachievable visually – complex analysis, specialized geometries, bulk geometry processing.

Consider the workflow needs – analysis depth versus rendering time, browsers versus desktops, scripts versus click-tools. Geometry Generator brings mapping to more users through visual simplicity. Geometry by Expression enables spatial problem solving through coding complexity. Each has advantages for different applications of polygon creation and manipulation in GIS.