def AddOverlay(self, id, type, command,
l_active = True, l_hidden = True, l_opacity = 1.0, l_render = False):
"""!Adds overlay (grid, barscale, legend, etc.) to list of
overlays
@param id overlay id (PseudoDC)
@param type overlay type (barscale, legend)
@param command GRASS command to render overlay
@param l_active overlay activated (True) or disabled (False)
@param l_hidden overlay is not shown in layer tree (if True)
@param l_render render an image (if True)
@return new layer on success
@retutn None on failure
"""
Debug.msg (2, "Map.AddOverlay(): cmd=%s, render=%d" % (command, l_render))
overlay = Overlay(id = id, type = type, cmd = command,
active = l_active, hidden = l_hidden, opacity = l_opacity)
# add maplayer to the list of layers
self.overlays.append(overlay)
if l_render and command != '' and not overlay.Render():
raise gcmd.GException(_("Unable render overlay <%s>.") %
name)
return self.overlays[-1]
def AlignExtentFromDisplay(self):
"""!Align region extent based on display size from center
point"""
# calculate new bounding box based on center of display
if self.region["ewres"] > self.region["nsres"]:
res = self.region["ewres"]
else:
res = self.region["nsres"]
Debug.msg(3, "Map.AlignExtentFromDisplay(): width=%d, height=%d, res=%f, center=%f,%f" % \
(self.width, self.height, res, self.region['center_easting'],
self.region['center_northing']))
ew = (self.width / 2) * res
ns = (self.height / 2) * res
self.region['n'] = self.region['center_northing'] + ns
self.region['s'] = self.region['center_northing'] - ns
self.region['e'] = self.region['center_easting'] + ew
self.region['w'] = self.region['center_easting'] - ew
# LL locations
if self.projinfo['proj'] == 'll':
self.region['n'] = min(self.region['n'], 90.0)
self.region['s'] = max(self.region['s'], -90.0)
def DeleteLayer(self, layer, overlay = False):
"""!Removes layer from list of layers
@param layer layer instance in layer tree
@param overlay delete overlay (use self.DeleteOverlay() instead)
@return removed layer on success or None
"""
Debug.msg (3, "Map.DeleteLayer(): name=%s" % layer.name)
if overlay:
list = self.overlays
else:
list = self.layers
if layer in list:
if layer.mapfile:
base = os.path.split(layer.mapfile)[0]
mapfile = os.path.split(layer.mapfile)[1]
tempbase = mapfile.split('.')[0]
if base == '' or tempbase == '':
return None
basefile = os.path.join(base, tempbase) + r'.*'
for f in glob.glob(basefile):
os.remove(f)
list.remove(layer)
return layer
return None
def Draw(self, pdc, img = None, drawid = None, pdctype = 'image', coords = [0,0,0,0]):
"""!Draws histogram or clears window
"""
if drawid == None:
if pdctype == 'image' :
drawid = imagedict[img]
elif pdctype == 'clear':
drawid == None
else:
drawid = wx.NewId()
else:
pdc.SetId(drawid)
pdc.BeginDrawing()
Debug.msg (3, "BufferedWindow.Draw(): id=%s, pdctype=%s, coord=%s" % (drawid, pdctype, coords))
if pdctype == 'clear': # erase the display
bg = wx.WHITE_BRUSH
pdc.SetBackground(bg)
pdc.Clear()
self.Refresh()
pdc.EndDrawing()
return
if pdctype == 'image':
bg = wx.TRANSPARENT_BRUSH
pdc.SetBackground(bg)
bitmap = wx.BitmapFromImage(img)
w,h = bitmap.GetSize()
pdc.DrawBitmap(bitmap, coords[0], coords[1], True) # draw the composite map
pdc.SetIdBounds(drawid, (coords[0],coords[1],w,h))
pdc.EndDrawing()
self.Refresh()
def _renderLayers(self, force, mapWindow):
maps = list()
masks = list()
opacities = list()
# render map layers
ilayer = 1
for layer in self.layers + self.overlays:
# skip non-active map layers
if not layer or not layer.active:
continue
# render
if force or layer.force_render:
if not layer.Render():
continue
if mapWindow:
# update progress bar
### wx.SafeYield(mapWindow)
event = wxUpdateProgressBar(value = ilayer)
wx.PostEvent(mapWindow, event)
# add image to compositing list
if layer.type != "overlay":
maps.append(layer.mapfile)
masks.append(layer.maskfile)
opacities.append(str(layer.opacity))
Debug.msg(3, "Map.Render() type=%s, layer=%s " % (layer.type, layer.name))
ilayer += 1
return maps, masks, opacities
def RunCmd(self, command, compReg = True, switchPage = False,
onDone = None):
"""!Run command typed into console command prompt (GPrompt).
@todo Display commands (*.d) are captured and processed
separately by mapdisp.py. Display commands are rendered in map
display widget that currently has the focus (as indicted by
mdidx).
@param command command given as a list (produced e.g. by utils.split())
@param compReg True use computation region
@param switchPage switch to output page
@param onDone function to be called when command is finished
@return 0 on success
@return 1 on failure
"""
if len(command) == 0:
Debug.msg(2, "GPrompt:RunCmd(): empty command")
return 0
# update history file
env = grass.gisenv()
try:
fileHistory = codecs.open(os.path.join(env['GISDBASE'],
env['LOCATION_NAME'],
env['MAPSET'],
'.bash_history'),
encoding = 'utf-8', mode = 'a')
except IOError, e:
self.WriteError(e)
fileHistory = None
def OnLeftUp(self, event):
"""!Left mouse button released
"""
Debug.msg (5, "BufferedWindow.OnLeftUp(): use=%s" % \
self.mouse["use"])
self.mouse['end'] = event.GetPositionTuple()[:]
if self.mouse['use'] in ["zoom", "pan"]:
# set region in zoom or pan
begin = self.mouse['begin']
end = self.mouse['end']
if self.mouse['use'] == 'zoom':
# set region for click (zero-width box)
if begin[0] - end[0] == 0 or \
begin[1] - end[1] == 0:
# zoom 1/2 of the screen (TODO: settings)
begin = (end[0] - self.Map.width / 4,
end[1] - self.Map.height / 4)
end = (end[0] + self.Map.width / 4,
end[1] + self.Map.height / 4)
self.Zoom(begin, end, self.zoomtype)
# redraw map
self.UpdateMap(render=True)
# update statusbar
self.parent.StatusbarUpdate()
def _onMouseMoving(self, event):
self.mouse['end'] = event.GetPositionTuple()[:]
Debug.msg (5, "BufferedWindow.OnMouseMoving(): coords=%f,%f" % \
(self.mouse['end'][0], self.mouse['end'][1]))
action = self.toolbar.GetAction()
if action == "addLine" and \
self.toolbar.GetAction('type') in ["line", "boundary", "area"]:
if len(self.polycoords) > 0:
self.MouseDraw(pdc = self.pdcTmp, begin = self.Cell2Pixel(self.polycoords[-1]))
elif action in ["moveLine", "moveVertex", "editLine"] \
and hasattr(self, "moveInfo"):
dx = self.mouse['end'][0] - self.mouse['begin'][0]
dy = self.mouse['end'][1] - self.mouse['begin'][1]
# draw lines on new position
if action == "moveLine" and \
len(self.moveInfo['id']) > 0:
# move line
for id in self.moveInfo['id']:
self.pdcTmp.TranslateId(id, dx, dy)
elif action in ["moveVertex", "editLine"]:
# move vertex ->
# (vertex, left vertex, left line,
# right vertex, right line)
# do not draw static lines
if action == "moveVertex" and \
len(self.moveInfo['id']) > 0:
self.polycoords = []
self.pdcTmp.RemoveId(self.moveInfo['id'][0])
if self.moveInfo['id'][1] > 0: # previous vertex
x, y = self.Pixel2Cell(self.pdcTmp.GetIdBounds(self.moveInfo['id'][1])[0:2])
self.pdcTmp.RemoveId(self.moveInfo['id'][1] + 1)
self.polycoords.append((x, y))
self.polycoords.append(self.Pixel2Cell(self.mouse['end']))
if self.moveInfo['id'][2] > 0: # next vertex
x, y = self.Pixel2Cell(self.pdcTmp.GetIdBounds(self.moveInfo['id'][2])[0:2])
self.pdcTmp.RemoveId(self.moveInfo['id'][2]-1)
self.polycoords.append((x, y))
self.ClearLines(pdc = self.pdcTmp)
self.DrawLines(pdc = self.pdcTmp)
if action == "editLine":
self.MouseDraw(pdc = self.pdcTmp,
begin = self.Cell2Pixel(self.polycoords[-1]))
self.Refresh() # TODO: use RefreshRect()
self.mouse['begin'] = self.mouse['end']
elif action == "zbulkLine":
if len(self.polycoords) == 1:
# draw mouse moving
self.MouseDraw(self.pdcTmp)
def ChangeLayerName (self, layer, name):
"""!Change name of the layer
@param layer layer instance in layer tree
@param name layer name to set up
"""
Debug.msg (3, "Map.ChangeLayerName(): from=%s to=%s" % \
(layer.name, name))
layer.name = name
def ChangeLayerActive(self, layer, active):
"""!Enable or disable map layer
@param layer layer instance in layer tree
@param active to be rendered (True)
"""
layer.active = active
Debug.msg (3, "Map.ChangeLayerActive(): name='%s' -> active=%d" % \
(layer.name, layer.active))
def SetCmd(self, cmd):
"""!Set new command for layer"""
if self.type == 'command':
self.cmd = []
for c in cmd:
self.cmd.append(utils.CmdToTuple(c))
else:
self.cmd = utils.CmdToTuple(cmd)
Debug.msg(3, "Layer.SetCmd(): cmd='%s'" % self.GetCmd(string = True))
# for re-rendering
self.force_render = True
def __InitDisplay(self):
"""
Initialize map display, set dimensions and map region
"""
self.width, self.height = self.GetClientSize()
Debug.msg(2, "MapFrame.__InitDisplay():")
self.grwiz.SwitchEnv('source')
self.SrcMap.ChangeMapSize(self.GetClientSize())
self.SrcMap.region = self.SrcMap.GetRegion() # g.region -upgc
self.grwiz.SwitchEnv('target')
self.TgtMap.ChangeMapSize(self.GetClientSize())
self.TgtMap.region = self.TgtMap.GetRegion() # g.region -upgc
def ReorderLayers(self, layerList):
"""!Reorder list to match layer tree
@param layerList list of layers
"""
self.layers = layerList
layerNameList = ""
for layer in self.layers:
if layer.name:
layerNameList += layer.name + ','
Debug.msg (4, "Map.ReoderLayers(): layers=%s" % \
(layerNameList))
def ChangeOpacity(self, layer, l_opacity):
"""!Changes opacity value of map layer
@param layer layer instance in layer tree
@param l_opacity opacity level <0;1>
"""
# l_opacity must be <0;1>
if l_opacity < 0: l_opacity = 0
elif l_opacity > 1: l_opacity = 1
layer.opacity = l_opacity
Debug.msg (3, "Map.ChangeOpacity(): layer=%s, opacity=%f" % \
(layer.name, layer.opacity))
def UpdateHist(self, img = None):
"""!Update canvas if histogram options changes or window
changes geometry
"""
Debug.msg (2, "BufferedWindow.UpdateHist(%s): render=%s" % (img, self.render))
oldfont = ""
oldencoding = ""
if self.render:
# render new map images
# set default font and encoding environmental variables
if "GRASS_FONT" in os.environ:
oldfont = os.environ["GRASS_FONT"]
if self.parent.font != "": os.environ["GRASS_FONT"] = self.parent.font
if "GRASS_ENCODING" in os.environ:
oldencoding = os.environ["GRASS_ENCODING"]
if self.parent.encoding != None and self.parent.encoding != "ISO-8859-1":
os.environ[GRASS_ENCODING] = self.parent.encoding
# using active comp region
self.Map.GetRegion(update = True)
self.Map.width, self.Map.height = self.GetClientSize()
self.mapfile = self.Map.Render(force = self.render)
self.img = self.GetImage()
self.resize = False
if not self.img: return
try:
id = self.imagedict[self.img]
except:
return
# paint images to PseudoDC
self.pdc.Clear()
self.pdc.RemoveAll()
self.Draw(self.pdc, self.img, drawid = id) # draw map image background
self.resize = False
# update statusbar
# Debug.msg (3, "BufferedWindow.UpdateHist(%s): region=%s" % self.Map.region)
self.Map.SetRegion()
self.parent.statusbar.SetStatusText("Image/Raster map <%s>" % self.parent.mapname)
# set default font and encoding environmental variables
if oldfont != "":
os.environ["GRASS_FONT"] = oldfont
if oldencoding != "":
os.environ["GRASS_ENCODING"] = oldencoding
def EncodeString(string):
"""!Return encoded string using system locales
@param string string to be encoded
@return encoded string
"""
if not string:
return string
enc = locale.getdefaultlocale()[1]
if enc:
Debug.msg(5, "EncodeString(): enc=%s" % enc)
return string.encode(enc)
return string
def DecodeString(string):
"""!Decode string using system encoding
@param string string to be decoded
@return decoded string
"""
if not string:
return string
enc = locale.getdefaultlocale()[1]
if enc:
Debug.msg(5, "DecodeString(): enc=%s" % enc)
return string.decode(enc)
return string
def __init__(self, type, cmd, name = None,
active = True, hidden = False, opacity = 1.0):
"""!Create new instance
@todo pass cmd as tuple instead of list
@param type layer type ('raster', 'vector', 'overlay', 'command', etc.)
@param cmd GRASS command to render layer,
given as list, e.g. ['d.rast', 'map=elevation@PERMANENT']
@param name layer name, e.g. 'elevation@PERMANENT' (for layer tree)
@param active layer is active, will be rendered only if True
@param hidden layer is hidden, won't be listed in Layer Manager if True
@param opacity layer opacity <0;1>
"""
self.type = type
self.name = name
if self.type == 'command':
self.cmd = list()
for c in cmd:
self.cmd.append(utils.CmdToTuple(c))
else:
self.cmd = utils.CmdToTuple(cmd)
self.active = active
self.hidden = hidden
self.opacity = opacity
self.force_render = True
Debug.msg (3, "Layer.__init__(): type=%s, cmd='%s', name=%s, " \
"active=%d, opacity=%d, hidden=%d" % \
(self.type, self.GetCmd(string = True), self.name, self.active,
self.opacity, self.hidden))
# generated file for each layer
if USE_GPNMCOMP or self.type == 'overlay':
tmpfile = tempfile.mkstemp()[1]
self.maskfile = tmpfile + '.pgm'
if self.type == 'overlay':
self.mapfile = tmpfile + '.png'
else:
self.mapfile = tmpfile + '.ppm'
grass.try_remove(tmpfile)
else:
self.mapfile = self.maskfile = None
def run(self):
"""!Run command"""
if len(self.cmd) == 0:
return
Debug.msg(1, "gcmd.CommandThread(): %s" % ' '.join(self.cmd))
self.startTime = time.time()
try:
self.module = Popen(self.cmd,
stdin = subprocess.PIPE,
stdout = subprocess.PIPE,
stderr = subprocess.PIPE,
shell = sys.platform == "win32")
except OSError, e:
self.error = str(e)
return 1
def OnPaint(self, event):
"""!
Draw PseudoDC's to buffered paint DC
self.pdc for background and decorations
self.pdcVector for vector map which is edited
self.pdcTmp for temporaly drawn objects (self.polycoords)
If self.redrawAll is False on self.pdcTmp content is re-drawn
"""
Debug.msg(4, "BufferedWindow.OnPaint(): redrawAll=%s" % self.redrawAll)
dc = wx.BufferedPaintDC(self, self.buffer)
### dc.SetBackground(wx.Brush("White"))
dc.Clear()
# use PrepareDC to set position correctly
self.PrepareDC(dc)
# create a clipping rect from our position and size
# and update region
rgn = self.GetUpdateRegion().GetBox()
dc.SetClippingRect(rgn)
switchDraw = False
if self.redrawAll is None:
self.redrawAll = True
switchDraw = True
if self.redrawAll: # redraw pdc and pdcVector
# draw to the dc using the calculated clipping rect
self.pdc.DrawToDCClipped(dc, rgn)
# draw vector map layer
if self.pdcVector:
# decorate with GDDC (transparency)
try:
gcdc = wx.GCDC(dc)
self.pdcVector.DrawToDCClipped(gcdc, rgn)
except NotImplementedError, e:
print >> sys.stderr, e
self.pdcVector.DrawToDCClipped(dc, rgn)
self.bufferLast = None
def AdjustRegion(self):
"""!Adjusts display resolution to match monitor size in
pixels. Maintains constant display resolution, not related to
computational region. Do NOT use the display resolution to set
computational resolution. Set computational resolution through
g.region.
"""
mapwidth = abs(self.region["e"] - self.region["w"])
mapheight = abs(self.region['n'] - self.region['s'])
self.region["nsres"] = mapheight / self.height
self.region["ewres"] = mapwidth / self.width
self.region['rows'] = round(mapheight / self.region["nsres"])
self.region['cols'] = round(mapwidth / self.region["ewres"])
self.region['cells'] = self.region['rows'] * self.region['cols']
Debug.msg (3, "Map.AdjustRegion(): %s" % self.region)
return self.region
def OpenMap(self, name, mapset, update = True):
"""!Open vector map by the driver
@param name name of vector map to be open
@param mapset name of mapset where the vector map lives
@return map_info
@return None on error
"""
Debug.msg("DisplayDriver.OpenMap(): name=%s mapset=%s updated=%d",
name, mapset, update)
if not self.mapInfo:
self.mapInfo = Map_info()
self.poMapInfo = pointer(self.mapInfo)
# open existing map
if update:
ret = Vect_open_update(self.poMapInfo, name, mapset)
else:
ret = Vect_open_old(self.poMapInfo, name, mapset)
self.is3D = Vect_is_3d(self.poMapInfo)
if ret == -1: # error
del self.mapInfo
self.poMapInfo = self.mapInfo = None
elif ret < 2:
dlg = wx.MessageDialog(parent = self.window,
message = _("Topology for vector map <%s> is not available. "
"Topology is required by digitizer. Do you want to "
"rebuild topology (takes some time) and open the vector map "
"for editing?") % name,
caption=_("Topology missing"),
style = wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION | wx.CENTRE)
ret = dlg.ShowModal()
if ret != wx.ID_YES:
del self.mapInfo
self.poMapInfo = self.mapInfo = None
else:
Vect_build(self.poMapInfo)
return self.poMapInfo
def AddLayer(self, type, command, name = None,
l_active = True, l_hidden = False, l_opacity = 1.0, l_render = False,
pos = -1):
"""!Adds generic map layer to list of layers
@param type layer type ('raster', 'vector', etc.)
@param command GRASS command given as list
@param name layer name
@param l_active layer render only if True
@param l_hidden layer not displayed in layer tree if True
@param l_opacity opacity level range from 0(transparent) - 1(not transparent)
@param l_render render an image if True
@param pos position in layer list (-1 for append)
@return new layer on success
@return None on failure
"""
wx.BeginBusyCursor()
# l_opacity must be <0;1>
if l_opacity < 0: l_opacity = 0
elif l_opacity > 1: l_opacity = 1
layer = MapLayer(type = type, name = name, cmd = command,
active = l_active, hidden = l_hidden, opacity = l_opacity)
# add maplayer to the list of layers
if pos > -1:
self.layers.insert(pos, layer)
else:
self.layers.append(layer)
Debug.msg (3, "Map.AddLayer(): layer=%s" % layer.name)
if l_render:
if not layer.Render():
raise gcmd.GException(_("Unable to render map layer <%s>.") % name)
wx.EndBusyCursor()
return layer
def DrawMap(self, force = False):
"""!Draw content of the vector map to the device
@param force force drawing
@return number of drawn features
@return -1 on error
"""
Debug.msg(1, "DisplayDriver.DrawMap(): force=%d", force)
if not self.poMapInfo or not self.dc or not self.dcTmp:
return -1
try:
rlist = Vedit_render_map(self.poMapInfo, byref(self._getRegionBox()), self._getDrawFlag(),
self.region['center_easting'], self.region['center_northing'],
self.mapObj.width, self.mapObj.height,
max(self.region['nsres'], self.region['ewres'])).contents
except SystemExit:
pass
self._resetTopology()
self.dc.BeginDrawing()
self.dcTmp.BeginDrawing()
# draw objects
for i in range(rlist.nitems):
robj = rlist.item[i].contents
self._drawObject(robj)
self.dc.EndDrawing()
self.dcTmp.EndDrawing()
# reset list of selected features by cat
# list of ids - see IsSelected()
self.selected['field'] = -1
self.selected['cats'] = list()
def ChangeLayer(self, layer, render = False, **kargs):
"""!Change map layer properties
@param layer map layer instance
@param type layer type ('raster', 'vector', etc.)
@param command GRASS command given as list
@param name layer name
@param active layer render only if True
@param hidden layer not displayed in layer tree if True
@param opacity opacity level range from 0(transparent) - 1(not transparent)
@param render render an image if True
"""
Debug.msg (3, "Map.ChangeLayer(): layer=%s" % layer.name)
if 'type' in kargs:
layer.SetType(kargs['type']) # check type
if 'command' in kargs:
layer.SetCmd(kargs['command'])
if 'name' in kargs:
layer.SetName(kargs['name'])
if 'active' in kargs:
layer.SetActive(kargs['active'])
if 'hidden' in kargs:
layer.SetHidden(kargs['hidden'])
if 'opacity' in kargs:
layer.SetOpacity(kargs['opacity'])
if render and not layer.Render():
raise gcmd.GException(_("Unable to render map layer <%s>.") %
name)
return layer
def main():
# We define the debuger
dbg = Debug(os.path.basename(__file__), level=2)
dbg.msg('Version', 'sys.version', 'sys.version', 1, sys.version)
dbg.msg('config', 'path', 'all_photos', 1, config.PATH)
if os.path.exists(config.PATH):
other_tables(config.PATH)
if config.correct_name:
name_correction(config.PATH, dbg)
for report in config.reports:
file_report = os.path.join(config.PATH, report['file'])
subpath = os.path.join(config.PATH, report['subpath'])
dbg.msg('report', 'file', 'output_csv', 1, subpath, file_report)
assert os.path.exists(subpath), "{} doesn't exist".format(subpath)
quickresult = create_report(subpath, file_report, dbg)
draw_report(quickresult, subpath)
else:
dbg.msg('config', 'path', 'all_photos', 3, config.PATH)
raise ValueError("A correct folder needs to be specified")
def GetVectorNumberOfLayers(parent, vector):
"""!Get list of vector layers"""
layers = list()
if not vector:
return layers
fullname = grass.find_file(name = vector, element = 'vector')['fullname']
if not fullname:
Debug.msg(5, "utils.GetVectorNumberOfLayers(): vector map '%s' not found" % vector)
return layers
ret, out, msg = gcmd.RunCommand('v.db.connect',
getErrorMsg = True,
read = True,
flags = 'g',
map = fullname,
fs = ';')
if ret != 0:
sys.stderr.write(_("Vector map <%(map)s>: %(msg)s\n") % { 'map' : fullname, 'msg' : msg })
return layers
else:
Debug.msg(1, "GetVectorNumberOfLayers(): ret %s" % ret)
for line in ret.splitlines():
try:
layer = line.split(';')[0]
if '/' in layer:
layer = layer.split('/')[0]
layers.append(layer)
except IndexError:
pass
Debug.msg(3, "utils.GetVectorNumberOfLayers(): vector=%s -> %s" % \
(fullname, ','.join(layers)))
return layers
def __del__(self):
Debug.msg (3, "Layer.__del__(): layer=%s, cmd='%s'" %
(self.name, self.GetCmd(string = True)))
def Render(self, force = False, mapWindow = None, windres = False):
"""!Creates final image composite
This function can conditionaly use high-level tools, which
should be avaliable in wxPython library
@param force force rendering
@param reference for MapFrame instance (for progress bar)
@param windres use region resolution (True) otherwise display resolution
@return name of file with rendered image or None
"""
wx.BeginBusyCursor()
# use external gisrc if defined
gisrc_orig = os.getenv("GISRC")
if self.gisrc:
os.environ["GISRC"] = self.gisrc
tmp_region = os.getenv("GRASS_REGION")
os.environ["GRASS_REGION"] = self.SetRegion(windres)
os.environ["GRASS_WIDTH"] = str(self.width)
os.environ["GRASS_HEIGHT"] = str(self.height)
driver = UserSettings.Get(group = 'display', key = 'driver', subkey = 'type')
if driver == 'png':
os.environ["GRASS_RENDER_IMMEDIATE"] = "png"
else:
os.environ["GRASS_RENDER_IMMEDIATE"] = "cairo"
if self.cmdfile:
maps, masks, opacities = self._renderCmdFile(force, windres)
else:
maps, masks, opacities = self._renderLayers(force, mapWindow)
# ugly hack for MSYS
if sys.platform != 'win32':
mapstr = ",".join(maps)
maskstr = ",".join(masks)
mapoutstr = self.mapfile
else:
mapstr = ""
for item in maps:
mapstr += item.replace('\\', '/')
mapstr = mapstr.rstrip(',')
maskstr = ""
for item in masks:
maskstr += item.replace('\\', '/')
maskstr = maskstr.rstrip(',')
mapoutstr = self.mapfile.replace('\\', '/')
# run g.pngcomp to get composite image
bgcolor = ':'.join(map(str, UserSettings.Get(group = 'display', key = 'bgcolor',
subkey = 'color')))
if maps:
ret, msg = gcmd.RunCommand('g.pnmcomp',
getErrorMsg = True,
overwrite = True,
input = '%s' % ",".join(maps),
mask = '%s' % ",".join(masks),
opacity = '%s' % ",".join(opacities),
bgcolor = bgcolor,
width = self.width,
height = self.height,
output = self.mapfile)
if ret != 0:
print >> sys.stderr, _("ERROR: Rendering failed. Details: %s") % msg
wx.EndBusyCursor()
return None
Debug.msg (3, "Map.Render() force=%s file=%s" % (force, self.mapfile))
# back to original region
if tmp_region:
os.environ["GRASS_REGION"] = tmp_region
else:
del os.environ["GRASS_REGION"]
# back to original gisrc
if self.gisrc:
os.environ["GISRC"] = gisrc_orig
wx.EndBusyCursor()
if not maps:
return None
return self.mapfile
file = []
# we append the headers
file.extend(writeheaders(datamodel))
# we write the data model
file.extend(writemodel(datamodel))
# we extract and process relations
relations = process_relations(datamodel)
file.extend(writerelations(relations))
#we end the file
file.extend(closefile(datamodel))
#we write the file
writeplantuml(file)
if __name__ == "__main__":
# Initialize debuger
dbg = Debug(os.path.basename(__file__), level=1)
dbg.msg('Version', 'sys.version', 'sys.version', 1, sys.version)
main()
# Use
# https://plantuml-editor.kkeisuke.com/
# to visualize
# TODO abrir branch nuevo
# TODO make two outputs with and without relations
# TODO black list for relationships
def GetListOfLayers(self, l_type = None, l_mapset = None, l_name = None,
l_active = None, l_hidden = None):
"""!Returns list of layers of selected properties or list of
all layers.
@param l_type layer type, e.g. raster/vector/wms/overlay (value or tuple of values)
@param l_mapset all layers from given mapset (only for maplayers)
@param l_name all layers with given name
@param l_active only layers with 'active' attribute set to True or False
@param l_hidden only layers with 'hidden' attribute set to True or False
@return list of selected layers
"""
selected = []
if type(l_type) == types.StringType:
one_type = True
else:
one_type = False
if one_type and l_type == 'overlay':
llist = self.overlays
else:
llist = self.layers
# ["raster", "vector", "wms", ... ]
for layer in llist:
# specified type only
if l_type != None:
if one_type and layer.type != l_type:
continue
elif not one_type and layer.type not in l_type:
continue
# mapset
if (l_mapset != None and l_type != 'overlay') and \
layer.GetMapset() != l_mapset:
continue
# name
if l_name != None and layer.name != l_name:
continue
# hidden and active layers
if l_active != None and \
l_hidden != None:
if layer.active == l_active and \
layer.hidden == l_hidden:
selected.append(layer)
# active layers
elif l_active != None:
if layer.active == l_active:
selected.append(layer)
# hidden layers
elif l_hidden != None:
if layer.hidden == l_hidden:
selected.append(layer)
# all layers
else:
selected.append(layer)
Debug.msg (3, "Map.GetListOfLayers(): numberof=%d" % len(selected))
return selected
def SetRegion(self, windres = False):
"""!Render string for GRASS_REGION env. variable, so that the
images will be rendered from desired zoom level.
@param windres uses resolution from WIND file rather than
display (for modules that require set resolution like
d.rast.num)
@return String usable for GRASS_REGION variable or None
"""
grass_region = ""
if windres:
compRegion = self.GetRegion()
region = copy.copy(self.region)
for key in ('nsres', 'ewres', 'cells'):
region[key] = compRegion[key]
else:
# adjust region settings to match monitor
region = self.AdjustRegion()
# read values from wind file
try:
for key in self.wind.keys():
if key == 'north':
grass_region += "north: %s; " % \
(region['n'])
continue
elif key == "south":
grass_region += "south: %s; " % \
(region['s'])
continue
elif key == "east":
grass_region += "east: %s; " % \
(region['e'])
continue
elif key == "west":
grass_region += "west: %s; " % \
(region['w'])
continue
elif key == "e-w resol":
grass_region += "e-w resol: %f; " % \
(region['ewres'])
continue
elif key == "n-s resol":
grass_region += "n-s resol: %f; " % \
(region['nsres'])
continue
elif key == "cols":
if windres:
continue
grass_region += 'cols: %d; ' % \
region['cols']
continue
elif key == "rows":
if windres:
continue
grass_region += 'rows: %d; ' % \
region['rows']
continue
else:
grass_region += key + ": " + self.wind[key] + "; "
Debug.msg (3, "Map.SetRegion(): %s" % grass_region)
return grass_region
except:
return None
def GetRegion(self, rast = [], zoom = False, vect = [], regionName = None,
n = None, s = None, e = None, w = None, default = False,
update = False):
"""!Get region settings (g.region -upgc)
Optionally extent, raster or vector map layer can be given.
@param rast list of raster maps
@param zoom zoom to raster map (ignore NULLs)
@param vect list of vector maps
@param regionName named region or None
@param n,s,e,w force extent
@param default force default region settings
@param update if True update current display region settings
@return region settings as directory, e.g. {
'n':'4928010', 's':'4913700', 'w':'589980',...}
"""
region = {}
tmpreg = os.getenv("GRASS_REGION")
if tmpreg:
del os.environ["GRASS_REGION"]
# use external gisrc if defined
gisrc_orig = os.getenv("GISRC")
if self.gisrc:
os.environ["GISRC"] = self.gisrc
# do not update & shell style output
cmd = {}
cmd['flags'] = 'ugpc'
if default:
cmd['flags'] += 'd'
if regionName:
cmd['region'] = regionName
if n:
cmd['n'] = n
if s:
cmd['s'] = s
if e:
cmd['e'] = e
if w:
cmd['w'] = w
if rast:
if zoom:
cmd['zoom'] = rast[0]
else:
cmd['rast'] = ','.join(rast)
if vect:
cmd['vect'] = ','.join(vect)
ret, reg, msg = gcmd.RunCommand('g.region',
read = True,
getErrorMsg = True,
**cmd)
if ret != 0:
if rast:
message = _("Unable to zoom to raster map <%s>.") % rast[0] + \
"\n\n" + _("Details:") + " %s" % msg
elif vect:
message = _("Unable to zoom to vector map <%s>.") % vect[0] + \
"\n\n" + _("Details:") + " %s" % msg
else:
message = _("Unable to get current geographic extent. "
"Force quiting wxGUI. Please manually run g.region to "
"fix the problem.")
gcmd.GError(message)
return self.region
for r in reg.splitlines():
key, val = r.split("=", 1)
try:
region[key] = float(val)
except ValueError:
region[key] = val
# back to original gisrc
if self.gisrc:
os.environ["GISRC"] = gisrc_orig
# restore region
if tmpreg:
os.environ["GRASS_REGION"] = tmpreg
Debug.msg (3, "Map.GetRegion(): %s" % region)
if update:
self.region = region
return region
for tablesearch in whole_tables.keys():
if field in whole_tables[tablesearch][
0] and table != tablesearch:
new_whole_tables[table][2].append(field + " -> " +
tablesearch)
return new_whole_tables
def main():
# We first extract all files in the path that have an extension in config.sql_extensions
list_of_files = all_sql_files(config.sql_path)
# Now we process all files and create a dictionary with the tables and fields
whole_tables = process_all_files(list_of_files)
#whole_tables
#{'table1': [['field1', 'field2', 'field3'],['C:\\path1\\','C:\\path2\\']], 'table2':[['field4', 'field1'...
# Now we extract the relationships
whole_tables = extract_relations(whole_tables)
process_whole_tables(whole_tables)
# TODO abrir branch nuevo
# TODO Incluir un fichero de entrada con Descripciones
# TODO Detectar tablas temporales o no reales
if __name__ == "__main__":
# Initialize debuger
dbg = Debug(os.path.basename(__file__), level=2)
dbg.msg('Version', 'sys.version', 'sys.version', 1, sys.version)
dbg.msg('config', 'path', 'sql path', 1, config.sql_path)
main()
def UpdateMap(self, render=True, renderVector=True):
"""!
Updates the canvas anytime there is a change to the
underlaying images or to the geometry of the canvas.
@param render re-render map composition
@param renderVector re-render vector map layer enabled for editing (used for digitizer)
"""
start = time.clock()
self.resize = False
# if len(self.Map.GetListOfLayers()) == 0:
# return False
if self.img is None:
render = True
#
# initialize process bar (only on 'render')
#
if render is True or renderVector is True:
self.parent.statusbarWin['progress'].Show()
if self.parent.statusbarWin['progress'].GetRange() > 0:
self.parent.statusbarWin['progress'].SetValue(1)
#
# render background image if needed
#
# update layer dictionary if there has been a change in layers
if self.tree and self.tree.reorder == True:
self.tree.ReorderLayers()
# reset flag for auto-rendering
if self.tree:
self.tree.rerender = False
if render:
# update display size
self.Map.ChangeMapSize(self.GetClientSize())
if self.parent.statusbarWin['resolution'].IsChecked():
# use computation region resolution for rendering
windres = True
else:
windres = False
self.mapfile = self.Map.Render(force=True,
mapWindow=self.parent,
windres=windres)
else:
self.mapfile = self.Map.Render(force=False, mapWindow=self.parent)
self.img = self.GetImage() # id=99
#
# clear pseudoDcs
#
for pdc in (self.pdc, self.pdcDec, self.pdcTmp):
pdc.Clear()
pdc.RemoveAll()
#
# draw background map image to PseudoDC
#
if not self.img:
self.Draw(self.pdc, pdctype='clear')
else:
try:
id = self.imagedict[self.img]['id']
except:
return False
self.Draw(self.pdc, self.img, drawid=id)
#
# render vector map layer
#
# render overlays
#
for img in self.GetOverlay():
# draw any active and defined overlays
if self.imagedict[img]['layer'].IsActive():
id = self.imagedict[img]['id']
self.Draw(self.pdc,
img=img,
drawid=id,
pdctype=self.overlays[id]['pdcType'],
coords=self.overlays[id]['coords'])
for id in self.textdict.keys():
self.Draw(self.pdc,
img=self.textdict[id],
drawid=id,
pdctype='text',
coords=[10, 10, 10, 10])
# optionally draw computational extent box
self.DrawCompRegionExtent()
#
# redraw pdcTmp if needed
#
if len(self.polycoords) > 0:
self.DrawLines(self.pdcTmp)
#
# clear measurement
#
stop = time.clock()
#
# hide process bar
#
self.parent.statusbarWin['progress'].Hide()
#
# update statusbar
#
### self.Map.SetRegion()
self.parent.StatusbarUpdate()
if grass.find_file(name='MASK', element='cell')['name']:
# mask found
self.parent.statusbarWin['mask'].SetLabel(_('MASK'))
else:
self.parent.statusbarWin['mask'].SetLabel('')
Debug.msg (2, "BufferedWindow.UpdateMap(): render=%s, renderVector=%s -> time=%g" % \
(render, renderVector, (stop-start)))
return True
def OnLayerContextMenu (self, event):
"""!Contextual menu for item/layer"""
if not self.layer_selected:
event.Skip()
return
self.popupMenu = wx.Menu()
item = event.GetItem()
if self.IsItemChecked(item) == False:
if self.addon == "True":
self.Minimal(item)
else:
if self.addon == "True":
self.Minimal(item)
ltype = self.GetPyData(self.layer_selected)[0]['type']
Debug.msg (4, "LayerTree.OnContextMenu: layertype=%s" % \
ltype)
if not hasattr (self, "popupID1"):
self.popupID1 = wx.NewId()
self.popupID2 = wx.NewId()
self.popupID3 = wx.NewId()
self.popupID4 = wx.NewId()
self.popupID5 = wx.NewId()
self.popupID6 = wx.NewId()
self.popupID7 = wx.NewId()
self.popupID8 = wx.NewId()
self.popupID9 = wx.NewId()
self.popupID10 = wx.NewId()
self.popupID11 = wx.NewId() # nviz
self.popupID12 = wx.NewId()
self.popupID13 = wx.NewId()
self.popupID14 = wx.NewId()
self.popupID15 = wx.NewId()
numSelected = len(self.GetSelections())
# general item
self.popupMenu.Append(self.popupID1, text=_("Remove from MapTree"))
self.Bind(wx.EVT_MENU, self.lmgr.OnDeleteLayer, id=self.popupID1)
if ltype != "command": # rename
self.popupMenu.Append(self.popupID2, text=_("Rename"))
self.Bind(wx.EVT_MENU, self.RenameLayer, id=self.popupID2)
if numSelected > 1:
self.popupMenu.Enable(self.popupID2, False)
# map layer items
if ltype != "group" and \
ltype != "command":
self.popupMenu.AppendSeparator()
self.popupMenu.Append(self.popupID8, text=_("Change opacity level"))
self.Bind(wx.EVT_MENU, self.OnPopupOpacityLevel, id=self.popupID8)
self.popupMenu.Append(self.popupID3, text=_("Properties"))
self.Bind(wx.EVT_MENU, self.OnPopupProperties, id=self.popupID3)
if ltype in ('raster', 'vector', 'raster3d') and self.mapdisplay.toolbars['nviz']:
self.popupMenu.Append(self.popupID11, _("3D view properties"))
self.Bind (wx.EVT_MENU, self.OnNvizProperties, id=self.popupID11)
if ltype in ('raster', 'vector', 'rgb'):
self.popupMenu.Append(self.popupID9, text=_("Zoom to selected map(s)"))
self.Bind(wx.EVT_MENU, self.mapdisplay.OnZoomToMap, id=self.popupID9)
self.popupMenu.Append(self.popupID10, text=_("Set computational region from selected map(s)"))
self.Bind(wx.EVT_MENU, self.OnSetCompRegFromMap, id=self.popupID10)
if numSelected > 1:
self.popupMenu.Enable(self.popupID8, False)
self.popupMenu.Enable(self.popupID3, False)
# specific items
try:
mltype = self.GetPyData(self.layer_selected)[0]['type']
except:
mltype = None
#
# vector layers (specific items)
#
if mltype and mltype == "vector":
self.popupMenu.AppendSeparator()
self.popupMenu.Append(self.popupID4, text=_("Show attribute data"))
self.Bind (wx.EVT_MENU, self.lmgr.OnShowAttributeTable, id=self.popupID4)
self.popupMenu.Append(self.popupID5, text=_("Start editing"))
self.popupMenu.Append(self.popupID6, text=_("Stop editing"))
self.popupMenu.Enable(self.popupID6, False)
self.Bind (wx.EVT_MENU, self.OnStartEditing, id=self.popupID5)
self.Bind (wx.EVT_MENU, self.OnStopEditing, id=self.popupID6)
layer = self.GetPyData(self.layer_selected)[0]['maplayer']
# enable editing only for vector map layers available in the current mapset
digitToolbar = self.mapdisplay.toolbars['vdigit']
if digitToolbar:
# background vector map
self.popupMenu.Append(self.popupID14,
text=_("Use as background vector map"),
kind=wx.ITEM_CHECK)
self.Bind(wx.EVT_MENU, self.OnSetBgMap, id=self.popupID14)
if UserSettings.Get(group='vdigit', key='bgmap', subkey='value',
internal=True) == layer.GetName():
self.popupMenu.Check(self.popupID14, True)
if layer.GetMapset() != grass.gisenv()['MAPSET']:
# only vector map in current mapset can be edited
self.popupMenu.Enable (self.popupID5, False)
self.popupMenu.Enable (self.popupID6, False)
elif digitToolbar and digitToolbar.GetLayer():
# vector map already edited
vdigitLayer = digitToolbar.GetLayer()
if vdigitLayer is layer:
# disable 'start editing'
self.popupMenu.Enable (self.popupID5, False)
# enable 'stop editing'
self.popupMenu.Enable(self.popupID6, True)
# disable 'remove'
self.popupMenu.Enable(self.popupID1, False)
# disable 'bgmap'
self.popupMenu.Enable(self.popupID14, False)
else:
# disable 'start editing'
self.popupMenu.Enable(self.popupID5, False)
# disable 'stop editing'
self.popupMenu.Enable(self.popupID6, False)
# enable 'bgmap'
self.popupMenu.Enable(self.popupID14, True)
self.popupMenu.Append(self.popupID7, _("Metadata"))
self.Bind (wx.EVT_MENU, self.OnMetadata, id=self.popupID7)
if numSelected > 1:
self.popupMenu.Enable(self.popupID4, False)
self.popupMenu.Enable(self.popupID5, False)
self.popupMenu.Enable(self.popupID6, False)
self.popupMenu.Enable(self.popupID7, False)
self.popupMenu.Enable(self.popupID14, False)
#
# raster layers (specific items)
#
elif mltype and mltype == "raster":
self.popupMenu.Append(self.popupID12, text=_("Zoom to selected map(s) (ignore NULLs)"))
self.Bind(wx.EVT_MENU, self.mapdisplay.OnZoomToRaster, id=self.popupID12)
self.popupMenu.Append(self.popupID13, text=_("Set computational region from selected map(s) (ignore NULLs)"))
self.Bind(wx.EVT_MENU, self.OnSetCompRegFromRaster, id=self.popupID13)
self.popupMenu.AppendSeparator()
self.popupMenu.Append(self.popupID15, _("Set color table"))
self.Bind (wx.EVT_MENU, self.OnColorTable, id=self.popupID15)
self.popupMenu.Append(self.popupID4, _("Histogram"))
self.Bind (wx.EVT_MENU, self.OnHistogram, id=self.popupID4)
self.popupMenu.Append(self.popupID5, _("Profile"))
self.Bind (wx.EVT_MENU, self.OnProfile, id=self.popupID5)
self.popupMenu.Append(self.popupID6, _("Metadata"))
self.Bind (wx.EVT_MENU, self.OnMetadata, id=self.popupID6)
if numSelected > 1:
self.popupMenu.Enable(self.popupID12, False)
self.popupMenu.Enable(self.popupID13, False)
self.popupMenu.Enable(self.popupID15, False)
self.popupMenu.Enable(self.popupID4, False)
self.popupMenu.Enable(self.popupID5, False)
self.popupMenu.Enable(self.popupID6, False)
self.popupMenu.Enable(self.popupID11, False)
## self.PopupMenu(self.popupMenu, pos)
self.PopupMenu(self.popupMenu)
self.popupMenu.Destroy()
def ChooseColour(self,event):
colourdialog = wx.ColourDialog(self)
colourdialog.ShowModal()
rgb = colourdialog.GetColourData().GetColour()
rgb = str(rgb)
self.colour = rgb.replace(',',':')
self.colour = self.colour.strip('(')
self.colour = self.colour.strip(')')
item = event.GetItem()
col = colourdialog.GetColourData().GetColour()
self.SetHilightFocusColour(col)
self.SetItemTextColour(item,col)
item = event.GetItem()
parent = self.GetItemParent(item)
if self.IsItemChecked(parent):
self.colour_selected = True
self.CheckItem(parent)
else:
self.CheckItem(parent)
def Render(self):
"""!Render layer to image
@return rendered image filename
@return None on error or if cmdfile is defined
"""
if not self.cmd:
return None
# ignore in 2D
if self.type == '3d-raster':
return None
Debug.msg (3, "Layer.Render(): type=%s, name=%s" % \
(self.type, self.name))
# prepare command for each layer
layertypes = ('raster', 'rgb', 'his', 'shaded', 'rastarrow', 'rastnum',
'vector','thememap','themechart',
'grid', 'geodesic', 'rhumb', 'labels',
'command', 'rastleg','maplegend',
'overlay')
if self.type not in layertypes:
raise gcmd.GException(_("<%(name)s>: layer type <%(type)s> is not supported") % \
{'type' : self.type, 'name' : self.name})
# start monitor
if self.mapfile:
os.environ["GRASS_PNGFILE"] = self.mapfile
# execute command
try:
if self.type == 'command':
read = False
for c in self.cmd:
ret, msg = gcmd.RunCommand(c[0],
getErrorMsg = True,
quiet = True,
**c[1])
if ret != 0:
break
if not read:
os.environ["GRASS_PNG_READ"] = "TRUE"
os.environ["GRASS_PNG_READ"] = "FALSE"
else:
ret, msg = gcmd.RunCommand(self.cmd[0],
getErrorMsg = True,
quiet = True,
**self.cmd[1])
if msg:
sys.stderr.write(_("Command '%s' failed\n") % self.GetCmd(string = True))
sys.stderr.write(_("Details: %s\n") % msg)
if ret != 0:
raise gcmd.GException()
except gcmd.GException:
# clean up after problems
for f in [self.mapfile, self.maskfile]:
if not f:
continue
grass.try_remove(f)
f = None
# stop monitor
if self.mapfile and "GRASS_PNGFILE" in os.environ:
del os.environ["GRASS_PNGFILE"]
self.force_render = False
return self.mapfile
