28.9. Processing algorithm အသစ်များကို Python script များအဖြစ် ရေးသားခြင်း

Python ကိုအသုံးပြုပြီး Processing algorithm များရေးသားခြင်းအတွက် နည်းလမ်း နှစ်မျိုးရှိပါသည်။

QGIS အတွင်းတွင် code များရေးနိုင်သော Processing Script Editor ကိုဖွင့်ရန် Processing Toolbox ၏အပေါ်ဘက် Scripts menu ထဲရှိ Create new script ကိုအသုံးပြုနိုင်ပါသည်။ လုပ်ငန်းကိုလွယ်ကူရိုးရှင်းစေရန်အတွက် ၎င်း menu မှ Create new script from template ကိုအသုံးပြုပြီး script template တစ်ခုဖြင့်စတင်နိုင်ပါသည်။ ၎င်းသည် QgsProcessingAlgorithm ကို ချဲ့ထွင်ပေးသော template တစ်ခုကိုဖွင့်ပေးပါသည်။

.py extension တစ်ခုဖြင့် scripts folder ထဲတွင် script ကိုသိမ်းဆည်းလျှင် algorithm သည် Processing Toolbox ထဲတွင် အသုံးပြုနိုင်မည်ဖြစ်သည်။

28.9.1. QgsProcessingAlgorithm ကိုချဲ့ထွင်ခြင်း (Extending QgsProcessingAlgorithm)

အောက်ပါ code များသည်

  1. Vector layer တစ်ခုကို ထည့်သွင်းအသုံးပြုသော အချက်အလက်အဖြစ် အသုံးပြုပါသည်။

  2. Feature အရေအတွက်ကို ရေတွက်ပါသည်။

  3. Buffer လုပ်ဆောင်မှုတစ်ခုဖန်တီးပေးပါသည်။

  4. Buffer လုပ်ဆောင်မှု၏ရလာဒ်မှ raster layer တစ်ခုဖန်တီးပေးပါသည်။

  5. Buffer layer ၊ raster layer နှင့် feature အရေအတွက်များကို ပြန်ထုတ်ပေးပါသည်။

  1from qgis.PyQt.QtCore import QCoreApplication
  2from qgis.core import (QgsProcessing,
  3                       QgsProcessingAlgorithm,
  4                       QgsProcessingException,
  5                       QgsProcessingOutputNumber,
  6                       QgsProcessingParameterDistance,
  7                       QgsProcessingParameterFeatureSource,
  8                       QgsProcessingParameterVectorDestination,
  9                       QgsProcessingParameterRasterDestination)
 10from qgis import processing
 11
 12
 13class ExampleProcessingAlgorithm(QgsProcessingAlgorithm):
 14    """
 15    Vector layer တစ်ခုကို အသုံးပြုပြီး အချို့သော layer အသစ်များကိုဖန်တီးကာ ရလာဒ်အချို့ပြန်ထုတ်ပေးသည့် နမူနာ algorithm ဖြစ်ပါသည်။
 16    """
 17
 18    def tr(self, string):
 19        """
 20        self.tr() function ဖြင့် ဘာသာပြန်နိုင်သော စာသားကိုပြန်ထုတ်ပေးပါသည်။
 21        """
 22        return QCoreApplication.translate('Processing', string)
 23
 24    def createInstance(self):
 25        # Algorithm ၏ မိတ္တူအသစ်တစ်ခုကို ပြန်ထုတ်ပေးရပါမည်။
 26        return ExampleProcessingAlgorithm()
 27
 28    def name(self):
 29        """
 30        တမူထူးခြားသော algorithm နာမည်ကို ပြန်ထုတ်ပေးပါသည်။
 31        """
 32        return 'bufferrasterextend'
 33
 34    def displayName(self):
 35        """
 36        ဘာသာပြန်ထားသော algorithm အမည်ကို ပြန်ထုတ်ပေးပါသည်။
 37        """
 38        return self.tr('Buffer and export to raster (extend)')
 39
 40    def group(self):
 41        """
 42        ၎င်း algorithm နှင့်သက်ဆိုင်သော အုပ်စု၏အမည်ကို ပြန်ထုတ်ပေးပါသည်။
 43        """
 44        return self.tr('Example scripts')
 45
 46    def groupId(self):
 47        """
 48        ၎င်း algorithm နှင့်သက်ဆိုင်သော အုပ်စု၏ တမူထူးခြားသည့် ID ကိုပြန်ထုတ်ပေးပါသည်။
 49        """
 50        return 'examplescripts'
 51
 52    def shortHelpString(self):
 53        """
 54        Algorithm အတွက် အကူအညီစာသားအတိုတစ်ခုကို ပြန်ထုတ်ပေးပါသည်။
 55        """
 56        return self.tr('Example algorithm short description')
 57
 58    def initAlgorithm(self, config=None):
 59        """
 60        Algorithm တွင်ထည့်သွင်းအသုံးပြုသော အချက်အလက်နှင့် ရလာဒ်များကို ဤတွင်သတ်မှတ်ပါသည်။
 61        """
 62        # 'INPUT' သည် အဓိကထည့်သွင်းလုပ်ဆောင်သော parameter များအတွက် အကြုံပြုထားသော အမည် ဖြစ်ပါသည်။
 63        self.addParameter(
 64            QgsProcessingParameterFeatureSource(
 65                'INPUT',
 66                self.tr('Input vector layer'),
 67                types=[QgsProcessing.TypeVectorAnyGeometry]
 68            )
 69        )
 70        self.addParameter(
 71            QgsProcessingParameterVectorDestination(
 72                'BUFFER_OUTPUT',
 73                self.tr('Buffer output'),
 74            )
 75        )
 76        # 'OUTPUT' သည် အဓိကထွက်လာသည့် ရလာဒ် parameter အတွက် အကြုံပြုထားသော အမည်ဖြစ်ပါသည်။
 77        self.addParameter(
 78            QgsProcessingParameterRasterDestination(
 79                'OUTPUT',
 80                self.tr('Raster output')
 81            )
 82        )
 83        self.addParameter(
 84            QgsProcessingParameterDistance(
 85                'BUFFERDIST',
 86                self.tr('BUFFERDIST'),
 87                defaultValue = 1.0,
 88        # ထည့်သွင်းအသုံးပြုသော layer ယူနစ်များနှင့် ကိုက်ညီသော အကွာအဝေးယူနစ်များကို ဖန်တီးပါ-
 89                parentParameterName='INPUT'
 90            )
 91        )
 92        self.addParameter(
 93            QgsProcessingParameterDistance(
 94                'CELLSIZE',
 95                self.tr('CELLSIZE'),
 96                defaultValue = 10.0,
 97                parentParameterName='INPUT'
 98            )
 99        )
