def testMapWindowDistance(self, giface, map_):
self.frame = wx.Frame(
parent=None, title=_("Map window distance measurement test frame"))
panel = wx.Panel(parent=self.frame, id=wx.ID_ANY)
sizer = wx.BoxSizer(wx.VERTICAL)
mapWindowProperties = MapWindowProperties()
mapWindowProperties.setValuesFromUserSettings()
mapWindowProperties.showRegion = True
width, height = self.frame.GetClientSize()
copyOfInitMap(map_, width, height)
window = BufferedMapWindow(parent=panel,
giface=giface,
Map=map_,
properties=mapWindowProperties)
giface.mapWindow = window
sizer.Add(window, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
panel.SetSizer(sizer)
panel.Layout()
window.ZoomToWind()
self._listenToAllMapWindowSignals(window)
self.frame.Show()
from mapwin.analysis import MeasureDistanceController
self.controller = MeasureDistanceController(giface, window)
self.controller.Start()
def testMapWindowApi(self, giface, map_):
self.frame = wx.Frame(parent=None,
title=_("Map window API test frame"))
panel = wx.Panel(parent=self.frame, id=wx.ID_ANY)
sizer = wx.BoxSizer(wx.VERTICAL)
mapWindowProperties = MapWindowProperties()
mapWindowProperties.setValuesFromUserSettings()
mapWindowProperties.showRegion = True
width, height = self.frame.GetClientSize()
copyOfInitMap(map_, width, height)
window = BufferedMapWindow(parent=panel,
giface=giface,
Map=map_,
properties=mapWindowProperties)
giface.mapWindow = window
sizer.Add(window, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
panel.SetSizer(sizer)
panel.Layout()
window.ZoomToWind()
self.frame.Show()
def __init__(self, parent, giface, Map, properties, tree=None,
id=wx.ID_ANY, lmgr=None,
style=wx.NO_FULL_REPAINT_ON_RESIZE, **kwargs):
BufferedMapWindow.__init__(self, parent=parent, giface=giface, Map=Map,
properties=properties,
style=style, **kwargs)
self.lmgr = lmgr
self.tree = tree
self.pdcVector = PseudoDC()
self.toolbar = self.parent.GetToolbar('vdigit')
self.digit = None # wxvdigit.IVDigit
self._digitizingInfo = False # digitizing with info
# Emitted when info about digitizing updated
# Parameter text is a string with information
# currently used only for coordinates of mouse cursor + segmnt and
# total feature length
self.digitizingInfo = Signal('VDigitWindow.digitizingInfo')
# Emitted when some info about digitizing is or will be availbale
self.digitizingInfoAvailable = Signal('VDigitWindow.digitizingInfo')
# Emitted when some info about digitizing is or will be availbale
# digitizingInfo signal is emmited only between digitizingInfoAvailable
# and digitizingInfoUnavailable signals
self.digitizingInfoUnavailable = Signal('VDigitWindow.digitizingInfo')
self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
self.mouseMoving.connect(self._mouseMovingToDigitizingInfo)
def __init__(self, parent, giface, Map, properties, tree=None,
id=wx.ID_ANY, lmgr=None,
style = wx.NO_FULL_REPAINT_ON_RESIZE, **kwargs):
BufferedMapWindow.__init__(self, parent=parent, giface=giface, Map=Map,
properties=properties,
style=style, **kwargs)
self.lmgr = lmgr
self.tree = tree
self.pdcVector = wx.PseudoDC()
self.toolbar = self.parent.GetToolbar('vdigit')
self.digit = None # wxvdigit.IVDigit
self._digitizingInfo = False # digitizing with info
# Emitted when info about digitizing updated
# Parameter text is a string with information
# currently used only for coordinates of mouse cursor + segmnt and
# total feature length
self.digitizingInfo = Signal('VDigitWindow.digitizingInfo')
# Emitted when some info about digitizing is or will be availbale
self.digitizingInfoAvailable = Signal('VDigitWindow.digitizingInfo')
# Emitted when some info about digitizing is or will be availbale
# digitizingInfo signal is emmited only between digitizingInfoAvailable
# and digitizingInfoUnavailable signals
self.digitizingInfoUnavailable = Signal('VDigitWindow.digitizingInfo')
self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
self.mouseMoving.connect(self._mouseMovingToDigitizingInfo)
def __init__(self, parent, giface, Map, properties, **kwargs):
BufferedMapWindow.__init__(self, parent=parent, giface=giface, Map=Map,
properties=properties, **kwargs)
Debug.msg(2, "SwipeBufferedWindow.__init__()")
self.specialSize = super(SwipeBufferedWindow, self).GetClientSize()
self.specialCoords = [0, 0]
self.imageId = 99
self.movingSash = False
self._mode = 'swipe'
self.lineid = wx.NewId()
def __init__(self, parent, giface, Map, properties, **kwargs):
BufferedMapWindow.__init__(self, parent=parent, giface=giface, Map=Map,
properties=properties, **kwargs)
Debug.msg(2, "SwipeBufferedWindow.__init__()")
self.specialSize = super(SwipeBufferedWindow, self).GetClientSize()
self.specialCoords = [0, 0]
self.imageId = 99
self.movingSash = False
self._mode = 'swipe'
self.lineid = wx.NewId()
def testMapWindowProfile(self, giface, map_):
self.frame = wx.Frame(parent=None,
title=_("Map window profile tool test frame"))
panel = wx.Panel(parent=self.frame, id=wx.ID_ANY)
sizer = wx.BoxSizer(wx.VERTICAL)
mapWindowProperties = MapWindowProperties()
mapWindowProperties.setValuesFromUserSettings()
mapWindowProperties.showRegion = True
width, height = self.frame.GetClientSize()
copyOfInitMap(map_, width, height)
window = BufferedMapWindow(parent=panel,
giface=giface,
Map=map_,
properties=mapWindowProperties)
giface.mapWindow = window
sizer.Add(window, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
panel.SetSizer(sizer)
panel.Layout()
window.ZoomToWind()
self._listenToAllMapWindowSignals(window)
self.frame.Show()
from mapwin.analysis import ProfileController
self.controller = ProfileController(giface, window)
self.controller.Start()
rasters = []
for layer in giface.GetLayerList().GetSelectedLayers():
if layer.maplayer.GetType() == "raster":
rasters.append(layer.maplayer.GetName())
from wxplot.profile import ProfileFrame
profileWindow = ProfileFrame(
parent=self.frame,
giface=giface,
controller=self.controller,
units=map_.projinfo["units"],
rasterList=rasters,
)
profileWindow.CentreOnParent()
profileWindow.Show()
# Open raster select dialog to make sure that a raster (and
# the desired raster) is selected to be profiled
profileWindow.OnSelectRaster(None)
def __init__(self, parent, samplingType, icon=None, map_=None):
wx.Panel.__init__(self, parent=parent)
self.mapWindowProperties = MapWindowProperties()
self.mapWindowProperties.setValuesFromUserSettings()
giface = StandaloneGrassInterface()
self.samplingtype = samplingType
self.parent = parent
if map_:
self.map_ = map_
else:
self.map_ = Map()
self.map_.region = self.map_.GetRegion()
self._mgr = wx.aui.AuiManager(self)
self.mapWindow = BufferedMapWindow(parent=self, giface=giface,
Map=self.map_,
properties=self.mapWindowProperties)
self._mgr.AddPane(self.mapWindow, wx.aui.AuiPaneInfo().CentrePane().
Dockable(True).BestSize((-1, -1)).Name('mapwindow').
CloseButton(False).DestroyOnClose(True).
Layer(0))
self._toolSwitcher = ToolSwitcher()
self._toolSwitcher.toggleToolChanged.connect(self._onToolChanged)
self.toolbar = RLiSetupToolbar(self, self._toolSwitcher)
self.catId = 1
self._mgr.AddPane(self.toolbar,
wx.aui.AuiPaneInfo().
Name("maptoolbar").Caption(_("Map Toolbar")).
ToolbarPane().Left().Name('mapToolbar').
CloseButton(False).Layer(1).Gripper(False).
BestSize((self.toolbar.GetBestSize())))
self._mgr.Update()
if self.samplingtype == SamplingType.REGIONS:
self.afterRegionDrawn = Signal('RLiSetupMapPanel.afterRegionDrawn')
self._registeredGraphics = self.mapWindow.RegisterGraphicsToDraw(
graphicsType='line')
elif self.samplingtype in [SamplingType.MUNITSR, SamplingType.MMVWINR]:
self.sampleFrameChanged = Signal(
'RLiSetupMapPanel.sampleFrameChanged')
self._registeredGraphics = self.mapWindow.RegisterGraphicsToDraw(
graphicsType='rectangle')
elif self.samplingtype in [SamplingType.MUNITSC, SamplingType.MMVWINC]:
self.afterCircleDrawn = Signal('RLiSetupMapPanel.afterCircleDrawn')
self._registeredGraphics = self.mapWindow.RegisterGraphicsToDraw(
graphicsType='line')
else:
self.sampleFrameChanged = Signal(
'RLiSetupMapPanel.sampleFrameChanged')
self._registeredGraphics = self.mapWindow.RegisterGraphicsToDraw(
graphicsType='rectangle')
self._registeredGraphics.AddPen('rlisetup', wx.Pen(wx.GREEN, width=2,
style=wx.SOLID))
self._registeredGraphics.AddItem(coords=[[0, 0], [0, 0]],
penName='rlisetup', hide=True)
if self.samplingtype != SamplingType.VECT:
self.toolbar.SelectDefault()
class RLiSetupMapPanel(wx.Panel):
"""Panel with mapwindow used in r.li.setup"""
def __init__(self, parent, samplingType, icon=None, map_=None):
wx.Panel.__init__(self, parent=parent)
self.mapWindowProperties = MapWindowProperties()
self.mapWindowProperties.setValuesFromUserSettings()
giface = StandaloneGrassInterface()
self.samplingtype = samplingType
self.parent = parent
if map_:
self.map_ = map_
else:
self.map_ = Map()
self.map_.region = self.map_.GetRegion()
self._mgr = wx.aui.AuiManager(self)
self.mapWindow = BufferedMapWindow(parent=self, giface=giface,
Map=self.map_,
properties=self.mapWindowProperties)
self._mgr.AddPane(self.mapWindow, wx.aui.AuiPaneInfo().CentrePane().
Dockable(True).BestSize((-1, -1)).Name('mapwindow').
CloseButton(False).DestroyOnClose(True).
Layer(0))
self._toolSwitcher = ToolSwitcher()
self._toolSwitcher.toggleToolChanged.connect(self._onToolChanged)
self.toolbar = RLiSetupToolbar(self, self._toolSwitcher)
self.catId = 1
self._mgr.AddPane(self.toolbar,
wx.aui.AuiPaneInfo().
Name("maptoolbar").Caption(_("Map Toolbar")).
ToolbarPane().Left().Name('mapToolbar').
CloseButton(False).Layer(1).Gripper(False).
BestSize((self.toolbar.GetBestSize())))
self._mgr.Update()
if self.samplingtype == SamplingType.REGIONS:
self.afterRegionDrawn = Signal('RLiSetupMapPanel.afterRegionDrawn')
self._registeredGraphics = self.mapWindow.RegisterGraphicsToDraw(
graphicsType='line')
elif self.samplingtype in [SamplingType.MUNITSR, SamplingType.MMVWINR]:
self.sampleFrameChanged = Signal(
'RLiSetupMapPanel.sampleFrameChanged')
self._registeredGraphics = self.mapWindow.RegisterGraphicsToDraw(
graphicsType='rectangle')
elif self.samplingtype in [SamplingType.MUNITSC, SamplingType.MMVWINC]:
self.afterCircleDrawn = Signal('RLiSetupMapPanel.afterCircleDrawn')
self._registeredGraphics = self.mapWindow.RegisterGraphicsToDraw(
graphicsType='line')
else:
self.sampleFrameChanged = Signal(
'RLiSetupMapPanel.sampleFrameChanged')
self._registeredGraphics = self.mapWindow.RegisterGraphicsToDraw(
graphicsType='rectangle')
self._registeredGraphics.AddPen('rlisetup', wx.Pen(wx.GREEN, width=2,
style=wx.SOLID))
self._registeredGraphics.AddItem(coords=[[0, 0], [0, 0]],
penName='rlisetup', hide=True)
if self.samplingtype != SamplingType.VECT:
self.toolbar.SelectDefault()
def GetMap(self):
return self.map_
def OnPan(self, event):
"""Panning, set mouse to drag."""
self.mapWindow.SetModePan()
def OnZoomIn(self, event):
"""Zoom in the map."""
self.mapWindow.SetModeZoomIn()
def OnZoomOut(self, event):
"""Zoom out the map."""
self.mapWindow.SetModeZoomOut()
def OnZoomToMap(self, event):
layers = self.map_.GetListOfLayers()
self.mapWindow.ZoomToMap(layers=layers, ignoreNulls=False, render=True)
def OnDrawRadius(self, event):
"""Start draw mode"""
self.mapWindow.mouse['use'] = "None"
self.mapWindow.mouse['box'] = "line"
self.mapWindow.pen = wx.Pen(colour=wx.RED, width=1,
style=wx.SHORT_DASH)
self.mapWindow.SetNamedCursor('cross')
self.mapWindow.mouseLeftUp.connect(self._radiusDrawn)
def OnDigitizeRegion(self, event):
"""Start draw mode"""
self.mapWindow.mouse['use'] = "None"
self.mapWindow.mouse['box'] = "line"
self.mapWindow.pen = wx.Pen(colour=wx.RED, width=1,
style=wx.SHORT_DASH)
self.mapWindow.SetNamedCursor('cross')
self.mapWindow.mouseLeftUp.connect(self._lineSegmentDrawn)
self.mapWindow.mouseDClick.connect(self._mouseDbClick)
self._registeredGraphics.GetItem(0).SetCoords([])
def OnDraw(self, event):
"""Start draw mode"""
self.mapWindow.mouse['use'] = "None"
self.mapWindow.mouse['box'] = "box"
self.mapWindow.pen = wx.Pen(colour=wx.RED, width=2,
style=wx.SHORT_DASH)
self.mapWindow.SetNamedCursor('cross')
self.mapWindow.mouseLeftUp.connect(self._rectangleDrawn)
def _lineSegmentDrawn(self, x, y):
item = self._registeredGraphics.GetItem(0)
coords = item.GetCoords()
if len(coords) == 0:
coords.extend([self.mapWindow.Pixel2Cell(
self.mapWindow.mouse['begin'])])
coords.extend([[x, y]])
item.SetCoords(coords)
item.SetPropertyVal('hide', False)
self.mapWindow.ClearLines()
self._registeredGraphics.Draw()
def _mouseDbClick(self, x, y):
item = self._registeredGraphics.GetItem(0)
coords = item.GetCoords()
coords.extend([[x, y]])
item.SetCoords(coords)
item.SetPropertyVal('hide', False)
self.mapWindow.ClearLines()
self._registeredGraphics.Draw()
self.createRegion()
def createRegion(self):
dlg = wx.TextEntryDialog(None, 'Name of sample region',
'Create region', 'region' + str(self.catId))
ret = dlg.ShowModal()
while True:
if ret == wx.ID_OK:
raster = dlg.GetValue()
if checkMapExists(raster):
GMessage(
parent=self, message=_(
"The raster file %s already"
" exists, please change name") %
raster)
ret = dlg.ShowModal()
else:
dlg.Destroy()
marea = self.writeArea(
self._registeredGraphics.GetItem(0).GetCoords(), raster)
self.nextRegion(next=True, area=marea)
break
else:
self.nextRegion(next=False)
break
def nextRegion(self, next=True, area=None):
self.mapWindow.ClearLines()
item = self._registeredGraphics.GetItem(0)
item.SetCoords([])
item.SetPropertyVal('hide', True)
layers = self.map_.GetListOfLayers()
self.mapWindow.ZoomToMap(layers=layers, ignoreNulls=False, render=True)
if next is True:
self.afterRegionDrawn.emit(marea=area)
else:
gcmd.GMessage(parent=self.parent, message=_(
"Raster map not created. Please redraw region."))
def writeArea(self, coords, rasterName):
polyfile = tempfile.NamedTemporaryFile(delete=False)
polyfile.write("AREA\n")
for coor in coords:
east, north = coor
point = " %s %s\n" % (east, north)
polyfile.write(point)
catbuf = "=%d a\n" % self.catId
polyfile.write(catbuf)
self.catId = self.catId + 1
polyfile.close()
region_settings = grass.parse_command('g.region', flags='p',
delimiter=':')
pname = polyfile.name.split('/')[-1]
tmpraster = "rast_" + pname
tmpvector = "vect_" + pname
wx.BeginBusyCursor()
wx.GetApp().Yield()
RunCommand('r.in.poly', input=polyfile.name, output=tmpraster,
rows=region_settings['rows'], overwrite=True)
RunCommand('r.to.vect', input=tmpraster, output=tmpvector,
type='area', overwrite=True)
RunCommand('v.to.rast', input=tmpvector, output=rasterName,
value=1, use='val')
wx.EndBusyCursor()
grass.use_temp_region()
grass.run_command('g.region', vector=tmpvector)
region = grass.region()
marea = MaskedArea(region, rasterName)
RunCommand('g.remove', flags='f', type='raster', name=tmpraster)
RunCommand('g.remove', flags='f', type='vector', name=tmpvector)
os.unlink(polyfile.name)
return marea
def _onToolChanged(self):
"""Helper function to disconnect drawing"""
try:
self.mapWindow.mouseLeftUp.disconnect(self._rectangleDrawn)
self.mapWindow.mouseLeftUp.disconnect(self._radiusDrawn)
self.mapWindow.mouseMoving.disconnect(self._mouseMoving)
self.mapWindow.mouseLeftDown.disconnect(self._mouseLeftDown)
self.mapWindow.mouseDClick.disconnect(self._mouseDbClick)
except DispatcherKeyError:
pass
def _radiusDrawn(self, x, y):
"""When drawing finished, get region values"""
mouse = self.mapWindow.mouse
item = self._registeredGraphics.GetItem(0)
p1 = mouse['begin']
p2 = mouse['end']
dist, (north, east) = self.mapWindow.Distance(p1, p2, False)
circle = Circle(p1, dist)
self.mapWindow.ClearLines()
self.mapWindow.pdcTmp.SetBrush(wx.Brush(wx.CYAN, wx.TRANSPARENT))
pen = wx.Pen(colour=wx.RED, width=2)
self.mapWindow.pdcTmp.SetPen(pen)
self.mapWindow.pdcTmp.DrawCircle(circle.point[0], circle.point[1],
circle.radius)
self._registeredGraphics.Draw()
self.createCricle(circle)
def createCricle(self, c):
dlg = wx.TextEntryDialog(None,
'Name of sample circle region',
'Create circle region',
'circle' + str(self.catId))
ret = dlg.ShowModal()
while True:
if ret == wx.ID_OK:
raster = dlg.GetValue()
if checkMapExists(raster):
GMessage(
parent=self, message=_(
"The raster file %s already"
" exists, please change name") %
raster)
ret = dlg.ShowModal()
else:
dlg.Destroy()
circle = self.writeCircle(c, raster)
self.nextCircle(next=True, circle=circle)
break
else:
self.nextCircle(next=False)
break
def nextCircle(self, next=True, circle=None):
self.mapWindow.ClearLines()
item = self._registeredGraphics.GetItem(0)
item.SetPropertyVal('hide', True)
layers = self.map_.GetListOfLayers()
self.mapWindow.ZoomToMap(layers=layers, ignoreNulls=False, render=True)
if next is True:
self.afterCircleDrawn.emit(region=circle)
else:
gcmd.GMessage(parent=self.parent, message=_(
"Raster map not created. redraw region again."))
def writeCircle(self, circle, rasterName):
coords = self.mapWindow.Pixel2Cell(circle.point)
RunCommand('r.circle', output=rasterName, max=circle.radius,
coordinate=coords, flags="b")
grass.use_temp_region()
grass.run_command('g.region', zoom=rasterName)
region = grass.region()
marea = MaskedArea(region, rasterName, circle.radius)
return marea
def _rectangleDrawn(self):
"""When drawing finished, get region values"""
mouse = self.mapWindow.mouse
item = self._registeredGraphics.GetItem(0)
p1 = self.mapWindow.Pixel2Cell(mouse['begin'])
p2 = self.mapWindow.Pixel2Cell(mouse['end'])
item.SetCoords([p1, p2])
region = {'n': max(p1[1], p2[1]),
's': min(p1[1], p2[1]),
'w': min(p1[0], p2[0]),
'e': max(p1[0], p2[0])}
item.SetPropertyVal('hide', False)
self.mapWindow.ClearLines()
self._registeredGraphics.Draw()
if self.samplingtype in [SamplingType.MUNITSR, SamplingType.MMVWINR]:
dlg = wx.MessageDialog(self, "Is this area ok?",
"select sampling unit",
wx.YES_NO | wx.ICON_QUESTION)
ret = dlg.ShowModal()
if ret == wx.ID_YES:
grass.use_temp_region()
grass.run_command('g.region', n=region['n'], s=region['s'],
e=region['e'], w=region['w'])
tregion = grass.region()
self.sampleFrameChanged.emit(region=tregion)
self.mapWindow.ClearLines()
item = self._registeredGraphics.GetItem(0)
item.SetPropertyVal('hide', True)
layers = self.map_.GetListOfLayers()
self.mapWindow.ZoomToMap(layers=layers, ignoreNulls=False,
render=True)
else:
self.nextRegion(next=False)
dlg.Destroy()
elif self.samplingtype != SamplingType.WHOLE:
"""When drawing finished, get region values"""
self.sampleFrameChanged.emit(region=region)
def __init__(
self,
parent,
giface,
title=_(
"GRASS GIS Manage Location of Tick Points on a Scanned Photo"),
toolbars=["gcpdisp"],
Map=None,
auimgr=None,
name='GCPMapWindow',
**kwargs):
"""Main map display window with toolbars, statusbar and
DrawWindow
:param giface: GRASS interface instance
:param title: window title
:param toolbars: array of activated toolbars, e.g. ['map', 'digit']
:param map: instance of render.Map
:param auimgs: AUI manager
:param kwargs: wx.Frame attribures
"""
SingleMapFrame.__init__(self,
parent=parent,
giface=giface,
title=title,
Map=Map,
auimgr=auimgr,
name=name,
**kwargs)
self._giface = giface
# properties are shared in other objects, so defining here
self.mapWindowProperties = MapWindowProperties()
self.mapWindowProperties.setValuesFromUserSettings()
self.mapWindowProperties.alignExtent = True
#
# Add toolbars
#
for toolb in toolbars:
self.AddToolbar(toolb)
self.activemap = self.toolbars['gcpdisp'].togglemap
self.activemap.SetSelection(0)
self.SrcMap = self.grwiz.SrcMap # instance of render.Map
self.TgtMap = self.grwiz.TgtMap # instance of render.Map
self._mgr.SetDockSizeConstraint(0.5, 0.5)
#
# Add statusbar
#
# items for choice
self.statusbarItems = [
sb.SbCoordinates, sb.SbRegionExtent, sb.SbCompRegionExtent,
sb.SbShowRegion, sb.SbResolution, sb.SbDisplayGeometry,
sb.SbMapScale, sb.SbProjection, sbgcp.SbGoToGCP, sbgcp.SbRMSError
]
# create statusbar and its manager
statusbar = self.CreateStatusBar(number=4, style=0)
statusbar.SetStatusWidths([-5, -2, -1, -1])
self.statusbarManager = sb.SbManager(mapframe=self,
statusbar=statusbar)
# fill statusbar manager
self.statusbarManager.AddStatusbarItemsByClass(self.statusbarItems,
mapframe=self,
statusbar=statusbar)
self.statusbarManager.AddStatusbarItem(
sb.SbMask(self, statusbar=statusbar, position=2))
self.statusbarManager.AddStatusbarItem(
sb.SbRender(self, statusbar=statusbar, position=3))
self.statusbarManager.SetMode(8) # goto GCP
#
# Init map display (buffered DC & set default cursor)
#
self.grwiz.SwitchEnv('source')
self.SrcMapWindow = BufferedMapWindow(
parent=self,
giface=self._giface,
id=wx.ID_ANY,
properties=self.mapWindowProperties,
Map=self.SrcMap)
self.grwiz.SwitchEnv('target')
self.TgtMapWindow = BufferedMapWindow(
parent=self,
giface=self._giface,
id=wx.ID_ANY,
properties=self.mapWindowProperties,
Map=self.TgtMap)
self.MapWindow = self.SrcMapWindow
self.Map = self.SrcMap
self._setUpMapWindow(self.SrcMapWindow)
self._setUpMapWindow(self.TgtMapWindow)
self.SrcMapWindow.SetNamedCursor('cross')
self.TgtMapWindow.SetNamedCursor('cross')
# used to switch current map (combo box in toolbar)
self.SrcMapWindow.mouseEntered.connect(
lambda: self._setActiveMapWindow(self.SrcMapWindow))
self.TgtMapWindow.mouseEntered.connect(
lambda: self._setActiveMapWindow(self.TgtMapWindow))
#
# initialize region values
#
self._initMap(Map=self.SrcMap)
self._initMap(Map=self.TgtMap)
self.GetMapToolbar().SelectDefault()
#
# Bind various events
#
self.activemap.Bind(wx.EVT_CHOICE, self.OnUpdateActive)
self.Bind(wx.EVT_SIZE, self.OnSize)
#
# Update fancy gui style
#
# AuiManager wants a CentrePane, workaround to get two equally sized
# windows
self.list = self.CreateGCPList()
#self.SrcMapWindow.SetSize((300, 300))
#self.TgtMapWindow.SetSize((300, 300))
self.list.SetSize((100, 150))
self._mgr.AddPane(
self.list,
wx.aui.AuiPaneInfo().Name("gcplist").Caption(
_("GCP List")).LeftDockable(False).RightDockable(
False).PinButton().FloatingSize((600, 200)).CloseButton(
False).DestroyOnClose(True).Top().Layer(1).MinSize(
(200, 100)))
self._mgr.AddPane(
self.SrcMapWindow,
wx.aui.AuiPaneInfo().Name("source").Caption(
_("Source Display")).Dockable(False).CloseButton(
False).DestroyOnClose(True).Floatable(False).Centre())
self._mgr.AddPane(
self.TgtMapWindow,
wx.aui.AuiPaneInfo().Name("target").Caption(
_("Target Display")).Dockable(False).CloseButton(False).
DestroyOnClose(True).Floatable(False).Right().Layer(0))
srcwidth, srcheight = self.SrcMapWindow.GetSize()
tgtwidth, tgtheight = self.TgtMapWindow.GetSize()
srcwidth = (srcwidth + tgtwidth) / 2
self._mgr.GetPane("target").Hide()
self._mgr.Update()
self._mgr.GetPane("source").BestSize((srcwidth, srcheight))
self._mgr.GetPane("target").BestSize((srcwidth, srcheight))
if self.show_target:
self._mgr.GetPane("target").Show()
else:
self.activemap.Enable(False)
# needed by Mac OS, does not harm on Linux, breaks display on Windows
if platform.system() != 'Windows':
self._mgr.Update()
#
# Init print module and classes
#
self.printopt = PrintOptions(self, self.MapWindow)
#
# Initialization of digitization tool
#
self.digit = None
# set active map
self.MapWindow = self.SrcMapWindow
self.Map = self.SrcMap
# do not init zoom history here, that happens when zooming to map(s)
#
# Re-use dialogs
#
self.dialogs = {}
self.dialogs['attributes'] = None
self.dialogs['category'] = None
self.dialogs['barscale'] = None
self.dialogs['legend'] = None
self.decorationDialog = None # decoration/overlays
# doing nice things in statusbar when other things are ready
self.statusbarManager.Update()
class MapFrame(SingleMapFrame):
"""Main frame for map display window. Drawing takes place in
child double buffered drawing window.
"""
def __init__(
self,
parent,
giface,
title=_(
"GRASS GIS Manage Location of Tick Points on a Scanned Photo"),
toolbars=["gcpdisp"],
Map=None,
auimgr=None,
name='GCPMapWindow',
**kwargs):
"""Main map display window with toolbars, statusbar and
DrawWindow
:param giface: GRASS interface instance
:param title: window title
:param toolbars: array of activated toolbars, e.g. ['map', 'digit']
:param map: instance of render.Map
:param auimgs: AUI manager
:param kwargs: wx.Frame attribures
"""
SingleMapFrame.__init__(self,
parent=parent,
giface=giface,
title=title,
Map=Map,
auimgr=auimgr,
name=name,
**kwargs)
self._giface = giface
# properties are shared in other objects, so defining here
self.mapWindowProperties = MapWindowProperties()
self.mapWindowProperties.setValuesFromUserSettings()
self.mapWindowProperties.alignExtent = True
#
# Add toolbars
#
for toolb in toolbars:
self.AddToolbar(toolb)
self.activemap = self.toolbars['gcpdisp'].togglemap
self.activemap.SetSelection(0)
self.SrcMap = self.grwiz.SrcMap # instance of render.Map
self.TgtMap = self.grwiz.TgtMap # instance of render.Map
self._mgr.SetDockSizeConstraint(0.5, 0.5)
#
# Add statusbar
#
# items for choice
self.statusbarItems = [
sb.SbCoordinates, sb.SbRegionExtent, sb.SbCompRegionExtent,
sb.SbShowRegion, sb.SbResolution, sb.SbDisplayGeometry,
sb.SbMapScale, sb.SbProjection, sbgcp.SbGoToGCP, sbgcp.SbRMSError
]
# create statusbar and its manager
statusbar = self.CreateStatusBar(number=4, style=0)
statusbar.SetStatusWidths([-5, -2, -1, -1])
self.statusbarManager = sb.SbManager(mapframe=self,
statusbar=statusbar)
# fill statusbar manager
self.statusbarManager.AddStatusbarItemsByClass(self.statusbarItems,
mapframe=self,
statusbar=statusbar)
self.statusbarManager.AddStatusbarItem(
sb.SbMask(self, statusbar=statusbar, position=2))
self.statusbarManager.AddStatusbarItem(
sb.SbRender(self, statusbar=statusbar, position=3))
self.statusbarManager.SetMode(8) # goto GCP
#
# Init map display (buffered DC & set default cursor)
#
self.grwiz.SwitchEnv('source')
self.SrcMapWindow = BufferedMapWindow(
parent=self,
giface=self._giface,
id=wx.ID_ANY,
properties=self.mapWindowProperties,
Map=self.SrcMap)
self.grwiz.SwitchEnv('target')
self.TgtMapWindow = BufferedMapWindow(
parent=self,
giface=self._giface,
id=wx.ID_ANY,
properties=self.mapWindowProperties,
Map=self.TgtMap)
self.MapWindow = self.SrcMapWindow
self.Map = self.SrcMap
self._setUpMapWindow(self.SrcMapWindow)
self._setUpMapWindow(self.TgtMapWindow)
self.SrcMapWindow.SetNamedCursor('cross')
self.TgtMapWindow.SetNamedCursor('cross')
# used to switch current map (combo box in toolbar)
self.SrcMapWindow.mouseEntered.connect(
lambda: self._setActiveMapWindow(self.SrcMapWindow))
self.TgtMapWindow.mouseEntered.connect(
lambda: self._setActiveMapWindow(self.TgtMapWindow))
#
# initialize region values
#
self._initMap(Map=self.SrcMap)
self._initMap(Map=self.TgtMap)
self.GetMapToolbar().SelectDefault()
#
# Bind various events
#
self.activemap.Bind(wx.EVT_CHOICE, self.OnUpdateActive)
self.Bind(wx.EVT_SIZE, self.OnSize)
#
# Update fancy gui style
#
# AuiManager wants a CentrePane, workaround to get two equally sized
# windows
self.list = self.CreateGCPList()
#self.SrcMapWindow.SetSize((300, 300))
#self.TgtMapWindow.SetSize((300, 300))
self.list.SetSize((100, 150))
self._mgr.AddPane(
self.list,
wx.aui.AuiPaneInfo().Name("gcplist").Caption(
_("GCP List")).LeftDockable(False).RightDockable(
False).PinButton().FloatingSize((600, 200)).CloseButton(
False).DestroyOnClose(True).Top().Layer(1).MinSize(
(200, 100)))
self._mgr.AddPane(
self.SrcMapWindow,
wx.aui.AuiPaneInfo().Name("source").Caption(
_("Source Display")).Dockable(False).CloseButton(
False).DestroyOnClose(True).Floatable(False).Centre())
self._mgr.AddPane(
self.TgtMapWindow,
wx.aui.AuiPaneInfo().Name("target").Caption(
_("Target Display")).Dockable(False).CloseButton(False).
DestroyOnClose(True).Floatable(False).Right().Layer(0))
srcwidth, srcheight = self.SrcMapWindow.GetSize()
tgtwidth, tgtheight = self.TgtMapWindow.GetSize()
srcwidth = (srcwidth + tgtwidth) / 2
self._mgr.GetPane("target").Hide()
self._mgr.Update()
self._mgr.GetPane("source").BestSize((srcwidth, srcheight))
self._mgr.GetPane("target").BestSize((srcwidth, srcheight))
if self.show_target:
self._mgr.GetPane("target").Show()
else:
self.activemap.Enable(False)
# needed by Mac OS, does not harm on Linux, breaks display on Windows
if platform.system() != 'Windows':
self._mgr.Update()
#
# Init print module and classes
#
self.printopt = PrintOptions(self, self.MapWindow)
#
# Initialization of digitization tool
#
self.digit = None
# set active map
self.MapWindow = self.SrcMapWindow
self.Map = self.SrcMap
# do not init zoom history here, that happens when zooming to map(s)
#
# Re-use dialogs
#
self.dialogs = {}
self.dialogs['attributes'] = None
self.dialogs['category'] = None
self.dialogs['barscale'] = None
self.dialogs['legend'] = None
self.decorationDialog = None # decoration/overlays
# doing nice things in statusbar when other things are ready
self.statusbarManager.Update()
def _setUpMapWindow(self, mapWindow):
# TODO: almost the smae implementation as for MapFrameBase (only names differ)
# enable or disable zoom history tool
mapWindow.zoomHistoryAvailable.connect(
lambda: self.GetMapToolbar().Enable('zoomback', enable=True))
mapWindow.zoomHistoryUnavailable.connect(
lambda: self.GetMapToolbar().Enable('zoomback', enable=False))
mapWindow.mouseMoving.connect(self.CoordinatesChanged)
def AddToolbar(self, name):
"""Add defined toolbar to the window
Currently known toolbars are:
- 'map' - basic map toolbar
- 'gcpdisp' - GCP Manager, Display
- 'gcpman' - GCP Manager, points management
- 'nviz' - 3D view mode
"""
# default toolbar
if name == "map":
self.toolbars['map'] = MapToolbar(self, self._toolSwitcher)
self._mgr.AddPane(
self.toolbars['map'],
wx.aui.AuiPaneInfo().Name("maptoolbar").Caption(
_("Map Toolbar")).ToolbarPane().Top().LeftDockable(False).
RightDockable(False).BottomDockable(False).TopDockable(
True).CloseButton(False).Layer(2).BestSize(
(self.toolbars['map'].GetSize())))
# GCP display
elif name == "gcpdisp":
self.toolbars['gcpdisp'] = GCPDisplayToolbar(
self, self._toolSwitcher)
self._mgr.AddPane(
self.toolbars['gcpdisp'],
wx.aui.AuiPaneInfo().Name("gcpdisplaytoolbar").Caption(
_("GCP Display toolbar")).ToolbarPane().Top().LeftDockable(
False).RightDockable(False).BottomDockable(False).
TopDockable(True).CloseButton(False).Layer(2))
if self.show_target == False:
self.toolbars['gcpdisp'].Enable('zoommenu', enable=False)
self.toolbars['gcpman'] = GCPManToolbar(self)
self._mgr.AddPane(
self.toolbars['gcpman'],
wx.aui.AuiPaneInfo().Name("gcpmanagertoolbar").Caption(
_("GCP Manager toolbar")).ToolbarPane().Top().Row(1).
LeftDockable(False).RightDockable(False).BottomDockable(
False).TopDockable(True).CloseButton(False).Layer(2))
self._mgr.Update()
def OnUpdateProgress(self, event):
"""
Update progress bar info
"""
self.GetProgressBar().UpdateProgress(event.layer, event.map)
event.Skip()
def OnFocus(self, event):
"""
Change choicebook page to match display.
Or set display for georectifying
"""
# was in if layer manager but considering the state it was executed
# always, moreover, there is no layer manager dependent code
# in GCP Management, set focus to current MapWindow for mouse actions
self.OnPointer(event)
self.MapWindow.SetFocus()
event.Skip()
def OnDraw(self, event):
"""Re-display current map composition
"""
self.MapWindow.UpdateMap(render=False)
def OnRender(self, event):
"""Re-render map composition (each map layer)
"""
# FIXME: remove qlayer code or use RemoveQueryLayer() now in mapdisp.frame
# delete tmp map layers (queries)
qlayer = self.Map.GetListOfLayers(name=globalvar.QUERYLAYER)
for layer in qlayer:
self.Map.DeleteLayer(layer)
self.SrcMapWindow.UpdateMap(render=True)
if self.show_target:
self.TgtMapWindow.UpdateMap(render=True)
# update statusbar
self.StatusbarUpdate()
def OnPointer(self, event):
"""Pointer button clicked
"""
self.SrcMapWindow.SetModePointer()
self.TgtMapWindow.SetModePointer()
# change the default cursor
self.SrcMapWindow.SetNamedCursor('cross')
self.TgtMapWindow.SetNamedCursor('cross')
def OnZoomIn(self, event):
"""Zoom in the map."""
self.SrcMapWindow.SetModeZoomIn()
self.TgtMapWindow.SetModeZoomIn()
def OnZoomOut(self, event):
"""Zoom out the map."""
self.SrcMapWindow.SetModeZoomOut()
self.TgtMapWindow.SetModeZoomOut()
def OnPan(self, event):
"""Panning, set mouse to drag"""
self.SrcMapWindow.SetModePan()
self.TgtMapWindow.SetModePan()
def OnErase(self, event):
"""
Erase the canvas
"""
self.MapWindow.EraseMap()
if self.MapWindow == self.SrcMapWindow:
win = self.TgtMapWindow
elif self.MapWindow == self.TgtMapWindow:
win = self.SrcMapWindow
win.EraseMap()
def SaveToFile(self, event):
"""Save map to image
"""
img = self.MapWindow.img
if not img:
GMessage(parent=self,
message=_(
"Nothing to render (empty map). Operation canceled."))
return
filetype, ltype = GetImageHandlers(img)
# get size
dlg = ImageSizeDialog(self)
dlg.CentreOnParent()
if dlg.ShowModal() != wx.ID_OK:
dlg.Destroy()
return
width, height = dlg.GetValues()
dlg.Destroy()
# get filename
dlg = wx.FileDialog(parent=self,
message=_("Choose a file name to save the image "
"(no need to add extension)"),
wildcard=filetype,
style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
if not path:
dlg.Destroy()
return
base, ext = os.path.splitext(path)
fileType = ltype[dlg.GetFilterIndex()]['type']
extType = ltype[dlg.GetFilterIndex()]['ext']
if ext != extType:
path = base + '.' + extType
self.MapWindow.SaveToFile(path, fileType, width, height)
dlg.Destroy()
def PrintMenu(self, event):
"""
Print options and output menu for map display
"""
point = wx.GetMousePosition()
printmenu = wx.Menu()
# Add items to the menu
setup = wx.MenuItem(printmenu, wx.ID_ANY, _('Page setup'))
printmenu.AppendItem(setup)
self.Bind(wx.EVT_MENU, self.printopt.OnPageSetup, setup)
preview = wx.MenuItem(printmenu, wx.ID_ANY, _('Print preview'))
printmenu.AppendItem(preview)
self.Bind(wx.EVT_MENU, self.printopt.OnPrintPreview, preview)
doprint = wx.MenuItem(printmenu, wx.ID_ANY, _('Print display'))
printmenu.AppendItem(doprint)
self.Bind(wx.EVT_MENU, self.printopt.OnDoPrint, doprint)
# Popup the menu. If an item is selected then its handler
# will be called before PopupMenu returns.
self.PopupMenu(printmenu)
printmenu.Destroy()
def OnZoomToRaster(self, event):
"""
Set display extents to match selected raster map (ignore NULLs)
"""
self.MapWindow.ZoomToMap(ignoreNulls=True)
def OnZoomToSaved(self, event):
"""Set display geometry to match extents in
saved region file
"""
self.MapWindow.SetRegion(zoomOnly=True)
def OnDisplayToWind(self, event):
"""Set computational region (WIND file) to match display
extents
"""
self.MapWindow.DisplayToWind()
def SaveDisplayRegion(self, event):
"""Save display extents to named region file.
"""
self.MapWindow.SaveDisplayRegion()
def OnZoomMenu(self, event):
"""Popup Zoom menu
"""
point = wx.GetMousePosition()
zoommenu = wx.Menu()
# Add items to the menu
zoomwind = wx.MenuItem(
zoommenu, wx.ID_ANY,
_('Zoom to computational region (set with g.region)'))
zoommenu.AppendItem(zoomwind)
self.Bind(wx.EVT_MENU, self.OnZoomToWind, zoomwind)
zoomdefault = wx.MenuItem(zoommenu, wx.ID_ANY,
_('Zoom to default region'))
zoommenu.AppendItem(zoomdefault)
self.Bind(wx.EVT_MENU, self.OnZoomToDefault, zoomdefault)
zoomsaved = wx.MenuItem(zoommenu, wx.ID_ANY, _('Zoom to saved region'))
zoommenu.AppendItem(zoomsaved)
self.Bind(wx.EVT_MENU, self.OnZoomToSaved, zoomsaved)
savewind = wx.MenuItem(zoommenu, wx.ID_ANY,
_('Set computational region from display'))
zoommenu.AppendItem(savewind)
self.Bind(wx.EVT_MENU, self.OnDisplayToWind, savewind)
savezoom = wx.MenuItem(zoommenu, wx.ID_ANY,
_('Save display geometry to named region'))
zoommenu.AppendItem(savezoom)
self.Bind(wx.EVT_MENU, self.SaveDisplayRegion, savezoom)
# Popup the menu. If an item is selected then its handler
# will be called before PopupMenu returns.
self.PopupMenu(zoommenu)
zoommenu.Destroy()
def IsStandalone(self):
"""Check if Map display is standalone"""
# we do not know and we do not care, so always False
return True
def GetLayerManager(self):
"""Get reference to Layer Manager
:return: always None
"""
return None
def GetSrcWindow(self):
return self.SrcMapWindow
def GetTgtWindow(self):
return self.TgtMapWindow
def GetShowTarget(self):
return self.show_target
def GetMapToolbar(self):
"""Returns toolbar with zooming tools"""
return self.toolbars['gcpdisp']
def _setActiveMapWindow(self, mapWindow):
if not self.MapWindow == mapWindow:
self.MapWindow = mapWindow
self.Map = mapWindow.Map
self.UpdateActive(mapWindow)
# needed for wingrass
self.SetFocus()
def __init__(
self,
parent,
giface,
title=_("Example Tool"),
toolbars=["MiscToolbar", "MapToolbar", "MainToolbar"],
size=(800, 600),
name="exampleWindow",
**kwargs,
):
"""!Map Frame constructor
@param parent (no parent is expected)
@param title window title
@param toolbars list of active toolbars (default value represents all toolbars)
@param size default size
"""
SingleMapFrame.__init__(
self, parent=parent, title=title, name=name, Map=Map(), **kwargs
)
# Place debug message where appropriate
# and set debug level from 1 to 5 (higher to lower level functions).
# To enable debug mode write:
# > g.gisenv set=WX_DEBUG=5
Debug.msg(1, "ExampleMapFrame.__init__()")
#
# Add toolbars to aui manager
#
toolbarsCopy = toolbars[:]
# workaround to have the same toolbar order on all platforms
if sys.platform == "win32":
toolbarsCopy.reverse()
for toolbar in toolbarsCopy:
self.AddToolbar(toolbar)
self.mapWindowProperties = MapWindowProperties()
self.mapWindowProperties.setValuesFromUserSettings()
self.mapWindowProperties.autoRenderChanged.connect(
lambda value: self.OnRender(None) if value else None
)
#
# Add statusbar
#
# choose items in statusbar choice, which makes sense for your application
self.statusbarItems = [
sb.SbCoordinates,
sb.SbRegionExtent,
sb.SbCompRegionExtent,
sb.SbShowRegion,
sb.SbAlignExtent,
sb.SbResolution,
sb.SbDisplayGeometry,
sb.SbMapScale,
sb.SbGoTo,
sb.SbProjection,
]
# create statusbar and its manager
statusbar = self.CreateStatusBar(number=4, style=0)
statusbar.SetStatusWidths([-5, -2, -1, -1])
self.statusbarManager = sb.SbManager(mapframe=self, statusbar=statusbar)
# fill statusbar manager
self.statusbarManager.AddStatusbarItemsByClass(
self.statusbarItems, mapframe=self, statusbar=statusbar
)
self.statusbarManager.AddStatusbarItem(
sb.SbMask(self, statusbar=statusbar, position=2)
)
self.statusbarManager.AddStatusbarItem(
sb.SbRender(self, statusbar=statusbar, position=3)
)
self.statusbarManager.Update()
# create map window
self.MapWindow = BufferedMapWindow(
parent=self,
Map=self.GetMap(),
properties=self.mapWindowProperties,
giface=self,
)
self._setUpMapWindow(self.MapWindow)
self.MapWindow.InitZoomHistory()
# create whatever you want, here it is a widget for displaying raster info
self.info = ExampleInfoTextManager(self)
# add map window (and other widgets) to aui manager
self._addPanes()
self._mgr.Update()
# initialize variables related to your application functionality
self.InitVariables()
# default action
self.GetMapToolbar().SelectDefault()
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.SetSize(size)
class ExampleMapFrame(SingleMapFrame):
"""! Main frame of example tool.
Inherits from SingleMapFrame, so map is displayed in one map widow.
In case two map windows are needed, use DoubleMapFrame from (gui_core.mapdisp).
@see IClassMapFrame in iclass.frame
"""
def __init__(
self,
parent,
giface,
title=_("Example Tool"),
toolbars=["MiscToolbar", "MapToolbar", "MainToolbar"],
size=(800, 600),
name="exampleWindow",
**kwargs,
):
"""!Map Frame constructor
@param parent (no parent is expected)
@param title window title
@param toolbars list of active toolbars (default value represents all toolbars)
@param size default size
"""
SingleMapFrame.__init__(
self, parent=parent, title=title, name=name, Map=Map(), **kwargs
)
# Place debug message where appropriate
# and set debug level from 1 to 5 (higher to lower level functions).
# To enable debug mode write:
# > g.gisenv set=WX_DEBUG=5
Debug.msg(1, "ExampleMapFrame.__init__()")
#
# Add toolbars to aui manager
#
toolbarsCopy = toolbars[:]
# workaround to have the same toolbar order on all platforms
if sys.platform == "win32":
toolbarsCopy.reverse()
for toolbar in toolbarsCopy:
self.AddToolbar(toolbar)
self.mapWindowProperties = MapWindowProperties()
self.mapWindowProperties.setValuesFromUserSettings()
self.mapWindowProperties.autoRenderChanged.connect(
lambda value: self.OnRender(None) if value else None
)
#
# Add statusbar
#
# choose items in statusbar choice, which makes sense for your application
self.statusbarItems = [
sb.SbCoordinates,
sb.SbRegionExtent,
sb.SbCompRegionExtent,
sb.SbShowRegion,
sb.SbAlignExtent,
sb.SbResolution,
sb.SbDisplayGeometry,
sb.SbMapScale,
sb.SbGoTo,
sb.SbProjection,
]
# create statusbar and its manager
statusbar = self.CreateStatusBar(number=4, style=0)
statusbar.SetStatusWidths([-5, -2, -1, -1])
self.statusbarManager = sb.SbManager(mapframe=self, statusbar=statusbar)
# fill statusbar manager
self.statusbarManager.AddStatusbarItemsByClass(
self.statusbarItems, mapframe=self, statusbar=statusbar
)
self.statusbarManager.AddStatusbarItem(
sb.SbMask(self, statusbar=statusbar, position=2)
)
self.statusbarManager.AddStatusbarItem(
sb.SbRender(self, statusbar=statusbar, position=3)
)
self.statusbarManager.Update()
# create map window
self.MapWindow = BufferedMapWindow(
parent=self,
Map=self.GetMap(),
properties=self.mapWindowProperties,
giface=self,
)
self._setUpMapWindow(self.MapWindow)
self.MapWindow.InitZoomHistory()
# create whatever you want, here it is a widget for displaying raster info
self.info = ExampleInfoTextManager(self)
# add map window (and other widgets) to aui manager
self._addPanes()
self._mgr.Update()
# initialize variables related to your application functionality
self.InitVariables()
# default action
self.GetMapToolbar().SelectDefault()
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.SetSize(size)
def __del__(self):
"""!Destructor deletes temporary region"""
gcore.del_temp_region()
def OnCloseWindow(self, event):
"""!Destroy frame"""
self.Destroy()
def IsStandalone(self):
"""!Check if application is standalone.
Standalone application can work without parent.
Parent can be e.g. Layer Manager.
"""
if self.parent:
return False
return True
def InitVariables(self):
"""!Initialize any variables nneded by application"""
self.currentRaster = None
self.statitistics = dict()
# use WIND_OVERRIDE region not to affect current region
gcore.use_temp_region()
def _addPanes(self):
"""!Add mapwindow (and other widgets) to aui manager"""
window = self.GetWindow()
name = "mainWindow"
self._mgr.AddPane(
window,
wx.aui.AuiPaneInfo()
.Name(name)
.CentrePane()
.Dockable(False)
.CloseButton(False)
.DestroyOnClose(True)
.Layer(0),
)
window = self.info.GetControl()
name = "infoText"
self._mgr.AddPane(
window,
wx.aui.AuiPaneInfo()
.Name(name)
.Caption(_("Raster Info"))
.MinSize((250, -1))
.Dockable(True)
.CloseButton(False)
.Layer(0)
.Left(),
)
def AddToolbar(self, name):
"""!Add defined toolbar to the window
Currently known toolbars are:
- 'ExampleMapToolbar' - basic map toolbar
- 'ExampleMainToolbar' - toolbar with application specific tools
- 'ExampleMiscToolbar' - toolbar with common tools (help, quit, ...)
"""
# see wx.aui.AuiPaneInfo documentation for understanding all options
if name == "MapToolbar":
self.toolbars[name] = ExampleMapToolbar(self, self._toolSwitcher)
self._mgr.AddPane(
self.toolbars[name],
wx.aui.AuiPaneInfo()
.Name(name)
.Caption(_("Map Toolbar"))
.ToolbarPane()
.Top()
.LeftDockable(False)
.RightDockable(False)
.BottomDockable(False)
.TopDockable(True)
.CloseButton(False)
.Layer(1)
.Row(1)
.BestSize((self.toolbars[name].GetBestSize())),
)
if name == "MiscToolbar":
self.toolbars[name] = ExampleMiscToolbar(self)
self._mgr.AddPane(
self.toolbars[name],
wx.aui.AuiPaneInfo()
.Name(name)
.Caption(_("Misc Toolbar"))
.ToolbarPane()
.Top()
.LeftDockable(False)
.RightDockable(False)
.BottomDockable(False)
.TopDockable(True)
.CloseButton(False)
.Layer(1)
.Row(1)
.BestSize((self.toolbars[name].GetBestSize())),
)
if name == "MainToolbar":
self.toolbars[name] = ExampleMainToolbar(self)
self._mgr.AddPane(
self.toolbars[name],
wx.aui.AuiPaneInfo()
.Name(name)
.Caption(_("Main Toolbar"))
.ToolbarPane()
.Top()
.LeftDockable(False)
.RightDockable(False)
.BottomDockable(False)
.TopDockable(True)
.CloseButton(False)
.Layer(1)
.Row(1)
.BestSize((self.toolbars[name].GetBestSize())),
)
def GetMapToolbar(self):
"""!Returns toolbar with zooming tools"""
return self.toolbars["MapToolbar"]
def OnHelp(self, event):
"""!Show help page"""
RunCommand("g.manual", entry="wxGUI.Example")
def OnSelectRaster(self, event):
"""!Opens dialog to select raster map"""
dlg = ExampleMapDialog(self)
if dlg.ShowModal() == wx.ID_OK:
raster = gcore.find_file(name=dlg.GetRasterMap(), element="cell")
if raster["fullname"]:
self.SetLayer(name=raster["fullname"])
else:
# show user that the map name is incorrect
GError(
parent=self,
message=_("Raster map <{raster}> not found").format(
raster=dlg.GetRasterMap()
),
)
dlg.Destroy()
def SetLayer(self, name):
"""!Sets layer in Map and updates statistics.
@param name layer (raster) name
"""
Debug.msg(3, "ExampleMapFrame.SetLayer(): name=%s" % name)
# this simple application enables to keep only one raster
self.GetMap().DeleteAllLayers()
cmdlist = ["d.rast", "map=%s" % name]
# add layer to Map instance (core.render)
newLayer = self.GetMap().AddLayer(
ltype="raster",
command=cmdlist,
active=True,
name=name,
hidden=False,
opacity=1.0,
render=True,
)
self.GetWindow().ZoomToMap(
layers=[
newLayer,
],
render=True,
)
self.currentRaster = name
# change comp. region to match new raster, so that the statistics
# are computed for the entire raster
RunCommand("g.region", rast=self.currentRaster, parent=self)
self.UpdateStatistics()
def ComputeStatitistics(self):
"""!Computes statistics for raster map using 'r.univar' module.
@return statistic in form of dictionary
"""
# RunCommand enables to run GRASS module
res = RunCommand(
"r.univar", # module name
flags="g", # command flags
map=self.currentRaster, # module parameters
read=True,
) # get command output
return gcore.parse_key_val(res, val_type=float)
def UpdateStatistics(self):
"""!Upadate statistic information.
Called after changing raster map.
"""
stats = self.ComputeStatitistics()
self.info.WriteStatistics(name=self.currentRaster, statDict=stats)
def __init__(
self,
parent,
giface,
title=_("Manage Ground Control Points"),
toolbars=["gcpdisp"],
Map=None,
auimgr=None,
name="GCPMapWindow",
**kwargs,
):
"""Main map display window with toolbars, statusbar and
DrawWindow
:param giface: GRASS interface instance
:param title: window title
:param toolbars: array of activated toolbars, e.g. ['map', 'digit']
:param map: instance of render.Map
:param auimgs: AUI manager
:param kwargs: wx.Frame attribures
"""
SingleMapPanel.__init__(
self,
parent=parent,
giface=giface,
title=title,
Map=Map,
auimgr=auimgr,
name=name,
**kwargs,
)
self._giface = giface
self.mapWindowProperties.alignExtent = True
#
# Add toolbars
#
for toolb in toolbars:
self.AddToolbar(toolb)
self.activemap = self.toolbars["gcpdisp"].togglemap
self.activemap.SetSelection(0)
self.SrcMap = self.grwiz.SrcMap # instance of render.Map
self.TgtMap = self.grwiz.TgtMap # instance of render.Map
self._mgr.SetDockSizeConstraint(0.5, 0.5)
#
# Create statusbar
#
statusbarItems = [
sb.SbCoordinates,
sb.SbRegionExtent,
sb.SbCompRegionExtent,
sb.SbDisplayGeometry,
sb.SbMapScale,
sbgcp.SbGoToGCP,
sbgcp.SbRMSError,
]
self.statusbar = self.CreateStatusbar(statusbarItems)
#
# Init map display (buffered DC & set default cursor)
#
self.grwiz.SwitchEnv("source")
self.SrcMapWindow = BufferedMapWindow(
parent=self,
giface=self._giface,
id=wx.ID_ANY,
properties=self.mapWindowProperties,
Map=self.SrcMap,
)
self.grwiz.SwitchEnv("target")
self.TgtMapWindow = BufferedMapWindow(
parent=self,
giface=self._giface,
id=wx.ID_ANY,
properties=self.mapWindowProperties,
Map=self.TgtMap,
)
self.MapWindow = self.SrcMapWindow
self.Map = self.SrcMap
self._setUpMapWindow(self.SrcMapWindow)
self._setUpMapWindow(self.TgtMapWindow)
self.SrcMapWindow.SetNamedCursor("cross")
self.TgtMapWindow.SetNamedCursor("cross")
# used to switch current map (combo box in toolbar)
self.SrcMapWindow.mouseEntered.connect(
lambda: self._setActiveMapWindow(self.SrcMapWindow))
self.TgtMapWindow.mouseEntered.connect(
lambda: self._setActiveMapWindow(self.TgtMapWindow))
#
# initialize region values
#
self._initMap(Map=self.SrcMap)
self._initMap(Map=self.TgtMap)
self.GetMapToolbar().SelectDefault()
#
# Bind various events
#
self.activemap.Bind(wx.EVT_CHOICE, self.OnUpdateActive)
self.Bind(wx.EVT_SIZE, self.OnSize)
#
# Update fancy gui style
#
# AuiManager wants a CentrePane, workaround to get two equally sized
# windows
self.list = self.CreateGCPList()
# set Go To GCP item as active in statusbar
self.mapWindowProperties.sbItem = 5
# self.SrcMapWindow.SetSize((300, 300))
# self.TgtMapWindow.SetSize((300, 300))
self.list.SetSize((100, 150))
self._addPanes()
srcwidth, srcheight = self.SrcMapWindow.GetSize()
tgtwidth, tgtheight = self.TgtMapWindow.GetSize()
srcwidth = (srcwidth + tgtwidth) / 2
self._mgr.GetPane("target").Hide()
self._mgr.Update()
self._mgr.GetPane("source").BestSize((srcwidth, srcheight))
self._mgr.GetPane("target").BestSize((srcwidth, srcheight))
if self.show_target:
self._mgr.GetPane("target").Show()
else:
self.activemap.Enable(False)
# needed by Mac OS, does not harm on Linux, breaks display on Windows
if platform.system() != "Windows":
self._mgr.Update()
#
# Init print module and classes
#
self.printopt = PrintOptions(self, self.MapWindow)
#
# Initialization of digitization tool
#
self.digit = None
# set active map
self.MapWindow = self.SrcMapWindow
self.Map = self.SrcMap
# do not init zoom history here, that happens when zooming to map(s)
#
# Re-use dialogs
#
self.dialogs = {}
self.dialogs["attributes"] = None
self.dialogs["category"] = None
self.dialogs["barscale"] = None
self.dialogs["legend"] = None
self.decorationDialog = None # decoration/overlays