> 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/pt-br/tour-do-produto-aplicativo-web/equation-based-analytics/catalog-of-custom-functions.md).

# Catálogo de Funções Personalizadas

Essas funções encapsulam código Python complexo, permitindo implementar manipulações e cálculos de dados sofisticados com facilidade.

O GeoPard oferece um catálogo abrangente de funções personalizadas projetadas para melhorar a legibilidade e a funcionalidade de análises baseadas em equações. Essas funções encapsulam operações complexas `python` de código, permitindo implementar manipulações e cálculos sofisticados de dados com facilidade.

### Inserir equação

<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>Insira uma equação</p></figcaption></figure>

A lista de funções pré-criadas disponíveis para criar equações mais intuitivas e fáceis de manter no GeoPard está incluída no pacote `geopard` :

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

```python
# input_data é uma camada de atributo do Dataset (por exemplo, Yield, NDVI)
filled_layer = geopard.fill_gaps_with_k_neighbors(yield_layer, k=5)
```

Esta função recupera dados ausentes ou zeros em um conjunto de dados usando o algoritmo K-Neighbors. Ao especificar a variável `input_data` (como Dataset com o atributo selecionado) e o número de vizinhos `k`, você pode preencher valores ausentes com facilidade, garantindo a continuidade e a integridade dos dados.

Esta função funciona bem quando as lacunas nos dados estão distribuídas pelo campo e não se concentram em uma parte específica dos limites do campo.

### determine\_data\_similarity

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

Use esta função para calcular a similaridade por pixel entre dois Datasets. As variáveis `data_layer_1` e `data_layer_2` devem representar a **mesma medição** nas **mesmas unidades** para garantir uma comparação significativa. Ao fornecer variáveis `data_layer_1` e `data_layer_2` associadas a Datasets, você pode gerar um mapa de similaridade com valores de 0 a 1, facilitando estudos comparativos e o reconhecimento de padrões.

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

Use esta função para calcular a similaridade por pixel entre dois conjuntos de dados normalizados. A normalização é recomendada quando os dados originais de `data_layer_1` e `data_layer_2` têm escalas ou unidades diferentes. Ao fornecer esses conjuntos de dados como entrada, a função gera um mapa de similaridade com valores de 0 a 1, adequado para estudos comparativos, reconhecimento de padrões e análise de consistência espacial.

### determine\_low\_high\_similarity

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

Esta função avalia a similaridade entre dois Datasets em termos de valores baixos e altos. Ao inserir as variáveis `data_layer_1` e `data_layer_2` associadas a Datasets, você obtém um mapa de similaridade categorizado que indica combinações como baixo-baixo, baixo-alto, alto-baixo e alto-alto, útil para uma classificação de dados mais detalhada.

### get\_value\_for\_zone

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

Use esta função para extrair todos os valores de um atributo de Dataset dentro de uma única zona. Forneça `data_layer` (a camada de atributo), `zones_layer` (o mapa de zonas) e `zone_id` (o número da zona) para isolar valores para análise, como produtividade, taxa de aplicação ou taxa de semeadura, dentro dessa zona.

### drop\_value

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

Esta função permite remover valores específicos de um atributo do conjunto de dados. Ao especificar `data_layer` e `value_to_drop`, você pode limpar o conjunto de dados eliminando esses valores do resultado, substituindo-os tecnicamente por `NaN`.

### normalize\_data

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

Normalize um atributo do conjunto de dados com esta função. Ao passar `data_layer`, você pode dimensionar os dados para um intervalo padronizado de 0 a 1, facilitando a comparação e a integração entre diferentes conjuntos de dados.

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

