QGIS2.x से QGIS3.x के संक्रमण के साथ, पूरे प्रसंस्करण ढांचे को फिर से काम किया गया है और इसके बड़े हिस्से अब C ++ कक्षाओं के रूप में चलते हैं जिन्हें आप पायथन का उपयोग करके बातचीत कर सकते हैं। दुर्भाग्य से डेटा / डेटासेट IO के लिए सरल पैरामीटर सिंटैक्स अब मान्य नहीं हैं। नई पैरामीटर संरचना बिलिन (पायथन-) प्रसंस्करण एल्गोरिदम के बाद बहुत अधिक उन्मुख है जो आपको टूलबॉक्स में पूर्वस्थापित मिलती है।
जैसा कि मैंने देखा, आपने पहले ही @underdark द्वारा नई एल्गोरिथ्म संरचना का वर्णन किया है। लेकिन अपनी आवश्यकताओं (रेखापुंज परतों, डबल इनपुट, आदि) के लिए इस संरचना को समायोजित करने के लिए आपको स्क्रिप्ट में कई स्थानों पर कोड को बदलना होगा। मैंने आपके लिए एक संक्षिप्त विवरण के साथ एक मोटे उदाहरण को कोडित किया है (सिर्फ @ एल्गोरिदम उदाहरण के आधार पर एक एल्गोरिथ्म कंकाल):
from qgis.PyQt.QtCore import QCoreApplication, QVariant
from qgis.core import (QgsProcessing, QgsProcessingAlgorithm,
QgsProcessingParameterRasterLayer,QgsProcessingParameterNumber,
QgsProcessingParameterRasterDestination)
class RasterAlg(QgsProcessingAlgorithm):
INPUT_RASTER_A = 'INPUT_RASTER_A'
INPUT_RASTER_B = 'INPUT_RASTER_B'
INPUT_DOUBLE = 'INPUT_DOUBLE'
OUTPUT_RASTER_A = 'OUTPUT_RASTER_A'
OUTPUT_RASTER_B = 'OUTPUT_RASTER_B'
def __init__(self):
super().__init__()
def name(self):
return "RasterAlg"
def tr(self, text):
return QCoreApplication.translate("RasterAlg", text)
def displayName(self):
return self.tr("RasterAlg script")
def group(self):
return self.tr("RasterAlgs")
def groupId(self):
return "RasterAlgs"
def shortHelpString(self):
return self.tr("RasterAlg script without logic")
def helpUrl(self):
return "https://qgis.org"
def createInstance(self):
return type(self)()
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(
self.INPUT_RASTER_A,
self.tr("Input Raster A"), None, False))
self.addParameter(QgsProcessingParameterRasterLayer(
self.INPUT_RASTER_B,
self.tr("Input Raster B"), None, False))
self.addParameter(QgsProcessingParameterNumber(
self.INPUT_DOUBLE,
self.tr("Input Double"),
QgsProcessingParameterNumber.Double,
QVariant(1.0)))
self.addParameter(QgsProcessingParameterRasterDestination(
self.OUTPUT_RASTER_A,
self.tr("Output Raster A"),
None, False))
self.addParameter(QgsProcessingParameterRasterDestination(
self.OUTPUT_RASTER_B,
self.tr("Output Raster B"),
None, False))
def processAlgorithm(self, parameters, context, feedback):
raster_a = self.parameterAsRasterLayer(parameters, self.INPUT_RASTER_A, context)
raster_b = self.parameterAsRasterLayer(parameters, self.INPUT_RASTER_B, context)
double_val = self.parameterAsDouble(parameters, self.INPUT_DOUBLE,context)
output_path_raster_a = self.parameterAsOutputLayer(parameters, self.OUTPUT_RASTER_A, context)
output_path_raster_b = self.parameterAsOutputLayer(parameters, self.OUTPUT_RASTER_B, context)
#DO SOME CALCULATION
results = {}
results[self.OUTPUT_RASTER_A] = output_path_raster_a
results[self.OUTPUT_RASTER_B] = output_path_raster_b
return results
कौन से कदम उठाए हैं?
- सभी आवश्यक कक्षाएं आयात करें।
- एल्गोरिथ्म को एक वर्ग से विरासत के रूप में परिभाषित करें
QgsProcessingAlgorithm।
- सबसे पहले आपको इनपुट और आउटपुट मापदंडों के नाम को एल्गोरिथम वर्ग (यानी।
INPUT_RASTER_A = 'INPUT_RASTER_A') के स्ट्रिंग चर (पैरामीटर नाम) के रूप में घोषित करना होगा, ताकि आपके एल्गोरिदम को प्रोसेसिंग फ्रेमवर्क द्वारा प्रदान किए गए मापदंडों के साथ संदर्भित किया जा सके।
- अपने एल्गोरिथ्म को वायर करने वाले तरीकों को प्रोसेसिंग टूलबॉक्स गुई में जोड़ें और हेल्पस्ट्रिंग आदि प्रदान करें।
- फिर आप प्रसंस्करण ढांचे के मापदंडों को जोड़ते हैं। उन के बच्चे कक्षाओं के रूप में परिभाषित कर रहे हैं
QgsProcessingParameterType- अपने एल्गोरिथ्म के मामले में: QgsProcessingParameterRasterLayer, QgsProcessingParameterNumber, और इतने पर। QgsProcessingParameterRasterLayerसही तर्क पास करने और पैरामीटर ऑब्जेक्ट बनाने के लिए आप API प्रविष्टियों (यानी। ) से परामर्श कर सकते हैं।
- जहाँ आप रनटाइम में पैरामीटर से इनपुट डेटासेट प्राप्त करते हैं, उस पद्धति के साथ
contextऔर feedbackऑब्जेक्ट्स को पास करें processAlgorithm()(इस मामले में QgsRasterLayer ऑब्जेक्ट्स को parameterAsRasterLayer()विधि, आदि का उपयोग करके )।
- अपनी गणना करें।
- परिणाम डिक्शनरी में आउटपुट जोड़ें और कॉलिंग के परिणाम के रूप में उन्हें वापस करें
processAlgorithm()।
मुझे आशा है कि मैं आपको QGIS3 में अपने अजगर एल्गोरिदम को डिजाइन करने के बारे में कुछ जानकारी दे सकता हूं। जब भी आप अटक जाते हैं, तो यह देखना हमेशा मददगार होता है कि प्रोसेसिंग फ्रेमवर्क के मौजूदा एल्गोरिदम मापदंडों को कैसे संभालते हैं। आप उन्हें यहाँ देख सकते हैं ।