index.qmd

---
title: "Ahnen Familie Niemann"
author: "Ulrike Niemann"
date: today
lang: de
format: 
  html: 
    theme: minty
    include-in-header: header.html
    code-fold: true
    highlight-style: github
    toc: true
    css: styles.css
    grid:
      body-width: 1100px
  docx: default
execute:
  echo: false
  warning: false
# editor: visual
---

Probanden: Juliane und Ulrike Niemann


```{r setup}
# librarys laden
if (!require("tidyverse")) install.packages("tidyverse"); library(tidyverse)
if (!require("readxl")) install.packages("readxl"); library(readxl)
if (!require("leaflet")) install.packages("leaflet"); library(leaflet)
if (!require("RColorBrewer")) install.packages("RColorBrewer"); library(RColorBrewer)
if (!require("janitor")) install.packages("janitor"); library(janitor)
if (!require("scales")) install.packages("scales"); library(scales)
if (!require("knitr")) install.packages("knitr"); library(knitr)
if (!require("kableExtra")) install.packages("kableExtra"); library(kableExtra)
if (!require("ggiraph")) install.packages("ggiraph"); library(ggiraph)
if (!require("igraph")) install.packages("igraph"); library(igraph)
if (!require("treemap")) install.packages("treemap"); library(treemap)
if (!require("ggraph")) install.packages("ggraph"); library(ggraph)

source("./R/0_functions.R")
source("./R/1_DatenEinlesen.R")
source("./R/2_DatenSelektieren.R")
source("./R/3_DatenAufbereiten.R")
source("./R/4_FamilienDaten.R")



tab <- data |> group_by(Vorfahren) |> 
  count(Anzahl = n())

Zahl_Probanden <- tab[[2,3]]
Zahl_Ahnen <- tab[[1,3]] 
Zahl_Weitere <- tab[[3,3]]

```


Bisher wurden `r nrow(data)` Personen erfasst, 
davon sind `r Zahl_Probanden` Probanden,
`r Zahl_Ahnen` direkte Vorfahren und
`r Zahl_Weitere` verwandt oder verschwägert.

Die eingelesene Ahnen-Datei ist vom `r LetzteAktualisierung`.

```{r}

#| fig-height: 1.2

# Vergleich Anzahl Personen und direkte Vorfahren
#tab <- data |> group_by(Vorfahren) |> 
#  summarise(Anzahl = n()) |> 
#  mutate(Vorfahren = c("Ahnen", "Probanden", "verwandt & verschwägert"))# |> 
 # mutate(Label = str_c(Vorfahren, "\n n = ", Anzahl)) |> 
 # mutate(color = c("grey", "#08519C", "grey"))
# treemap


#treemap(tab,
#        index="Label",
#        vSize="Anzahl",
#        type="color",
#        vColor = "color",
#        title = "",
#        sortID = "size")


```


--------------------------------------------------------------------------------

## Generation - nur direkte Vorfahren

Anteil erfasster direkter Vorfahren an allen möglichen Vorfahren.

```{r}
# doppelte KekuleNr
Zahl_Doppelte_Ahnen <- data |> filter(!is.na(KekuleNr2)) |> nrow()
# hier mal temporär zusammengefügt 
tempDirekt <-
  dataDIREKT |> 
  select(KekuleNr, Generation) |> 
  add_row(
    dataDIREKT |> 
      filter(!is.na(KekuleNr2)) |> 
      select(KekuleNr2, Generation) |> 
      rename(KekuleNr = KekuleNr2)
  )
```

<b>Ahnenimplex:</b>

Wir haben `r Zahl_Doppelte_Ahnen` "doppelte" direkten Vorfahren (doppelte Kekule). 
(z.B. durch Heirat von Cousin oder so)

Hier die betroffenen Generationen:

