# Koordinatsystemer og geometri: WGS84 og EPSG:25832

De danske registre fører koordinater i ETRS89 / UTM zone 32N (EPSG:25832); kort og GPS taler WGS84. Grundfast leverer WGS84 i GeoJSON-rækkefølgen `[lon, lat]` med de oprindelige EPSG:25832-koordinater ved siden af, og input er WGS84, medmindre et endpoint siger andet.

## To koordinatsystemer

Et dansk koordinat kan være skrevet på to måder, og forveksler man dem, lander punktet et helt andet sted på kloden:

|  | WGS84 | ETRS89 / UTM zone 32N |
| --- | --- | --- |
| EPSG-kode | `4326` | `25832` |
| Enhed | Decimalgrader | Meter |
| Eksempel (Silkeborg) | `9.5329415, 56.157787` | `533102.67, 6223768.95` |
| Hvem bruger det | GPS, web-kort, GeoJSON, de fleste apps | BBR, Matriklen, DAGI, DHM og Miljøportalen |
| Godt til | At vise et punkt på et kort | At regne afstande og arealer i meter |

WGS84 er et geografisk system: længde- og breddegrad på kloden. UTM er en projektion: kloden foldet ud på et fladt net, så en afstand kan regnes med Pythagoras i meter. EPSG:25832 er UTM-zone 32 nord på datummet ETRS89, og de danske registre bruger den for hele landet — også det østligste Sjælland og Bornholm, som geografisk ligger i zone 33 (12°–18° øst). Derfor har et punkt på Bornholm en østkoordinat omkring 890.000 m, langt uden for zonens normale bredde. Det er ikke en fejl.

ETRS89 og WGS84 er ikke helt det samme datum, men til kortvisning og opslag på adresse- og matrikelniveau behandles de som ens. Det gør Grundfast også: reprojiceringen bruger den gængse definition med `towgs84=0`. Skal noget måles op med centimeternøjagtighed, er det landinspektørens opgave, ikke et API-opslags.

> **Kend systemet på tallene** To tal mellem 7 og 16 og mellem 54 og 58 er WGS84. En østkoordinat i hundredtusinder af meter og en nordkoordinat omkring 6 millioner er EPSG:25832.

## Output: WGS84 og EPSG:25832

De danske registre fører koordinater i ETRS89 / UTM zone 32N (EPSG:25832), i meter. Grundfast reprojicerer til WGS84 (EPSG:4326), så geometrien kan bruges direkte i Leaflet, MapLibre og GeoJSON-værktøjer, og beholder de oprindelige koordinater, så du kan regne i meter uden selv at reprojicere.

> **Længdegrad først** Arrays er `[lon, lat]` som i GeoJSON — ikke `[lat, lon]`. I Danmark er længdegraden 8–15 og breddegraden 54–58, så en ombytning er let at se.

| Form | WGS84 | EPSG:25832 |
| --- | --- | --- |
| Punkt (BBR-bygning) | `geometri.coordinates: [lon, lat]` | `geometri.epsg25832: [x, y]` |
| Polygon (jordstykke) | `coordinates` (GeoJSON-ringe) | `epsg25832_ring` |
| Multipolygon (DAGI-område) | `coordinates` | `epsg25832_rings` |
| Adressepunkt | `koordinat: { lon, lat }` | — |
| Bygningsomrids (GeoDanmark) | `buildings[].rings` | — |

Adresser har et navngivet objekt (`koordinat.lon`, `koordinat.lat`) i stedet for et array. `coordinates` kan være `null`, hvis reprojiceringen ikke var mulig; `epsg25832` er der altid.

## Input: et punkt

Endpoints, der tager et punkt, bruger `lon` og `lat` i WGS84-decimalgrader. Et punkt uden for Danmark (længdegrad 7–16, breddegrad 54–58) giver `400`.

```bash
curl "https://api.grundfast.dk/v1/jord/omraadeklassificering?lon=10.1763672&lat=56.1327761" \
  -H "Authorization: Bearer gf_live_..."
```

For at gøre det nemt at flytte fra DAWA accepterer de samme endpoints også `x`, `y` og `srid`. `srid=4326` (standard) betyder, at `x`/`y` er længde- og breddegrad; `srid=25832` betyder UTM-meter, som vi reprojicerer for dig:

```bash
curl "https://api.grundfast.dk/v1/dhm/kote?x=533103.83&y=6223775.44&srid=25832" \
  -H "Authorization: Bearer gf_live_..."
```

