> For the complete documentation index, see [llms.txt](https://docs.geopard.tech/geopard-tutorials/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.geopard.tech/geopard-tutorials/fr/visite-guidee-du-produit-application-web/equation-based-analytics/catalog-of-custom-functions.md).

# Catalogue de fonctions personnalisées

Ces fonctions encapsulent du code Python complexe, vous permettant de mettre en œuvre facilement des manipulations et calculs de données sophistiqués.

GeoPard propose un catalogue complet de fonctions personnalisées conçues pour améliorer la lisibilité et les fonctionnalités des analyses basées sur des équations. Ces fonctions encapsulent des opérations complexes en `python` code, ce qui vous permet de mettre en œuvre facilement des manipulations et des calculs sophistiqués sur les données.

### Saisir l’équation

<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>Saisissez une équation</p></figcaption></figure>

La liste des fonctions prédéfinies disponibles pour créer des équations plus intuitives et faciles à maintenir dans GeoPard figure dans le package `geopard` :

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

```python
# input_data is a Dataset attribute layer (e.g., Yield, NDVI)
filled_layer = geopard.fill_gaps_with_k_neighbors(yield_layer, k=5)
```

Cette fonction reconstitue les données manquantes ou les zéros d’un jeu de données à l’aide de l’algorithme des k plus proches voisins. En indiquant la variable `input_data` (un Dataset contenant l’attribut sélectionné) et le nombre de voisins `k`, vous pouvez combler facilement les valeurs manquantes et garantir la continuité et l’intégrité des données.

Cette fonction est particulièrement efficace lorsque les lacunes dans les données sont réparties dans la parcelle et ne se concentrent pas sur une partie précise de ses limites.

### determine\_data\_similarity

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

Utilisez cette fonction pour calculer la similarité pixel par pixel entre deux Datasets. Les variables `data_layer_1` et `data_layer_2` doivent représenter la **même mesure** dans les **mêmes unités** pour garantir une comparaison pertinente. En fournissant des variables `data_layer_1` et `data_layer_2` associées à des Datasets, vous pouvez générer une carte de similarité dont les valeurs vont de 0 à 1, afin de faciliter les études comparatives et la reconnaissance de motifs.

### 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)
```

Utilisez cette fonction pour calculer la similarité pixel par pixel entre deux jeux de données normalisés. La normalisation est recommandée lorsque les `data_layer_1` et `data_layer_2` d’origine ont des échelles ou des unités différentes. En fournissant ces jeux de données en entrée, la fonction génère une carte de similarité dont les valeurs vont de 0 à 1. Elle convient ainsi aux études comparatives, à la reconnaissance de motifs et à l’analyse de la cohérence spatiale.

### determine\_low\_high\_similarity

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

Cette fonction évalue la similarité faible ou forte entre deux Datasets. En saisissant les variables `data_layer_1` et `data_layer_2` associées à des Datasets, vous obtenez une carte de similarité classant les combinaisons — faible-faible, faible-forte, forte-faible et forte-forte —, utile pour une classification nuancée des données.

### get\_value\_for\_zone

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

Utilisez cette fonction pour extraire toutes les valeurs d’un attribut d’un Dataset dans une seule zone. Indiquez `data_layer` (la couche attributaire), `zones_layer` (la carte des zones), et `zone_id` (le numéro de zone) pour isoler les valeurs à analyser, comme le rendement, la dose d’application ou la dose de semis, à l’intérieur de cette zone.

### drop\_value

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

Cette fonction permet de supprimer des valeurs spécifiques d’un attribut de jeu de données. En indiquant `data_layer` et `value_to_drop`, vous pouvez nettoyer le jeu de données en éliminant ces valeurs du résultat, ce qui revient techniquement à les remplacer par `NaN`.

### normalize\_data

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

Normalisez un attribut de jeu de données à l’aide de cette fonction. En transmettant `data_layer`, vous pouvez ramener les données à une plage normalisée de 0 à 1, ce qui facilite leur comparaison et leur intégration avec différents jeux de données.

### calculate\_total\_applied\_fertilizer

```python
applications = [urea_rate, map_rate]
coefficients = [1.0, 1.0]  # use 1.0 to keep units, or adjust for product concentration

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

Calculez la quantité totale d’engrais appliquée par unité de surface (par exemple, en kg/ha, l/ha, gal/ac, etc.) avec cette fonction. Fournissez `application_list` des jeux de données comportant des attributs AppliedRate et la liste correspondante `active_ingredient_coefficient_list` associée aux produits fertilisants pour obtenir la quantité totale réelle d’engrais appliquée, exprimée en unités (par exemple, en kg, l, gal, etc.).

### calculate\_total\_applied\_nitrogen

```python
applications = [urea_rate, uan_rate]
nitrogen_coefficients = [0.46, 0.32]  # N fraction (active ingredient) in each product

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

Calculez la quantité totale d’azote appliquée en kg/ha à l’aide de cette fonction. Fournissez `application_list` des jeux de données comportant des attributs AppliedRate et la liste correspondante `active_ingredient_coefficient_list` associée aux produits azotés pour convertir la quantité réelle d’azote en kg/ha. Vous pouvez ainsi calculer avec précision la quantité totale d’azote appliquée, un élément essentiel à la planification agricole et à l’évaluation de la durabilité. Le résultat est utilisé comme `N_total_applied` dans[`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
)
```

Déterminez l’absorption d’azote en kg/ha à l’aide de cette fonction. Fournissez `yield_wet_tha`, `moisture_pct`, `protein_pct` provenant du jeu de données sur le rendement et `protein_crop_correction_coefficient` représentant la protéine de liaison à l’absorption de l’azote, vous pouvez évaluer l’efficacité d’utilisation de l’azote dans les cultures. Le résultat est utilisé comme `N_uptake` dans[`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)
```

Évaluez l’efficacité d’utilisation de l’azote en pourcentage à l’aide de cette fonction. En indiquant [`N_total_applied`](#calculate_total_applied_nitrogen) et [`N_uptake`](#calculate_nitrogen_uptake) comme variables (issues des fonctions précédentes), vous pouvez mesurer l’efficacité de l’apport d’azote et ainsi optimiser l’utilisation des engrais.

### calculate\_costs

```python
rates = [seed_rate, fertilizer_rate]
prices = [1.2, 0.8]  # price per unit for each rate layer
costs = geopard.calculate_costs(rates, prices)
```

Calculez les coûts totaux à partir des doses d’application et des prix avec cette fonction. En fournissant une `application_rate_list` liste de jeux de données comportant les attributs AppliedRate et une `price_per_unit_list`correspondante, vous pouvez totaliser les dépenses liées aux différentes activités agricoles, ce qui facilite la gestion du budget et la planification financière. Le résultat est utilisé comme `costs` dans[`geopard.calculate_profit`](#calculate_profit).

### calculate\_revenue

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

Calculez le revenu à partir du jeu de données de rendement à l’aide de cette fonction. En indiquant `yield_as_mass` associé à l’attribut Yield du jeu de données de rendement, ainsi que le `yield_price_per_unit`correspondant, vous pouvez estimer les revenus issus de la production agricole et faciliter les évaluations économiques. Le résultat est utilisé comme `costs` dans[`geopard.calculate_profit`](#calculate_profit) .

### calculate\_profit

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

Déterminez le bénéfice en soustrayant les coûts du revenu à l’aide de cette fonction. En fournissant les variables [`revenue`](#calculate_revenue) et [`costs`](#calculate_costs) (issues des fonctions précédentes), vous pouvez facilement calculer le gain financier de vos activités agricoles, afin d’analyser leur rentabilité et d’éclairer vos décisions stratégiques.

### fill\_value\_for\_range

```python
# ne conserver que les valeurs entre 10 et 20, remplacer les autres par 0
filtered = geopard.fill_value_for_range(layer, min_value=10, max_value=20, value_to_fill=0)
```

Cette fonction filtre les valeurs comprises dans une plage donnée du tableau `input` . Fournissez le tableau, ainsi que les paramètres facultatifs `input` et `min_value` facultatif `max_value` seuils, vous pouvez isoler les valeurs comprises dans la plage souhaitée. Le paramètre `value_to_fill` permet de remplacer les valeurs hors plage par une valeur spécifiée, améliorant ainsi le filtrage et la normalisation des données.

### calculate\_per\_pixel\_mae

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

Utilisez cette fonction pour calculer l’erreur absolue moyenne (MAE) par pixel entre deux jeux de données. Elle produit une carte spatiale des différences absolues. La « différence absolue » correspond simplement à l’écart entre les valeurs de pixels correspondantes, sans tenir compte du fait que l’une soit supérieure ou inférieure à l’autre.

Cette fonction aide à repérer les zones où les écarts sont plus importants.

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

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

Cette fonction calcule l’écart relatif pour chaque pixel entre deux jeux de données et exprime la différence en pourcentage de la valeur de `dataset_1`. Elle indique essentiellement dans quelle mesure la valeur d’un pixel s’écarte de la valeur correspondante de `dataset_1` en termes proportionnels.

Cette approche est particulièrement utile pour analyser les variations des propriétés du sol, du rendement des cultures ou des données de télédétection, car elle permet de repérer rapidement les zones présentant des différences proportionnelles importantes.

### calculate\_difference

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

Cette fonction soustrait un jeu de données d’un autre pour créer une carte des différences. Elle met en évidence les zones où les valeurs d’un jeu de données sont supérieures ou inférieures à celles de l’autre, ce qui facilite le repérage des tendances et des changements au fil du temps.

Cet outil est particulièrement utile pour visualiser les variations des propriétés du sol, du rendement des cultures ou des données de télédétection, et pour repérer rapidement les zones qui peuvent nécessiter une analyse ou une intervention supplémentaire.

### calculate\_relative\_difference

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

Cette fonction calcule la différence relative pour chaque pixel en normalisant la différence entre les jeux de données à l’aide des valeurs de `dataset_2`. Elle indique ainsi l’importance du changement par rapport à l’amplitude de `dataset_2`.

Cette comparaison proportionnelle est particulièrement utile lorsque l’on travaille avec des jeux de données d’échelles différentes. Elle permet de révéler les variations relatives des propriétés du sol, des rendements des cultures ou des mesures des capteurs, et de repérer les zones présentant des variations notables.

### calculate\_normalized\_difference

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

Cette fonction calcule la différence normalisée pour chaque pixel en rapportant les deux jeux de données à leur valeur maximale globale. Ainsi, les jeux de données deviennent directement comparables, même s’ils présentent initialement des plages de valeurs différentes.

La carte obtenue offre une vue claire des variations des propriétés du sol, du rendement des cultures et des données de télédétection, ce qui permet de repérer et d’évaluer rapidement les principales différences.

### build\_zones\_by\_intervals

```python
# intervalles pour le zonage
intervals = [
    (4, 8),
    (8, 12),
    (12, 16)
]

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

