# Catalogus van aangepaste functies

GeoPard biedt een uitgebreide catalogus met aangepaste functies, ontworpen om de leesbaarheid en functionaliteit van op vergelijkingen gebaseerde analyses te verbeteren. Deze functies kapselen complexe `python` code in, zodat u geavanceerde datamanipulaties en berekeningen eenvoudig kunt uitvoeren.

### Vergelijking invoeren

<figure><img src="https://docs.geopard.tech/~gitbook/image?url=https%3A%2F%2F3272281156-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252FYICBELdyAXXebKAzfLOR%252Fuploads%252FdHTdBE1CN2gSJbE7Bfo0%252Fimage.png%3Falt%3Dmedia%26token%3Dd8e3544f-feca-43a6-b6a1-f1305068de88&#x26;width=768&#x26;dpr=4&#x26;quality=100&#x26;sign=508ec9e0&#x26;sv=2" alt=""><figcaption><p>Voer een vergelijking in</p></figcaption></figure>

De lijst met beschikbare kant-en-klare functies voor het maken van intuïtievere en beter onderhoudbare vergelijkingen in GeoPard is opgenomen in het `geopard` pakket:

### fill\_gaps\_with\_k\_neighbors

```python
# input_data is een Dataset-attribuutlaag (bijv. Opbrengst, NDVI)
filled_layer = geopard.fill_gaps_with_k_neighbors(yield_layer, k=5)
```

Deze functie herstelt datagaten of nullen in een dataset met behulp van het K-Neighbors-algoritme. Door de `input_data` variabele te specificeren (als Dataset met het geselecteerde attribuut) en het aantal buren `k`, kunt u ontbrekende waarden naadloos aanvullen, zodat de datacontinuïteit en integriteit worden gewaarborgd.

Deze functie werkt goed wanneer datagaten verspreid zijn over het perceel en niet aan een bepaald deel van de perceelsgrens zijn toegewezen.

### determine\_data\_similarity

```python
similarity = geopard.determine_data_similarity(yield_2023, yield_2024)
```

Gebruik deze functie om de overeenkomst per pixel tussen twee Datasets te berekenen. De variabelen `data_layer_1` en `data_layer_2` moeten dezelfde **meting** in **dezelfde eenheden** weergeven om een betekenisvolle vergelijking te garanderen. Door variabelen te voorzien `data_layer_1` en `data_layer_2` die aan Datasets zijn gekoppeld, kunt u een overeenkomstskaart genereren met waarden van 0 tot 1, wat vergelijkende studies en patroonherkenning vergemakkelijkt.

### determine\_data\_similarity\_from\_normalized

```python
layer_1_norm = geopard.normalize_data(layer_1)
layer_2_norm = geopard.normalize_data(layer_2)

similarity = geopard.determine_data_similarity_from_normalized(layer_1_norm, layer_2_norm)
```

Gebruik deze functie om de overeenkomst per pixel tussen twee genormaliseerde datasets te berekenen. Normalisatie wordt aanbevolen wanneer de oorspronkelijke `data_layer_1` en `data_layer_2` verschillende schalen of eenheden hebben. Door deze datasets als invoer te geven, genereert de functie een overeenkomstskaart met waarden van 0 tot 1, waardoor deze geschikt is voor vergelijkende studies, patroonherkenning en analyse van ruimtelijke consistentie.

### determine\_low\_high\_similarity

```python
zones = geopard.determine_low_high_similarity(soil_ph, yield_layer)
```

Deze functie beoordeelt de lage-hoge overeenkomst tussen twee Datasets. Door variabelen in te voeren `data_layer_1` en `data_layer_2` die aan Datasets zijn gekoppeld, ontvangt u een gecategoriseerde overeenkomstskaart die combinaties aangeeft zoals laag-laag, laag-hoog, hoog-laag en hoog-hoog, wat nuttig is voor genuanceerde dataclassificatie.

### get\_value\_for\_zone

```python
zone_3_values = geopard.get_value_for_zone(yield_layer, zone_map, zone_id=3)
```

