> 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/in/product-tour-web-app/equation-based-analytics/catalog-of-custom-functions.md).

# कस्टम फ़ंक्शनों का कैटलॉग

ये फ़ंक्शन जटिल Python कोड को समेटते हैं, जिससे आप आसान तरीके से उन्नत डेटा मैनिपुलेशन और गणनाएँ कर सकते हैं।

GeoPard समीकरण-आधारित विश्लेषणों को पढ़ने और इस्तेमाल करने में आसान बनाने के लिए कस्टम फ़ंक्शन की एक विस्तृत सूची प्रदान करता है। ये फ़ंक्शन जटिल `python` कोड को अपने भीतर समेटते हैं, जिससे आप आसानी से डेटा में जटिल बदलाव और गणनाएँ कर सकते हैं।

### समीकरण दर्ज करें

<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>एक समीकरण दर्ज करें</p></figcaption></figure>

GeoPard में अधिक सहज और आसानी से बनाए रखे जा सकने वाले समीकरण बनाने के लिए उपलब्ध पहले से बने फ़ंक्शन की सूची `geopard` पैकेज में शामिल है:

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

```python
# input_data एक Dataset की एट्रिब्यूट लेयर है (जैसे, उपज, NDVI)
filled_layer = geopard.fill_gaps_with_k_neighbors(yield_layer, k=5)
```

यह फ़ंक्शन K-Neighbors एल्गोरिदम का उपयोग करके डेटासेट में डेटा के खाली स्थानों या शून्य मानों को भरता है। `input_data` वेरिएबल (चुने गए एट्रिब्यूट वाले Dataset के रूप में) और पड़ोसी बिंदुओं की संख्या `k`निर्दिष्ट करके आप अनुपलब्ध मान आसानी से भर सकते हैं और डेटा की निरंतरता और अखंडता बनाए रख सकते हैं।

यह फ़ंक्शन तब अच्छी तरह काम करता है जब डेटा के खाली स्थान पूरे खेत में फैले हों और खेत की सीमा के किसी एक हिस्से तक सीमित न हों।

### determine\_data\_similarity

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

दो Dataset के बीच प्रत्येक पिक्सेल की समानता की गणना करने के लिए इस फ़ंक्शन का उपयोग करें। सार्थक तुलना के लिए वेरिएबल `data_layer_1` और `data_layer_2` में **एक ही माप** को **एक ही इकाई** में दर्शाया जाना चाहिए। `data_layer_1` और `data_layer_2` Dataset से जुड़े वेरिएबल देने पर आप 0 से 1 तक के मानों वाला समानता मानचित्र बना सकते हैं, जिससे तुलनात्मक अध्ययन और पैटर्न पहचानने में मदद मिलती है।

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

दो सामान्यीकृत डेटासेट के बीच प्रत्येक पिक्सेल की समानता की गणना करने के लिए इस फ़ंक्शन का उपयोग करें। जब मूल `data_layer_1` और `data_layer_2` के पैमाने या इकाइयाँ अलग-अलग हों, तो सामान्यीकरण की सलाह दी जाती है। इन डेटासेट को इनपुट के रूप में देने पर फ़ंक्शन 0 से 1 तक के मानों वाला समानता मानचित्र बनाता है। यह तुलनात्मक अध्ययन, पैटर्न पहचानने और स्थानिक संगति के विश्लेषण के लिए उपयोगी है।

### determine\_low\_high\_similarity

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

यह फ़ंक्शन दो Dataset के बीच निम्न-उच्च समानता का आकलन करता है। Dataset से जुड़े वेरिएबल `data_layer_1` और `data_layer_2` को इनपुट देने पर आपको एक वर्गीकृत समानता मानचित्र मिलता है, जो निम्न-निम्न, निम्न-उच्च, उच्च-निम्न और उच्च-उच्च जैसे संयोजन दिखाता है। यह डेटा के विस्तृत वर्गीकरण के लिए उपयोगी है।

### get\_value\_for\_zone

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

किसी एक ज़ोन के भीतर Dataset के एट्रिब्यूट से सभी मान निकालने के लिए इस फ़ंक्शन का उपयोग करें। `data_layer` (एट्रिब्यूट लेयर) दें, `zones_layer` (ज़ोन का मानचित्र), और `zone_id` (ज़ोन संख्या) का इस्तेमाल करके विश्लेषण के लिए उस ज़ोन के अंदर के मान अलग करें, जैसे उपज, अनुप्रयोग दर या बीज दर।

