Initial release v1.0: Adres analyse met isochroon bereikbaarheid

- Geocoding via PDOK Locatieserver - Isochroon (auto 20 min) via OpenRouteService - Rapport generatie in markdown formaat - Voorbeeld adres: Griendvelden 14, Best
2026-06-19 18:53:39 +02:00
11 changed files with 209 additions and 932 deletions
@@ -0,0 +1,6 @@
 *.json
 *.html
 *.png
 __pycache__/
 *.pyc
 .pytest_cache/
@@ -0,0 +1,73 @@
 # Adres Analyse
 Genereert modulaire rapporten voor Nederlandse adressen met bereikbaarheid, voorzieningen en locatie kenmerken.
 ## Installatie
 ```bash
 git clone https://git.wouterverduin.nl/wouser/adres-analyse.git
 cd adres-analyse
 pip install folium shapely
 ```
 ## Gebruik
 ```bash
 python3 rapport.py "Griendvelden 14 Best"
 ```
 Output is markdown formaat naar stdout.
 ## Features
 ### Huidig (v1.0)
 - **Geocoding** via PDOK Locatieserver (gratis, geen API key)
 - **Isochroon bereikbaarheid** (auto, 20 min) via OpenRouteService
 - Oppervlakte bereikbaar gebied (km²)
 - Reach factor en geografisch bereik
 ### Gepland
 - Cycling isochroon (fiets)
 - OV bereikbaarheid
 - Voorzieningen in de buurt (OSM)
 - Luchtkwaliteit (RIVM)
 - Geluidsniveaus
 - Overstromingsrisico
 - Demografie (CBS)
 - Woningwaarde (Kadaster/WOZ)
 ## Vereisten
 - **OpenRouteService**: Draaiend op `192.168.1.71:9080` met `driving-car` profiel
 - **PDOK Locatieserver**: Openbaar, geen setup nodig
 ## Configuratie
 Pas aan in `rapport.py`:
 ```python
 ORS_BASE = "http://192.168.1.71:9080/ors/v2"
 PDOK_BASE = "https://api.pdok.nl/bzk/locatieserver/search/v3_1"
 ```
 ## Voorbeeld output
 ```
 📍 **Adres Analyse Rapport**
 Gegenereerd: 19-06-2026 18:49
 🔍 Geocoding...
 **Adres:** Griendvelden 14, 5685JL Best
 **Coördinaten:** 51.505547, 5.370553
 🚗 **Bereikbaarheid (Auto 20 min)**
 **Oppervlakte:** 316.8 km²
 **Reach factor:** 0.091
 **Bereik:** 51.378°-51.679°N, 5.128°-5.530°E
 ---
 _Onderdeel 1/?: Isochroon bereikbaarheid_
 ```
 ## Licentie
 MIT
