Huisnummer toevoegingen: de complete gids voor Nederlandse adresparserering

// Functie om Romeinse cijfers te converteren naar Arabische getallen
function romanToArabic(roman) {
  const romanNumerals = {
    'I': 1, 'V': 5, 'X': 10, 'L': 50,
    'C': 100, 'D': 500, 'M': 1000
  };

  let result = 0;
  for (let i = 0; i < roman.length; i++) {
    const current = romanNumerals[roman[i]];
    const next = romanNumerals[roman[i + 1]];

    if (next && current < next) {
      result -= current;
    } else {
      result += current;
    }
  }
  return result;
}

// Voorbeeld
console.log(romanToArabic('III')); // 3
console.log(romanToArabic('IV'));  // 4

// BAG adres structuur
interface BAGAddress {
  straatnaam: string;
  huisnummer: number;
  huisletter?: string;           // Max 1 karakter: A-Z
  huisnummertoevoeging?: string; // Max 4 karakters: bis, I, 101, hs
  postcode: string;
  woonplaatsnaam: string;
}

// Voorbeelden van BAG adressen
const examples: BAGAddress[] = [
  {
    straatnaam: "Damrak",
    huisnummer: 1,
    huisletter: undefined,
    huisnummertoevoeging: undefined,
    postcode: "1012LG",
    woonplaatsnaam: "Amsterdam"
  },
  {
    straatnaam: "Herengracht",
    huisnummer: 123,
    huisletter: "A",
    huisnummertoevoeging: undefined,
    postcode: "1015BK",
    woonplaatsnaam: "Amsterdam"
  },
  {
    straatnaam: "Keizersgracht",
    huisnummer: 456,
    huisletter: undefined,
    huisnummertoevoeging: "III",
    postcode: "1016EJ",
    woonplaatsnaam: "Amsterdam"
  },
  {
    straatnaam: "Prinsengracht",
    huisnummer: 789,
    huisletter: "B",
    huisnummertoevoeging: "hs",
    postcode: "1017KL",
    woonplaatsnaam: "Amsterdam"
  }
];

/**
 * Nederlandse adres parser
 * Ondersteunt alle gangbare huisnummer toevoegingen
 */

const ADDRESS_REGEX = /^(.+?)\s+(\d+)\s*([A-Za-z])?\s*[-\/]?\s*(.+)?$/;

function parseAddress(address) {
  // Normaliseer de input
  const normalized = address
    .trim()
    .replace(/\s+/g, ' ')
    .replace(/,/g, '');

  const match = normalized.match(ADDRESS_REGEX);

  if (!match) {
    return null;
  }

  const [, street, number, letter, addition] = match;

  return {
    street: street.trim(),
    number: parseInt(number, 10),
    letter: letter ? letter.toUpperCase() : null,
    addition: normalizeAddition(addition)
  };
}

function normalizeAddition(addition) {
  if (!addition) return null;

  const normalized = addition.trim().toLowerCase();

  // Normaliseer bekende afkortingen
  const abbreviations = {
    'huis': 'hs',
    'souterrain': 'sous',
    'beletage': 'bel',
    'bel-etage': 'bel',
    'bovenhuis': 'bov',
    'parterre': 'part',
    '1e': 'I',
    '2e': 'II',
    '3e': 'III',
    '4e': 'IV',
    '1ste': 'I',
    '2de': 'II',
    '3de': 'III'
  };

  return abbreviations[normalized] || addition.toUpperCase();
}

// Test voorbeelden
const testAddresses = [
  "Herengracht 123A",
  "Keizersgracht 456 III",
  "Prinsengracht 789-bis",
  "Damrak 1 B hs",
  "Rokin 50-2",
  "Singel 100 huis"
];

testAddresses.forEach(addr => {
  console.log(`Input: ${addr}`);
  console.log('Parsed:', parseAddress(addr));
  console.log('---');
});

import re
from dataclasses import dataclass
from typing import Optional

@dataclass
class ParsedAddress:
    street: str
    number: int
    letter: Optional[str] = None
    addition: Optional[str] = None

