def main():
options, flags = gscript.parser()
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from dbmgr.manager import AttributeManager
mapName = gscript.find_file(options["map"], element="vector")["fullname"]
if not mapName:
gscript.set_raise_on_error(False)
gscript.fatal(_("Vector map <%s> not found") % options["map"])
app = wx.App()
gscript.message(
_("Loading attribute data for vector map <%s>...") % mapName)
f = AttributeManager(
parent=None,
id=wx.ID_ANY,
base_title=_("Attribute Table Manager - GRASS GIS"),
size=(900, 600),
vectorName=mapName,
)
f.Show()
app.MainLoop()
def main():
options, flags = gscript.parser()
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.utils import _
from dbmgr.manager import AttributeManager
mapName = gscript.find_file(options['map'], element='vector')['fullname']
if not mapName:
gscript.set_raise_on_error(False)
gscript.fatal(_("Vector map <%s> not found") % options['map'])
app = wx.App()
gscript.message(
_("Loading attribute data for vector map <%s>...") % mapName)
f = AttributeManager(parent=None,
id=wx.ID_ANY,
title="%s - <%s>" %
(_("GRASS GIS Attribute Table Manager"), mapName),
size=(900, 600),
vectorName=mapName)
f.Show()
app.MainLoop()
def main():
options, flags = gscript.parser()
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.utils import _
from dbmgr.manager import AttributeManager
mapName = gscript.find_file(options['map'], element='vector')['fullname']
if not mapName:
gscript.set_raise_on_error(False)
gscript.fatal(_("Vector map <%s> not found") % options['map'])
app = wx.App()
gscript.message(_("Loading attribute data for vector map <%s>...") % mapName)
f = AttributeManager(parent=None, id=wx.ID_ANY,
title="%s - <%s>" % (_("GRASS GIS Attribute Table Manager"),
mapName),
size=(900, 600), vectorName=mapName)
f.Show()
app.MainLoop()
def main():
grass.set_raise_on_error(False)
options, flags = grass.parser()
app = MyApp(0) # Create an instance of the application class
app.MainLoop() # Tell it to start processing events
def _set_notebook_defaults():
"""
This function sets several GRASS environment variables that are
important for GRASS to run smoothly in Jupyter.
It also allows GRASS to overwrite existing maps of the same name.
"""
# We want functions to raise exceptions and see standard output of
# the modules in the notebook.
gs.set_raise_on_error(True)
gs.set_capture_stderr(True)
# Allow overwrite of existing maps
os.environ["GRASS_OVERWRITE"] = "1"
def main():
mapName = grass.find_file(options['map'], element = 'vector')['fullname']
if not mapName:
grass.set_raise_on_error(False)
grass.fatal(_("Vector map <%s> not found") % options['map'])
app = wx.App()
grass.message(_("Loading attribute data for vector map <%s>...") % mapName)
f = AttributeManager(parent = None, id = wx.ID_ANY,
title = "%s - <%s>" % (_("GRASS GIS Attribute Table Manager"),
mapName),
size = (900, 600), vectorName = mapName)
f.Show()
app.MainLoop()
def main():
mapName = grass.find_file(options['map'], element='vector')['fullname']
if not mapName:
grass.set_raise_on_error(False)
grass.fatal(_("Vector map <%s> not found") % options['map'])
app = wx.App()
grass.message(_("Loading attribute data for vector map <%s>...") % mapName)
f = AttributeManager(parent=None,
id=wx.ID_ANY,
title="%s - <%s>" %
(_("GRASS GIS Attribute Table Manager"), mapName),
size=(900, 600),
vectorName=mapName)
f.Show()
app.MainLoop()
def initialize_GRASS_notebook(binary, grassdata, location, mapset):
# create GRASS GIS runtime environment
gisbase = subprocess.check_output([binary, "--config", "path"], universal_newlines=True).strip()
os.environ['GISBASE'] = gisbase
sys.path.append(os.path.join(gisbase, "etc", "python"))
# do GRASS GIS imports
import grass.script as gs
import grass.script.setup as gsetup
# set GRASS GIS session data
rcfile = gsetup.init(gisbase, grassdata, location, mapset)
# default font displays
os.environ['GRASS_FONT'] = 'sans'
# overwrite existing maps
os.environ['GRASS_OVERWRITE'] = '1'
gs.set_raise_on_error(True)
gs.set_capture_stderr(True)
# set display modules to render into a file (named map.png by default)
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
os.environ['GRASS_RENDER_FILE_READ'] = 'TRUE'
os.environ['GRASS_LEGEND_FILE'] = 'legend.txt'
from core.gcmd import RunCommand
from animation.mapwindow import AnimationWindow
from animation.provider import BitmapProvider, BitmapPool, \
MapFilesPool, CleanUp
from animation.controller import AnimationController
from animation.anim import Animation
from animation.toolbars import MainToolbar, AnimationToolbar, MiscToolbar
from animation.dialogs import SpeedDialog, PreferencesDialog
from animation.utils import Orientation, ReplayMode, TemporalType
MAX_COUNT = 4
TMP_DIR = None
gcore.set_raise_on_error(True)
class AnimationFrame(wx.Frame):
def __init__(self, parent, giface, title=_("GRASS GIS Animation tool"),
rasters=None, timeseries=None):
wx.Frame.__init__(self, parent, title=title,
style=wx.DEFAULT_FRAME_STYLE, size=(800, 600))
self._giface = giface
self.SetClientSize(self.GetSize())
self.iconsize = (16, 16)
self.SetIcon(
wx.Icon(
os.path.join(
app = wx.App()
if not CheckWxVersion([2, 9]):
wx.InitAllImageHandlers()
# show main frame
giface = StandaloneGrassInterface()
frame = IClassMapFrame(parent=None, giface=giface)
if not flags["m"]:
frame.CenterOnScreen()
if group_name:
frame.SetGroup(group_name, subgroup_name)
if map_name:
giface.WriteLog(_("Loading raster map <%s>...") % map_name)
frame.trainingMapManager.AddLayer(map_name)
if trainingmap_name:
giface.WriteLog(_("Loading training map <%s>...") % trainingmap_name)
frame.ImportAreas(trainingmap_name)
frame.Show()
if flags["m"]:
frame.Maximize()
app.MainLoop()
if __name__ == "__main__":
grass.set_raise_on_error(False)
options, flags = grass.parser()
GuiModuleMain(main)
#%option G_OPT_STDS_INPUTS
#%end
#%option G_OPT_STDS_OUTPUT
#%end
#%option G_OPT_STDS_TYPE
#% guidependency: inputs
#% guisection: Required
#%end
import grass.temporal as tgis
import grass.script as grass
############################################################################
grass.set_raise_on_error(True)
def main():
# Get the options
inputs = options["inputs"]
output = options["output"]
type = options["type"]
# Make sure the temporal database exists
tgis.init()
#Get the current mapset to create the id of the space time dataset
mapset = grass.gisenv()["MAPSET"]
inputs_split = inputs.split(",")
if driver == 'png':
os.environ['GRASS_RENDER_IMMEDIATE'] = 'png'
else:
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
app = wx.App()
if not CheckWxVersion([2, 9]):
wx.InitAllImageHandlers()
frame = VDigitMapFrame(options['map'])
frame.Show()
app.MainLoop()
if __name__ == "__main__":
grass.set_raise_on_error(False)
options, flags = grass.parser()
if not haveVDigit:
grass.fatal(_("Vector digitizer not available. %s") % errorMsg)
if not grass.find_file(name=options['map'],
element='vector',
mapset=grass.gisenv()['MAPSET'])['fullname']:
if not flags['c']:
grass.fatal(
_("Vector map <%s> not found in current mapset. "
"New vector map can be created by providing '-c' flag.") %
options['map'])
else:
def main():
grass.set_raise_on_error(False)
options, flags = grass.parser()
# import wx only after running parser
# to avoid issues with complex imports when only interface is needed
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.render import Map
from core.globalvar import ICONDIR
from mapdisp.frame import MapPanel
from gui_core.mapdisp import FrameMixin
from mapdisp.main import DMonGrassInterface
from core.settings import UserSettings
from vdigit.main import haveVDigit, errorMsg
from grass.exceptions import CalledModuleError
# define classes which needs imports as local
# for longer definitions, a separate file would be a better option
class VDigitMapDisplay(FrameMixin, MapPanel):
"""Map display for wrapping map panel with v.digit mathods and frame methods"""
def __init__(self, parent, vectorMap):
MapPanel.__init__(self,
parent=parent,
Map=Map(),
giface=DMonGrassInterface(None))
# set system icon
parent.SetIcon(
wx.Icon(os.path.join(ICONDIR, "grass_map.ico"),
wx.BITMAP_TYPE_ICO))
# bindings
parent.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
# extend shortcuts and create frame accelerator table
self.shortcuts_table.append(
(self.OnFullScreen, wx.ACCEL_NORMAL, wx.WXK_F11))
self._initShortcuts()
# this giface issue not solved yet, we must set mapframe aferwards
self._giface._mapframe = self
# load vector map
mapLayer = self.GetMap().AddLayer(
ltype="vector",
name=vectorMap,
command=["d.vect", "map=%s" % vectorMap],
active=True,
hidden=False,
opacity=1.0,
render=True,
)
# switch toolbar
self.AddToolbar("vdigit", fixed=True)
# start editing
self.toolbars["vdigit"].StartEditing(mapLayer)
# use Close instead of QuitVDigit for standalone tool
self.toolbars["vdigit"].quitDigitizer.disconnect(self.QuitVDigit)
self.toolbars["vdigit"].quitDigitizer.connect(lambda: self.Close())
# 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()
if not haveVDigit:
grass.fatal(_("Vector digitizer not available. %s") % errorMsg)
if not grass.find_file(name=options["map"],
element="vector",
mapset=grass.gisenv()["MAPSET"])["fullname"]:
if not flags["c"]:
grass.fatal(
_("Vector map <%s> not found in current mapset. "
"New vector map can be created by providing '-c' flag.") %
options["map"])
else:
grass.verbose(_("New vector map <%s> created") % options["map"])
try:
grass.run_command("v.edit",
map=options["map"],
tool="create",
quiet=True)
except CalledModuleError:
grass.fatal(
_("Unable to create new vector map <%s>") % options["map"])
# allow immediate rendering
driver = UserSettings.Get(group="display", key="driver", subkey="type")
if driver == "png":
os.environ["GRASS_RENDER_IMMEDIATE"] = "png"
else:
os.environ["GRASS_RENDER_IMMEDIATE"] = "cairo"
app = wx.App()
frame = wx.Frame(
None,
id=wx.ID_ANY,
size=(850, 600),
style=wx.DEFAULT_FRAME_STYLE,
title=_("Vector Digitizer - GRASS GIS"),
)
frame = VDigitMapDisplay(parent=frame, vectorMap=options["map"])
frame.Show()
app.MainLoop()
def main():
gs.set_raise_on_error(False)
options, flags = gs.parser()
# import wx only after running parser
# to avoid issues with complex imports when only interface is needed
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.render import Map
from mapdisp.frame import MapFrame
from mapdisp.main import DMonGrassInterface
from core.settings import UserSettings
from grass.exceptions import CalledModuleError
# define classes which needs imports as local
# for longer definitions, a separate file would be a better option
class RDigitMapFrame(MapFrame):
def __init__(
self,
new_map=None,
base_map=None,
edit_map=None,
map_type=None,
):
MapFrame.__init__(
self,
parent=None,
Map=Map(),
giface=DMonGrassInterface(None),
title=_("GRASS GIS Raster Digitizer"),
size=(850, 600),
)
# this giface issue not solved yet, we must set mapframe aferwards
self._giface._mapframe = self
self._giface.mapCreated.connect(self.OnMapCreated)
self._mapObj = self.GetMap()
# load raster map
self._addLayer(name=new_map if new_map else edit_map)
# switch toolbar
self.AddToolbar('rdigit', fixed=True)
rdigit = self.toolbars['rdigit']
if new_map:
rdigit._mapSelectionCombo.Unbind(wx.EVT_COMBOBOX)
self.rdigit.SelectNewMap(
standalone=True,
mapName=new_map,
bgMap=base_map,
mapType=map_type,
)
rdigit._mapSelectionCombo.Bind(
wx.EVT_COMBOBOX,
rdigit.OnMapSelection,
)
else:
rdigit._mapSelectionCombo.SetSelection(n=1)
rdigit.OnMapSelection()
def _addLayer(self, name, ltype='raster'):
"""Add layer into map
:param str name: map name
:param str ltype: layer type
"""
mapLayer = self._mapObj.AddLayer(
ltype=ltype,
name=name,
command=['d.rast', "map={}".format(name)],
active=True,
hidden=False,
opacity=1.0,
render=True,
)
def OnMapCreated(self, name, ltype):
"""Add new created raster layer into map
:param str name: map name
:param str ltype: layer type
"""
self._mapObj.Clean()
self._addLayer(name=name, ltype=ltype)
self.GetMapWindow().UpdateMap()
kwargs = {
'new_map': options['create'],
'base_map': options['base'],
'edit_map': options['edit'],
'map_type': options['type'],
}
mapset = gs.gisenv()['MAPSET']
if kwargs['edit_map']:
edit_map = gs.find_file(
name=kwargs['edit_map'],
element='raster',
mapset=mapset,
)['fullname']
if not edit_map:
gs.fatal(
_(
"Raster map <{}> not found in current mapset.".format(
options['edit'], ), ), )
else:
kwargs['edit_map'] = edit_map
else:
if kwargs['base_map']:
base_map = gs.find_file(
name=kwargs['base_map'],
element='raster',
mapset=mapset,
)['fullname']
if not base_map:
gs.fatal(
_(
"Base raster map <{}> not found in "
"current mapset.".format(options['base'], ), ), )
kwargs['base_map'] = base_map
# allow immediate rendering
driver = UserSettings.Get(
group='display',
key='driver',
subkey='type',
)
if driver == 'png':
os.environ['GRASS_RENDER_IMMEDIATE'] = 'png'
else:
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
app = wx.App()
frame = RDigitMapFrame(**kwargs)
frame.Show()
app.MainLoop()
def main():
# Get the options
input = options["input"]
start = options["start"]
stop = options["stop"]
base = options["basename"]
cycle = options["cycle"]
offset = options["offset"]
minimum = options["minimum"]
maximum = options["maximum"]
occurrence = options["occurrence"]
range = options["range"]
indicator = options["indicator"]
staend = options["staend"]
register_null = flags["n"]
reverse = flags["r"]
grass.set_raise_on_error(True)
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
mapset = tgis.get_current_mapset()
if input.find("@") >= 0:
id = input
else:
id = input + "@" + mapset
input_strds = tgis.SpaceTimeRasterDataset(id)
if input_strds.is_in_db() == False:
dbif.close()
grass.fatal(_("Space time %s dataset <%s> not found") % (
input_strds.get_output_map_instance(None).get_type(), id))
input_strds.select(dbif)
dummy = input_strds.get_new_map_instance(None)
# The occurrence space time raster dataset
if occurrence:
if not minimum or not maximum:
if not range:
dbif.close()
grass.fatal(_("You need to set the range to compute the occurrence"
" space time raster dataset"))
if occurrence.find("@") >= 0:
occurrence_id = occurrence
else:
occurrence_id = occurrence + "@" + mapset
occurrence_strds = tgis.SpaceTimeRasterDataset(occurrence_id)
if occurrence_strds.is_in_db(dbif):
if not grass.overwrite():
dbif.close()
grass.fatal(_("Space time raster dataset <%s> is already in the "
"database, use overwrite flag to overwrite") % occurrence_id)
# The indicator space time raster dataset
if indicator:
if not occurrence:
dbif.close()
grass.fatal(_("You need to set the occurrence to compute the indicator"
" space time raster dataset"))
if not staend:
dbif.close()
grass.fatal(_("You need to set the staend options to compute the indicator"
" space time raster dataset"))
if indicator.find("@") >= 0:
indicator = indicator
else:
indicator_id = indicator + "@" + mapset
indicator_strds = tgis.SpaceTimeRasterDataset(indicator_id)
if indicator_strds.is_in_db(dbif):
if not grass.overwrite():
dbif.close()
grass.fatal(_("Space time raster dataset <%s> is already in the "
"database, use overwrite flag to overwrite") % indicator_id)
staend = staend.split(",")
indicator_start = int(staend[0])
indicator_mid = int(staend[1])
indicator_end = int(staend[2])
# The minimum threshold space time raster dataset
minimum_strds = None
if minimum:
if minimum.find("@") >= 0:
minimum_id = minimum
else:
minimum_id = minimum + "@" + mapset
minimum_strds = tgis.SpaceTimeRasterDataset(minimum_id)
if minimum_strds.is_in_db() == False:
dbif.close()
grass.fatal(_("Space time raster dataset <%s> not found") % (minimum_strds.get_id()))
if minimum_strds.get_temporal_type() != input_strds.get_temporal_type():
dbif.close()
grass.fatal(_("Temporal type of input strds and minimum strds must be equal"))
minimum_strds.select(dbif)
# The maximum threshold space time raster dataset
maximum_strds = None
if maximum:
if maximum.find("@") >= 0:
maximum_id = maximum
else:
maximum_id = maximum + "@" + mapset
maximum_strds = tgis.SpaceTimeRasterDataset(maximum_id)
if maximum_strds.is_in_db() == False:
dbif.close()
grass.fatal(_("Space time raster dataset <%s> not found") % (maximum_strds.get_id()))
if maximum_strds.get_temporal_type() != input_strds.get_temporal_type():
dbif.close()
grass.fatal(_("Temporal type of input strds and maximum strds must be equal"))
maximum_strds.select(dbif)
input_strds_start, input_strds_end = input_strds.get_temporal_extent_as_tuple()
if input_strds.is_time_absolute():
start = tgis.string_to_datetime(start)
if stop:
stop = tgis.string_to_datetime(stop)
else:
stop = input_strds_end
else:
start = int(start)
if stop:
stop = int(stop)
else:
stop = input_strds_end
if input_strds.is_time_absolute():
end = tgis.increment_datetime_by_string(start, cycle)
else:
end = start + cycle
count = 1
indi_count = 1
occurrence_maps = {}
indicator_maps = {}
while input_strds_end > start and stop > start:
# Make sure that the cyclic computation will stop at the correct time
if stop and end > stop:
end = stop
where = "start_time >= \'%s\' AND start_time < \'%s\'"%(str(start),
str(end))
input_maps = input_strds.get_registered_maps_as_objects(where=where,
dbif=dbif)
print len(input_maps)
input_topo = tgis.SpatioTemporalTopologyBuilder()
input_topo.build(input_maps, input_maps)
if len(input_maps) == 0:
continue
grass.message(_("Processing cycle %s - %s"%(str(start), str(end))))
count = compute_occurrence(occurrence_maps, input_strds, input_maps,
start, base, count, mapset, where, reverse,
range, minimum_strds, maximum_strds, dbif)
# Indicator computation is based on the occurrence so we need to start it after
# the occurrence cycle
if indicator:
num_maps = len(input_maps)
for i in xrange(num_maps):
if reverse:
map = input_maps[num_maps - i - 1]
else:
map = input_maps[i]
indicator_map_name = "%s_indicator_%i" % (base, indi_count)
indicator_map_id = dummy.build_id(indicator_map_name, mapset)
indicator_map = input_strds.get_new_map_instance(indicator_map_id)
# Check if new map is in the temporal database
if indicator_map.is_in_db(dbif):
if grass.overwrite():
# Remove the existing temporal database entry
indicator_map.delete(dbif)
indicator_map = input_strds.get_new_map_instance(indicator_map_id)
else:
grass.fatal(_("Map <%s> is already registered in the temporal"
" database, use overwrite flag to overwrite.") %
(indicator_map.get_map_id()))
curr_map = occurrence_maps[map.get_id()].get_name()
# Reverse time
if reverse:
if i == 0:
prev_map = curr_map
subexpr1 = "null()"
subexpr3 = "%i"%(indicator_start)
elif i > 0 and i < num_maps - 1:
prev_map = occurrence_maps[map.next().get_id()].get_name()
next_map = occurrence_maps[map.prev().get_id()].get_name()
# In case the previous map is null() set null() or the start indicator
subexpr1 = "if(isnull(%s), null(), %i)"%(curr_map, indicator_start)
# In case the previous map was not null() if the current map is null() set null()
# if the current map is not null() and the next map is not null() set
# intermediate indicator, if the next map is null set the end indicator
subexpr2 = "if(isnull(%s), %i, %i)"%(next_map, indicator_end, indicator_mid)
subexpr3 = "if(isnull(%s), null(), %s)"%(curr_map, subexpr2)
expression = "%s = if(isnull(%s), %s, %s)"%(indicator_map_name,
prev_map, subexpr1,
subexpr3)
else:
prev_map = occurrence_maps[map.next().get_id()].get_name()
subexpr1 = "if(isnull(%s), null(), %i)"%(curr_map, indicator_start)
subexpr3 = "if(isnull(%s), null(), %i)"%(curr_map, indicator_mid)
else:
if i == 0:
prev_map = curr_map
subexpr1 = "null()"
subexpr3 = "%i"%(indicator_start)
elif i > 0 and i < num_maps - 1:
prev_map = occurrence_maps[map.prev().get_id()].get_name()
next_map = occurrence_maps[map.next().get_id()].get_name()
# In case the previous map is null() set null() or the start indicator
subexpr1 = "if(isnull(%s), null(), %i)"%(curr_map, indicator_start)
# In case the previous map was not null() if the current map is null() set null()
# if the current map is not null() and the next map is not null() set
# intermediate indicator, if the next map is null set the end indicator
subexpr2 = "if(isnull(%s), %i, %i)"%(next_map, indicator_end, indicator_mid)
subexpr3 = "if(isnull(%s), null(), %s)"%(curr_map, subexpr2)
expression = "%s = if(isnull(%s), %s, %s)"%(indicator_map_name,
prev_map, subexpr1,
subexpr3)
else:
prev_map = occurrence_maps[map.prev().get_id()].get_name()
subexpr1 = "if(isnull(%s), null(), %i)"%(curr_map, indicator_start)
subexpr3 = "if(isnull(%s), null(), %i)"%(curr_map, indicator_mid)
expression = "%s = if(isnull(%s), %s, %s)"%(indicator_map_name,
prev_map, subexpr1,
subexpr3)
print expression
grass.mapcalc(expression, overwrite=True)
map_start, map_end = map.get_temporal_extent_as_tuple()
if map.is_time_absolute():
indicator_map.set_absolute_time(map_start, map_end)
else:
indicator_map.set_relative_time(map_start, map_end,
map.get_relative_time_unit())
indicator_maps[map.get_id()] = indicator_map
indi_count += 1
# Increment the cycle
start = end
if input_strds.is_time_absolute():
start = end
if offset:
start = tgis.increment_datetime_by_string(end, offset)
end = tgis.increment_datetime_by_string(start, cycle)
else:
if offset:
start = end + offset
end = start + cycle
empty_maps = []
create_strds_register_maps(input_strds, occurrence_strds, occurrence_maps,
register_null, empty_maps, dbif)
if indicator:
create_strds_register_maps(input_strds, indicator_strds, indicator_maps,
register_null, empty_maps, dbif)
dbif.close()
# Remove empty maps
if len(empty_maps) > 0:
for map in empty_maps:
grass.run_command("g.remove", flags='f', type="rast", pattern=map.get_name(), quiet=True)
#%option G_OPT_STDS_INPUTS
#%end
#%option G_OPT_STDS_OUTPUT
#%end
#%option G_OPT_STDS_TYPE
#% guidependency: inputs
#% guisection: Required
#%end
import grass.script as grass
############################################################################
grass.set_raise_on_error(True)
def main():
# lazy imports
import grass.temporal as tgis
# Get the options
inputs = options["inputs"]
output = options["output"]
type = options["type"]
# Make sure the temporal database exists
tgis.init()
#Get the current mapset to create the id of the space time dataset
mapset = grass.gisenv()["MAPSET"]
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
os.environ['GRASS_RENDER_FILE_READ'] = 'TRUE'
os.environ['GRASS_LEGEND_FILE'] = 'legend.txt'
# import GRASS GIS
import grass.script as gs
import grass.script.setup as gsetup
from grass.script import core as grass
# for pygrass
from grass.pygrass.modules.shortcuts import raster as r, vector as v, general as g, display as d
from subprocess import PIPE
# further setup for GRASS GIS
gs.set_raise_on_error(True)
#gs.set_capture_stderr(True) #might be Python 2 vs 3 issue
## set default encoding
#import sys
#reload(sys)
#sys.setdefaultencoding('utf-8')
class Basemap():
"""prepares a set of basemaps for project layout"""
def __init__(self, project):
self.project = project
#define project dir
project_dir = project_basedir + project + '/'
def import_stds(input,
output,
directory,
title=None,
descr=None,
location=None,
link=False,
exp=False,
overr=False,
create=False,
stds_type="strds",
base=None,
set_current_region=False,
memory=300):
"""Import space time datasets of type raster and vector
:param input: Name of the input archive file
:param output: The name of the output space time dataset
:param directory: The extraction directory
:param title: The title of the new created space time dataset
:param descr: The description of the new created
space time dataset
:param location: The name of the location that should be created,
maps are imported into this location
:param link: Switch to link raster maps instead importing them
:param exp: Extend location extents based on new dataset
:param overr: Override projection (use location's projection)
:param create: Create the location specified by the "location"
parameter and exit.
Do not import the space time datasets.
:param stds_type: The type of the space time dataset that
should be imported
:param base: The base name of the new imported maps, it will be
extended using a numerical index.
:param memory: Cache size for raster rows, used in r.in.gdal
"""
global raise_on_error
old_state = gscript.raise_on_error
gscript.set_raise_on_error(True)
# Check if input file and extraction directory exits
if not os.path.exists(input):
gscript.fatal(
_("Space time raster dataset archive <%s> not found") % input)
if not create and not os.path.exists(directory):
gscript.fatal(_("Extraction directory <%s> not found") % directory)
tar = tarfile.open(name=input, mode='r')
# Check for important files
msgr = get_tgis_message_interface()
msgr.message(
_("Checking validity of input file (size: %0.1f MB). Make take a while..."
% (os.path.getsize(input) / (1024 * 1024.0))))
members = tar.getnames()
# Make sure that the basenames of the files are used for comparison
member_basenames = [os.path.basename(name) for name in members]
if init_file_name not in member_basenames:
gscript.fatal(_("Unable to find init file <%s>") % init_file_name)
if list_file_name not in member_basenames:
gscript.fatal(_("Unable to find list file <%s>") % list_file_name)
if proj_file_name not in member_basenames:
gscript.fatal(
_("Unable to find projection file <%s>") % proj_file_name)
msgr.message(_("Extracting data..."))
tar.extractall(path=directory)
tar.close()
# We use a new list file name for map registration
new_list_file_name = list_file_name + "_new"
# Save current working directory path
old_cwd = os.getcwd()
# Switch into the data directory
os.chdir(directory)
# Check projection information
if not location:
temp_name = gscript.tempfile()
temp_file = open(temp_name, "w")
proj_name = os.path.abspath(proj_file_name)
# We need to convert projection strings generated
# from other programs than g.proj into
# new line format so that the grass file comparison function
# can be used to compare the projections
proj_name_tmp = temp_name + "_in_projection"
proj_file = open(proj_name, "r")
proj_content = proj_file.read()
proj_content = proj_content.replace(" +", "\n+")
proj_content = proj_content.replace("\t+", "\n+")
proj_file.close()
proj_file = open(proj_name_tmp, "w")
proj_file.write(proj_content)
proj_file.close()
p = gscript.start_command("g.proj", flags="j", stdout=temp_file)
p.communicate()
temp_file.close()
if not gscript.compare_key_value_text_files(
temp_name, proj_name_tmp, sep="="):
if overr:
gscript.warning(
_("Projection information does not match. "
"Proceeding..."))
else:
diff = ''.join(gscript.diff_files(temp_name, proj_name))
gscript.warning(
_("Difference between PROJ_INFO file of "
"imported map and of current location:"
"\n{diff}").format(diff=diff))
gscript.fatal(
_("Projection information does not match. "
"Aborting."))
# Create a new location based on the projection information and switch
# into it
old_env = gscript.gisenv()
if location:
try:
proj4_string = open(proj_file_name, 'r').read()
gscript.create_location(dbase=old_env["GISDBASE"],
location=location,
proj4=proj4_string)
# Just create a new location and return
if create:
os.chdir(old_cwd)
return
except Exception as e:
gscript.fatal(
_("Unable to create location %(l)s. Reason: %(e)s") % {
'l': location,
'e': str(e)
})
# Switch to the new created location
try:
gscript.run_command("g.mapset",
mapset="PERMANENT",
location=location,
dbase=old_env["GISDBASE"])
except CalledModuleError:
gscript.fatal(_("Unable to switch to location %s") % location)
# create default database connection
try:
gscript.run_command("t.connect", flags="d")
except CalledModuleError:
gscript.fatal(
_("Unable to create default temporal database "
"in new location %s") % location)
try:
# Make sure the temporal database exists
factory.init()
fs = "|"
maplist = []
mapset = get_current_mapset()
list_file = open(list_file_name, "r")
new_list_file = open(new_list_file_name, "w")
# get number of lines to correctly form the suffix
max_count = -1
for max_count, l in enumerate(list_file):
pass
max_count += 1
list_file.seek(0)
# Read the map list from file
line_count = 0
while True:
line = list_file.readline()
if not line:
break
line_list = line.split(fs)
# The filename is actually the base name of the map
# that must be extended by the file suffix
filename = line_list[0].strip().split(":")[0]
if base:
mapname = "%s_%s" % (
base, gscript.get_num_suffix(line_count + 1, max_count))
mapid = "%s@%s" % (mapname, mapset)
else:
mapname = filename
mapid = mapname + "@" + mapset
row = {}
row["filename"] = filename
row["name"] = mapname
row["id"] = mapid
row["start"] = line_list[1].strip()
row["end"] = line_list[2].strip()
new_list_file.write("%s%s%s%s%s\n" %
(mapname, fs, row["start"], fs, row["end"]))
maplist.append(row)
line_count += 1
list_file.close()
new_list_file.close()
# Read the init file
fs = "="
init = {}
init_file = open(init_file_name, "r")
while True:
line = init_file.readline()
if not line:
break
kv = line.split(fs)
init[kv[0]] = kv[1].strip()
init_file.close()
if "temporal_type" not in init or \
"semantic_type" not in init or \
"number_of_maps" not in init:
gscript.fatal(
_("Key words %(t)s, %(s)s or %(n)s not found in init"
" file.") % {
't': "temporal_type",
's': "semantic_type",
'n': "number_of_maps"
})
if line_count != int(init["number_of_maps"]):
gscript.fatal(_("Number of maps mismatch in init and list file."))
format_ = "GTiff"
type_ = "strds"
if "stds_type" in init:
type_ = init["stds_type"]
if "format" in init:
format_ = init["format"]
if stds_type != type_:
gscript.fatal(
_("The archive file is of wrong space time dataset"
" type"))
# Check the existence of the files
if format_ == "GTiff":
for row in maplist:
filename = row["filename"] + ".tif"
if not os.path.exists(filename):
gscript.fatal(
_("Unable to find GeoTIFF raster file "
"<%s> in archive.") % filename)
elif format_ == "AAIGrid":
for row in maplist:
filename = row["filename"] + ".asc"
if not os.path.exists(filename):
gscript.fatal(
_("Unable to find AAIGrid raster file "
"<%s> in archive.") % filename)
elif format_ == "GML":
for row in maplist:
filename = row["filename"] + ".xml"
if not os.path.exists(filename):
gscript.fatal(
_("Unable to find GML vector file "
"<%s> in archive.") % filename)
elif format_ == "pack":
for row in maplist:
if type_ == "stvds":
filename = str(row["filename"].split(":")[0]) + ".pack"
else:
filename = row["filename"] + ".pack"
if not os.path.exists(filename):
gscript.fatal(
_("Unable to find GRASS package file "
"<%s> in archive.") % filename)
else:
gscript.fatal(_("Unsupported input format"))
# Check the space time dataset
id = output + "@" + mapset
sp = dataset_factory(type_, id)
if sp.is_in_db() and gscript.overwrite() is False:
gscript.fatal(
_("Space time %(t)s dataset <%(sp)s> is already in"
" the database. Use the overwrite flag.") % {
't': type_,
'sp': sp.get_id()
})
# Import the maps
if type_ == "strds":
if format_ == "GTiff" or format_ == "AAIGrid":
_import_raster_maps_from_gdal(maplist, overr, exp, location,
link, format_,
set_current_region, memory)
if format_ == "pack":
_import_raster_maps(maplist, set_current_region)
elif type_ == "stvds":
if format_ == "GML":
_import_vector_maps_from_gml(maplist, overr, exp, location,
link)
if format_ == "pack":
_import_vector_maps(maplist)
# Create the space time dataset
if sp.is_in_db() and gscript.overwrite() is True:
gscript.info(
_("Overwrite space time %(sp)s dataset "
"<%(id)s> and unregister all maps.") % {
'sp': sp.get_new_map_instance(None).get_type(),
'id': sp.get_id()
})
sp.delete()
sp = sp.get_new_instance(id)
temporal_type = init["temporal_type"]
semantic_type = init["semantic_type"]
relative_time_unit = None
if temporal_type == "relative":
if "relative_time_unit" not in init:
gscript.fatal(
_("Key word %s not found in init file.") %
("relative_time_unit"))
relative_time_unit = init["relative_time_unit"]
sp.set_relative_time_unit(relative_time_unit)
gscript.verbose(
_("Create space time %s dataset.") %
sp.get_new_map_instance(None).get_type())
sp.set_initial_values(temporal_type=temporal_type,
semantic_type=semantic_type,
title=title,
description=descr)
sp.insert()
# register the maps
fs = "|"
register_maps_in_space_time_dataset(
type=sp.get_new_map_instance(None).get_type(),
name=output,
file=new_list_file_name,
start="file",
end="file",
unit=relative_time_unit,
dbif=None,
fs=fs,
update_cmd_list=False)
os.chdir(old_cwd)
except:
raise
# Make sure the location is switched back correctly
finally:
if location:
# Switch to the old location
try:
gscript.run_command("g.mapset",
mapset=old_env["MAPSET"],
location=old_env["LOCATION_NAME"],
gisdbase=old_env["GISDBASE"])
except CalledModuleError:
grass.warning(_("Switching to original location failed"))
gscript.set_raise_on_error(old_state)
def main():
grass.set_raise_on_error(False)
options, flags = grass.parser()
# import wx only after running parser
# to avoid issues with complex imports when only interface is needed
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.globalvar import CheckWxVersion
from core.utils import _
from core.render import Map
from mapdisp.frame import MapFrame
from mapdisp.main import DMonGrassInterface
from core.settings import UserSettings
from vdigit.main import haveVDigit, errorMsg
from grass.exceptions import CalledModuleError
# define classes which needs imports as local
# for longer definitions, a separate file would be a better option
class VDigitMapFrame(MapFrame):
def __init__(self, vectorMap):
MapFrame.__init__(
self, parent=None, Map=Map(), giface=DMonGrassInterface(None),
title=_("GRASS GIS Vector Digitizer"), size=(850, 600))
# this giface issue not solved yet, we must set mapframe aferwards
self._giface._mapframe = self
# load vector map
mapLayer = self.GetMap().AddLayer(
ltype='vector', name=vectorMap,
command=['d.vect', 'map=%s' % vectorMap],
active=True, hidden=False, opacity=1.0, render=True)
# switch toolbar
self.AddToolbar('vdigit', fixed=True)
# start editing
self.toolbars['vdigit'].StartEditing(mapLayer)
if not haveVDigit:
grass.fatal(_("Vector digitizer not available. %s") % errorMsg)
if not grass.find_file(name=options['map'], element='vector',
mapset=grass.gisenv()['MAPSET'])['fullname']:
if not flags['c']:
grass.fatal(_("Vector map <%s> not found in current mapset. "
"New vector map can be created by providing '-c' flag.") % options['map'])
else:
grass.verbose(_("New vector map <%s> created") % options['map'])
try:
grass.run_command('v.edit', map=options['map'], tool='create', quiet=True)
except CalledModuleError:
grass.fatal(_("Unable to create new vector map <%s>") % options['map'])
# allow immediate rendering
driver = UserSettings.Get(group='display', key='driver', subkey='type')
if driver == 'png':
os.environ['GRASS_RENDER_IMMEDIATE'] = 'png'
else:
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
app = wx.App()
if not CheckWxVersion([2, 9]):
wx.InitAllImageHandlers()
frame = VDigitMapFrame(options['map'])
frame.Show()
app.MainLoop()
from core.utils import _
from animation.mapwindow import AnimationWindow
from animation.provider import BitmapProvider, BitmapPool, \
MapFilesPool, CleanUp
from animation.controller import AnimationController
from animation.anim import Animation
from animation.toolbars import MainToolbar, AnimationToolbar, MiscToolbar
from animation.dialogs import SpeedDialog, PreferencesDialog
from animation.utils import Orientation, ReplayMode, TemporalType
MAX_COUNT = 4
TMP_DIR = None
gcore.set_raise_on_error(True)
class AnimationFrame(wx.Frame):
def __init__(self, parent, giface, title=_("GRASS GIS Animation tool"),
rasters=None, timeseries=None):
wx.Frame.__init__(self, parent, title=title,
style=wx.DEFAULT_FRAME_STYLE, size=(800, 600))
self._giface = giface
self.SetClientSize(self.GetSize())
self.iconsize = (16, 16)
self.SetIcon(wx.Icon(os.path.join(globalvar.ICONDIR, 'grass_map.ico'), wx.BITMAP_TYPE_ICO))
# Make sure the temporal database exists
tgis.init()
def main():
grass.set_raise_on_error(False)
options, flags = grass.parser()
# import wx only after running parser
# to avoid issues with complex imports when only interface is needed
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.render import Map
from mapdisp.frame import MapFrame
from mapdisp.main import DMonGrassInterface
from core.settings import UserSettings
from vdigit.main import haveVDigit, errorMsg
from grass.exceptions import CalledModuleError
# define classes which needs imports as local
# for longer definitions, a separate file would be a better option
class VDigitMapFrame(MapFrame):
def __init__(self, vectorMap):
MapFrame.__init__(
self,
parent=None,
Map=Map(),
giface=DMonGrassInterface(None),
title=_("Vector Digitizer - GRASS GIS"),
size=(850, 600),
)
# this giface issue not solved yet, we must set mapframe aferwards
self._giface._mapframe = self
# load vector map
mapLayer = self.GetMap().AddLayer(
ltype="vector",
name=vectorMap,
command=["d.vect", "map=%s" % vectorMap],
active=True,
hidden=False,
opacity=1.0,
render=True,
)
# switch toolbar
self.AddToolbar("vdigit", fixed=True)
# start editing
self.toolbars["vdigit"].StartEditing(mapLayer)
# use Close instead of QuitVDigit for standalone tool
self.toolbars["vdigit"].quitDigitizer.disconnect(self.QuitVDigit)
self.toolbars["vdigit"].quitDigitizer.connect(lambda: self.Close())
if not haveVDigit:
grass.fatal(_("Vector digitizer not available. %s") % errorMsg)
if not grass.find_file(name=options["map"],
element="vector",
mapset=grass.gisenv()["MAPSET"])["fullname"]:
if not flags["c"]:
grass.fatal(
_("Vector map <%s> not found in current mapset. "
"New vector map can be created by providing '-c' flag.") %
options["map"])
else:
grass.verbose(_("New vector map <%s> created") % options["map"])
try:
grass.run_command("v.edit",
map=options["map"],
tool="create",
quiet=True)
except CalledModuleError:
grass.fatal(
_("Unable to create new vector map <%s>") % options["map"])
# allow immediate rendering
driver = UserSettings.Get(group="display", key="driver", subkey="type")
if driver == "png":
os.environ["GRASS_RENDER_IMMEDIATE"] = "png"
else:
os.environ["GRASS_RENDER_IMMEDIATE"] = "cairo"
app = wx.App()
frame = VDigitMapFrame(options["map"])
frame.Show()
app.MainLoop()
def main():
gscript.set_raise_on_error(False)
options, flags = gscript.parser()
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.settings import UserSettings
from iclass.frame import IClassMapFrame
group_name = subgroup_name = map_name = trainingmap_name = None
if options["group"]:
if not options["subgroup"]:
gscript.fatal(_("Name of subgroup required"))
group_name = gscript.find_file(name=options["group"],
element="group")["name"]
if not group_name:
gscript.fatal(_("Group <%s> not found") % options["group"])
subgroups = gscript.read_command("i.group",
group=group_name,
flags="sg").splitlines()
if options["subgroup"] not in subgroups:
gscript.fatal(_("Subgroup <%s> not found") % options["subgroup"])
subgroup_name = options["subgroup"]
if options["map"]:
map_name = gscript.find_file(name=options["map"],
element="cell")["fullname"]
if not map_name:
gscript.fatal(_("Raster map <%s> not found") % options["map"])
if options["trainingmap"]:
trainingmap_name = gscript.find_file(name=options["trainingmap"],
element="vector")["fullname"]
if not trainingmap_name:
gscript.fatal(
_("Vector map <%s> not found") % options["trainingmap"])
# define display driver
driver = UserSettings.Get(group="display", key="driver", subkey="type")
if driver == "png":
os.environ["GRASS_RENDER_IMMEDIATE"] = "png"
else:
os.environ["GRASS_RENDER_IMMEDIATE"] = "cairo"
# launch application
app = wx.App()
# show main frame
frame = IClassMapFrame(
parent=None,
giface=None,
title=_("Supervised Classification Tool - GRASS GIS"),
)
if not flags["m"]:
frame.CenterOnScreen()
if group_name:
frame.SetGroup(group_name, subgroup_name)
if map_name:
frame.giface.WriteLog(_("Loading raster map <%s>...") % map_name)
frame.trainingMapManager.AddLayer(map_name)
if trainingmap_name:
frame.giface.WriteLog(
_("Loading training map <%s>...") % trainingmap_name)
frame.ImportAreas(trainingmap_name)
frame.Show()
if flags["m"]:
frame.Maximize()
app.MainLoop()
def main():
gscript.set_raise_on_error(False)
options, flags = gscript.parser()
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.settings import UserSettings
from core.globalvar import CheckWxVersion
from core.giface import StandaloneGrassInterface
from core.utils import _
from iclass.frame import IClassMapFrame
group_name = subgroup_name = map_name = trainingmap_name = None
if options['group']:
if not options['subgroup']:
gscript.fatal(_("Name of subgroup required"))
group_name = gscript.find_file(name=options['group'],
element='group')['name']
if not group_name:
gscript.fatal(_("Group <%s> not found") % options['group'])
subgroups = gscript.read_command('i.group',
group=group_name,
flags='sg').splitlines()
if options['subgroup'] not in subgroups:
gscript.fatal(_("Subgroup <%s> not found") % options['subgroup'])
subgroup_name = options['subgroup']
if options['map']:
map_name = gscript.find_file(name=options['map'],
element='cell')['fullname']
if not map_name:
gscript.fatal(_("Raster map <%s> not found") % options['map'])
if options['trainingmap']:
trainingmap_name = gscript.find_file(name=options['trainingmap'],
element='vector')['fullname']
if not trainingmap_name:
gscript.fatal(
_("Vector map <%s> not found") %
options['trainingmap'])
# define display driver
driver = UserSettings.Get(group='display', key='driver', subkey='type')
if driver == 'png':
os.environ['GRASS_RENDER_IMMEDIATE'] = 'png'
else:
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
# launch application
app = wx.App()
if not CheckWxVersion([2, 9]):
wx.InitAllImageHandlers()
# show main frame
giface = StandaloneGrassInterface()
frame = IClassMapFrame(parent=None, giface=giface)
if not flags['m']:
frame.CenterOnScreen()
if group_name:
frame.SetGroup(group_name, subgroup_name)
if map_name:
giface.WriteLog(_("Loading raster map <%s>...") % map_name)
frame.trainingMapManager.AddLayer(map_name)
if trainingmap_name:
giface.WriteLog(_("Loading training map <%s>...") % trainingmap_name)
frame.ImportAreas(trainingmap_name)
frame.Show()
if flags['m']:
frame.Maximize()
app.MainLoop()
def main():
# Get the options
input = options["input"]
start = options["start"]
stop = options["stop"]
base = options["basename"]
cycle = options["cycle"]
offset = options["offset"]
minimum = options["minimum"]
maximum = options["maximum"]
occurrence = options["occurrence"]
range = options["range"]
indicator = options["indicator"]
staend = options["staend"]
register_null = flags["n"]
reverse = flags["r"]
time_suffix = options["suffix"]
grass.set_raise_on_error(True)
# Make sure the temporal database exists
tgis.init()
# We need a database interface
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
mapset = tgis.get_current_mapset()
if input.find("@") >= 0:
id = input
else:
id = input + "@" + mapset
input_strds = tgis.SpaceTimeRasterDataset(id)
if input_strds.is_in_db() == False:
dbif.close()
grass.fatal(
_("Space time %s dataset <%s> not found") %
(input_strds.get_output_map_instance(None).get_type(), id))
input_strds.select(dbif)
dummy = input_strds.get_new_map_instance(None)
# The occurrence space time raster dataset
if occurrence:
if not minimum or not maximum:
if not range:
dbif.close()
grass.fatal(
_("You need to set the range to compute the occurrence"
" space time raster dataset"))
if occurrence.find("@") >= 0:
occurrence_id = occurrence
else:
occurrence_id = occurrence + "@" + mapset
occurrence_strds = tgis.SpaceTimeRasterDataset(occurrence_id)
if occurrence_strds.is_in_db(dbif):
if not grass.overwrite():
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> is already in the "
"database, use overwrite flag to overwrite") %
occurrence_id)
# The indicator space time raster dataset
if indicator:
if not occurrence:
dbif.close()
grass.fatal(
_("You need to set the occurrence to compute the indicator"
" space time raster dataset"))
if not staend:
dbif.close()
grass.fatal(
_("You need to set the staend options to compute the indicator"
" space time raster dataset"))
if indicator.find("@") >= 0:
indicator = indicator
else:
indicator_id = indicator + "@" + mapset
indicator_strds = tgis.SpaceTimeRasterDataset(indicator_id)
if indicator_strds.is_in_db(dbif):
if not grass.overwrite():
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> is already in the "
"database, use overwrite flag to overwrite") %
indicator_id)
staend = staend.split(",")
indicator_start = int(staend[0])
indicator_mid = int(staend[1])
indicator_end = int(staend[2])
# The minimum threshold space time raster dataset
minimum_strds = None
if minimum:
if minimum.find("@") >= 0:
minimum_id = minimum
else:
minimum_id = minimum + "@" + mapset
minimum_strds = tgis.SpaceTimeRasterDataset(minimum_id)
if minimum_strds.is_in_db() == False:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> not found") %
(minimum_strds.get_id()))
if minimum_strds.get_temporal_type() != input_strds.get_temporal_type(
):
dbif.close()
grass.fatal(
_("Temporal type of input strds and minimum strds must be equal"
))
minimum_strds.select(dbif)
# The maximum threshold space time raster dataset
maximum_strds = None
if maximum:
if maximum.find("@") >= 0:
maximum_id = maximum
else:
maximum_id = maximum + "@" + mapset
maximum_strds = tgis.SpaceTimeRasterDataset(maximum_id)
if maximum_strds.is_in_db() == False:
dbif.close()
grass.fatal(
_("Space time raster dataset <%s> not found") %
(maximum_strds.get_id()))
if maximum_strds.get_temporal_type() != input_strds.get_temporal_type(
):
dbif.close()
grass.fatal(
_("Temporal type of input strds and maximum strds must be equal"
))
maximum_strds.select(dbif)
input_strds_start, input_strds_end = input_strds.get_temporal_extent_as_tuple(
)
if input_strds.is_time_absolute():
start = tgis.string_to_datetime(start)
if stop:
stop = tgis.string_to_datetime(stop)
else:
stop = input_strds_end
else:
start = int(start)
if stop:
stop = int(stop)
else:
stop = input_strds_end
if input_strds.is_time_absolute():
end = tgis.increment_datetime_by_string(start, cycle)
else:
end = start + cycle
count = 1
indi_count = 1
occurrence_maps = {}
indicator_maps = {}
while input_strds_end > start and stop > start:
# Make sure that the cyclic computation will stop at the correct time
if stop and end > stop:
end = stop
where = "start_time >= \'%s\' AND start_time < \'%s\'" % (str(start),
str(end))
input_maps = input_strds.get_registered_maps_as_objects(where=where,
dbif=dbif)
print len(input_maps)
input_topo = tgis.SpatioTemporalTopologyBuilder()
input_topo.build(input_maps, input_maps)
if len(input_maps) == 0:
continue
grass.message(_("Processing cycle %s - %s" % (str(start), str(end))))
count = compute_occurrence(occurrence_maps, input_strds, input_maps,
start, base, count, time_suffix, mapset,
where, reverse, range, minimum_strds,
maximum_strds, dbif)
# Indicator computation is based on the occurrence so we need to start it after
# the occurrence cycle
if indicator:
num_maps = len(input_maps)
for i in xrange(num_maps):
if reverse:
map = input_maps[num_maps - i - 1]
else:
map = input_maps[i]
if input_strds.get_temporal_type(
) == 'absolute' and time_suffix == 'gran':
suffix = tgis.create_suffix_from_datetime(
map.temporal_extent.get_start_time(),
input_strds.get_granularity())
indicator_map_name = "{ba}_indicator_{su}".format(
ba=base, su=suffix)
elif input_strds.get_temporal_type(
) == 'absolute' and time_suffix == 'time':
suffix = tgis.create_time_suffix(map)
indicator_map_name = "{ba}_indicator_{su}".format(
ba=base, su=suffix)
else:
indicator_map_name = tgis.create_numeric_suffic(
base + "_indicator", indi_count, time_suffix)
indicator_map_id = dummy.build_id(indicator_map_name, mapset)
indicator_map = input_strds.get_new_map_instance(
indicator_map_id)
# Check if new map is in the temporal database
if indicator_map.is_in_db(dbif):
if grass.overwrite():
# Remove the existing temporal database entry
indicator_map.delete(dbif)
indicator_map = input_strds.get_new_map_instance(
indicator_map_id)
else:
grass.fatal(
_("Map <%s> is already registered in the temporal"
" database, use overwrite flag to overwrite.") %
(indicator_map.get_map_id()))
curr_map = occurrence_maps[map.get_id()].get_name()
# Reverse time
if reverse:
if i == 0:
prev_map = curr_map
subexpr1 = "null()"
subexpr3 = "%i" % (indicator_start)
elif i > 0 and i < num_maps - 1:
prev_map = occurrence_maps[
map.next().get_id()].get_name()
next_map = occurrence_maps[
map.prev().get_id()].get_name()
# In case the previous map is null() set null() or the start indicator
subexpr1 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_start)
# In case the previous map was not null() if the current map is null() set null()
# if the current map is not null() and the next map is not null() set
# intermediate indicator, if the next map is null set the end indicator
subexpr2 = "if(isnull(%s), %i, %i)" % (
next_map, indicator_end, indicator_mid)
subexpr3 = "if(isnull(%s), null(), %s)" % (curr_map,
subexpr2)
expression = "%s = if(isnull(%s), %s, %s)" % (
indicator_map_name, prev_map, subexpr1, subexpr3)
else:
prev_map = occurrence_maps[
map.next().get_id()].get_name()
subexpr1 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_start)
subexpr3 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_mid)
else:
if i == 0:
prev_map = curr_map
subexpr1 = "null()"
subexpr3 = "%i" % (indicator_start)
elif i > 0 and i < num_maps - 1:
prev_map = occurrence_maps[
map.prev().get_id()].get_name()
next_map = occurrence_maps[
map.next().get_id()].get_name()
# In case the previous map is null() set null() or the start indicator
subexpr1 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_start)
# In case the previous map was not null() if the current map is null() set null()
# if the current map is not null() and the next map is not null() set
# intermediate indicator, if the next map is null set the end indicator
subexpr2 = "if(isnull(%s), %i, %i)" % (
next_map, indicator_end, indicator_mid)
subexpr3 = "if(isnull(%s), null(), %s)" % (curr_map,
subexpr2)
expression = "%s = if(isnull(%s), %s, %s)" % (
indicator_map_name, prev_map, subexpr1, subexpr3)
else:
prev_map = occurrence_maps[
map.prev().get_id()].get_name()
subexpr1 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_start)
subexpr3 = "if(isnull(%s), null(), %i)" % (
curr_map, indicator_mid)
expression = "%s = if(isnull(%s), %s, %s)" % (
indicator_map_name, prev_map, subexpr1, subexpr3)
print expression
grass.mapcalc(expression, overwrite=True)
map_start, map_end = map.get_temporal_extent_as_tuple()
if map.is_time_absolute():
indicator_map.set_absolute_time(map_start, map_end)
else:
indicator_map.set_relative_time(
map_start, map_end, map.get_relative_time_unit())
indicator_maps[map.get_id()] = indicator_map
indi_count += 1
# Increment the cycle
start = end
if input_strds.is_time_absolute():
start = end
if offset:
start = tgis.increment_datetime_by_string(end, offset)
end = tgis.increment_datetime_by_string(start, cycle)
else:
if offset:
start = end + offset
end = start + cycle
empty_maps = []
create_strds_register_maps(input_strds, occurrence_strds, occurrence_maps,
register_null, empty_maps, dbif)
if indicator:
create_strds_register_maps(input_strds, indicator_strds,
indicator_maps, register_null, empty_maps,
dbif)
dbif.close()
# Remove empty maps
if len(empty_maps) > 0:
for map in empty_maps:
grass.run_command("g.remove",
flags='f',
type="raster",
name=map.get_name(),
quiet=True)
def main():
gs.set_raise_on_error(False)
options, flags = gs.parser()
# import wx only after running parser
# to avoid issues with complex imports when only interface is needed
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.render import Map
from mapdisp.frame import MapFrame
from mapdisp.main import DMonGrassInterface
from core.settings import UserSettings
# define classes which needs imports as local
# for longer definitions, a separate file would be a better option
class RDigitMapFrame(MapFrame):
def __init__(
self,
new_map=None,
base_map=None,
edit_map=None,
map_type=None,
):
MapFrame.__init__(
self,
parent=None,
Map=Map(),
giface=DMonGrassInterface(None),
title=_("Raster Digitizer - GRASS GIS"),
size=(850, 600),
)
# this giface issue not solved yet, we must set mapframe afterwards
self._giface._mapframe = self
self._giface.mapCreated.connect(self.OnMapCreated)
self._mapObj = self.GetMap()
# load raster map
self._addLayer(name=new_map if new_map else edit_map)
# switch toolbar
self.AddToolbar("rdigit", fixed=True)
rdigit = self.toolbars["rdigit"]
if new_map:
rdigit._mapSelectionCombo.Unbind(wx.EVT_COMBOBOX)
self.rdigit.SelectNewMap(
standalone=True,
mapName=new_map,
bgMap=base_map,
mapType=map_type,
)
rdigit._mapSelectionCombo.Bind(
wx.EVT_COMBOBOX,
rdigit.OnMapSelection,
)
else:
rdigit._mapSelectionCombo.SetSelection(n=1)
rdigit.OnMapSelection()
# use Close instead of QuitRDigit for standalone tool
self.rdigit.quitDigitizer.disconnect(self.QuitRDigit)
self.rdigit.quitDigitizer.connect(lambda: self.Close())
def _addLayer(self, name, ltype="raster"):
"""Add layer into map
:param str name: map name
:param str ltype: layer type
"""
mapLayer = self._mapObj.AddLayer(
ltype=ltype,
name=name,
command=["d.rast", "map={}".format(name)],
active=True,
hidden=False,
opacity=1.0,
render=True,
)
def OnMapCreated(self, name, ltype):
"""Add new created raster layer into map
:param str name: map name
:param str ltype: layer type
"""
self._mapObj.Clean()
self._addLayer(name=name, ltype=ltype)
self.GetMapWindow().UpdateMap()
kwargs = {
"new_map": options["create"],
"base_map": options["base"],
"edit_map": options["edit"],
"map_type": options["type"],
}
mapset = gs.gisenv()["MAPSET"]
if kwargs["edit_map"]:
edit_map = gs.find_file(
name=kwargs["edit_map"],
element="raster",
mapset=mapset,
)["fullname"]
if not edit_map:
gs.fatal(
_(
"Raster map <{}> not found in current mapset.".format(
options["edit"], ), ), )
else:
kwargs["edit_map"] = edit_map
else:
if kwargs["base_map"]:
base_map = gs.find_file(
name=kwargs["base_map"],
element="raster",
mapset=mapset,
)["fullname"]
if not base_map:
gs.fatal(
_(
"Base raster map <{}> not found in "
"current mapset.".format(options["base"], ), ), )
kwargs["base_map"] = base_map
# allow immediate rendering
driver = UserSettings.Get(
group="display",
key="driver",
subkey="type",
)
if driver == "png":
os.environ["GRASS_RENDER_IMMEDIATE"] = "png"
else:
os.environ["GRASS_RENDER_IMMEDIATE"] = "cairo"
app = wx.App()
frame = RDigitMapFrame(**kwargs)
frame.Show()
app.MainLoop()
def main():
gscript.set_raise_on_error(False)
options, flags = gscript.parser()
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.settings import UserSettings
from core.giface import StandaloneGrassInterface
from iclass.frame import IClassMapFrame
group_name = subgroup_name = map_name = trainingmap_name = None
if options['group']:
if not options['subgroup']:
gscript.fatal(_("Name of subgroup required"))
group_name = gscript.find_file(name=options['group'],
element='group')['name']
if not group_name:
gscript.fatal(_("Group <%s> not found") % options['group'])
subgroups = gscript.read_command('i.group',
group=group_name,
flags='sg').splitlines()
if options['subgroup'] not in subgroups:
gscript.fatal(_("Subgroup <%s> not found") % options['subgroup'])
subgroup_name = options['subgroup']
if options['map']:
map_name = gscript.find_file(name=options['map'],
element='cell')['fullname']
if not map_name:
gscript.fatal(_("Raster map <%s> not found") % options['map'])
if options['trainingmap']:
trainingmap_name = gscript.find_file(name=options['trainingmap'],
element='vector')['fullname']
if not trainingmap_name:
gscript.fatal(
_("Vector map <%s> not found") % options['trainingmap'])
# define display driver
driver = UserSettings.Get(group='display', key='driver', subkey='type')
if driver == 'png':
os.environ['GRASS_RENDER_IMMEDIATE'] = 'png'
else:
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
# launch application
app = wx.App()
# show main frame
giface = StandaloneGrassInterface()
frame = IClassMapFrame(parent=None, giface=giface)
if not flags['m']:
frame.CenterOnScreen()
if group_name:
frame.SetGroup(group_name, subgroup_name)
if map_name:
giface.WriteLog(_("Loading raster map <%s>...") % map_name)
frame.trainingMapManager.AddLayer(map_name)
if trainingmap_name:
giface.WriteLog(_("Loading training map <%s>...") % trainingmap_name)
frame.ImportAreas(trainingmap_name)
frame.Show()
if flags['m']:
frame.Maximize()
app.MainLoop()
def import_stds(input, output, directory, title=None, descr=None, location=None,
link=False, exp=False, overr=False, create=False,
stds_type="strds", base=None, set_current_region=False):
"""Import space time datasets of type raster and vector
:param input: Name of the input archive file
:param output: The name of the output space time dataset
:param directory: The extraction directory
:param title: The title of the new created space time dataset
:param descr: The description of the new created
space time dataset
:param location: The name of the location that should be created,
maps are imported into this location
:param link: Switch to link raster maps instead importing them
:param exp: Extend location extents based on new dataset
:param overr: Override projection (use location's projection)
:param create: Create the location specified by the "location"
parameter and exit.
Do not import the space time datasets.
:param stds_type: The type of the space time dataset that
should be imported
:param base: The base name of the new imported maps, it will be
extended using a numerical index.
"""
global raise_on_error
old_state = gscript.raise_on_error
gscript.set_raise_on_error(True)
# Check if input file and extraction directory exits
if not os.path.exists(input):
gscript.fatal(_("Space time raster dataset archive <%s> not found")
% input)
if not create and not os.path.exists(directory):
gscript.fatal(_("Extraction directory <%s> not found") % directory)
tar = tarfile.open(name=input, mode='r')
# Check for important files
msgr = get_tgis_message_interface()
msgr.message(_("Checking validity of input file (size: %0.1f MB). Make take a while..."
% (os.path.getsize(input)/(1024*1024.0))))
members = tar.getnames()
# Make sure that the basenames of the files are used for comparison
member_basenames = [os.path.basename(name) for name in members]
if init_file_name not in member_basenames:
gscript.fatal(_("Unable to find init file <%s>") % init_file_name)
if list_file_name not in member_basenames:
gscript.fatal(_("Unable to find list file <%s>") % list_file_name)
if proj_file_name not in member_basenames:
gscript.fatal(_("Unable to find projection file <%s>") % proj_file_name)
msgr.message(_("Extracting data..."))
tar.extractall(path=directory)
tar.close()
# We use a new list file name for map registration
new_list_file_name = list_file_name + "_new"
# Save current working directory path
old_cwd = os.getcwd()
# Switch into the data directory
os.chdir(directory)
# Check projection information
if not location:
temp_name = gscript.tempfile()
temp_file = open(temp_name, "w")
proj_name = os.path.abspath(proj_file_name)
# We need to convert projection strings generated
# from other programms than g.proj into
# new line format so that the grass file comparison function
# can be used to compare the projections
proj_name_tmp = temp_name + "_in_projection"
proj_file = open(proj_name, "r")
proj_content = proj_file.read()
proj_content = proj_content.replace(" +", "\n+")
proj_content = proj_content.replace("\t+", "\n+")
proj_file.close()
proj_file = open(proj_name_tmp, "w")
proj_file.write(proj_content)
proj_file.close()
p = gscript.start_command("g.proj", flags="j", stdout=temp_file)
p.communicate()
temp_file.close()
if not gscript.compare_key_value_text_files(temp_name, proj_name_tmp,
sep="="):
if overr:
gscript.warning(_("Projection information does not match. "
"Proceeding..."))
else:
diff = ''.join(gscript.diff_files(temp_name, proj_name))
gscript.warning(_("Difference between PROJ_INFO file of "
"imported map and of current location:"
"\n{diff}").format(diff=diff))
gscript.fatal(_("Projection information does not match. "
"Aborting."))
# Create a new location based on the projection information and switch
# into it
old_env = gscript.gisenv()
if location:
try:
proj4_string = open(proj_file_name, 'r').read()
gscript.create_location(dbase=old_env["GISDBASE"],
location=location,
proj4=proj4_string)
# Just create a new location and return
if create:
os.chdir(old_cwd)
return
except Exception as e:
gscript.fatal(_("Unable to create location %(l)s. Reason: %(e)s")
% {'l': location, 'e': str(e)})
# Switch to the new created location
try:
gscript.run_command("g.mapset", mapset="PERMANENT",
location=location,
dbase=old_env["GISDBASE"])
except CalledModuleError:
gscript.fatal(_("Unable to switch to location %s") % location)
# create default database connection
try:
gscript.run_command("t.connect", flags="d")
except CalledModuleError:
gscript.fatal(_("Unable to create default temporal database "
"in new location %s") % location)
try:
# Make sure the temporal database exists
factory.init()
fs = "|"
maplist = []
mapset = get_current_mapset()
list_file = open(list_file_name, "r")
new_list_file = open(new_list_file_name, "w")
# get number of lines to correctly form the suffix
max_count = -1
for max_count, l in enumerate(list_file):
pass
max_count += 1
list_file.seek(0)
# Read the map list from file
line_count = 0
while True:
line = list_file.readline()
if not line:
break
line_list = line.split(fs)
# The filename is actually the base name of the map
# that must be extended by the file suffix
filename = line_list[0].strip().split(":")[0]
if base:
mapname = "%s_%s" % (base, gscript.get_num_suffix(line_count + 1,
max_count))
mapid = "%s@%s" % (mapname, mapset)
else:
mapname = filename
mapid = mapname + "@" + mapset
row = {}
row["filename"] = filename
row["name"] = mapname
row["id"] = mapid
row["start"] = line_list[1].strip()
row["end"] = line_list[2].strip()
new_list_file.write("%s%s%s%s%s\n" % (mapname, fs, row["start"],
fs, row["end"]))
maplist.append(row)
line_count += 1
list_file.close()
new_list_file.close()
# Read the init file
fs = "="
init = {}
init_file = open(init_file_name, "r")
while True:
line = init_file.readline()
if not line:
break
kv = line.split(fs)
init[kv[0]] = kv[1].strip()
init_file.close()
if "temporal_type" not in init or \
"semantic_type" not in init or \
"number_of_maps" not in init:
gscript.fatal(_("Key words %(t)s, %(s)s or %(n)s not found in init"
" file.") % {'t': "temporal_type",
's': "semantic_type",
'n': "number_of_maps"})
if line_count != int(init["number_of_maps"]):
gscript.fatal(_("Number of maps mismatch in init and list file."))
format_ = "GTiff"
type_ = "strds"
if "stds_type" in init:
type_ = init["stds_type"]
if "format" in init:
format_ = init["format"]
if stds_type != type_:
gscript.fatal(_("The archive file is of wrong space time dataset"
" type"))
# Check the existence of the files
if format_ == "GTiff":
for row in maplist:
filename = row["filename"] + ".tif"
if not os.path.exists(filename):
gscript.fatal(_("Unable to find GeoTIFF raster file "
"<%s> in archive.") % filename)
elif format_ == "AAIGrid":
for row in maplist:
filename = row["filename"] + ".asc"
if not os.path.exists(filename):
gscript.fatal(_("Unable to find AAIGrid raster file "
"<%s> in archive.") % filename)
elif format_ == "GML":
for row in maplist:
filename = row["filename"] + ".xml"
if not os.path.exists(filename):
gscript.fatal(_("Unable to find GML vector file "
"<%s> in archive.") % filename)
elif format_ == "pack":
for row in maplist:
if type_ == "stvds":
filename = str(row["filename"].split(":")[0]) + ".pack"
else:
filename = row["filename"] + ".pack"
if not os.path.exists(filename):
gscript.fatal(_("Unable to find GRASS package file "
"<%s> in archive.") % filename)
else:
gscript.fatal(_("Unsupported input format"))
# Check the space time dataset
id = output + "@" + mapset
sp = dataset_factory(type_, id)
if sp.is_in_db() and gscript.overwrite() is False:
gscript.fatal(_("Space time %(t)s dataset <%(sp)s> is already in"
" the database. Use the overwrite flag.") %
{'t': type_, 'sp': sp.get_id()})
# Import the maps
if type_ == "strds":
if format_ == "GTiff" or format_ == "AAIGrid":
_import_raster_maps_from_gdal(maplist, overr, exp, location,
link, format_, set_current_region)
if format_ == "pack":
_import_raster_maps(maplist, set_current_region)
elif type_ == "stvds":
if format_ == "GML":
_import_vector_maps_from_gml(
maplist, overr, exp, location, link)
if format_ == "pack":
_import_vector_maps(maplist)
# Create the space time dataset
if sp.is_in_db() and gscript.overwrite() is True:
gscript.info(_("Overwrite space time %(sp)s dataset "
"<%(id)s> and unregister all maps.") %
{'sp': sp.get_new_map_instance(None).get_type(),
'id': sp.get_id()})
sp.delete()
sp = sp.get_new_instance(id)
temporal_type = init["temporal_type"]
semantic_type = init["semantic_type"]
relative_time_unit = None
if temporal_type == "relative":
if "relative_time_unit" not in init:
gscript.fatal(_("Key word %s not found in init file.") %
("relative_time_unit"))
relative_time_unit = init["relative_time_unit"]
sp.set_relative_time_unit(relative_time_unit)
gscript.verbose(_("Create space time %s dataset.") %
sp.get_new_map_instance(None).get_type())
sp.set_initial_values(temporal_type=temporal_type,
semantic_type=semantic_type, title=title,
description=descr)
sp.insert()
# register the maps
fs = "|"
register_maps_in_space_time_dataset(
type=sp.get_new_map_instance(None).get_type(),
name=output, file=new_list_file_name, start="file",
end="file", unit=relative_time_unit, dbif=None, fs=fs,
update_cmd_list=False)
os.chdir(old_cwd)
except:
raise
# Make sure the location is switched back correctly
finally:
if location:
# Switch to the old location
try:
gscript.run_command("g.mapset", mapset=old_env["MAPSET"],
location=old_env["LOCATION_NAME"],
gisdbase=old_env["GISDBASE"])
except CalledModuleError:
grass.warning(_("Switching to original location failed"))
gscript.set_raise_on_error(old_state)
def main():
grass.set_raise_on_error(False)
options, flags = grass.parser()
# import wx only after running parser
# to avoid issues with complex imports when only interface is needed
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.render import Map
from mapdisp.frame import MapFrame
from mapdisp.main import DMonGrassInterface
from core.settings import UserSettings
from vdigit.main import haveVDigit, errorMsg
from grass.exceptions import CalledModuleError
# define classes which needs imports as local
# for longer definitions, a separate file would be a better option
class VDigitMapFrame(MapFrame):
def __init__(self, vectorMap):
MapFrame.__init__(self,
parent=None,
Map=Map(),
giface=DMonGrassInterface(None),
title=_("Vector Digitizer - GRASS GIS"),
size=(850, 600))
# this giface issue not solved yet, we must set mapframe aferwards
self._giface._mapframe = self
# load vector map
mapLayer = self.GetMap().AddLayer(
ltype='vector',
name=vectorMap,
command=['d.vect', 'map=%s' % vectorMap],
active=True,
hidden=False,
opacity=1.0,
render=True)
# switch toolbar
self.AddToolbar('vdigit', fixed=True)
# start editing
self.toolbars['vdigit'].StartEditing(mapLayer)
if not haveVDigit:
grass.fatal(_("Vector digitizer not available. %s") % errorMsg)
if not grass.find_file(name=options['map'],
element='vector',
mapset=grass.gisenv()['MAPSET'])['fullname']:
if not flags['c']:
grass.fatal(
_("Vector map <%s> not found in current mapset. "
"New vector map can be created by providing '-c' flag.") %
options['map'])
else:
grass.verbose(_("New vector map <%s> created") % options['map'])
try:
grass.run_command('v.edit',
map=options['map'],
tool='create',
quiet=True)
except CalledModuleError:
grass.fatal(
_("Unable to create new vector map <%s>") % options['map'])
# allow immediate rendering
driver = UserSettings.Get(group='display', key='driver', subkey='type')
if driver == 'png':
os.environ['GRASS_RENDER_IMMEDIATE'] = 'png'
else:
os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
app = wx.App()
frame = VDigitMapFrame(options['map'])
frame.Show()
app.MainLoop()
def main():
gs.set_raise_on_error(False)
options, flags = gs.parser()
# import wx only after running parser
# to avoid issues with complex imports when only interface is needed
import wx
from grass.script.setup import set_gui_path
set_gui_path()
from core.render import Map
from core.globalvar import ICONDIR
from mapdisp.frame import MapPanel
from gui_core.mapdisp import FrameMixin
from mapdisp.main import DMonGrassInterface
from core.settings import UserSettings
# define classes which needs imports as local
# for longer definitions, a separate file would be a better option
class RDigitMapDisplay(FrameMixin, MapPanel):
"""Map display for wrapping map panel with r.digit mathods and frame methods"""
def __init__(
self,
parent,
new_map=None,
base_map=None,
edit_map=None,
map_type=None,
):
MapPanel.__init__(self,
parent=parent,
Map=Map(),
giface=DMonGrassInterface(None))
# set system icon
parent.SetIcon(
wx.Icon(os.path.join(ICONDIR, "grass_map.ico"),
wx.BITMAP_TYPE_ICO))
# bindings
parent.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
# extend shortcuts and create frame accelerator table
self.shortcuts_table.append(
(self.OnFullScreen, wx.ACCEL_NORMAL, wx.WXK_F11))
self._initShortcuts()
# this giface issue not solved yet, we must set mapframe afterwards
self._giface._mapframe = self
self._giface.mapCreated.connect(self.OnMapCreated)
self._mapObj = self.GetMap()
# load raster map
self._addLayer(name=new_map if new_map else edit_map)
# switch toolbar
self.AddToolbar("rdigit", fixed=True)
rdigit = self.toolbars["rdigit"]
if new_map:
rdigit._mapSelectionCombo.Unbind(wx.EVT_COMBOBOX)
self.rdigit.SelectNewMap(
standalone=True,
mapName=new_map,
bgMap=base_map,
mapType=map_type,
)
rdigit._mapSelectionCombo.Bind(
wx.EVT_COMBOBOX,
rdigit.OnMapSelection,
)
else:
rdigit._mapSelectionCombo.SetSelection(n=1)
rdigit.OnMapSelection()
# use Close instead of QuitRDigit for standalone tool
self.rdigit.quitDigitizer.disconnect(self.QuitRDigit)
self.rdigit.quitDigitizer.connect(lambda: self.Close())
# 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()
def _addLayer(self, name, ltype="raster"):
"""Add layer into map
:param str name: map name
:param str ltype: layer type
"""
mapLayer = self._mapObj.AddLayer(
ltype=ltype,
name=name,
command=["d.rast", "map={}".format(name)],
active=True,
hidden=False,
opacity=1.0,
render=True,
)
def OnMapCreated(self, name, ltype):
"""Add new created raster layer into map
:param str name: map name
:param str ltype: layer type
"""
self._mapObj.Clean()
self._addLayer(name=name, ltype=ltype)
self.GetMapWindow().UpdateMap()
kwargs = {
"new_map": options["create"],
"base_map": options["base"],
"edit_map": options["edit"],
"map_type": options["type"],
}
mapset = gs.gisenv()["MAPSET"]
if kwargs["edit_map"]:
edit_map = gs.find_file(
name=kwargs["edit_map"],
element="raster",
mapset=mapset,
)["fullname"]
if not edit_map:
gs.fatal(
_(
"Raster map <{}> not found in current mapset.".format(
options["edit"], ), ), )
else:
kwargs["edit_map"] = edit_map
else:
if kwargs["base_map"]:
base_map = gs.find_file(
name=kwargs["base_map"],
element="raster",
mapset=mapset,
)["fullname"]
if not base_map:
gs.fatal(
_(
"Base raster map <{}> not found in "
"current mapset.".format(options["base"], ), ), )
kwargs["base_map"] = base_map
# allow immediate rendering
driver = UserSettings.Get(
group="display",
key="driver",
subkey="type",
)
if driver == "png":
os.environ["GRASS_RENDER_IMMEDIATE"] = "png"
else:
os.environ["GRASS_RENDER_IMMEDIATE"] = "cairo"
app = wx.App()
frame = wx.Frame(
None,
id=wx.ID_ANY,
size=(850, 600),
style=wx.DEFAULT_FRAME_STYLE,
title=_("Raster Digitizer - GRASS GIS"),
)
frame = RDigitMapDisplay(parent=frame, **kwargs)
frame.Show()
app.MainLoop()