100        self.addOutput(
101            QgsProcessingOutputNumber(
102                'NUMBEROFFEATURES',
103                self.tr('Number of features processed')
104            )
105        )
106
107    def processAlgorithm(self, parameters, context, feedback):
108        """
109        Processing လုပ်ဆောင်သော နေရာဖြစ်ပါသည်။
110        """
111        # ပထမဆုံးအနေဖြင့် ထည့်သွင်းအသုံးပြုသော layer မှ feature အရေအတွက်ကို ရယူပါ။
112        # self.parameterAsSource ကိုခေါ်ယူခြင်းဖြင့် ၎င်းကို ပြန်လည်ရယူနိုင်ရန် ဤ layer ကို
113        # QgsProcessingParameterFeatureSource parameter အဖြစ်သတ်မှတ်ပါ။
114        input_featuresource = self.parameterAsSource(parameters,
115                                                     'INPUT',
116                                                     context)
117        numfeatures = input_featuresource.featureCount()
118
119        # Buffer အကွာအဝေးနှင့် raster cell အရွယ်အစား ကိန်းဂဏန်းတန်ဖိုးများကို ရယူပါသည်။
120        # ၎င်းတို့သည် ကိန်းဂဏန်းတန်ဖိုးများ ဖြစ်သောကြောင့် self.parameterAsDouble အသုံးပြုပြီး ၎င်းတို့ကို ပြန်လည်ရယူပါသည်။
121        bufferdist = self.parameterAsDouble(parameters, 'BUFFERDIST',
122                                            context)
123        rastercellsize = self.parameterAsDouble(parameters, 'CELLSIZE',
124                                                context)
125        if feedback.isCanceled():
126            return {}
127        buffer_result = processing.run(
128            'native:buffer',
129            {
130        # ဤတွင် INPUT နှင့် BUFFER_OUTPUT များ၏မူရင်း parameter တန်ဖိုးများကို Buffer algorithm သို့ပို့ဆောင်ပေးပါသည်။
131                'INPUT': parameters['INPUT'],
132                'OUTPUT': parameters['BUFFER_OUTPUT'],
133                'DISTANCE': bufferdist,
134                'SEGMENTS': 10,
135                'DISSOLVE': True,
136                'END_CAP_STYLE': 0,
137                'JOIN_STYLE': 0,
138                'MITER_LIMIT': 10
139            },
140        # Buffer algorithm ကို ပိုကြီးသော အခြား algorithm ထဲတွင် အဆင့်တစ်ခုအဖြစ် လုပ်ဆောင်သောကြောင့်
141            # is_child_algorithm option ကို True အဖြစ်သတ်မှတ်သင့်ပါသည်
142            is_child_algorithm=True,
143            #
144        # အသုံးပြုသူများသို့ သင့်တော်သောတုန့်ပြန်မှုပေးရန်နှင့် ပယ်ဖျက်ခြင်းတောင်းဆိုမှုများကို ကိုင်တွယ်နိုင်ရန်အတွက်
145        # အခြေအနေနှင့် တုန့်ပြန်သော object များကို child algorithm များသို့ပို့ဆောင်ပေးရန် အရေးကြီးပါသည်။
146            context=context,
147            feedback=feedback)
148
149        # ပယ်ဖျက်မှုအတွက် စစ်ဆေးခြင်း
150        if feedback.isCanceled():
151            return {}
152
153        # Buffer မှ ရလာသော ရလာဒ်ကို ထည့်သွင်းအသုံးပြုသော အချက်အလက်အဖြစ် အသုံးပြုပြီး
154        # သီးခြား raster ဖန်တီးခြင်း algorithm ကို လုပ်ဆောင်ပါ။
155        rasterized_result = processing.run(
156            'qgis:rasterize',
157            {
158                                # Buffer ၏ရလာဒ် dictionary မှ 'OUTPUT' တန်ဖိုးကို raster ဖန်တီးပေးသော child algorithm သို့ ပို့ဆောင်ပေးပါသည်။
159                'LAYER': buffer_result['OUTPUT'],
160                'EXTENT': buffer_result['OUTPUT'],
161                'MAP_UNITS_PER_PIXEL': rastercellsize,
162        # မူရင်း parameter တန်ဖိုးကိုအသုံးပြုပါ။
163                'OUTPUT': parameters['OUTPUT']
164            },
165            is_child_algorithm=True,
166            context=context,
167            feedback=feedback)
168
169        if feedback.isCanceled():
170            return {}
171
172        # ရလာဒ်များကို ပြန်ထုတ်ပေးပါသည်။
173        return {'OUTPUT': rasterized_result['OUTPUT'],
174                'BUFFER_OUTPUT': buffer_result['OUTPUT'],
175                'NUMBEROFFEATURES': numfeatures}