```{r}
tab <- data |> filter(!is.na(KekuleNr2)) |> 
  group_by(Generation) |> 
  count(Generation, name = "Anzahl") 

if (knitr::is_html_output()) { 
  tab |> 
  kable(align = c("l", "c", "c")) |> 
  kable_styling(bootstrap_options = c("striped", "hover", "condensed"),
                full_width = F) 
} else { kable(tab) }
```

Das heißt: die `r Zahl_Ahnen` direkten Vorfahren-Personen entsprechen eigentlich `r Zahl_Ahnen` + `r Zahl_Doppelte_Ahnen` = `r nrow(tempDirekt)` direkten Ahnen. 


```{r}
# Tabelle
dat <- computeTable(tempDirekt, Generation)

dat <- dat |> select(-Prozent)

tab <- dat |> 
  mutate(Vorfahren = c((2^(1:14)), sum(2^(1:14)))) |> 
  mutate(Prozent = Anzahl / Vorfahren) |> 
  mutate(Prozent = Prozent |> percent(accuracy = 0.1, decimal.mark = ","))

# wir bereiten die Tabelle weiter auf
# Spalte für Anzahl Personen
tab <- tab |> 
  add_column(
    computeTable(dataDIREKT, Generation) |> 
      select(Anzahl) |> 
      rename(`Anzahl Personen IST` = Anzahl),
    .after = "Anzahl"
  ) 
# Spalten umbenennen
tab <- tab |> 
  rename(`Anzahl Vorfahren IST` = Anzahl,
         `Anzahl Vorfahren SOLL` = Vorfahren,
         `Anteil Vorfahren IST an SOLL in %` = Prozent)
# Spalten von (frühestes Geb.-Datum) bis (spätestes Sterbedatum)
# erst mal temporär berechnen
temp <- dataDIREKT |> 
  group_by(Generation) |> 
  summarise(von = min(year(GEBURTSDATUM), na.rm = TRUE),
            bis = max(year(TODESDATUM), na.rm = TRUE)) |> 
  suppressWarnings() |> 
  mutate_if(is.numeric, list(~na_if(., Inf))) |> 
  mutate_if(is.numeric, list(~na_if(., -Inf)))
# und jetzt einfügen
tab <- tab |> left_join(temp) |> 
  relocate(c(von, bis), .after = Generation)

# letzte Zeile modifizieren: Anzahl und Anteil raus
tab[nrow(tab), 6:7] <- NA

options(knitr.kable.NA = '')
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
```



```{r}
#| fig-height: 4
# Grafik
dat <- computeTable(data = data |> filter(!is.na(Generation) & !str_detect(Generation, "1")), 
                    Generation) |> filter(row_number() <= n()-1)
g <- ggplot(dat, aes(y = Generation, x = Anzahl)) + 
  geom_bar_interactive(stat = "identity", 
                       aes(fill = "#08519C", 
                           tooltip = str_c(Generation, ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Generation / Ebene") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  geom_text(aes(label = Anzahl), hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_identity(guide = "none") +
  ggtitle("Anzahl direkter Vorfahren nach Generation") +
  myTheme
#g
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```


```{r}
#| fig-height: 4
# Grafik
dat <- tab |> 
  filter(Generation != "Total") |> 
  select(Generation, `Anzahl Vorfahren IST`, `Anzahl Vorfahren SOLL`) |> 
  pivot_longer(cols = 2:3, names_to = "Variable", values_to = "Anzahl")

g <- ggplot(dat, aes(y = Generation, x = Anzahl, fill = Variable, group = Variable)) + 
  geom_bar_interactive(stat = "identity", position = position_dodge(), 
                           aes(tooltip = str_c(Generation, " - ", Variable, 
                                               ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Generation / Ebene") +
  scale_x_log10(expand = expansion(mult = c(0, 0.5))) +
  scale_fill_manual(values = c("#08519C", "grey"))+
  geom_text(aes(label = Anzahl), position = position_dodge(width = 1),
            vjust = 0.4, hjust = -0.5, size = 6, size.unit = "pt") +
  ggtitle("Anzahl direkter Vorfahren nach Generation Soll-Ist-Vergleich",
          subtitle = "(Log-Skala)") +
  myTheme +
  theme(legend.title = element_blank(),
        plot.subtitle = element_text(size = 8, color = "#5a5a5a"),
        legend.position = "top",
        legend.text = element_text(size = 7),
        legend.key.size = unit(0.6, "line"))
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```


