{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 📥 Øving 3\n",
    "\n",
    "I denne øvingen skal du jobbe med å lese og bruke romlige data ved hjelp av GeoPandas.\n",
    "\n",
    "Øvingsoppgaven finner du på Canvas under Oppgaver, eller på [dette GitHub-repoet](https://github.com/GMGI221-2024/gmgi221-ovinger).\n",
    "\n",
    "Last den ned, åpne den i Jupyter Notebooks/Lab eller den editoren du bruker og følg instruksjonene i Notebooken. Lever den så inn på Canvas etter du har endret navn til \"oving3-ditt_navn.ipynb\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tips til oppgaven:\n",
    "\n",
    "### Pandas `apply()`-metoden:\n",
    "\n",
    "Pandas' DataFrames har en metode `apply()` som kjører en brukerdefinert funksjon på hver rad eller på hver kolonne (avhengig av `axis`-parameteren, hvis `axis=1`, fungerer `apply()` på rader).\n",
    "\n",
    "Resultatene av å kjøre funksjonen gjentatte ganger (parallelt, for å være presis) samles i en pandas.GeoSeries som er returverdien av `apply()` og kan tilordnes til en ny kolonne eller rad.\n",
    "\n",
    "For eksempel kan dette brukes for å lage punkt-geometrier:\n",
    "\n",
    "```python\n",
    "def create_point(row):\n",
    "    \"\"\"Create a Point geometry from a row with x and y values.\"\"\"\n",
    "    point = shapely.geometry.Point(row[\"x\"], row[\"y\"])\n",
    "    return point\n",
    "\n",
    "point_series = data.apply(create_point, axis=1)\n",
    "```\n",
    "\n",
    "#### Bruke en anonym `lambda`-funksjon med `apply()`\n",
    "\n",
    "Til slutt, for enkle funksjoner som passer på en enkelt linje, kan vi sende funksjonen inn i såkalt 'lambda-notasjon'. Lambda-funksjoner følger syntaksen `lambda argumenter: returverdi`, dvs. nøkkelordet `lambda` etterfulgt av ett eller flere, kommaseparerte argumentnavn (inputvariabler), et kolon (:), og returverdi-setningen (f.eks. en beregning). En lambda-funksjon som aksepterer to argumenter og returnerer summen av dem, vil se slik ut: `lambda a, b: (a + b)`.\n",
    "\n",
    "Lambda-funksjoner kan bare brukes der de er definert, men tilbyr en praktisk snarvei for å slippe separate funksjoner for enkle uttrykk. De er svært vanlige i datavitenskapsprosjekter, men bør ikke brukes for mye: som en tommelfingerregel, ikke bruk lambda-funksjoner hvis koden deres ikke passer på en (kort) linje.\n",
    "\n",
    "Les mer om lambda-funksjoner i [Python-dokumentasjonen](https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Konvertere en `pandas.DataFrame` til en `geopandas.GeoDataFrame`\n",
    "\n",
    "Noen ganger jobber vi med data som er i et ikke-romlig format (som Excel\n",
    "eller CSV-regneark) men inneholder informasjon om plasseringen av poster, for\n",
    "eksempel, i kolonner for lengde- og breddegradverdier. Mens geopandas sin\n",
    "`read_file()`-funksjon kan lese noen formater, er det ofte tryggest å bruke\n",
    "pandas for å lese datasettet og deretter konvertere det til en `GeoDataFrame`.\n",
    "\n",
    "La oss anta at vi leser følgende tabell ved å bruke `pandas.read_csv()` inn i en\n",
    "variabel `df`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "# sample data\n",
    "import pandas\n",
    "df = pandas.DataFrame({\n",
    "    \"longitude\": [24.9557, 24.8353, 24.9587],\n",
    "    \"latitude\": [60.1555, 60.1878, 60.2029]\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>longitude</th>\n",
       "      <th>latitude</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>24.9557</td>\n",
       "      <td>60.1555</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>24.8353</td>\n",
       "      <td>60.1878</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>24.9587</td>\n",
       "      <td>60.2029</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   longitude  latitude\n",
       "0    24.9557   60.1555\n",
       "1    24.8353   60.1878\n",
       "2    24.9587   60.2029"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`geopandas.GeoDataFrame()`-konstruktøren aksepterer en `pandas.DataFrame` som input, men den fyller ikke automatisk `geometry`-kolonnen. Biblioteket kommer imidlertid med en praktisk hjelpefunksjon `geopandas.points_from_xy()`. Som vi alle vet, bør et romlig datasett alltid ha et koordinatreferansesystem (CRS) definert; vi kan spesifisere CRS for inngangsdataene her også:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>longitude</th>\n",
       "      <th>latitude</th>\n",
       "      <th>geometry</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>24.9557</td>\n",
       "      <td>60.1555</td>\n",
       "      <td>POINT (24.95570 60.15550)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>24.8353</td>\n",
       "      <td>60.1878</td>\n",
       "      <td>POINT (24.83530 60.18780)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>24.9587</td>\n",
       "      <td>60.2029</td>\n",
       "      <td>POINT (24.95870 60.20290)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   longitude  latitude                   geometry\n",
       "0    24.9557   60.1555  POINT (24.95570 60.15550)\n",
       "1    24.8353   60.1878  POINT (24.83530 60.18780)\n",
       "2    24.9587   60.2029  POINT (24.95870 60.20290)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import geopandas\n",
    "\n",
    "gdf = geopandas.GeoDataFrame(\n",
    "    df,\n",
    "    geometry=geopandas.points_from_xy(df.longitude, df.latitude),\n",
    "    crs=\"EPSG:4326\"\n",
    ")\n",
    "\n",
    "gdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nå har vi en 'ordentlig' `GeoDataFrame` som vi kan utføre alle romlige operasjoner vi ønsker med.\n",
    "\n",
    "### Opprette en ny `geopandas.GeoDataFrame`: alternativ 1\n",
    "\n",
    "Noen ganger gir det mening å starte fra bunnen av med et tomt datasett og gradvis legge til poster. Selvfølgelig er dette også mulig med geopandas' dataframes, som deretter kan lagres som en ny geopackage eller shapefil.\n",
    "\n",
    "Først, opprett en helt tom `GeoDataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import geopandas\n",
    "\n",
    "new_geodataframe = geopandas.GeoDataFrame()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deretter, opprett shapely-geometriobjekter og legg dem inn i dataframen. For å legge inn et geometriobjekt i `geometry`-kolonnen, og et navn i `name`-kolonnen, i en ny rad, bruk:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>geometry</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Stortorget</td>\n",
       "      <td>POLYGON ((10.74487 59.91309, 10.74455 59.91273...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         name                                           geometry\n",
       "0  Stortorget  POLYGON ((10.74487 59.91309, 10.74455 59.91273..."
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import shapely.geometry\n",
    "polygon = shapely.geometry.Polygon(\n",
    "    [\n",
    "        (10.744868,59.913090),\n",
    "        (10.744548,59.912731),\n",
    "        (10.745796,59.912435),\n",
    "        (10.746048,59.912704)\n",
    "    ]\n",
    ")\n",
    "name = \"Stortorget\"\n",
    "\n",
    "new_geodataframe.loc[\n",
    "    len(new_geodataframe),  # in which row,\n",
    "    [\"name\", \"geometry\"]    # in which columns to save values\n",
    "] = [name, polygon]\n",
    "\n",
    "new_geodataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Før du lagrer det nyopprettede datasettet, ikke glem å definere et kartografisk referansesystem for det. Ellers vil du få problemer med å gjenbruke filen i andre programmer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "new_geodataframe = new_geodataframe.set_geometry(\"geometry\")\n",
    "new_geodataframe.crs = \"EPSG:4326\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{hint}\n",
    "I eksempelet ovenfor brukte vi `len(new_geodataframe)` som en radindeks\n",
    "(som, i en nyopprettet dataframe, er ekvivalent med radnummeret). Siden\n",
    "rader telles fra 0, er antall rader (lengden på dataframen) en større enn adressen til den siste raden. Dette uttrykket legger derfor alltid til en ny rad, uavhengig av den faktiske lengden på dataframen.\n",
    "\n",
    "Merk at, strengt tatt, er indeksen uavhengig av radnummeret,\n",
    "men i nyopprettede dataframes er de identiske.\n",
    ":::\n",
    "\n",
    "### Opprette en ny `geopandas.GeoDataFrame`: alternativ 2\n",
    "\n",
    "Ofte er det mer praktisk og mer elegant å først opprette en ordbok (dictionary)\n",
    "for å samle data, som deretter kan konverteres til en dataframe på en gang.\n",
    "\n",
    "For dette, definer først en `dict` med kolonnenavnene som nøkler, og tomme `list`er\n",
    "som verdier:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    \"name\": [],\n",
    "    \"geometry\": []\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deretter fyller du ordboken med data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shapely.geometry\n",
    "\n",
    "data[\"name\"].append(\"Stortorget\")\n",
    "data[\"geometry\"].append(\n",
    "    shapely.geometry.Polygon(\n",
    "        [\n",
    "            (10.744868,59.913090),\n",
    "            (10.744548,59.912731),\n",
    "            (10.745796,59.912435),\n",
    "            (10.746048,59.912704)\n",
    "        ]\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Til slutt, bruk denne ordboken som input for en ny `GeoDataFrame`. Ikke glem å spesifisere et CRS:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>geometry</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Stortorget</td>\n",
       "      <td>POLYGON ((10.74487 59.91309, 10.74455 59.91273...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         name                                           geometry\n",
       "0  Stortorget  POLYGON ((10.74487 59.91309, 10.74455 59.91273..."
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_geodataframe = geopandas.GeoDataFrame(data, crs=\"EPSG:4326\")\n",
    "new_geodataframe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{note}\n",
    "Disse to tilnærmingene resulterer i identiske `GeoDataFrame`s. Noen ganger er den ene teknikken mer praktisk enn den andre. Du bør alltid vurdere forskjellige måter å løse et problem på, og finne den mest passende og effektive løsningen (det finnes **alltid** mer enn én mulig løsning).\n",
    ":::"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "gmgi221",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}