> 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/ro/tur-de-produs-aplicatia-web/equation-based-analytics/catalog-of-custom-functions.md).

# Catalog de funcții personalizate

Aceste funcții încorporează cod Python complex, permițându-ți să implementezi cu ușurință transformări și calcule sofisticate de date.

GeoPard oferă un catalog cuprinzător de funcții personalizate, concepute pentru a îmbunătăți lizibilitatea și funcționalitatea analizelor bazate pe ecuații. Aceste funcții încapsulează operații complexe `python` în cod, permițându-vă să efectuați cu ușurință manipulări și calcule sofisticate asupra datelor.

### Introduceți ecuația

<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>Introduceți o ecuație</p></figcaption></figure>

Lista funcțiilor predefinite disponibile pentru crearea unor ecuații mai intuitive și mai ușor de întreținut în GeoPard este inclusă în pachetul `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)
```

Această funcție reface datele lipsă sau valorile zero dintr-un set de date folosind algoritmul K-Neighbors. Specificând variabila `input_data` (un set de date cu atributul selectat) și numărul de vecini `k`, puteți completa cu ușurință valorile lipsă, asigurând continuitatea și integritatea datelor.

Această funcție funcționează bine atunci când golurile din date sunt distribuite pe parcelă, nu concentrate într-o anumită zonă de la marginea acesteia.

### determine\_data\_similarity

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

Folosiți această funcție pentru a calcula similaritatea pixel cu pixel dintre două seturi de date. Variabilele `data_layer_1` și `data_layer_2` trebuie să reprezinte **aceeași măsurătoare** în **aceleași unități** pentru a asigura o comparație relevantă. Furnizând variabilele `data_layer_1` și `data_layer_2` asociate seturilor de date, puteți genera o hartă a similarității cu valori între 0 și 1, utilă pentru studii comparative și recunoașterea tiparelor.

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

Folosiți această funcție pentru a calcula similaritatea pixel cu pixel dintre două seturi de date normalizate. Se recomandă normalizarea atunci când variabilele originale `data_layer_1` și `data_layer_2` au scări sau unități diferite. Furnizând aceste seturi de date ca intrare, funcția generează o hartă a similarității cu valori între 0 și 1, potrivită pentru studii comparative, recunoașterea tiparelor și analiza coerenței spațiale.

### determine\_low\_high\_similarity

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

Această funcție evaluează similaritatea dintre valorile mici și mari din două seturi de date. Introducând variabilele `data_layer_1` și `data_layer_2` asociate seturilor de date, obțineți o hartă a similarității pe categorii, care indică combinații precum mic-mic, mic-mare, mare-mic și mare-mare, utilă pentru clasificarea detaliată a datelor.

### get\_value\_for\_zone

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

Folosiți această funcție pentru a extrage toate valorile unui atribut dintr-un set de date, pentru o singură zonă. Furnizați `data_layer` (stratul de atribute), `zones_layer` (harta zonelor) și `zone_id` (numărul zonei), pentru a izola valorile folosite în analiză, precum producția, rata de aplicare sau rata de însămânțare, din zona respectivă.

### drop\_value

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

Această funcție vă permite să eliminați anumite valori dintr-un atribut al setului de date. Specificând `data_layer` și `value_to_drop`, puteți curăța setul de date eliminând valorile respective din rezultat, înlocuindu-le, din punct de vedere tehnic, cu `NaN`.

### normalize\_data

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

Folosiți această funcție pentru a normaliza un atribut al setului de date. Transmițând `data_layer`, puteți scala datele la un interval standardizat de la 0 la 1, facilitând compararea și integrarea seturilor de date diferite.

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

