[GRASS-SVN] r54125 - grass-addons/grass6/raster/mcda/r.mcda.roughset
svn_grass at osgeo.org
svn_grass at osgeo.org
Sat Dec 1 09:11:42 PST 2012
Author: gianluca
Date: 2012-12-01 09:11:42 -0800 (Sat, 01 Dec 2012)
New Revision: 54125
Removed:
grass-addons/grass6/raster/mcda/r.mcda.roughset/Makefile
grass-addons/grass6/raster/mcda/r.mcda.roughset/description.html
grass-addons/grass6/raster/mcda/r.mcda.roughset/r.mcda.roughset.py
Log:
Deleted: grass-addons/grass6/raster/mcda/r.mcda.roughset/Makefile
===================================================================
--- grass-addons/grass6/raster/mcda/r.mcda.roughset/Makefile 2012-12-01 17:11:28 UTC (rev 54124)
+++ grass-addons/grass6/raster/mcda/r.mcda.roughset/Makefile 2012-12-01 17:11:42 UTC (rev 54125)
@@ -1,7 +0,0 @@
-#MODULE_TOPDIR = ../..
-
-PGM = r.mcda.roughset
-
-include $(MODULE_TOPDIR)/include/Make/Script.make
-
-default: script
Deleted: grass-addons/grass6/raster/mcda/r.mcda.roughset/description.html
===================================================================
--- grass-addons/grass6/raster/mcda/r.mcda.roughset/description.html 2012-12-01 17:11:28 UTC (rev 54124)
+++ grass-addons/grass6/raster/mcda/r.mcda.roughset/description.html 2012-12-01 17:11:42 UTC (rev 54125)
@@ -1,31 +0,0 @@
-<h2>DESCRIPTION</h2>
-
-<em>r.mcda.roughset</em> is the python implementation of the dominance rough set approach (Domlem algorithm) in GRASS GIS environment. It requires the following input:
-<br>1. the geographical criteria constituting the information system for the rough set analysis; they have to describe environmental, economic or social issues(<b>criteria</b>=<em>name[,name,...]</em>);<br> 2. the preference (<b>preferences</b>=<em>character</em>)for each criteria used in analysis (gain or cost with comma separator)<br>3. the theme in which areas with the issues to be studied are classified (with crescent preference values) (<b>decision</b>=<em>string</em>).
-
-<p>An information system is generated and Domlem algorithm is applied for extraction a minimal set of rules.</P> The algorithm builds two text files (<b>outputTxt</b>=<em>name</em>): the first with isf extension for more deep analysis with non geographic software like 4emka and JAMM ; the second file with rls extension hold all the set of rules generate. An output map (<b>outputMap</b>=<em>string</em>)is generated for region classification with the rules finded and the criteria stored in GRASS geodb.
-
-<h2>NOTES</h2>
-<p> The module can work very slowly with high number of criteria and sample. For bug please contact Gianluca Massei (g_mass at libero.it)</P>
-
-
-<h2>REFERENCE</h2>
-<ol>
- <li><p>Greco S., Matarazzo B., Slowinski R.: <i>Rough sets theory for multicriteria decision analysis</i>. European Journal of Operational Research, 129, 1 (2001) 1-47.</P>
- <li><p>Greco S., Matarazzo B., Slowinski R.:<i> Multicriteria classification by dominance-based rough set approach</i>. In: W.Kloesgen and J.Zytkow (eds.), Handbook of Data Mining and Knowledge Discovery, Oxford University Press, New York, 2002.</P>
- <li><p>Greco S., Matarazzo B., Slowinski, R., Stefanowski, J.: <i>An Algorithm for Induction of Decision Rules Consistent with the Dominance Principle</i>. In W. Ziarko, Y. Yao (eds.): Rough Sets and Current Trends in Computing. Lecture Notes in Artificial Intelligence 2005 (2001) 304 - 313. Springer-Verlag</P>
- <li><p>Greco, S., B. Matarazzo, R. Slowinski and J. Stefanowski:<i> Variable consistency model of dominance-based rough set approach.</i> In W.Ziarko, Y.Yao (eds.): Rough Sets and Current Trends in Computing. Lecture Notes in Artificial Intelligence 2005 (2001) 170 - 181. Springer-Verlag</P>
- <li><p><a href="http://en.wikipedia.org/wiki/Dominance-based_rough_set_approach">http://en.wikipedia.org/wiki/Dominance-based_rough_set_approach</a> - “Dominance-based rough set approach”</P>
- <li><p><a href="http://idss.cs.put.poznan.pl/site/software.html">http://idss.cs.put.poznan.pl/site/software.html</a> - Software from Laboratory of intelligent decision support system in Poznam University of Technology
- </P>
-</ol>
-
-<h2>SEE ALSO</h2>
-<p><em>r.mcda.fuzzy, r.mcda.electre, r.mcda.regime, r.to.drsa, r.in.drsa</em></P>
-
-<h2>AUTHORS</h2>
-Antonio Boggia - Gianluca Massei<br>
-Department of Economics and Appraisal - University of Perugia - Italy
-
-<p>
-<i>Last changed: $Date$</i>
Deleted: grass-addons/grass6/raster/mcda/r.mcda.roughset/r.mcda.roughset.py
===================================================================
--- grass-addons/grass6/raster/mcda/r.mcda.roughset/r.mcda.roughset.py 2012-12-01 17:11:28 UTC (rev 54124)
+++ grass-addons/grass6/raster/mcda/r.mcda.roughset/r.mcda.roughset.py 2012-12-01 17:11:42 UTC (rev 54125)
@@ -1,611 +0,0 @@
-#!/usr/bin/env python
-############################################################################
-#
-# MODULE: r.mcda.roughset
-# AUTHOR: Gianluca Massei - Antonio Boggia
-# PURPOSE: Generate a MCDA map from several criteria maps using Dominance Rough Set Approach - DRSA
-# (DOMLEM algorithm proposed by (S. Greco, B. Matarazzo, R. Slowinski)
-# COPYRIGHT: c) 2010 Gianluca Massei, Antonio Boggia and the GRASS
-# Development Team. This program is free software under the
-# GNU General PublicLicense (>=v2). Read the file COPYING
-# that comes with GRASS for details.
-#
-#############################################################################
-
-#%Module
-#% description: Generate a MCDA map from several criteria maps using Dominance Rough Set Approach.
-#% keywords: raster, Dominance Rough Set Approach
-#% keywords: Multi Criteria Decision Analysis (MCDA)
-#%End
-#%option
-#% key: criteria
-#% type: string
-#% multiple: yes
-#% gisprompt: old,cell,raster
-#% key_desc: name
-#% description: Name of criteria raster maps
-#% required: yes
-#%end
-#%option
-#% key: preferences
-#% type: string
-#% key_desc: character
-#% description: gain,cost
-#% required: yes
-#%end
-#%option
-#% key: decision
-#% type: string
-#% gisprompt: old,cell,raster
-#% key_desc: name
-#% description: Name of decision raster map
-#% required: yes
-#%end
-#%option
-#% key: outputMap
-#% type: string
-#% gisprompt: new_file,cell,output
-#% description: Output classified raster map
-#% required: yes
-#%end
-#%option
-#% key: outputTxt
-#% type: string
-#% gisprompt: new_file,file,output
-#% key_desc: name
-#% description: Name for output files (base for *.isf and *.rls files)
-#% answer:infosys
-#% required: yes
-#%end
-#%flag
-#% key: l
-#% description: do not remove single rules in vector format
-#% answer:false
-#%end
-#%flag
-#% key: n
-#% description: compute null value as zero
-#% answer:true
-#%end
-
-import sys
-import copy
-import numpy as np
-from time import time, ctime
-import grass.script as grass
-import grass.script.array as garray
-
-
-def BuildFileISF(attributes, preferences, decision, outputMap, outputTxt):
- outputTxt=outputTxt+".isf"
- outf = file(outputTxt,"w")
- outf.write("**ATTRIBUTES\n")
- for i in range(len(attributes)):
- outf.write("+ %s: (continuous)\n" % attributes[i])
- outf.write("+ %s: [" % decision)
- value=[]
- value=grass.read_command("r.describe", flags = "1n", map = decision)
- v=value.split()
-
- for i in range(len(v)-1):
- outf.write("%s, " % str(v[i]))
- outf.write("%s]\n" % str(v[len(v)-1]))
- outf.write("decision: %s\n" % decision)
-
- outf.write("\n**PREFERENCES\n")
- for i in range(len(attributes)):
- if(preferences[i]==""):
- preferences[i]="none"
- outf.write("%s: %s\n" % (attributes[i], preferences[i]))
- outf.write("%s: gain\n" % decision)
-
- if flags['n']:
- for i in range(len(attributes)):
- print "%s - convert null to 0" % str(attributes[i])
- grass.run_command("r.null", map=attributes[i], null=0)
-
- outf.write("\n**EXAMPLES\n")
- examples=[]
- MATRIX=[]
-
- for i in range(len(attributes)):
- grass.mapcalc("rast=if(isnull(${decision})==0,${attribute},null())",
- rast="rast",
- decision=decision,
- attribute=attributes[i])
- tmp=grass.read_command("r.stats", flags = "1n", nv="?", input = "rast")
- example=tmp.split()
- examples.append(example)
- tmp=grass.read_command("r.stats", flags = "1n", nv="?", input = decision)
- example=tmp.split()
- examples.append(example)
-
- MATRIX=map(list,zip(*examples))
- MATRIX=[r for r in MATRIX if not '?' in r] #remove all rows with almost one "?"
- MATRIX=[list(i) for i in set(tuple(j) for j in MATRIX)] #remove duplicate example
-
- for r in range(len(MATRIX)):
- for c in range(len(MATRIX[0])):
- outf.write("%s " % (MATRIX[r][c]))
-# outf.write("%s " % round(float(MATRIX[r][c]), 2))
- outf.write("\n")
-
- outf.write("**END")
- outf.close()
- return outputTxt
-
-
-
-def collect_attributes (data):
- "Collects the values of header files isf, puts them in an array of dictionaries"
- header=[]
- attribute=dict()
- j=0
- start=(data.index(['**ATTRIBUTES'])+1)
- end=(data.index(['**PREFERENCES'])-1)
- for r in range(start, end):
- attribute={'name':data[r][1].strip('+:')}
- header.append(attribute)
- decision=data[end-1][1]
- end=(data.index(['**EXAMPLES']))
-
- start=(data.index(['**PREFERENCES'])+1)
- for r in header:
- r['preference']=data[start+j][1]
- j=j+1
- return header
-
-
-def collect_examples (data):
- "Collect examples values and put them in a matrix (list of lists) "
-
- matrix=[]
- data=[r for r in data if not '?' in r] #filter objects with " ?"
-# data=[data.remove(r) for r in data if data.count(r)>1]
- start=(data.index(['**EXAMPLES'])+1)
- end=data.index(['**END'])
- for i in range(start, end):
- data[i]=(map(float, data[i]))
- matrix.append(data[i])
- i=1
- for r in matrix:
- r.insert(0, str(i))
- i=i+1
-## matrix=[list(i) for i in set(tuple(j) for j in matrix)] #remove duplicate example
- return matrix
-
-
-def FileToInfoSystem(isf):
- "Read *.isf file and copy it's values in Infosystem dictionary"
- data=[]
- try:
- infile=open(isf,"r")
- rows=infile.readlines()
- for line in rows:
- line=(line.split())
- if (len(line)>0 ):
- data.append(line)
- infile.close()
- infosystem={'attributes':collect_attributes(data),'examples':collect_examples(data)}
- except TypeError:
- print "\n\n Computing error or input file %s is not readeable. Exiting gracefully" % isf
- sys.exit(0)
-
- return infosystem
-
-
-def UnionOfClasses (infosystem):
- "Find upward and downward union for all classes and put it in a dictionary"
- DecisionClass=[]
- AllClasses=[]
- matrix=infosystem['examples']
- for r in matrix:
- DecisionClass.append(int(r[-1]))
- DecisionClass=list(set(DecisionClass))
- for c in range(len(DecisionClass)):
- tmplist=[r for r in matrix if int(r[-1])==DecisionClass[c]]
- AllClasses.append(tmplist)
-
- return AllClasses
-
-
-def DownwardUnionsOfClasses (infosystem):
- "For each decision class, downward union corresponding to a decision class\
- is composed of this class and all worse classes (<=)"
-
- DownwardUnionClass=[]
- DecisionClass=[]
- matrix=infosystem['examples']
- for r in matrix:
- DecisionClass.append(int(r[-1]))
- DecisionClass=list(set(DecisionClass))
- for c in DecisionClass:
- tmplist=[r for r in matrix if int(r[-1])<=c]
- DownwardUnionClass.append(tmplist)
- #label=[row[0] for row in tmplist]
- return DownwardUnionClass
-
-
-def UpwardUnionsOfClasses (infosystem):
- "For each decision class, upward union corresponding to a decision class \
- is composed of this class and all better classes.(>=)"
-
- UpwardUnionClass=[]
- DecisionClass=[]
- matrix=infosystem['examples']
- for r in matrix:
- DecisionClass.append(int(r[-1]))
- DecisionClass=list(set(DecisionClass))
- for c in DecisionClass:
- tmplist=[r for r in matrix if int(r[-1])>=c]
- UpwardUnionClass.append(tmplist)
- #label=[row[0] for row in tmplist]
- return UpwardUnionClass
-
-
-###############################
-def is_better (r1,r2, preference):
- "Check if r1 is better than r2"
- return all((( x >=y and p=='gain') or (x<=y and p=='cost')) for x,y, p in zip(r1,r2, preference) )
-
-
-def is_worst (r1,r2, preference):
- "Check if r1 is worst than r2"
- return all((( x <=y and p=='gain') or (x>=y and p=='cost')) for x,y, p in zip(r1,r2, preference) )
- #################################
-
-
-def DominatingSet (infosystem):
- "Find P-dominating set"
- matrix=infosystem['examples']
- preference=[s['preference'] for s in infosystem['attributes'] ]
- Dominating=[]
- for row in matrix:
- examples=[r for r in matrix if is_better(r[1:-1], row[1:-1], preference) ]
- Dominating.append({'object':row[0], 'dominance':[i[0] for i in examples], 'examples':examples})
-## for dom in Dominating:
-## print dom['dominance'] ,' dominating ', dom['object']
- return Dominating
-
-def DominatedSet (infosystem):
- "Find P-Dominated set"
- matrix=infosystem['examples']
- preference=[s['preference'] for s in infosystem['attributes'] ]
- Dominated=[]
- for row in matrix:
- examples=[r for r in matrix if is_worst(r[1:-1], row[1:-1], preference[:-1]) ]
- Dominated.append({'object':row[0], 'dominance':[i[0] for i in examples], 'examples':examples})
-## for dom in Dominated:
-## print dom['dominance'] ,' is dominated by ', dom['object']
- return Dominated
-
-
-def LowerApproximation (UnionClasses, Dom):
- "Find Lower approximation and return a dictionaries list"
- c=1
- LowApprox=[]
- single=dict()
- for union in UnionClasses:
- tmp=[]
- UClass=set([row[0] for row in union] )
- for d in Dom:
- if (UClass.issuperset(set(d['dominance']))): #if Union class is a superse of dominating/dominated set, =>single Loer approx.
- tmp.append(d['object'])
- single={'class':c, 'objects':tmp} #dictionary for lower approximation --
- LowApprox.append(single) #insert all Lower approximation in a list
- c+=1
- return LowApprox
-
-
-def UpperApproximation (UnionClasses, Dom):
- "Find Upper approximation and return a dictionaries list"
- c=1
- UppApprox=[]
- single=dict()
- for union in UnionClasses:
- UnClass=[row[0] for row in union] #single union class
- s=[]
- for d in Dom:
- if len(set(d['dominance']) & set(UnClass)) >0:
- s.append(d['object'])
-# print set(s)
- single={'class':c,'objects':list(set(s))}
- UppApprox.append(single)
- c+=1
-
- return UppApprox
-
-
-def Boundaries (UppApprox, LowApprox):
- "Find Boundaries like doubtful regions"
- Boundary=[]
- single=dict()
-
- for i in range(len(UppApprox)):
- single={'class':i, 'objects':list (set(UppApprox[i]['objects'])-set(LowApprox[i]['objects']) )}
- Boundary.append(single)
-
- return Boundary
-
-
-def AccuracyOfApproximation(UppApprox, LowApprox):
- "Define the accuracy of approximation of Upward and downward approximation class"
- return len(LowApprox)/len(UppApprox)
-
-
-def QualityOfQpproximation(DownwardBoundary, infosystem):
- "Defines the quality of approximation of the partition Cl or, briefly, the quality of sorting"
- UnionBoundary=set()
- U=set([i[0] for i in infosystem['examples']])
- for b in DownwardBoundary:
- UnionBoundary=set(UnionBoundary) | set(b['objects'])
- return float(len(U-UnionBoundary)) / float(len(U))
-
-
-def FindObjectCovered (rules, selected):
- "Find objects covered by a single rule and return\
- all related examples covered"
- obj=[]
- examples=[]
-
- for rule in rules:
- examples.append(rule['objectsCovered'])
-
- if len(examples)>0:
- examples = reduce(set.intersection,map(set,examples)) #functional approach: intersect all lists if example is not empty
- examples = list(set(examples) & set([r[0] for r in selected]))
- return examples #all examples covered from a single rule
-
-
-def Evaluate (elem,rules,G,selected,infosystem):
- "Calcolate first and second evaluate index, according with original DOMLEM Algorithm"
- tmpRules=copy.deepcopy(rules)
- tmpElem=copy.deepcopy(elem)
- tmpRules.append(tmpElem)
- Object=[]
- Object=FindObjectCovered(tmpRules,selected)
- if(float(len(Object)))>0:
- firstEvaluate=float(len(set(G) & set(Object))) / float(len(Object))
- secondEvaluate=float(len(set(G) & set(Object)))
- else:
- firstEvaluate=0
- secondEvaluate=0
-
- return firstEvaluate,secondEvaluate
-
-
-
-def FindBestCondition (best, elem, rules, selected, G, infosystem):
- "Choose the best condition"
-
- firstElem,secondElem=Evaluate(elem,rules,G,selected,infosystem)
- firstBest,secondBest=Evaluate(best,rules,G,selected,infosystem)
-
- if (firstElem>firstBest) or (firstElem==firstBest and secondElem>=secondBest):
- best=copy.deepcopy(elem)
- else:
- best=best
-
- return best
-
-
-def Type_one_rule (c, e, preference, matrix):
- elem={'criterion':c,'condition':e, 'sign':preference[c-1],'class':'', \
- 'objectsCovered':[r[0] for r in matrix if (((r[c] >= e ) and (preference[c-1] == 'gain')) \
- or ((r[c] <= e ) and (preference[c-1] == 'cost' )))],'label':''}
- return elem
-
-def Type_three_rule (c, e, preference, matrix):
- elem={'criterion':c,'condition':e, 'sign':preference[c-1],'class':'', \
- 'objectsCovered':[r[0] for r in matrix if (((r[c] <= e ) and (preference[c-1] == 'gain')) \
- or ((r[c] >= e ) and (preference[c-1] == 'cost' )))],'label':''}
- return elem
-
-
-def Find_rules (B, infosystem, type_rule):
- "Search rule from a family of lower approximation of upward unions \
- of decision classes"
- start=time()
- matrix=copy.deepcopy(infosystem['examples'])
- criteria_num=len(infosystem['attributes'])
- criteria=[r[1:-1] for r in matrix]
- preference=[s['preference'] for s in infosystem['attributes'] ] #extract preference label
- num_rules=0 #total rules number for each lower approximation
- G=copy.deepcopy(B) #a set of objects from the given approximation
- E=[] #a set of rules covering set B (is a list of dictionary)
- all_obj_cov_by_rules=[] #all objects covered by all rules in E
- selected=copy.deepcopy(matrix) #storage reduct matrix by single elementary condition
- while (len(G)!=0 ):
- rules=[] #starting comples (single rule built from elementary conditions )
- S=copy.deepcopy(G) #set of objects currently covered by rule
- control=0
- while (len(rules)==0 or set(obj_cov_by_rules).issubset(B)==False):
- obj_cov_by_rules=[] #set covered by rules
- best={'criterion':'','condition':'','sign':'','class':'','objectsCovered':'','label':'', 'type':''} #best candidate for elementary condition - start as empty
- for c in range(1, criteria_num):
- Cond=[r[c] for r in selected if r[0] in S] #for each positive object from S create an elementary condition
- for e in Cond:
- if type_rule=='one':
- elem= Type_one_rule (c, e, preference, matrix)
- elif type_rule=='three':
- elem= Type_three_rule (c, e, preference, matrix)
- else:
- elem={'criterion':'','condition':'','sign':'','class':'','objectsCovered':'','label':'', 'type':''}
- best=FindBestCondition(best, elem, rules, selected, G, infosystem)
- if best not in rules:
- rules.append(best) #add the best condition to the complex
-
- for r in rules:
- obj_cov_by_rules.append(r['objectsCovered'])
- obj_cov_by_rules=list((reduce(set.intersection,map(set,obj_cov_by_rules)))) #reduce():Apply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value.
-
- S=list(set(S) & set(best['objectsCovered'] ))
- control+=1
-
-# rules=CheckMinimalCondition (rules,B,matrix)
-
- if rules not in E:
- E.append(rules) #add the induced rule
- num_rules+=1
- all_obj_cov_by_rules=list(set(all_obj_cov_by_rules) | set(obj_cov_by_rules))
-
- G=list(set(B)-set(all_obj_cov_by_rules)) #remove example coverred by all finded rule -- this operation is a set difference
- selected=[o for o in selected if not o[0] in all_obj_cov_by_rules] #reduct matrix, remove object coverred by all finded rule
- num_rules+=1
-
- return E
-
-
-
-def Domlem(Lu,Ld, infosystem):
- "DOMLEM algoritm \
- (An algorithm for induction of decision rules consistent with the dominance\
- principle - Greco S., Matarazzo, B., Slowinski R., Stefanowski J.)"
- attributes=infosystem['attributes']
-
- RULES=[]
-
-## *** AT MOST {<= Class} - Type 3 rules ***"
- for b in Ld[:-1]:
- B=b['objects']
- E=Find_rules(B, infosystem, 'three')
- for e in E:
- for i in e:
- i['class']=b['class']
- i['label']=attributes[i['criterion']-1]['name']
- i['type']='at_most'
- if (attributes[i['criterion']-1]['preference']=='gain'):
- i['sign']='<='
- else:
- i['sign']='>='
- RULES.append(e)
-
-## *** AT LEAST {>= Class} - Type 1 rules *** "
- for a in Lu[1:]:
- B=a['objects']
- E=Find_rules (B, infosystem, 'one')
- for e in E:
- for i in e:
- i['class']=a['class']
- i['label']=attributes[i['criterion']-1]['name']
- i['type']='at_least'
- if (attributes[i['criterion']-1]['preference']=='gain'):
- i['sign']='>='
- else:
- i['sign']='<='
- RULES.append(e)
-
- return RULES
-
-
-def Print_rules(RULES, outputTxt):
- "Print rls output file"
- i=1
- outfile=open(outputTxt+".rls","w")
- outfile.write('[RULES]\n')
-
- for R in RULES:
- outfile.write("%d: " % i, )
- for e in R:
- outfile.write("( %s %s %.3f )" % (e['label'], e['sign'],e['condition'] ))
- outfile.write("=> ( class %s , %s )\n" % ( e['type'], e['class'] ))
- i+=1
- outfile.close()
- return 0
-
-def Parser_mapcalc(RULES, outputMap):
- "Parser to build a formula to be included in mapcalc command"
- i=1
- category=[]
- maps=[]
- stringa=[]
-
- for R in RULES:
- formula="if("
- for e in R[:-1]: #build a mapcalc formula
- formula+= "(%s %s %.4f ) && " % (e['label'], e['sign'] , e['condition'] )
- formula+= "(%s %s %.4f ),%d,null())" % (R[-1]['label'],R[-1]['sign'], R[-1]['condition'] ,i )
- mappa="r%d_%s_%d" % ( i, R[0]['type'], R[0]['class'] ) #build map name for mapcalc output
- category.append({'id':i, 'type': R[0]['type'], 'class':R[0]['class']}) #extract category name
- maps.append(mappa) #extract maps name
- grass.mapcalc(mappa +"=" +formula)
- i+=1
- mapstring=",".join(maps)
-
-
- #make one layer for each label rule
- labels=["_".join(m.split('_')[1:]) for m in maps]
- labels=list(set(labels))
- for l in labels:
- print "mapping %s rule" % str(l)
- map_synth=[]
- for m in maps:
- if l == "_".join(m.split('_')[1:]):
- map_synth.append(m)
- if len(map_synth)>1:
- grass.run_command("r.patch", overwrite='True', input=(",".join(map_synth)), output=l )
- else:
- grass.run_command("g.copy",rast=(str(map_synth),l))
- print "__",str(map_synth),l
- grass.run_command("r.to.vect", overwrite='True', flags='s', input=l, output=l, feature='area')
- grass.run_command("v.db.addcol", map=l, columns='rule varchar(25)')
- grass.run_command("v.db.update", map=l, column='rule', value=l)
- grass.run_command("v.db.update", map=l, column='label', value=l)
- mapslabels=",".join(labels)
-
- if len(maps)>1:
- grass.run_command("v.patch", overwrite='True', flags='e', input=mapslabels, output=outputMap)
- else:
- grass.run_command("g.copy",vect=(mapslabels,outputMap))
-
- if not flags['l']:
- grass.run_command("g.remove", rast=mapstring)
- grass.run_command("g.remove", vect=mapstring)
-
- return 0
-
-
-def main():
- "main function for DOMLEM algorithm"
- #try:
- start=time()
- attributes = options['criteria'].split(',')
- preferences=options['preferences'].split(',')
- decision=options['decision']
- outputMap= options['outputMap']
- outputTxt= options['outputTxt']
- out=BuildFileISF(attributes, preferences, decision, outputMap, outputTxt)
- infosystem=FileToInfoSystem(out)
-
- UnionOfClasses(infosystem)
- DownwardUnionClass=DownwardUnionsOfClasses(infosystem)
- UpwardUnionClass=UpwardUnionsOfClasses(infosystem)
- Dominating=DominatingSet(infosystem)
- Dominated=DominatedSet(infosystem)
-## upward union class
- print "elaborate upward union"
- Lu=LowerApproximation(UpwardUnionClass, Dominating) #lower approximation of upward union for type 1 rules
- Uu=UpperApproximation(UpwardUnionClass,Dominated ) #upper approximation of upward union
- UpwardBoundary=Boundaries(Uu, Lu)
-## downward union class
- print "elaborate downward union"
- Ld=LowerApproximation(DownwardUnionClass, Dominated) # lower approximation of downward union for type 3 rules
- Ud=UpperApproximation(DownwardUnionClass,Dominating ) # upper approximation of downward union
- DownwardBoundary=Boundaries(Ud, Ld)
- QualityOfQpproximation(DownwardBoundary, infosystem)
- print "RULES extraction (*)"
- RULES=Domlem(Lu,Ld, infosystem)
- Parser_mapcalc(RULES, outputMap)
- Print_rules(RULES, outputTxt)
- end=time()
- print "Time computing-> %.4f s" % (end-start)
- return 0
- #except:
- #print "ERROR! Rules does not generated!"
- #sys.exit()
-
-if __name__ == "__main__":
- options, flags = grass.parser()
- sys.exit(main())
-
-
More information about the grass-commit
mailing list