Gebruik deze functie om alle waarden uit een Dataset-attribuut binnen één zone te extraheren. Geef `data_layer` (de attribuutlaag), `zones_layer` (de zonenkaarten), en `zone_id` (het zonenummer) op om waarden voor analyse te isoleren, zoals opbrengst, toedieningshoeveelheid of zaaizaadhoeveelheid, binnen die zone.

### drop\_value

```python
clean_layer = geopard.drop_value(elevation_layer, value_to_drop=0)
```

Met deze functie kunt u specifieke waarden uit een datasetattribuut verwijderen. Door `data_layer` en `value_to_drop`op te geven, kunt u de dataset opschonen door die waarden uit het resultaat te verwijderen, technisch gezien door ze te vervangen door `NaN`.

### normalize\_data

```python
ndvi_normalized = geopard.normalize_data(ndvi_layer)
```

Normaliseer een datasetattribuut met deze functie. Door `data_layer`door te geven, kunt u de gegevens schalen naar een gestandaardiseerd bereik van 0 tot 1, waardoor vergelijking en integratie tussen verschillende datasets eenvoudiger worden.

### calculate\_total\_applied\_fertilizer

```python
applications = [urea_rate, map_rate]
coefficients = [1.0, 1.0]  # gebruik 1.0 om de eenheden te behouden, of pas aan voor productconcentratie

total_applied = geopard.calculate_total_applied_fertilizer(applications, coefficients)
```

Bereken de totale toegediende meststof in eenheden per oppervlakte-eenheid (bijvoorbeeld in kg/ha, l/ha, gal/ac, enz.). Door `application_list` datasets met AppliedRate-attributen en een bijbehorende `active_ingredient_coefficient_list` met meststofproducten te geven, kunt u de werkelijke totale toegediende meststof in eenheden berekenen (bijvoorbeeld in kg, l, gal, enz.).

### calculate\_total\_applied\_nitrogen

```python
applications = [urea_rate, uan_rate]
nitrogen_coefficients = [0.46, 0.32]  # N-fractie (werkzame stof) in elk product

N_total_applied = geopard.calculate_total_applied_nitrogen(applications, nitrogen_coefficients)
```