Calcule o total de fertilizante aplicado em unidades por área (por exemplo, em kg/ha, l/ha, gal/ac etc.) com esta função. Forneça `application_list` conjuntos de dados com atributos AppliedRate e a lista correspondente de `active_ingredient_coefficient_list` com os produtos fertilizantes para obter o total efetivamente aplicado em unidades (por exemplo, em 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)
```

Calcule o total de nitrogênio aplicado em kg/ha com esta função. Forneça `application_list` conjuntos de dados com atributos AppliedRate e a lista correspondente de `active_ingredient_coefficient_list` com produtos nitrogenados para converter a quantidade efetiva de nitrogênio em kg/ha, permitindo calcular com precisão o total de nitrogênio aplicado, essencial para o planejamento agrícola e as avaliações de sustentabilidade. A saída é usada como `N_total_applied` em[`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
)
```

Determine a absorção de nitrogênio em kg/ha com esta função. Forneça `yield_wet_tha`, `moisture_pct`, `protein_pct` do conjunto de dados de produtividade e `protein_crop_correction_coefficient` representando a proteína de ligação à absorção de nitrogênio, você pode avaliar a eficiência do uso de nitrogênio na produção agrícola. A saída é usada como `N_uptake` em[`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)
```

Avalie a eficiência do uso de nitrogênio como porcentagem usando esta função. Ao inserir [`N_total_applied`](#calculate_total_applied_nitrogen) e [`N_uptake`](#calculate_nitrogen_uptake) como variáveis (de funções anteriores), você pode medir a eficácia da aplicação de nitrogênio, ajudando a otimizar o uso de fertilizantes.

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

Calcule os custos totais com base nas taxas de aplicação e nos preços usando esta função. Ao fornecer uma `application_rate_list` de conjuntos de dados com os atributos AppliedRate e uma `price_per_unit_list` correspondente, você pode agregar as despesas relacionadas a diversas atividades agrícolas, contribuindo para a gestão do orçamento e o planejamento financeiro. A saída é usada como `costs` em[`geopard.calculate_profit`](#calculate_profit).

### calculate\_revenue

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

Calcule a receita a partir do conjunto de dados de produtividade usando esta função. Ao inserir `yield_as_mass` associado ao atributo Yield do conjunto de dados de produtividade e o `yield_price_per_unit`, você pode estimar a renda gerada pela produção agrícola, facilitando as avaliações econômicas. A saída é usada como `costs` em[`geopard.calculate_profit`](#calculate_profit) .

### calculate\_profit

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

Determine o lucro subtraindo os custos da receita usando esta função. Ao fornecer a [`revenue`](#calculate_revenue) e [`costs`](#calculate_costs) como variáveis (de funções anteriores), você pode calcular facilmente o ganho financeiro das operações agrícolas, contribuindo para a análise de rentabilidade e a tomada de decisões estratégicas.

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

Esta função filtra valores dentro de um intervalo especificado no array `input` . Ao fornecer o `input` array, juntamente com o opcional `min_value` e o opcional `max_value` limites, você pode isolar valores que estejam dentro do intervalo desejado. O parâmetro `value_to_fill` permite substituir valores fora do intervalo por um valor especificado, aprimorando os processos de filtragem e normalização de dados.

### calculate\_per\_pixel\_mae

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

Use esta função para calcular o Erro Absoluto Médio (MAE) por pixel entre dois conjuntos de dados. Ela fornece um mapa espacial das diferenças absolutas. A “diferença absoluta” é simplesmente o tamanho da distância entre os valores dos pixels correspondentes, independentemente de um ser maior ou menor que o outro.

A função ajuda a identificar áreas com discrepâncias maiores.

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

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

Esta função calcula o desvio relativo de cada pixel entre dois conjuntos de dados, expressando a diferença como uma porcentagem do valor em `dataset_1`. Em essência, ela mostra quanto o valor de um pixel se desvia do valor correspondente em `dataset_1` em termos proporcionais.

Essa abordagem é particularmente útil ao analisar variações nas propriedades do solo, na produtividade das culturas ou em dados de sensoriamento remoto, pois ajuda a identificar rapidamente áreas com diferenças proporcionais significativas.

### calculate\_difference

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

Esta função subtrai um conjunto de dados de outro para criar um mapa de diferenças. Ela destaca as áreas em que os valores de um conjunto são maiores ou menores que os do outro, facilitando a identificação de tendências e mudanças ao longo do tempo.

Esta ferramenta é especialmente útil para visualizar variações nas propriedades do solo, na produtividade das culturas ou em dados de sensoriamento remoto, ajudando a identificar rapidamente áreas que podem exigir análises ou intervenções adicionais.

### calculate\_relative\_difference

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

Esta função calcula a diferença relativa de cada pixel normalizando a diferença entre os conjuntos de dados com os valores de `dataset_2`. Isso mostra a importância da mudança em relação à magnitude de `dataset_2`.

Essa comparação proporcional é especialmente útil ao trabalhar com conjuntos de dados de escalas diferentes, pois ajuda a revelar variações relativas nas propriedades do solo, na produtividade das culturas ou nos dados de sensores. Essa abordagem ajuda a localizar áreas com variações relevantes.

### calculate\_normalized\_difference

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

Esta função calcula a diferença normalizada de cada pixel, escalando ambos os conjuntos de dados em relação ao valor máximo global. Esse processo torna os conjuntos de dados diretamente comparáveis, mesmo que originalmente tenham intervalos diferentes.

O mapa resultante oferece uma visão clara das variações nas propriedades do solo, na produtividade das culturas e nos dados de sensoriamento remoto, permitindo identificar e avaliar rapidamente as diferenças mais importantes.

### build\_zones\_by\_intervals

```python
# intervalos para zoneamento
intervals = [
    (4, 8),
    (8, 12),
    (12, 16)
]

