Crate cogrs 

cogrs

Pure Rust COG (Cloud Optimized GeoTIFF) reader library.

Features

• Local, HTTP, and S3 sources
• Point queries
• XYZ tile extraction
• Coordinate transforms
• Compression: DEFLATE, LZW, ZSTD, JPEG, WebP

Quick Start

use cogrs::{CogReader, PointQuery, TileExtractor};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let reader = CogReader::open("path/to/file.tif")?;

    // Point query (sync)
    let result = reader.sample_lonlat(-122.4, 37.8)?;

    // XYZ tile extraction (async)
    let tile = TileExtractor::new(&reader)
        .xyz(10, 163, 395)
        .extract()
        .await?;

    Ok(())
}

Sources

use cogrs::CogReader;
// Local file
let reader = CogReader::open("path/to/file.tif")?;

// HTTP
let reader = CogReader::open("https://example.com/file.tif")?;

// S3 (uses AWS_* environment variables for credentials)
let reader = CogReader::open("s3://bucket/path/to/file.tif")?;

Point Queries

use cogrs::{CogReader, PointQuery};
let reader = CogReader::open("elevation.tif")?;

// Sample at lon/lat
let result = reader.sample_lonlat(-122.4, 37.8)?;
for (band, value) in &result.values {
    println!("Band {band}: {value}");
}

// Sample in specific CRS (e.g., UTM zone 10N)
let result = reader.sample_crs(32610, 551000.0, 4185000.0)?;

Tile Extraction

use cogrs::{CogReader, TileExtractor, ResamplingMethod};
let reader = CogReader::open("imagery.tif")?;

// Simple extraction (256x256)
let tile = TileExtractor::new(&reader)
    .xyz(10, 163, 395)
    .extract()
    .await?;

// With options
let tile = TileExtractor::new(&reader)
    .xyz(10, 163, 395)
    .output_size(512, 512)
    .resampling(ResamplingMethod::Bilinear)
    .bands(&[0, 1, 2])
    .extract()
    .await?;

Coordinate Transforms

use cogrs::{CoordTransformer, project_point};

// One-off transform
let (x, y) = project_point(4326, 3857, -122.4, 37.8)?;

// Reusable transformer
let transformer = CoordTransformer::new(4326, 32610)?;
let (utm_x, utm_y) = transformer.transform(-122.4, 37.8)?;

Compression

Supported formats are detected automatically:

• DEFLATE
• LZW (8/16-bit, predictors 1-3)
• ZSTD
• JPEG
• WebP

License

MIT

Architecture

The library is organized into several modules:

• cog_reader: Core COG metadata parsing and tile reading
• point_query: Geographic coordinate sampling via PointQuery trait
• xyz_tile: XYZ tile extraction with TileExtractor builder
• geometry: Coordinate types (Point, BoundingBox) and projections
• range_reader: I/O abstraction for local/HTTP/S3 sources
• source: COG discovery from directories and S3 buckets
• tile_cache: Global LRU cache for decompressed tiles
• s3: S3-compatible storage backend
• raster: Raster data abstraction trait
• geotiff_writer: Write reprojected rasters to GeoTIFF files

Re-exports

pub use cog_reader::CogReader;

pub use cog_reader::CogMetadata;

pub use cog_reader::CogDataType;

pub use cog_reader::Compression;

pub use cog_reader::GeoTransform;

pub use cog_reader::OverviewMetadata;

pub use cog_reader::OverviewQualityHint;

pub use point_query::PointQuery;

pub use point_query::PointQueryResult;

pub use point_query::sample_point;

pub use point_query::sample_point_crs;

pub use xyz_tile::TileData;

pub use xyz_tile::TileExtractor;

pub use xyz_tile::BoundingBox;

pub use xyz_tile::CoordTransformer;

pub use xyz_tile::ResamplingMethod;

pub use xyz_tile::Reprojector;

pub use xyz_tile::ReprojectedRaster;

pub use xyz_tile::StreamingReprojector;

pub use xyz_tile::StreamingOutputInfo;

pub use xyz_tile::RasterChunk;

pub use geometry::Point;

pub use geometry::projection::project_point;

pub use geometry::projection::lon_lat_to_mercator;

pub use geometry::projection::mercator_to_lon_lat;

pub use geometry::projection::try_lon_lat_to_mercator;

pub use geometry::projection::try_mercator_to_lon_lat;

pub use geometry::projection::get_proj_string;

pub use geometry::projection::is_geographic_crs;

pub use range_reader::RangeReader;

pub use range_reader::LocalRangeReader;

pub use range_reader::HttpRangeReader;

pub use range_reader::MemoryRangeReader;

pub use range_reader::create_range_reader;

pub use s3::S3Config;

pub use s3::S3RangeReaderAsync;

pub use s3::S3RangeReaderSync;

pub use source::CogSource;

pub use source::CogEntry;

pub use source::CogLocation;

pub use source::LocalCogSource;

pub use source::LocalScanOptions;

pub use source::LocalSourceStats;

pub use source::S3CogSource;

pub use source::S3ScanOptions;

pub use source::S3SourceStats;

pub use tile_cache::TileCache;

pub use raster::RasterSource;

pub use geotiff_writer::GeoTiffCompression;

pub use geotiff_writer::GeoTiffWriteError;

pub use geotiff_writer::GeoTiffWriter;

Modules

casting

Safe numeric casting utilities for geospatial image processing.

cog_reader

Pure Rust COG (Cloud Optimized GeoTIFF) reader

geometry

geotiff_writer

GeoTIFF writer for reprojected rasters

lzw_fallback

Fallback LZW TIFF reader that streams tiles on demand.

point_query

Point query functionality for sampling COG values at geographic coordinates.

range_reader

Range-based reader interface for COG files

raster

s3

S3 Range Reader implementation using object_store

source

COG source discovery and abstraction.

tiff_chunked

tiff_utils

tile_cache

xyz_tile

XYZ tile extraction from COG files