| Endpoints der tager `lon`/`lat` eller `x`/`y`/`srid` |
| --- |
| `/v1/jordstykker/reverse` · `/v1/adgangsadresser/reverse` |
| `/v1/dagi/reverse` |
| `/v1/dhm/punkt` · `/v1/dhm/kote` |
| `/v1/stednavne/punkt` |
| `/v1/jord/omraadeklassificering` |
| `/v1/natur/skovbyggelinje` · `/v1/natur/byggelinjer` |
| `/v1/plan` |
| `/v1/orto/daekning` |

De fleste punktregistre gentager punktet i WGS84 (`punkt`) og i EPSG:25832 (`epsg25832`), så du kan se, hvad der faktisk blev slået op.

## Regn i meter, vis i grader

En afstand regnet direkte på længde- og breddegrader er forkert, fordi en længdegrad i Danmark kun er godt halvt så lang som en breddegrad. Brug `epsg25832`-koordinaterne, der følger med i svaret, når du skal regne — så er afstanden mellem to punkter bare Pythagoras i meter — og WGS84-koordinaterne, når du skal tegne.

**TypeScript**

```ts
import { GrundfastClient } from '@grundfast/sdk';

const gf = new GrundfastClient({ apiKey: process.env.GRUNDFAST_API_KEY });
const ejendom = await gf.ejendom(5651067);

// To bygninger på samme ejendom: afstanden i meter, uden at reprojicere selv.
const [a, b] = ejendom.bygninger.flatMap((x) => (x.geometri ? [x.geometri.epsg25832] : []));
if (a && b) {
  const meter = Math.hypot(b[0] - a[0], b[1] - a[1]);
  console.log(meter.toFixed(1), 'm');
}
```

**Python**

```py
import math, os
import requests

H = {"Authorization": f"Bearer {os.environ['GRUNDFAST_API_KEY']}"}
ejendom = requests.get("https://api.grundfast.dk/v1/bbr/ejendom/5651067", headers=H).json()

punkter = [b["geometri"]["epsg25832"] for b in ejendom["bygninger"] if b["geometri"]]
if len(punkter) >= 2:
    (x1, y1), (x2, y2) = punkter[:2]
    print(round(math.hypot(x2 - x1, y2 - y1), 1), "m")
```

Har du selv koordinater i det ene system og skal bruge dem i det andet, så send dem til et punkt-endpoint med `srid` (se ovenfor) — svaret gentager punktet i begge systemer — eller reprojicér lokalt med samme definition, som API’et bruger:

```js
import proj4 from 'proj4';

proj4.defs('EPSG:25832', '+proj=utm +zone=32 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs');

const [lon, lat] = proj4('EPSG:25832', 'EPSG:4326', [533102.67, 6223768.95]);
const [x, y] = proj4('EPSG:4326', 'EPSG:25832', [9.5329415, 56.157787]);
```

## Højder: profiler og terrænnet

- `/v1/dhm/profil` tager `fra` og `til` som `"lon,lat"` i WGS84, fx `fra=10.2036,56.1577&til=10.2051,56.1582`. Profilen må højst være 2.000 m lang og have 500 punkter.
- `/v1/dhm/kote:batch` tager en liste af punkter med `lon` og `lat` i WGS84.
- `/v1/dhm/terraen` tager `bbox=minx,miny,maxx,maxy` i **EPSG:25832-meter**, ikke grader, højst 240 m på hver led. Sender du grader, får du en `400`, der siger det.

Terrænnettet returneres række for række fra nord mod syd og vest mod øst: værdien på indeks `r * kolonner + c` ligger i `[oprindelse[0] + c * celle_m, oprindelse[1] - r * celle_m]`. Alle højder er i meter over DVR90, og en celle uden data er `null`.

## Bygningsomrids og luftfoto

BBR har kun ét punkt pr. bygning. `/v1/geodanmark/bygninger/:bfe` giver bygningernes rigtige omrids som WGS84-polygoner, koblet til BBR-bygningen med `bbr_uuid`. GeoDanmark-data er under CC BY 4.0: vis værdien i svarets `attribution`-felt, hvor du tegner omridsene.

Luftfoto leveres som XYZ-tiles i web-mercator (EPSG:3857) på `/v1/orto/tile/:z/:x/:y` — samme z/x/y-skema som et almindeligt tile-lag i Leaflet eller MapLibre. Tiles kræver nøglen i headeren, så lad din egen backend hente dem og videregive dem til kortet. `aar` vælger en årgang, og `dpr=2` giver en 512×512-tile til skærme med høj opløsning. Hvilke årgange der dækker et punkt, fortæller `/v1/orto/daekning`.