Python ParameterFactory.getFromString方法代码示例

# 需要导入模块: from sextante.parameters.ParameterFactory import ParameterFactory [as 别名]
# 或者: from sextante.parameters.ParameterFactory.ParameterFactory import getFromString [as 别名]
 def defineCharacteristicsFromFile(self):
     lines = open(self.descriptionFile)
     line = lines.readline().strip("\n").strip()
     self.grassName = line
     line = lines.readline().strip("\n").strip()
     self.name = line
     line = lines.readline().strip("\n").strip()
     self.group = line
     hasRasterOutput = False
     hasVectorOutput = False
     while line != "":
         try:
             line = line.strip("\n").strip()
             if line.startswith("Parameter"):
                 parameter = ParameterFactory.getFromString(line);
                 self.addParameter(parameter)
                 if isinstance(parameter, ParameterVector):
                    hasVectorOutput = True
                 if isinstance(parameter, ParameterMultipleInput) and parameter.datatype < 3:
                    hasVectorOutput = True                        
             elif line.startswith("*Parameter"):
                 param = ParameterFactory.getFromString(line[1:])
                 param.isAdvanced = True
                 self.addParameter(param)
             else:
                 output = OutputFactory.getFromString(line)
                 self.addOutput(output);
                 if isinstance(output, OutputRaster):
                     hasRasterOutput = True
             line = lines.readline().strip("\n").strip()
         except Exception,e:
             SextanteLog.addToLog(SextanteLog.LOG_ERROR, "Could not open GRASS algorithm: " + self.descriptionFile + "\n" + line)
             raise e

# 需要导入模块: from sextante.parameters.ParameterFactory import ParameterFactory [as 别名]
# 或者: from sextante.parameters.ParameterFactory.ParameterFactory import getFromString [as 别名]
 def defineCharacteristicsFromFile(self):
     lines = open(self.descriptionFile)
     line = lines.readline().strip("\n").strip()
     self.appkey = line
     line = lines.readline().strip("\n").strip()
     self.cliName = line
     line = lines.readline().strip("\n").strip()
     self.name = line
     line = lines.readline().strip("\n").strip()
     self.group = line
     while line != "":
         try:
             line = line.strip("\n").strip()
             if line.startswith("Parameter"):
                 param = ParameterFactory.getFromString(line)
                 # Hack for initializing the elevation parameters from Sextante configuration
                 if param.name == "-elev.dem.path" or param.name == "-elev.dem":
                     param.default = OTBUtils.otbSRTMPath()
                 elif param.name == "-elev.dem.geoid" or param.name == "-elev.geoid":
                     param.default = OTBUtils.otbGeoidPath()
                 self.addParameter(param)
             elif line.startswith("*Parameter"):
                 param = ParameterFactory.getFromString(line[1:])
                 param.isAdvanced = True
                 self.addParameter(param)
             elif line.startswith("Extent"):
                 self.addParameter(ParameterExtent(self.REGION_OF_INTEREST, "Region of interest", "0,1,0,1"))
                 self.hasROI = True
             else:
                 self.addOutput(OutputFactory.getFromString(line))
             line = lines.readline().strip("\n").strip()
         except Exception,e:
             SextanteLog.addToLog(SextanteLog.LOG_ERROR, "Could not open OTB algorithm: " + self.descriptionFile + "\n" + line)
             raise e

# 需要导入模块: from sextante.parameters.ParameterFactory import ParameterFactory [as 别名]
# 或者: from sextante.parameters.ParameterFactory.ParameterFactory import getFromString [as 别名]
 def processDescriptionParameterLine(self, line):
     try:
         if line.startswith("Parameter"):
             self.addParameter(ParameterFactory.getFromString(line))
         elif line.startswith("*Parameter"):
             param = ParameterFactory.getFromString(line[1:])
             param.isAdvanced = True
             self.addParameter(param)
         else:
             self.addOutput(OutputFactory.getFromString(line))
     except Exception:
         raise WrongScriptException("Could not load script:" + self.descriptionFile + ".\n Problem with line \"" + line + "\"")

# 需要导入模块: from sextante.parameters.ParameterFactory import ParameterFactory [as 别名]
# 或者: from sextante.parameters.ParameterFactory.ParameterFactory import getFromString [as 别名]
 def defineCharacteristicsFromFile(self):
     lines = open(self.descriptionFile)
     line = lines.readline().strip("\n").strip()
     self.name = line
     if "|" in self.name:
         tokens = self.name.split("|")
         self.name = tokens[0]
         self.cmdname = tokens[1]
     else:
         self.cmdname = self.name
     line = lines.readline().strip("\n").strip()
     self.undecoratedGroup = line
     self.group = SagaGroupNameDecorator.getDecoratedName(self.undecoratedGroup)
     while line != "":
         line = line.strip("\n").strip()
         if line.startswith("Parameter"):
             self.addParameter(ParameterFactory.getFromString(line))
         elif line.startswith("DontResample"):
             self.resample = False
         elif line.startswith("Extent"): #An extent parameter that wraps 4 SAGA numerical parameters
             self.extentParamNames = line[6:].strip().split(" ")
             self.addParameter(ParameterExtent(self.OUTPUT_EXTENT, "Output extent", "0,1,0,1"))
         else:
             self.addOutput(OutputFactory.getFromString(line))
         line = lines.readline().strip("\n").strip()
     lines.close()

