Hazard Risk Analysis Library

A TypeScript library for analyzing disaster risk in any polygon area based on tile map data.

Features

• ✅ Risk analysis in any polygon (GeoJSON)
• ✅ Multiple hazard tile sources support with weighted risk calculation
• ✅ Automatic grid generation with customizable resolution
• ✅ Pixel reading from tile images (hazard map + base map)
• ✅ Risk classification by RGB color
• ✅ Water area exclusion
• ✅ Detailed statistics calculation
• ✅ Node.js environment support
• ✅ TypeScript with full type safety
• ✅ Tile caching with LRU algorithm
• ✅ Concurrent tile preloading
• ✅ Nearest point detection
• ✅ Current location risk assessment
• ✅ DEM elevation data extraction

Installation

npm install @sk-global/hazard-risk

Usage

Node.js Environment

import { analyzeRiskInPolygon, TileCache } from '@sk-global/hazard-risk';

// Create cache for better performance
const cache = new TileCache(200 * 1024 * 1024, 10 * 60 * 1000); // 200MB, 10 minutes

const polygon = {
  type: 'Polygon',
  coordinates: [[
    [141.3, 43.0], // bottom-left
    [141.4, 43.0], // bottom-right
    [141.4, 43.1], // top-right
    [141.3, 43.1], // top-left
    [141.3, 43.0]  // close polygon
  ]]
};

const result = await analyzeRiskInPolygon({
  polygon,
  hazardTiles: [
    {
      url: 'https://disaportaldata.gsi.go.jp/raster/01_flood_l1_shinsuishin_newlegend_data/{z}/{x}/{y}.png',
      weight: 1.0,
      priority: 1,
      name: 'Flood Risk'
    }
  ],
  baseTileUrl: 'https://cyberjapandata.gsi.go.jp/xyz/pale/{z}/{x}/{y}.png',
  gridSize: 100, // 100 meters
  zoom: 12,
  currentLocation: { lat: 43.0619, lon: 141.3543 },
  mergeStrategy: 'max'
}, cache);

console.log('Risk statistics:', result.stats);
console.log('Total points:', result.total);
console.log('Water points:', result.waterCount);

Multiple Hazard Tiles Support

The library now supports analyzing risk from multiple hazard tile sources simultaneously with advanced merge strategies:

const result = await analyzeRiskInPolygon({
  polygon,
  hazardTiles: [
    {
      url: 'https://disaportaldata.gsi.go.jp/raster/01_flood_l1_shinsuishin_newlegend_data/{z}/{x}/{y}.png',
      weight: 1.0,
      priority: 1,
      name: 'Flood Risk'
    },
    {
      url: 'https://disaportaldata.gsi.go.jp/raster/02_tsunami_l2_shinsuishin_data/{z}/{x}/{y}.png',
      weight: 1.5,
      priority: 2,
      name: 'Tsunami Risk'
    },
    {
      url: 'https://disaportaldata.gsi.go.jp/raster/03_landslide_l1_shinsuishin_data/{z}/{x}/{y}.png',
      weight: 0.8,
      priority: 1,
      name: 'Landslide Risk'
    }
  ],
  baseTileUrl: 'https://cyberjapandata.gsi.go.jp/xyz/pale/{z}/{x}/{y}.png',
  gridSize: 100,
  zoom: 12,
  mergeStrategy: 'max' // or 'average', 'weighted', 'priority'
});

Merge Strategies

• max (default): Returns the highest risk level (safest approach, may have false positives)
• average: Returns average risk level (balanced, good for reliable sources)
• weighted: Returns weighted average based on provided weights
• priority: Returns risk level from tile with highest priority

Advanced Usage with Custom Hazard Configuration

import { createHazardConfig, analyzeRiskInPolygon } from '@sk-global/hazard-risk';

// Create custom hazard configuration
const tsunamiConfig = createHazardConfig('Tsunami Depth', {
  0: { name: 'level0', color: '#FFFFFF', description: '0m' },
  1: { name: 'level1', color: '#FFFFB3', description: '<0.3m' },
  2: { name: 'level2', color: '#F7F5A9', description: '<0.5m' },
  3: { name: 'level3', color: '#F8E1A6', description: '0.5~1m' },
  4: { name: 'level4', color: '#FFD8C0', description: '0.5~3m' },
  5: { name: 'level5', color: '#FFB7B7', description: '3~5m' },
  6: { name: 'level6', color: '#FF9191', description: '5~10m' },
  7: { name: 'level7', color: '#F285C9', description: '10~20m' },
  8: { name: 'level8', color: '#DC7ADC', description: '>20m' }
}, ['#bed2ff', '#f7f5a9', '#8bb8ff', '#6aa8ff']);