Processing algorithm ၏ စံလုပ်ဆောင်ချက်များ -

  • createInstance (မဖြစ်မနေလုပ်ဆောင်ရမည်)

    Algorithm ၏ မိတ္တူအသစ်တစ်ခုကို ပြန်ထုတ်ပေးရပါမည်။ အမျိုးအစား၏ နာမည်ကိုပြောင်းလိုက်လျှင် ကိုက်ညီစေရန်အတွက် ပြန်ထုတ်ပေးသည့် တန်ဖိုးကိုလည်း အသစ်ပြောင်းလဲပေးပါ။

  • name (မဖြစ်မနေလုပ်ဆောင်ရမည်)

    တမူထူးခြားသော algorithm နာမည်ကို ပြန်ထုတ်ပေးပါသည်။ Algorithm ကို သဏ္ဍာန်ခွဲဖော်ပြခြင်းအတွက် အသုံးပြုပါသည်။

  • displayName (မဖြစ်မနေလုပ်ဆောင်ရမည်)

    ဘာသာပြန်ထားသော algorithm အမည်ကို ပြန်ထုတ်ပေးပါသည်။

  • group

    ၎င်း algorithm နှင့်သက်ဆိုင်သော အုပ်စု၏နာမည်ကို ပြန်ထုတ်ပေးပါသည်။

  • groupId

    ၎င်း algorithm နှင့်သက်ဆိုင်သော အုပ်စု၏ တမူထူးခြားသော ID ကို ပြန်ထုတ်ပေးပါသည်။

  • shortHelpString

    Algorithm အတွက် အကူအညီစာသားအတိုကို ပြန်ထုတ်ပေးပါသည်။

  • initAlgorithm (မဖြစ်မနေလုပ်ဆောင်ရမည်)

    Algorithm ၏ ထည့်သွင်းအသုံးပြုသော အချက်အလက်များနှင့် ထွက်လာသောရလာဒ် များကို ဤတွင်သတ်မှတ်ပါသည်။

    INPUT နှင့် OUTPUT သည် အဓိက ထည့်သွင်းအသုံးပြုသော အချက်အလက်နှင့် အဓိကထွက်လာမည့် ရလာဒ် parameter များအတွက် အကြံပြုထားသော အမည်များ ဖြစ်ပါသည်။

    Parameter တစ်ခုသည် အခြား parameter ပေါ်တွင် မှီခိုနေလျှင် ၎င်းချိတ်ဆက်မှုကို သတ်မှတ်ဖော်ပြန်ရန် parentParameterName ကိုအသုံးပြုပါသည် (Layer တစ်ခု၏ field/band သို့မဟုတ် layer တစ်ခု၏ အကွာအဝေးယူနစ်များ ဖြစ်နိုင်ပါသည်)။

  • processAlgorithm (မဖြစ်မနေလုပ်ဆောင်ရမည်)

    Processing လုပ်ဆောင်သော နေရာဖြစ်ပါသည်။

    အထူးရည်ရွယ်ချက် function များကိုအသုံးပြုပြီး parameter ကိုပြန်လည်ရယူပါသည်၊ ဥပမာ- parameterAsSource နှင့် parameterAsDouble။

    Processing algrithm တွင် အခြား processing algorithm များကိုလုပ်ဆောင်ရန် processing.run ကိုအသုံးပြုနိုင်ပါသည်။ ပထမထည့်သွင်းရမည့် parameter မှာ algorithm ၏အမည်ဖြစ်ပြီး ဒုတိယထည့်သွင်းရမည်မှာ algorithm အတွက် parameter များ၏ dictionary ဖြစ်ပါသည်။ အခြား algorithm အတွင်းမှ algorithm တစ်ခုကိုလုပ်ဆောင်သောအခါ is_child_algorithm ကို သာမန်အားဖြင့် True အဖြစ်သတ်မှတ်ပါသည်။ context နှင့် feedback တို့သည် အလုပ်လုပ်ဆောင်မည့် environment အကြောင်းနှင့် အသုံးပြုသူနှင့် ဆက်သွယ်သော channel တို့ကို algorithm သို့အကြောင်းကြားပေးပါသည် (ပယ်ဖျက်သောတောင်းဆိုမှုကို သိမ်းပေးထားခြင်း၊ ပြီးစီးမှုပမာဏကို ကို တင်ပြခြင်း၊ အခြေအနေပေါ်မူတည်သော တုန့်ပြန်မှုများကို ဖော်ပြခြင်း)။ Parent algorithm ၏ parameter များကို “child” algorithms ၏ parameter များအဖြစ် အသုံးပြုသောအခါ မူရင်း parameter တန်ဖိုးများကို အသုံးပြုသင့်ပါသည် (ဥပမာ- parameters['OUTPUT'])

    ဖြစ်နိုင်လျှင် နေရာအတော်များများတွင် ပယ်ဖျက်ခြင်းအတွက် တုန့်ပြန်မှု (feedback) ကို စစ်ဆေးခြင်းသည် ကောင်းမွန်သောအကျင့် ဖြစ်ပါသည်။ ထိုသို့လုပ်ဆောင်ခြင်းဖြင့် မလိုချင်သော processing လုပ်ဆောင်ခြင်းများကို စောင့်နေခိုင်းမည့်အစား တုံ့ပြန်နိုင်သော ပယ်ဖျက်မှုကို ခွင့်ပြုပေးနိုင်ပါသည်။

    Algorithm သည် dictionary တစ်ခုအဖြစ် သတ်မှတ်သော ရလာဒ် parameter များအားလုံးအတွက် တန်ဖိုးများကို ပြန်ထုတ်ပေးသင့်ပါသည်။ ယခုကိစ္စတွင် ၎င်းသည် buffer နှင့် raster အဖြစ်ထွက်လာသော layer များ၊ နှင့် process လုပ်ထားသော feature များ၏အရေအတွက် ဖြစ်ပါသည်။ Dictionary key များသည် မူလ parameter/ရလာဒ် အမည်များနှင့် ကိုက်ညီနေရမည်ဖြစ်သည်။