# exemplo de uso
zones = geopard.build_zones_by_intervals(
    layer, 
    intervals
)
```

Esta função cria um mapa de zonas de manejo classificando uma camada raster contínua em zonas discretas com base em intervalos de valores definidos pelo usuário.

Cada intervalo define uma zona, e cada pixel é atribuído à zona correspondente ao intervalo de valores em que se enquadra. Pixels que não correspondam a nenhum intervalo recebem o valor -1.

Essa abordagem de zoneamento é comumente usada para transformar mapas de produtividade, propriedades do solo ou índices de sensoriamento remoto em zonas de manejo acionáveis para aplicações em taxa variável.

**Casos de uso comuns**

* Criação de zonas de manejo a partir de camadas de produtividade, NDVI ou solo
* Preparação de mapas de zonas para cálculos de taxas de aplicação de nutrientes ou de semeadura
* Divisão de talhões em zonas homogêneas para apoiar a tomada de decisões

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

```python
# opções de target_nutrient
target_nutrient_option1 = 50 # número constante
# OU
target_nutrient_option2 = {1: 20, 2: 40} # dicionário por zona
# OU
target_nutrient_option3 = np.array([[1, 1], [2, 3]], dtype=float) # camada raster contínua

# opções de applied_nutrient_operations
applied_operations = [
    5,                                      # operação1 como número constante
    {1: 2, 2: 4},                           # operação2 como dicionário por zona
    np.array([[1, 1], [2, 3]], dtype=float) # operação3 como camada raster contínua
]

# exemplo de uso
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 # ou []
)
```

Esta função calcula a taxa necessária de aplicação de nutrientes (ingrediente ativo) para cada zona de manejo.

O cálculo se baseia em:

* um nível-alvo de nutrientes,
* o fornecimento de nutrientes disponíveis para as plantas pelo solo,
* os nutrientes já aplicados em operações anteriores (esterco, fertilizantes, digestato etc.).

As operações de aplicação de nutrientes podem ser fornecidas como constantes, valores por zona, camadas raster ou qualquer combinação desses formatos. Todas as entradas são automaticamente interpretadas e agregadas por zona.

Por padrão, a taxa necessária é calculada como a diferença entre o nível-alvo de nutrientes e a soma do fornecimento pelo solo com os nutrientes aplicados. O resultado é retornado como um mapa raster, no qual cada zona apresenta uma taxa uniforme de nutrientes.

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

```python
# coeficiente de conversão entre ingrediente ativo e produto, e vice-versa
corrected_coefficient = 1.5  # coeficiente constante
# OU
corrected_coefficient = np.array([[np.nan, 5], [np.nan, 1]], dtype=float)  # coeficientes por pixel

# exemplo de uso
rates_as_products = geopard.convert_active_ingredient_and_product(
    layer, 
    corrected_coefficient
)
```

Esta função converte uma camada raster entre **taxas de ingrediente ativo e taxas de produto** usando um coeficiente de correção.

O `corrected_coefficient` pode ser um único valor **float** (aplicado a todos os pixels) ou uma **matriz** de coeficientes (conversão por pixel). Ela é normalmente usada para converter as necessidades calculadas de nutrientes (ingrediente ativo) em taxas reais de aplicação de produtos, ou vice-versa, com base na composição do fertilizante ou na concentração de nutrientes.

A conversão é aplicada pixel a pixel, preservando a estrutura espacial da camada original.

**Casos de uso comuns**

* Conversão de taxas de nutrientes em taxas de produtos fertilizantes
* Ajuste de mapas de aplicação com base na concentração de nutrientes
* Preparação dos mapas de prescrição finais para as máquinas

### map\_value\_by\_zone

```python
# atribuir um valor a todas as zonas
planned_yield = geopard.map_value_by_zone(
    zone_map,
    3.0
)