@@ -1,150 +0,0 @@
 ---
 name: adres-analyse
 description: Genereer uitgebreide adresrapporten met geocodering, isochronen (bereikbaarheidskaarten), en andere locatie-gerelateerde analyses voor Nederlandse adressen.
 tags: [geocoding, isochrone, routing, maps, locatie-analyse, pdok, ors]
 ---
 # Adres Analyse
 Genereer modulaire rapporten voor Nederlandse adressen. Elk onderdeel wordt als aparte sectie toegevoegd aan het rapport.
 ## Rapport generatie
 **Hoofdscript:** `scripts/rapport.py` (ook geïnstalleerd op `/root/adres-analyse/rapport.py`)
 > ⚠️ **Let op**: de geïnstalleerde versie kan achterlopen op de skill-template. **Hele functies kunnen ontbreken** (bijv. Obsidian-integratie). Voer altijd eerst de sync-check uit:
 **Sync-check (voor elke sessie):**
 ```bash
 diff ~/.hermes/skills/research/adres-analyse/scripts/rapport.py /root/adres-analyse/rapport.py
 ```
 Als er output is, synchroniseer onmiddellijk:
 ```bash
 cp ~/.hermes/skills/research/adres-analyse/scripts/rapport.py /root/adres-analyse/rapport.py
 ```
 **Daarna pas uitvoeren:**
 ```bash
 python3 /root/adres-analyse/rapport.py "Adres Plaats"
 ```
 Output is markdown formaat, direct naar stdout (voor Telegram) én wordt opgeslagen in Obsidian vault (map: huizenjacht).
 ## Huidige onderdelen
 ### 1. Bereikbaarheid (Isochroon)
 - **Auto profiel:** `driving-car`, 20 minuten, blauw op de kaart
 - **Fiets profiel:** `cycling-regular`, 30 minuten, groen op de kaart
 - **Metrics:** Oppervlakte (km²), reach factor, geografisch bereik
 - **Data bron:** ORS op `192.168.1.71:9080`
 ### 2. Voorzieningen in de buurt
 - **Bron:** lokale PostGIS database met geselecteerde POI's uit heel Nederland OSM extract
 - **Docker:** `postgis/postgis` op poort `5433`, database `adresanalyse`
 - **Import:** `import-osm.sh` downloadt `netherlands-latest.osm.pbf` en `osm-poi-import.py` importeert alleen `shop=supermarket` en `amenity=school`
 - **Routeverrijking:** ORS Matrix voor `driving-car` en `cycling-regular`
 - **Output:** top 5 supermarkten en top 5 scholen in rapport + markers op Folium kaart
 ### 3. (Toekomstige onderdelen)
 - OV bereikbaarheid
 - Luchtkwaliteit
 - Demografie
 - Vastgoeddata
 ## Workflow (intern)
 ### Stap 1: Geocoding (adres → coördinaten)
 Gebruik **PDOK Locatieserver** (gratis, geen API key nodig):
 ```bash
 curl -s "https://api.pdok.nl/bzk/locatieserver/search/v3_1/free?q={adres}&rows=5&fl=centroide_ll,weergavenaam,postcode,woonplaatsnaam,type,huisnummer"
 ```
 **Parsing:**
 - Zoek naar `type=adres` voor exacte adres match (niet straat)
 - `centroide_ll` is in formaat `POINT(lon lat)` → split op spatie, coords[0]=lon, coords[1]=lat
 - Fallback naar eerste resultaat als geen adres match
 ### Stap 2: Isochroon ophalen
 POST naar ORS:
 ```bash
 curl -s -X POST "http://192.168.1.71:9080/ors/v2/isochrones/driving-car" \
  -H "Content-Type: application/json" \
  -d '{
    "locations": [[lon, lat]],
    "range": [1200],
    "attributes": ["area","reachfactor","total_pop"]
  }'
 ```
 **Parameters:**
 - `range` in seconden (20 min = 1200)
 - Response bevat GeoJSON FeatureCollection met polygon geometrie
 - GeoJSON wordt opgeslagen in `/tmp/isochroon_{timestamp}.geojson`
 ### Stap 3: Kaart genereren (optioneel)
 Gebruik script: `scripts/generate-map.py`
 ```bash
 python3 scripts/generate-map.py "Griendvelden 14, Best" /root/adres-analyse/kaart.html
 ```
 Voor Telegram delivery:
 1. Open HTML in browser: `browser_navigate` naar `file:///root/adres-analyse/kaart.html`
 2. Screenshot maken: `browser_vision` met vraag over kaart inhoud
 3. Screenshot pad gebruiken in MEDIA: directive voor Telegram
 **Vereisten:** `pip install folium shapely`
 ## Pitfalls
 1. **Geocoding exactheid**: PDOK zoekt op straatnaam als huisnummer niet exact matcht - altijd checken of `type=adres` in response. Zoek door eerste 5 resultaten voor adres match.
 2. **ORS cycling profielen niet geactiveerd**: Alleen `driving-car` werkt momenteel. Fietsprofielen geven error "RoutingProfile.getGraphhopper() is null". Zie `references/ors-setup.md` voor activatie-instructies.
 3. **Coördinaten volgorde**: PDOK geeft `POINT(lon lat)` (WGS84), maar ORS verwacht `[[lon, lat]]` in array. Let op volgorde bij parsen.
 4. **Oppervlakte conversie**: ORS geeft area in m², niet km². Deel door 1_000_000 voor km² of 10_000 voor hectare.
 5. **Folium installatie**: `pip install folium shapely` nodig voor kaartgeneratie (niet voor basis rapport).
 6. **Telegram media**: HTML-kaarten werken niet direct in Telegram - maak PNG screenshots via browser tools.
 7. **Rapport zonder kaart**: Het rapport.py script genereert alleen tekst. Voor visuele kaart: gebruik apart folium script + browser screenshot workflow.
 8. **Obsidian API**: Vereist dat Obsidian draait met Local REST API plugin ingeschakeld. Token en host staan in script. Bestandsnaam wordt gegenereerd met timestamp om collisions te voorkomen.
 9. **Script drift — skill vs. installed**: Het geïnstalleerde script op `/root/adres-analyse/rapport.py` kan achterlopen op de skill-template (`scripts/rapport.py`). **Dit is niet alleen kleine drift — hele functies kunnen ontbreken** (bijv. `schrijf_naar_obsidian()`, Obsidian-config, token-definities). Altijd eerst `diff` uitvoeren. Als de Obsidian-opslag niet werkt, is dit de eerste plek om te checken. Zie `references/script-drift.md`.
 10. **Token patching via patch tool**: Bij het bewerken van scripts die API tokens bevatten (zoals `OBSIDIAN_TOKEN`) met de `patch` tool, kan de security scan het token maskeren of splitsen. Dit resulteert in een kapotte string concatenatie en 401 Unauthorized errors. **Workaround**: gebruik `read_file` om de exacte regel te zien, schrijf dan het volledige token expliciet met `write_file`, of synchroniseer het hele skill-script. Verifieer altijd na patchen dat het script syntactisch correct is (`python3 -m py_compile script.py`). Zie `references/token-patching.md`.
 ## Uitbreiding
 Nieuwe onderdelen toevoegen:
 1. Voeg functie toe aan `/root/adres-analyse/rapport.py`
 2. Roep aan in `genereer_rapport()` na geocoding
 3. Update deze skill met nieuwe sectie onder "Huidige onderdelen"
 4. Verhoog onderdeel teller in output footer
 ## Voorbeeld rapport
 ```
 📍 **Adres Analyse Rapport**
 Gegenereerd: 19-06-2026 18:42
 🔍 Geocoding...
 **Adres:** Griendvelden 14, 5685JL Best
 **Coördinaten:** 51.505547, 5.370553
 🚗 **Bereikbaarheid (Auto 20 min)**
 **Oppervlakte:** 316.8 km²
 **Reach factor:** 0.091
 **Bereik:** 51.378°-51.679°N, 5.128°-5.530°E
 💾 Data opgeslagen: `/tmp/isochroon_20260619_184239.geojson`
 ---
 _Onderdeel 1/?: Isochroon bereikbaarheid_
 ```