28.9.2. The @alg decorator

@alg decorator ကိုအသုံးပြုခြင်းဖြင့် Python code များရေးခြင်း နှင့် သင့်တော်သော processing algorithm တစ်ခုဖန်တီးရန်အတွက် အခြားလိုအပ်သော သတင်းအချက်အလက်များကို ပံ့ပိုးရန်အတွက် စာကြောင်းအပိုများ ထပ်ဖြည့်ခြင်း အားဖြင့် ကိုယ်ပိုင် algorithm များကိုဖန်တီးနိုင်ပါသည်။ ၎င်းသည် algorithm များဖန်တီးခြင်းနှင့် ထည့်သွင်းအသုံးပြုသောအချက်အလက်များနှင့် ထွက်လာသောရလာဒ်များ၏သတ်မှတ်ချက်များကို လွယ်ကူရှင်းလင်းစေပါသည်။

Decorator ကိုအသုံးပြုခြင်း၏ အဓိက အားနည်းချက်တစ်ခုမှာ ဤနည်းဖြင့်ဖန်တီးထားသော algorithm များကို အသုံးပြုသူ၏ Proessing Scripts provider သို့ အမြဲတမ်းထည့်ပေါင်းပေးမည်ဖြစ်ပါသည်။ စိတ်ကြိုက်ရွေးထားသော provider သို့ ၎င်း algorithm များကိုထည့်ပေါင်း၍မရနိုင်ပါ။ ဥပမာ- plugin များတွင် အသုံးပြုရန်။

အောက်ပါ code များသည် @alg decorator ကိုအသုံးပြုပြီး အောက်ပါတို့ကိုလုပ်ဆောင်ပါသည်-

  1. Vector layer ကို ထည့်သွင်းအသုံးပြုမည့်အချက်အလက်အဖြစ် အသုံးပြုပါသည်။

  2. Feature များ၏အရေအတွက်ကို ရေတွက်ပါသည်။

  3. Buffer လုပ်ဆောင်မှုတစ်ခုကို ပြုလုပ်ပါသည်။

  4. လုပ်ဆောင်ထားသော buffer ၏ရလာဒ်မှ raster layer တစ်ခုဖန်တီးပါသည်။

  5. Buffer layer ၊ raster layer နှင့် feature အရေအတွက်တို့ကို ပြန်ထုတ်ပေးပါသည်။

 1from qgis import processing
 2from qgis.processing import alg
 3from qgis.core import QgsProject
 4
 5@alg(name='bufferrasteralg', label='Buffer and export to raster (alg)',
 6     group='examplescripts', group_label='Example scripts')
 7# 'INPUT' သည် အဓိကထည့်သွင်းလုပ်ဆောင်သော parameter အတွက် အကြုံပြုထားသော အမည် ဖြစ်ပါသည်။
 8@alg.input(type=alg.SOURCE, name='INPUT', label='Input vector layer')
 9# 'OUTPUT' is the recommended name for the main output parameter
10# 'OUTPUT' သည် အဓိကရလာဒ် parameter အတွက် အကြုံပြုထားသော အမည်ဖြစ်ပါသည်။
11@alg.input(type=alg.RASTER_LAYER_DEST, name='OUTPUT',
12           label='Raster output')
13@alg.input(type=alg.VECTOR_LAYER_DEST, name='BUFFER_OUTPUT',
14           label='Buffer output')
15@alg.input(type=alg.DISTANCE, name='BUFFERDIST', label='BUFFER DISTANCE',
16           default=1.0)
17@alg.input(type=alg.DISTANCE, name='CELLSIZE', label='RASTER CELL SIZE',
18           default=10.0)
19@alg.output(type=alg.NUMBER, name='NUMBEROFFEATURES',
20            label='Number of features processed')
21
22def bufferrasteralg(instance, parameters, context, feedback, inputs):
23    """
24    Algorithm ၏ရှင်းလင်းဖော်ပြချက်။
25    (ဒီနေရာတွင် comment မရှိလျှင် အမှားတစ်ခုရရှိပါလိမ့်မည်)
26    """
27    input_featuresource = instance.parameterAsSource(parameters,
28                                                     'INPUT', context)
29    numfeatures = input_featuresource.featureCount()
30    bufferdist = instance.parameterAsDouble(parameters, 'BUFFERDIST',
31                                            context)
32    rastercellsize = instance.parameterAsDouble(parameters, 'CELLSIZE',
33                                                context)
34    if feedback.isCanceled():
35        return {}
36    buffer_result = processing.run('native:buffer',
37                               {'INPUT': parameters['INPUT'],
38                                'OUTPUT': parameters['BUFFER_OUTPUT'],
39                                'DISTANCE': bufferdist,
40                                'SEGMENTS': 10,
41                                'DISSOLVE': True,
42                                'END_CAP_STYLE': 0,
43                                'JOIN_STYLE': 0,
44                                'MITER_LIMIT': 10
45                                },
46                               is_child_algorithm=True,
47                               context=context,
48                               feedback=feedback)
49    if feedback.isCanceled():
50        return {}
51    rasterized_result = processing.run('qgis:rasterize',
52                               {'LAYER': buffer_result['OUTPUT'],
53                                'EXTENT': buffer_result['OUTPUT'],
54                                'MAP_UNITS_PER_PIXEL': rastercellsize,
55                                'OUTPUT': parameters['OUTPUT']
56                               },
57                               is_child_algorithm=True, context=context,
58                               feedback=feedback)
59    if feedback.isCanceled():
60        return {}
61    return {'OUTPUT': rasterized_result['OUTPUT'],
62            'BUFFER_OUTPUT': buffer_result['OUTPUT'],
63            'NUMBEROFFEATURES': numfeatures}