Calculați cantitatea totală de îngrășământ aplicată pe unitatea de suprafață (de exemplu, în kg/ha, l/ha, gal/ac etc.). Furnizând `application_list` seturi de date cu atribute AppliedRate și lista corespunzătoare `active_ingredient_coefficient_list` pentru produsele fertilizante, puteți obține cantitatea totală reală de îngrășământ aplicată, exprimată în unități (de exemplu, 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)
```

Folosiți această funcție pentru a calcula cantitatea totală de azot aplicată, în kg/ha. Furnizând `application_list` seturi de date cu atribute AppliedRate și lista corespunzătoare `active_ingredient_coefficient_list` pentru produsele cu azot, puteți converti cantitatea efectivă de azot în kg/ha și calcula cu precizie cantitatea totală de azot aplicată, esențială pentru planificarea agricolă și evaluările sustenabilității. Rezultatul este utilizat ca `N_total_applied` în[`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
)
```

Folosiți această funcție pentru a determina absorbția de azot, în kg/ha. Furnizați `yield_wet_tha`, `moisture_pct`, `protein_pct` din setul de date privind producția și `protein_crop_correction_coefficient` reprezentând proteina de legătură cu absorbția azotului, puteți evalua eficiența utilizării azotului în producția agricolă. Rezultatul este folosit ca `N_uptake` în[`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)
```

Evaluați eficiența utilizării azotului ca procent cu ajutorul acestei funcții. Introducând variabilele [`N_total_applied`](#calculate_total_applied_nitrogen) și [`N_uptake`](#calculate_nitrogen_uptake) (obținute din funcțiile anterioare), puteți măsura eficiența aplicării azotului, contribuind la optimizarea utilizării îngrășămintelor.

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

Calculați costurile totale pe baza normelor de aplicare și a prețurilor cu ajutorul acestei funcții. Furnizând o `application_rate_list` cu seturi de date care au atributele AppliedRate și o listă corespunzătoare de `price_per_unit_list`, puteți însuma cheltuielile asociate diferitelor activități agricole, facilitând gestionarea bugetului și planificarea financiară. Rezultatul este folosit ca `costs` în[`geopard.calculate_profit`](#calculate_profit).

### calculate\_revenue

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

Calculați veniturile obținute din setul de date privind producția cu ajutorul acestei funcții. Introducând `yield_as_mass` asociat atributului Yield din setul de date privind producția și `yield_price_per_unit`, puteți estima veniturile generate de producția agricolă, facilitând evaluările economice. Rezultatul este folosit ca `costs` în[`geopard.calculate_profit`](#calculate_profit) .

### calculate\_profit

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

Determinați profitul scăzând costurile din venituri cu ajutorul acestei funcții. Furnizând variabilele [`revenue`](#calculate_revenue) și [`costs`](#calculate_costs) (obținute din funcțiile anterioare), puteți calcula cu ușurință câștigul financiar din activitățile agricole, sprijinind analiza rentabilității și luarea deciziilor strategice.

### fill\_value\_for\_range

```python
# keep only values between 10 and 20, replace the rest with 0
filtered = geopard.fill_value_for_range(layer, min_value=10, max_value=20, value_to_fill=0)
```

Această funcție filtrează valorile dintr-un interval specificat în matricea `input` . Furnizând matricea `input` împreună cu valorile opționale `min_value` și `max_value` praguri, puteți izola valorile care se încadrează în intervalul dorit. Parametrul `value_to_fill` permite înlocuirea valorilor din afara intervalului cu o valoare specificată, îmbunătățind procesele de filtrare și normalizare a datelor.

### calculate\_per\_pixel\_mae

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

Folosiți această funcție pentru a calcula eroarea medie absolută (MAE) pentru fiecare pixel dintre două seturi de date. Aceasta oferă o hartă spațială a diferențelor absolute. „Diferența absolută” reprezintă pur și simplu mărimea decalajului dintre valorile pixelilor corespunzători, fără a ține cont dacă una este mai mare sau mai mică decât cealaltă.

Funcția ajută la identificarea zonelor cu discrepanțe mai mari.

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

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

Această funcție calculează abaterea relativă pentru fiecare pixel dintre două seturi de date, exprimând diferența ca procent din valoarea din `dataset_1`. În esență, arată cât de mult se abate valoarea unui pixel față de valoarea corespunzătoare din `dataset_1` în termeni proporționali.

Această abordare este deosebit de utilă la analizarea variațiilor proprietăților solului, a randamentului culturilor sau a datelor de teledetecție, deoarece vă ajută să identificați rapid zonele cu diferențe proporționale semnificative.

### calculate\_difference

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

Această funcție scade un set de date din altul pentru a crea o hartă a diferențelor. Evidențiază zonele în care valorile dintr-un set de date sunt mai mari sau mai mici decât cele din celălalt, facilitând identificarea tendințelor și a schimbărilor în timp.

Acest instrument este deosebit de util pentru vizualizarea variațiilor proprietăților solului, a randamentului culturilor sau a datelor de teledetecție și vă ajută să identificați rapid zonele care ar putea necesita analize suplimentare sau intervenții.

### calculate\_relative\_difference

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

Această funcție calculează diferența relativă pentru fiecare pixel, normalizând diferența dintre seturile de date cu ajutorul valorilor din `dataset_2`. Astfel, arată cât de semnificativă este schimbarea în raport cu mărimea valorilor din `dataset_2`.

O astfel de comparație proporțională este deosebit de utilă când lucrați cu seturi de date de scări diferite, ajutând la evidențierea schimbărilor relative ale proprietăților solului, randamentelor culturilor sau valorilor înregistrate de senzori. Această abordare ajută la identificarea zonelor cu variații notabile.

### calculate\_normalized\_difference

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

Această funcție calculează diferența normalizată pentru fiecare pixel, raportând ambele seturi de date la valoarea lor maximă globală. Astfel, seturile de date pot fi comparate direct, chiar dacă inițial au avut intervale diferite.

Harta rezultată oferă o imagine clară a variațiilor proprietăților solului, randamentului culturilor și datelor de teledetecție, permițându-vă să identificați și să evaluați rapid diferențele importante.

### build\_zones\_by\_intervals

```python
# intervale pentru zonare
intervals = [
    (4, 8),
    (8, 12),
    (12, 16)
]

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

