Vastgoed en geocoding: de complete gids voor locatie-intelligentie in PropTech

// Property matching met locatie-intelligentie
async function matchProperties(searchCriteria, properties) {
  const matches = [];

  for (const property of properties) {
    // Geocode het property adres
    const response = await fetch(
      `https://api.georex.nl/geocode?q=${encodeURIComponent(property.address)}&token=${TOKEN}`
    );
    const geo = await response.json();

    if (geo.features.length === 0) continue;

    const [lng, lat] = geo.features[0].geometry.coordinates;

    // Bereken scores voor locatiecriteria
    const scores = {
      schoolDistance: await scoreSchoolDistance(lat, lng, searchCriteria.maxSchoolDistance),
      transitScore: await scoreTransitAccess(lat, lng, searchCriteria.transitPreference),
      greenScore: await scoreGreenSpace(lat, lng, searchCriteria.greenPreference),
      noiseScore: await scoreNoiseLevel(lat, lng, searchCriteria.maxNoiseLevel)
    };

    // Bereken totaalscore (gewogen gemiddelde)
    const totalScore = calculateWeightedScore(scores, searchCriteria.weights);

    if (totalScore >= searchCriteria.minimumScore) {
      matches.push({
        property,
        coordinates: { lat, lng },
        scores,
        totalScore
      });
    }
  }

  return matches.sort((a, b) => b.totalScore - a.totalScore);
}

// Haversine formule voor afstandsberekening
function calculateDistance(lat1, lng1, lat2, lng2) {
  const R = 6371; // Aarde radius in km
  const dLat = toRad(lat2 - lat1);
  const dLng = toRad(lng2 - lng1);

  const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
            Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) *
            Math.sin(dLng/2) * Math.sin(dLng/2);

  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
  return R * c;
}

function toRad(deg) {
  return deg * (Math.PI / 180);
}

import requests
import pandas as pd

def enrich_with_neighborhood_data(address: str, token: str) -> dict:
    """
    Verrijk een adres met CBS buurtstatistieken.
    """
    # Stap 1: Geocode het adres
    geo_response = requests.get(
        f"https://api.georex.nl/geocode",
        params={"q": address, "token": token}
    )
    geo_data = geo_response.json()

    if not geo_data.get("features"):
        return None

    # Haal buurtcode uit response
    properties = geo_data["features"][0]["properties"]
    buurt_code = properties.get("neighborhood_code")  # BU + gemeentecode + buurtnr

    # Stap 2: Haal CBS data op voor deze buurt
    cbs_data = get_cbs_neighborhood_stats(buurt_code)

    return {
        "address": address,
        "coordinates": geo_data["features"][0]["geometry"]["coordinates"],
        "postcode": properties.get("postcode"),
        "city": properties.get("city"),
        "neighborhood": {
            "code": buurt_code,
            "name": properties.get("neighborhood"),
            "statistics": cbs_data
        }
    }

def get_cbs_neighborhood_stats(buurt_code: str) -> dict:
    """
    Haal CBS statistieken op voor een specifieke buurt.
    """
    # CBS Open Data API
    url = "https://opendata.cbs.nl/ODataApi/odata/85039NED/TypedDataSet"
    params = {
        "$filter": f"WijkenEnBuurten eq '{buurt_code}'"
    }

    response = requests.get(url, params=params)
    data = response.json()

    if data.get("value"):
        record = data["value"][0]
        return {
            "woz_waarde": record.get("GemiddeldeWOZWaardeVanWoningen_35"),
            "stedelijkheid": record.get("Stedelijkheid_118"),
            "perc_koopwoningen": record.get("PercentageKoopwoningen_122"),
            "gem_inkomen": record.get("GemiddeldInkomenPerInwoner_66"),
            "afstand_supermarkt": record.get("AfstandTotGroteSupermarkt_136")
        }
    return {}

# Voorbeeld gebruik
enriched = enrich_with_neighborhood_data(
    "Herengracht 123, Amsterdam",
    "YOUR_TOKEN"
)
print(enriched)

import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler

def build_hedonic_model(properties_df: pd.DataFrame) -> dict:
    """
    Bouw een hedonisch prijsmodel met locatiefactoren.

    Input DataFrame moet bevatten:
    - price: verkoopprijs
    - size_m2: woonoppervlakte
    - rooms: aantal kamers
    - lat, lng: coördinaten (via geocoding)
    - dist_station: afstand tot OV station
    - dist_centrum: afstand tot stadscentrum
    - green_pct: percentage groen in 300m radius
    - noise_db: geluidsniveau
    - woz_buurt: gemiddelde WOZ waarde buurt
    """

    # Features selecteren
    location_features = [
        'dist_station', 'dist_centrum', 'green_pct',
        'noise_db', 'woz_buurt'
    ]
    property_features = ['size_m2', 'rooms']
    all_features = property_features + location_features

    X = properties_df[all_features]
    y = properties_df['price']

    # Schalen voor betere interpretatie
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)

    # Model trainen
    model = LinearRegression()
    model.fit(X_scaled, y)

    # Resultaten analyseren
    feature_importance = dict(zip(all_features, model.coef_))

    return {
        'model': model,
        'scaler': scaler,
        'r2_score': model.score(X_scaled, y),
        'feature_importance': feature_importance,
        'intercept': model.intercept_
    }

# Interpretatie van coefficiënten
def interpret_model(model_results: dict):
    """
    Interpreteer de impact van locatiefactoren op de prijs.
    """
    print("\n=== Hedonisch Prijsmodel Resultaten ===")
    print(f"R² Score: {model_results['r2_score']:.3f}")
    print(f"\nBasisprijs (intercept): €{model_results['intercept']:,.0f}")
    print("\nImpact per factor (gestandaardiseerd):")

    for feature, coef in sorted(
        model_results['feature_importance'].items(),
        key=lambda x: abs(x[1]),
        reverse=True
    ):
        impact = "+" if coef > 0 else ""
        print(f"  {feature}: {impact}€{coef:,.0f}")

// Analyseer prijsontwikkeling per wijk
async function analyzeMarketTrends(transactions, neighborhoods) {
  const trendsByNeighborhood = {};

  for (const transaction of transactions) {
    // Geocode en bepaal wijk
    const geo = await geocode(transaction.address);
    const neighborhood = geo.properties.neighborhood;

    if (!trendsByNeighborhood[neighborhood]) {
      trendsByNeighborhood[neighborhood] = {
        transactions: [],
        avgPricePerM2: [],
        timeline: []
      };
    }

    trendsByNeighborhood[neighborhood].transactions.push({
      date: transaction.date,
      price: transaction.price,
      pricePerM2: transaction.price / transaction.size,
      coordinates: geo.geometry.coordinates
    });
  }

  // Bereken trends per wijk
  for (const [name, data] of Object.entries(trendsByNeighborhood)) {
    // Sorteer op datum
    data.transactions.sort((a, b) => new Date(a.date) - new Date(b.date));

    // Bereken voortschrijdend gemiddelde prijs/m²
    data.avgPricePerM2 = calculateMovingAverage(
      data.transactions.map(t => ({ date: t.date, value: t.pricePerM2 })),
      3 // 3-maands gemiddelde
    );

    // Bereken jaarlijkse groei
    data.yearlyGrowth = calculateYearlyGrowth(data.avgPricePerM2);
  }

  return trendsByNeighborhood;
}

// Identificeer opkomende wijken
function findEmergingNeighborhoods(trends, minGrowth = 0.05) {
  return Object.entries(trends)
    .filter(([_, data]) => data.yearlyGrowth > minGrowth)
    .sort((a, b) => b[1].yearlyGrowth - a[1].yearlyGrowth)
    .map(([name, data]) => ({
      neighborhood: name,
      growth: data.yearlyGrowth,
      avgPrice: data.avgPricePerM2[data.avgPricePerM2.length - 1].value,
      transactionCount: data.transactions.length
    }));
}

# Geocode een vastgoed adres met GeoRex
curl "https://api.georex.nl/geocode?q=Herengracht+500+Amsterdam&token=YOUR_TOKEN"

# Response bevat:
# - Exacte coördinaten
# - BAG gegevens (bouwjaar, oppervlakte, gebruiksdoel)
# - Postcode, wijk en buurtcode
# - Gemeente en provincie