@@ -0,0 +1,130 @@
 #!/usr/bin/env python3
 """
 Adres Analyse - Rapport generator
 Gebruikt PDOK voor geocoding en ORS voor isochronen
 """
 import json
 import sys
 import urllib.request
 import urllib.parse
 from datetime import datetime
 # Config
 ORS_BASE = "http://192.168.1.71:9080/ors/v2"
 PDOK_BASE = "https://api.pdok.nl/bzk/locatieserver/search/v3_1"
 def geocode_adres(adres):
    """Geocode adres naar coördinaten via PDOK Locatieserver"""
    # Gebruik suggest endpoint voor betere adres matching
    params = urllib.parse.urlencode({
        'q': adres,
        'rows': 5,
        'fl': 'centroide_ll,weergavenaam,postcode,woonplaatsnaam,type,huisnummer'
    })
    url = f"{PDOK_BASE}/free?{params}"
    with urllib.request.urlopen(url, timeout=10) as resp:
        data = json.loads(resp.read())
    if not data['response']['docs']:
        raise ValueError(f"Adres niet gevonden: {adres}")
    # Zoek naar exact adres match (type=adres)
    doc = None
    for d in data['response']['docs']:
        if d.get('type') == 'adres':
            doc = d
            break
    if not doc:
        doc = data['response']['docs'][0]  # Fallback naar eerste resultaat
    # Parse POINT(lon lat) format
    point = doc['centroide_ll']
    coords = point.replace('POINT(', '').replace(')', '').split()
    lon, lat = float(coords[0]), float(coords[1])
    return {
        'adres': doc.get('weergavenaam', adres),
        'postcode': doc.get('postcode', ''),
        'woonplaats': doc.get('woonplaatsnaam', ''),
        'lat': lat,
        'lon': lon
    }
 def haal_isochroon(lon, lat, profiel='driving-car', minuten=20):
    """Haal isochroon op van ORS"""
    url = f"{ORS_BASE}/isochrones/{profiel}"
    payload = {
        "locations": [[lon, lat]],
        "range": [minuten * 60],  # seconden
        "attributes": ["area", "reachfactor", "total_pop"]
    }
    req = urllib.request.Request(
        url,
        data=json.dumps(payload).encode(),
        headers={'Content-Type': 'application/json'},
        method='POST'
    )
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.loads(resp.read())
 def format_oppervlakte(m2):
    """Converteer m² naar leesbaar formaat"""
    if m2 >= 1_000_000:
        return f"{m2/1_000_000:.1f} km²"
    elif m2 >= 10_000:
        return f"{m2/10_000:.1f} ha"
    else:
        return f"{m2:.0f} m²"
 def genereer_rapport(adres_input):
    """Genereer volledig adres analyse rapport"""
    print(f"📍 **Adres Analyse Rapport**")
    print(f"Gegenereerd: {datetime.now().strftime('%d-%m-%Y %H:%M')}")
    print()
    # Geocoding
    print("🔍 Geocoding...")
    locatie = geocode_adres(adres_input)
    print(f"**Adres:** {locatie['adres']}")
    print(f"**Coördinaten:** {locatie['lat']:.6f}, {locatie['lon']:.6f}")
    print()
    # Isochroon
    print("🚗 **Bereikbaarheid (Auto 20 min)**")
    iso_data = haal_isochroon(locatie['lon'], locatie['lat'], 'driving-car', 20)
    if 'features' in iso_data and iso_data['features']:
        props = iso_data['features'][0]['properties']
        area_m2 = props.get('area', 0)
        reach = props.get('reachfactor', 0)
        print(f"**Oppervlakte:** {format_oppervlakte(area_m2)}")
        print(f"**Reach factor:** {reach:.3f}")
        print()
        # Bereken bbox
        bbox = iso_data.get('bbox', [])
        if len(bbox) == 4:
            print(f"**Bereik:** {bbox[1]:.3f}°-{bbox[3]:.3f}°N, {bbox[0]:.3f}°-{bbox[2]:.3f}°E")
            print()
        # Save GeoJSON voor kaart generatie
        output_file = f"/tmp/isochroon_{datetime.now().strftime('%Y%m%d_%H%M%S')}.geojson"
        with open(output_file, 'w') as f:
            json.dump(iso_data, f)
        print(f"💾 Data opgeslagen: `{output_file}`")
    else:
        print("❌ Geen isochroon data ontvangen")
    print()
    print("---")
    print("_Onderdeel 1/?: Isochroon bereikbaarheid_")
 if __name__ == '__main__':
    adres = sys.argv[1] if len(sys.argv) > 1 else "Griendvelden 14 Best"
    genereer_rapport(adres)
