def run(self):
# prevent eventual locks
gc.collect()
self.fragments_left = []
arcpy.AddMessage(encode('Lösche Projekte'))
projects_to_delete = self.par.projekte.values
step = 100 / len(projects_to_delete)
pos = 0
for project in projects_to_delete:
pos += step
arcpy.SetProgressorPosition(pos)
arcpy.SetProgressorLabel(
encode(u'Lösche Projekt {}'.format(project)))
self.compact_gdbs(project)
self.remove_project_from_output(project)
self.projekt_loeschen(project)
config = self.parent_tbx.config
if len(self.fragments_left) > 0:
arcpy.AddError(u'Folgende Projekte konnten aufgrund von '
u'Schemasperren nicht restlos entfernt werden:')
arcpy.AddError(', '.join(self.fragments_left))
arcpy.AddError('Bitte starten Sie ArcMap neu und '
'versuchen Sie es erneut!')
# change active project, if it was deleted
if config.active_project in projects_to_delete:
projects = self.folders.get_projects()
config.active_project = projects[0] if len(projects) > 0 else ''
def _getParameterInfo(self):
# Projekt
params = self.par
p = self.add_parameter('projectname')
p.name = u'Projekt'
p.displayName = u'Projekt'
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPString'
projects = self.folders.get_projects()
p.filter.list = projects
p.value = '' if len(projects) == 0 else p.filter.list[0]
# Teilfläche
p = self.add_parameter('area')
p.name = encode(u'Teilfläche')
p.displayName = encode(u'Teilfläche')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPString'
p.filter.list = []
self.df_types_of_use = self.table_to_dataframe(
'Nutzungsarten', workspace='FGDB_Definition_Projekt_Tool.gdb',
is_base_table=True
)
return params
def _getParameterInfo(self):
params = self.par
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
# markets radius
p = self.add_parameter('radius_markets')
p.name = u'radius_markets'
p.displayName = encode(u'Pufferzone für Märkte um gewählte '
u'Gemeinden festlegen (in m)')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPLong'
p.filter.type = 'Range'
p.filter.list = [3000, 10000]
p.value = 6000
p.enabled = True
return params
def _getParameterInfo(self):
params = self.par
projekte = self.folders.get_projects()
# Projekt_auswählen
p = self.add_parameter('projectname')
p.name = u'Projekt_auswählen'.encode('cp1252')
p.displayName = u'Projekt'.encode('cp1252')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPString'
p.value = self.config.active_project
param = self.add_parameter('stops')
param.name = encode(u'stops')
param.displayName = encode(u'Name der Haltestelle')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
self.df_stops = []
return params
def _getParameterInfo(self):
params = self.par
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
# markets radius
p = self.add_parameter('radius_markets')
p.name = u'radius_markets'
p.displayName = encode(u'Pufferzone für Märkte um gewählte '
u'Gemeinden festlegen (in m)')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPLong'
p.filter.type = 'Range'
p.filter.list = [3000, 10000]
p.value = 6000
p.enabled = True
return params
def _getParameterInfo(self):
params = self.par
projekte = self.folders.get_projects()
# Projekt_auswählen
p = self.add_parameter('projectname')
p.name = u'Projekt_auswählen'.encode('cp1252')
p.displayName = u'Projekt'.encode('cp1252')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPString'
p.value = self.config.active_project
param = self.add_parameter('stops')
param.name = encode(u'stops')
param.displayName = encode(u'Name der Haltestelle')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
self.df_stops = []
return params
def _getParameterInfo(self):
# Bestehendes_Projekt_auswählen
p = self.add_parameter('projectname')
p.name = encode('Projekt')
p.displayName = encode('Projekt')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
p.filter.list = []
return self.par
def _getParameterInfo(self):
# Bestehendes_Projekt_auswählen
p = self.add_parameter('projectname')
p.name = encode('Projekt')
p.displayName = encode('Projekt')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
p.filter.list = []
return self.par
def _getParameterInfo(self):
super(TbxErreichbarkeitOEPNV, self)._getParameterInfo()
params = self.par
params.stops.displayName = encode(u'Abfahrt von Haltestelle:')
param = self.add_parameter('recalculate')
param.name = encode(u'Neuberechnung')
param.displayName = encode(u'Neuberechnung erzwingen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
return params
def _getParameterInfo(self):
super(TbxErreichbarkeitOEPNV, self)._getParameterInfo()
params = self.par
params.stops.displayName = encode(u'Abfahrt von Haltestelle:')
param = self.add_parameter('recalculate')
param.name = encode(u'Neuberechnung')
param.displayName = encode(u'Neuberechnung erzwingen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
return params
def _getParameterInfo(self):
projects = self.folders.get_projects()
# Bestehendes_Projekt_auswählen
p = self.add_parameter('projekte')
p.name = encode('1-Projekt_auswählen')
p.displayName = encode('Zu löschende Projekte auswählen')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
p.multiValue = True
p.filter.list = projects
return self.par
def _getParameterInfo(self):
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('centers')
param.name = encode(u'Zentren')
param.displayName = encode(u'Zentrum auswählen')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('name')
param.name = encode(u'Name')
param.displayName = encode(u'Name des Zentrums')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param = self.add_parameter('do_delete')
param.name = encode(u'Löschen')
param.displayName = encode(u'Zentrum entfernen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
self.centers_df = []
return self.par
def _getParameterInfo(self):
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('template_type')
param.name = encode(u'type')
param.displayName = encode(u'Dateiformat des zu erzeugenden Templates')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = MarketTemplate.template_types.keys()
param.value = param.filter.list[1]
param = self.add_parameter('folder')
param.name = encode(u'folder')
param.displayName = encode(u'Zielordner')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'DEFolder'
param = self.add_parameter('show_help')
param.name = encode(u'Hilfe')
param.displayName = encode(u'Kurzanleitung zum Ausfüllen anzeigen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
return self.par
def _getParameterInfo(self):
projects = self.folders.get_projects()
# Bestehendes_Projekt_auswählen
p = self.add_parameter('projekte')
p.name = encode('1-Projekt_auswählen')
p.displayName = encode('Zu löschende Projekte auswählen')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
p.multiValue = True
p.filter.list = projects
return self.par
def _getParameterInfo(self):
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('centers')
param.name = encode(u'Zentren')
param.displayName = encode(u'Zentrum auswählen')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('name')
param.name = encode(u'Name')
param.displayName = encode(u'Name des Zentrums')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param = self.add_parameter('do_delete')
param.name = encode(u'Löschen')
param.displayName = encode(u'Zentrum entfernen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
self.centers_df = []
return self.par
def _getParameterInfo(self):
params = self.par
# Bestehendes_Projekt_auswählen
p = self.add_parameter('name')
p.name = encode('Projekt')
p.displayName = encode('Projekt')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
active = self.config.active_project
projects = self.folders.get_projects()
p.filter.list = projects
if active and active in projects:
p.value = active
return params
def _create(self, **kwargs):
"""
Diagramm für Teilflächen
"""
# Erstelle Diagramm Teilflaechen nach Hektar
project_name = kwargs['project_name'] if 'project_name' in kwargs \
else self.tbx.par.get_projectname()
input_template = self.tbx.folders.get_diagram_template(
'Teilflaechen_Hektar')
# Create the graph
graph = arcpy.Graph()
mxd = arcpy.mapping.MapDocument("CURRENT")
project_layer = self.tbx.output.get_projectlayer(project_name)
input_data = arcpy.mapping.ListLayers(project_layer,
"Nutzungen des Plangebiets",
mxd.activeDataFrame)[0]
del (mxd)
# Add a vertical bar series to the graph
graph.addSeriesBarVertical(dataSrc=input_data,
fieldY="Flaeche_ha",
fieldLabel="Name")
title = encode("{}: Teilflächen des Plangebiets (Bruttofläche)".format(
project_name.encode("utf-8")))
graph.graphPropsGeneral.title = title
return graph, input_template
def _getParameterInfo(self):
params = super(TbxSetSource, self)._getParameterInfo()
params.area.displayName = encode(u'Teilfläche, die über den eben in '
u'der Karte gesetzten Anbindungspunkt'
u' an das Straßennetz angeschlossen'
u'werden soll')
return self.par
def projekt_loeschen(self, project_name):
arcpy.AddMessage(u"Projektname: " + project_name)
# Mit dem Projektnamen zum neuen Projektpfad zusammenführen"
projektPfad = self.folders.get_projectpath(project_name)
arcpy.AddMessage(u"Suche Ordner: " + projektPfad)
# Überprüfen, ob der Projektordner existiert
if isdir(projektPfad):
arcpy.AddMessage("Projektordner gefunden \n")
shutil.rmtree(projektPfad, ignore_errors=True)
try:
arcpy.Delete_management(projektPfad)
except:
pass
arcpy.AddMessage(u"Projektordner gelöscht \n")
else:
arcpy.AddMessage(u"Projektordner " + project_name + u" nicht gefunden \n")
arcpy.AddMessage("*" * 45)
if arcpy.Exists(projektPfad):
self.fragments_left.append(project_name)
arcpy.AddError(encode('Projekt {p} konnte nicht vollständig gelöscht '
'werden.'.format(p=project_name)))
else:
arcpy.AddMessage("Das Projekt " + project_name + " wurde erfolgreich entfernt \n")
def get_layer(self, layername, folder='', enhance = True):
"""
A lyr-file
Parameters
----------
layername : str
the name of the lyr-file
folder : str, optional
a subfolder
enhance = boolean, optional
True -> ".lyr" will be added to layername
Returns
-------
layer : str
the full path to the lyr-file
"""
layername = encode(layername)
if (enhance == True):
layerfile = '{}.lyr'.format(layername)
else:
layerfile = layername
layer = self.join_and_check(self.TEMPLATE_LAYERFOLDER, folder, layerfile)
return layer
def get_diagram_template(self, name, subfolder='', enhance=True):
"""
Return a diagram from the templates
Parameters
----------
name : str
the name of the diagram
subfolder : str, optional
a subfolder for a specific diagram
enhance : bool, optional (Default=True)
if true, add .grf as extension to the diagram name
Returns
-------
path : str
the full path to the diagram
"""
filename = encode(name)
if enhance:
filename = '{}.grf'.format(filename)
diagram_path = self.join_and_check(self.TEMPLATE_DIAGRAMFOLDER,
subfolder,
filename)
return diagram_path
def get_layer(self, layername, folder='', enhance=True):
"""
A lyr-file
Parameters
----------
layername : str
the name of the lyr-file
folder : str, optional
a subfolder
enhance = boolean, optional
True -> ".lyr" will be added to layername
Returns
-------
layer : str
the full path to the lyr-file
"""
layername = encode(layername)
if (enhance == True):
layerfile = '{}.lyr'.format(layername)
else:
layerfile = layername
layer = self.join_and_check(self.TEMPLATE_LAYERFOLDER, folder,
layerfile)
return layer
def _getParameterInfo(self):
params = super(TbxSetSource, self)._getParameterInfo()
params.area.displayName = encode(u'Teilfläche, die über den eben in '
u'der Karte gesetzten Anbindungspunkt'
u' an das Straßennetz angeschlossen'
u'werden soll')
return self.par
def _getParameterInfo(self):
params = super(TbxMaerkteImportierenFeatureClass, self)._getParameterInfo()
param = self.par.template
param.displayName = encode(u'Befüllte Erfassungsvorlage (Shape-Datei)')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPFeatureLayer'
return params
def show_external(self, plot, filename):
filename = str(filename)
if plot is None:
return
with open(filename,'wb') as f:
pickle.dump(plot, f)
subprocess.Popen(
[os.path.join(sys.exec_prefix, 'python.exe'),
'-m' , diagram_exec.__name__, '-f', filename,
'-t', encode(self.title)], shell=True)
def _getParameterInfo(self):
params = super(TbxMaerkteImportierenFeatureClass,
self)._getParameterInfo()
param = self.par.template
param.displayName = encode(u'Befüllte Erfassungsvorlage (Shape-Datei)')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPFeatureLayer'
return params
def _getParameterInfo(self):
params = super(TbxTeilflaecheVerwalten, self)._getParameterInfo()
# Name
p = self.add_parameter('name')
p.name = u'Name'
p.displayName = u'Name'
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPString'
# Nutzungsart
p = self.add_parameter('type_of_use')
p.name = encode(u'Nutzungsart')
p.displayName = encode(u'Nutzungsart')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPString'
p.filter.list = self.df_types_of_use['nutzungsart'].values.tolist()
return params
def _getParameterInfo(self):
params = super(TbxNutzungenEinzelhandel, self)._getParameterInfo()
# no duration needed as the shops are assumed to be finished instantly
self.remove_parameter('dauer_aufsiedlung')
self.remove_parameter('bezugsbeginn')
for srt in self.sortimente.itervalues():
assert isinstance(srt, Sortiment)
# Verkaufsfläche nach Sortiment
param = self.add_parameter(srt.param_vfl)
param.name = encode(srt.kurzname)
param.displayName = encode(u'{} (Verkaufsfläche in qm)'.format(srt.name))
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'Long'
param.value = u'0'
param.filter.type = 'Range'
param.filter.list = [0, 20000]
return params
def _getParameterInfo(self):
params = self.par
# Bestehendes_Projekt_auswählen
p = self.add_parameter('existing_project')
p.name = encode('Bestehendes_Projekt_auswählen')
p.displayName = encode('Bestehendes Projekt auswählen')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
# Name_des_neuen_Projektes
p = self.add_parameter('name')
p.name = u'Name_des_neuen_Projektes'
p.displayName = u'Name des neuen Projekts'
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
p.value = u''
return params
def _getParameterInfo(self):
params = self.par
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
#param = self.add_parameter('count')
#param.name = encode(u'Anzahl')
#param.displayName = encode(u'Maximale Anzahl an '
#u'hinzuzufügenden Märkten')
#param.parameterType = 'Required'
#param.direction = 'Input'
#param.datatype = u'GPLong'
#param.filter.type = 'Range'
#param.filter.list = [0, 5000]
#param.value = 1000
param = self.add_parameter('truncate')
param.name = encode(u'truncate')
param.displayName = encode(u'Vorhandene OSM-Märkte entfernen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
#param = self.add_parameter('known_only')
#param.name = encode(u'known_only')
#param.displayName = encode(u'Nur Märkte großer Ketten hinzufügen')
#param.parameterType = 'Optional'
#param.direction = 'Input'
#param.datatype = u'GPBoolean'
#param.value = True
return params
def _getParameterInfo(self):
params = self.par
# Bestehendes_Projekt_auswählen
p = self.add_parameter('existing_project')
p.name = encode('Bestehendes_Projekt_auswählen')
p.displayName = encode('Bestehendes Projekt auswählen')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
# Name_des_neuen_Projektes
p = self.add_parameter('name')
p.name = u'Name_des_neuen_Projektes'
p.displayName = u'Name des neuen Projekts'
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = 'GPString'
p.value = u''
return params
def _getParameterInfo(self):
params = super(TbxNutzungenWohnen, self)._getParameterInfo()
# specific parameters for "Wohnen"
heading = encode(u"2) Anzahl Wohneinheiten nach Gebäudetypen")
for gt in self.gebaeudetypen.itervalues():
assert isinstance(gt, Gebaeudetyp)
# Anzahl WE in Gebäudetypen
param = self.add_parameter(gt.param_we)
param.name = encode(u'Bewohner {}'.format(gt.display_name))
param.displayName = encode(u'Anzahl WE in {}'.format(gt.display_name))
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'Long'
param.value = u'0'
param.filter.type = 'Range'
param.filter.list = [0, 500]
param.category = heading
heading = ("3) Mittlere Anzahl Einwohner pro Wohneinheit " +
"(3 Jahre nach Bezug)")
for gt in self.gebaeudetypen.itervalues():
assert isinstance(gt, Gebaeudetyp)
# Mittlere Anzahl Einwohner pro WE in Einfamilienhäusern
# (kurz nach dem Bezug)
param = self.add_parameter(gt.param_ew_je_we)
param.name = encode(u'EW_JE_WE {}'.format(gt.display_name))
param.displayName = encode(u'... in {}'.format(gt.display_name))
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPDouble'
param.value = gt.default_ew_je_we
param.filter.list = self.ew_je_we_range
param.category = heading
return params
def show_external(self, plot, filename):
filename = str(filename)
if plot is None:
return
with open(filename, 'wb') as f:
pickle.dump(plot, f)
subprocess.Popen([
os.path.join(sys.exec_prefix, 'python.exe'), '-m',
diagram_exec.__name__, '-f', filename, '-t',
encode(self.title)
],
shell=True)
def _create(self, **kwargs):
project_name = self.tbx.par.get_projectname()
title = encode(
u"{}: qm Wohnfläche pro Hektar Nettowohnbauland"
.format(project_name))
input_template = self.tbx.folders.get_diagram_template(
'Wohnflaechendichte')
graph = arcpy.Graph()
input_data = self.tbx.folders.get_table("Wohnflaechendichte", "FGDB_Flaeche_und_Oekologie.gdb")
graph.addSeriesBarVertical(dataSrc=input_data,
fieldY= "Wohnflaechendichte",
fieldLabel="Typ")
graph.graphPropsGeneral.title = title
return graph, input_template
def _create(self, **kwargs):
project_name = self.tbx.par.get_projectname()
title = encode(
u"{}: Bodenbedeckung im Planfall"
.format(project_name))
input_template = self.tbx.folders.get_diagram_template(
'Bodenbedeckung')
graph = arcpy.Graph()
input_data = self.tbx.folders.get_table("Bodenbedeckung_Zeichnung", "FGDB_Flaeche_und_Oekologie.gdb")
graph.addSeriesBarVertical(dataSrc=input_data,
fieldY= "Planfall",
fieldLabel="Bodenbedeckung")
graph.graphPropsGeneral.title = title
return graph, input_template
def _getParameterInfo(self):
params = self.par
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('radius')
param.name = encode(u'radius')
param.displayName = encode(u'Radius in Kilometern')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPLong'
param.filter.type = 'Range'
param.filter.list = [1, 20]
param.value = 10
return params
def _getParameterInfo(self):
params = self.par
projekte = self.folders.get_projects()
# Projekt_auswählen
p = self.add_parameter('projectname')
p.name = u'Projekt_auswählen'.encode('cp1252')
p.displayName = u'Projekt'.encode('cp1252')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPString'
p.value = self.config.active_project
p.enabled = False
# markets radius
p = self.add_parameter('radius_sz')
p.name = u'radius_sz'
p.displayName = encode(u'Pufferzone für Siedlungszellen um gewählte '
u'Gemeinden festlegen (in m)')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPLong'
p.filter.type = 'Range'
p.filter.list = [0, 5000]
p.value = 2000
param = self.add_parameter('recalculate')
param.name = encode(u'Neuberechnung')
param.displayName = encode(u'Neuberechnung der Distanzen und '
u'Siedlungszellen erzwingen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
return params
def _getParameterInfo(self):
params = self.par
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('template')
param.name = encode(u'template')
param = self.add_parameter('truncate')
param.name = encode(u'truncate')
param.displayName = encode(u'Vorhandene Märkte entfernen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
return params
def _create(self, **kwargs):
project_name = self.tbx.par.get_projectname()
title = encode(
u"{}: Bodenkennwert Biotopausbildungsvermögen"
.format(project_name))
input_template = self.tbx.folders.get_diagram_template(
'Bodenkennwerte')
graph = arcpy.Graph()
input_data = self.tbx.folders.get_table("Leistungskennwerte", "FGDB_Flaeche_und_Oekologie.gdb")
graph.addSeriesBarVertical(dataSrc=input_data,
fieldY= "Biotopausbildungsvermoegen",
fieldLabel="Kategorie")
graph.graphPropsGeneral.title = title
return graph, input_template
def _create(self, **kwargs):
project_name = self.tbx.par.get_projectname()
title = encode(
"{}: Anteil der Plangebietsgrenze (in Prozent), der ..."
.format(project_name))
input_template = self.tbx.folders.get_diagram_template(
'Integrationsgrad')
graph = arcpy.Graph()
input_data = self.tbx.folders.get_table("Integrationsgrad", "FGDB_Flaeche_und_Oekologie.gdb")
graph.addSeriesPie(dataSrc=input_data,
fieldValue = "Umfang",
fieldLabel="Grenze")
graph.graphPropsGeneral.title = title
return graph, input_template
def _getParameterInfo(self):
params = self.par
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('template')
param.name = encode(u'template')
param = self.add_parameter('truncate')
param.name = encode(u'truncate')
param.displayName = encode(u'Vorhandene Märkte entfernen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
return params
def _getParameterInfo(self):
params = self.par
projekte = self.folders.get_projects()
# Projekt_auswählen
p = self.add_parameter('projectname')
p.name = u'Projekt_auswählen'.encode('cp1252')
p.displayName = u'Projekt'.encode('cp1252')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPString'
p.value = self.config.active_project
p.enabled = False
# markets radius
p = self.add_parameter('radius_sz')
p.name = u'radius_sz'
p.displayName = encode(u'Pufferzone für Siedlungszellen um gewählte '
u'Gemeinden festlegen (in m)')
p.parameterType = 'Required'
p.direction = 'Input'
p.datatype = u'GPLong'
p.filter.type = 'Range'
p.filter.list = [0, 5000]
p.value = 2000
param = self.add_parameter('recalculate')
param.name = encode(u'Neuberechnung')
param.displayName = encode(u'Neuberechnung der Distanzen und '
u'Siedlungszellen erzwingen')
param.parameterType = 'Optional'
param.direction = 'Input'
param.datatype = u'GPBoolean'
return params
def _getParameterInfo(self):
params = self.par
# Projekt_auswählen
param = self.add_parameter('projectname')
param.name = encode(u'Projekt_auswählen')
param.displayName = encode(u'Projekt')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = []
param = self.add_parameter('cutoff')
param.name = encode(u'Erreichbarkeit')
param.displayName = encode(u'Erreichbarkeit in x Minuten')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPLong'
param.filter.type = 'Range'
param.filter.list = [5, 60]
param.value = 10
return params
def _getParameterInfo(self):
params = super(TbxMaerkteImportierenDatei, self)._getParameterInfo()
param = self.par.template
param.displayName = encode(u'Befüllte Erfassungsvorlage (csv- oder '
u'Excel- Datei)')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'DEFile'
#param.filter.type = 'File'
#param.filter.list = [e.replace('.', '')
#for e in MarketTemplate.template_types.values()]
param.filter.list = ['csv', 'xlsx']
return params
def _getParameterInfo(self):
params = super(TbxMaerkteImportierenDatei, self)._getParameterInfo()
param = self.par.template
param.displayName = encode(u'Befüllte Erfassungsvorlage (csv- oder '
u'Excel- Datei)')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'DEFile'
#param.filter.type = 'File'
#param.filter.list = [e.replace('.', '')
#for e in MarketTemplate.template_types.values()]
param.filter.list = ['csv', 'xlsx']
return params
def _create(self, **kwargs):
"""
Diagramm für die Zuzugsstatistik (SvB)
"""
project_name = self.tbx.par.get_projectname()
title = encode(
"{}: Herkunftsorte der Arbeitsplätze im Plangebiet"
.format(project_name))
input_template = self.tbx.folders.get_diagram_template(
'Zuzugsstatistik')
graph = arcpy.Graph()
input_data = self.tbx.folders.get_table("Zuzugsstatistik_SvB", "FGDB_Einnahmen.gdb")
graph.addSeriesBarVertical(dataSrc=input_data,
fieldY= "Anzahl",
fieldLabel="Kategorie")
graph.graphPropsGeneral.title = title
return graph, input_template
class TbxExtendMarkets(TbxEditMarkets):
setting = CHANGE
_label = encode(u'Bestehende Märkte im Planfall verändern')
def _updateParameters(self, params):
if len(self.markets_df) == 0:
return
market_idx = self.markets_df['pretty'] == self.par.markets.value
altered = False
if self.par.changed('type_name'):
id_typ = self.df_types['id_betriebstyp'][
self.df_types['pretty'] == self.par.type_name.value].values[0]
self.markets_df.loc[market_idx, 'id_betriebstyp_planfall'] = id_typ
altered = True
elif self.par.changed('do_close'):
if self.par.do_close.value:
self.markets_df.loc[market_idx, 'id_betriebstyp_planfall'] = 0
else:
self.markets_df.loc[market_idx, 'id_betriebstyp_planfall'] = \
self.markets_df.loc[market_idx, 'id_betriebstyp_nullfall']
altered = True
if altered:
id_typ = self.markets_df.loc[market_idx,
'id_betriebstyp_planfall'].values[0]
id_kette = self.markets_df.loc[market_idx, 'id_kette'].values[0]
if id_typ == 0:
vkfl = 0
else:
vkfl = self.betriebstyp_to_vkfl(id_typ, id_kette)
self.markets_df.loc[market_idx, 'vkfl_planfall'] = vkfl
i = np.where(market_idx == True)[0][0]
pretty = self.get_pretty_market_name(self.markets_df.iloc[i])
self.markets_df.loc[market_idx, 'pretty'] = pretty
self.update_market_list()
# market changed -> change values of input fields
if self.par.changed('markets') or altered:
self.set_selected_market_inputs()
return params
def get_diagram_template(self, name, subfolder='', enhance=True):
"""
Return a diagram from the templates
Parameters
----------
name : str
the name of the diagram
subfolder : str, optional
a subfolder for a specific diagram
enhance : bool, optional (Default=True)
if true, add .grf as extension to the diagram name
Returns
-------
path : str
the full path to the diagram
"""
filename = encode(name)
if enhance:
filename = '{}.grf'.format(filename)
diagram_path = self.join_and_check(self.TEMPLATE_DIAGRAMFOLDER,
subfolder, filename)
return diagram_path
def _getParameterInfo(self):
params = super(TbxNutzungenGewerbe, self)._getParameterInfo()
self.df_comm_types = self.table_to_dataframe(
'Gewerbegebietstypen',
workspace='FGDB_Definition_Projekt_Tool.gdb',
is_base_table=True
)
# extend the commercial types
default_idx = self.df_comm_types['IDGewerbegebietstyp'] == self._default_typ_id
self.df_comm_types.loc[default_idx, 'Name_Gewerbegebietstyp'] += ' (default)'
custom_row = pd.DataFrame(columns=self.df_comm_types.columns)
custom_row['IDGewerbegebietstyp'] = [Gewerbegebietstyp.BENUTZERDEFINIERT]
custom_row['Name_Gewerbegebietstyp'] = ['Benutzerdefiniert']
self.df_comm_types = self.df_comm_types.append(
custom_row, ignore_index=True).sort('IDGewerbegebietstyp')
self.df_presets = self.table_to_dataframe(
'Vorschlagswerte_Branchenstruktur',
workspace='FGDB_Definition_Projekt_Tool.gdb',
is_base_table=True
)
self.df_density = self.table_to_dataframe(
'Dichtekennwerte_Gewerbe',
workspace='FGDB_Definition_Projekt_Tool.gdb',
is_base_table=True
)
heading = u"2) Voraussichtlicher Anteil der Branchen an der Nettofläche"
# Gebietstyp auswählen
param = self.add_parameter('gebietstyp')
param.name = u'Gebietstyp'
param.displayName = encode(u'Gebietstyp auswählen')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = self.df_comm_types['Name_Gewerbegebietstyp'].values.tolist()
param.value = param.filter.list[0]
param.category = heading
# remember params
sum_params = []
for branche in self.branchen.itervalues():
assert isinstance(branche, Branche)
param = self.add_parameter(branche.param_gewerbenutzung)
param.name = encode(encode(branche.name))
param.displayName = encode(
u'{} (in % der Nettofläche)'.format(branche.name))
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'Long'
param.value = branche.default_gewerbenutzung
param.filter.type = 'Range'
param.filter.list = [0, 100]
param.category = heading
sum_params.append(branche.param_gewerbenutzung)
self.add_dependency(sum_params, 100)
heading = u'3) Voraussichtliche Anzahl an Arbeitsplätzen'
# Arbeitsplatzzahl schätzen
param = self.add_parameter('auto')
param.name = u'Arbeitsplatzzahl schätzen'
param.displayName = encode(u'Vorgehen zur Schätzung der Zahl der '
u'Arbeitsplätze nach Vollbezug')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPString'
param.filter.list = [u'Eigenen Wert eingeben',
u'Arbeitsplatzzahl automatisch schätzen']
param.value = param.filter.list[0]
param.category = heading
# Arbeitsplätze insgesamt
param = self.add_parameter('arbeitsplaetze_insgesamt')
param.name = u'Arbeitsplätze insgesamt'
param.displayName = encode(u'Schätzung der Zahl der Arbeitsplätze '
u'nach Vollbezug (Summe über alle '
u'Branchen)')
param.parameterType = 'Required'
param.direction = 'Input'
param.datatype = u'GPLong'
param.category = heading
param.enabled = False
param.filter.type = 'Range'
param.filter.list = [0, 10000]
return params