တွေ့ရသည့်အတိုင်း algorithm နှစ်မျိုးပါဝင်ပါသည် (‘native:buffer’ နှင့် ‘qgis:rasterize’)။ နောက်ဆုံးတစ်ခုသည် (‘qgis:rasterize’) ပထမဆုံးတစ်ခု (‘native:buffer’) ဖြင့် ဖန်တီးခဲ့သော buffer layer မှ raster layer တစ်ခုကို ဖန်တီးပေးပါသည်။

ရှေ့ကသင်ခန်းစာများကိုဖတ်ခဲ့လျှင် ဤ processing လုပ်ဆောင်သော code များကိုနားလည်ရန် ခက်ခဲမည်မဟုတ်ပါ။ သို့သော် အစပိုင်းစာကြောင်းများသည် အချို့သောရှင်းလင်းချက်များ လိုအပ်ပါသည်။ Toolbox သို့မဟုတ် model designer ကဲ့သို့သော မည်သည့် GUI အစိတ်အပိုင်းဖြင့်မဆို လုပ်ဆောင်နိုင်သော algorithm အဖြစ် code ကိုပြောင်းလဲရန် လိုအပ်သော အချက်အလက်များကို ၎င်းတို့က ထောက်ပံ့ပေးပါသည်။

ထိုစာကြောင်းများအားလုံးကို algorithm ၏ coding ကိုလွယ်ကူရှင်းလင်းအောင် ကူညီပေးသော @alg decorator function များသို့ ခေါ်ယူပေးပါသည်။

  • Toolbox ထဲရှိ algorithm ၏အမည်နှင့် တည်နေရာကိုသတ်မှတ်ရန် @alg decorator ကိုအသုံးပြုပါသည်။

  • Algorithm ၏ထည့်သွင်းအသုံးပြုသော အချက်အလက်များကို သတ်မှတ်ရန် @alg.input decorator ကိုအသုံးပြုပါသည်။

  • Algorithm ၏ ရလာဒ်များကို သတ်မှတ်ရန် @alg.output decorator ကိုအသုံးပြုပါသည်။

28.9.3. Processing Algorithm များအတွက် Input နှင့် Output အမျိုးအစားများ (Input and output types for Processing Algorithms)

သက်ဆိုင်သော alg decorator မပြောင်းလဲမှုများနှင့် processing ထဲတွင် လုပ်ဆောင်ပေးသော Input နှင့် Output အမျိုးအစားများစာရင်းကို အောက်တွင် ဖော်ပြထားပါသည်။ (algfactory.py file တွင် ပြီးပြည့်စုံသော alg constants စာရင်းပါဝင်ပါသည်။) Class အမည်ဖြင့် စီထားပါသည်။

28.9.3.1. ထည့်သွင်းအသုံးပြုမည့်အမျိုးအစားများ (Input types)

Class

Alg constant

ရှင်းလင်းဖော်ပြချက်

QgsProcessingParameterAnnotationLayer

alg.ANNOTATION_LAYER

Annotation (မှတ်ချက်) layer တစ်ခု

QgsProcessingParameterAuthConfig

alg.AUTH_CFG

အသုံးပြုနိုင်သော authentication ပြင်ဆင်မှုများထဲမှ ရွေးချယ်နိုင်ခြင်း သို့မဟုတ် authentication ပြင်ဆင်မှုအသစ်များ ဖန်တီးနိုင်စေခြင်း

QgsProcessingParameterBand

alg.BAND

Raster layer band တစ်ခု

QgsProcessingParameterBoolean

alg.BOOL

မှား/မှန် တန်ဖိုး

QgsProcessingParameterColor

alg.COLOR

အရောင်တစ်မျိုး

QgsProcessingParameterCoordinateOperation

alg.COORDINATE_OPERATION

ကိုဩဒိနိတ်လုပ်ဆောင်မှုတစ်ခု (CRS ပြောင်းလဲခြင်းအတွက်)

QgsProcessingParameterCrs

alg.CRS

Coordinate Reference System (ကိုဩဒိနိတ်အညွှန်းစနစ်တစ်ခု)

QgsProcessingParameterDatabaseSchema

alg.DATABASE_SCHEMA