Cette fonction crée une carte de zones de gestion en classant une couche raster continue en zones distinctes, selon des intervalles de valeurs définis par l’utilisateur.

Chaque intervalle définit une zone, et chaque pixel est affecté à la zone dont la plage de valeurs le comprend. Les pixels qui ne correspondent à aucun intervalle reçoivent la valeur -1.

Cette méthode de zonage est couramment utilisée pour transformer des cartes de rendement, des données sur les propriétés du sol ou des indices de télédétection en zones de gestion exploitables pour les applications à taux variable.

**Cas d’utilisation courants**

* Créer des zones de gestion à partir de couches de rendement, de NDVI ou de propriétés du sol
* Préparer des cartes de zones pour calculer les doses d’apport d’éléments nutritifs ou les densités de semis
* Diviser les parcelles en zones homogènes pour faciliter la prise de décision

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

```python
# options pour target_nutrient
target_nutrient_option1 = 50 # nombre constant
# OU
target_nutrient_option2 = {1: 20, 2: 40} # dictionnaire par zone
# OU
target_nutrient_option3 = np.array([[1, 1], [2, 3]], dtype=float) # couche raster continue

# options pour applied_nutrient_operations
applied_operations = [
    5,                                      # operation1 as constant number
    {1: 2, 2: 4},                           # operation2 as per-zone dict
    np.array([[1, 1], [2, 3]], dtype=float) # operation3 as continuous raster layer
]

# utilisation
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 # or []
)
```

