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