--------------------------------------------------------------------------------

## KekuleNr und Versuch eines Stammbaums

Nur zum Verständnis - KekuleNr (hier: bis 60): 

- Männer = gerade KekuleNr, Frauen die darauffolgende ungerade KekuleNr
- also: Wolfgang = 2, Renate = 3
- Kind ist damit immer: KekuleNr / 2 -> abgerundet
- Wolfgangs Eltern: KekuleNr 4+5 -> jeweils / 2 abgerundet: KekuleNr Kind (Wolfgang) = 2
- der mittlere Knoten (1) repräsentiert hier Juliane+Ulrike

```{r}
#| fig-height: 7
#| fig-width: 7

if (knitr::is_html_output()) {
# https://r-graph-gallery.com/251-network-with-node-size-based-on-edges-number.html
# create data:
direkt <- data |> 
  filter(KekuleNr > 1 & KekuleNr <= 60) |> 
  select(KekuleNr, VORNAME, NACHNAME, Kind, Generation)

links=data.frame(
  source=as.character(direkt$KekuleNr),
  target=as.character(direkt$Kind))

# Turn it into igraph object
set.seed(2)
network <- graph_from_data_frame(d=links, directed=F) 
plot(network, layout=layout.fruchterman.reingold)
}
```
```{r}
#| fig-height: 6
#| fig-width: 9
if (knitr::is_html_output()) {
# data: edge list
edges=data.frame(
  from=as.character(direkt$Kind),
  to=as.character(direkt$KekuleNr))

# We can add a second data frame with information for each node!
name <- unique(c(as.character(edges$from), as.character(edges$to)))

vertices <- data.frame(name = as.numeric(name)) |> 
  left_join(direkt |> 
  select(KekuleNr, VORNAME, NACHNAME, Generation), 
  by = join_by(name == KekuleNr))
vertices[1, 2] <- "Ulrike + Juliane"  
vertices[1, 3] <- "NIEMANN" 

mygraph <- graph_from_data_frame( edges, vertices=vertices )

ggraph(mygraph, layout = 'tree', circular = FALSE) +
  geom_edge_link() +
  geom_node_text(aes(label = name, vjust = 1.5)) +
  geom_node_point(aes(color = Generation)) +
  theme_void()
}
```


```{r}
#| fig-height: 6
#| fig-width: 9
if (knitr::is_html_output()) {
ggraph(mygraph, layout = 'tree', circular = FALSE) +
  geom_edge_link() +
  geom_node_text(aes(label = str_c(VORNAME, " ", NACHNAME), 
                     angle = -90, hjust = -0.1), size = 2) +
  geom_node_point() +
  theme_void() +
  expand_limits(x = c(-0, 0), y = c(-1.7, 1.7))

}
```



```{r}
if (knitr::is_html_output()) {
#| fig-height: 6
#| fig-width: 9
# data: edge list

# Hier für alle direkten Vorfahren nach Stamm Wolfgang oder Stamm Renate:
edges <- data.frame(
  from=as.character(dataDIREKT$Kind),
  to=as.character(dataDIREKT$KekuleNr))

# We can add a second data frame with information for each node!
name <- unique(c(as.character(edges$from), as.character(edges$to)))

vertices <- data.frame(name = as.numeric(name)) |> 
  left_join(dataDIREKT |> 
              select(KekuleNr, VORNAME, NACHNAME, Generation, Stamm, colorStamm), 
            by = join_by(name == KekuleNr))
# nur ein Knoten für J+U
vertices[1, 1] <- 1 
vertices[1, 2] <- "Ulrike + Juliane"  
vertices[1, 3] <- "NIEMANN" 
vertices[1, 5] <- "1" 
vertices[1, 6] <- "grey" 
vertices <- vertices[-c(2:3), ]
edges <- edges[-c(1:2), ]


#mygraph <- graph_from_data_frame( edges, vertices=vertices )

layout <- create_layout(mygraph, layout = 'tree', circular = FALSE)

#ggraph(layout, layout = 'tree', circular = FALSE) +
#  geom_edge_link() +
#  geom_node_text(aes(label = name, vjust = 1.5), size = 2) +
#  geom_node_point(aes(color = Stamm)) +
#  scale_color_manual(values=vertices$colorStamm)+
#  theme_void()


}
```