Această funcție creează o hartă a zonelor de management prin clasificarea unui strat raster continuu în zone discrete, pe baza intervalelor de valori definite de utilizator.

Fiecare interval definește o zonă, iar fiecărui pixel i se atribuie zona al cărei interval de valori îl cuprinde. Pixelii care nu se încadrează în niciun interval sunt marcați cu -1.

Această metodă de zonare este folosită frecvent pentru a transforma hărțile de randament, proprietățile solului sau indicii de teledetecție în zone de management aplicabile, în vederea aplicării cu rată variabilă.

**Cazuri de utilizare tipice**

* Crearea zonelor de management pe baza straturilor de randament, NDVI sau sol
* Pregătirea hărților zonale pentru calculul dozelor de nutrienți sau al normelor de semănat
* Împărțirea parcelelor în zone omogene pentru luarea deciziilor

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

```python
# opțiuni pentru target_nutrient
target_nutrient_option1 = 50 # număr constant
# SAU
target_nutrient_option2 = {1: 20, 2: 40} # dicționar per zonă
# SAU
target_nutrient_option3 = np.array([[1, 1], [2, 3]], dtype=float) # strat raster continuu

# opțiuni pentru applied_nutrient_operations
applied_operations = [
    5,                                      # operația1 ca număr constant
    {1: 2, 2: 4},                           # operația2 ca dicționar per zonă
    np.array([[1, 1], [2, 3]], dtype=float) # operația3 ca strat raster continuu
]

# utilizare
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 # sau []
)
```

Această funcție calculează rata necesară de aplicare a nutrienților (substanța activă) pentru fiecare zonă de management.

Calculul se bazează pe:

* nivelul-țintă de nutrienți,
* aportul de nutrienți din sol disponibili pentru plante,
* nutrienții aplicați deja prin operațiuni anterioare (gunoi de grajd, îngrășăminte, digestat etc.).

Operațiunile de aplicare a nutrienților pot fi furnizate ca valori constante, valori per zonă, straturi raster sau orice combinație a acestora. Toate intrările sunt procesate și agregate automat pentru fiecare zonă.

În mod implicit, rata necesară se calculează ca diferență dintre nivelul-țintă de nutrienți și suma aportului din sol și a nutrienților aplicați. Rezultatul este returnat ca hartă raster, în care fiecare zonă conține o rată uniformă de nutrienți.

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

```python
# coeficient de conversie între substanța activă și produs și invers
corrected_coefficient = 1.5  # coeficient constant
# SAU
corrected_coefficient = np.array([[np.nan, 5], [np.nan, 1]], dtype=float)  # coeficienți per pixel

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

Această funcție convertește un strat raster între **ratele substanței active și ratele produsului** folosind un coeficient de corecție.

Parametrul `corrected_coefficient` poate fi un singur **float** (aplicat tuturor pixelilor) sau o matrice de coeficienți **matrice** (conversie per pixel). Este folosit de obicei pentru a converti necesarul de nutrienți calculat (substanța activă) în rate efective de aplicare a produsului sau invers, în funcție de compoziția îngrășământului sau de concentrația de nutrienți.

Conversia se aplică pixel cu pixel, păstrând structura spațială a stratului original.

**Cazuri de utilizare tipice**

* Conversia ratelor de nutrienți în rate de aplicare a produsului fertilizant
* Ajustarea hărților de aplicare în funcție de concentrația de nutrienți
* Pregătirea hărților finale de prescripție pentru utilaje

### map\_value\_by\_zone

```python
# atribuie aceeași valoare tuturor zonelor
planned_yield = geopard.map_value_by_zone(
    zone_map,
    3.0
)

# SAU: atribuie valori diferite fiecărei zone
planned_yield = geopard.map_value_by_zone(
    zone_map,
    {1: 2.91, 2: 3.0, 3: 3.06}
)