@@ -1,93 +0,0 @@
 # OpenRouteService (ORS) Setup Guide
 ## Huidige status
 - **Locatie**: `192.168.1.71:9080` (Docker container)
 - **Versie**: 8.0.0 (build 2024-03-21)
 - **Actief profiel**: `driving-car` ✅
 - **Niet actief**: `cycling-regular`, `cycling-electric`, `foot-walking`, `driving-hgv`, `wheelchair` ❌
 ## Cycling profiel activeren
 ### Stap 1: SSH naar host
 ```bash
 ssh 192.168.1.71
 ```
 ### Stap 2: ORS config aanpassen
 Locatie: `/path/to/ors/config/ors-config.yml` (pas aan naar jouw setup)
 Voeg toe onder `ors.engine.profiles`:
 ```yaml
 ors:
  engine:
    profiles:
      driving-car:
        enabled: true
      cycling-regular:
        enabled: true
        graph_path: /home/ors/graphs/cycling-regular
      cycling-electric:
        enabled: true
        graph_path: /home/ors/graphs/cycling-electric
 ```
 ### Stap 3: Graph data downloaden
 ORS heeft pre-built graphs nodig of moet ze bouwen van OSM data:
 ```bash
 # Download Netherlands OSM extract
 wget https://download.geofabrik.de/europe/netherlands-latest.osm.pbf
 # Bouw graph (kan uren duren)
 docker exec -it ors-container java -jar ors-engine.jar build
 ```
 ### Stap 4: Container herstarten
 ```bash
 docker restart ors-container
 ```
 ### Stap 5: Verifiëren
 ```bash
 curl -s -X POST "http://192.168.1.71:9080/ors/v2/isochrones/cycling-regular" \
  -H "Content-Type: application/json" \
  -d '{
    "locations": [[5.37055345, 51.50554732]],
    "range": [1800]
  }' | head -c 200
 ```
 Verwacht: GeoJSON FeatureCollection (geen error).
 ## Troubleshooting
 ### Error: "getRouteProfile(int) is null"
 → Profiel niet geactiveerd in config of graph ontbreekt.
 ### Error: "Parameter 'X' has incorrect value"
 → Profielnaam bestaat niet (typo of niet ondersteund).
 ### Lange wachttijd na herstart
 → ORS bouwt graphs bij eerste start (kan 30+ min duren voor NL).
 ## API Endpoints
 ### Geocoding (niet beschikbaar op deze instantie)
 ORS heeft optionele Pelias geocoding, maar die draait niet op 192.168.1.71.
 Gebruik PDOK Locatieserver als alternatief.
 ### Isochrones
 ```
 POST /ors/v2/isochrones/{profile}
 ```
 ### Routing
 ```
 POST /ors/v2/directions/{profile}
 ```
 ### Matrix
 ```
 POST /ors/v2/matrix/{profile}
 ```
@@ -1,35 +0,0 @@
 # Script Drift: skill-template vs. installed script
 ## Probleem
 Het geïnstalleerde script `/root/adres-analyse/rapport.py` kan achterlopen op de skill-template onder `~/.hermes/skills/research/adres-analyse/scripts/rapport.py`.
 ## Gevonden verschillen (2026-06-22)
 | Feature | Skill-template | Geïnstalleerd op `/root/adres-analyse/rapport.py` |
 |---------|---------------|---------------------------------------------------|
 | `schrijf_naar_obsidian()` | ✅ Aanwezig | ❌ Ontbreekt volledig |
 | Obsidian config (`OBSIDIAN_BASE`, `OBSIDIAN_TOKEN`) | ✅ Aanwezig | ❌ Ontbreekt |
 | `voorzieningen` import | ✅ Aparte module | ✅ Aparte module |
 | Auto + fiets isochroon | ✅ Beide | ✅ Beide |
 | Voorzieningen-sectie | ✅ Aanwezig | ✅ Aanwezig |
 ## Gevolg
 Rapporten werden wel in de chat getoond, maar **niet** naar Obsidian geschreven. De gebruiker merkte dit pas op bij expliciete vraag.
 ## Fix
 Kopieer de skill-template naar de geïnstalleerde locatie:
 ```bash
 cp ~/.hermes/skills/research/adres-analyse/scripts/rapport.py /root/adres-analyse/rapport.py
 ```
 **Let op**: als je in plaats daarvan `patch` gebruikt om het script te bewerken, kan de security scan API tokens (zoals `OBSIDIAN_TOKEN`) maskeren. Dit geeft 401 Unauthorized. Zie `references/token-patching.md` voor workarounds.
 Of voer een diff uit om exacte verschillen te zien:
 ```bash
 diff ~/.hermes/skills/research/adres-analyse/scripts/rapport.py /root/adres-analyse/rapport.py
 ```
 ## Preventie
 Bij elke skill-update die `scripts/rapport.py` raakt, ook de geïnstalleerde versie bijwerken.
@@ -1,50 +0,0 @@
 # Token Patching in Python Scripts
 ## Context
 Scripts zoals `rapport.py` bevatten gevoelige waarden (API tokens, passwords). Bij het gebruik van de `patch` tool kan de security scan deze waarden maskeren of fragmenteren.
 ## Probleem (2026-06-22)
 Bij het patchen van `OBSIDIAN_TOKEN` in `/root/adres-analyse/rapport.py` werd het lange token door de security scan opgesplitst in een ongeldige string concatenatie:
 ```python
 # FOUT — resultaat na patch met gemaskerd token:
 OBSIDIAN_TOKEN = "90ec..."  # incompleet, script faalt met 401
 # FOUT — geprobeerde fix met concatenatie die ook faalt:
 OBSIDIAN_TOKEN="90ec" + "6de948..."  # security scan splitst opnieuw
 ```
 Dit leidde tot herhaalde `HTTP Error 401: Unauthorized` omdat het verzonden token niet overeenkwam met het token in de Obsidian plugin.
 ## Workarounds
 ### Optie 1: write_file voor het volledige script
 Gebruik `read_file` om het huidige script te bekijken, pas aan in je context, en schrijf terug met `write_file`. Dit vermijdt de security scan op patch-niveau.
 ### Optie 2: Token ophalen uit bestaande bron
 Bouw een klein hulp-script dat het token uit een bekend bestand leest (bijv. het skill-script zelf):
 ```python
 import re
 def lees_token_uit_skill():
    with open("~/.hermes/skills/research/adres-analyse/scripts/rapport.py") as f:
        for i, line in enumerate(f, 1):
            if i == 19 and "OBSIDIAN_TOKEN" in line:
                return line.split("=")[1].strip().strip('"').strip("'")
    return None
 ```
 ### Optie 3: Synchroniseer het hele skill-script
 In plaats van patchen, kopieer de skill-template naar de geïnstalleerde locatie:
 ```bash
 cp ~/.hermes/skills/research/adres-analyse/scripts/rapport.py /root/adres-analyse/rapport.py
 ```
 Dit is de meest betrouwbare aanpak als er meerdere verschillen zijn.
 ## Preventie
 - Vermijd het patchen van regels die gevoelige tokens bevatten
 - Als patch onvermijdelijk is, verifieer altijd met `python3 -m py_compile script.py` en een test-API-call
 - Overweeg om tokens uit een apart `.env` bestand te laden in plaats van hardcoded in het script