Cette fonction calcule le taux d’application requis en éléments fertilisants (matière active) pour chaque zone de gestion.

Le calcul est basé sur :

* un niveau cible en éléments fertilisants,
* l’apport d’éléments fertilisants disponibles pour les plantes provenant du sol,
* les éléments fertilisants déjà apportés lors d’opérations précédentes (fumier, engrais, digestat, etc.).

Les opérations d’apport d’éléments fertilisants peuvent être fournies sous forme de constantes, de valeurs par zone, de couches raster ou de toute combinaison de ces formats. Toutes les entrées sont automatiquement traitées et agrégées par zone.

Par défaut, le taux requis est calculé comme la différence entre le niveau cible en éléments fertilisants et la somme des apports du sol et des éléments déjà apportés. Le résultat est renvoyé sous forme de carte raster où chaque zone présente un taux uniforme d’apport d’éléments fertilisants.

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

```python
# conversion coefficient active_ingredient to product and vice versa
corrected_coefficient = 1.5  # constant coefficient
# OU
corrected_coefficient = np.array([[np.nan, 5], [np.nan, 1]], dtype=float)  # per-pixel coefficients

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

Cette fonction convertit une couche raster entre les **taux de matière active et les taux de produit** à l’aide d’un coefficient de correction.

Le `corrected_coefficient` peut être un **float** unique (appliqué à tous les pixels) ou une matrice de coefficients **matrix** (conversion par pixel). Il sert généralement à convertir les besoins calculés en éléments fertilisants (matière active) en doses réelles de produit à épandre, ou inversement, en fonction de la composition de l’engrais ou de la concentration en éléments fertilisants.

La conversion est appliquée pixel par pixel, tout en préservant la structure spatiale de la couche d’origine.

**Cas d’utilisation courants**

* Conversion des doses d’éléments fertilisants en doses de produits fertilisants
* Ajustement des cartes d’épandage en fonction de la concentration en éléments fertilisants
* Préparation des cartes de préconisation finales pour les machines agricoles

### map\_value\_by\_zone

```python
# assign one value to all zones
planned_yield = geopard.map_value_by_zone(
    zone_map,
    3.0
)