# SAU: agregă un raster existent în funcție de zonă
p_zone_median = geopard.map_value_by_zone(
    zone_map,
    p2o5,
    aggregation_logic="median"
)
```

Această funcție convertește valori scalare, dicționare cu valori specifice zonelor sau straturi raster într-un raster bazat pe zone.

Fiecare pixel valid primește valoarea atribuită zonei corespunzătoare. Pentru intrările raster, valorile sunt agregate în fiecare zonă folosind `mean`, `median`, `min`sau `max`, eliminând efectiv variabilitatea din interiorul zonei.

Valorile lipsă din dicționar și pixelii nodata primesc valoarea specificată `default` (NaN în mod implicit).

**Cazuri de utilizare tipice**

* Crearea unor ținte de producție planificată la nivel de pixel, pornind de la valorile specifice zonelor
* Conversia recomandărilor de fertilizare specifice zonelor în rastere de prescriere
* Uniformizarea variabilității nutrienților din sol în interiorul zonelor de management
* Pregătirea parametrilor la nivel de zonă pentru calcule NumPy la nivel de pixel

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

```python
# calcularea dozei de îngrășământ comercial
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
)
```

Această funcție calculează dozele de aplicare a îngrășămintelor pentru fiecare pixel, pe baza echilibrului dintre extragerea nutrienților de către cultură și aportul de nutrienți din sol.

Calculul ia în considerare producția planificată, extragerea nutrienților de către cultură, nutrienții disponibili în sol, coeficienții de utilizare a solului și a îngrășământului, precum și factorii de corecție. Necesarul rezultat de substanță activă poate fi convertit opțional în doze de produs comercial folosind `product_nutrient_share`.

Sunt acceptate valori scalare, de tip dicționar sau raster pentru producția planificată. Valorile nutrienților din sol pot fi utilizate pentru fiecare pixel sau agregate pe zone. Dozele finale pot fi limitate la valori minime și maxime de aplicare și rotunjite la numere întregi.

**Cazuri de utilizare tipice**

* Generarea prescripțiilor de fertilizare cu doză variabilă pentru P₂O₅ și K₂O
* Calcularea cantității de nutrienți necesare pentru înlocuire în funcție de producția planificată a culturii
* Luarea în calcul a aportului de nutrienți din sol și a eficienței utilizării îngrășămintelor
* Conversia necesarului de substanță activă în doze de aplicare a produsului comercial
* Generarea hărților de prescriere a îngrășămintelor, gata de utilizare de către utilaje

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

Această funcție estimează textura solului conform USDA pentru fiecare pixel, folosind procentele de nisip, praf și argilă.

Furnizați trei straturi raster în procente (0-100), care reprezintă fracțiile granulometrice. Rezultatul este <mark style="background-color:green;">denumiri de clase USDA, precum</mark> *<mark style="background-color:green;">nisip, nisip lutos, lut nisipos, lut, lut prăfos, lut argilo-nisipos, lut argilos, lut argilo-prăfos, argilă prăfoasă sau nedefinit</mark>* <mark style="background-color:green;">atunci când intrările nu sunt valide.</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
)
```

Această funcție estimează clasa texturală a solului conform FAO/WRB (ISO 11277) pentru fiecare pixel, pe baza procentelor de nisip, praf și argilă.

Furnizați trei straturi raster în procente (0-100), care reprezintă fracțiile granulometrice. Rezultatul este <mark style="background-color:green;">coduri de clase FAO/WRB, precum</mark> *<mark style="background-color:green;">S, LS, SL, L, SiL, Si, SCL, CL, SiCL, SC, SiC, C, HC sau nedefinit</mark>* <mark style="background-color:green;">atunci când intrările nu sunt valide</mark>.

### calculate\_soil\_bulk\_density

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

Această funcție calculează <mark style="background-color:green;">densitatea aparentă a solului (g/cm³) pe baza clasei texturale și a conținutului opțional de materie organică din sol (SOM)</mark>.

Stratul `texture_class_layer` trebuie să conțină denumirile sau codurile claselor generate de funcția de clasificare a texturii USDA [funcția USDA pentru textura solului](#estimate_texture_class_based_on_usda) sau de [funcția FAO/WRB pentru textura solului](#estimate_texture_class_based_on_fao_wrb) menționată mai sus.

Dacă `som_pct_layer` este furnizat ca valoare procentuală, funcția ajustează densitatea aparentă în funcție de SOM. În caz contrar, returnează valorile densității aparente a solului în g/cm³ asociate claselor de textură, conform tabelului de corespondență USDA sau 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/ro/tur-de-produs-aplicatia-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.
