Katalog med anpassade funktioner

Dessa funktioner kapslar in komplex Python-kod, så att du enkelt kan implementera avancerad datamanipulering och beräkningar.

GeoPard erbjuder en omfattande katalog med anpassade funktioner som är utformade för att förbättra läsbarheten och funktionaliteten i ekvationsbaserad analys. Dessa funktioner kapslar in komplex python kod, vilket gör att du enkelt kan implementera avancerade datamanipulationer och beräkningar.

Ange ekvation

Ange en ekvation

Listan över tillgängliga färdigbyggda funktioner för att skapa mer intuitiva och lättunderhållna ekvationer i GeoPard finns i geopard paketet:

fill_gaps_with_k_neighbors

# input_data är ett dataset-attributlager (t.ex. skörd, NDVI)
filled_layer = geopard.fill_gaps_with_k_neighbors(yield_layer, k=5)

Den här funktionen återställer datagap eller nollor i ett dataset med hjälp av K-Neighbors-algoritmen. Genom att ange input_data variabeln (som Dataset med det valda attributet) och antalet grannar k, kan du sömlöst fylla i saknade värden och säkerställa datakontinuitet och integritet.

Den här funktionen fungerar bra när datagap är fördelade över fältet och inte är förlagda till någon särskild del av fältgränsen.

determine_data_similarity

similarity = geopard.determine_data_similarity(yield_2023, yield_2024)

Använd den här funktionen för att beräkna likheten per pixel mellan två Dataset. Variablerna data_layer_1 och data_layer_2 bör representera samma mätning i samma enheter för att säkerställa en meningsfull jämförelse. Genom att tillhandahålla variabler data_layer_1 och data_layer_2 kopplade till Dataset kan du skapa en likhetskarta med värden från 0 till 1, vilket underlättar jämförande studier och mönsterigenkänning.

determine_data_similarity_from_normalized

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)

Använd den här funktionen för att beräkna likheten per pixel mellan två normaliserade dataset. Normalisering rekommenderas när de ursprungliga data_layer_1 och data_layer_2 har olika skalor eller enheter. Genom att tillhandahålla dessa dataset som indata genererar funktionen en likhetskarta med värden från 0 till 1, vilket gör den lämplig för jämförande studier, mönsterigenkänning och analys av rumslig konsistens.

determine_low_high_similarity

zones = geopard.determine_low_high_similarity(soil_ph, yield_layer)

Den här funktionen bedömer likheten låg-hög mellan två Dataset. Genom att mata in variabler data_layer_1 och data_layer_2 kopplade till Dataset får du en kategoriserad likhetskarta som visar kombinationer som låg-låg, låg-hög, hög-låg och hög-hög, vilket är användbart för nyanserad dataklassificering.

get_value_for_zone

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

Använd den här funktionen för att extrahera alla värden från ett Dataset-attribut inom en enda zon. Ange data_layer (attributlagret), zones_layer (zonkartan), och zone_id (zonens nummer) för att isolera värden för analys, såsom skörd, giva eller utsädesmängd, inom den zonen.

drop_value

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

Den här funktionen låter dig ta bort specifika värden från ett dataset-attribut. Genom att ange data_layer och value_to_drop, kan du rensa datasetet genom att ta bort dessa värden från resultatet, tekniskt sett genom att ersätta dem med NaN.

normalize_data

ndvi_normalized = geopard.normalize_data(ndvi_layer)

Normalisera ett dataset-attribut med den här funktionen. Genom att ange data_layerkan du skala datan till ett standardiserat intervall från 0 till 1, vilket gör jämförelse och integrering mellan olika dataset enklare.

calculate_total_applied_fertilizer

applications = [urea_rate, map_rate]
coefficients = [1.0, 1.0]  # använd 1.0 för att behålla enheter, eller justera för produktkoncentration

total_applied = geopard.calculate_total_applied_fertilizer(applications, coefficients)