def parse_address(address: str) -> Optional[ParsedAddress]:
    """
    Parse een Nederlands adres en extraheer componenten.

    Ondersteunt:
    - Letters: 12A, 12 A, 12-A
    - Romeinse cijfers: 12-III, 12 III
    - Toevoegingen: 12bis, 12-hs, 12 huis
    """
    # Regex voor Nederlandse adressen
    pattern = r'^(.+?)\s+(\d+)\s*([A-Za-z])?\s*[-/]?\s*(.+)?$'

    normalized = ' '.join(address.strip().split())
    match = re.match(pattern, normalized)

    if not match:
        return None

    street, number, letter, addition = match.groups()

    return ParsedAddress(
        street=street.strip(),
        number=int(number),
        letter=letter.upper() if letter else None,
        addition=normalize_addition(addition)
    )

def normalize_addition(addition: Optional[str]) -> Optional[str]:
    """Normaliseer huisnummer toevoegingen naar BAG-standaard."""
    if not addition:
        return None

    normalized = addition.strip().lower()

    abbreviations = {
        'huis': 'hs',
        'souterrain': 'sous',
        'bel-etage': 'bel',
        'beletage': 'bel',
        'bovenhuis': 'bov',
        'parterre': 'part',
    }

    return abbreviations.get(normalized, addition.upper())

# Test
if __name__ == "__main__":
    test_addresses = [
        "Herengracht 123A",
        "Keizersgracht 456-III",
        "Prinsengracht 789 bis",
        "Damrak 1B hs",
    ]

    for addr in test_addresses:
        result = parse_address(addr)
        print(f"{addr} -> {result}")

/**
 * Fuzzy matcher voor huisnummer toevoegingen
 */

function normalizeForMatching(address) {
  return {
    ...address,
    // Normaliseer letter naar hoofdletter
    letter: address.letter?.toUpperCase(),
    // Normaliseer toevoeging
    addition: normalizeAdditionForMatch(address.addition)
  };
}

function normalizeAdditionForMatch(addition) {
  if (!addition) return null;

  // Verwijder alle spaties en koppeltekens
  let normalized = addition
    .replace(/[\s-]/g, '')
    .toLowerCase();

  // Map varianten naar standaard
  const variants = {
    // Huis varianten
    'huis': 'hs', 'h': 'hs',
    // Souterrain varianten
    'souterrain': 'sous', 'sout': 'sous', 's': 'sous',
    // Romeinse cijfer varianten
    '1': 'i', '2': 'ii', '3': 'iii', '4': 'iv', '5': 'v',
    'eerste': 'i', 'tweede': 'ii', 'derde': 'iii',
    '1e': 'i', '2e': 'ii', '3e': 'iii',
    // Bis varianten
    'b': 'bis',
  };

  return variants[normalized] || normalized;
}

function addressesMatch(addr1, addr2) {
  const n1 = normalizeForMatching(addr1);
  const n2 = normalizeForMatching(addr2);

  return n1.street.toLowerCase() === n2.street.toLowerCase() &&
         n1.number === n2.number &&
         n1.letter === n2.letter &&
         n1.addition === n2.addition;
}

// Test
const input = { street: 'Herengracht', number: 123, letter: 'a', addition: 'huis' };
const bag =   { street: 'Herengracht', number: 123, letter: 'A', addition: 'hs' };

console.log('Match:', addressesMatch(input, bag)); // true

# Alle varianten geven hetzelfde resultaat:
curl "https://api.georex.nl/geocode?q=Herengracht+123A+hs+Amsterdam&token=YOUR_TOKEN"
curl "https://api.georex.nl/geocode?q=Herengracht+123+A+huis+Amsterdam&token=YOUR_TOKEN"
curl "https://api.georex.nl/geocode?q=Herengracht+123-a-hs+Amsterdam&token=YOUR_TOKEN"

# Response bevat genormaliseerde BAG-data:
# {
#   "features": [{
#     "properties": {
#       "street": "Herengracht",
#       "housenumber": "123",
#       "houseletter": "A",
#       "addition": "hs",
#       "postcode": "1015BK",
#       "city": "Amsterdam"
#     }
#   }]
# }