@@ -1,137 +0,0 @@
 #!/usr/bin/env python3
 """
 Genereer interactieve kaart voor adres analyse.
 Toont in één figuur:
 - blauw: 20 minuten autorijden (driving-car)
 - groen: 30 minuten fietsen (cycling-regular)
 """
 import json
 import sys
 import urllib.parse
 import urllib.request
 import folium
 ORS_BASE = "http://192.168.1.71:9080/ors/v2"
 PDOK_BASE = "https://api.pdok.nl/bzk/locatieserver/search/v3_1"
 def geocode_adres(adres):
    params = urllib.parse.urlencode({
        "q": adres,
        "rows": 5,
        "fl": "centroide_ll,weergavenaam,postcode,woonplaatsnaam,type,huisnummer",
    })
    url = f"{PDOK_BASE}/free?{params}"
    with urllib.request.urlopen(url, timeout=10) as resp:
        data = json.loads(resp.read())
    docs = data.get("response", {}).get("docs", [])
    if not docs:
        raise ValueError(f"Adres niet gevonden: {adres}")
    doc = next((d for d in docs if d.get("type") == "adres"), docs[0])
    point = doc["centroide_ll"].replace("POINT(", "").replace(")", "").split()
    lon, lat = float(point[0]), float(point[1])
    return {
        "adres": doc.get("weergavenaam", adres),
        "postcode": doc.get("postcode", ""),
        "woonplaats": doc.get("woonplaatsnaam", ""),
        "lat": lat,
        "lon": lon,
    }
 def haal_isochroon(lon, lat, profiel, minuten):
    payload = json.dumps({
        "locations": [[lon, lat]],
        "range": [minuten * 60],
        "attributes": ["area", "reachfactor", "total_pop"],
    }).encode()
    req = urllib.request.Request(
        f"{ORS_BASE}/isochrones/{profiel}",
        data=payload,
        headers={"Content-Type": "application/json"},
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=60) as resp:
        return json.loads(resp.read())
 def polygon_bounds(feature_collection):
    bbox = feature_collection.get("bbox", [])
    if len(bbox) == 4:
        return [[bbox[1], bbox[0]], [bbox[3], bbox[2]]]
    bounds = []
    for feature in feature_collection.get("features", []):
        coords = feature.get("geometry", {}).get("coordinates", [[]])[0]
        bounds.extend([[lat, lon] for lon, lat in coords])
    return bounds
 def voeg_isochroon_toe(m, iso, label, kleur, tooltip):
    for feature in iso.get("features", []):
        coords = feature["geometry"]["coordinates"][0]
        props = feature.get("properties", {})
        area_km2 = props.get("area", 0) / 1_000_000
        reach = props.get("reachfactor", 0)
        folium.Polygon(
            locations=[[lat, lon] for lon, lat in coords],
            color=kleur,
            weight=3,
            fill=True,
            fill_color=kleur,
            fill_opacity=0.18,
            popup=(
                f"<b>{label}</b><br>"
                f"Oppervlakte: {area_km2:.1f} km²<br>"
                f"Reach factor: {reach:.3f}"
            ),
            tooltip=tooltip,
        ).add_to(m)
 def genereer_kaart(adres, output_file="/root/adres-analyse/kaart.html"):
    locatie = geocode_adres(adres)
    lat, lon = locatie["lat"], locatie["lon"]
    auto_iso = haal_isochroon(lon, lat, "driving-car", 20)
    fiets_iso = haal_isochroon(lon, lat, "cycling-regular", 30)
    m = folium.Map(location=[lat, lon], zoom_start=11, tiles="OpenStreetMap")
    folium.Marker(
        [lat, lon],
        popup=locatie["adres"],
        tooltip=locatie["adres"],
        icon=folium.Icon(color="red", icon="home"),
    ).add_to(m)
    voeg_isochroon_toe(m, auto_iso, "Auto 20 min", "#2196F3", "Bereikbaar in 20 min (auto)")
    voeg_isochroon_toe(m, fiets_iso, "Fiets 30 min", "#2E7D32", "Bereikbaar in 30 min (fiets)")
    all_bounds = polygon_bounds(auto_iso) + polygon_bounds(fiets_iso)
    if all_bounds:
        m.fit_bounds(all_bounds)
    title_html = f'''
    <div style="position:fixed;top:10px;left:60px;z-index:1000;background:white;padding:10px 15px;border-radius:8px;box-shadow:0 2px 6px rgba(0,0,0,0.3);font-family:sans-serif;font-size:14px;line-height:1.35;">
      <b>📍 Adres Analyse</b><br>
      {locatie["adres"]}<br>
      <span style="color:#2196F3">■</span> 20 min autorijden<br>
      <span style="color:#2E7D32">■</span> 30 min fietsen
    </div>
    '''
    m.get_root().html.add_child(folium.Element(title_html))
    m.save(output_file)
    print(f"Kaart gegenereerd: {output_file}")
    print(f"Adres: {locatie['adres']}")
    print(f"Coördinaten: {lat}, {lon}")
 if __name__ == "__main__":
    adres = sys.argv[1] if len(sys.argv) > 1 else "Griendvelden 14 Best"
    output = sys.argv[2] if len(sys.argv) > 2 else "/root/adres-analyse/kaart.html"
    genereer_kaart(adres, output)
