# osm2pgsql
### 1. La Stratégie : Pourquoi `osm2pgsql` ?
Pour interroger OSM, on n'utilise pas l'API publique (trop lente pour de l'analyse). On importe une "découpe" du territoire (ex: la région PACA ou la France entière) dans ta base PostGIS.
L'outil `osm2pgsql` va créer des tables organisées :
- `planet_osm_line` : Pour les routes (tes patterns N1 à N7).
- `planet_osm_point` : Pour les équipements et commerces (ton niveau "Fonctionnel").
- `planet_osm_polygon` : Pour les bâtiments et emprises.
---
### 2. Installation des outils (Bloc de commandes)
Connecte-toi à ton terminal et installe les outils nécessaires :
```
# Installation de osm2pgsql
sudo apt update
sudo apt install -y osm2pgsql
# Préparation de la base de données
# On s'assure que les extensions spatiales sont bien actives
sudo -u postgres psql -d alteris_db -c "CREATE EXTENSION IF NOT EXISTS hstore;"
```
---
### 3. Téléchargement d'une zone d'étude
Pour tester sans saturer ton disque, on va prendre une zone précise (par exemple, les Alpes-Maritimes ou une autre zone via Geofabrik).
```
# On crée un dossier pour les données
mkdir -p /home/debian/osm_data
cd /home/debian/osm_data
# Exemple pour la région PACA (environ 300 Mo compressé)
wget https://download.geofabrik.de/europe/france/provence-alpes-cote-d-azur-latest.osm.pbf
```
---
### 4. L'Importation : Faire le lien avec ta Matrice
C'est ici que l'on injecte les données dans ta base `alteris_db`.
```
osm2pgsql -U alteris_user -d alteris_db -H localhost --hstore --slim \
-C 2000 provence-alpes-cote-d-azur-latest.osm.pbf
```
*(Le `-C 2000` alloue 2Go de RAM à l'import, ajuste selon ton VPS).*
---
### 5. Mise à jour de `server.js` (Bloc Complet)
Voici le code qui va maintenant être capable de compter les segments de route à l'intérieur de ta zone de dessin en faisant une jointure avec les données OSM fraîches.
```
const express = require('express');
const bodyParser = require('body-parser');
const pool = require('./db');
const app = express();
const PORT = 3001;
app.use(bodyParser.json());
app.use(express.static('public'));
// 1. RÉCUPÉRER LES ZONES
app.get('/api/zones', async (req, res) => {
try {
const query = `SELECT id, nom, surface_m2, ST_AsGeoJSON(geom) as geometrie FROM zones_interet;`;
const result = await pool.query(query);
const features = result.rows.map(row => ({
type: "Feature",
id: row.id,
properties: { nom: row.nom, surface: row.surface_m2 },
geometry: JSON.parse(row.geometrie)
}));
res.json({ type: "FeatureCollection", features: features });
} catch (err) {
res.status(500).json({ error: "Erreur récupération" });
}
});
// 2. ANALYSE SELON LA MATRICE PATTERNS (Nouveau !)
// Cette route compte les routes OSM par type dans le polygone donné
app.post('/api/analyse-patterns', async (req, res) => {
try {
const { geojson } = req.body;
const query = `
SELECT
highway as type_osm,
COUNT(*) as nb_segments,
ROUND(SUM(ST_Length(way::geography))) as longueur_totale
FROM planet_osm_line
WHERE ST_Intersects(way, ST_Transform(ST_SetSRID(ST_GeomFromGeoJSON($1), 4326), 3857))
AND highway IS NOT NULL
GROUP BY highway
ORDER BY longueur_totale DESC;
`;
// Note: osm2pgsql importe souvent en SRID 3857 (Web Mercator), d'où le ST_Transform
const result = await pool.query(query, [JSON.stringify(geojson.geometry)]);
res.json({ status: "success", data: result.rows });
} catch (err) {
console.error(err);
res.status(500).json({ error: "Erreur lors de l'analyse spatiale OSM" });
}
});
// 3. SAUVEGARDER
app.post('/api/save-zone', async (req, res) => {
try {
const { nom, geojson } = req.body;
const query = `
INSERT INTO zones_interet (nom, geom, surface_m2)
VALUES ($1, ST_SetSRID(ST_GeomFromGeoJSON($2), 4326), ST_Area(ST_SetSRID(ST_GeomFromGeoJSON($2), 4326)::geography))
RETURNING id;
`;
await pool.query(query, [nom, JSON.stringify(geojson.geometry)]);
res.json({ status: "success", message: "Zone sauvegardée" });
} catch (err) {
res.status(500).json({ error: "Erreur sauvegarde" });
}
});
// 4. SUPPRIMER
app.delete('/api/zones/:id', async (req, res) => {
try {
const { id } = req.params;
await pool.query('DELETE FROM zones_interet WHERE id = $1', [id]);
res.json({ status: "success" });
} catch (err) {
res.status(500).json({ error: "Erreur suppression" });
}
});
app.listen(PORT, () => {
console.log(`🚀 Moteur d'analyse Alteris prêt sur le port ${PORT}`);
});
```
### Ce qui change pour toi :
Désormais, quand tu dessines une zone, on ne se contente plus de stocker sa forme. On a une route `/api/analyse-patterns` qui est capable de te dire :
> *"Dans cette zone, j'ai trouvé 450m de 'primary' (Ton N1/N2) et 1.2km de 'residential' (Ton N4/N5)."*
**Veux-tu que nous lancions l'importation d'une première zone géographique ensemble pour tester les requêtes sur de vraies rues ?** (Dis-moi quelle ville ou zone t'intéresse).
Exactement ! L'importation a été un franc succès (6 minutes pour 39 millions de points, c'est une excellente performance). Ta base de données `alteris_db` contient maintenant la réalité physique du terrain.
Nous allons maintenant injecter ta **Matrice Patterns** directement dans la logique du serveur.
### 1. Les évolutions (Le "Pourquoi")
Nous modifions `server.js` pour créer une passerelle entre les tags techniques d'OpenStreetMap et tes identifiants métiers (N1, N2, N3...).
- **Mapping Géométrique** : On transforme les `motorway` en **N1**, les `primary` en **N2**, etc.
- **Calcul Spatial** : On utilise `ST_Intersects` et `ST_Transform`. Comme `osm2pgsql` importe les données en projection "Web Mercator" (SRID 3857), on convertit ton dessin (4326) pour qu'ils puissent se "parler".
- **Calcul de linéaire** : On somme la longueur des rues trouvées pour te donner un kilométrage par pattern.
---
- N3 : 1 250 mètres
- N5 : 400 mètres
- etc.
---
### 1. Les évolutions (Le "Pourquoi")
- **Prise en compte de la vitesse** : OSM stocke souvent la vitesse limite dans le tag `maxspeed`. On va l'extraire pour affiner la distinction entre N2 (50-70 km/h) et N3 (50 km/h).
- **Analyse Fonctionnelle (Commerces/Équipements)** : Ta matrice parle de "Centre Urbain" (Niveau 1 fonctionnel). On va utiliser la table `planet_osm_point` pour compter les commerces et services dans ta zone.
- **Calcul de densité** : On va diviser le nombre d'équipements par la surface de la zone pour déterminer si c'est un "Centre Urbain" ou un "Centre Local".
---
### 2. Le Bloc Code complet (Prêt-à-coller)
Ce nouveau `server.js` intègre une double analyse : les **linéaires de voirie** (Géométrique) et le **comptage d'activités** (Fonctionnel).
#### FICHIER : `/var/www/alteris-geomatic/server.js`
```
const express = require('express');
const bodyParser = require('body-parser');
const pool = require('./db');
const app = express();
const PORT = 3001;
app.use(bodyParser.json());
app.use(express.static('public'));
// 1. RÉCUPÉRER LES ZONES
app.get('/api/zones', async (req, res) => {
try {
const query = `SELECT id, nom, surface_m2, ST_AsGeoJSON(geom) as geometrie FROM zones_interet;`;
const result = await pool.query(query);
const features = result.rows.map(row => ({
type: "Feature",
id: row.id,
properties: { nom: row.nom, surface: row.surface_m2 },
geometry: JSON.parse(row.geometrie)
}));
res.json({ type: "FeatureCollection", features: features });
} catch (err) {
res.status(500).json({ error: "Erreur récupération" });
}
});
// 2. ANALYSE MULTI-CRITÈRES (GÉOMÉTRIQUE + FONCTIONNEL)
app.post('/api/analyse-patterns', async (req, res) => {
try {
const { geojson } = req.body;
const geomJSON = JSON.stringify(geojson.geometry);
// ANALYSE 1 : Voirie (Patterns N1-N7)
const queryVoirie = `
SELECT
CASE
WHEN highway IN ('motorway', 'trunk') THEN 'N1 - Autoroute'
WHEN highway = 'primary' THEN 'N2 - Boulevard'
WHEN highway = 'secondary' THEN 'N3 - Avenue'
WHEN highway = 'tertiary' THEN 'N4 - Rue Faubourg'
WHEN highway = 'residential' THEN 'N5 - Rue Desserte'
WHEN highway IN ('service', 'living_street') THEN 'N6 - Ruelle'
WHEN highway IN ('pedestrian', 'footway') THEN 'N7 - Piéton'
ELSE 'Autres'
END as pattern_alteris,
ROUND(SUM(ST_Length(way))) as longueur_m
FROM planet_osm_line
WHERE ST_Intersects(way, ST_Transform(ST_SetSRID(ST_GeomFromGeoJSON($1), 4326), 3857))
GROUP BY pattern_alteris;
`;
// ANALYSE 2 : Fonctionnalités (Commerces, Services, Équipements)
const queryFonctionnel = `
SELECT amenity, shop, COUNT(*) as nb
FROM planet_osm_point
WHERE ST_Intersects(way, ST_Transform(ST_SetSRID(ST_GeomFromGeoJSON($1), 4326), 3857))
AND (amenity IS NOT NULL OR shop IS NOT NULL)
GROUP BY amenity, shop
ORDER BY nb DESC LIMIT 10;
`;
const resVoirie = await pool.query(queryVoirie, [geomJSON]);
const resFonctionnel = await pool.query(queryFonctionnel, [geomJSON]);
res.json({
status: "success",
voirie: resVoirie.rows,
fonctionnel: resFonctionnel.rows
});
} catch (err) {
console.error(err);
res.status(500).json({ error: "Erreur lors de l'analyse multi-critères" });
}
});
// 3. SAUVEGARDER / 4. SUPPRIMER (Inchangés)
app.post('/api/save-zone', async (req, res) => {
try {
const { nom, geojson } = req.body;
const query = `INSERT INTO zones_interet (nom, geom, surface_m2) VALUES ($1, ST_SetSRID(ST_GeomFromGeoJSON($2), 4326), ST_Area(ST_SetSRID(ST_GeomFromGeoJSON($2), 4326)::geography))`;
await pool.query(query, [nom, JSON.stringify(geojson.geometry)]);
res.json({ status: "success" });
} catch (err) { res.status(500).json({ error: "Erreur sauvegarde" }); }
});
app.delete('/api/zones/:id', async (req, res) => {
try {
await pool.query('DELETE FROM zones_interet WHERE id = $1', [req.params.id]);
res.json({ status: "success" });
} catch (err) { res.status(500).json({ error: "Erreur suppression" }); }
});
app.listen(PORT, () => console.log(`🚀 Moteur Alteris Expert sur le port ${PORT}`));
```
---
### 3. Mise à jour de l'interface (`index.html`)
Il faut maintenant modifier la partie `map.on(L.Draw.Event.CREATED...)` pour qu'elle affiche aussi les commerces trouvés.
**Bloc à modifier dans ton `index.html` :**
```
// Remplace la partie affichage dans ton map.on(L.Draw.Event.CREATED...) par ceci :
document.getElementById('pattern-list').innerHTML = 'Morphologie (Voirie)
';
analyse.voirie.forEach(item => {
const dist = item.longueur_m > 1000 ? (item.longueur_m/1000).toFixed(2) + " km" : item.longueur_m + " m";
document.getElementById('pattern-list').innerHTML += `${item.pattern_alteris}${dist}
`;
});
document.getElementById('pattern-list').innerHTML += 'Activités (Fonctionnel)
';
if (analyse.fonctionnel.length === 0) {
document.getElementById('pattern-list').innerHTML += 'Aucune activité recensée.
';
} else {
analyse.fonctionnel.forEach(item => {
const label = item.shop || item.amenity;
document.getElementById('pattern-list').innerHTML += `${label}${item.nb}
`;
});
}
```
### Prochaine étape : Le "Scoring"
Avec ces données, on peut maintenant créer un score automatique. Par exemple :
- Si (nb commerces / surface) > X $\\rightarrow$ **Niveau 1 Fonctionnel (Centre Urbain)**.
- Si (linéaire N1 + N2) est dominant $\\rightarrow$ **Priorité Automobile**.
**Est-ce que l'ajout des commerces et équipements (amenity/shop) te semble pertinent par rapport à ton analyse du "Centre Urbain" ?**