--------------------------------------------------------------------------------

## Version Wolfgang: Anzahl gemeinsamer Kinder <span style="text-decoration:underline">DER ELTERN</span> der direkten Linie (Eltern, Großeltern, Urgroßeltern...)



```{r}

data_KIDS <- data |> 
  filter(KekuleNr > 0) |> 
  select(PERSONEN_ID, KekuleNr, NACHNAME, VORNAME, ELTERN)




# NEU Duplikate bei Ahnen (=direkte Linie) & Geschwistern der Probanden entfernen

data_KIDS <- data_KIDS |> 
  filter(! is.na(ELTERN))
library(dplyr)
data_KIDS <- data_KIDS %>% distinct( ELTERN, .keep_all = TRUE)

# Ende NEU

# für gemeinsame Kinder: nur die, die Eltern haben

data_ELTERN <- data_KIDS |> filter(KekuleNr > 0, ! is.na(ELTERN))

data_ELTERN <- data_ELTERN |>
  left_join(FamTab |> select(FamID, AnzahlKinder), 
            by = join_by(ELTERN == FamID)) |> 
  rename(Kinderzahl_der_Eltern = AnzahlKinder)

# ..............................................................................
#| fig-height: 3

# Tabelle
tab <- computeTable(data_ELTERN, Kinderzahl_der_Eltern) 
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }

# Grafik
dat <- computeTable(data_ELTERN, Kinderzahl_der_Eltern) |> 
  filter(row_number() <= n()-1) # Total-Zeile für Grafik raus
# ..............................................................................
 g <- ggplot(dat, aes(y = Kinderzahl_der_Eltern, x = Anzahl)) + 
  geom_bar_interactive(stat = "identity", 
                       aes(fill = "#08519C", 
                           tooltip = str_c(Kinderzahl_der_Eltern, ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Anzahl Kinder") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  geom_text(aes(label = Anzahl), hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_identity(guide = "none") +
  ggtitle("Anzahl der gemeinsamen Kinder der ELTERN der direkten Linie") +
  myTheme


if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }

```

--------------------------------------------------------------------------------

## Gesamtzahl der Kinder der direkten Linie (Mutter, Vater, Großmütter, Großväter,...)  

Hier also die Gesamtzahl der Kinder, entspricht Kindern aus jeweils allen Familien,
also nicht nur die Vorfahren-Stamm-Familie.