Database ပုံစံတစ်ခု

QgsProcessingParameterDatabaseTable

alg.DATABASE_TABLE

Database ဇယားတစ်ခု

QgsProcessingParameterDateTime

alg.DATETIME

ရက်စွဲအချိန်တစ်ခု (ရက်စွဲချည်းပဲ သို့မဟုတ် အချိန်)

QgsProcessingParameterDistance

alg.DISTANCE

အကွာအဝေးတန်ဖိုးများအဝွက် ဒဿမကိန်းဂဏန်း parameter

QgsProcessingParameterEnum

alg.ENUM

ကြိုတင်သတ်မှတ်ထားသောတန်ဖိုးများအစုမှ ရွေးချယ်နိုင်သော enumeration (ရေတွက်မှု) တစ်ခု

QgsProcessingParameterExpression

alg.EXPRESSION

Expression တစ်ခု

QgsProcessingParameterExtent

alg.EXTENT

အနည်းဆုံး x တန်ဖိုး၊ အများဆုံး x တန်ဖိုး၊ အနည်းဆုံး y တန်ဖိုး၊ အများဆုံး y တန်ဖိုး တို့ဖြင့်သတ်မှတ်ထားသော မြေပြင်အကျယ်အဝန်း

QgsProcessingParameterField

alg.FIELD

Vector layer တစ်ခု၏ attribute ဇယားထဲရှိ field တစ်ခု

QgsProcessingParameterFile

alg.FILE

ရှိနေပြီးသား file တစ်ခု၏ file အမည်တစ်ခု

QgsProcessingParameterFileDestination

alg.FILE_DEST

အသစ်ဖန်တီးထားသော ရလာဒ် file ၏ file နာမည်တစ်ခု

QgsProcessingParameterFolderDestination

alg.FOLDER_DEST

Folder တစ်ခု (သိမ်းဆည်းမည့် folder)

QgsProcessingParameterGeometry

alg.GEOMETRY

ဂျီဩမေတြီ တစ်ခု

QgsProcessingParameterNumber

alg.INT

ကိန်းပြည့်တစ်ခု

QgsProcessingParameterLayout

alg.LAYOUT

Layout တစ်ခု

QgsProcessingParameterLayoutItem

alg.LAYOUT_ITEM

Layout item တစ်ခု

QgsProcessingParameterMapLayer

alg.MAPLAYER

မြေပုံ layer တစ်ခု

QgsProcessingParameterMapTheme

alg.MAP_THEME

Project မြေပုံ ကဏ္ဍတစ်ခု

QgsProcessingParameterMatrix

alg.MATRIX

Matrix တစ်ခု

QgsProcessingParameterMeshLayer

alg.MESH_LAYER

Mesh layer တစ်ခု

QgsProcessingParameterMultipleLayers

alg.MULTILAYER

Layer အစုတစ်ခု

QgsProcessingParameterNumber

alg.NUMBER

ဂဏန်းတန်ဖိုးတစ်ခု

QgsProcessingParameterPoint

alg.POINT

အမှတ်တစ်ခု

QgsProcessingParameterPointCloudDestination

alg.POINTCLOUD_LAYER_DEST

Point cloud layer အတွက် နေရာ parameter ၊ algorithm ဖြင့်ဖန်တီးထားသော point cloud layer တစ်ခုအတွက် တည်နေရာလမ်းကြောင်း ကိုသတ်မှတ်ခြင်းအတွက်။

QgsProcessingParameterPointCloudLayer

alg.POINTCLOUD_LAYER

Point cloud layer တစ်ခု

QgsProcessingParameterProviderConnection

alg.PROVIDER_CONNECTION

Database provider တစ်ခုအတွက် အသုံးပြုနိုင်သော ချိတ်ဆက်မှုတစ်ခု

QgsProcessingParameterRange

alg.RANGE

ကိန်းဂဏန်းအပိုင်းအခြားတစ်ခု

QgsProcessingParameterRasterLayer

alg.RASTER_LAYER

Raster layer တစ်ခု

QgsProcessingParameterRasterDestination

alg.RASTER_LAYER_DEST

Raster layer တစ်ခုအတွက် နေရာ parameter ၊ algorithm ဖြင့်ဖန်တီးထားသော raster layer တစ်ခုအတွက် တည်နေရာလမ်းကြောင်း ကိုသတ်မှတ်ခြင်းအတွက်။

QgsProcessingParameterScale

alg.SCALE

မြေပုံ စကေးတစ်ခု

QgsProcessingParameterFeatureSink

alg.SINK

Feature sink တစ်ခု

QgsProcessingParameterFeatureSource

alg.SOURCE

Feature အရင်းအမြစ် တစ်ခု

QgsProcessingParameterString

alg.STRING

စာသားတစ်ခု

QgsProcessingParameterVectorLayer

alg.VECTOR_LAYER

Vector layer တစ်ခု

QgsProcessingParameterVectorDestination

alg.VECTOR_LAYER_DEST

Vector layer တစ်ခုအတွက် နေရာ parameter ၊ algorithm ဖြင့်ဖန်တီးထားသော vector layer တစ်ခုအတွက် တည်နေရာလမ်းကြောင်း ကိုသတ်မှတ်ခြင်းအတွက်။

QgsProcessingParameterVectorTileDestination

Vector tile layer တစ်ခုအတွက် နေရာ parameter ၊ algorithm ဖြင့်ဖန်တီးထားသော vector tile layer တစ်ခုအတွက် တည်နေရာလမ်းကြောင်း ကိုသတ်မှတ်ခြင်းအတွက်။

