""" @package gcp.manager @brief Georectification module for GRASS GIS. Includes ground control point management and interactive point and click GCP creation Classes: - manager::GCPWizard - manager::LocationPage - manager::GroupPage - manager::DispMapPage - manager::GCPPanel - manager::GCPDisplay - manager::GCPList - manager::VectGroup - manager::EditGCP - manager::GrSettingsDialog (C) 2006-2014 by the GRASS Development Team This program is free software under the GNU General Public License (>=v2). Read the file COPYING that comes with GRASS for details. @author Original author Michael Barton @author Original version improved by Martin Landa @author Rewritten by Markus Metz redesign georectfier -> GCP Manage @author Support for GraphicsSet added by Stepan Turek (2012) """ from __future__ import print_function import os import sys import shutil import six from copy import copy import wx from wx.lib.mixins.listctrl import ColumnSorterMixin, ListCtrlAutoWidthMixin import wx.lib.colourselect as csel from core import globalvar if globalvar.wxPythonPhoenix: from wx import adv as wiz else: from wx import wizard as wiz import grass.script as grass from core import utils from core.render import Map from gui_core.gselect import Select, LocationSelect, MapsetSelect from gui_core.dialogs import GroupDialog from gui_core.mapdisp import FrameMixin from core.gcmd import RunCommand, GMessage, GError, GWarning from core.settings import UserSettings from gcp.mapdisplay import MapPanel from core.giface import Notification from gui_core.wrap import ( SpinCtrl, Button, StaticText, StaticBox, CheckListBox, TextCtrl, Menu, ListCtrl, BitmapFromImage, CheckListCtrlMixin, ) from location_wizard.wizard import GridBagSizerTitledPage as TitledPage # # global variables # global src_map global tgt_map global maptype src_map = "" tgt_map = {"raster": "", "vector": ""} maptype = "raster" def getSmallUpArrowImage(): stream = open(os.path.join(globalvar.IMGDIR, "small_up_arrow.png"), "rb") try: img = wx.Image(stream) finally: stream.close() return img def getSmallDnArrowImage(): stream = open(os.path.join(globalvar.IMGDIR, "small_down_arrow.png"), "rb") try: img = wx.Image(stream) finally: stream.close() stream.close() return img class GCPWizard(object): """ Start wizard here and finish wizard here """ def __init__(self, parent, giface): self.parent = parent # GMFrame self._giface = giface # # get environmental variables # self.grassdatabase = grass.gisenv()["GISDBASE"] # # read original environment settings # self.target_gisrc = os.environ["GISRC"] self.gisrc_dict = {} try: f = open(self.target_gisrc, "r") for line in f.readlines(): line = line.replace("\n", "").strip() if len(line) < 1: continue key, value = line.split(":", 1) self.gisrc_dict[key.strip()] = value.strip() finally: f.close() self.currentlocation = self.gisrc_dict["LOCATION_NAME"] self.currentmapset = self.gisrc_dict["MAPSET"] # location for xy map to georectify self.newlocation = "" # mapset for xy map to georectify self.newmapset = "" global maptype global src_map global tgt_map # src_map = '' # tgt_map = '' maptype = "raster" # GISRC file for source location/mapset of map(s) to georectify self.source_gisrc = "" self.src_maps = [] # # define wizard pages # self.wizard = wiz.Wizard( parent=parent, id=wx.ID_ANY, title=_("Setup for georectification") ) self.startpage = LocationPage(self.wizard, self) self.grouppage = GroupPage(self.wizard, self) self.mappage = DispMapPage(self.wizard, self) # # set the initial order of the pages # self.startpage.SetNext(self.grouppage) self.grouppage.SetPrev(self.startpage) self.grouppage.SetNext(self.mappage) self.mappage.SetPrev(self.grouppage) # # do pages layout # self.startpage.DoLayout() self.grouppage.DoLayout() self.mappage.DoLayout() self.wizard.FitToPage(self.startpage) # self.Bind(wx.EVT_CLOSE, self.Cleanup) # self.parent.Bind(wx.EVT_ACTIVATE, self.OnGLMFocus) success = False # # run wizard # if self.wizard.RunWizard(self.startpage): success = self.OnWizFinished() if not success: GMessage(parent=self.parent, message=_("Georectifying setup canceled.")) self.Cleanup() else: GMessage(parent=self.parent, message=_("Georectifying setup canceled.")) self.Cleanup() # # start GCP display # if success: # instance of render.Map to be associated with display self.SwitchEnv("source") self.SrcMap = Map(gisrc=self.source_gisrc) self.SwitchEnv("target") self.TgtMap = Map(gisrc=self.target_gisrc) self.Map = self.SrcMap # # add layer to source map # if maptype == "raster": rendertype = "raster" cmdlist = ["d.rast", "map=%s" % src_map] else: # -> vector layer rendertype = "vector" cmdlist = ["d.vect", "map=%s" % src_map] self.SwitchEnv("source") name, found = utils.GetLayerNameFromCmd(cmdlist) self.SrcMap.AddLayer( ltype=rendertype, command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=False, ) self.SwitchEnv("target") web_service_layer = self.mappage.GetWebServiceLayers(name=tgt_map["raster"]) if tgt_map["raster"] and web_service_layer: # # add web service layer to target map # rendertype = web_service_layer["type"] cmdlist = web_service_layer["cmd"] name = tgt_map["raster"] self.TgtMap.AddLayer( ltype=rendertype, command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=False, ) elif tgt_map["raster"]: # # add raster layer to target map # rendertype = "raster" cmdlist = ["d.rast", "map=%s" % tgt_map["raster"]] name, found = utils.GetLayerNameFromCmd(cmdlist) self.TgtMap.AddLayer( ltype=rendertype, command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=False, ) if tgt_map["vector"]: # # add raster layer to target map # rendertype = "vector" cmdlist = ["d.vect", "map=%s" % tgt_map["vector"]] name, found = utils.GetLayerNameFromCmd(cmdlist) self.TgtMap.AddLayer( ltype=rendertype, command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=False, ) # # start GCP Manager # # create superior Map Display frame mapframe = wx.Frame( parent=None, id=wx.ID_ANY, size=globalvar.MAP_WINDOW_SIZE, style=wx.DEFAULT_FRAME_STYLE, title=name, ) # create GCP manager gcpmgr = GCPDisplay( parent=mapframe, giface=self._giface, grwiz=self, id=wx.ID_ANY, Map=self.SrcMap, lmgr=self.parent, title=name, ) # load GCPs gcpmgr.InitMapDisplay() gcpmgr.CenterOnScreen() gcpmgr.Show() # need to update AUI here for wingrass gcpmgr._mgr.Update() else: self.Cleanup() def SetSrcEnv(self, location, mapset): """Create environment to use for location and mapset that are the source of the file(s) to georectify :param location: source location :param mapset: source mapset :return: False on error :return: True on success """ self.newlocation = location self.newmapset = mapset # check to see if we are georectifying map in current working # location/mapset if ( self.newlocation == self.currentlocation and self.newmapset == self.currentmapset ): return False self.gisrc_dict["LOCATION_NAME"] = location self.gisrc_dict["MAPSET"] = mapset self.source_gisrc = utils.GetTempfile() try: f = open(self.source_gisrc, mode="w") for line in self.gisrc_dict.items(): f.write(line[0] + ": " + line[1] + "\n") finally: f.close() return True def SwitchEnv(self, grc): """ Switches between original working location/mapset and location/mapset that is source of file(s) to georectify """ # check to see if we are georectifying map in current working # location/mapset if ( self.newlocation == self.currentlocation and self.newmapset == self.currentmapset ): return False if grc == "target": os.environ["GISRC"] = str(self.target_gisrc) elif grc == "source": os.environ["GISRC"] = str(self.source_gisrc) return True def OnWizFinished(self): # self.Cleanup() return True def OnGLMFocus(self, event): """Layer Manager focus""" # self.SwitchEnv('target') event.Skip() def Cleanup(self): """Return to current location and mapset""" # here was also the cleaning of gcpmanagement from layer manager # which is no longer needed self.SwitchEnv("target") self.wizard.Destroy() class LocationPage(TitledPage): """ Set map type (raster or vector) to georectify and select location/mapset of map(s) to georectify. """ def __init__(self, wizard, parent): TitledPage.__init__(self, wizard, _("Select map type and location/mapset")) self.parent = parent self.grassdatabase = self.parent.grassdatabase self.xylocation = "" self.xymapset = "" # # layout # # map type self.rb_maptype = wx.RadioBox( parent=self, id=wx.ID_ANY, label=" %s " % _("Map type to georectify"), choices=[_("raster"), _("vector")], majorDimension=wx.RA_SPECIFY_COLS, ) self.sizer.Add( self.rb_maptype, flag=wx.ALIGN_CENTER | wx.ALL | wx.EXPAND, border=5, pos=(1, 1), span=(1, 2), ) # location self.sizer.Add( StaticText(parent=self, id=wx.ID_ANY, label=_("Select source location:")), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(2, 1), ) self.cb_location = LocationSelect(parent=self, gisdbase=self.grassdatabase) self.sizer.Add( self.cb_location, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(2, 2), ) # mapset self.sizer.Add( StaticText(parent=self, id=wx.ID_ANY, label=_("Select source mapset:")), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(3, 1), ) self.cb_mapset = MapsetSelect( parent=self, gisdbase=self.grassdatabase, setItems=False ) self.sizer.Add( self.cb_mapset, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(3, 2), ) self.sizer.AddGrowableCol(2) # # bindings # self.Bind(wx.EVT_RADIOBOX, self.OnMaptype, self.rb_maptype) self.Bind(wx.EVT_COMBOBOX, self.OnLocation, self.cb_location) self.cb_mapset.Bind(wx.EVT_TEXT, self.OnMapset) self.Bind(wiz.EVT_WIZARD_PAGE_CHANGING, self.OnPageChanging) self.Bind(wiz.EVT_WIZARD_PAGE_CHANGED, self.OnEnterPage) # self.Bind(wx.EVT_CLOSE, self.parent.Cleanup) def OnMaptype(self, event): """Change map type""" global maptype if event.GetInt() == 0: maptype = "raster" else: maptype = "vector" def OnLocation(self, event): """Sets source location for map(s) to georectify""" self.xylocation = event.GetString() # create a list of valid mapsets tmplist = os.listdir(os.path.join(self.grassdatabase, self.xylocation)) self.mapsetList = [] for item in tmplist: if os.path.isdir( os.path.join(self.grassdatabase, self.xylocation, item) ) and os.path.exists( os.path.join(self.grassdatabase, self.xylocation, item, "WIND") ): if item != "PERMANENT": self.mapsetList.append(item) self.xymapset = "PERMANENT" utils.ListSortLower(self.mapsetList) self.mapsetList.insert(0, "PERMANENT") self.cb_mapset.SetItems(self.mapsetList) self.cb_mapset.SetStringSelection(self.xymapset) if not wx.FindWindowById(wx.ID_FORWARD).IsEnabled(): wx.FindWindowById(wx.ID_FORWARD).Enable(True) def OnMapset(self, event): """Sets source mapset for map(s) to georectify""" if self.xylocation == "": GMessage( _("You must select a valid location " "before selecting a mapset"), parent=self, ) return self.xymapset = event.GetString() if not wx.FindWindowById(wx.ID_FORWARD).IsEnabled(): wx.FindWindowById(wx.ID_FORWARD).Enable(True) def OnPageChanging(self, event=None): if event.GetDirection() and (self.xylocation == "" or self.xymapset == ""): GMessage( _( "You must select a valid location " "and mapset in order to continue" ), parent=self, ) event.Veto() return self.parent.SetSrcEnv(self.xylocation, self.xymapset) def OnEnterPage(self, event=None): if self.xylocation == "" or self.xymapset == "": wx.FindWindowById(wx.ID_FORWARD).Enable(False) else: wx.FindWindowById(wx.ID_FORWARD).Enable(True) class GroupPage(TitledPage): """ Set group to georectify. Create group if desired. """ def __init__(self, wizard, parent): TitledPage.__init__(self, wizard, _("Select image/map group to georectify")) self.parent = parent self.grassdatabase = self.parent.grassdatabase self.groupList = [] self.xylocation = "" self.xymapset = "" self.xygroup = "" # default extension self.extension = "_georect" + str(os.getpid()) # # layout # # group self.sizer.Add( StaticText(parent=self, id=wx.ID_ANY, label=_("Select/create group:")), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(1, 1), ) self.cb_group = wx.ComboBox( parent=self, id=wx.ID_ANY, choices=self.groupList, size=(350, -1), style=wx.CB_DROPDOWN, ) self.sizer.Add( self.cb_group, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(1, 2), ) # create group self.sizer.Add( StaticText( parent=self, id=wx.ID_ANY, label=_("Create group if none exists") ), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(2, 1), ) btnSizer = wx.BoxSizer(wx.HORIZONTAL) self.btn_mkgroup = Button( parent=self, id=wx.ID_ANY, label=_("Create/edit group...") ) self.btn_vgroup = Button( parent=self, id=wx.ID_ANY, label=_("Add vector map to group...") ) btnSizer.Add(self.btn_mkgroup, flag=wx.RIGHT, border=5) btnSizer.Add(self.btn_vgroup, flag=wx.LEFT, border=5) self.sizer.Add( btnSizer, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(2, 2), ) # extension self.sizer.Add( StaticText( parent=self, id=wx.ID_ANY, label=_("Extension for output maps:") ), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(3, 1), ) self.ext_txt = TextCtrl(parent=self, id=wx.ID_ANY, value="", size=(350, -1)) self.ext_txt.SetValue(self.extension) self.sizer.Add( self.ext_txt, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(3, 2), ) self.sizer.AddGrowableCol(2) # # bindings # self.Bind(wx.EVT_COMBOBOX, self.OnGroup, self.cb_group) self.Bind(wx.EVT_TEXT, self.OnExtension, self.ext_txt) self.Bind(wiz.EVT_WIZARD_PAGE_CHANGING, self.OnPageChanging) self.Bind(wiz.EVT_WIZARD_PAGE_CHANGED, self.OnEnterPage) self.Bind(wx.EVT_CLOSE, self.parent.Cleanup) # hide vector group button by default self.btn_vgroup.Hide() def OnGroup(self, event): self.xygroup = event.GetString() def OnMkGroup(self, event): """Create new group in source location/mapset""" if self.xygroup == "": self.xygroup = self.cb_group.GetValue() dlg = GroupDialog(parent=self, defaultGroup=self.xygroup) dlg.DisableSubgroupEdit() dlg.ShowModal() gr, s = dlg.GetSelectedGroup() if gr in dlg.GetExistGroups(): self.xygroup = gr else: gr = "" dlg.Destroy() self.OnEnterPage() self.Update() def OnVGroup(self, event): """Add vector maps to group""" if self.xygroup == "": self.xygroup = self.cb_group.GetValue() vector_dir = os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "vector" ) if os.path.exists(vector_dir): dlg = VectGroup( parent=self, id=wx.ID_ANY, grassdb=self.grassdatabase, location=self.xylocation, mapset=self.xymapset, group=self.xygroup, ) if dlg.ShowModal() != wx.ID_OK: return dlg.MakeVGroup() self.OnEnterPage() else: GError(parent=self, message=_("No vector maps.")) def OnExtension(self, event): self.extension = self.ext_txt.GetValue() def OnPageChanging(self, event=None): if event.GetDirection() and self.xygroup == "": GMessage( _("You must select a valid image/map " "group in order to continue"), parent=self, ) event.Veto() return if event.GetDirection() and self.extension == "": GMessage( _("You must enter an map name " "extension in order to continue"), parent=self, ) event.Veto() return def OnEnterPage(self, event=None): global maptype self.groupList = [] self.xylocation = self.parent.gisrc_dict["LOCATION_NAME"] self.xymapset = self.parent.gisrc_dict["MAPSET"] # create a list of groups in selected mapset if os.path.isdir( os.path.join(self.grassdatabase, self.xylocation, self.xymapset, "group") ): tmplist = os.listdir( os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "group" ) ) for item in tmplist: if os.path.isdir( os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "group", item, ) ): self.groupList.append(item) if maptype == "raster": self.btn_vgroup.Hide() self.Bind(wx.EVT_BUTTON, self.OnMkGroup, self.btn_mkgroup) elif maptype == "vector": self.btn_vgroup.Show() self.Bind(wx.EVT_BUTTON, self.OnMkGroup, self.btn_mkgroup) self.Bind(wx.EVT_BUTTON, self.OnVGroup, self.btn_vgroup) utils.ListSortLower(self.groupList) self.cb_group.SetItems(self.groupList) if len(self.groupList) > 0: if self.xygroup and self.xygroup in self.groupList: self.cb_group.SetStringSelection(self.xygroup) else: self.cb_group.SetSelection(0) self.xygroup = self.groupList[0] if self.xygroup == "" or self.extension == "": wx.FindWindowById(wx.ID_FORWARD).Enable(False) else: wx.FindWindowById(wx.ID_FORWARD).Enable(True) # switch to source self.parent.SwitchEnv("source") class DispMapPage(TitledPage): """ Select ungeoreferenced map to display for interactively setting ground control points (GCPs). """ def __init__(self, wizard, parent): TitledPage.__init__( self, wizard, _("Select maps to display for ground control point (GCP) creation"), ) self.parent = parent global maptype self.web_servc_lyrs_root_node_name = _("Map Display Web Service Layer(s)") # # layout # self.sizer.Add( StaticText( parent=self, id=wx.ID_ANY, label=_("Select source map to display:") ), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(1, 1), ) self.srcselection = Select( self, id=wx.ID_ANY, size=globalvar.DIALOG_GSELECT_SIZE, type=maptype, updateOnPopup=False, ) self.sizer.Add( self.srcselection, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(1, 2), ) self.sizer.Add( StaticText( parent=self, id=wx.ID_ANY, label=_("Select target raster map to display:"), ), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(2, 1), ) self.tgtrastselection = Select( self, id=wx.ID_ANY, size=globalvar.DIALOG_GSELECT_SIZE, type="raster", updateOnPopup=False, extraItems=self.GetSelectTargetRasterExtraItems(), ) self.sizer.Add( self.tgtrastselection, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(2, 2), ) self.sizer.Add( StaticText( parent=self, id=wx.ID_ANY, label=_("Select target vector map to display:"), ), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(3, 1), ) self.tgtvectselection = Select( self, id=wx.ID_ANY, size=globalvar.DIALOG_GSELECT_SIZE, type="vector", updateOnPopup=False, ) self.sizer.Add( self.tgtvectselection, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, pos=(3, 2), ) # # bindings # self.srcselection.Bind(wx.EVT_TEXT, self.OnSrcSelection) self.tgtrastselection.Bind(wx.EVT_TEXT, self.OnTgtRastSelection) self.tgtvectselection.Bind(wx.EVT_TEXT, self.OnTgtVectSelection) self.Bind(wiz.EVT_WIZARD_PAGE_CHANGING, self.OnPageChanging) self.Bind(wiz.EVT_WIZARD_PAGE_CHANGED, self.OnEnterPage) self.Bind(wx.EVT_CLOSE, self.parent.Cleanup) def OnSrcSelection(self, event): """Source map to display selected""" global src_map global maptype src_map = self.srcselection.GetValue() if src_map == "": wx.FindWindowById(wx.ID_FORWARD).Enable(False) else: wx.FindWindowById(wx.ID_FORWARD).Enable(True) try: # set computational region to match selected map and zoom display # to region if maptype == "raster": p = RunCommand("g.region", "raster=src_map") elif maptype == "vector": p = RunCommand("g.region", "vector=src_map") if p.returncode == 0: print("returncode = ", str(p.returncode)) self.parent.Map.region = self.parent.Map.GetRegion() except: pass def OnTgtRastSelection(self, event): """Source map to display selected""" global tgt_map tgt_map["raster"] = self.tgtrastselection.GetValue() def OnTgtVectSelection(self, event): """Source map to display selected""" global tgt_map tgt_map["vector"] = self.tgtvectselection.GetValue() def OnPageChanging(self, event=None): global src_map global tgt_map if event.GetDirection() and (src_map == ""): GMessage( _("You must select a source map " "in order to continue"), parent=self ) event.Veto() return self.parent.SwitchEnv("target") def OnEnterPage(self, event=None): global maptype global src_map global tgt_map self.srcselection.SetElementList(maptype) if maptype == "raster": ret = RunCommand( "i.group", parent=self, read=True, group=self.parent.grouppage.xygroup, flags="g", ) if ret: self.parent.src_maps = ret.splitlines() else: GError( parent=self, message=_( "No maps in selected group <%s>.\n" "Please edit group or select another group." ) % self.parent.grouppage.xygroup, ) return elif maptype == "vector": grassdatabase = self.parent.grassdatabase xylocation = self.parent.gisrc_dict["LOCATION_NAME"] xymapset = self.parent.gisrc_dict["MAPSET"] # make list of vectors to georectify from VREF vgrpfile = os.path.join( grassdatabase, xylocation, xymapset, "group", self.parent.grouppage.xygroup, "VREF", ) error_message = ( _( "No maps in selected group <%s>.\n" "Please edit group or select another group." ) % self.parent.grouppage.xygroup ) try: with open(vgrpfile) as f: for vect in f.readlines(): vect = vect.strip("\n") if len(vect) < 1: continue self.parent.src_maps.append(vect) except FileNotFoundError: GError(parent=self, message=error_message, showTraceback=False) return if len(self.parent.src_maps) < 1: GError(parent=self, message=error_message) return # filter out all maps not in group self.srcselection.tcp.GetElementList(elements=self.parent.src_maps) src_map = self.parent.src_maps[0] self.srcselection.SetValue(src_map) self.parent.SwitchEnv("target") self.tgtrastselection.SetElementList("raster") self.tgtrastselection.GetElementList() self.tgtvectselection.SetElementList("vector") self.tgtvectselection.GetElementList() self.parent.SwitchEnv("source") if src_map == "": wx.FindWindowById(wx.ID_FORWARD).Enable(False) else: wx.FindWindowById(wx.ID_FORWARD).Enable(True) def GetWebServiceLayers(self, ltype=("wms"), name=None): """Get Map Display web service layer(s). :param ltype: map layer type :param name: map layer name :return: web service layer(s) dict { web_service_map_layer_name: {'type': ltype, 'cmd': [cmd list]}, ... } :return: None when web service map layer name doesn't exist """ layers = {} for layer in self.parent._giface.GetLayerList(): if layer.type in ltype: layers[str(layer)] = {"type": layer.type, "cmd": layer.cmd} if name: return layers.get(name) return layers def GetSelectTargetRasterExtraItems(self): """Get select target raster widget extra items.""" return {self.web_servc_lyrs_root_node_name: self.GetWebServiceLayers().keys()} class GCPPanel(MapPanel, ColumnSorterMixin): """ Manages ground control points for georectifying. Calculates RMS statistics. Calls i.rectify or v.rectify to georectify map. """ def __init__( self, parent, giface, grwiz=None, id=wx.ID_ANY, title=_("Manage Ground Control Points"), size=(700, 300), toolbars=["gcpdisp"], Map=None, lmgr=None, ): self.grwiz = grwiz # GR Wizard self._giface = giface if tgt_map["raster"] == "" and tgt_map["vector"] == "": self.show_target = False else: self.show_target = True # wx.Frame.__init__(self, parent, id, title, size = size, name = "GCPFrame") MapPanel.__init__( self, parent=parent, giface=self._giface, title=title, size=size, Map=Map, toolbars=toolbars, name="GCPMapWindow", ) # init variables self.parent = parent # # register data structures for drawing GCP's # self.pointsToDrawTgt = self.TgtMapWindow.RegisterGraphicsToDraw( graphicsType="point", setStatusFunc=self.SetGCPSatus ) self.pointsToDrawSrc = self.SrcMapWindow.RegisterGraphicsToDraw( graphicsType="point", setStatusFunc=self.SetGCPSatus ) # connect to the map windows signals # used to add or edit GCP self.SrcMapWindow.mouseLeftUpPointer.connect( lambda x, y: self._onMouseLeftUpPointer(self.SrcMapWindow, x, y) ) self.TgtMapWindow.mouseLeftUpPointer.connect( lambda x, y: self._onMouseLeftUpPointer(self.TgtMapWindow, x, y) ) # window resized self.resize = False self.grassdatabase = self.grwiz.grassdatabase self.currentlocation = self.grwiz.currentlocation self.currentmapset = self.grwiz.currentmapset self.newlocation = self.grwiz.newlocation self.newmapset = self.grwiz.newmapset self.xylocation = self.grwiz.gisrc_dict["LOCATION_NAME"] self.xymapset = self.grwiz.gisrc_dict["MAPSET"] self.xygroup = self.grwiz.grouppage.xygroup self.src_maps = self.grwiz.src_maps self.extension = self.grwiz.grouppage.extension self.outname = "" self.VectGRList = [] self.file = { "points": os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "group", self.xygroup, "POINTS", ), "points_bak": os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "group", self.xygroup, "POINTS_BAK", ), "rgrp": os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "group", self.xygroup, "REF", ), "vgrp": os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "group", self.xygroup, "VREF", ), "target": os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "group", self.xygroup, "TARGET", ), } # make a backup of the current points file if os.path.exists(self.file["points"]): shutil.copy(self.file["points"], self.file["points_bak"]) # polynomial order transformation for georectification self.gr_order = 1 # interpolation method for georectification self.gr_method = "nearest" # region clipping for georectified map self.clip_to_region = False # overwrite result map self.overwrite = False # number of GCPs selected to be used for georectification (checked) self.GCPcount = 0 # forward RMS error self.fwd_rmserror = 0.0 # backward RMS error self.bkw_rmserror = 0.0 # list map coords and ID of map display they came from self.mapcoordlist = [] self.mapcoordlist.append( [ 0, # GCP number 0.0, # source east 0.0, # source north 0.0, # target east 0.0, # target north 0.0, # forward error 0.0, ] ) # backward error # init vars to highlight high RMS errors self.highest_only = True self.show_unused = True self.highest_key = -1 self.rmsthresh = 0 self.rmsmean = 0 self.rmssd = 0 self.SetTarget(self.xygroup, self.currentlocation, self.currentmapset) self.itemDataMap = None # images for column sorting # CheckListCtrlMixin must set an ImageList first self.il = self.list.GetImageList(wx.IMAGE_LIST_SMALL) SmallUpArrow = BitmapFromImage(getSmallUpArrowImage()) SmallDnArrow = BitmapFromImage(getSmallDnArrowImage()) self.sm_dn = self.il.Add(SmallDnArrow) self.sm_up = self.il.Add(SmallUpArrow) # set mouse characteristics self.mapwin = self.SrcMapWindow self.mapwin.mouse["box"] = "point" self.mapwin.mouse["use"] == "pointer" self.mapwin.zoomtype = 0 self.mapwin.pen = wx.Pen(colour="black", width=2, style=wx.SOLID) self.mapwin.SetNamedCursor("cross") self.mapwin = self.TgtMapWindow # set mouse characteristics self.mapwin.mouse["box"] = "point" self.mapwin.mouse["use"] == "pointer" self.mapwin.zoomtype = 0 self.mapwin.pen = wx.Pen(colour="black", width=2, style=wx.SOLID) self.mapwin.SetNamedCursor("cross") # # show new display & draw map # if self.show_target: self.MapWindow = self.TgtMapWindow self.Map = self.TgtMap self.OnZoomToMap(None) self.MapWindow = self.SrcMapWindow self.Map = self.SrcMap self.OnZoomToMap(None) # # bindings # self.Bind(wx.EVT_ACTIVATE, self.OnFocus) self.Bind(wx.EVT_SIZE, self.OnSize) self.Bind(wx.EVT_IDLE, self.OnIdle) self.SetSettings() def __del__(self): """Disable GCP manager mode""" # leaving the method here but was used only to delete gcpmanagement # from layer manager which is now not needed pass def CreateGCPList(self): """Create GCP List Control""" return GCPList(parent=self, gcp=self) # Used by the ColumnSorterMixin, see wx/lib/mixins/listctrl.py def GetListCtrl(self): return self.list def GetMapCoordList(self): return self.mapcoordlist # Used by the ColumnSorterMixin, see wx/lib/mixins/listctrl.py def GetSortImages(self): return (self.sm_dn, self.sm_up) def GetFwdError(self): return self.fwd_rmserror def GetBkwError(self): return self.bkw_rmserror def InitMapDisplay(self): self.list.LoadData() # initialize column sorter self.itemDataMap = self.mapcoordlist ncols = self.list.GetColumnCount() ColumnSorterMixin.__init__(self, ncols) # init to ascending sort on first click self._colSortFlag = [1] * ncols def SetTarget(self, tgroup, tlocation, tmapset): """ Sets rectification target to current location and mapset """ # check to see if we are georectifying map in current working # location/mapset if ( self.newlocation == self.currentlocation and self.newmapset == self.currentmapset ): RunCommand("i.target", parent=self, flags="c", group=tgroup) else: self.grwiz.SwitchEnv("source") RunCommand( "i.target", parent=self, group=tgroup, location=tlocation, mapset=tmapset, ) self.grwiz.SwitchEnv("target") def AddGCP(self, event): """ Appends an item to GCP list """ keyval = self.list.AddGCPItem() + 1 # source east, source north, target east, target north, forward error, # backward error self.mapcoordlist.append( [ keyval, # GCP number 0.0, # source east 0.0, # source north 0.0, # target east 0.0, # target north 0.0, # forward error 0.0, ] ) # backward error if self.statusbarManager.GetMode() == 5: # go to self.StatusbarUpdate() def DeleteGCP(self, event): """ Deletes selected item in GCP list """ minNumOfItems = self.OnGROrder(None) if self.list.GetItemCount() <= minNumOfItems: GMessage( parent=self, message=_("At least %d GCPs required. Operation canceled.") % minNumOfItems, ) return key = self.list.DeleteGCPItem() del self.mapcoordlist[key] # update key and GCP number for newkey in range(key, len(self.mapcoordlist)): index = self.list.FindItem(-1, newkey + 1) self.mapcoordlist[newkey][0] = newkey self.list.SetItem(index, 0, str(newkey)) self.list.SetItemData(index, newkey) # update selected if self.list.GetItemCount() > 0: if self.list.selected < self.list.GetItemCount(): self.list.selectedkey = self.list.GetItemData(self.list.selected) else: self.list.selected = self.list.GetItemCount() - 1 self.list.selectedkey = self.list.GetItemData(self.list.selected) self.list.SetItemState( self.list.selected, wx.LIST_STATE_SELECTED, wx.LIST_STATE_SELECTED ) else: self.list.selected = wx.NOT_FOUND self.list.selectedkey = -1 self.UpdateColours() if self.statusbarManager.GetMode() == 5: # go to self.StatusbarUpdate() if self.list.selectedkey > 0: self.statusbarManager.SetProperty("gotoGCP", self.list.selectedkey) def ClearGCP(self, event): """ Clears all values in selected item of GCP list and unchecks it """ index = self.list.GetSelected() key = self.list.GetItemData(index) for i in range(1, 5): self.list.SetItem(index, i, "0.0") self.list.SetItem(index, 5, "") self.list.SetItem(index, 6, "") self.list.CheckItem(index, False) # GCP number, source E, source N, target E, target N, fwd error, bkwd # error self.mapcoordlist[key] = [key, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] def SetSettings(self): """Sets settings for drawing of GCP's.""" self.highest_only = UserSettings.Get( group="gcpman", key="rms", subkey="highestonly" ) self.show_unused = UserSettings.Get( group="gcpman", key="symbol", subkey="unused" ) colours = { "color": "default", "hcolor": "highest", "scolor": "selected", "ucolor": "unused", } wpx = UserSettings.Get(group="gcpman", key="symbol", subkey="width") for k, v in six.iteritems(colours): col = UserSettings.Get(group="gcpman", key="symbol", subkey=k) self.pointsToDrawSrc.GetPen(v).SetColour( wx.Colour(col[0], col[1], col[2], 255) ) # TODO GetPen neni to spatne? self.pointsToDrawTgt.GetPen(v).SetColour( wx.Colour(col[0], col[1], col[2], 255) ) self.pointsToDrawSrc.GetPen(v).SetWidth(wpx) self.pointsToDrawTgt.GetPen(v).SetWidth(wpx) spx = UserSettings.Get(group="gcpman", key="symbol", subkey="size") self.pointsToDrawSrc.SetPropertyVal("size", int(spx)) self.pointsToDrawTgt.SetPropertyVal("size", int(spx)) font = self.GetFont() font.SetPointSize(int(spx) + 2) textProp = {} textProp["active"] = True textProp["font"] = font self.pointsToDrawSrc.SetPropertyVal("text", textProp) self.pointsToDrawTgt.SetPropertyVal("text", copy(textProp)) # overwrite result map self.overwrite = UserSettings.Get(group="gcpman", key="map", subkey="overwrite") def SetGCPSatus(self, item, itemIndex): """Before GCP is drawn, decides it's colour and whether it will be drawn. """ key = self.list.GetItemData(itemIndex) # incremented because of itemDataMap (has one more item) - will be # changed itemIndex += 1 if not self.list.IsItemChecked(key - 1): wxPen = "unused" if not self.show_unused: item.SetPropertyVal("hide", True) else: item.SetPropertyVal("hide", False) else: item.SetPropertyVal("hide", False) if self.highest_only: if itemIndex == self.highest_key: wxPen = "highest" else: wxPen = "default" else: if self.mapcoordlist[key][5] > self.rmsthresh: wxPen = "highest" else: wxPen = "default" if itemIndex == self.list.selectedkey: wxPen = "selected" item.SetPropertyVal("label", str(itemIndex)) item.SetPropertyVal("penName", wxPen) def SetGCPData(self, coordtype, coord, mapdisp=None, confirm=False): """Inserts coordinates from file, mouse click on map, or after editing into selected item of GCP list and checks it for use. """ index = self.list.GetSelected() if index == wx.NOT_FOUND: return coord0 = coord[0] coord1 = coord[1] key = self.list.GetItemData(index) if confirm: if self.MapWindow == self.SrcMapWindow: currloc = _("source") else: currloc = _("target") ret = wx.MessageBox( parent=self, caption=_("Set GCP coordinates"), message=_( "Set %(coor)s coordinates for GCP No. %(key)s? \n\n" "East: %(coor0)s \n" "North: %(coor1)s" ) % { "coor": currloc, "key": str(key), "coor0": str(coord0), "coor1": str(coord1), }, style=wx.ICON_QUESTION | wx.YES_NO | wx.CENTRE, ) # for wingrass if os.name == "nt": self.MapWindow.SetFocus() if ret == wx.NO: return if coordtype == "source": self.list.SetItem(index, 1, str(coord0)) self.list.SetItem(index, 2, str(coord1)) self.mapcoordlist[key][1] = coord[0] self.mapcoordlist[key][2] = coord[1] self.pointsToDrawSrc.GetItem(key - 1).SetCoords([coord0, coord1]) elif coordtype == "target": self.list.SetItem(index, 3, str(coord0)) self.list.SetItem(index, 4, str(coord1)) self.mapcoordlist[key][3] = coord[0] self.mapcoordlist[key][4] = coord[1] self.pointsToDrawTgt.GetItem(key - 1).SetCoords([coord0, coord1]) self.list.SetItem(index, 5, "0") self.list.SetItem(index, 6, "0") self.mapcoordlist[key][5] = 0.0 self.mapcoordlist[key][6] = 0.0 # self.list.ResizeColumns() def SaveGCPs(self, event): """Make a POINTS file or save GCP coordinates to existing POINTS file """ self.GCPcount = 0 try: f = open(self.file["points"], mode="w") # use os.linesep or '\n' here ??? f.write("# Ground Control Points File\n") f.write("# \n") f.write("# target location: " + self.currentlocation + "\n") f.write("# target mapset: " + self.currentmapset + "\n") f.write("#\tsource\t\ttarget\t\tstatus\n") f.write("#\teast\tnorth\teast\tnorth\t(1=ok, 0=ignore)\n") f.write( "#----------------------- ----------------------- ---------------\n" ) for index in range(self.list.GetItemCount()): if self.list.IsItemChecked(index): check = "1" self.GCPcount += 1 else: check = "0" coord0 = self.list.GetItem(index, 1).GetText() coord1 = self.list.GetItem(index, 2).GetText() coord2 = self.list.GetItem(index, 3).GetText() coord3 = self.list.GetItem(index, 4).GetText() f.write( coord0 + " " + coord1 + " " + coord2 + " " + coord3 + " " + check + "\n" ) except IOError as err: GError( parent=self, message="%s <%s>. %s%s" % ( _("Writing POINTS file failed"), self.file["points"], os.linesep, err, ), ) return f.close() # if event != None save also to backup file if event: shutil.copy(self.file["points"], self.file["points_bak"]) self._giface.WriteLog(_("POINTS file saved for group <%s>") % self.xygroup) # self.SetStatusText(_('POINTS file saved')) def ReadGCPs(self): """ Reads GCPs and georectified coordinates from POINTS file """ self.GCPcount = 0 sourceMapWin = self.SrcMapWindow targetMapWin = self.TgtMapWindow if not sourceMapWin: GError(parent=self, message=_("source mapwin not defined")) if not targetMapWin: GError(parent=self, message=_("target mapwin not defined")) try: f = open(self.file["points"], "r") GCPcnt = 0 for line in f.readlines(): if line[0] == "#" or line == "": continue line = line.replace("\n", "").strip() coords = list(map(float, line.split())) if coords[4] == 1: check = True self.GCPcount += 1 else: check = False self.AddGCP(event=None) self.SetGCPData("source", (coords[0], coords[1]), sourceMapWin) self.SetGCPData("target", (coords[2], coords[3]), targetMapWin) index = self.list.GetSelected() if index != wx.NOT_FOUND: self.list.CheckItem(index, check) GCPcnt += 1 except IOError as err: GError( parent=self, message="%s <%s>. %s%s" % ( _("Reading POINTS file failed"), self.file["points"], os.linesep, err, ), ) return f.close() if GCPcnt == 0: # 3 gcp is minimum for i in range(3): self.AddGCP(None) if self.CheckGCPcount(): # calculate RMS self.RMSError(self.xygroup, self.gr_order) def ReloadGCPs(self, event): """Reload data from file""" # use backup shutil.copy(self.file["points_bak"], self.file["points"]) # delete all items in mapcoordlist self.mapcoordlist = [] self.mapcoordlist.append( [ 0, # GCP number 0.0, # source east 0.0, # source north 0.0, # target east 0.0, # target north 0.0, # forward error 0.0, ] ) # backward error self.list.LoadData() self.itemDataMap = self.mapcoordlist if self._col != -1: self.list.ClearColumnImage(self._col) self._colSortFlag = [1] * self.list.GetColumnCount() # draw GCPs (source and target) sourceMapWin = self.SrcMapWindow sourceMapWin.UpdateMap(render=False, renderVector=False) if self.show_target: targetMapWin = self.TgtMapWindow targetMapWin.UpdateMap(render=False, renderVector=False) def OnFocus(self, event): # TODO: it is here just to remove old or obsolete beavior of base class gcp/MapPanel? # self.grwiz.SwitchEnv('source') pass def _onMouseLeftUpPointer(self, mapWindow, x, y): if mapWindow == self.SrcMapWindow: coordtype = "source" else: coordtype = "target" coord = (x, y) self.SetGCPData(coordtype, coord, self, confirm=True) mapWindow.UpdateMap(render=False, renderVector=False) def OnRMS(self, event): """ RMS button handler """ self.RMSError(self.xygroup, self.gr_order) sourceMapWin = self.SrcMapWindow sourceMapWin.UpdateMap(render=False, renderVector=False) if self.show_target: targetMapWin = self.TgtMapWindow targetMapWin.UpdateMap(render=False, renderVector=False) def CheckGCPcount(self, msg=False): """ Checks to make sure that the minimum number of GCPs have been defined and are active for the selected transformation order """ if ( (self.GCPcount < 3 and self.gr_order == 1) or (self.GCPcount < 6 and self.gr_order == 2) or (self.GCPcount < 10 and self.gr_order == 3) ): if msg: GWarning( parent=self, message=_( "Insufficient points defined and active (checked) " "for selected rectification method (order: %d).\n" "3+ points needed for 1st order,\n" "6+ points for 2nd order, and\n" "10+ points for 3rd order." ) % self.gr_order, ) return False else: return True def _getOverWriteDialog(self, maptype, overwrite): """Get overwrite confirm dialog :param str maptype: map type :param bool overwrite: overwrite :return object: overwrite dialog None: it isn't necessary to display the overwrite dialog """ if maptype == "raster": self.grwiz.SwitchEnv("source") maps = grass.read_command( "i.group", flags="gl", group=self.xygroup, quiet=True, ).split("\n") self.grwiz.SwitchEnv("target") found_maps = [] if maps: for map in maps: if map: map_name = map.split("@")[0] + self.extension found = grass.find_file( name=map_name, element="cell", mapset=self.currentmapset, ) if found["name"]: found_maps.append("<{}>".format(found["name"])) map_name = ", ".join(found_maps) else: self.grwiz.SwitchEnv("target") found = grass.find_file( name=self.outname, element="vector", mapset=self.currentmapset, ) self.grwiz.SwitchEnv("source") map_name = "<{}>".format(found["name"]) if found["name"] and not overwrite: overwrite_dlg = wx.MessageDialog( self.GetParent(), message=_( "The {map_type} map {map_name} exists. " "Do you want to overwrite?".format( map_type=maptype, map_name=map_name, ), ), caption=_("Overwrite?"), style=wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION, ) return overwrite_dlg def OnGeorect(self, event): """ Georectifies map(s) in group using i.rectify or v.transform """ global maptype self.SaveGCPs(None) if not self.CheckGCPcount(msg=True): return if maptype == "raster": overwrite_dlg = self._getOverWriteDialog( maptype=maptype, overwrite=self.overwrite, ) if overwrite_dlg: if not overwrite_dlg.ShowModal() == wx.ID_YES: overwrite_dlg.Destroy() return overwrite_dlg.Destroy() overwrite = True else: overwrite = self.overwrite self.grwiz.SwitchEnv("source") if self.clip_to_region: flags = "ac" else: flags = "a" busy = wx.BusyInfo(_("Rectifying images, please wait..."), parent=self) wx.GetApp().Yield() ret, msg = RunCommand( "i.rectify", parent=self, getErrorMsg=True, quiet=True, group=self.xygroup, extension=self.extension, order=self.gr_order, method=self.gr_method, flags=flags, overwrite=overwrite, ) del busy # provide feedback on failure if ret != 0: print(msg, file=sys.stderr) elif maptype == "vector": # loop through all vectors in VREF self.grwiz.SwitchEnv("source") # make list of vectors to georectify from VREF f = open(self.file["vgrp"]) vectlist = [] try: for vect in f.readlines(): vect = vect.strip("\n") if len(vect) < 1: continue vectlist.append(vect) finally: f.close() # georectify each vector in VREF using v.rectify for vect in vectlist: self.outname = str(vect.split("@")[0]) + self.extension overwrite_dlg = self._getOverWriteDialog( maptype=maptype, overwrite=self.overwrite, ) if overwrite_dlg: if not overwrite_dlg.ShowModal() == wx.ID_YES: overwrite_dlg.Destroy() return overwrite_dlg.Destroy() overwrite = True else: overwrite = self.overwrite self._giface.WriteLog( text=_("Transforming <%s>...") % vect, notification=Notification.MAKE_VISIBLE, ) ret = msg = "" busy = wx.BusyInfo( _("Rectifying vector map <%s>, please wait...") % vect, parent=self ) wx.GetApp().Yield() ret, msg = RunCommand( "v.rectify", parent=self, getErrorMsg=True, quiet=True, input=vect, output=self.outname, group=self.xygroup, order=self.gr_order, overwrite=overwrite, ) del busy # provide feedback on failure if ret != 0: print(msg, file=sys.stderr) self.grwiz.SwitchEnv("target") def OnGeorectDone(self, **kargs): """Print final message""" global maptype if maptype == "raster": return returncode = kargs["returncode"] if returncode == 0: self.VectGRList.append(self.outname) print("*****vector list = " + str(self.VectGRList)) else: self._giface.WriteError( _("Georectification of vector map <%s> failed") % self.outname ) def OnSettings(self, event): """GCP Manager settings""" dlg = GrSettingsDialog( parent=self, giface=self._giface, id=wx.ID_ANY, title=_("GCP Manager settings"), ) if dlg.ShowModal() == wx.ID_OK: pass dlg.Destroy() def UpdateColours( self, srcrender=False, srcrenderVector=False, tgtrender=False, tgtrenderVector=False, ): """update colours""" highest_fwd_err = 0.0 self.highest_key = 0 highest_idx = 0 for index in range(self.list.GetItemCount()): if self.list.IsItemChecked(index): key = self.list.GetItemData(index) fwd_err = self.mapcoordlist[key][5] if self.highest_only: self.list.SetItemTextColour(index, wx.BLACK) if highest_fwd_err < fwd_err: highest_fwd_err = fwd_err self.highest_key = key highest_idx = index elif self.rmsthresh > 0: if fwd_err > self.rmsthresh: self.list.SetItemTextColour(index, wx.RED) else: self.list.SetItemTextColour(index, wx.BLACK) else: self.list.SetItemTextColour(index, wx.BLACK) if self.highest_only and highest_fwd_err > 0.0: self.list.SetItemTextColour(highest_idx, wx.RED) sourceMapWin = self.SrcMapWindow sourceMapWin.UpdateMap(render=srcrender, renderVector=srcrenderVector) if self.show_target: targetMapWin = self.TgtMapWindow targetMapWin.UpdateMap(render=tgtrender, renderVector=tgtrenderVector) def OnQuit(self, event): """Quit georectifier""" ret = wx.MessageBox( parent=self, caption=_("Quit GCP Manager"), message=_("Save ground control points?"), style=wx.ICON_QUESTION | wx.YES_NO | wx.CANCEL | wx.CENTRE, ) if ret != wx.CANCEL: if ret == wx.YES: self.SaveGCPs(None) elif ret == wx.NO: # restore POINTS file from backup if os.path.exists(self.file["points_bak"]): shutil.copy(self.file["points_bak"], self.file["points"]) if os.path.exists(self.file["points_bak"]): os.unlink(self.file["points_bak"]) self.SrcMap.Clean() self.TgtMap.Clean() self.grwiz.Cleanup() self._mgr.UnInit() self.Destroy() # event.Skip() def OnGROrder(self, event): """ sets transformation order for georectifying """ if event: self.gr_order = event.GetInt() + 1 numOfItems = self.list.GetItemCount() minNumOfItems = numOfItems if self.gr_order == 1: minNumOfItems = 3 # self.SetStatusText(_('Insufficient points, 3+ points needed for 1st order')) elif self.gr_order == 2: minNumOfItems = 6 diff = 6 - numOfItems # self.SetStatusText(_('Insufficient points, 6+ points needed for 2nd order')) elif self.gr_order == 3: minNumOfItems = 10 # self.SetStatusText(_('Insufficient points, 10+ points needed for 3rd order')) for i in range(minNumOfItems - numOfItems): self.AddGCP(None) return minNumOfItems def RMSError(self, xygroup, order): """ Uses m.transform to calculate forward and backward error for each used GCP in POINTS file and insert error values into GCP list. Calculates total forward and backward RMS error for all used points """ # save GCPs to points file to make sure that all checked GCPs are used self.SaveGCPs(None) # self.SetStatusText('') if not self.CheckGCPcount(msg=True): return # get list of forward and reverse rms error values for each point self.grwiz.SwitchEnv("source") ret = RunCommand( "m.transform", parent=self, read=True, group=xygroup, order=order ) self.grwiz.SwitchEnv("target") if ret: errlist = ret.splitlines() else: GError( parent=self, message=_( "Could not calculate RMS Error.\n" "Possible error with m.transform." ), ) return # insert error values into GCP list for checked items sdfactor = float(UserSettings.Get(group="gcpman", key="rms", subkey="sdfactor")) GCPcount = 0 sumsq_fwd_err = 0.0 sumsq_bkw_err = 0.0 sum_fwd_err = 0.0 highest_fwd_err = 0.0 self.highest_key = 0 highest_idx = 0 for index in range(self.list.GetItemCount()): key = self.list.GetItemData(index) if self.list.IsItemChecked(index): fwd_err, bkw_err = errlist[GCPcount].split() self.list.SetItem(index, 5, fwd_err) self.list.SetItem(index, 6, bkw_err) self.mapcoordlist[key][5] = float(fwd_err) self.mapcoordlist[key][6] = float(bkw_err) self.list.SetItemTextColour(index, wx.BLACK) if self.highest_only: if highest_fwd_err < float(fwd_err): highest_fwd_err = float(fwd_err) self.highest_key = key highest_idx = index sumsq_fwd_err += float(fwd_err) ** 2 sumsq_bkw_err += float(bkw_err) ** 2 sum_fwd_err += float(fwd_err) GCPcount += 1 else: self.list.SetItem(index, 5, "") self.list.SetItem(index, 6, "") self.mapcoordlist[key][5] = 0.0 self.mapcoordlist[key][6] = 0.0 self.list.SetItemTextColour(index, wx.BLACK) # SD if GCPcount > 0: self.rmsmean = sum_fwd_err / GCPcount self.rmssd = (sumsq_fwd_err - self.rmsmean**2) ** 0.5 self.rmsthresh = self.rmsmean + sdfactor * self.rmssd else: self.rmsthresh = 0 self.rmsmean = 0 self.rmssd = 0 if self.highest_only and highest_fwd_err > 0.0: self.list.SetItemTextColour(highest_idx, wx.RED) elif GCPcount > 0 and self.rmsthresh > 0 and not self.highest_only: for index in range(self.list.GetItemCount()): if self.list.IsItemChecked(index): key = self.list.GetItemData(index) if self.mapcoordlist[key][5] > self.rmsthresh: self.list.SetItemTextColour(index, wx.RED) # calculate global RMS error (geometric mean) self.fwd_rmserror = round((sumsq_fwd_err / GCPcount) ** 0.5, 4) self.bkw_rmserror = round((sumsq_bkw_err / GCPcount) ** 0.5, 4) self.list.ResizeColumns() def GetNewExtent(self, region, map=None): coord_file = utils.GetTempfile() newreg = { "n": 0.0, "s": 0.0, "e": 0.0, "w": 0.0, } try: f = open(coord_file, mode="w") # NW corner f.write(str(region["e"]) + " " + str(region["n"]) + "\n") # NE corner f.write(str(region["e"]) + " " + str(region["s"]) + "\n") # SW corner f.write(str(region["w"]) + " " + str(region["n"]) + "\n") # SE corner f.write(str(region["w"]) + " " + str(region["s"]) + "\n") finally: f.close() # save GCPs to points file to make sure that all checked GCPs are used self.SaveGCPs(None) order = self.gr_order self.gr_order = 1 if not self.CheckGCPcount(msg=True): self.gr_order = order return self.gr_order = order # get list of forward and reverse rms error values for each point self.grwiz.SwitchEnv("source") if map == "source": ret = RunCommand( "m.transform", parent=self, read=True, group=self.xygroup, order=1, format="dst", coords=coord_file, ) elif map == "target": ret = RunCommand( "m.transform", parent=self, read=True, group=self.xygroup, order=1, flags="r", format="src", coords=coord_file, ) os.unlink(coord_file) self.grwiz.SwitchEnv("target") if ret: errlist = ret.splitlines() else: GError( parent=self, message=_( "Could not calculate new extends.\n" "Possible error with m.transform." ), ) return # fist corner e, n = errlist[0].split() fe = float(e) fn = float(n) newreg["n"] = fn newreg["s"] = fn newreg["e"] = fe newreg["w"] = fe # other three corners for i in range(1, 4): e, n = errlist[i].split() fe = float(e) fn = float(n) if fe < newreg["w"]: newreg["w"] = fe if fe > newreg["e"]: newreg["e"] = fe if fn < newreg["s"]: newreg["s"] = fn if fn > newreg["n"]: newreg["n"] = fn return newreg def OnHelp(self, event): """Show GCP Manager manual page""" self._giface.Help(entry="wxGUI.gcp") def OnUpdateActive(self, event): if self.activemap.GetSelection() == 0: self.MapWindow = self.SrcMapWindow self.Map = self.SrcMap else: self.MapWindow = self.TgtMapWindow self.Map = self.TgtMap self.UpdateActive(self.MapWindow) # for wingrass if os.name == "nt": self.MapWindow.SetFocus() def UpdateActive(self, win): # optionally disable tool zoomback tool self.GetMapToolbar().Enable( "zoomback", enable=(len(self.MapWindow.zoomhistory) > 1) ) if self.activemap.GetSelection() != (win == self.TgtMapWindow): self.activemap.SetSelection(win == self.TgtMapWindow) self.StatusbarUpdate() def AdjustMap(self, newreg): """Adjust map window to new extents""" # adjust map window self.Map.region["n"] = newreg["n"] self.Map.region["s"] = newreg["s"] self.Map.region["e"] = newreg["e"] self.Map.region["w"] = newreg["w"] self.MapWindow.ZoomHistory( self.Map.region["n"], self.Map.region["s"], self.Map.region["e"], self.Map.region["w"], ) # LL locations if self.Map.projinfo["proj"] == "ll": if newreg["n"] > 90.0: newreg["n"] = 90.0 if newreg["s"] < -90.0: newreg["s"] = -90.0 ce = newreg["w"] + (newreg["e"] - newreg["w"]) / 2 cn = newreg["s"] + (newreg["n"] - newreg["s"]) / 2 # calculate new center point and display resolution self.Map.region["center_easting"] = ce self.Map.region["center_northing"] = cn self.Map.region["ewres"] = (newreg["e"] - newreg["w"]) / self.Map.width self.Map.region["nsres"] = (newreg["n"] - newreg["s"]) / self.Map.height self.Map.AlignExtentFromDisplay() self.MapWindow.ZoomHistory( self.Map.region["n"], self.Map.region["s"], self.Map.region["e"], self.Map.region["w"], ) if self.MapWindow.redrawAll is False: self.MapWindow.redrawAll = True self.MapWindow.UpdateMap() self.StatusbarUpdate() def OnZoomToSource(self, event): """Set target map window to match extents of source map window""" if not self.MapWindow == self.TgtMapWindow: self.MapWindow = self.TgtMapWindow self.Map = self.TgtMap self.UpdateActive(self.TgtMapWindow) # get new N, S, E, W for target newreg = self.GetNewExtent(self.SrcMap.region, "source") if newreg: self.AdjustMap(newreg) def OnZoomToTarget(self, event): """Set source map window to match extents of target map window""" if not self.MapWindow == self.SrcMapWindow: self.MapWindow = self.SrcMapWindow self.Map = self.SrcMap self.UpdateActive(self.SrcMapWindow) # get new N, S, E, W for target newreg = self.GetNewExtent(self.TgtMap.region, "target") if newreg: self.AdjustMap(newreg) def OnZoomMenuGCP(self, event): """Popup Zoom menu""" point = wx.GetMousePosition() zoommenu = Menu() # Add items to the menu zoomsource = wx.MenuItem( zoommenu, wx.ID_ANY, _("Adjust source display to target display") ) zoommenu.AppendItem(zoomsource) self.Bind(wx.EVT_MENU, self.OnZoomToTarget, zoomsource) zoomtarget = wx.MenuItem( zoommenu, wx.ID_ANY, _("Adjust target display to source display") ) zoommenu.AppendItem(zoomtarget) self.Bind(wx.EVT_MENU, self.OnZoomToSource, zoomtarget) # Popup the menu. If an item is selected then its handler # will be called before PopupMenu returns. self.PopupMenu(zoommenu) zoommenu.Destroy() def OnSize(self, event): """Adjust Map Windows after GCP Map Display has been resized""" # re-render image on idle self.resize = grass.clock() super(MapPanel, self).OnSize(event) def OnIdle(self, event): """GCP Map Display resized, adjust Map Windows""" if self.GetMapToolbar(): if self.resize and self.resize + 0.2 < grass.clock(): srcwidth, srcheight = self.SrcMapWindow.GetSize() tgtwidth, tgtheight = self.TgtMapWindow.GetSize() srcwidth = (srcwidth + tgtwidth) / 2 if self.show_target: self._mgr.GetPane("target").Hide() self._mgr.Update() self._mgr.GetPane("source").BestSize((srcwidth, srcheight)) self._mgr.GetPane("target").BestSize((srcwidth, tgtheight)) if self.show_target: self._mgr.GetPane("target").Show() self._mgr.Update() self.resize = False elif self.resize: event.RequestMore() pass class GCPDisplay(FrameMixin, GCPPanel): """Map display for wrapping map panel with frame methods""" def __init__(self, parent, giface, grwiz, id, lmgr, Map, title, **kwargs): # init map panel GCPPanel.__init__( self, parent=parent, giface=giface, grwiz=grwiz, id=id, lmgr=lmgr, Map=Map, title=title, **kwargs, ) # set system icon parent.SetIcon( wx.Icon( os.path.join(globalvar.ICONDIR, "grass_map.ico"), wx.BITMAP_TYPE_ICO ) ) # bind to frame parent.Bind(wx.EVT_CLOSE, self.OnQuit) # extend shortcuts and create frame accelerator table self.shortcuts_table.append((self.OnFullScreen, wx.ACCEL_NORMAL, wx.WXK_F11)) self._initShortcuts() # add Map Display panel to Map Display frame sizer = wx.BoxSizer(wx.VERTICAL) sizer.Add(self, proportion=1, flag=wx.EXPAND) parent.SetSizer(sizer) parent.Layout() class GCPList(ListCtrl, CheckListCtrlMixin, ListCtrlAutoWidthMixin): def __init__( self, parent, gcp, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.LC_REPORT | wx.SUNKEN_BORDER | wx.LC_HRULES | wx.LC_SINGLE_SEL, ): ListCtrl.__init__(self, parent, id, pos, size, style) self.gcp = gcp # GCP class self.render = True # Mixin settings CheckListCtrlMixin.__init__(self) ListCtrlAutoWidthMixin.__init__(self) # TextEditMixin.__init__(self) # tracks whether list items are checked or not self.CheckList = [] self._Create() self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected) self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnItemActivated) self.Bind(wx.EVT_LIST_COL_CLICK, self.OnColClick) self.selected = wx.NOT_FOUND self.selectedkey = -1 def _Create(self): if 0: # normal, simple columns idx_col = 0 for col in ( _("use"), _("source E"), _("source N"), _("target E"), _("target N"), _("Forward error"), _("Backward error"), ): self.InsertColumn(idx_col, col) idx_col += 1 else: # the hard way: we want images on the column header info = wx.ListItem() info.SetMask(wx.LIST_MASK_TEXT | wx.LIST_MASK_IMAGE | wx.LIST_MASK_FORMAT) info.SetImage(-1) info.m_format = wx.LIST_FORMAT_LEFT idx_col = 0 for lbl in ( _("use"), _("source E"), _("source N"), _("target E"), _("target N"), _("Forward error"), _("Backward error"), ): info.SetText(lbl) self.InsertColumn(idx_col, info) idx_col += 1 def LoadData(self): """Load data into list""" self.DeleteAllItems() self.render = False if os.path.isfile(self.gcp.file["points"]): self.gcp.ReadGCPs() else: # 3 gcp is minimum for i in range(3): self.gcp.AddGCP(None) # select first point by default self.selected = 0 self.selectedkey = self.GetItemData(self.selected) self.SetItemState(self.selected, wx.LIST_STATE_SELECTED, wx.LIST_STATE_SELECTED) self.ResizeColumns() self.render = True self.EnsureVisible(self.selected) def OnCheckItem(self, index, flag): """Item is checked/unchecked""" if self.render: # redraw points sourceMapWin = self.gcp.SrcMapWindow sourceMapWin.UpdateMap(render=False, renderVector=False) if self.gcp.show_target: targetMapWin = self.gcp.TgtMapWindow targetMapWin.UpdateMap(render=False, renderVector=False) def AddGCPItem(self): """ Appends an item to GCP list """ self.selectedkey = self.GetItemCount() + 1 self.Append( [ str(self.selectedkey), # GCP number "0.0", # source E "0.0", # source N "0.0", # target E "0.0", # target N "", # forward error "", ] ) # backward error self.selected = self.GetItemCount() - 1 self.SetItemData(self.selected, self.selectedkey) self.SetItemState(self.selected, wx.LIST_STATE_SELECTED, wx.LIST_STATE_SELECTED) self.ResizeColumns() self.gcp.pointsToDrawSrc.AddItem(coords=[0, 0], label=str(self.selectedkey)) self.gcp.pointsToDrawTgt.AddItem(coords=[0, 0], label=str(self.selectedkey)) self.EnsureVisible(self.selected) return self.selected def DeleteGCPItem(self): """Deletes selected item in GCP list.""" if self.selected == wx.NOT_FOUND: return key = self.GetItemData(self.selected) self.DeleteItem(self.selected) if self.selected != wx.NOT_FOUND: item = self.gcp.pointsToDrawSrc.GetItem(key - 1) self.gcp.pointsToDrawSrc.DeleteItem(item) item = self.gcp.pointsToDrawTgt.GetItem(key - 1) self.gcp.pointsToDrawTgt.DeleteItem(item) return key def ResizeColumns(self): """Resize columns""" minWidth = [90, 120] for i in range(self.GetColumnCount()): self.SetColumnWidth(i, wx.LIST_AUTOSIZE) # first column is checkbox, don't set to minWidth if i > 0 and self.GetColumnWidth(i) < minWidth[i > 4]: self.SetColumnWidth(i, minWidth[i > 4]) self.SendSizeEvent() def GetSelected(self): """Get index of selected item""" return self.selected def OnItemSelected(self, event): """Item selected""" if self.render and self.selected != event.GetIndex(): self.selected = event.GetIndex() self.selectedkey = self.GetItemData(self.selected) sourceMapWin = self.gcp.SrcMapWindow sourceMapWin.UpdateMap(render=False, renderVector=False) if self.gcp.show_target: targetMapWin = self.gcp.TgtMapWindow targetMapWin.UpdateMap(render=False, renderVector=False) event.Skip() def OnItemActivated(self, event): """ When item double clicked, open editor to update coordinate values """ coords = [] index = event.GetIndex() key = self.GetItemData(index) changed = False for i in range(1, 5): coords.append(self.GetItem(index, i).GetText()) dlg = EditGCP(parent=self, id=wx.ID_ANY, data=coords, gcpno=key) if dlg.ShowModal() == wx.ID_OK: values = dlg.GetValues() # string if len(values) == 0: GError( parent=self, message=_("Invalid coordinate value. Operation canceled."), ) else: for i in range(len(values)): if values[i] != coords[i]: self.SetItem(index, i + 1, values[i]) changed = True if changed: # reset RMS and update mapcoordlist self.SetItem(index, 5, "") self.SetItem(index, 6, "") key = self.GetItemData(index) self.gcp.mapcoordlist[key] = [ key, float(values[0]), float(values[1]), float(values[2]), float(values[3]), 0.0, 0.0, ] self.gcp.pointsToDrawSrc.GetItem(key - 1).SetCoords( [float(values[0]), float(values[1])] ) self.gcp.pointsToDrawTgt.GetItem(key - 1).SetCoords( [float(values[2]), float(values[3])] ) self.gcp.UpdateColours() def OnColClick(self, event): """ListCtrl forgets selected item...""" self.selected = self.FindItem(-1, self.selectedkey) self.SetItemState(self.selected, wx.LIST_STATE_SELECTED, wx.LIST_STATE_SELECTED) event.Skip() class VectGroup(wx.Dialog): """Dialog to create a vector group (VREF file) for georectifying .. todo:: Replace by g.group """ def __init__( self, parent, id, grassdb, location, mapset, group, style=wx.DEFAULT_DIALOG_STYLE, ): wx.Dialog.__init__( self, parent, id, style=style, title=_("Create vector map group") ) self.grassdatabase = grassdb self.xylocation = location self.xymapset = mapset self.xygroup = group # # get list of valid vector directories # vectlist = os.listdir( os.path.join(self.grassdatabase, self.xylocation, self.xymapset, "vector") ) for dir in vectlist: if not os.path.isfile( os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "vector", dir, "coor", ) ): vectlist.remove(dir) utils.ListSortLower(vectlist) # path to vref file self.vgrpfile = os.path.join( self.grassdatabase, self.xylocation, self.xymapset, "group", self.xygroup, "VREF", ) # # buttons # self.btnCancel = Button(parent=self, id=wx.ID_CANCEL) self.btnOK = Button(parent=self, id=wx.ID_OK) self.btnOK.SetDefault() # # list of vector maps # self.listMap = CheckListBox(parent=self, id=wx.ID_ANY, choices=vectlist) if os.path.isfile(self.vgrpfile): f = open(self.vgrpfile) try: checked = [] for line in f.readlines(): line = line.replace("\n", "") if len(line) < 1: continue checked.append(line.split("@")[0]) self.listMap.SetCheckedStrings(checked) finally: f.close() line = wx.StaticLine( parent=self, id=wx.ID_ANY, size=(20, -1), style=wx.LI_HORIZONTAL ) # # layout # sizer = wx.BoxSizer(wx.VERTICAL) box = wx.BoxSizer(wx.HORIZONTAL) box.Add( StaticText( parent=self, id=wx.ID_ANY, label=_("Select vector map(s) to add to group:"), ), flag=wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_RIGHT | wx.LEFT, border=5, ) box.Add( self.listMap, flag=wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_RIGHT | wx.LEFT, border=5, ) sizer.Add(box, flag=wx.ALIGN_RIGHT | wx.ALL, border=3) sizer.Add( line, proportion=0, flag=wx.GROW | wx.ALIGN_CENTER_VERTICAL | wx.LEFT | wx.RIGHT, border=5, ) # buttons btnSizer = wx.StdDialogButtonSizer() btnSizer.AddButton(self.btnCancel) btnSizer.AddButton(self.btnOK) btnSizer.Realize() sizer.Add( btnSizer, proportion=0, flag=wx.EXPAND | wx.ALL | wx.ALIGN_CENTER, border=5 ) self.SetSizer(sizer) sizer.Fit(self) self.Layout() def MakeVGroup(self): """Create VREF file""" vgrouplist = [] for item in range(self.listMap.GetCount()): if not self.listMap.IsChecked(item): continue vgrouplist.append(self.listMap.GetString(item) + "@" + self.xymapset) dirname = os.path.dirname(self.vgrpfile) if not os.path.exists(dirname): os.makedirs(dirname) f = open(self.vgrpfile, mode="w") try: for vect in vgrouplist: f.write(vect + "\n") finally: f.close() class EditGCP(wx.Dialog): def __init__( self, parent, data, gcpno, id=wx.ID_ANY, title=_("Edit GCP"), style=wx.DEFAULT_DIALOG_STYLE, ): """Dialog for editing GPC and map coordinates in list control""" wx.Dialog.__init__(self, parent, id, title=title, style=style) panel = wx.Panel(parent=self) sizer = wx.BoxSizer(wx.VERTICAL) box = StaticBox( parent=panel, id=wx.ID_ANY, label=" %s %s " % (_("Ground Control Point No."), str(gcpno)), ) boxSizer = wx.StaticBoxSizer(box, wx.VERTICAL) # source coordinates gridSizer = wx.GridBagSizer(vgap=5, hgap=5) self.xcoord = TextCtrl(parent=panel, id=wx.ID_ANY, size=(150, -1)) self.ycoord = TextCtrl(parent=panel, id=wx.ID_ANY, size=(150, -1)) self.ecoord = TextCtrl(parent=panel, id=wx.ID_ANY, size=(150, -1)) self.ncoord = TextCtrl(parent=panel, id=wx.ID_ANY, size=(150, -1)) # swap source N, target E tmp_coord = data[1] data[1] = data[2] data[2] = tmp_coord row = 0 col = 0 idx = 0 for label, win in ( (_("source E:"), self.xcoord), (_("target E:"), self.ecoord), (_("source N:"), self.ycoord), (_("target N:"), self.ncoord), ): label = StaticText(parent=panel, id=wx.ID_ANY, label=label) gridSizer.Add(label, flag=wx.ALIGN_CENTER_VERTICAL, pos=(row, col)) col += 1 win.SetValue(str(data[idx])) gridSizer.Add(win, pos=(row, col)) col += 1 idx += 1 if col > 3: row += 1 col = 0 boxSizer.Add(gridSizer, proportion=1, flag=wx.EXPAND | wx.ALL, border=5) sizer.Add(boxSizer, proportion=1, flag=wx.EXPAND | wx.ALL, border=5) # # buttons # self.btnCancel = Button(panel, wx.ID_CANCEL) self.btnOk = Button(panel, wx.ID_OK) self.btnOk.SetDefault() btnSizer = wx.StdDialogButtonSizer() btnSizer.AddButton(self.btnCancel) btnSizer.AddButton(self.btnOk) btnSizer.Realize() sizer.Add(btnSizer, proportion=0, flag=wx.ALIGN_RIGHT | wx.ALL, border=5) panel.SetSizer(sizer) sizer.Fit(self) def GetValues(self, columns=None): """Return list of values (as strings).""" valuelist = [] try: float(self.xcoord.GetValue()) float(self.ycoord.GetValue()) float(self.ecoord.GetValue()) float(self.ncoord.GetValue()) except ValueError: return valuelist valuelist.append(self.xcoord.GetValue()) valuelist.append(self.ycoord.GetValue()) valuelist.append(self.ecoord.GetValue()) valuelist.append(self.ncoord.GetValue()) return valuelist class GrSettingsDialog(wx.Dialog): def __init__( self, parent, id, giface, title, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.DEFAULT_DIALOG_STYLE, ): wx.Dialog.__init__(self, parent, id, title, pos, size, style) """ Dialog to set profile text options: font, title and font size, axis labels and font size """ # # initialize variables # self.parent = parent self.new_src_map = src_map self.new_tgt_map = {"raster": tgt_map["raster"], "vector": tgt_map["vector"]} self.sdfactor = 0 self.symbol = {} self.methods = [ "nearest", "linear", "linear_f", "cubic", "cubic_f", "lanczos", "lanczos_f", ] # notebook notebook = wx.Notebook(parent=self, id=wx.ID_ANY, style=wx.BK_DEFAULT) self.__CreateSymbologyPage(notebook) self.__CreateRectificationPage(notebook) # buttons btnSave = Button(self, wx.ID_SAVE) btnApply = Button(self, wx.ID_APPLY) btnClose = Button(self, wx.ID_CLOSE) btnApply.SetDefault() # bindings btnApply.Bind(wx.EVT_BUTTON, self.OnApply) btnApply.SetToolTip(_("Apply changes for the current session")) btnSave.Bind(wx.EVT_BUTTON, self.OnSave) btnSave.SetToolTip( _( "Apply and save changes to user settings file (default for next sessions)" ) ) btnClose.Bind(wx.EVT_BUTTON, self.OnClose) btnClose.SetToolTip(_("Close dialog")) # sizers btnSizer = wx.BoxSizer(wx.HORIZONTAL) btnSizer.Add(btnApply, flag=wx.LEFT | wx.RIGHT, border=5) btnSizer.Add(btnSave, flag=wx.LEFT | wx.RIGHT, border=5) btnSizer.Add(btnClose, flag=wx.LEFT | wx.RIGHT, border=5) # sizers mainSizer = wx.BoxSizer(wx.VERTICAL) mainSizer.Add(notebook, proportion=1, flag=wx.EXPAND | wx.ALL, border=5) mainSizer.Add(btnSizer, proportion=0, flag=wx.ALIGN_RIGHT | wx.ALL, border=5) # flag=wx.EXPAND | wx.ALL | wx.ALIGN_CENTER, border=5) self.SetSizer(mainSizer) mainSizer.Fit(self) def __CreateSymbologyPage(self, notebook): """Create notebook page with symbology settings""" panel = wx.Panel(parent=notebook, id=wx.ID_ANY) notebook.AddPage(page=panel, text=_("Symbology")) sizer = wx.BoxSizer(wx.VERTICAL) rmsgridSizer = wx.GridBagSizer(vgap=5, hgap=5) # highlight only highest forward RMS error self.highlighthighest = wx.CheckBox( parent=panel, id=wx.ID_ANY, label=_("Highlight highest RMS error only") ) hh = UserSettings.Get(group="gcpman", key="rms", subkey="highestonly") self.highlighthighest.SetValue(hh) rmsgridSizer.Add( self.highlighthighest, flag=wx.ALIGN_CENTER_VERTICAL, pos=(0, 0) ) # RMS forward error threshold rmslabel = StaticText( parent=panel, id=wx.ID_ANY, label=_("Highlight RMS error > M + SD * factor:"), ) rmslabel.SetToolTip( _( "Highlight GCPs with an RMS error larger than \n" "mean + standard deviation * given factor. \n" "Recommended values for this factor are between 1 and 2." ) ) rmsgridSizer.Add(rmslabel, flag=wx.ALIGN_CENTER_VERTICAL, pos=(1, 0)) sdfactor = UserSettings.Get(group="gcpman", key="rms", subkey="sdfactor") self.rmsWin = TextCtrl( parent=panel, id=wx.ID_ANY, size=(70, -1), style=wx.TE_NOHIDESEL ) self.rmsWin.SetValue("%s" % str(sdfactor)) if self.parent.highest_only: self.rmsWin.Disable() self.symbol["sdfactor"] = self.rmsWin.GetId() rmsgridSizer.Add(self.rmsWin, flag=wx.ALIGN_RIGHT, pos=(1, 1)) rmsgridSizer.AddGrowableCol(1) sizer.Add(rmsgridSizer, flag=wx.EXPAND | wx.ALL, border=5) box = StaticBox(parent=panel, id=wx.ID_ANY, label=" %s " % _("Symbol settings")) boxSizer = wx.StaticBoxSizer(box, wx.VERTICAL) gridSizer = wx.GridBagSizer(vgap=5, hgap=5) # # general symbol color # row = 0 label = StaticText(parent=panel, id=wx.ID_ANY, label=_("Color:")) gridSizer.Add(label, flag=wx.ALIGN_CENTER_VERTICAL, pos=(row, 0)) col = UserSettings.Get(group="gcpman", key="symbol", subkey="color") colWin = csel.ColourSelect( parent=panel, id=wx.ID_ANY, colour=wx.Colour(col[0], col[1], col[2], 255) ) self.symbol["color"] = colWin.GetId() gridSizer.Add(colWin, flag=wx.ALIGN_RIGHT, pos=(row, 1)) # # symbol color for high forward RMS error # row += 1 label = StaticText( parent=panel, id=wx.ID_ANY, label=_("Color for high RMS error:") ) gridSizer.Add(label, flag=wx.ALIGN_CENTER_VERTICAL, pos=(row, 0)) hcol = UserSettings.Get(group="gcpman", key="symbol", subkey="hcolor") hcolWin = csel.ColourSelect( parent=panel, id=wx.ID_ANY, colour=wx.Colour(hcol[0], hcol[1], hcol[2], 255) ) self.symbol["hcolor"] = hcolWin.GetId() gridSizer.Add(hcolWin, flag=wx.ALIGN_RIGHT, pos=(row, 1)) # # symbol color for selected GCP # row += 1 label = StaticText( parent=panel, id=wx.ID_ANY, label=_("Color for selected GCP:") ) gridSizer.Add(label, flag=wx.ALIGN_CENTER_VERTICAL, pos=(row, 0)) scol = UserSettings.Get(group="gcpman", key="symbol", subkey="scolor") scolWin = csel.ColourSelect( parent=panel, id=wx.ID_ANY, colour=wx.Colour(scol[0], scol[1], scol[2], 255) ) self.symbol["scolor"] = scolWin.GetId() gridSizer.Add(scolWin, flag=wx.ALIGN_RIGHT, pos=(row, 1)) # # symbol color for unused GCP # row += 1 label = StaticText( parent=panel, id=wx.ID_ANY, label=_("Color for unused GCPs:") ) gridSizer.Add(label, flag=wx.ALIGN_CENTER_VERTICAL, pos=(row, 0)) ucol = UserSettings.Get(group="gcpman", key="symbol", subkey="ucolor") ucolWin = csel.ColourSelect( parent=panel, id=wx.ID_ANY, colour=wx.Colour(ucol[0], ucol[1], ucol[2], 255) ) self.symbol["ucolor"] = ucolWin.GetId() gridSizer.Add(ucolWin, flag=wx.ALIGN_RIGHT, pos=(row, 1)) # show unused GCPs row += 1 self.showunused = wx.CheckBox( parent=panel, id=wx.ID_ANY, label=_("Show unused GCPs") ) shuu = UserSettings.Get(group="gcpman", key="symbol", subkey="unused") self.showunused.SetValue(shuu) gridSizer.Add(self.showunused, flag=wx.ALIGN_CENTER_VERTICAL, pos=(row, 0)) # # symbol size # row += 1 label = StaticText(parent=panel, id=wx.ID_ANY, label=_("Symbol size:")) gridSizer.Add(label, flag=wx.ALIGN_CENTER_VERTICAL, pos=(row, 0)) symsize = int(UserSettings.Get(group="gcpman", key="symbol", subkey="size")) sizeWin = SpinCtrl(parent=panel, id=wx.ID_ANY, min=1, max=20) sizeWin.SetValue(symsize) self.symbol["size"] = sizeWin.GetId() gridSizer.Add(sizeWin, flag=wx.ALIGN_RIGHT, pos=(row, 1)) # # symbol width # row += 1 label = StaticText(parent=panel, id=wx.ID_ANY, label=_("Line width:")) gridSizer.Add(label, flag=wx.ALIGN_CENTER_VERTICAL, pos=(row, 0)) width = int(UserSettings.Get(group="gcpman", key="symbol", subkey="width")) widWin = SpinCtrl(parent=panel, id=wx.ID_ANY, min=1, max=10) widWin.SetValue(width) self.symbol["width"] = widWin.GetId() gridSizer.Add(widWin, flag=wx.ALIGN_RIGHT, pos=(row, 1)) gridSizer.AddGrowableCol(1) boxSizer.Add(gridSizer, flag=wx.EXPAND) sizer.Add(boxSizer, flag=wx.EXPAND | wx.ALL, border=5) # # maps to display # # source map to display self.srcselection = Select( panel, id=wx.ID_ANY, size=globalvar.DIALOG_GSELECT_SIZE, type="maptype", updateOnPopup=False, ) self.parent.grwiz.SwitchEnv("source") self.srcselection.SetElementList(maptype) # filter out all maps not in group self.srcselection.tcp.GetElementList(elements=self.parent.src_maps) # target map(s) to display self.parent.grwiz.SwitchEnv("target") self.tgtrastselection = Select( panel, id=wx.ID_ANY, size=globalvar.DIALOG_GSELECT_SIZE, type="raster", updateOnPopup=False, extraItems=self.parent.grwiz.mappage.GetSelectTargetRasterExtraItems(), ) self.tgtrastselection.SetElementList("cell") self.tgtrastselection.GetElementList() self.tgtvectselection = Select( panel, id=wx.ID_ANY, size=globalvar.DIALOG_GSELECT_SIZE, type="vector", updateOnPopup=False, ) self.tgtvectselection.SetElementList("vector") self.tgtvectselection.GetElementList() sizer.Add( StaticText( parent=panel, id=wx.ID_ANY, label=_("Select source map to display:") ), proportion=0, flag=wx.ALIGN_LEFT | wx.ALL, border=5, ) sizer.Add( self.srcselection, proportion=0, flag=wx.ALIGN_LEFT | wx.ALL, border=5 ) self.srcselection.SetValue(src_map) sizer.Add( StaticText( parent=panel, id=wx.ID_ANY, label=_("Select target raster map to display:"), ), proportion=0, flag=wx.ALIGN_LEFT | wx.ALL, border=5, ) sizer.Add( self.tgtrastselection, proportion=0, flag=wx.ALIGN_LEFT | wx.ALL, border=5 ) self.tgtrastselection.SetValue(tgt_map["raster"]) sizer.Add( StaticText( parent=panel, id=wx.ID_ANY, label=_("Select target vector map to display:"), ), proportion=0, flag=wx.ALIGN_LEFT | wx.ALL, border=5, ) sizer.Add( self.tgtvectselection, proportion=0, flag=wx.ALIGN_LEFT | wx.ALL, border=5 ) self.tgtvectselection.SetValue(tgt_map["vector"]) # bindings self.highlighthighest.Bind(wx.EVT_CHECKBOX, self.OnHighlight) self.rmsWin.Bind(wx.EVT_TEXT, self.OnSDFactor) self.srcselection.Bind(wx.EVT_TEXT, self.OnSrcSelection) self.tgtrastselection.Bind(wx.EVT_TEXT, self.OnTgtRastSelection) self.tgtvectselection.Bind(wx.EVT_TEXT, self.OnTgtVectSelection) panel.SetSizer(sizer) return panel def __CreateRectificationPage(self, notebook): """Create notebook page with symbology settings""" panel = wx.Panel(parent=notebook, id=wx.ID_ANY) notebook.AddPage(page=panel, text=_("Rectification")) sizer = wx.BoxSizer(wx.VERTICAL) # transformation order self.rb_grorder = wx.RadioBox( parent=panel, id=wx.ID_ANY, label=" %s " % _("Select rectification order"), choices=[_("1st order"), _("2nd order"), _("3rd order")], majorDimension=wx.RA_SPECIFY_COLS, ) sizer.Add(self.rb_grorder, proportion=0, flag=wx.EXPAND | wx.ALL, border=5) self.rb_grorder.SetSelection(self.parent.gr_order - 1) # interpolation method gridSizer = wx.GridBagSizer(vgap=5, hgap=5) gridSizer.Add( StaticText( parent=panel, id=wx.ID_ANY, label=_("Select interpolation method:") ), pos=(0, 0), flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5, ) self.grmethod = wx.Choice(parent=panel, id=wx.ID_ANY, choices=self.methods) gridSizer.Add(self.grmethod, pos=(0, 1), flag=wx.ALIGN_RIGHT, border=5) self.grmethod.SetStringSelection(self.parent.gr_method) gridSizer.AddGrowableCol(1) sizer.Add(gridSizer, flag=wx.EXPAND | wx.ALL, border=5) # clip to region self.check = wx.CheckBox( parent=panel, id=wx.ID_ANY, label=_("clip to computational region in target location"), ) sizer.Add(self.check, proportion=0, flag=wx.EXPAND | wx.ALL, border=5) self.check.SetValue(self.parent.clip_to_region) # overwrite result map overwrite = UserSettings.Get(group="gcpman", key="map", subkey="overwrite") self.overwrite = wx.CheckBox( parent=panel, id=wx.ID_ANY, label=_("overwrite result map") ) self.Bind(wx.EVT_CHECKBOX, self.OnOverwrite, self.overwrite) sizer.Add(self.overwrite, proportion=0, flag=wx.EXPAND | wx.ALL, border=5) self.overwrite.SetValue(overwrite) self.parent.overwrite = overwrite # extension sizer.Add( StaticText( parent=panel, id=wx.ID_ANY, label=_("Extension for output maps:") ), proportion=0, flag=wx.ALIGN_LEFT | wx.ALL, border=5, ) self.ext_txt = TextCtrl(parent=panel, id=wx.ID_ANY, value="", size=(350, -1)) self.ext_txt.SetValue(self.parent.extension) sizer.Add(self.ext_txt, proportion=0, flag=wx.ALIGN_LEFT | wx.ALL, border=5) # bindings self.ext_txt.Bind(wx.EVT_TEXT, self.OnExtension) self.Bind(wx.EVT_RADIOBOX, self.parent.OnGROrder, self.rb_grorder) self.Bind(wx.EVT_CHOICE, self.OnMethod, self.grmethod) self.Bind(wx.EVT_CHECKBOX, self.OnClipRegion, self.check) panel.SetSizer(sizer) return panel def OnHighlight(self, event): """Checkbox 'highlighthighest' checked/unchecked""" if self.highlighthighest.IsChecked(): self.parent.highest_only = True self.rmsWin.Disable() else: self.parent.highest_only = False self.rmsWin.Enable() def OnSDFactor(self, event): """New factor for RMS threshold = M + SD * factor""" try: self.sdfactor = float(self.rmsWin.GetValue()) except ValueError: return if self.sdfactor <= 0: GError(parent=self, message=_("RMS threshold factor must be > 0")) elif self.sdfactor < 1: GError( parent=self, message=_( "RMS threshold factor is < 1\n" "Too many points might be highlighted" ), ) def OnSrcSelection(self, event): """Source map to display selected""" global src_map tmp_map = self.srcselection.GetValue() if not tmp_map == "" and not tmp_map == src_map: self.new_src_map = tmp_map def OnTgtRastSelection(self, event): """Target map to display selected""" global tgt_map self.new_tgt_map["raster"] = self.tgtrastselection.GetValue() def OnTgtVectSelection(self, event): """Target map to display selected""" global tgt_map self.new_tgt_map["vector"] = self.tgtvectselection.GetValue() def OnMethod(self, event): self.parent.gr_method = self.methods[event.GetSelection()] def OnClipRegion(self, event): self.parent.clip_to_region = event.IsChecked() def OnOverwrite(self, event): self.parent.overwrite = event.IsChecked() def OnExtension(self, event): self.parent.extension = self.ext_txt.GetValue() def UpdateSettings(self): global src_map global tgt_map global maptype layers = None UserSettings.Set( group="gcpman", key="rms", subkey="highestonly", value=self.highlighthighest.GetValue(), ) if self.sdfactor > 0: UserSettings.Set( group="gcpman", key="rms", subkey="sdfactor", value=self.sdfactor ) self.parent.sdfactor = self.sdfactor if self.parent.rmsthresh > 0: self.parent.rmsthresh = ( self.parent.rmsmean + self.parent.sdfactor * self.parent.rmssd ) UserSettings.Set( group="gcpman", key="symbol", subkey="color", value=tuple(wx.FindWindowById(self.symbol["color"]).GetColour()), ) UserSettings.Set( group="gcpman", key="symbol", subkey="hcolor", value=tuple(wx.FindWindowById(self.symbol["hcolor"]).GetColour()), ) UserSettings.Set( group="gcpman", key="symbol", subkey="scolor", value=tuple(wx.FindWindowById(self.symbol["scolor"]).GetColour()), ) UserSettings.Set( group="gcpman", key="symbol", subkey="ucolor", value=tuple(wx.FindWindowById(self.symbol["ucolor"]).GetColour()), ) UserSettings.Set( group="gcpman", key="symbol", subkey="unused", value=self.showunused.GetValue(), ) UserSettings.Set( group="gcpman", key="symbol", subkey="size", value=wx.FindWindowById(self.symbol["size"]).GetValue(), ) UserSettings.Set( group="gcpman", key="symbol", subkey="width", value=wx.FindWindowById(self.symbol["width"]).GetValue(), ) UserSettings.Set( group="gcpman", key="map", subkey="overwrite", value=self.parent.overwrite, ) srcrender = False srcrenderVector = False tgtrender = False tgtrenderVector = False reload_target = False if self.new_src_map != src_map: # remove old layer layers = self.parent.grwiz.SrcMap.GetListOfLayers() self.parent.grwiz.SrcMap.DeleteLayer(layers[0]) src_map = self.new_src_map if maptype == "raster": cmdlist = ["d.rast", "map=%s" % src_map] srcrender = True else: cmdlist = ["d.vect", "map=%s" % src_map] srcrenderVector = True self.parent.grwiz.SwitchEnv("source") name, found = utils.GetLayerNameFromCmd(cmdlist) self.parent.grwiz.SrcMap.AddLayer( ltype=maptype, command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=False, ) self.parent.grwiz.SwitchEnv("target") if ( self.new_tgt_map["raster"] != tgt_map["raster"] or self.new_tgt_map["vector"] != tgt_map["vector"] ): # remove all layers layers = self.parent.grwiz.TgtMap.GetListOfLayers() while layers: self.parent.grwiz.TgtMap.DeleteLayer(layers[0]) del layers[0] layers = self.parent.grwiz.TgtMap.GetListOfLayers() # self.parent.grwiz.TgtMap.DeleteAllLayers() reload_target = True tgt_map["raster"] = self.new_tgt_map["raster"] tgt_map["vector"] = self.new_tgt_map["vector"] web_service_layer = self.parent.grwiz.mappage.GetWebServiceLayers( name=tgt_map["raster"] ) if tgt_map["raster"] != "" and web_service_layer: # # add web service layer to target map # rendertype = web_service_layer["type"] cmdlist = web_service_layer["cmd"] name = tgt_map["raster"] self.parent.grwiz.TgtMap.AddLayer( ltype=rendertype, command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=False, ) elif tgt_map["raster"] != "": cmdlist = ["d.rast", "map=%s" % tgt_map["raster"]] name, found = utils.GetLayerNameFromCmd(cmdlist) self.parent.grwiz.TgtMap.AddLayer( ltype="raster", command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=False, ) tgtrender = True if tgt_map["vector"] != "": cmdlist = ["d.vect", "map=%s" % tgt_map["vector"]] name, found = utils.GetLayerNameFromCmd(cmdlist) self.parent.grwiz.TgtMap.AddLayer( ltype="vector", command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=False, ) tgtrenderVector = True if tgt_map["raster"] == "" and tgt_map["vector"] == "": if self.parent.show_target: self.parent.show_target = False self.parent._mgr.GetPane("target").Hide() self.parent._mgr.Update() self.parent.activemap.SetSelection(0) self.parent.activemap.Enable(False) self.parent.GetMapToolbar().Enable("zoommenu", enable=False) else: if not self.parent.show_target: self.parent.show_target = True self.parent._mgr.GetPane("target").Show() self.parent._mgr.Update() self.parent.activemap.SetSelection(0) self.parent.activemap.Enable(True) self.parent.GetMapToolbar().Enable("zoommenu", enable=True) self.parent.TgtMapWindow.ZoomToMap( layers=self.parent.TgtMap.GetListOfLayers() ) self.parent.UpdateColours( srcrender, srcrenderVector, tgtrender, tgtrenderVector ) self.parent.SetSettings() def OnSave(self, event): """Button 'Save' pressed""" self.UpdateSettings() fileSettings = {} UserSettings.ReadSettingsFile(settings=fileSettings) fileSettings["gcpman"] = UserSettings.Get(group="gcpman") file = UserSettings.SaveToFile(fileSettings) self.parent._giface.WriteLog( _("GCP Manager settings saved to file '%s'.") % file ) # self.Close() def OnApply(self, event): """Button 'Apply' pressed""" self.UpdateSettings() # self.Close() def OnClose(self, event): """Button 'Cancel' pressed""" self.Close()