# OR: assign different values per zone
planned_yield = geopard.map_value_by_zone(
    zone_map,
    {1: 2.91, 2: 3.0, 3: 3.06}
)

# OR: aggregate an existing raster by zone
p_zone_median = geopard.map_value_by_zone(
    zone_map,
    p2o5,
    aggregation_logic="median"
)
```

Cette fonction convertit des valeurs scalaires, des dictionnaires propres à chaque zone ou des couches raster en un raster par zone.

Chaque pixel valide reçoit la valeur attribuée à sa zone. Pour les données raster, les valeurs sont agrégées dans chaque zone selon la `mean`, `median`, `min`ou la `max`, ce qui élimine efficacement la variabilité au sein de la zone.

Les valeurs manquantes du dictionnaire et les pixels nodata reçoivent la valeur `default` (NaN par défaut).

**Cas d’utilisation courants**

* Créer des objectifs de rendement prévisionnel à l’échelle du pixel à partir de valeurs propres à chaque zone
* Convertir les recommandations de fertilisation propres à chaque zone en rasters de préconisation
* Uniformiser la variabilité des éléments nutritifs du sol au sein des zones de gestion
* Préparer les paramètres par zone pour les calculs NumPy pixel par pixel

### calculate\_dose\_by\_nutrient\_balance

```python
# calculer la dose d’engrais commercial
ammophos_dose = geopard.calculate_dose_by_nutrient_balance(
    zone_map,
    planned_yield={1: 2.91, 2: 3.0, 3: 3.06},
    soil_nutrient=p2o5,
    removal_per_yield_unit=12.5,
    soil_use_coefficient=0.2,
    fertilizer_use_coefficient=0.4,
    correction_coefficient=1.5,
    product_nutrient_share=0.46,
    min_dose=50,
    max_dose=100
)
```

Cette fonction calcule les doses d’application d’engrais par pixel en équilibrant les prélèvements d’éléments nutritifs par la culture et leur apport par le sol.

Le calcul prend en compte le rendement prévisionnel, les prélèvements d’éléments nutritifs par la culture, les éléments nutritifs disponibles dans le sol, les coefficients d’utilisation du sol et de l’engrais, ainsi que les facteurs de correction. Le besoin en substance active obtenu peut éventuellement être converti en doses d’application d’un engrais commercial à l’aide de `product_nutrient_share`.

Prend en charge les rendements prévisionnels sous forme de scalaire, de dictionnaire ou de raster. Les valeurs des éléments nutritifs du sol peuvent être utilisées par pixel ou agrégées par zone. Les doses finales peuvent être limitées par des seuils minimal et maximal et arrondies à l’entier.

**Cas d’utilisation courants**

* Générer des cartes de préconisation d’engrais à dose variable en P₂O₅ et K₂O
* Calculer le remplacement des éléments nutritifs en fonction du rendement prévisionnel de la culture
* Tenir compte de l’apport en éléments nutritifs du sol et de l’efficacité d’utilisation des engrais
* Convertir les besoins en substance active en doses d’application d’engrais commerciaux
* Générer des cartes de préconisation d’engrais prêtes à l’emploi pour les machines agricoles

### 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
)
```