Beräkna den totala tillförda gödselmängden i enheter per area (till exempel kg/ha, l/ha, gal/ac osv.). Genom att ange application_list Dataset med AppliedRate-attribut och motsvarande active_ingredient_coefficient_list med gödselprodukter får du den faktiska totala tillförda gödselmängden i enheter (till exempel kg, l, gal osv.).

calculate_total_applied_nitrogen

applications = [urea_rate, uan_rate]
nitrogen_coefficients = [0.46, 0.32]  # N-fraktion (aktiv substans) i varje produkt

N_total_applied = geopard.calculate_total_applied_nitrogen(applications, nitrogen_coefficients)

Beräkna den totala tillförda kvävegivan i kg/ha med den här funktionen. Genom att ange application_list Dataset med AppliedRate-attribut och motsvarande active_ingredient_coefficient_list med kväveprodukter för att omvandla faktiskt kväve till kg/ha kan du noggrant beräkna total tillförd kvävegiva, vilket är viktigt för jordbruksplanering och hållbarhetsbedömningar. Resultatet används som N_total_applied igeopard.calculate_nitrogen_use_efficiency.

calculate_nitrogen_uptake

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
)

Bestäm kväveupptag i kg/ha med den här funktionen. Genom att tillhandahålla yield_wet_tha, moisture_pct, protein_pct från Yield-datasetet och protein_crop_correction_coefficient som representerar kopplingen mellan protein och kväveupptag kan du bedöma kväveanvändningseffektiviteten i grödproduktionen. Resultatet används som N_uptake igeopard.calculate_nitrogen_use_efficiency .

calculate_nitrogen_use_efficiency

NUE_pct = geopard.calculate_nitrogen_use_efficiency(N_total_applied, N_uptake)

Utvärdera kväveanvändningseffektiviteten som en procent med den här funktionen. Genom att mata in N_total_applied och N_uptake variabler (från tidigare funktioner) kan du mäta hur effektiv kvävegivan är, vilket hjälper till att optimera gödselanvändningen.

calculate_costs

rates = [seed_rate, fertilizer_rate]
prices = [1.2, 0.8]  # pris per enhet för varje givalager
costs = geopard.calculate_costs(rates, prices)

Beräkna totalkostnader baserat på givor och priser med den här funktionen. Genom att tillhandahålla en application_rate_list av Dataset med AppliedRate-attribut och en motsvarande price_per_unit_list, kan du summera kostnader kopplade till olika lantbruksåtgärder och stödja budgethantering och ekonomisk planering. Resultatet används som costs igeopard.calculate_profit.

calculate_revenue

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

Beräkna intäkt från Yield-datasetet med den här funktionen. Genom att ange yield_as_mass kopplat till attributet i Yield-datasetet och yield_price_per_unit, kan du uppskatta intäkter från grödproduktion och underlätta ekonomiska utvärderingar. Resultatet används som costs igeopard.calculate_profit .

calculate_profit

profit = geopard.calculate_profit(revenue, costs)

Bestäm vinst genom att subtrahera kostnader från intäkter med den här funktionen. Genom att tillhandahålla revenue och costs variablerna (från tidigare funktioner) kan du enkelt beräkna den ekonomiska vinsten från dina lantbruksoperationer, vilket stödjer lönsamhetsanalys och strategiskt beslutsfattande.

fill_value_for_range

# behåll bara värden mellan 10 och 20, ersätt resten med 0
filtered = geopard.fill_value_for_range(layer, min_value=10, max_value=20, value_to_fill=0)

Den här funktionen filtrerar värden inom ett angivet intervall i indata arrayen. Genom att tillhandahålla indata arrayen, tillsammans med valfria min_value och valfria max_value trösklar, kan du isolera värden som faller inom det önskade intervallet. Parametern value_to_fill gör det möjligt att ersätta värden utanför intervallet med ett angivet värde, vilket förbättrar processerna för datafiltrering och normalisering.

calculate_per_pixel_mae

mae_layer = geopard.calculate_per_pixel_mae(predicted_yield, observed_yield)

