Skip to main content
The geometry module provides comprehensive spatial operations for working with geographic data, including coordinate reference system (CRS) management, distance calculations, spatial joins, geometry validation, and parcel analysis.

​
Coordinate Reference Systems

​
get_crs()

Returns the appropriate CRS for a GeoDataFrame based on the specified projection type. 
from openavmkit.utilities.geometry import get_crs
import geopandas as gpd

crs = get_crs(gdf, projection_type='equal_area')
​
gdf
gpd.GeoDataFrame
required
Input GeoDataFrame
​
projection_type
str
required
Type of projection: 'latlon', 'equal_area', 'equal_distance', or 'conformal'
​
crs
pyproj.CRS
Appropriate CRS for the specified projection type

​
get_crs_from_lat_lon()

Return a Coordinate Reference System (CRS) suitable for the requested projection type at the given latitude/longitude location. 
from openavmkit.utilities.geometry import get_crs_from_lat_lon

crs = get_crs_from_lat_lon(lat=40.7128, lon=-74.0060, projection_type='equal_area', units='m')
​
lat
float
required
Latitude
​
lon
float
required
Longitude
​
projection_type
str
required
The desired projection type: 'latlon', 'equal_area', 'equal_distance', or 'conformal'
​
units
str
default:"'m'"
The desired units: 'ft' or 'm'
​
crs
pyproj.CRS
The appropriate Coordinate Reference System

​
Distance Calculations

​
distance_km()

Calculates the distance in kilometers between two latitude/longitude points. 
from openavmkit.utilities.geometry import distance_km

dist = distance_km(lat1=40.7128, lon1=-74.0060, lat2=34.0522, lon2=-118.2437)
​
lat1
float
required
Latitude of the first point
​
lon1
float
required
Longitude of the first point
​
lat2
float
required
Latitude of the second point
​
lon2
float
required
Longitude of the second point
​
distance
float
Distance in kilometers

​
offset_coordinate_km()

Offset a lat/long coordinate by the designated number of kilometers. 
from openavmkit.utilities.geometry import offset_coordinate_km

new_lat, new_lon = offset_coordinate_km(lat=40.7128, lon=-74.0060, lat_km=10, lon_km=5)
​
lat
float
required
Latitude
​
lon
float
required
Longitude
​
lat_km
float
required
Number of kilometers to offset latitude by
​
lon_km
float
required
Number of kilometers to offset longitude by
​
return
tuple[float, float]
The offset latitude, longitude pair (in degrees)

​
offset_coordinate_m()

Offset a lat/long coordinate by the designated number of meters.
​
lat
float
required
Latitude
​
lon
float
required
Longitude
​
lat_m
float
required
Number of meters to offset latitude by
​
lon_m
float
required
Number of meters to offset longitude by
​
return
tuple[float, float]
The offset latitude, longitude pair (in degrees)

​
offset_coordinate_feet()

Offset a lat/long coordinate by the designated number of feet.
​
lat
float
required
Latitude
​
lon
float
required
Longitude
​
lat_feet
float
required
Number of feet to offset latitude by
​
lon_feet
float
required
Number of feet to offset longitude by
​
return
tuple[float, float]
The offset latitude, longitude pair (in degrees)

​
Geometry Creation

​
create_geo_circle()

Creates a GeoDataFrame containing a circle centered at the specified latitude and longitude. 
from openavmkit.utilities.geometry import create_geo_circle
from pyproj import CRS

circle_gdf = create_geo_circle(
    lat=40.7128,
    lon=-74.0060,
    crs=CRS.from_epsg(4326),
    radius_km=5.0,
    num_points=100
)
​
lat
float
required
Latitude
​
lon
float
required
Longitude
​
crs
pyproj.CRS
required
Coordinate Reference System
​
radius_km
float
required
Radius of the circle, in kilometers
​
num_points
int
default:"100"
Number of points used to approximate the circle
​
gdf
gpd.GeoDataFrame
A GeoDataFrame containing the circle

​
create_geo_rect()

Creates a GeoDataFrame containing a rectangle centered at the specified latitude and longitude. 
from openavmkit.utilities.geometry import create_geo_rect

rect_gdf = create_geo_rect(
    lat=40.7128,
    lon=-74.0060,
    crs=CRS.from_epsg(4326),
    width_km=10,
    height_km=8,
    anchor_point='center'
)
​
lat
float
required
Latitude
​
lon
float
required
Longitude
​
crs
pyproj.CRS
required
Coordinate Reference System
​
width_km
float
required
Width in kilometers
​
height_km
float
required
Height in kilometers
​
anchor_point
str
default:"'center'"
Anchor point of the rectangle: 'center' or 'nw' (northwest)
​
gdf
gpd.GeoDataFrame
A GeoDataFrame containing the rectangle