const result = await analyzeRiskInPolygon({
  polygon,
  hazardTiles: [
    {
      url: 'https://disaportaldata.gsi.go.jp/raster/01_flood_l1_shinsuishin_newlegend_data/{z}/{x}/{y}.png',
      weight: 1.0,
      priority: 1,
      name: 'Flood Risk'
    },
    {
      url: 'https://disaportaldata.gsi.go.jp/raster/02_tsunami_l2_shinsuishin_data/{z}/{x}/{y}.png',
      weight: 1.5,
      priority: 2,
      name: 'Tsunami Risk'
    }
  ],
  baseTileUrl: 'https://cyberjapandata.gsi.go.jp/xyz/pale/{z}/{x}/{y}.png',
  gridSize: 100,
  zoom: 12,
  hazardConfig: tsunamiConfig,
  currentLocation: { lat: 43.0619, lon: 141.3543 },
  mergeStrategy: 'weighted'
});

Results

Node.js Result Structure

{
  stats: {
    '0': 2174,    // Level 0 - No risk
    '2': 1294,    // Level 2 - Warning
    '4': 917,     // Level 4 - Moderate risk
    '5': 11,      // Level 5 - High risk
    '6': 2,       // Level 6 - Very high risk
    total: 4398   // Total points analyzed
  },
  nearestPoints: {
    '0': { latitude: 43.0616, longitude: 141.3538, distance: 56.56 },
    '2': { latitude: 43.0623, longitude: 141.3538, distance: 56.56 },
    // ... nearest points for each risk level
  },
  waterCount: 0,
  currentLocationRisk: { riskLevel: 2, isWater: false },
  hazardConfig: { /* hazard configuration */ }
}

API Reference

analyzeRiskInPolygon(options, cache?)

Analyze risk in polygon for Node.js environment.

Parameters:

• options.polygon: GeoJSON Polygon
• options.hazardTiles: Array of hazard tile configurations
  • url: URL template for hazard tiles
  • weight?: Weight for this hazard (default: 1)
  • priority?: Priority for this hazard (default: 1)
  • name?: Optional name for this hazard source
  • type?: Optional type for this hazard source
• options.baseTileUrl: URL template for base tiles
• options.gridSize: Distance between grid points (meters)
• options.zoom: Tile zoom level
• options.hazardConfig?: Custom hazard configuration
• options.currentLocation?: Current location for nearest point detection
• options.mergeStrategy?: Strategy to merge risk levels ('max', 'average', 'weighted', 'priority')
• cache?: Optional TileCache instance

TileCache(maxSize, ttl)

LRU cache for tile images.

Parameters:

• maxSize: Maximum cache size in bytes
• ttl: Time to live in milliseconds

createHazardConfig(name, levels, waterColors?)

Create custom hazard configuration.

Parameters:

• name: Hazard name
• levels: Risk level configuration object
• waterColors?: Array of water color hex codes

getElevationFromDEM(options)

Get elevation data from DEM tiles for Node.js environment.

Parameters:

• options.lat: Latitude
• options.lng: Longitude
• options.zoom?: Zoom level (default: 17)
• options.demConfigs?: Custom DEM configurations
• options.cache?: Optional TileCache instance

Returns:

{
  elevation: number | null,
  source: string,
  fixed: number,
  position: { lat: number, lng: number, zoom: number }
}

DEM Elevation Data

The library supports extracting elevation data from DEM (Digital Elevation Model) tiles. Default configurations support GSI Japan DEM services:

| DEM Type | Zoom Level | Precision | Description | |----------|------------|-----------|-------------| | DEM1A | 17 | 0.1m | Highest precision | | DEM5A | 15 | 0.1m | High precision | | DEM5B | 15 | 0.1m | High precision | | DEM5C | 15 | 0.1m | High precision | | DEM10B | 14 | 1m | Standard precision |

Example Usage

import { getElevationFromDEM } from '@sk-global/hazard-risk';

// Get elevation for Tokyo
const result = await getElevationFromDEM({
  lat: 35.6762,
  lng: 139.6503,
  zoom: 17
});

if (result.elevation !== null) {
  console.log(`Elevation: ${result.elevation.toFixed(result.fixed)}m`);
  console.log(`Source: ${result.source}`);
} else {
  console.log('No elevation data found');
}

Risk Classification

The library supports dynamic risk classification based on RGB colors. Default tsunami configuration:

| Color (RGB) | Level | Description | |-------------|-------|-------------| | 255,255,255 | 0 | No risk | | 255,255,179 | 1 | Attention | | 247,245,169 | 2 | Warning | | 248,225,166 | 3 | Moderate risk | | 255,216,192 | 4 | High risk | | 255,183,183 | 5 | Very high risk | | 255,145,145 | 6 | Extreme risk | | 242,133,201 | 7 | Critical risk | | 220,122,220 | 8 | Maximum risk |

Environment Support

• ✅ Node.js: Full support with PNG processing via pngjs
• ✅ TypeScript: Complete type definitions
• ✅ AWS Lambda: Optimized for serverless environments

Dependencies

• @turf/turf: Polygon processing, bounding box calculations
• pngjs: PNG image processing (Node.js)
• axios: HTTP requests for tile fetching

Performance Features

• Tile Caching: LRU cache with configurable size and TTL
• Concurrent Loading: Parallel tile fetching with rate limiting
• Grid Optimization: Efficient point grid generation with polygon masking
• Memory Management: Automatic cache eviction and memory cleanup

Examples

See the example.ts file for a complete working example using GSI Japan tsunami data.

License

MIT