```{r}
data_KIDS <- data |> 
  filter(KekuleNr > 1)|> 
  select(PERSONEN_ID, KekuleNr, NACHNAME, VORNAME,
         FAMILIE_1, FAMILIE_2, FAMILIE_3, FAMILIE_4)

# Anzahl der Kinder aus den einzelnen Verbindungen

# VERBINDUNG 1
data_KIDS <- data_KIDS |>
left_join(FamTab |> select(FamID, AnzahlKinder), 
          by = join_by(FAMILIE_1 == FamID)) |> 
  rename("KINDER_1" = "AnzahlKinder")

# VERBINDUNG 2
data_KIDS <- data_KIDS |>
left_join(FamTab |> select(FamID, AnzahlKinder), 
          by = join_by(FAMILIE_2 == FamID)) |> 
  rename("KINDER_2" = "AnzahlKinder")

# VERBINDUNG 3
data_KIDS <- data_KIDS |>
left_join(FamTab |> select(FamID, AnzahlKinder), 
          by = join_by(FAMILIE_3 == FamID)) |> 
  rename("KINDER_3" = "AnzahlKinder")

# VERBINDUNG 4
data_KIDS <- data_KIDS |>
left_join(FamTab |> select(FamID, AnzahlKinder), 
          by = join_by(FAMILIE_4 == FamID)) |> 
  rename("KINDER_4" = "AnzahlKinder")

# Gesamtzahl der Kinder der einzelnen Ahnen
# NA durch 0 ersetzen
data_KIDS[is.na(data_KIDS)] <- 0

data_KIDS <- data_KIDS |> 
  mutate(SUMME_KINDER = KINDER_1 + KINDER_2 + KINDER_3 + KINDER_4)

#| fig-height: 3


# Tabelle
tab <- computeTable(data_KIDS, SUMME_KINDER) 
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }

# Grafik
dat <- computeTable(data_KIDS, SUMME_KINDER)  |> 
  filter(row_number() <= n()-1) # Grafik ohne Total-Zeile
# ..............................................................................
 g <- ggplot(dat, aes(y = SUMME_KINDER, x = Anzahl)) + 
  geom_bar_interactive(stat = "identity", 
                       aes(fill = "#08519C", 
                           tooltip = str_c(SUMME_KINDER, ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Anzahl aller Kinder") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  geom_text(aes(label = Anzahl), hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_identity(guide = "none") +
  ggtitle("Gesamtzahl der Kinder der einzelnen Ahnen") +
  myTheme

if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }

```
<!-- ab hier: Version Ulrike -------------------------------------------------->

## Version Ulrike: Anzahl Kinder - Anzahl der direkten Vorfahren 

```{r}

#| fig-height: 3

# Tabelle
tab <- computeTable(dataDIREKT, AnzahlKinder)
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
# Grafik
# keine Angabe auch raus: -2
dat <- computeTable(dataDIREKT, AnzahlKinder) |> filter(row_number() <= n()-2)
########################################################
 g <- ggplot(dat, aes(y = AnzahlKinder, x = Anzahl)) + 
  geom_bar_interactive(stat = "identity", 
                       aes(fill = "#08519C", 
                           tooltip = str_c(AnzahlKinder, ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Anzahl Kinder") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  geom_text(aes(label = Anzahl), hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_identity(guide = "none") +
  ggtitle("Anzahl direkte Vorfahren nach Anzahl ihrer Kinder") +
  myTheme
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```

### Mittlere Anzahl Kinder - alle direkten Vorfahren

```{r}
#| fig-height: 3
tab <- dataDIREKT |> 
  group_by(Generation) |> 
  summarise(`Mittelwert Anzahl Kinder` = round(mean(AnzahlKinder, na.rm = TRUE), 1),
            Anzahl = n()) |> 
  add_row(Generation = "Alle direkten Vorfahren",
          `Mittelwert Anzahl Kinder` = round(mean(data$AnzahlKinder, na.rm = TRUE), 1), 
          Anzahl = nrow(data |> filter(Vorfahren == "Direkt")))
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
#
g <- ggplot(tab, aes(y = Generation, x = `Mittelwert Anzahl Kinder`)) + 
  geom_bar_interactive(stat = "identity", width = 0.5,
                       aes(fill = "#08519C", 
                           tooltip = str_c("Generation : ", Generation, 
                                           " - Mittelwert Anzahl Kinder: ", 
                                           `Mittelwert Anzahl Kinder`, " Kinder (n = ",
                                           Anzahl, ")"))) +
  geom_text(aes(label = `Mittelwert Anzahl Kinder`), 
            hjust = -0.1, size = 8, size.unit = "pt") +
  scale_y_discrete(limits=rev, name = "Generation / Ebene") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  scale_fill_identity(guide = "none") +
  ggtitle("Mittlere Anzahl Kinder, direkte Vorfahren nach Generation") +
  myTheme
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```

## Anzahl Kinder - Anzahl der direkten Vorfahren-PAARE 