Cette fonction estime la texture du sol selon la classification USDA pour chaque pixel, à partir des pourcentages de sable, de limon et d’argile.

Fournissez trois couches raster exprimées en pourcentage (0-100), représentant les fractions granulométriques. La sortie correspond à <mark style="background-color:green;">des noms de classes USDA, tels que</mark> *<mark style="background-color:green;">sand, loamy\_sand, sandy\_loam, loam, silt\_loam, sandy\_clay\_loam, clay\_loam, silty\_clay\_loam, silty\_clay, ou undefined</mark>* <mark style="background-color:green;">si les données d’entrée ne sont pas valides.</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
)
```

Cette fonction estime la classe de texture du sol FAO/WRB (ISO 11277) pour chaque pixel à partir des pourcentages de sable, de limon et d’argile.

Fournissez trois couches raster exprimées en pourcentage (0-100), représentant les fractions granulométriques. La sortie correspond à <mark style="background-color:green;">des codes de classes FAO/WRB, tels que</mark> *<mark style="background-color:green;">S, LS, SL, L, SiL, Si, SCL, CL, SiCL, SC, SiC, C, HC ou undefined</mark>* <mark style="background-color:green;">si les données d’entrée ne sont pas valides</mark>.

### calculate\_soil\_bulk\_density

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

Cette fonction calcule <mark style="background-color:green;">la densité apparente du sol (g/cm³) à partir de la classe de texture et, facultativement, de la matière organique du sol (MOS)</mark>.

La couche `texture_class_layer` doit contenir les noms ou les codes de classe produits par la fonction de texture de l’ [USDA](#estimate_texture_class_based_on_usda) ou par la fonction de texture de la [FAO/WRB](#estimate_texture_class_based_on_fao_wrb) mentionnée ci-dessus.

Si `som_pct_layer` est fourni sous forme de valeur en pourcentage, la fonction ajuste la densité apparente en fonction de la matière organique du sol (MOS). Sinon, elle renvoie les valeurs de densité apparente du sol, en g/cm³, associées aux classes de texture selon la table de correspondance de l’USDA ou de la FAO/WRB.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

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

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.geopard.tech/geopard-tutorials/fr/visite-guidee-du-produit-application-web/equation-based-analytics/catalog-of-custom-functions.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