Bereken de totale toegediende stikstof in kg/ha met deze functie. Door `application_list` datasets met AppliedRate-attributen en een bijbehorende `active_ingredient_coefficient_list` met stikstofproducten te geven om de werkelijke stikstof om te zetten naar kg/ha, kunt u de totale toegediende stikstof nauwkeurig berekenen, essentieel voor agrarische planning en duurzaamheidsbeoordelingen. De uitvoer wordt gebruikt als `N_total_applied` in[`geopard.calculate_nitrogen_use_efficiency`](#calculate_nitrogen_use_efficiency).

### calculate\_nitrogen\_uptake

```python
N_uptake = geopard.calculate_nitrogen_uptake(
    yield_wet_tha=yield_layer,
    moisture_pct=moisture_layer,
    protein_pct=protein_layer,
    protein_crop_correction_coefficient=6.25
)
```

Bepaal de stikstofopname in kg/ha met deze functie. Door `yield_wet_tha`, `moisture_pct`, `protein_pct` uit de Yield Dataset en `protein_crop_correction_coefficient` dat de relatie tussen eiwit en de opname van stikstof weergeeft, kunt u de stikstofbenuttingsefficiëntie in de gewasproductie beoordelen. De uitvoer wordt gebruikt als `N_uptake` in[`geopard.calculate_nitrogen_use_efficiency`](#calculate_nitrogen_use_efficiency) .

### calculate\_nitrogen\_use\_efficiency

```python
NUE_pct = geopard.calculate_nitrogen_use_efficiency(N_total_applied, N_uptake)
```

Evalueer de stikstofbenuttingsefficiëntie als percentage met deze functie. Door [`N_total_applied`](#calculate_total_applied_nitrogen) en [`N_uptake`](#calculate_nitrogen_uptake) variabelen in te voeren (van eerdere functies), kunt u de effectiviteit van stikstoftoediening meten, wat helpt bij het optimaliseren van meststoffengebruik.

### calculate\_costs

```python
rates = [seed_rate, fertilizer_rate]
prices = [1.2, 0.8]  # prijs per eenheid voor elke snelheidslaag
costs = geopard.calculate_costs(rates, prices)
```

Bereken de totale kosten op basis van toedieningshoeveelheden en prijzen met deze functie. Door een `application_rate_list` van Datasets met de AppliedRate-attributen en een bijbehorende `price_per_unit_list`te geven, kunt u uitgaven bundelen die verband houden met verschillende agrarische activiteiten, ter ondersteuning van budgetbeheer en financiële planning. De uitvoer wordt gebruikt als `costs` in[`geopard.calculate_profit`](#calculate_profit).

### calculate\_revenue

```python
revenue = geopard.calculate_revenue(yield_as_mass=yield_layer, yield_price_per_unit=0.25)
```

Bereken de opbrengst uit de Yield Dataset met deze functie. Door `yield_as_mass` gekoppeld aan het attribuut van de Yield Dataset en de `yield_price_per_unit`in te voeren, kunt u de inkomsten uit de gewasproductie schatten, wat economische evaluaties vergemakkelijkt. De uitvoer wordt gebruikt als `costs` in[`geopard.calculate_profit`](#calculate_profit) .

### calculate\_profit

```python
profit = geopard.calculate_profit(revenue, costs)
```

Bepaal de winst door de kosten van de opbrengst af te trekken met deze functie. Door de [`revenue`](#calculate_revenue) en [`costs`](#calculate_costs) variabelen (van eerdere functies) te gebruiken, kunt u eenvoudig de financiële opbrengst van hun agrarische bedrijfsvoering berekenen, ter ondersteuning van winstgevendheidsanalyse en strategische besluitvorming.

### fill\_value\_for\_range

```python
# behoud alleen waarden tussen 10 en 20, vervang de rest door 0
filtered = geopard.fill_value_for_range(layer, min_value=10, max_value=20, value_to_fill=0)
```

Deze functie filtert waarden binnen een opgegeven bereik in de `input` array. Door de `input` array, samen met optionele `min_value` en optionele `max_value` drempels op te geven, kunt u waarden isoleren die binnen het gewenste bereik vallen. De `value_to_fill` parameter maakt het mogelijk om waarden buiten bereik te vervangen door een opgegeven waarde, waardoor processen voor gegevensfiltering en normalisatie worden verbeterd.

### calculate\_per\_pixel\_mae

```python
mae_layer = geopard.calculate_per_pixel_mae(predicted_yield, observed_yield)
```

Gebruik deze functie om de Mean Absolute Error (MAE) per pixel tussen twee datasets te berekenen. Het levert een ruimtelijke kaart van absolute verschillen. Het "absolute verschil" is eenvoudigweg de grootte van de kloof tussen overeenkomstige pixelwaarden, zonder rekening te houden met welke hoger of lager is.

De functie helpt gebieden met grotere afwijkingen te identificeren.

### calculate\_per\_pixel\_relative\_deviation

```python
relative_dev = geopard.calculate_per_pixel_relative_deviation(observed_yield, modeled_yield)
```

Deze functie berekent de relatieve afwijking voor elke pixel tussen twee datasets en drukt het verschil uit als een percentage van de waarde in `dataset_1`. In wezen laat het zien in hoeverre de waarde van één pixel afwijkt van de overeenkomstige waarde in `dataset_1` in proportionele termen.

Deze benadering is bijzonder waardevol bij het analyseren van variaties in bodemeigenschappen, gewasopbrengst of remote-sensinggegevens, omdat het u helpt snel gebieden met significante proportionele verschillen te herkennen.

### calculate\_difference

```python
difference = geopard.calculate_difference(yield_2024, yield_2023)
```

Deze functie trekt de ene dataset af van de andere om een verschilkaart te maken. Het benadrukt gebieden waar de waarden in de ene dataset hoger of lager zijn in vergelijking met de andere, waardoor het gemakkelijker wordt om trends en veranderingen in de tijd te zien.

Deze tool is vooral nuttig voor het visualiseren van variaties in bodemeigenschappen, gewasopbrengst of remote-sensinggegevens, en helpt u snel gebieden te identificeren die verder onderzoek of ingrijpen vereisen.

### calculate\_relative\_difference

```python
relative_diff = geopard.calculate_relative_difference(yield_2024, yield_2023)
```

Deze functie berekent het relatieve verschil voor elke pixel door het verschil tussen de datasets te normaliseren met de waarden uit `dataset_2`. Dit betekent dat het laat zien hoe significant de verandering is in verhouding tot de omvang van `dataset_2`.

Zo'n proportionele vergelijking is vooral nuttig bij datasets met verschillende schalen, omdat het helpt relatieve verschuivingen in bodemeigenschappen, gewasopbrengsten of sensoruitvoer zichtbaar te maken. Deze benadering helpt gebieden met opvallende variatie te lokaliseren.

### calculate\_normalized\_difference

```python
normalized_diff = geopard.calculate_normalized_difference(layer_1, layer_2)
```

Deze functie berekent het genormaliseerde verschil voor elke pixel door beide datasets te schalen ten opzichte van hun globale maximale waarde. Dit proces maakt de datasets direct vergelijkbaar, zelfs als ze oorspronkelijk verschillende bereiken hebben.

De resulterende kaart biedt een duidelijk beeld van variaties in bodemeigenschappen, gewasopbrengst en remote-sensinggegevens, waardoor u belangrijke verschillen snel kunt identificeren en beoordelen.

### build\_zones\_by\_intervals

```python
# intervallen voor zonering
intervals = [
    (4, 8),
    (8, 12),
    (12, 16)
]

# gebruik
zones = geopard.build_zones_by_intervals(
    layer, 
    intervals
)
```

Deze functie maakt een beheerszonemap door een doorlopende rasterlaag te classificeren in afzonderlijke zones op basis van door de gebruiker gedefinieerde waardenintervallen.

Elk interval definieert een zone, en elke pixel wordt toegewezen aan de zone waarvan het waardebereik erin valt. Pixels die niet met een interval overeenkomen, worden gemarkeerd als -1.

Deze zoneringsaanpak wordt vaak gebruikt om opbrengstkaarten, bodemeigenschappen of remote-sensingindices om te zetten in bruikbare beheerszones voor variabele toedieningen.

**Typische toepassingsgevallen**

* Beheerszones maken van opbrengst-, NDVI- of bodemlagen
* Zonkaarten voorbereiden voor nutriënten- of zaaizaadhoeveelheidsberekeningen
* Perceel opdelen in homogene zones voor besluitvorming

### calculate\_nutrient\_rate\_as\_active\_ingredients\_per\_zone

```python
# opties voor doelnutriënt
target_nutrient_option1 = 50 # constant getal
# OF
target_nutrient_option2 = {1: 20, 2: 40} # dict per zone
# OF
target_nutrient_option3 = np.array([[1, 1], [2, 3]], dtype=float) # doorlopende rasterlaag

# opties voor toegepaste nutriëntenbewerkingen
applied_operations = [
    5,                                      # operatie1 als constant getal
    {1: 2, 2: 4},                           # operatie2 als dict per zone
    np.array([[1, 1], [2, 3]], dtype=float) # operatie3 als doorlopende rasterlaag
]

# gebruik
rates_as_active_ingredients = geopard.calculate_nutrient_rate_as_active_ingredients_per_zone(
    zone_map, 
    target_nutrient, 
    plant_available_soil_nutrient, 
    applied_nutrient_operations = applied_operations # of []
)
```

Deze functie berekent de vereiste nutriënten-toedieningshoeveelheid (werkzame stof) voor elke beheerszone.

De berekening is gebaseerd op:

* een doelnutriëntenniveau,
* beschikbare nutriëntenvoorraad uit de bodem voor de plant,
* nutriënten die al zijn toegediend via eerdere bewerkingen (mest, kunstmest, digestaat, enz.).

Toegepaste nutriëntenbewerkingen kunnen worden opgegeven als constanten, waarden per zone, rasterlagen of elke combinatie daarvan. Alle invoer wordt automatisch opgelost en per zone geaggregeerd.

Standaard wordt de vereiste hoeveelheid berekend als het verschil tussen het doelnutriëntenniveau en de som van de bodemvoorraad en de toegediende nutriënten. Het resultaat wordt geretourneerd als een rasterkaart waarin elke zone een uniforme nutriëntenhoeveelheid bevat.

### convert\_active\_ingredient\_and\_product

```python
# conversiecoëfficiënt van werkzame stof naar product en omgekeerd
corrected_coefficient = 1.5  # constante coëfficiënt
# OF
corrected_coefficient = np.array([[np.nan, 5], [np.nan, 1]], dtype=float)  # coëfficiënten per pixel

# gebruik
rates_as_products = geopard.convert_active_ingredient_and_product(
    layer, 
    corrected_coefficient
)
```

Deze functie zet een rasterlaag om tussen **hoeveelheden werkzame stof en producthoeveelheden** met behulp van een correctiecoëfficiënt.

De `corrected_coefficient` kan een enkele **float** (toegepast op alle pixels) zijn of een coëfficiënten **matrix** (conversie per pixel). Het wordt doorgaans gebruikt om berekende nutriëntenbehoeften (werkzame stof) om te zetten in werkelijke producttoedieningshoeveelheden, of omgekeerd, op basis van meststofsamenstelling of nutriëntenconcentratie.

De conversie wordt per pixel toegepast, waarbij de ruimtelijke structuur van de oorspronkelijke laag behouden blijft.

**Typische toepassingsgevallen**

* Nutriëntenhoeveelheden omzetten naar meststofproducthoeveelheden
* Toedieningskaarten aanpassen op basis van nutriëntenconcentratie
* Definitieve voorschriftkaarten voorbereiden voor machines

### estimate\_texture\_class\_based\_on\_usda

```python
usda_texture = geopard.estimate_texture_class_based_on_usda(
    sand_pct_layer,
    silt_pct_layer,
    clay_pct_layer
)
```

Deze functie schat voor elke pixel de USDA-bodemtextuur met behulp van percentages zand, silt en klei.

Geef drie rasterlagen in procenten (0-100) die de deeltjesfractie weergeven. De uitvoer is <mark style="background-color:green;">USDA-klassenamen zoals</mark> *<mark style="background-color:green;">sand, loamy\_sand, sandy\_loam, loam, silt\_loam, sandy\_clay\_loam, clay\_loam, silty\_clay\_loam, silty\_clay, of undefined</mark>* <mark style="background-color:green;">wanneer de invoer ongeldig is.</mark>

### estimate\_texture\_class\_based\_on\_fao\_wrb

```python
fao_wrb_texture = geopard.estimate_texture_class_based_on_fao_wrb(
    sand_pct_layer,
    silt_pct_layer,
    clay_pct_layer
)
```

Deze functie schat de FAO/WRB (ISO 11277) bodemtextuurklasse voor elke pixel op basis van percentages zand, silt en klei.

Geef drie rasterlagen in procenten (0-100) die de deeltjesfractie weergeven. De uitvoer is <mark style="background-color:green;">FAO/WRB-klassecodes zoals</mark> *<mark style="background-color:green;">S, LS, SL, L, SiL, Si, SCL, CL, SiCL, SC, SiC, C, HC, of undefined</mark>* <mark style="background-color:green;">wanneer de invoer ongeldig is</mark>.

### calculate\_soil\_bulk\_density

```python
bulk_density = geopard.calculate_soil_bulk_density(texture_class_layer, som_pct_layer)
```

Deze functie berekent <mark style="background-color:green;">de bodemvolumieke massa (g/cm³) op basis van textuurklasse en optionele bodemorganische stof (SOM)</mark>.

De `texture_class_layer` moet klassebenamingen of codes bevatten die zijn gegenereerd door de [USDA-textuurfunctie](#estimate_texture_class_based_on_usda) of de [FAO/WRB-textuurfunctie](#estimate_texture_class_based_on_fao_wrb) hierboven vermeld.

Als `som_pct_layer` als procentwaarde wordt opgegeven, past de functie de volumieke massa aan met behulp van SOM. Anders retourneert het bodemvolumieke-massawaarden in g/cm³ die zijn gekoppeld aan textuurklassen volgens de USDA- of FAO/WRB-opzoeking.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.geopard.tech/geopard-tutorials/nl/producttour-webapp/analyse-op-basis-van-vergelijkingen/catalogus-van-aangepaste-functies.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