@@ -1,136 +0,0 @@
 #!/usr/bin/env python3
 """Importeer alleen benodigde POI's uit een OSM PBF naar PostGIS.
 Veel lichter dan volledige osm2pgsql-import voor heel Nederland.
 """
 import argparse
 import os
 import osmium
 import psycopg2
 from psycopg2.extras import execute_values
 DB_DSN = os.environ.get(
    "ADRES_ANALYSE_DB_DSN",
    "host=127.0.0.1 port=5433 dbname=adresanalyse user=adres password=adres",
 )
 SCHEMA_SQL = """
 CREATE EXTENSION IF NOT EXISTS postgis;
 DROP TABLE IF EXISTS osm_pois;
 CREATE TABLE osm_pois (
  id bigserial PRIMARY KEY,
  osm_type text NOT NULL,
  osm_id bigint NOT NULL,
  category text NOT NULL,
  name text NOT NULL,
  brand text,
  operator text,
  lon double precision NOT NULL,
  lat double precision NOT NULL,
  geom geometry(Point, 4326) NOT NULL
 );
 CREATE INDEX osm_pois_category_geom_gix ON osm_pois USING GIST (geom);
 CREATE INDEX osm_pois_category_idx ON osm_pois (category);
 CREATE INDEX osm_pois_name_idx ON osm_pois (lower(name));
 CREATE OR REPLACE VIEW poi_supermarkten AS
 SELECT osm_id, name, 'supermarkt'::text AS category, 'supermarket'::text AS shop, NULL::text AS amenity, brand, operator, geom
 FROM osm_pois WHERE category = 'supermarkt';
 CREATE OR REPLACE VIEW poi_scholen AS
 SELECT osm_id, name, 'school'::text AS category, NULL::text AS shop, 'school'::text AS amenity, brand, operator, geom
 FROM osm_pois WHERE category = 'school';
 """
 def poi_from_tags(tags):
    if tags.get("shop") == "supermarket":
        return "supermarkt", tags.get("name") or tags.get("brand") or "Supermarkt"
    if tags.get("amenity") == "school":
        return "school", tags.get("name") or "School"
    return None, None
 class PoiHandler(osmium.SimpleHandler):
    def __init__(self, conn, batch_size=1000):
        super().__init__()
        self.conn = conn
        self.batch_size = batch_size
        self.rows = []
        self.count = 0
        self.factory = osmium.geom.WKBFactory()
    def flush(self):
        if not self.rows:
            return
        with self.conn.cursor() as cur:
            execute_values(
                cur,
                """
                INSERT INTO osm_pois (osm_type, osm_id, category, name, brand, operator, lon, lat, geom)
                VALUES %s
                """,
                self.rows,
            )
        self.conn.commit()
        self.rows.clear()
    def add_row(self, osm_type, osm_id, tags, lon, lat):
        category, name = poi_from_tags(tags)
        if not category:
            return
        self.rows.append((
            osm_type,
            int(osm_id),
            category,
            name,
            tags.get("brand"),
            tags.get("operator"),
            float(lon),
            float(lat),
            f"SRID=4326;POINT({float(lon)} {float(lat)})",
        ))
        self.count += 1
        if len(self.rows) >= self.batch_size:
            self.flush()
    def node(self, n):
        if not n.location.valid():
            return
        self.add_row("node", n.id, n.tags, n.location.lon, n.location.lat)
    def area(self, a):
        category, _ = poi_from_tags(a.tags)
        if not category:
            return
        try:
            wkb = self.factory.create_multipolygon(a)
            with self.conn.cursor() as cur:
                cur.execute("SELECT ST_X(p), ST_Y(p) FROM (SELECT ST_PointOnSurface(ST_GeomFromWKB(%s, 4326)) p) s", (psycopg2.Binary(wkb),))
                lon, lat = cur.fetchone()
            self.add_row("area", a.orig_id(), a.tags, lon, lat)
        except Exception:
            return
 def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("pbf")
    args = parser.parse_args()
    with psycopg2.connect(DB_DSN) as conn:
        with conn.cursor() as cur:
            cur.execute(SCHEMA_SQL)
        conn.commit()
        handler = PoiHandler(conn)
        handler.apply_file(args.pbf, locations=True)
        handler.flush()
        with conn.cursor() as cur:
            cur.execute("ANALYZE osm_pois")
        conn.commit()
        print(f"Imported {handler.count} POIs into osm_pois")
 if __name__ == "__main__":
    main()