```{r}
#| fig-height: 3

# Tabelle
tab <- computeTable(dataDIREKT |> select(Paar, AnzahlKinder) |> unique(), 
             AnzahlKinder) 
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
# Grafik
# keine Angabe auch raus: -2
dat <- computeTable(dataDIREKT |> select(Paar, AnzahlKinder) |> unique(), AnzahlKinder) |>
  filter(row_number() <= n()-2)
########################################################
 g <- ggplot(dat, aes(y = AnzahlKinder, x = Anzahl)) + 
  geom_bar_interactive(stat = "identity", 
                       aes(fill = "#08519C", 
                           tooltip = str_c(AnzahlKinder, ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Anzahl Kinder") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  geom_text(aes(label = Anzahl), hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_identity(guide = "none") +
  ggtitle("Anzahl direkte Vorfahren nach Anzahl ihrer Kinder") +
  myTheme
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```

### Mittlere Anzahl Kinder - alle direkten Vorfahren-PAARE

```{r}
#| fig-height: 3
tab <- dataDIREKT |> select(Paar, AnzahlKinder, Generation) |> unique() |> 
  group_by(Generation) |> 
  summarise(`Mittelwert Anzahl Kinder` = round(mean(AnzahlKinder, na.rm = TRUE), 1),
            Anzahl = n()) |> 
  add_row(Generation = "Alle direkten Vorfahren",
          `Mittelwert Anzahl Kinder` = round(mean(data$AnzahlKinder, na.rm = TRUE), 1), 
          Anzahl = nrow(data |> filter(Vorfahren == "Direkt")))
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
#
g <- ggplot(tab, aes(y = Generation, x = `Mittelwert Anzahl Kinder`)) + 
  geom_bar_interactive(stat = "identity", width = 0.5,
                       aes(fill = "#08519C", 
                           tooltip = str_c("Generation : ", Generation, 
                                           " - Mittelwert Anzahl Kinder: ", 
                                           `Mittelwert Anzahl Kinder`, " Kinder (n = ",
                                           Anzahl, ")"))) +
  geom_text(aes(label = `Mittelwert Anzahl Kinder`), 
            hjust = -0.1, size = 8, size.unit = "pt") +
  scale_y_discrete(limits=rev, name = "Generation / Ebene") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  scale_fill_identity(guide = "none") +
  ggtitle("Mittlere Anzahl Kinder, direkte Vorfahren nach Generation") +
  myTheme
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```
--------------------------------------------------------------------------------


## Geburt / Jahrhundert - Alle

```{r}
#| fig-height: 2
tab <- computeTable(data, Geburt) 
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
# keine Angabe auch raus: -2
dat <- computeTable(data, Geburt) |> filter(row_number() <= n()-2)
g <- ggplot(dat, aes(y = Geburt, x = Anzahl)) + 
  geom_bar_interactive(stat = "identity", 
                       aes(fill = "grey", 
                           tooltip = str_c(Geburt, ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Jahrhundert Geburt") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  geom_text(aes(label = Anzahl), hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_identity(guide = "none") +
  ggtitle("Anzahl Vorfahren nach Geburtsjahrhundert") +
  myTheme
#g
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```

## Generation und Geburtsjahrhundert - nur Direktvorfahren

```{r}
#| fig-height: 4
# Generation + Geburt
g <- ggplot(data = data[!is.na(data$Generation), ], aes(y = Generation)) + 
  geom_bar_interactive(aes(fill = Geburt, 
                           tooltip = str_c("Anzahl = ", 
                                           after_stat(count)))) +
  scale_y_discrete(limits=rev, name = "Generation / Ebene") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  geom_text(aes(label = ..count..), 
            stat = "count", hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_manual(values = 
                      c(brewer.pal(length(levels(data$Geburt)), "Blues")[-1], "#aaaaaa")) +
  ggtitle("Anzahl Direkt-Vorfahren nach Generation und Geburtsjahrhundert") +
  myTheme
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```