Använd den här funktionen för att beräkna medelabsolut fel (MAE) per pixel mellan två dataset. Den ger en rumslig karta över absoluta skillnader. "Absolut skillnad" är helt enkelt storleken på gapet mellan motsvarande pixelvärden, oavsett om det ena är högre eller lägre.

Funktionen hjälper till att identifiera områden med större avvikelser.

calculate_per_pixel_relative_deviation

relative_dev = geopard.calculate_per_pixel_relative_deviation(observed_yield, modeled_yield)

Den här funktionen beräknar den relativa avvikelsen för varje pixel mellan två dataset och uttrycker skillnaden som en procent av värdet i dataset_1. I praktiken visar den hur mycket en pixels värde avviker från motsvarande värde i dataset_1 i proportionella termer.

Det här tillvägagångssättet är särskilt värdefullt när man analyserar variationer i jordegenskaper, skörd eller fjärranalysdata, eftersom det hjälper dig att snabbt upptäcka områden med betydande proportionella skillnader.

calculate_difference

difference = geopard.calculate_difference(yield_2024, yield_2023)

Den här funktionen subtraherar ett dataset från ett annat för att skapa en differenskarta. Den lyfter fram områden där värdena i det ena datasetet är högre eller lägre jämfört med det andra, vilket gör det lättare att upptäcka trender och förändringar över tid.

Det här verktyget är särskilt användbart för att visualisera variationer i jordegenskaper, skörd eller fjärranalysdata och hjälper dig att snabbt identifiera områden som kan kräva vidare analys eller åtgärd.

calculate_relative_difference

relative_diff = geopard.calculate_relative_difference(yield_2024, yield_2023)

Den här funktionen beräknar den relativa skillnaden för varje pixel genom att normalisera skillnaden mellan dataset med värdena från dataset_2. Det betyder att den visar hur stor förändringen är i förhållande till storleken på dataset_2.

En sådan proportionell jämförelse är särskilt användbar när man arbetar med dataset av olika skala och hjälper till att synliggöra relativa skiften i jordegenskaper, skördar eller sensorsvar. Det här tillvägagångssättet hjälper till att identifiera områden med märkbar variation.

calculate_normalized_difference

normalized_diff = geopard.calculate_normalized_difference(layer_1, layer_2)

Den här funktionen beräknar den normaliserade skillnaden för varje pixel genom att skala båda dataset mot deras globala maxvärde. Den här processen gör dataset direkt jämförbara även om de ursprungligen har olika intervall.

Den resulterande kartan ger en tydlig bild av variationer i jordegenskaper, skörd och fjärranalysdata, så att du snabbt kan identifiera och bedöma viktiga skillnader.

build_zones_by_intervals

# intervall för zonindelning
intervals = [
    (4, 8),
    (8, 12),
    (12, 16)
]

# användning
zones = geopard.build_zones_by_intervals(
    layer, 
    intervals
)

Den här funktionen skapar en zonkarta för växtodlingsstyrning genom att klassificera ett kontinuerligt rasterlager i diskreta zoner baserat på användardefinierade värdeintervall.

Varje intervall definierar en zon, och varje pixel tilldelas den zon vars värdeintervall den hamnar i. Pixlar som inte matchar något intervall markeras som -1.

Det här zonindelningssättet används ofta för att omvandla skördekartor, jordegenskaper eller fjärranalysindex till åtgärdsbara styrzoner för variabel giva.

Typiska användningsområden

• Skapa styrzoner från skörd, NDVI eller jordlager

• Förbereda zonkartor för närings- eller utsädesgiva-beräkningar

• Dela in fält i homogena zoner för beslutsfattande

calculate_nutrient_rate_as_active_ingredients_per_zone

# alternativ för målnäring
target_nutrient_option1 = 50 # konstant tal
# ELLER
target_nutrient_option2 = {1: 20, 2: 40} # ordbok per zon
# ELLER
target_nutrient_option3 = np.array([[1, 1], [2, 3]], dtype=float) # kontinuerligt rasterlager