@@ -1,187 +0,0 @@
 #!/usr/bin/env python3
 """
 Adres Analyse - Rapport generator
 Gebruikt PDOK voor geocoding, ORS voor isochronen/routes en PostGIS OSM-data voor voorzieningen.
 Slaat rapport ook op in Obsidian vault (map: huizenjacht).
 """
 import json
 import sys
 import urllib.request
 import urllib.parse
 import re
 from datetime import datetime
 from voorzieningen import analyse_voorzieningen, format_voorzieningen_markdown
 # Config
 ORS_BASE = "http://192.168.1.71:9080/ors/v2"
 PDOK_BASE = "https://api.pdok.nl/bzk/locatieserver/search/v3_1"
 OBSIDIAN_BASE = "http://192.168.1.50:27123"
 OBSIDIAN_TOKEN = "90ec" + "6de948dc8ef7832fda3516fd900c7a3071dd526edf852ade145aa9daf637"
 def geocode_adres(adres):
    """Geocode adres naar coördinaten via PDOK Locatieserver"""
    params = urllib.parse.urlencode({
        'q': adres,
        'rows': 5,
        'fl': 'centroide_ll,weergavenaam,postcode,woonplaatsnaam,type,huisnummer'
    })
    url = f"{PDOK_BASE}/free?{params}"
    with urllib.request.urlopen(url, timeout=10) as resp:
        data = json.loads(resp.read())
    if not data['response']['docs']:
        raise ValueError(f"Adres niet gevonden: {adres}")
    doc = None
    for d in data['response']['docs']:
        if d.get('type') == 'adres':
            doc = d
            break
    if not doc:
        doc = data['response']['docs'][0]
    point = doc['centroide_ll']
    coords = point.replace('POINT(', '').replace(')', '').split()
    lon, lat = float(coords[0]), float(coords[1])
    return {
        'adres': doc.get('weergavenaam', adres),
        'postcode': doc.get('postcode', ''),
        'woonplaats': doc.get('woonplaatsnaam', ''),
        'lat': lat,
        'lon': lon
    }
 def haal_isochroon(lon, lat, profiel='driving-car', minuten=20):
    """Haal isochroon op van ORS"""
    url = f"{ORS_BASE}/isochrones/{profiel}"
    payload = {
        "locations": [[lon, lat]],
        "range": [minuten * 60],
        "attributes": ["area", "reachfactor", "total_pop"]
    }
    req = urllib.request.Request(
        url,
        data=json.dumps(payload).encode(),
        headers={'Content-Type': 'application/json'},
        method='POST'
    )
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.loads(resp.read())
 def format_oppervlakte(m2):
    """Converteer m² naar leesbaar formaat"""
    if m2 >= 1_000_000:
        return f"{m2/1_000_000:.1f} km²"
    elif m2 >= 10_000:
        return f"{m2/10_000:.1f} ha"
    else:
        return f"{m2:.0f} m²"
 def schrijf_naar_obsidian(rapport_text, adres):
    """Schrijf rapport naar Obsidian vault in map huizenjacht"""
    safe_name = re.sub(r'[^a-zA-Z0-9]+', '-', adres)
    safe_name = safe_name.strip('-')
    filename = f"huizenjacht/{safe_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
    req = urllib.request.Request(
        f"{OBSIDIAN_BASE}/vault/{filename}",
        data=rapport_text.encode('utf-8'),
        headers={
            'Authorization': f'Bearer {OBSIDIAN_TOKEN}',
            'Content-Type': 'text/markdown'
        },
        method='POST'
    )
    with urllib.request.urlopen(req, timeout=10) as resp:
        if resp.status in [200, 204]:
            return f"📝 **Opgeslagen in Obsidian:** `huizenjacht/{safe_name}_*.md`"
        else:
            return f"⚠️ Obsidian upload mislukt: {resp.status}"
 def print_isochroon_sectie(titel, icoon, iso_data, rapport_lines=None):
    """Print isochroon sectie; optioneel ook toevoegen aan rapport_lines voor Obsidian"""
    text = f"{icoon} **{titel}**"
    print(text)
    if rapport_lines is not None:
        rapport_lines.append(text)
    if 'features' in iso_data and iso_data['features']:
        props = iso_data['features'][0]['properties']
        area_m2 = props.get('area', 0)
        reach = props.get('reachfactor', 0)
        text = f"**Oppervlakte:** {format_oppervlakte(area_m2)}"
        print(text)
        if rapport_lines is not None:
            rapport_lines.append(text)
        text = f"**Reach factor:** {reach:.3f}"
        print(text)
        if rapport_lines is not None:
            rapport_lines.append(text)
        bbox = iso_data.get('bbox', [])
        if len(bbox) == 4:
            text = f"**Bereik:** {bbox[1]:.3f}°-{bbox[3]:.3f}°N, {bbox[0]:.3f}°-{bbox[2]:.3f}°E"
            print(text)
            if rapport_lines is not None:
                rapport_lines.append(text)
    else:
        text = "❌ Geen isochroon data ontvangen"
        print(text)
        if rapport_lines is not None:
            rapport_lines.append(text)
    print()
    if rapport_lines is not None:
        rapport_lines.append("")
 def genereer_rapport(adres_input):
    """Genereer volledig adres analyse rapport"""
    rapport_lines = []
    def print_line(text=""):
        print(text)
        rapport_lines.append(text)
    print_line(f"📍 **Adres Analyse Rapport**")
    print_line(f"Gegenereerd: {datetime.now().strftime('%d-%m-%Y %H:%M')}")
    print_line()
    print_line("🔍 Geocoding...")
    locatie = geocode_adres(adres_input)
    print_line(f"**Adres:** {locatie['adres']}")
    print_line(f"**Coördinaten:** {locatie['lat']:.6f}, {locatie['lon']:.6f}")
    print_line()
    auto_iso = haal_isochroon(locatie['lon'], locatie['lat'], 'driving-car', 20)
    fiets_iso = haal_isochroon(locatie['lon'], locatie['lat'], 'cycling-regular', 30)
    print_isochroon_sectie("Bereikbaarheid (Auto 20 min)", "🚗", auto_iso, rapport_lines)
    print_isochroon_sectie("Bereikbaarheid (Fiets 30 min)", "🚲", fiets_iso, rapport_lines)
    print_line("🏙️ **Voorzieningen dichtbij**")
    voorzieningen = analyse_voorzieningen(locatie['lon'], locatie['lat'], limit=5)
    print_line(format_voorzieningen_markdown("🛒 **Supermarkten**", voorzieningen['supermarkten']))
    print_line()
    print_line(format_voorzieningen_markdown("🏫 **Scholen**", voorzieningen['scholen']))
    print_line()
    output_file = f"/tmp/isochronen_{datetime.now().strftime('%Y%m%d_%H%M%S')}.geojson"
    with open(output_file, 'w') as f:
        json.dump({'auto_20_min': auto_iso, 'fiets_30_min': fiets_iso}, f)
    print_line(f"💾 Isochroondata opgeslagen: `{output_file}`")
    print_line()
    print_line("---")
    print_line("_Onderdelen: geocoding, isochronen, voorzieningen_")
    # Schrijf naar Obsidian
    print_line()
    obsidian_result = schrijf_naar_obsidian('\n'.join(rapport_lines), locatie['adres'])
    print_line(obsidian_result)
 if __name__ == '__main__':
    adres = sys.argv[1] if len(sys.argv) > 1 else "Griendvelden 14 Best"
    genereer_rapport(adres)
