Geometry data

1
import { geometryData } from '@tomtom-org/maps-sdk/services';
2
import { geocode } from '@tomtom-org/maps-sdk/services';
3

4
// First, get a place from geocoding or search
5
const place = await geocode({ query: 'Amsterdam, Netherlands' });
6

7
// Then fetch its geometry data
8
const geometry = await geometryData({
9
    geometries: place,
10
    zoom: 10 // Appropriate zoom level for the geometry detail
11
});
12

13
console.log(geometry.type); // "FeatureCollection"
14
console.log(geometry.features[0].geometry.type); // "Polygon" or "MultiPolygon"

1
import { geometryData } from '@tomtom-org/maps-sdk/services';
2
import { GeometriesModule } from '@tomtom-org/maps-sdk/map';
3

4
// Get place and its geometry
5
const place = await geocode({ query: 'Central Park, New York' });
6
const boundaries = await geometryData({ geometries: place, zoom: 15 });
7

8
// Display on map
9
const geometriesModule = await GeometriesModule.get(map);
10
geometriesModule.show(boundaries);
11

12
// Fit map to boundaries
13
if (boundaries.bbox) {
14
    map.mapLibreMap.fitBounds(boundaries.bbox);
15
}

1
// Low detail for country/region level
2
const countryBoundary = await geometryData({
3
    geometries: place,
4
    zoom: 5
5
});
6

7
// Medium detail for city level
8
const cityBoundary = await geometryData({
9
    geometries: place,
10
    zoom: 10
11
});
12

13
// High detail for neighborhood level
14
const detailedBoundary = await geometryData({
15
    geometries: place,
16
    zoom: 15
17
});

1
// Get multiple places
2
const places = await search({
3
    query: 'parks',
4
    position: [4.9041, 52.3676],
5
    limit: 5
6
});
7

8
// Get geometries for all places
9
const allGeometries = await geometryData({
10
    geometries: places,
11
    zoom: 14
12
});
13

14
// Display all boundaries
15
geometriesModule.show(allGeometries);

1
const geometriesModule = await GeometriesModule.get(map, {
2
    fillConfig: {
3
        fillColor: '#87CEEB',
4
        fillOpacity: 0.3
5
    },
6
    lineConfig: {
7
        lineColor: '#4169E1',
8
        lineWidth: 2,
9
        lineOpacity: 0.8
10
    }
11
});
12

13
const boundaries = await geometryData({ geometries: place, zoom: 12 });
14
geometriesModule.show(boundaries);

1
const displayAdminBoundaries = async (placeName, zoomLevel = 8) => {
2
    try {
3
        const place = await geocode({ query: placeName });
4

5
        if (place.features.length > 0) {
6
            const boundaries = await geometryData({
7
                geometries: place,
8
                zoom: zoomLevel
9
            });
10

11
            geometriesModule.show(boundaries);
12

13
            // Fit map to show the entire boundary
14
            if (boundaries.bbox) {
15
                map.mapLibreMap.fitBounds(boundaries.bbox, { padding: 50 });
16
            }
17
        }
18
    } catch (error) {
19
        console.error('Failed to display boundaries:', error);
20
    }
21
};
22

23
// Display Netherlands boundaries
24
await displayAdminBoundaries('Netherlands', 6);

1
const showServiceAreas = async (locations) => {
2
    const serviceAreas = [];
3

4
    for (const location of locations) {
5
        const place = await geocode({ query: location.address });
6

7
        if (place.features.length > 0) {
8
            const geometry = await geometryData({
9
                geometries: place,
10
                zoom: 12
11
            });
12

13
            serviceAreas.push({
14
                ...location,
15
                boundary: geometry
16
            });
17
        }
18
    }
19

20
    // Display all service areas
21
    serviceAreas.forEach(area => {
22
        geometriesModule.show(area.boundary);
23
    });
24

25
    return serviceAreas;
26
};

1
const compareAreas = async (placeNames) => {
2
    const areas = {};
3

4
    for (const name of placeNames) {
5
        const place = await geocode({ query: name });
6

7
        if (place.features.length > 0) {
8
            const geometry = await geometryData({
9
                geometries: place,
10
                zoom: 8
11
            });
12

13
            areas[name] = {
14
                geometry,
15
                bbox: geometry.bbox,
16
                area: calculateArea(geometry) // Custom area calculation
17
            };
18
        }
19
    }
20

21
    return areas;
22
};
23

24
const areas = await compareAreas(['Texas', 'California', 'Alaska']);

1
const getOptimalZoom = (areaType) => {
2
    const zoomLevels = {
3
        'country': 4,
4
        'state': 6,
5
        'region': 8,
6
        'city': 10,
7
        'district': 12,
8
        'neighborhood': 14,
9
        'detailed': 16
10
    };
11

12
    return zoomLevels[areaType] || 10;
13
};
14

15
const geometry = await geometryData({
16
    geometries: place,
17
    zoom: getOptimalZoom('city')
18
});

1
class GeometryCache {
2
    constructor() {
3
        this.cache = new Map();
4
    }
5

6
    getCacheKey(placeId, zoom) {
7
        return `${placeId}-${zoom}`;
8
    }
9

10
    async getGeometry(place, zoom) {
11
        const placeId = place.features[0]?.properties.id;
12
        const key = this.getCacheKey(placeId, zoom);
13

14
        if (this.cache.has(key)) {
15
            return this.cache.get(key);
16
        }
17

18
        const geometry = await geometryData({ geometries: place, zoom });
19
        this.cache.set(key, geometry);
20

21
        return geometry;
22
    }
23
}
24

25
const cache = new GeometryCache();
26
const geometry = await cache.getGeometry(place, 10);

1
const safeGeometryData = async (place, zoom = 10) => {
2
    try {
3
        if (!place.features || place.features.length === 0) {
4
            return { success: false, message: 'No place data provided' };
5
        }
6

7
        const geometry = await geometryData({ geometries: place, zoom });
8

9
        if (!geometry.features || geometry.features.length === 0) {
10
            return {
11
                success: false,
12
                message: 'No geometry data available for this place'
13
            };
14
        }
15

16
        return { success: true, geometry };
17

18
    } catch (error) {
19
        return {
20
            success: false,
21
            message: `Geometry data request failed: ${error.message}`
22
        };
23
    }
24
};