28.9.3.2. ရလာဒ်အမျိုးအစားများ (Output types)

Class

Alg constant

ရှင်းလင်းဖော်ပြချက်

QgsProcessingOutputBoolean

alg.BOOL

အမှား/အမှန် တန်ဖိုးတစ်ခု

QgsProcessingOutputNumber

alg.DISTANCE

အကွာအဝေးတန်ဖိုးများအတွက် ဒဿမကိန်းဂဏန်း parameter တစ်ခု

QgsProcessingOutputFile

alg.FILE

ရှိနေပြီးသား file တစ်ခု၏ file နာမည်တစ်ခု

QgsProcessingOutputFolder

alg.FOLDER

Folder တစ်ခု

QgsProcessingOutputHtml

alg.HTML

HTML

QgsProcessingOutputNumber

alg.INT

ကိန်းပြည့်တစ်ခု

QgsProcessingOutputLayerDefinition

alg.LAYERDEF

Layer အဓိပ္ပါယ်ဖွင့်ဆိုချက်တစ်ခု

QgsProcessingOutputMapLayer

alg.MAPLAYER

မြေပုံ layer တစ်ခု

QgsProcessingOutputMultipleLayers

alg.MULTILAYER

Layer အစုတစ်ခု

QgsProcessingOutputNumber

alg.NUMBER

ကိန်းဂဏန်းတန်ဖိုး တစ်ခု

QgsProcessingOutputPointCloudLayer

alg.POINTCLOUD_LAYER

Point cloud layer တစ်ခု

QgsProcessingOutputRasterLayer

alg.RASTER_LAYER

Raster layer တစ်ခု

QgsProcessingOutputString

alg.STRING

စာသားတစ်ခု

QgsProcessingOutputVectorLayer

alg.VECTOR_LAYER

Vector layer တစ်ခု

QgsProcessingOutputVectorTileLayer

Vector tile layer တစ်ခု

28.9.4. ရလာဒ်ကိုလက်ဆင့်ကမ်းခြင်း (Handing algorithm output)

Layer တစ်ခု (raster သို့မဟုတ် vector) ကိုကိုယ်စားပြုသော ရလာဒ်တစ်ခုကို ကြေညာသောအခါ လုပ်ဆောင်မှုပြီးစီးသည်နှင့် algorithm က ၎င်းကို QGIS ထဲကိုပေါင်းထည့်ပါလိမ့်မည်။

  • Raster layer ရလာဒ် - QgsProcessingParameterRasterDestination / alg.RASTER_LAYER_DEST.

  • Vector layer ရလာဒ် - QgsProcessingParameterVectorDestination / alg.VECTOR_LAYER_DEST.

processing.run() နည်းလမ်းသည် ၎င်းဖန်တီးထားသော layer များကို အသုံးပြုသူ၏ လက်ရှိ project သို့ထည့်မပေါင်းလျှင်တောင်မှ အသုံးပြုသူမှထည့်သွင်းထားသည့် တည်နေရာတွင်သိမ်းဆည်းသောကြောင့် (သို့မဟုတ် အသုံးပြုသူမှ တည်နေရာကိုမသတ်မှတ်ထားလျှင် ယာယီတည်နေရာတွင်) ထွက်လာမည့် layer နှစ်ခု (buffer နှင့် raster buffer) ကို ခေါ်ယူထည့်သွင်းပါလိမ့်မည်။

Layer တစ်ခုကို algorithm တစ်ခု၏ ရလာဒ်အဖြစ် ဖန်တီးလျှင် ၎င်းကို ဖန်တီးခဲ့သောနည်းလမ်းအတိုင်း‌ ကြေညာရပါမည်။ ထိုသို့မလုပ်လျှင် ကြေညာထားမှုသည် တကယ်ဖန်တီးခဲ့မှုနှင့် မကိုက်ညီသောကြောင့် modeler ထဲတွင် algorithm ကိုမှန်မှန်ကန်ကန် အသုံးပြုလို့ရနိုင်မည် မဟုတ်ပါ။

ရလာဒ် dictionary ထဲတွင် စာသားများ၊ ဂဏန်းများ နှင့်အခြားအရာများကို သတ်မှတ်ပေးခြင်းဖြင့် ၎င်းတို့ကို ပြန်လည်ထုတ်ပေးနိုင်ပါသည် (“NUMBEROFFEATURES” အတွက်သရုပ်ဖော်ထားသကဲ့သို့)၊ သို့သော် ၎င်းတို့ကို algorithm မှထွက်လာသောရလာဒ်များအဖြစ် အတိအလင်းသတ်မှတ်သင့်ပါသည်။ Algorithm ကို model ၏အစိတ်အပိုင်းတစ်ခုအဖြစ် အသုံးပြုသောအခါ နောက်ပိုင်းတွင်အသုံးပြုမည့် algorithm များအတွက်အသုံးဝင်သောကြောင့် algorithm များမှ အသုံးဝင်သောရလာဒ်တန်ဖိုးများကို ရနိုင်သမျှ ထုတ်ပေးရန် အကြံပြုပါသည်။

28.9.5. အသုံးပြုသူ နှင့် ဆက်သွယ်ခြင်း (Communicating with the user)

Algorithm သည်လုပ်ဆောင်သောအချိန်ကြာမြင့်မည်ဆိုလျှင် ပြီးစီးနေမှုပမာဏကို ဖော်ပြသင့်ပါသည်။ ထိုသို့ဖော်ပြရန် feedback (QgsProcessingFeedback) ကိုအသုံးပြုနိုင်ပါသည်။