# OU: atribuir valores diferentes por zona
planned_yield = geopard.map_value_by_zone(
    zone_map,
    {1: 2.91, 2: 3.0, 3: 3.06}
)

# OU: agregar um raster existente por zona
p_zone_median = geopard.map_value_by_zone(
    zone_map,
    p2o5,
    aggregation_logic="median"
)
```

Esta função converte valores escalares, dicionários específicos por zona ou camadas raster em um raster baseado em zonas.

Cada pixel válido recebe o valor atribuído à sua zona correspondente. Para entradas raster, os valores são agregados dentro de cada zona usando `média`, `mediana`, `mínimo`, ou `máximo`, removendo efetivamente a variabilidade dentro da zona.

Valores ausentes no dicionário e pixels nodata recebem o valor especificado `default` (NaN por padrão).

**Casos de uso comuns**

* Criar metas de produtividade planejada por pixel a partir de valores específicos por zona
* Converter recomendações de fertilizantes específicas por zona em rasters de prescrição
* Achatar a variabilidade dos nutrientes do solo dentro das zonas de manejo
* Preparar parâmetros por zona para cálculos NumPy por pixel

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

```python
# calcular a dose de fertilizante 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
)
```

Esta função calcula as taxas de aplicação de fertilizantes por pixel com base no balanço entre a remoção de nutrientes pela cultura e o fornecimento de nutrientes pelo solo.

O cálculo considera a produtividade planejada, a remoção de nutrientes pela cultura, os nutrientes disponíveis no solo, os coeficientes de aproveitamento pelo solo e pelo fertilizante e os fatores de correção. A necessidade resultante de ingrediente ativo pode ser convertida opcionalmente em taxas de aplicação do produto fertilizante comercial usando `product_nutrient_share`.

Aceita valores escalares, dicionários ou rasters de produtividade planejada. Os valores de nutrientes do solo podem ser usados por pixel ou agregados por zona. As taxas finais podem ser limitadas por valores mínimos e máximos de aplicação e arredondadas para números inteiros.

**Casos de uso comuns**

* Gerar prescrições de fertilizantes com taxa variável de P₂O₅ e K₂O
* Calcular a reposição de nutrientes com base na produtividade planejada da cultura
* Considerar o fornecimento de nutrientes pelo solo e a eficiência de uso do fertilizante
* Converter as necessidades de ingrediente ativo em taxas de aplicação do produto comercial
* Gerar mapas de prescrição de fertilizantes prontos para uso em máquinas

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

Esta função estima a textura do solo segundo o USDA para cada pixel, usando as porcentagens de areia, silte e argila.

Forneça três camadas raster em porcentagem (0-100) que representem as frações granulométricas. A saída consiste em <mark style="background-color:green;">nomes de classes do USDA, como</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;">quando as entradas forem inválidas.</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
)
```

Esta função estima a classe textural do solo segundo a FAO/WRB (ISO 11277) para cada pixel, com base nas porcentagens de areia, silte e argila.

Forneça três camadas raster em porcentagem (0-100) que representem as frações granulométricas. A saída consiste em <mark style="background-color:green;">códigos de classe da FAO/WRB, como</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;">quando as entradas forem inválidas</mark>.

### calculate\_soil\_bulk\_density

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

Esta função calcula a <mark style="background-color:green;">densidade aparente do solo (g/cm³) com base na classe textural e no teor opcional de matéria orgânica do solo (SOM)</mark>.

A `texture_class_layer` deve conter nomes de classes ou códigos gerados pela função de textura da [USDA](#estimate_texture_class_based_on_usda) ou pela função de textura da [FAO/WRB](#estimate_texture_class_based_on_fao_wrb) mencionada acima.

Se `som_pct_layer` for fornecida como um valor percentual, a função ajustará a densidade aparente usando a SOM. Caso contrário, ela retornará valores de densidade aparente do solo em g/cm³ associados às classes de textura, de acordo com a tabela de consulta da USDA ou da 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/pt-br/tour-do-produto-aplicativo-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.