--------------------------------------------------------------------------------

## Erreichtes Alter

### Alter: Nur Direkt-Vorfahren

```{r}
#| fig-height: 3
# Altersgruppen - Direkt-Vorfahren
tab <- computeTable(data |> filter(Vorfahren == "Direkt"), Altersgruppe) 
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
# keine Angabe auch raus: -2
dat <- computeTable(data |> filter(Vorfahren == "Direkt"), Altersgruppe) |> 
  filter(row_number() <= n()-2)

g <- ggplot(dat, aes(y = Altersgruppe, x = Anzahl)) + 
  geom_bar_interactive(stat = "identity", 
                       aes(fill = "#08519C", 
                           tooltip = str_c(Altersgruppe, ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Altersgruppe") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  #coord_flip() +
  geom_text(aes(label = Anzahl), hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_identity(guide = "none") +
  ggtitle("Anzahl Vorfahren nach Alter - Direktvorfahren") +
  myTheme
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```

### Alter: Alle Vorfahren

```{r}
#| fig-height: 3
# Altersgruppen - alle
tab <- computeTable(data, Altersgruppe) 
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
# keine Angabe auch raus: -2
dat <- computeTable(data, Altersgruppe) |> filter(row_number() <= n()-2)

g <- ggplot(dat, aes(y = Altersgruppe, x = Anzahl)) + 
  geom_bar_interactive(stat = "identity", 
                       aes(fill = "grey", 
                           tooltip = str_c(Altersgruppe, ": n = ", Anzahl))) +
  scale_y_discrete(limits=rev, name = "Altersgruppe") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  #coord_flip() +
  geom_text(aes(label = Anzahl), hjust = -0.1, size = 8, size.unit = "pt") +
  scale_fill_identity(guide = "none") +
  ggtitle("Anzahl Vorfahren nach Alter") +
  myTheme
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```

### Mittleres Alter nach Jahrhunderten - Alle

```{r}
#| fig-height: 2
tab <- data |> 
  filter(!is.na(Alter)) |> 
  group_by(Geburt) |> 
  summarise(`Mittelwert Alter` = round(mean(Alter), 1),
            Anzahl = n()) |> 
  add_row(Geburt = "Alle Vorfahren",
          `Mittelwert Alter` = round(mean(data$Alter, na.rm = TRUE), 1), 
          Anzahl = nrow(data |> filter(!is.na(Alter))))
if (knitr::is_html_output()) { getTable(tab) } else { kable(tab) }
#
g <- ggplot(tab, aes(y = Geburt, x = `Mittelwert Alter`)) + 
  geom_bar_interactive(stat = "identity", width = 0.5,
           aes(fill = "grey", 
               tooltip = str_c("Geburt: ", Geburt, 
                               " - Mittelwert erreichtes Alter: ", 
                               `Mittelwert Alter`, " Jahre (n = ",
                               Anzahl, ")"))) +
  geom_text(aes(label = `Mittelwert Alter`), 
            hjust = -0.1, size = 8, size.unit = "pt") +
  scale_x_continuous(expand = expansion(mult = c(0, 0.1))) +
  scale_fill_identity(guide = "none") +
  ggtitle("Mittleres Alter bei Tod, Alle und nach Jahrhundert der Geburt") +
  myTheme
if (knitr::is_html_output()) { girafe(ggobj = g) } else { print(g) }
```

--------------------------------------------------------------------------------


# Karten

Den Geodaten fügen wir ein leichtes "Rauschen" hinzu, damit Dublikate (Vorfahren mit gleichen Geodaten)
beim Reinscrollen trotzdem sichtbar werden.

```{r}
# Geo Dublikate ?
# duplicated(data[,c("lat1", "lon1")]) |> table()
# leichtes Rauschen
data <- data |> 
  mutate(lat1x = jitter(lat1, factor = 1),
         lon1x = jitter(lon1, factor = 1),
         lat2x = jitter(lat2, factor = 1),
         lon2x = jitter(lon2, factor = 1) )

```