# 需要导入模块: from sextante.parameters.ParameterFactory import ParameterFactory [as 别名]
# 或者: from sextante.parameters.ParameterFactory.ParameterFactory import getFromString [as 别名]
 def defineCharacteristicsFromFile(self):
     lines = open(self.descriptionFile)
     line = lines.readline().strip("\n").strip()
     self.grassName = line
     line = lines.readline().strip("\n").strip()
     self.name = line
     line = lines.readline().strip("\n").strip()
     self.group = line
     while line != "":
         try:
             line = line.strip("\n").strip()
             if line.startswith("Parameter"):
                 self.addParameter(ParameterFactory.getFromString(line))
             elif line.startswith("*Parameter"):
                 param = ParameterFactory.getFromString(line[1:])
                 param.isAdvanced = True
                 self.addParameter(param)
             else:
                 self.addOutput(OutputFactory.getFromString(line))
             line = lines.readline().strip("\n").strip()
         except Exception,e:
             SextanteLog.addToLog(SextanteLog.LOG_ERROR, "Could not open GRASS algorithm: " + self.descriptionFile + "\n" + line)
             raise e

# 需要导入模块: from sextante.parameters.ParameterFactory import ParameterFactory [as 别名]
# 或者: from sextante.parameters.ParameterFactory.ParameterFactory import getFromString [as 别名]
    def openModel(self, filename):
        self.algPos = []
        self.paramPos = []
        self.algs = []
        self.algParameters = []
        self.algOutputs = []
        self.paramValues = {}
        self.dependencies = []

        self.descriptionFile = filename
        lines = codecs.open(filename, "r", encoding='utf-8')
        line = lines.readline().strip("\n")
        iAlg = 0
        try:
            while line != "":
                if line.startswith("PARAMETER:"):
                    paramLine = line[len("PARAMETER:"):]
                    param = ParameterFactory.getFromString(paramLine)
                    if param:
                        self.parameters.append(param)
                    else:
                        raise WrongModelException("Error in line: " + line)
                    line = lines.readline().strip("\n")
                    tokens = line.split(",")
                    self.paramPos.append(QtCore.QPointF(float(tokens[0]), float(tokens[1])))
                elif line.startswith("VALUE:"):
                    valueLine = line[len("VALUE:"):]
                    tokens = valueLine.split("===")

                    self.paramValues[tokens[0]] = tokens[1].replace(ModelerAlgorithm.LINE_BREAK_STRING, '\n')
                elif line.startswith("NAME:"):
                    self.name = line[len("NAME:"):]
                elif line.startswith("GROUP:"):
                    self.group = line[len("GROUP:"):]
                elif line.startswith("ALGORITHM:"):
                    algParams={}
                    algOutputs={}
                    algLine = line[len("ALGORITHM:"):]
                    alg = ModelerUtils.getAlgorithm(algLine)
                    if alg:
                        posline = lines.readline().strip("\n")
                        tokens = posline.split(",")
                        self.algPos.append(QtCore.QPointF(float(tokens[0]), float(tokens[1])))
                        self.algs.append(alg)
                        dependenceline = lines.readline().strip("\n")
                        dependencies = [];
                        if dependenceline != str(None):
                            for index in dependenceline.split(","):
                                dependencies.append(int(index))
                        for param in alg.parameters:
                            line = lines.readline().strip("\n")
                            if line==str(None):
                                algParams[param.name] = None
                            else:
                                tokens = line.split("|")
                                algParams[param.name] = AlgorithmAndParameter(int(tokens[0]), tokens[1])
                        for out in alg.outputs:
                            line = lines.readline().strip("\n")
                            if str(None)!=line:
                                algOutputs[out.name] = line
                                #we add the output to the algorithm, with a name indicating where it comes from
                                #that guarantees that the name is unique
                                output = copy.deepcopy(out)
                                output.description = line
                                output.name = self.getSafeNameForOutput(iAlg, output)
                                self.addOutput(output)
                            else:
                                algOutputs[out.name] = None
                        self.algOutputs.append(algOutputs)
                        self.algParameters.append(algParams)
                        self.dependencies.append(dependencies)
                        iAlg += 1
                    else:
                        raise WrongModelException("Error in line: " + line)
                line = lines.readline().strip("\n")
        except:
            raise WrongModelException("Error in line: " + line)