setProgressText(text) နှင့် setProgress(percent) များကိုအသုံးပြုပြီး ပြီးစီးမှုစာသားနှင့် ပြီးစီးမှုပြ bar တို့၏ နောက်ဆုံးရအခြေအနေကို update ပြုလုပ်နိုင်ပါသည်။

pushCommandInfo(text)၊ pushDebugInfo(text)၊ pushInfo(text) နှင့် reportError(text) များကိုအသုံးပြုပြီး အခြားအချက်အလက်များကိုလည်း ဖော်ပြနိုင်ပါသည်။

Script တွင်ပြဿနာတစ်ခုခုရှိနေလျှင် မှန်ကန်သော ပြင်ဆင်နည်းမှာ QgsProcessingException ကိုအသုံးပြုရန်ဖြစ်ပါသည်။ Exception (ချွင်းချက်)၏ constructor (တည်ဆောက်သူ) ဆီသို့ message စာတစ်ခု ပေးပို့နိုင်ပါသည်။ Algorithm ကိုမည်သည့်နေရာမှ လုပ်ဆောင်သည် (toolbox ၊ modeler ၊ Python console ၊ …) ဆိုတာပေါ်မူတည်ပြီး processing မှ ၎င်းကိုကိုင်တွယ်ဖြေရှင်းပြီး အသုံးပြုသူနှင့် ဆက်သွယ်ပေးပါသည်။

28.9.6. Script များကို မှတ်တမ်းပြုစုခြင်း (Documenting your scripts)

QgsProcessingAlgorithm ၏ helpString() နှင့် helpUrl() နည်းလမ်းများကို ထည့်သွင်းပြီး မိမိ၏ script များကို မှတ်တမ်းပြုစုနိုင်ပါသည်။

28.9.7. အလံများ (Flags)

QGIS ကို မိမိ၏ algorithm အကြောင်းကို ပိုမိုသိစေရန် QgsProcessingAlgorithm ၏ flags() နည်းလမ်းကို အစားထိုးရေးသားနိုင်ပါသည်။ ဥပမာ- ပယ်ဖျက်နိုင်သော၊ thread လုံခြုံမှုမရှိသော modeler မှ script ကိုဝှက်ထားနိုင်ကြောင်းကို QGIS ကို သိအောင် လုပ်ပေးနိုင်ပါသည်။

Tip

ပုံမှန်အားဖြင့် processing task ကိုလုပ်ဆောင်နေစဉ်တွင် QGIS ကို တုန့်ပြန်မှုရှိနေစေရန် Processing က algroithm များကို သီးခြား thread တစ်ခုထဲတွင် လုပ်ဆောင်ပါသည်။ မိမိ၏ algorithm က မကြာခဏဆိုသလို ပိတ်ကျနေလျှင် နောက်ကွယ် thread ထဲတွင် လုပ်ဆောင်ရန် လုံခြုံမှုမရှိသော API call များကိုအသုံးပြုနေခြင်း ဖြစ်နိုင်ပါသည်။ Algorithm ကို အဓိက thread ထဲတွင်လုပ်ဆောင်ရန် Processing ကိုတွန်းအားပေးမည့်အစား algorithm ၏ flags() နည်းလမ်းမှ QgsProcessingAlgorithm.FlagNoThreading flag ကို ပြန်ထုတ်ပေးသင့်ပါသည်။

28.9.8. အလေ့အကျင့်ကောင်းများဖြင့် Script ရေးသားခြင်း

ကိုယ်ပိုင် script algorithm များရေးသားပြီး အခြား QGIS အသုံးပြုသူများကို မျှဝေလိုလျှင် ထည့်သွင်းစဉ်းစားသင့်သည့် အကြံပေးချက်အချို့ကို အောက်မှာ အကျဉ်းချုပ် ဖော်ပြထားပါသည်။ ရိုးရှင်းသော အောက်ပါစည်းမျဉ်းများကိုအသုံးပြုလျှင် toolbox ၊ modeler သို့မဟုတ် batch processing လုပ်သော interface များကဲ့သို့သော အမျိုးမျိုးသော processing element များတွင် တသတ်မတ်တည်းဖြစ်နေစေပါလိမ့်မည်။

  • ရလာဒ် layer များကို ခေါ်ယူထည့်သွင်းခြင်း မလုပ်ပါနှင့်။ Processing ကိုသာ ရလာဒ်များကို ကိုင်တွယ်စေပြီး လိုအပ်မှသာ layer များကို ခေါ်ယူထည့်သွင်းပါစေ။

  • Algorithm မှဖန်တီးခဲ့သော ရလာဒ်များကို အမြဲတမ်း ကြေညာပါ။

  • Messge box များကို မပြသပါနှင့် သို့မဟုတ် script မှ မည်သည့် GUI element ကိုမှအသုံးမပြုပါနှင့်။ အသုံးပြုသူများနှင့် ဆက်သွယ်လိုလျှင် တုန့်ပြန်မှု object (QgsProcessingFeedback) ကိုအသုံးပြုပါ သို့မဟုတ် QgsProcessingException တစ်ခုကို အသုံးပြုပါ။

QGIS ထဲတွင် အသုံးပြုနိုင်သော processing algorithm များစွာရှိပြီးသား ဖြစ်ပါသည်။ QGIS repo တွင် code များကိုသွားရောက်ရှာဖွေနိုင်ပါသည်။