Beim Pop-Up sind die Namen hinterlegt.

### Version 1

Direkt- vs. weitere Vorfahren.

Wiso ist da ein schwedischer noName ??

```{r}
if (knitr::is_html_output()) {
col <- c("#08519C", "grey")
cols <- colorFactor(palette = col, data$Vorfahren)
# Karte V1
leaflet(data |> filter(!is.na(lon1))) |>
  addTiles() |>
  addProviderTiles("OpenStreetMap.DE",
                   options = providerTileOptions(noWrap = TRUE)) |>
  # setView(lng = mean(data$lon1, na.rm = TRUE), 
  #         lat = mean(data$lat1, na.rm = TRUE), zoom = 8) |> 
    addCircleMarkers(~lon1x, ~lat1x, radius = 4,
                   fillColor = col, fillOpacity = 0.7,
                   weight = 1,
                   popup = ~str_c(VORNAME, " ", NACHNAME)) |>
  addLegend('bottomright', pal = cols, values = unique(data$Vorfahren),
            title = 'Vorfahren',
            opacity = 1)
}
```

### Version 2

Geburtsorte nach Jahrhundert der Geburt.

Es gibt außerdem viele verschiedene Hintergrundkarten, da ist noch das optimale zu wählen...

siehe z.B. 
http://leaflet-extras.github.io/leaflet-providers/preview/


```{r}
col <- c(brewer.pal(length(levels(data$Geburt)), "Blues")[-1], "#aaaaaa")
lev <- levels(data$Geburt)
cols <- colorFactor(palette = col, data$Geburt)

l2 <- leaflet(data |> filter(!is.na(lon1))) |> 
  addTiles() |> 
  addProviderTiles(providers$Esri.NatGeoWorldMap) |> 
  # setView(lng = mean(data$lon1, na.rm = TRUE),
  #         lat = mean(data$lat1, na.rm = TRUE), zoom = 8) |>
  addCircleMarkers(~lon1x, ~lat1x, radius = 4,
                   fillColor  = ~cols(Geburt), fillOpacity = 0.7,
                   weight = 1,
                   popup = ~str_c(VORNAME, " ", NACHNAME)) |>
  addLegend('bottomright', pal = cols, values = lev,
            title = 'Geburt',
            opacity = 1)
if (knitr::is_html_output()) { l2 }
```

## Version 3: direkte Vorfahren nach Stamm

```{r}
# leichtes Rauschen
dataDIREKT <- dataDIREKT |> 
  mutate(lat1x = jitter(lat1, factor = 1),
         lon1x = jitter(lon1, factor = 1),
         lat2x = jitter(lat2, factor = 1),
         lon2x = jitter(lon2, factor = 1) )

# Karte V3
dataMap <- dataDIREKT |> filter(!is.na(lon1))

col <- dataMap$colorStamm
cols <- colorFactor(palette = unique(dataMap$colorStamm), domain = NULL)
lev <- c("1", "Wolfgang", "test")

l3 <- leaflet(dataMap) |>
  addTiles() |>
  addProviderTiles("OpenTopoMap",#"Stadia.StamenWatercolor",
                   options = providerTileOptions(noWrap = TRUE)) |>
    # addProviderTiles("OpenTopoMap",
    #                options = providerTileOptions(opacity = 0.3)) |>
  setView(lng = mean(dataMap$lon1, na.rm = TRUE),
          lat = mean(dataMap$lat1, na.rm = TRUE), zoom = 7) |>
  addCircleMarkers(~lon1x, ~lat1x, radius = 4,
                   fillColor = col, fillOpacity = 0.7,
                   weight = 1,
                   popup = ~str_c(VORNAME, " ", NACHNAME)) |> 
  addLegend('bottomright', colors = unique(col), 
            labels =  unique(dataMap$Stamm),
            title = 'Stamm',
            opacity = 1)
if (knitr::is_html_output()) { l3 }

```


... hier kommt bald noch mehr ...