​
Geometry Processing

​
ensure_geometries()

Parse a DataFrame whose geometry column may be in various formats (Shapely, WKT, WKB, hex-encoded WKB). 
from openavmkit.utilities.geometry import ensure_geometries

gdf = ensure_geometries(df, geom_col='geometry', crs='EPSG:4326')
​
df
pd.DataFrame
required
Input DataFrame
​
geom_col
str
default:"'geometry'"
Name of the geometry column
​
crs
pyproj.CRS
default:"None"
Coordinate Reference System
​
gdf
gpd.GeoDataFrame
A brand-new GeoDataFrame with a clean geometry column

​
clean_geometry()

Preprocess a GeoDataFrame by diagnosing and fixing common geometry issues. 
from openavmkit.utilities.geometry import clean_geometry

cleaned_gdf = clean_geometry(
    gdf,
    ensure_polygon=True,
    target_crs='EPSG:4326'
)
​
gdf
gpd.GeoDataFrame
required
The input GeoDataFrame with geometries
​
ensure_polygon
bool
default:"True"
If True, removes non-polygon geometries
​
target_crs
str or int
default:"None"
If specified, ensures the GeoDataFrame is in this CRS
​
gdf
gpd.GeoDataFrame
A cleaned and fixed GeoDataFrame

​
Spatial Joins

​
geolocate_point_to_polygon()

Assign each point (latitude/longitude) in a DataFrame to a containing polygon ID. 
from openavmkit.utilities.geometry import geolocate_point_to_polygon

df_matched = geolocate_point_to_polygon(
    gdf=parcels_gdf,
    df_in=sales_df,
    lat_field='latitude',
    lon_field='longitude',
    parcel_id_field='parcel_id'
)
​
gdf
gpd.GeoDataFrame
required
GeoDataFrame of polygon geometries (must include a geometry column and the parcel ID field)
​
df_in
pd.DataFrame
required
Input DataFrame with at least latitude and longitude columns
​
lat_field
str
required
Name of the column in df_in containing latitude values
​
lon_field
str
required
Name of the column in df_in containing longitude values
​
parcel_id_field
str
required
Name of the parcel ID column in gdf to attach to each point
​
df
pd.DataFrame
Copy of df_in with a new column containing the ID of the polygon that contains each point. Rows with no containing polygon will have NaN.

​
Parcel Analysis

​
identify_irregular_parcels()

Detect and flag irregular parcel geometries based on shape metrics. 
from openavmkit.utilities.geometry import identify_irregular_parcels

gdf_with_flags = identify_irregular_parcels(
    gdf,
    verbose=False,
    tolerance=10,
    complex_threshold=12,
    rectangularity_threshold=0.75,
    elongation_threshold=5
)
​
gdf
gpd.GeoDataFrame
required
Must contain a geometry column of Polygon geometries, plus precomputed fields:
  • geom_rectangularity_num: numeric rectangularity measure (0-1)
  • geom_aspect_ratio: width/height ratio of each parcel
​
verbose
bool
default:"False"
If True, print timing and progress for each processing phase
​
tolerance
int
default:"10"
Simplification tolerance (projection units) for reducing geometry complexity
​
complex_threshold
int
default:"12"
Minimum vertex count (post-simplification) for a parcel to be considered ‘complex’
​
rectangularity_threshold
float
default:"0.75"
Maximum rectangularity below which a high-vertex-count geometry is flagged as irregular
​
elongation_threshold
float
default:"5"
Minimum bounding-box aspect ratio that qualifies a parcel as ‘elongated’
​
gdf
gpd.GeoDataFrame
A copy of the input with these added columns:
  • geom_vertices: int count of vertices after simplification
  • is_geom_complex: bool flag for complex non-rectangular shapes
  • is_geom_elongated: bool flag for elongated shapes
  • is_geom_irregular: bool flag if any irregular condition is met

​
Parquet CRS Detection

​
detect_crs_from_parquet()

Return CRS and geometry column name from GeoParquet metadata. 
from openavmkit.utilities.geometry import detect_crs_from_parquet

crs, geom_col = detect_crs_from_parquet('parcels.parquet', geom_col='geometry')
​
path
str
required
Path to the parquet file
​
geom_col
str
default:"'geometry'"
Name of the geometry column to check
​
return
Tuple[Optional[CRS], str]
Tuple containing:
  • crs: pyproj.CRS or None
  • geometry_column_used: the geometry column name detected or provided

Build docs developers (and LLMs) love

Get started for freeTalk to us