### drop\_value

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

यह फ़ंक्शन आपको डेटासेट एट्रिब्यूट से खास मान हटाने देता है। `data_layer` और `value_to_drop`निर्दिष्ट करके, आप परिणाम से उन मानों को हटाकर डेटासेट को साफ़ कर सकते हैं; तकनीकी रूप से उनकी जगह `NaN`.

### normalize\_data

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

इस फ़ंक्शन से डेटासेट एट्रिब्यूट को सामान्यीकृत करें। `data_layer`देकर, आप डेटा को 0 से 1 की मानकीकृत सीमा में स्केल कर सकते हैं, जिससे अलग-अलग डेटासेट की तुलना और उन्हें एकीकृत करना आसान हो जाता है।

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

इस फ़ंक्शन से प्रति क्षेत्रफल इकाई में कुल डाले गए उर्वरक की गणना करें (उदाहरण के लिए, kg/ha, l/ha, gal/ac आदि में)। `application_list` AppliedRate एट्रिब्यूट वाले डेटासेट `active_ingredient_coefficient_list` और उर्वरक उत्पादों के गुणांक देकर, डाले गए उर्वरक की वास्तविक कुल मात्रा इकाइयों में (उदाहरण के लिए, kg, l, gal आदि) प्राप्त करें।

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

