# fastGeoToolkit Python
[](https://pypi.org/project/fastgeotoolkit/)
[](https://pypi.org/project/fastgeotoolkit/)
[](https://opensource.org/licenses/MIT)
A novel high-performance geospatial analysis framework with advanced route density mapping algorithms, powered by Rust for maximum performance in Python.
## Installation
```bash
pip install fastgeotoolkit
```
### Optional Dependencies
For enhanced functionality, install with optional dependencies:
```bash
# For visualization
pip install fastgeotoolkit[examples] # includes matplotlib, folium, etc.
# For development
pip install fastgeotoolkit[dev] # includes testing and linting tools
# Everything
pip install fastgeotoolkit[all]
```
## Quick Start
### Basic Usage
```python
import fastgeotoolkit as fgt
# Load and process GPX files
heatmap = fgt.load_gpx_file("track.gpx")
print(f"Generated heatmap with {len(heatmap.tracks)} tracks")
print(f"Maximum frequency: {heatmap.max_frequency}")
# Access individual tracks with frequency data
for i, track in enumerate(heatmap.tracks):
print(f"Track {i}: {track.frequency}x frequency, {len(track.coordinates)} points")
```
### Route Density Analysis
```python
import fastgeotoolkit as fgt
# Process multiple GPX files for route density analysis
gpx_files = ["route1.gpx", "route2.gpx", "route3.gpx"]
heatmap = fgt.load_multiple_gpx_files(gpx_files)
# Analyze route popularity
stats = fgt.calculate_heatmap_statistics(heatmap)
print(f"Total tracks: {stats['total_tracks']}")
print(f"Average frequency: {stats['mean_frequency']:.1f}")
print(f"Frequency distribution: {stats['frequency_distribution']}")
# Find most popular routes
popular_routes = [
track for track in heatmap.tracks
if track.frequency == heatmap.max_frequency
]
print(f"Found {len(popular_routes)} most popular routes")
```
### Interactive Visualization
```python
import fastgeotoolkit as fgt
# Create interactive map with Folium
heatmap = fgt.load_gpx_file("tracks.gpx")
map_viz = fgt.create_folium_map(heatmap)
map_viz.save("heatmap.html")
# Create matplotlib visualization
fgt.visualize_heatmap(heatmap, figsize=(15, 10))
```
### Advanced GPS Processing
```python
import fastgeotoolkit as fgt
# Decode polylines (Google Maps format)
coordinates = fgt.decode_polyline("_p~iF~ps|U_ulLnnqC_mqNvxq`@")
print(f"Decoded {len(coordinates)} points")
# Calculate track statistics
stats = fgt.calculate_track_statistics(coordinates)
print(f"Distance: {stats.distance_km:.2f} km")
print(f"Bounding box: {stats.bounding_box}")
# Validate coordinates
validation = fgt.validate_coordinates(coordinates)
print(f"Valid coordinates: {validation.valid_count}/{validation.total_count}")
for issue in validation.issues:
print(f" - {issue}")
```
## Core Features
### Route Density Mapping
Advanced segment-based analysis for route popularity:
```python
import fastgeotoolkit as fgt
# Multiple GPS tracks from the same area
tracks = [
[(40.7128, -74.0060), (40.7589, -73.9851)], # NYC to Times Square
[(40.7128, -74.0060), (40.7589, -73.9851)], # Same route (increases frequency)
[(40.7505, -73.9934), (40.7831, -73.9712)], # Empire State to Central Park
]
# Process with our novel frequency algorithm
result = fgt.process_polylines([fgt.coordinates_to_polyline(track) for track in tracks])
# Analyze route overlap and frequency
for track in result.tracks:
popularity = "High" if track.frequency > result.max_frequency * 0.7 else "Medium" if track.frequency > result.max_frequency * 0.3 else "Low"
print(f"Route popularity: {popularity} (frequency: {track.frequency})")
```
### Track Analysis & Statistics
Comprehensive geospatial analysis:
```python
import fastgeotoolkit as fgt
coordinates = [(40.7128, -74.0060), (40.7589, -73.9851), (40.7831, -73.9712)]
# Detailed statistics
stats = fgt.calculate_track_statistics(coordinates)
print(f"Distance: {stats.distance_km:.2f} km")
print(f"Points: {stats.point_count}")
print(f"Bounds: {stats.bounding_box}")
# Find intersections between multiple tracks
tracks = [track1, track2, track3]
intersections = fgt.find_track_intersections(tracks, tolerance=0.001)
for intersection in intersections:
print(f"Intersection at {intersection.coordinate} between tracks {intersection.track_indices}")
# Calculate geographic coverage
coverage = fgt.calculate_coverage_area(tracks)
print(f"Coverage area: {coverage.area_km2:.2f} km²")
```
### Track Manipulation
Powerful track processing capabilities:
```python
import fastgeotoolkit as fgt
# Simplify tracks (reduce point density while preserving shape)
simplified = fgt.simplify_coordinates(dense_track, tolerance=0.001)
print(f"Reduced from {len(dense_track)} to {len(simplified)} points")
# Split tracks by gaps
split_tracks = fgt.split_track_by_gaps(track_with_gaps, max_gap_km=5.0)
print(f"Split into {len(split_tracks)} continuous segments")
# Filter by geographic bounds
bounds = (40.7, -74.1, 40.8, -73.9) # NYC area
filtered = fgt.filter_coordinates_by_bounds(coordinates, bounds)
# Merge similar tracks
merged = fgt.merge_nearby_tracks(similar_tracks, distance_threshold=0.5)
```
### 📝 Format Conversion
Convert between popular GPS formats:
```python
import fastgeotoolkit as fgt
# Convert to GeoJSON
geojson = fgt.coordinates_to_geojson(coordinates, {
"name": "My Route",
"sport": "cycling",
"date": "2024-01-15"
})
# Export to GPX
gpx_content = fgt.export_to_gpx([track1, track2], {
"creator": "fastGeoToolkit",
"version": "1.1"
})
# Encode as polyline
polyline = fgt.coordinates_to_polyline(coordinates)
print(f"Encoded polyline: {polyline}")
```
## NumPy Integration
Seamless integration with NumPy arrays:
```python
import fastgeotoolkit as fgt
import numpy as np
# Convert between NumPy arrays and coordinate lists
coords_array = np.array([[40.7128, -74.0060], [40.7589, -73.9851]])
coord_list = fgt.numpy_to_coordinates(coords_array)
# Process NumPy data
stats = fgt.calculate_track_statistics(coord_list)
simplified = fgt.simplify_coordinates(coord_list, tolerance=0.001)
# Convert back to NumPy
result_array = fgt.coordinates_to_numpy(simplified)
```
## Performance
fastGeoToolkit leverages Rust's performance for demanding geospatial tasks:
- **10-100x faster** than pure Python implementations
- **Memory efficient** processing of large GPS datasets
- **Parallel processing** for multi-track analysis
- **Optimized algorithms** for route density calculation
### Benchmarks
```python
import fastgeotoolkit as fgt
import time
# Load large dataset
start = time.time()
heatmap = fgt.load_multiple_gpx_files(large_gpx_file_list)
processing_time = time.time() - start
print(f"Processed {len(heatmap.tracks)} tracks in {processing_time:.2f} seconds")
print(f"Performance: {len(heatmap.tracks)/processing_time:.0f} tracks/second")
```
## Advanced Examples
### Route Popularity Analysis
```python
import fastgeotoolkit as fgt
# Load cycling route data
heatmap = fgt.load_multiple_gpx_files(["route1.gpx", "route2.gpx", "route3.gpx"])
# Identify popular segments
popular_segments = [
track for track in heatmap.tracks
if track.frequency >= heatmap.max_frequency * 0.8
]
print(f"Found {len(popular_segments)} highly popular route segments")
# Create frequency distribution analysis
stats = fgt.calculate_heatmap_statistics(heatmap)
for freq, count in stats['frequency_distribution'].items():
percentage = (count / stats['total_tracks']) * 100
print(f"Frequency {freq}: {count} routes ({percentage:.1f}%)")
```
### Interactive Web Visualization
```python
import fastgeotoolkit as fgt
# Create web-ready heatmap
heatmap = fgt.load_gpx_file("mountain_bike_trails.gpx")
# Generate interactive map
map_viz = fgt.create_folium_map(
heatmap,
zoom_start=14,
colormap='viridis'
)
# Add custom styling and save
map_viz.save("trail_heatmap.html")
print("Interactive map saved to trail_heatmap.html")
```
### Batch Processing Pipeline
```python
import fastgeotoolkit as fgt
from pathlib import Path
# Process all GPX files in a directory
gpx_directory = Path("./gpx_data/")
gpx_files = list(gpx_directory.glob("*.gpx"))
# Batch process with progress tracking
print(f"Processing {len(gpx_files)} GPX files...")
heatmap = fgt.load_multiple_gpx_files(gpx_files)
# Export results in multiple formats
fgt.save_heatmap_to_geojson(heatmap, "output.geojson")
gpx_output = fgt.export_to_gpx([track.coordinates for track in heatmap.tracks])
with open("combined_routes.gpx", "w") as f:
f.write(gpx_output)
print("Batch processing complete!")
```
## API Reference
### Core Functions
- `load_gpx_file(path)` - Load single GPX file
- `load_multiple_gpx_files(paths)` - Load multiple GPX files
- `process_gpx_files(file_data_list)` - Process GPX binary data
- `decode_polyline(encoded)` - Decode Google polyline format
- `process_polylines(polylines)` - Process multiple polylines
### Analysis Functions
- `calculate_track_statistics(coords)` - Track distance, bounds, point count
- `validate_coordinates(coords)` - Validate GPS coordinates
- `find_track_intersections(tracks, tolerance)` - Find intersection points
- `calculate_coverage_area(tracks)` - Geographic coverage analysis
- `cluster_tracks_by_similarity(tracks, threshold)` - Group similar routes
### Manipulation Functions
- `simplify_coordinates(coords, tolerance)` - Reduce point density
- `split_track_by_gaps(coords, max_gap_km)` - Split by spatial gaps
- `merge_nearby_tracks(tracks, threshold)` - Merge similar tracks
- `filter_coordinates_by_bounds(coords, bounds)` - Geographic filtering
- `resample_track(coords, target_points)` - Resample to target density
### Conversion Functions
- `coordinates_to_geojson(coords, properties)` - Export to GeoJSON
- `coordinates_to_polyline(coords)` - Encode as polyline
- `export_to_gpx(tracks, metadata)` - Export to GPX format
- `get_file_info(file_data)` - File format information
### Utility Functions
- `save_heatmap_to_geojson(heatmap, path)` - Save heatmap as GeoJSON
- `create_folium_map(heatmap)` - Create interactive map
- `visualize_heatmap(heatmap)` - Create matplotlib visualization
- `calculate_heatmap_statistics(heatmap)` - Comprehensive statistics
- `numpy_to_coordinates(array)` - NumPy array conversion
- `coordinates_to_numpy(coords)` - Convert to NumPy array
## Type Hints
fastGeoToolkit provides comprehensive type hints for better development experience:
```python
from fastgeotoolkit import (
Coordinate,
HeatmapResult,
HeatmapTrack,
ValidationResult,
TrackStatistics,
FileInfo
)
def process_route(coords: List[Coordinate]) -> TrackStatistics:
return fgt.calculate_track_statistics(coords)
```
## Requirements
- Python 3.8+
- NumPy (included in requirements)
### Optional Dependencies
- `matplotlib` - For visualization
- `folium` - For interactive maps
- `geopandas` - For advanced geospatial operations
- `pandas` - For data analysis
## License
MIT License - see [LICENSE](LICENSE) file for details.
## Performance Tips
1. **Use batch processing** for multiple files with `load_multiple_gpx_files()`
2. **Simplify tracks** before analysis to reduce computation time
3. **Set appropriate tolerances** for intersection detection
4. **Use NumPy arrays** for large coordinate datasets
5. **Cache results** of expensive operations when processing similar data
## Contributing
Contributions are welcome! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
## Citation
If you use fastGeoToolkit in research, please cite:
```bibtex
@software{fastgeotoolkit2024,
title={fastGeoToolkit: A Novel High-Performance Geospatial Analysis Framework with Advanced Route Density Mapping},
author={fastGeoToolkit Contributors},
year={2024},
url={https://github.com/a0a7/fastgeotoolkit},
version={0.1.3}
}
```
Raw data
{
"_id": null,
"home_page": null,
"name": "fastgeotoolkit",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "gps, geospatial, trajectory, route-density, heatmap, gpx, fit, polyline, rust, performance",
"author": null,
"author_email": "a0a7 <contact@a0.ax>",
"download_url": "https://files.pythonhosted.org/packages/f2/9e/2ebc74856b80cdf634696426af8e75ca7bd5b1f748d3f66c681e6c567744/fastgeotoolkit-0.1.7.tar.gz",
"platform": null,
"description": "# fastGeoToolkit Python\n\n[](https://pypi.org/project/fastgeotoolkit/)\n[](https://pypi.org/project/fastgeotoolkit/)\n[](https://opensource.org/licenses/MIT)\n\nA novel high-performance geospatial analysis framework with advanced route density mapping algorithms, powered by Rust for maximum performance in Python.\n\n## Installation\n\n```bash\npip install fastgeotoolkit\n```\n\n### Optional Dependencies\n\nFor enhanced functionality, install with optional dependencies:\n\n```bash\n# For visualization\npip install fastgeotoolkit[examples] # includes matplotlib, folium, etc.\n\n# For development\npip install fastgeotoolkit[dev] # includes testing and linting tools\n\n# Everything\npip install fastgeotoolkit[all]\n```\n\n## Quick Start\n\n### Basic Usage\n\n```python\nimport fastgeotoolkit as fgt\n\n# Load and process GPX files\nheatmap = fgt.load_gpx_file(\"track.gpx\")\nprint(f\"Generated heatmap with {len(heatmap.tracks)} tracks\")\nprint(f\"Maximum frequency: {heatmap.max_frequency}\")\n\n# Access individual tracks with frequency data\nfor i, track in enumerate(heatmap.tracks):\n print(f\"Track {i}: {track.frequency}x frequency, {len(track.coordinates)} points\")\n```\n\n### Route Density Analysis\n\n```python\nimport fastgeotoolkit as fgt\n\n# Process multiple GPX files for route density analysis\ngpx_files = [\"route1.gpx\", \"route2.gpx\", \"route3.gpx\"]\nheatmap = fgt.load_multiple_gpx_files(gpx_files)\n\n# Analyze route popularity\nstats = fgt.calculate_heatmap_statistics(heatmap)\nprint(f\"Total tracks: {stats['total_tracks']}\")\nprint(f\"Average frequency: {stats['mean_frequency']:.1f}\")\nprint(f\"Frequency distribution: {stats['frequency_distribution']}\")\n\n# Find most popular routes\npopular_routes = [\n track for track in heatmap.tracks \n if track.frequency == heatmap.max_frequency\n]\nprint(f\"Found {len(popular_routes)} most popular routes\")\n```\n\n### Interactive Visualization\n\n```python\nimport fastgeotoolkit as fgt\n\n# Create interactive map with Folium\nheatmap = fgt.load_gpx_file(\"tracks.gpx\")\nmap_viz = fgt.create_folium_map(heatmap)\nmap_viz.save(\"heatmap.html\")\n\n# Create matplotlib visualization\nfgt.visualize_heatmap(heatmap, figsize=(15, 10))\n```\n\n### Advanced GPS Processing\n\n```python\nimport fastgeotoolkit as fgt\n\n# Decode polylines (Google Maps format)\ncoordinates = fgt.decode_polyline(\"_p~iF~ps|U_ulLnnqC_mqNvxq`@\")\nprint(f\"Decoded {len(coordinates)} points\")\n\n# Calculate track statistics\nstats = fgt.calculate_track_statistics(coordinates)\nprint(f\"Distance: {stats.distance_km:.2f} km\")\nprint(f\"Bounding box: {stats.bounding_box}\")\n\n# Validate coordinates\nvalidation = fgt.validate_coordinates(coordinates)\nprint(f\"Valid coordinates: {validation.valid_count}/{validation.total_count}\")\nfor issue in validation.issues:\n print(f\" - {issue}\")\n```\n\n## Core Features\n\n### Route Density Mapping\n\nAdvanced segment-based analysis for route popularity:\n\n```python\nimport fastgeotoolkit as fgt\n\n# Multiple GPS tracks from the same area\ntracks = [\n [(40.7128, -74.0060), (40.7589, -73.9851)], # NYC to Times Square\n [(40.7128, -74.0060), (40.7589, -73.9851)], # Same route (increases frequency)\n [(40.7505, -73.9934), (40.7831, -73.9712)], # Empire State to Central Park\n]\n\n# Process with our novel frequency algorithm\nresult = fgt.process_polylines([fgt.coordinates_to_polyline(track) for track in tracks])\n\n# Analyze route overlap and frequency\nfor track in result.tracks:\n popularity = \"High\" if track.frequency > result.max_frequency * 0.7 else \"Medium\" if track.frequency > result.max_frequency * 0.3 else \"Low\"\n print(f\"Route popularity: {popularity} (frequency: {track.frequency})\")\n```\n\n### Track Analysis & Statistics\n\nComprehensive geospatial analysis:\n\n```python\nimport fastgeotoolkit as fgt\n\ncoordinates = [(40.7128, -74.0060), (40.7589, -73.9851), (40.7831, -73.9712)]\n\n# Detailed statistics\nstats = fgt.calculate_track_statistics(coordinates)\nprint(f\"Distance: {stats.distance_km:.2f} km\")\nprint(f\"Points: {stats.point_count}\")\nprint(f\"Bounds: {stats.bounding_box}\")\n\n# Find intersections between multiple tracks\ntracks = [track1, track2, track3]\nintersections = fgt.find_track_intersections(tracks, tolerance=0.001)\nfor intersection in intersections:\n print(f\"Intersection at {intersection.coordinate} between tracks {intersection.track_indices}\")\n\n# Calculate geographic coverage\ncoverage = fgt.calculate_coverage_area(tracks)\nprint(f\"Coverage area: {coverage.area_km2:.2f} km\u00b2\")\n```\n\n### Track Manipulation\n\nPowerful track processing capabilities:\n\n```python\nimport fastgeotoolkit as fgt\n\n# Simplify tracks (reduce point density while preserving shape)\nsimplified = fgt.simplify_coordinates(dense_track, tolerance=0.001)\nprint(f\"Reduced from {len(dense_track)} to {len(simplified)} points\")\n\n# Split tracks by gaps\nsplit_tracks = fgt.split_track_by_gaps(track_with_gaps, max_gap_km=5.0)\nprint(f\"Split into {len(split_tracks)} continuous segments\")\n\n# Filter by geographic bounds\nbounds = (40.7, -74.1, 40.8, -73.9) # NYC area\nfiltered = fgt.filter_coordinates_by_bounds(coordinates, bounds)\n\n# Merge similar tracks\nmerged = fgt.merge_nearby_tracks(similar_tracks, distance_threshold=0.5)\n```\n\n### \ud83d\udcdd Format Conversion\n\nConvert between popular GPS formats:\n\n```python\nimport fastgeotoolkit as fgt\n\n# Convert to GeoJSON\ngeojson = fgt.coordinates_to_geojson(coordinates, {\n \"name\": \"My Route\",\n \"sport\": \"cycling\",\n \"date\": \"2024-01-15\"\n})\n\n# Export to GPX\ngpx_content = fgt.export_to_gpx([track1, track2], {\n \"creator\": \"fastGeoToolkit\",\n \"version\": \"1.1\"\n})\n\n# Encode as polyline\npolyline = fgt.coordinates_to_polyline(coordinates)\nprint(f\"Encoded polyline: {polyline}\")\n```\n\n## NumPy Integration\n\nSeamless integration with NumPy arrays:\n\n```python\nimport fastgeotoolkit as fgt\nimport numpy as np\n\n# Convert between NumPy arrays and coordinate lists\ncoords_array = np.array([[40.7128, -74.0060], [40.7589, -73.9851]])\ncoord_list = fgt.numpy_to_coordinates(coords_array)\n\n# Process NumPy data\nstats = fgt.calculate_track_statistics(coord_list)\nsimplified = fgt.simplify_coordinates(coord_list, tolerance=0.001)\n\n# Convert back to NumPy\nresult_array = fgt.coordinates_to_numpy(simplified)\n```\n\n## Performance\n\nfastGeoToolkit leverages Rust's performance for demanding geospatial tasks:\n\n- **10-100x faster** than pure Python implementations\n- **Memory efficient** processing of large GPS datasets\n- **Parallel processing** for multi-track analysis\n- **Optimized algorithms** for route density calculation\n\n### Benchmarks\n\n```python\nimport fastgeotoolkit as fgt\nimport time\n\n# Load large dataset\nstart = time.time()\nheatmap = fgt.load_multiple_gpx_files(large_gpx_file_list)\nprocessing_time = time.time() - start\n\nprint(f\"Processed {len(heatmap.tracks)} tracks in {processing_time:.2f} seconds\")\nprint(f\"Performance: {len(heatmap.tracks)/processing_time:.0f} tracks/second\")\n```\n\n## Advanced Examples\n\n### Route Popularity Analysis\n\n```python\nimport fastgeotoolkit as fgt\n\n# Load cycling route data\nheatmap = fgt.load_multiple_gpx_files([\"route1.gpx\", \"route2.gpx\", \"route3.gpx\"])\n\n# Identify popular segments\npopular_segments = [\n track for track in heatmap.tracks \n if track.frequency >= heatmap.max_frequency * 0.8\n]\n\nprint(f\"Found {len(popular_segments)} highly popular route segments\")\n\n# Create frequency distribution analysis\nstats = fgt.calculate_heatmap_statistics(heatmap)\nfor freq, count in stats['frequency_distribution'].items():\n percentage = (count / stats['total_tracks']) * 100\n print(f\"Frequency {freq}: {count} routes ({percentage:.1f}%)\")\n```\n\n### Interactive Web Visualization\n\n```python\nimport fastgeotoolkit as fgt\n\n# Create web-ready heatmap\nheatmap = fgt.load_gpx_file(\"mountain_bike_trails.gpx\")\n\n# Generate interactive map\nmap_viz = fgt.create_folium_map(\n heatmap, \n zoom_start=14,\n colormap='viridis'\n)\n\n# Add custom styling and save\nmap_viz.save(\"trail_heatmap.html\")\nprint(\"Interactive map saved to trail_heatmap.html\")\n```\n\n### Batch Processing Pipeline\n\n```python\nimport fastgeotoolkit as fgt\nfrom pathlib import Path\n\n# Process all GPX files in a directory\ngpx_directory = Path(\"./gpx_data/\")\ngpx_files = list(gpx_directory.glob(\"*.gpx\"))\n\n# Batch process with progress tracking\nprint(f\"Processing {len(gpx_files)} GPX files...\")\nheatmap = fgt.load_multiple_gpx_files(gpx_files)\n\n# Export results in multiple formats\nfgt.save_heatmap_to_geojson(heatmap, \"output.geojson\")\ngpx_output = fgt.export_to_gpx([track.coordinates for track in heatmap.tracks])\nwith open(\"combined_routes.gpx\", \"w\") as f:\n f.write(gpx_output)\n\nprint(\"Batch processing complete!\")\n```\n\n## API Reference\n\n### Core Functions\n\n- `load_gpx_file(path)` - Load single GPX file\n- `load_multiple_gpx_files(paths)` - Load multiple GPX files\n- `process_gpx_files(file_data_list)` - Process GPX binary data\n- `decode_polyline(encoded)` - Decode Google polyline format\n- `process_polylines(polylines)` - Process multiple polylines\n\n### Analysis Functions\n\n- `calculate_track_statistics(coords)` - Track distance, bounds, point count\n- `validate_coordinates(coords)` - Validate GPS coordinates\n- `find_track_intersections(tracks, tolerance)` - Find intersection points\n- `calculate_coverage_area(tracks)` - Geographic coverage analysis\n- `cluster_tracks_by_similarity(tracks, threshold)` - Group similar routes\n\n### Manipulation Functions\n\n- `simplify_coordinates(coords, tolerance)` - Reduce point density\n- `split_track_by_gaps(coords, max_gap_km)` - Split by spatial gaps\n- `merge_nearby_tracks(tracks, threshold)` - Merge similar tracks\n- `filter_coordinates_by_bounds(coords, bounds)` - Geographic filtering\n- `resample_track(coords, target_points)` - Resample to target density\n\n### Conversion Functions\n\n- `coordinates_to_geojson(coords, properties)` - Export to GeoJSON\n- `coordinates_to_polyline(coords)` - Encode as polyline\n- `export_to_gpx(tracks, metadata)` - Export to GPX format\n- `get_file_info(file_data)` - File format information\n\n### Utility Functions\n\n- `save_heatmap_to_geojson(heatmap, path)` - Save heatmap as GeoJSON\n- `create_folium_map(heatmap)` - Create interactive map\n- `visualize_heatmap(heatmap)` - Create matplotlib visualization\n- `calculate_heatmap_statistics(heatmap)` - Comprehensive statistics\n- `numpy_to_coordinates(array)` - NumPy array conversion\n- `coordinates_to_numpy(coords)` - Convert to NumPy array\n\n## Type Hints\n\nfastGeoToolkit provides comprehensive type hints for better development experience:\n\n```python\nfrom fastgeotoolkit import (\n Coordinate,\n HeatmapResult,\n HeatmapTrack,\n ValidationResult,\n TrackStatistics,\n FileInfo\n)\n\ndef process_route(coords: List[Coordinate]) -> TrackStatistics:\n return fgt.calculate_track_statistics(coords)\n```\n\n## Requirements\n\n- Python 3.8+\n- NumPy (included in requirements)\n\n### Optional Dependencies\n\n- `matplotlib` - For visualization\n- `folium` - For interactive maps\n- `geopandas` - For advanced geospatial operations\n- `pandas` - For data analysis\n\n## License\n\nMIT License - see [LICENSE](LICENSE) file for details.\n\n## Performance Tips\n\n1. **Use batch processing** for multiple files with `load_multiple_gpx_files()`\n2. **Simplify tracks** before analysis to reduce computation time\n3. **Set appropriate tolerances** for intersection detection\n4. **Use NumPy arrays** for large coordinate datasets\n5. **Cache results** of expensive operations when processing similar data\n\n## Contributing\n\nContributions are welcome! Please see our [Contributing Guide](CONTRIBUTING.md) for details.\n\n## Citation\n\nIf you use fastGeoToolkit in research, please cite:\n\n```bibtex\n@software{fastgeotoolkit2024,\n title={fastGeoToolkit: A Novel High-Performance Geospatial Analysis Framework with Advanced Route Density Mapping},\n author={fastGeoToolkit Contributors},\n year={2024},\n url={https://github.com/a0a7/fastgeotoolkit},\n version={0.1.3}\n}\n```\n\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "High-performance geospatial analysis framework",
"version": "0.1.7",
"project_urls": {
"Bug Reports": "https://github.com/a0a7/fastgeotoolkit/issues",
"Documentation": "https://fastgeotoolkit.readthedocs.io",
"Source": "https://github.com/a0a7/fastgeotoolkit"
},
"split_keywords": [
"gps",
" geospatial",
" trajectory",
" route-density",
" heatmap",
" gpx",
" fit",
" polyline",
" rust",
" performance"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "98796f6cd754f7c121558d24308739ab54d41359884cd26a1558d25011634c7a",
"md5": "af3f2a734f78affbb0bad99613f00799",
"sha256": "a3597b92d9d70720d20dad3415918f33b754fa2a154cb0e6cc7c46b151d902fd"
},
"downloads": -1,
"filename": "fastgeotoolkit-0.1.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl",
"has_sig": false,
"md5_digest": "af3f2a734f78affbb0bad99613f00799",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": ">=3.8",
"size": 12636,
"upload_time": "2025-08-02T03:37:19",
"upload_time_iso_8601": "2025-08-02T03:37:19.003141Z",
"url": "https://files.pythonhosted.org/packages/98/79/6f6cd754f7c121558d24308739ab54d41359884cd26a1558d25011634c7a/fastgeotoolkit-0.1.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "f29e2ebc74856b80cdf634696426af8e75ca7bd5b1f748d3f66c681e6c567744",
"md5": "341e3e2429eb7d00504751acf31ab594",
"sha256": "11292b3975b421fa848bb278cb7672c12be4b8abaf8a8e47543d82bdc4d728b6"
},
"downloads": -1,
"filename": "fastgeotoolkit-0.1.7.tar.gz",
"has_sig": false,
"md5_digest": "341e3e2429eb7d00504751acf31ab594",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 29671,
"upload_time": "2025-08-02T03:37:20",
"upload_time_iso_8601": "2025-08-02T03:37:20.227630Z",
"url": "https://files.pythonhosted.org/packages/f2/9e/2ebc74856b80cdf634696426af8e75ca7bd5b1f748d3f66c681e6c567744/fastgeotoolkit-0.1.7.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-02 03:37:20",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "a0a7",
"github_project": "fastgeotoolkit",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "fastgeotoolkit"
}
JSON