@@ -1,144 +0,0 @@
 #!/usr/bin/env python3
 """Voorzieningenanalyse op basis van lokale PostGIS OSM-data + ORS Matrix."""
 import json
 import os
 import urllib.request
 from dataclasses import dataclass, asdict
 import psycopg2
 import psycopg2.extras
 DB_DSN = os.environ.get(
    "ADRES_ANALYSE_DB_DSN",
    "host=127.0.0.1 port=5433 dbname=adresanalyse user=adres password=adres",
 )
 ORS_BASE = os.environ.get("ORS_BASE", "http://192.168.1.71:9080/ors/v2")
@dataclass
 class Voorziening:
    categorie: str
    naam: str
    lat: float
    lon: float
    hemelsbreed_m: float
    fiets_afstand_m: float | None = None
    fiets_duur_s: float | None = None
    auto_afstand_m: float | None = None
    auto_duur_s: float | None = None
    bron: str = "OSM/PostGIS"
    def to_dict(self):
        return asdict(self)
 def _matrix(lon, lat, pois, profiel):
    if not pois:
        return []
    locations = [[lon, lat]] + [[p.lon, p.lat] for p in pois]
    payload = json.dumps({
        "locations": locations,
        "sources": [0],
        "destinations": list(range(1, len(locations))),
        "metrics": ["distance", "duration"],
    }).encode()
    req = urllib.request.Request(
        f"{ORS_BASE}/matrix/{profiel}",
        data=payload,
        headers={"Content-Type": "application/json"},
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=60) as resp:
        data = json.loads(resp.read())
    distances = data.get("distances", [[]])[0]
    durations = data.get("durations", [[]])[0]
    return list(zip(distances, durations))
 def verrijk_met_routes(lon, lat, pois):
    fiets = _matrix(lon, lat, pois, "cycling-regular")
    auto = _matrix(lon, lat, pois, "driving-car")
    for i, poi in enumerate(pois):
        if i < len(fiets):
            poi.fiets_afstand_m, poi.fiets_duur_s = fiets[i]
        if i < len(auto):
            poi.auto_afstand_m, poi.auto_duur_s = auto[i]
    return pois
 def zoek_voorzieningen(lon, lat, categorie, limit=5, radius_m=10000):
    if categorie == "supermarkt":
        view = "poi_supermarkten"
    elif categorie == "school":
        view = "poi_scholen"
    else:
        raise ValueError(f"Onbekende categorie: {categorie}")
    sql = f"""
    WITH origin AS (
      SELECT ST_SetSRID(ST_MakePoint(%s, %s), 4326)::geography AS geog
    )
    SELECT DISTINCT ON (lower(name))
      name,
      ST_Y(geom) AS lat,
      ST_X(geom) AS lon,
      ST_Distance(geom::geography, origin.geog) AS hemelsbreed_m
    FROM {view}, origin
    WHERE geom IS NOT NULL
      AND ST_DWithin(geom::geography, origin.geog, %s)
    ORDER BY lower(name), hemelsbreed_m ASC
    """
    wrapped = f"SELECT * FROM ({sql}) q ORDER BY hemelsbreed_m ASC LIMIT %s"
    with psycopg2.connect(DB_DSN) as conn:
        with conn.cursor(cursor_factory=psycopg2.extras.DictCursor) as cur:
            cur.execute(wrapped, (lon, lat, radius_m, limit))
            rows = cur.fetchall()
    return [
        Voorziening(
            categorie=categorie,
            naam=row["name"],
            lat=float(row["lat"]),
            lon=float(row["lon"]),
            hemelsbreed_m=float(row["hemelsbreed_m"]),
        )
        for row in rows
    ]
 def analyse_voorzieningen(lon, lat, limit=5):
    supermarkten = zoek_voorzieningen(lon, lat, "supermarkt", limit=limit, radius_m=10000)
    scholen = zoek_voorzieningen(lon, lat, "school", limit=limit, radius_m=15000)
    verrijk_met_routes(lon, lat, supermarkten)
    verrijk_met_routes(lon, lat, scholen)
    return {"supermarkten": supermarkten, "scholen": scholen}
 def format_afstand(m):
    if m is None:
        return "n.b."
    if m < 1000:
        return f"{m:.0f} m"
    return f"{m/1000:.1f} km".replace(".", ",")
 def format_duur(s):
    if s is None:
        return "n.b."
    minutes = max(1, round(s / 60))
    return f"{minutes} min"
 def format_voorzieningen_markdown(titel, pois):
    lines = [titel]
    if not pois:
        lines.append("Geen voorzieningen gevonden in zoekradius.")
        return "\n".join(lines)
    for i, p in enumerate(pois, 1):
        lines.extend([
            f"{i}. **{p.naam}**",
            f"   Hemelsbreed: {format_afstand(p.hemelsbreed_m)}",
            f"   Fiets: {format_afstand(p.fiets_afstand_m)} / {format_duur(p.fiets_duur_s)}",
            f"   Auto: {format_afstand(p.auto_afstand_m)} / {format_duur(p.auto_duur_s)}",
        ])
    return "\n".join(lines)