# alternativ för applied_nutrient_operations
applied_operations = [
    5,                                      # operation1 som konstant tal
    {1: 2, 2: 4},                           # operation2 som ordbok per zon
    np.array([[1, 1], [2, 3]], dtype=float) # operation3 som kontinuerligt rasterlager
]

# användning
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 # eller []
)

Den här funktionen beräknar den erforderliga näringsgivan (aktiv substans) för varje styrzon.

Beräkningen bygger på:

• en målnivå för näring,

• växttillgänglig näring från jorden,

• näring som redan tillförts genom tidigare åtgärder (stallgödsel, gödselmedel, biogasrest osv.).

Tillförda näringsåtgärder kan anges som konstanter, per-zon-värden, rasterlager eller valfri kombination av dessa. Alla indata löses automatiskt och summeras per zon.

Som standard beräknas den erforderliga givan som skillnaden mellan målnivån för näring och summan av jordens tillförsel och tillförd näring. Resultatet returneras som en rasterkarta där varje zon innehåller en enhetlig näringsgiva.

convert_active_ingredient_and_product

# omvandlingskoefficient mellan aktiv substans och produkt och vice versa
corrected_coefficient = 1.5  # konstant koefficient
# ELLER
corrected_coefficient = np.array([[np.nan, 5], [np.nan, 1]], dtype=float)  # koefficienter per pixel

# användning
rates_as_products = geopard.convert_active_ingredient_and_product(
    layer, 
    corrected_coefficient
)

Den här funktionen omvandlar ett rasterlager mellan givor av aktiv substans och produktgivor med hjälp av en korrigeringskoefficient.

Den corrected_coefficient kan vara en enda float (tillämpad på alla pixlar) eller en koefficient matris (omvandling per pixel). Den används vanligtvis för att översätta beräknade näringsbehov (aktiv substans) till faktiska produktgivor, eller tvärtom, baserat på gödselmedlets sammansättning eller näringskoncentration.

Omvandlingen tillämpas pixel för pixel och bevarar den ursprungliga lagrets rumsliga struktur.

Typiska användningsområden

• Omvandla näringsgivor till gödselproduktgivor

• Justera applikationskartor baserat på näringskoncentration

• Förbereda slutliga spridningskartor för maskiner

estimate_texture_class_based_on_usda

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

Den här funktionen uppskattar USDA:s jordtextur för varje pixel med hjälp av procentsatser för sand, silt och lera.

Ange tre rasterlager i procent (0-100) som representerar partikelstorleksfraktionerna. Utdata är USDA-klassnamn såsom sand, loamy_sand, sandy_loam, loam, silt_loam, sandy_clay_loam, clay_loam, silty_clay_loam, silty_clay, eller undefined när indata är ogiltiga.

estimate_texture_class_based_on_fao_wrb

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

Den här funktionen uppskattar FAO/WRB:s jordtexturklass (ISO 11277) för varje pixel baserat på procentsatser för sand, silt och lera.

Ange tre rasterlager i procent (0-100) som representerar partikelstorleksfraktionerna. Utdata är FAO/WRB-klasskoder såsom S, LS, SL, L, SiL, Si, SCL, CL, SiCL, SC, SiC, C, HC, eller undefined när indata är ogiltiga.

calculate_soil_bulk_density

bulk_density = geopard.calculate_soil_bulk_density(texture_class_layer, som_pct_layer)

Den här funktionen beräknar jordens skrymdensitet (g/cm³) baserat på texturklass och valfritt organiskt material i jorden (SOM).

Den texture_class_layer bör innehålla klassnamn eller koder som skapas av USDA-texturfunktionen eller FAO/WRB-texturfunktionen som nämns ovan.

Om som_pct_layer anges som ett procentvärde justerar funktionen skrymdensiteten med hjälp av SOM. Annars returnerar den värden för jordens skrymdensitet i g/cm³ kopplade till texturklasser enligt uppslagningen för USDA eller FAO/WRB.