इस फ़ंक्शन से डाले गए कुल नाइट्रोजन की गणना kg/ha में करें। `application_list` AppliedRate एट्रिब्यूट वाले डेटासेट `active_ingredient_coefficient_list` और नाइट्रोजन उत्पादों के गुणांक देकर, वास्तविक नाइट्रोजन को kg/ha में बदलें। इससे आप डाले गए कुल नाइट्रोजन की सटीक गणना कर सकते हैं, जो कृषि योजना और टिकाऊपन के आकलन के लिए ज़रूरी है। आउटपुट का उपयोग `N_total_applied` को[`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
)
```

इस फ़ंक्शन से नाइट्रोजन अवशोषण की गणना kg/ha में करें। `yield_wet_tha`, `moisture_pct`, `protein_pct` उपज डेटासेट से और `protein_crop_correction_coefficient` नाइट्रोजन के अवशोषण से जुड़े प्रोटीन को दर्शाकर, आप फसल उत्पादन में नाइट्रोजन उपयोग दक्षता का आकलन कर सकते हैं। आउटपुट का उपयोग इस रूप में किया जाता है `N_uptake` में[`geopard.calculate_nitrogen_use_efficiency`](#calculate_nitrogen_use_efficiency) .

### नाइट्रोजन\_उपयोग\_दक्षता\_गणना\_करें

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

इस फ़ंक्शन का उपयोग करके नाइट्रोजन उपयोग दक्षता का प्रतिशत के रूप में मूल्यांकन करें। [`N_total_applied`](#calculate_total_applied_nitrogen) और [`N_uptake`](#calculate_nitrogen_uptake) चर (पिछले फ़ंक्शनों से) डालकर, आप नाइट्रोजन के इस्तेमाल की प्रभावशीलता माप सकते हैं और उर्वरक के उपयोग को बेहतर बनाने में मदद पा सकते हैं।

### लागत\_गणना\_करें

```python
rates = [seed_rate, fertilizer_rate]
prices = [1.2, 0.8]  # प्रत्येक दर लेयर की प्रति इकाई कीमत
costs = geopard.calculate_costs(rates, prices)
```

इस फ़ंक्शन का उपयोग करके आवेदन दरों और कीमतों के आधार पर कुल लागत की गणना करें। `application_rate_list` AppliedRate विशेषताओं वाले डेटासेट की सूची `price_per_unit_list`देकर, आप खेती की विभिन्न गतिविधियों से जुड़े खर्चों का कुल जोड़ निकाल सकते हैं। इससे बजट प्रबंधन और वित्तीय योजना बनाने में मदद मिलती है। आउटपुट का उपयोग इस रूप में किया जाता है `costs` में[`geopard.calculate_profit`](#calculate_profit).

### राजस्व\_गणना\_करें

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

इस फ़ंक्शन का उपयोग करके उपज डेटासेट से राजस्व की गणना करें। `yield_as_mass` उपज डेटासेट की विशेषता से जुड़ा `yield_price_per_unit`देकर, आप फसल उत्पादन से होने वाली आय का अनुमान लगा सकते हैं, जिससे आर्थिक मूल्यांकन में मदद मिलती है। आउटपुट का उपयोग इस रूप में किया जाता है `costs` में[`geopard.calculate_profit`](#calculate_profit) .

### लाभ\_गणना\_करें

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

इस फ़ंक्शन का उपयोग करके राजस्व में से लागत घटाकर लाभ निर्धारित करें। [`revenue`](#calculate_revenue) और [`costs`](#calculate_costs) चर (पिछले फ़ंक्शनों से) देकर, आप अपने खेती के कामकाज से होने वाले वित्तीय लाभ की आसानी से गणना कर सकते हैं। इससे लाभप्रदता का विश्लेषण और रणनीतिक निर्णय लेने में मदद मिलती है।

### दायरे\_के\_लिए\_मान\_भरें

```python
# केवल 10 और 20 के बीच के मान रखें, बाकी को 0 से बदलें
filtered = geopard.fill_value_for_range(layer, min_value=10, max_value=20, value_to_fill=0)
```

यह फ़ंक्शन निर्दिष्ट दायरे के भीतर आने वाले मानों को छाँटता है `input` ऐरे में। `input` ऐरे के साथ वैकल्पिक `min_value` और वैकल्पिक `max_value` थ्रेशहोल्ड, आप वांछित सीमा में आने वाले मानों को अलग कर सकते हैं। `value_to_fill` पैरामीटर सीमा से बाहर के मानों को किसी निर्दिष्ट मान से बदलने की सुविधा देता है, जिससे डेटा फ़िल्टर करने और सामान्यीकृत करने की प्रक्रियाएँ बेहतर होती हैं।

### calculate\_per\_pixel\_mae

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

दो डेटासेट के बीच प्रत्येक पिक्सेल के लिए माध्य निरपेक्ष त्रुटि (MAE) निकालने हेतु इस फ़ंक्शन का उपयोग करें। यह निरपेक्ष अंतरों का स्थानिक मानचित्र देता है। “निरपेक्ष अंतर” का अर्थ है संबंधित पिक्सेल मानों के बीच के अंतर का परिमाण—इस बात की परवाह किए बिना कि कौन-सा मान अधिक या कम है।

यह फ़ंक्शन उन क्षेत्रों की पहचान करने में मदद करता है जहाँ विसंगतियाँ अधिक हैं।

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

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

यह फ़ंक्शन दो डेटासेट के प्रत्येक पिक्सेल का सापेक्ष विचलन निकालता है और अंतर को `dataset_1`के मान के प्रतिशत के रूप में दर्शाता है। मूलतः, यह दिखाता है कि एक पिक्सेल का मान संबंधित मान से कितना विचलित है `dataset_1` आनुपातिक रूप में।

मिट्टी के गुणों, फसल की उपज या रिमोट सेंसिंग डेटा में बदलावों का विश्लेषण करते समय यह तरीका विशेष रूप से उपयोगी है, क्योंकि इससे आप आनुपातिक रूप से बड़े अंतर वाले क्षेत्रों को जल्दी पहचान सकते हैं।

### calculate\_difference

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

यह फ़ंक्शन एक डेटासेट को दूसरे से घटाकर अंतर का मानचित्र बनाता है। यह उन क्षेत्रों को दर्शाता है जहाँ एक डेटासेट के मान दूसरे की तुलना में अधिक या कम हैं, जिससे समय के साथ रुझानों और बदलावों को पहचानना आसान होता है।

मिट्टी के गुणों, फसल की उपज या रिमोट सेंसिंग डेटा में बदलावों को दिखाने के लिए यह टूल खास तौर पर उपयोगी है। इससे आप उन क्षेत्रों की जल्दी पहचान कर सकते हैं जहाँ आगे विश्लेषण या हस्तक्षेप की ज़रूरत हो सकती है।

### calculate\_relative\_difference

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

यह फ़ंक्शन डेटासेट के बीच के अंतर को `dataset_2`के मानों से सामान्यीकृत करके प्रत्येक पिक्सेल का सापेक्ष अंतर निकालता है। इसका अर्थ है कि यह दिखाता है कि बदलाव, `dataset_2`.

के परिमाण की तुलना में कितना महत्वपूर्ण है। अलग-अलग पैमानों वाले डेटासेट पर काम करते समय यह आनुपातिक तुलना विशेष रूप से उपयोगी होती है। इससे मिट्टी के गुणों, फसल की उपज या सेंसर आउटपुट में सापेक्ष बदलाव सामने आते हैं और उल्लेखनीय भिन्नता वाले क्षेत्रों की पहचान करने में मदद मिलती है।

### calculate\_normalized\_difference

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

यह फ़ंक्शन दोनों डेटासेट को उनके वैश्विक अधिकतम मान के आधार पर स्केल करके प्रत्येक पिक्सेल का सामान्यीकृत अंतर निकालता है। इससे मूल सीमाएँ अलग-अलग होने पर भी डेटासेट की सीधे तुलना की जा सकती है।

परिणामी मानचित्र मिट्टी के गुणों, फसल की उपज और रिमोट सेंसिंग डेटा में भिन्नताओं का स्पष्ट दृश्य देता है, जिससे आप प्रमुख अंतरों की तुरंत पहचान और आकलन कर सकते हैं।

### build\_zones\_by\_intervals

```python
# ज़ोन बनाने के लिए अंतराल
intervals = [
    (4, 8),
    (8, 12),
    (12, 16)
]

# उपयोग
zones = geopard.build_zones_by_intervals(
    layer, 
    intervals
)
```

यह फ़ंक्शन उपयोगकर्ता द्वारा तय किए गए मान-अंतरालों के आधार पर सतत रास्टर लेयर को अलग-अलग ज़ोन में वर्गीकृत करके प्रबंधन ज़ोन का मानचित्र बनाता है।

हर अंतराल एक ज़ोन निर्धारित करता है, और प्रत्येक पिक्सेल को उस ज़ोन में रखा जाता है जिसकी मान-सीमा में वह आता है। किसी भी अंतराल से मेल न खाने वाले पिक्सेल को -1 चिह्नित किया जाता है।

उपज मानचित्रों, मिट्टी के गुणों या रिमोट सेंसिंग सूचकांकों को परिवर्तनशील दर से किए जाने वाले कामों के लिए उपयोगी प्रबंधन ज़ोन में बदलने हेतु इस ज़ोनिंग तरीके का आम तौर पर उपयोग किया जाता है।

**सामान्य उपयोग**

* उपज, NDVI या मिट्टी की लेयर से प्रबंधन ज़ोन बनाना
* पोषक तत्वों की मात्रा या बीज दर की गणना के लिए ज़ोन मानचित्र तैयार करना
* निर्णय लेने के लिए खेतों को एकसमान ज़ोन में बाँटना

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

```python
# target_nutrient के विकल्प
target_nutrient_option1 = 50 # स्थिर संख्या
# या
target_nutrient_option2 = {1: 20, 2: 40} # हर ज़ोन के लिए डिक्शनरी
# या
target_nutrient_option3 = np.array([[1, 1], [2, 3]], dtype=float) # सतत रास्टर लेयर

# applied_nutrient_operations के विकल्प
applied_operations = [
    5,                                      # operation1 एक स्थिर संख्या के रूप में
    {1: 2, 2: 4},                           # operation2 ज़ोन के अनुसार डिक्शनरी के रूप में
    np.array([[1, 1], [2, 3]], dtype=float) # operation3 सतत रास्टर लेयर के रूप में
]

# उपयोग
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 # या []
)
```

यह फ़ंक्शन हर प्रबंधन ज़ोन के लिए आवश्यक पोषक तत्व की आवेदन दर (सक्रिय घटक के रूप में) की गणना करता है।

यह गणना इन बातों पर आधारित है:

* लक्षित पोषक तत्व का स्तर,
* मिट्टी से पौधों को उपलब्ध पोषक तत्वों की आपूर्ति,
* पिछले कार्यों में पहले से डाले गए पोषक तत्व (गोबर की खाद, उर्वरक, डाइजेस्टेट आदि)।

डाले गए पोषक तत्वों के कार्यों को स्थिर मानों, ज़ोन के अनुसार मानों, रास्टर लेयरों या इनके किसी भी संयोजन के रूप में दिया जा सकता है। सभी इनपुट अपने-आप हल करके हर ज़ोन के लिए एकत्रित किए जाते हैं।

डिफ़ॉल्ट रूप से, आवश्यक दर की गणना लक्षित पोषक तत्व के स्तर और मिट्टी से मिलने वाली आपूर्ति तथा पहले से डाले गए पोषक तत्वों के कुल योग के अंतर के रूप में की जाती है। परिणाम रास्टर मानचित्र के रूप में लौटाया जाता है, जिसमें हर ज़ोन के लिए पोषक तत्व की एक समान दर होती है।

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

```python
# सक्रिय घटक से उत्पाद और इसके उलट रूपांतरण का गुणांक
corrected_coefficient = 1.5  # स्थिर गुणांक
# या
corrected_coefficient = np.array([[np.nan, 5], [np.nan, 1]], dtype=float)  # प्रति-पिक्सेल गुणांक

# उपयोग
rates_as_products = geopard.convert_active_ingredient_and_product(
    layer, 
    corrected_coefficient
)
```

यह फ़ंक्शन सुधार गुणांक का उपयोग करके रास्टर लेयर को इन दोनों के बीच रूपांतरित करता है: **सक्रिय घटक की दरें और उत्पाद की दरें** ।

corrected\_coefficient `corrected_coefficient` एक अकेला **float** (जो सभी पिक्सेल पर लागू होता है) या एक गुणांक **मैट्रिक्स** (जो प्रति-पिक्सेल रूपांतरण करता है) हो सकता है। इसका उपयोग आम तौर पर उर्वरक की संरचना या पोषक तत्वों की सांद्रता के आधार पर, गणना की गई पोषक तत्वों की ज़रूरतों (सक्रिय घटक के रूप में) को उत्पाद की वास्तविक आवेदन दरों में बदलने, या इसके उलट करने के लिए किया जाता है।

यह रूपांतरण पिक्सेल-दर-पिक्सेल लागू होता है और मूल लेयर की स्थानिक संरचना को बनाए रखता है।

**सामान्य उपयोग**

* पोषक तत्वों की दरों को उर्वरक उत्पाद की दरों में बदलना
* पोषक तत्वों की सांद्रता के आधार पर आवेदन मानचित्रों में बदलाव करना
* कृषि मशीनरी के लिए अंतिम प्रिस्क्रिप्शन मानचित्र तैयार करना

### map\_value\_by\_zone

```python
# सभी ज़ोन को एक मान दें
planned_yield = geopard.map_value_by_zone(
    zone_map,
    3.0
)

# या: हर ज़ोन को अलग-अलग मान दें
planned_yield = geopard.map_value_by_zone(
    zone_map,
    {1: 2.91, 2: 3.0, 3: 3.06}
)

# या: किसी मौजूदा रास्टर को ज़ोन के अनुसार एकत्रित करें
p_zone_median = geopard.map_value_by_zone(
    zone_map,
    p2o5,
    aggregation_logic="median"
)
```

यह फ़ंक्शन संख्यात्मक मानों, ज़ोन-विशिष्ट डिक्शनरी या रास्टर लेयरों को ज़ोन-आधारित रास्टर में बदलता है।

हर मान्य पिक्सेल को उसके संबंधित ज़ोन का निर्धारित मान मिलता है। रास्टर इनपुट के लिए, हर ज़ोन के भीतर मानों का एकत्रीकरण इस विधि से किया जाता है: `mean`, `median`, `min`या `max`जिससे ज़ोन के भीतर की परिवर्तनशीलता प्रभावी रूप से समाप्त हो जाती है।

शब्दकोश में अनुपलब्ध मानों और nodata पिक्सेल को निर्दिष्ट `default` (डिफ़ॉल्ट रूप से NaN)।

**सामान्य उपयोग**

* ज़ोन-विशिष्ट मानों से पिक्सेल-स्तर के नियोजित उपज लक्ष्य बनाना
* ज़ोन-विशिष्ट उर्वरक अनुशंसाओं को प्रिस्क्रिप्शन रास्टर में बदलना
* प्रबंधन ज़ोन के भीतर मृदा पोषक तत्वों की परिवर्तनशीलता को समतल करना
* पिक्सेल-वार NumPy गणनाओं के लिए ज़ोन-स्तरीय पैरामीटर तैयार करना

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

```python
# calculate commercial fertilizer dose
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
)
```

यह फ़ंक्शन फसल द्वारा पोषक तत्वों के निष्कासन और मिट्टी से पोषक तत्वों की आपूर्ति के संतुलन के आधार पर, प्रत्येक पिक्सेल के लिए उर्वरक डालने की मात्रा की गणना करता है।

इस गणना में नियोजित उपज, फसल द्वारा पोषक तत्वों का निष्कासन, मिट्टी में उपलब्ध पोषक तत्व, मिट्टी और उर्वरक उपयोग गुणांक तथा सुधार कारक शामिल होते हैं। सक्रिय घटक की परिणामी आवश्यकता को वैकल्पिक रूप से वाणिज्यिक उर्वरक उत्पाद की मात्रा में बदला जा सकता है, इसके लिए `product_nutrient_share`.

यह नियोजित उपज के लिए स्केलर, शब्दकोश या रास्टर मानों का समर्थन करता है। मिट्टी के पोषक तत्वों के मान प्रति पिक्सेल इस्तेमाल किए जा सकते हैं या ज़ोन के आधार पर एकत्र किए जा सकते हैं। अंतिम मात्रा को न्यूनतम और अधिकतम डालने की सीमाओं के भीतर रखा जा सकता है और पूर्ण संख्याओं में राउंड किया जा सकता है।

**सामान्य उपयोग**

* परिवर्ती-दर P₂O₅ और K₂O उर्वरक प्रिस्क्रिप्शन तैयार करना
* नियोजित फसल उपज के आधार पर पोषक तत्वों की भरपाई की गणना करना
* मिट्टी से पोषक तत्वों की आपूर्ति और उर्वरक उपयोग दक्षता को ध्यान में रखना
* सक्रिय घटक की आवश्यकता को वाणिज्यिक उत्पाद की डालने की मात्रा में बदलना
* मशीनरी में इस्तेमाल के लिए तैयार उर्वरक प्रिस्क्रिप्शन मानचित्र बनाना

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

यह फ़ंक्शन रेत, गाद और चिकनी मिट्टी के प्रतिशत के आधार पर हर पिक्सेल के लिए USDA मृदा बनावट का अनुमान लगाता है।

कण-आकार अंशों को दर्शाने वाली तीन रास्टर परतें प्रतिशत (0-100) में दें। आउटपुट में <mark style="background-color:green;">USDA वर्ग के नाम शामिल होते हैं, जैसे</mark> *<mark style="background-color:green;">sand, loamy\_sand, sandy\_loam, loam, silt\_loam, sandy\_clay\_loam, clay\_loam, silty\_clay\_loam, silty\_clay, या undefined</mark>* <mark style="background-color:green;">यदि इनपुट अमान्य हों।</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
)
```

यह फ़ंक्शन रेत, गाद और चिकनी मिट्टी के प्रतिशत के आधार पर हर पिक्सेल के लिए FAO/WRB (ISO 11277) मृदा बनावट वर्ग का अनुमान लगाता है।

कण-आकार अंशों को दर्शाने वाली तीन रास्टर परतें प्रतिशत (0-100) में दें। आउटपुट में <mark style="background-color:green;">FAO/WRB वर्ग कोड शामिल होते हैं, जैसे</mark> *<mark style="background-color:green;">S, LS, SL, L, SiL, Si, SCL, CL, SiCL, SC, SiC, C, HC, या undefined</mark>* <mark style="background-color:green;">यदि इनपुट अमान्य हों</mark>.

### calculate\_soil\_bulk\_density

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

यह फ़ंक्शन गणना करता है <mark style="background-color:green;">बनावट वर्ग और वैकल्पिक मृदा जैविक पदार्थ (SOM) के आधार पर मृदा का आयतन घनत्व (g/cm³)।</mark>.

यह `texture_class_layer` में इनके द्वारा बनाए गए मृदा बनावट वर्गों के नाम या कोड होने चाहिए: [USDA बनावट फ़ंक्शन](#estimate_texture_class_based_on_usda) या [FAO/WRB बनावट फ़ंक्शन](#estimate_texture_class_based_on_fao_wrb) जिनका ऊपर उल्लेख किया गया है।

यदि `som_pct_layer` को प्रतिशत मान के रूप में दिया जाता है, तो फ़ंक्शन SOM के आधार पर थोक घनत्व को समायोजित करता है। अन्यथा, यह USDA या FAO/WRB लुकअप के अनुसार बनावट वर्गों से जुड़े मृदा के थोक घनत्व के मान g/cm³ में लौटाता है।


---

# 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/in/product-tour-web-app/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.
