def contextMenuEvent(self, ev):
index = self.indexAt(ev.pos())
if not index.isValid():
return
if index != self.currentIndex():
self.itemChanged(index)
item = self.currentItem()
menu = QMenu(self)
if isinstance(item, (Table, Schema)):
menu.addAction(self.tr("Rename"), self.rename)
menu.addAction(self.tr("Delete"), self.delete)
if isinstance(item, Table) and item.canBeAddedToCanvas():
menu.addSeparator()
menu.addAction(self.tr("Add to canvas"), self.addLayer)
elif isinstance(item, DBPlugin):
if item.database() is not None:
menu.addAction(self.tr("Re-connect"), self.reconnect)
menu.addAction(self.tr("Remove"), self.delete)
elif not index.parent().isValid() and item.typeName() == "spatialite":
menu.addAction(self.tr("New Connection..."), self.newConnection)
if not menu.isEmpty():
menu.exec_(ev.globalPos())
menu.deleteLater()
def process_custom_menu(self, point):
''' See XmlController for documentation '''
item = self.select_item_at(point)
if not item:
return
menu = QMenu()
node = item.node
if node.get('executable') == 'True':
menu.addAction(self.actRunScenario)
elif node.get('type') in ['selectable', 'model_choice']:
menu.addAction(self.actMoveNodeUp)
menu.addAction(self.actMoveNodeDown)
elif node.tag == 'models_to_run': # special case of a selectable list
models_menu = QMenu(menu)
models_menu.setTitle('Add model to run')
models_menu.setIcon(IconLibrary.icon('add'))
available_model_names = get_model_names(self.project)
for model_name in available_model_names:
cb = lambda x=model_name, y=self.selected_index(
): self.addModel(y, x)
action = self.create_action('model', model_name, cb)
models_menu.addAction(action)
menu.addMenu(models_menu)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def process_custom_menu(self, point):
item = self.select_item_at(point)
if not item:
return
node = item.node
menu = QMenu(self.view)
# Populate menu
if node.tag == 'run':
menu.addAction(self.actGetInfoSimulationRuns)
menu.addAction(self.actDeleteRun)
elif node.tag == 'indicator_batches':
menu.addAction(self.actAddNewIndicatorBatch)
elif node.tag == 'simulation_runs':
menu.addAction(self.actImportRun)
elif node.tag == 'indicator_batch':
menu.addAction(self.actAddVisualizationToBatch)
run_batch_on_menu = QMenu('Run indicator batch on...')
self._createBatchRunMenu(run_batch_on_menu)
menu.addMenu(run_batch_on_menu)
elif node.tag == 'batch_visualization': # get('type') == 'batch_visualization':
menu.addAction(self.actConfigureExistingBatchIndicatorVis)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def process_custom_menu(self, point):
''' See XmlController for documentation '''
item = self.select_item_at(point)
if not item:
return
menu = QMenu()
node = item.node
if node.get('executable') == 'True':
menu.addAction(self.actRunScenario)
elif node.get('type') in ['selectable', 'model_choice']:
menu.addAction(self.actMoveNodeUp)
menu.addAction(self.actMoveNodeDown)
elif node.tag == 'models_to_run': # special case of a selectable list
models_menu = QMenu(menu)
models_menu.setTitle('Add model to run')
models_menu.setIcon(IconLibrary.icon('add'))
available_model_names = get_model_names(self.project)
for model_name in available_model_names:
cb = lambda x = model_name, y = self.selected_index(): self.addModel(y, x)
action = self.create_action('model', model_name, cb)
models_menu.addAction(action)
menu.addMenu(models_menu)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def create_custom_menu_for_node(self, node):
menu = QMenu(self.view)
if node is self.model.root_node():
self.add_default_menu_items_for_widget(menu)
elif not self.add_custom_menu_items_for_node(node, menu):
if not menu.isEmpty():
menu.addSeparator()
self.add_default_menu_items_for_node(node, menu)
return menu
def process_custom_menu(self, position):
'''
Abstract method for creating a context sensitive popup menu.
@param position (QPoint) point of request for the popupmenu.
'''
item = self.select_item_at(position)
if not item:
return
node = item.node
menu = QMenu(self.view)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def process_custom_menu(self, point):
''' See XmlConfig.processCustomMenu for documentation '''
index = self.select_item_at(point)
if not index:
return
node = self.selected_item().node
menu = QMenu(self.view)
if node.tag == 'models':
submenu = QMenu(menu) # to populate with templates
submenu.setTitle('Create model from template')
for action in self.create_from_template_actions:
submenu.addAction(action)
menu.addMenu(submenu)
if node.tag == 'model':
# If the users right clicks a model, give them the option to
# estimate it only if the model has a (non empty) specification
# subnode. If the model holds subgroups -- inform the user how to
# estimate them.
spec_node = node.find('specification')
submodels = None
if spec_node is not None:
submodels = spec_node.getchildren()
if spec_node is not None and submodels:
# check if its groups by type checking the first node
# note: this is not a reliable method if models can have mixed
# submodels and submodel groups.
if submodels[0].tag == 'submodel':
menu.addAction(self.action_run_estimation)
else:
menu.addAction(self.action_show_how_to_estimate_groups)
if node.tag == 'submodel' and not node.get('inherited'):
menu.addAction(self.action_edit_submodel)
if node.tag == 'submodel_group':
menu.addAction(self.action_run_estimation_group)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def process_custom_menu(self, point):
''' See XmlConfig.processCustomMenu for documentation '''
index = self.select_item_at(point)
if not index:
return
node = self.selected_item().node
menu = QMenu(self.view)
if node.tag == 'models':
submenu = QMenu(menu) # to populate with templates
submenu.setTitle('Create model from template')
for action in self.create_from_template_actions:
submenu.addAction(action)
menu.addMenu(submenu)
if node.tag == 'model':
# If the users right clicks a model, give them the option to
# estimate it only if the model has a (non empty) specification
# subnode. If the model holds subgroups -- inform the user how to
# estimate them.
spec_node = node.find('specification')
submodels = None
if spec_node is not None:
submodels = spec_node.getchildren()
if spec_node is not None and submodels:
# check if its groups by type checking the first node
# note: this is not a reliable method if models can have mixed
# submodels and submodel groups.
if submodels[0].tag == 'submodel':
menu.addAction(self.action_run_estimation)
else:
menu.addAction(self.action_show_how_to_estimate_groups)
if node.tag == 'submodel' and not node.get('inherited'):
menu.addAction(self.action_edit_submodel)
if node.tag == 'submodel_group':
menu.addAction(self.action_run_estimation_group)
self.add_default_menu_items_for_node(node, menu)
if not menu.isEmpty():
menu.exec_(QCursor.pos())
class GdalTools:
def __init__(self, iface):
if not valid:
return
# Save reference to the QGIS interface
self.iface = iface
try:
self.QgisVersion = unicode(QGis.QGIS_VERSION_INT)
except:
self.QgisVersion = unicode(QGis.qgisVersion)[0]
if QGis.QGIS_VERSION[0:3] < "1.5":
# For i18n support
userPluginPath = qgis.utils.home_plugin_path + "/GdalTools"
systemPluginPath = qgis.utils.sys_plugin_path + "/GdalTools"
overrideLocale = QSettings().value("locale/overrideFlag",
False,
type=bool)
if not overrideLocale:
localeFullName = QLocale.system().name()
else:
localeFullName = QSettings().value("locale/userLocale",
"",
type=str)
if QFileInfo(userPluginPath).exists():
translationPath = userPluginPath + "/i18n/GdalTools_" + localeFullName + ".qm"
else:
translationPath = systemPluginPath + "/i18n/GdalTools_" + localeFullName + ".qm"
self.localePath = translationPath
if QFileInfo(self.localePath).exists():
self.translator = QTranslator()
self.translator.load(self.localePath)
QCoreApplication.installTranslator(self.translator)
def initGui(self):
if not valid:
return
if int(self.QgisVersion) < 1:
QMessageBox.warning(
self.iface.getMainWindow(), "Gdal Tools",
QCoreApplication.translate("GdalTools",
"QGIS version detected: ") +
unicode(self.QgisVersion) + ".xx\n" +
QCoreApplication.translate(
"GdalTools",
"This version of Gdal Tools requires at least QGIS version 1.0.0\nPlugin will not be enabled."
))
return None
from tools.GdalTools_utils import GdalConfig, LayerRegistry
self.GdalVersionNum = GdalConfig.versionNum()
LayerRegistry.setIface(self.iface)
# find the Raster menu
rasterMenu = None
menu_bar = self.iface.mainWindow().menuBar()
actions = menu_bar.actions()
rasterText = QCoreApplication.translate("QgisApp", "&Raster")
for a in actions:
if a.menu() is not None and a.menu().title() == rasterText:
rasterMenu = a.menu()
break
if rasterMenu is None:
# no Raster menu, create and insert it before the Help menu
self.menu = QMenu(rasterText, self.iface.mainWindow())
lastAction = actions[len(actions) - 1]
menu_bar.insertMenu(lastAction, self.menu)
else:
self.menu = rasterMenu
self.menu.addSeparator()
# projections menu (Warp (Reproject), Assign projection)
self.projectionsMenu = QMenu(
QCoreApplication.translate("GdalTools", "Projections"),
self.iface.mainWindow())
self.projectionsMenu.setObjectName("projectionsMenu")
self.warp = QAction(
QIcon(":/icons/warp.png"),
QCoreApplication.translate("GdalTools", "Warp (Reproject)..."),
self.iface.mainWindow())
self.warp.setObjectName("warp")
self.warp.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Warp an image into a new coordinate system"))
QObject.connect(self.warp, SIGNAL("triggered()"), self.doWarp)
self.projection = QAction(
QIcon(":icons/projection-add.png"),
QCoreApplication.translate("GdalTools", "Assign Projection..."),
self.iface.mainWindow())
self.projection.setObjectName("projection")
self.projection.setStatusTip(
QCoreApplication.translate("GdalTools",
"Add projection info to the raster"))
QObject.connect(self.projection, SIGNAL("triggered()"),
self.doProjection)
self.extractProj = QAction(
QIcon(":icons/projection-export.png"),
QCoreApplication.translate("GdalTools", "Extract Projection..."),
self.iface.mainWindow())
self.extractProj.setObjectName("extractProj")
self.extractProj.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Extract projection information from raster(s)"))
QObject.connect(self.extractProj, SIGNAL("triggered()"),
self.doExtractProj)
self.projectionsMenu.addActions(
[self.warp, self.projection, self.extractProj])
# conversion menu (Rasterize (Vector to raster), Polygonize (Raster to vector), Translate, RGB to PCT, PCT to RGB)
self.conversionMenu = QMenu(
QCoreApplication.translate("GdalTools", "Conversion"),
self.iface.mainWindow())
self.conversionMenu.setObjectName("conversionMenu")
if self.GdalVersionNum >= 1300:
self.rasterize = QAction(
QIcon(":/icons/rasterize.png"),
QCoreApplication.translate("GdalTools",
"Rasterize (Vector to Raster)..."),
self.iface.mainWindow())
self.rasterize.setObjectName("rasterize")
self.rasterize.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Burns vector geometries into a raster"))
QObject.connect(self.rasterize, SIGNAL("triggered()"),
self.doRasterize)
self.conversionMenu.addAction(self.rasterize)
if self.GdalVersionNum >= 1600:
self.polygonize = QAction(
QIcon(":/icons/polygonize.png"),
QCoreApplication.translate("GdalTools",
"Polygonize (Raster to Vector)..."),
self.iface.mainWindow())
self.polygonize.setObjectName("polygonize")
self.polygonize.setStatusTip(
QCoreApplication.translate(
"GdalTools",
"Produces a polygon feature layer from a raster"))
QObject.connect(self.polygonize, SIGNAL("triggered()"),
self.doPolygonize)
self.conversionMenu.addAction(self.polygonize)
self.translate = QAction(
QIcon(":/icons/translate.png"),
QCoreApplication.translate("GdalTools",
"Translate (Convert Format)..."),
self.iface.mainWindow())
self.translate.setObjectName("translate")
self.translate.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Converts raster data between different formats"))
QObject.connect(self.translate, SIGNAL("triggered()"),
self.doTranslate)
self.paletted = QAction(
QIcon(":icons/24-to-8-bits.png"),
QCoreApplication.translate("GdalTools", "RGB to PCT..."),
self.iface.mainWindow())
self.paletted.setObjectName("paletted")
self.paletted.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Convert a 24bit RGB image to 8bit paletted"))
QObject.connect(self.paletted, SIGNAL("triggered()"), self.doPaletted)
self.rgb = QAction(
QIcon(":icons/8-to-24-bits.png"),
QCoreApplication.translate("GdalTools", "PCT to RGB..."),
self.iface.mainWindow())
self.rgb.setObjectName("rgb")
self.rgb.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Convert an 8bit paletted image to 24bit RGB"))
QObject.connect(self.rgb, SIGNAL("triggered()"), self.doRGB)
self.conversionMenu.addActions(
[self.translate, self.paletted, self.rgb])
# extraction menu (Clipper, Contour)
self.extractionMenu = QMenu(
QCoreApplication.translate("GdalTools", "Extraction"),
self.iface.mainWindow())
self.extractionMenu.setObjectName("extractionMenu")
if self.GdalVersionNum >= 1600:
self.contour = QAction(
QIcon(":/icons/contour.png"),
QCoreApplication.translate("GdalTools", "Contour..."),
self.iface.mainWindow())
self.contour.setObjectName("contour")
self.contour.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Builds vector contour lines from a DEM"))
QObject.connect(self.contour, SIGNAL("triggered()"),
self.doContour)
self.extractionMenu.addAction(self.contour)
self.clipper = QAction(
QIcon(":icons/raster-clip.png"),
QCoreApplication.translate("GdalTools", "Clipper..."),
self.iface.mainWindow())
self.clipper.setObjectName("clipper")
#self.clipper.setStatusTip( QCoreApplication.translate( "GdalTools", "Converts raster data between different formats") )
QObject.connect(self.clipper, SIGNAL("triggered()"), self.doClipper)
self.extractionMenu.addActions([self.clipper])
# analysis menu (DEM (Terrain model), Grid (Interpolation), Near black, Proximity (Raster distance), Sieve)
self.analysisMenu = QMenu(
QCoreApplication.translate("GdalTools", "Analysis"),
self.iface.mainWindow())
self.analysisMenu.setObjectName("analysisMenu")
if self.GdalVersionNum >= 1600:
self.sieve = QAction(
QIcon(":/icons/sieve.png"),
QCoreApplication.translate("GdalTools", "Sieve..."),
self.iface.mainWindow())
self.sieve.setObjectName("sieve")
self.sieve.setStatusTip(
QCoreApplication.translate("GdalTools",
"Removes small raster polygons"))
QObject.connect(self.sieve, SIGNAL("triggered()"), self.doSieve)
self.analysisMenu.addAction(self.sieve)
if self.GdalVersionNum >= 1500:
self.nearBlack = QAction(
QIcon(":/icons/nearblack.png"),
QCoreApplication.translate("GdalTools", "Near Black..."),
self.iface.mainWindow())
self.nearBlack.setObjectName("nearBlack")
self.nearBlack.setStatusTip(
QCoreApplication.translate(
"GdalTools",
"Convert nearly black/white borders to exact value"))
QObject.connect(self.nearBlack, SIGNAL("triggered()"),
self.doNearBlack)
self.analysisMenu.addAction(self.nearBlack)
if self.GdalVersionNum >= 1700:
self.fillNodata = QAction(
QIcon(":/icons/fillnodata.png"),
QCoreApplication.translate("GdalTools", "Fill nodata..."),
self.iface.mainWindow())
self.fillNodata.setObjectName("fillNodata")
self.fillNodata.setStatusTip(
QCoreApplication.translate(
"GdalTools",
"Fill raster regions by interpolation from edges"))
QObject.connect(self.fillNodata, SIGNAL("triggered()"),
self.doFillNodata)
self.analysisMenu.addAction(self.fillNodata)
if self.GdalVersionNum >= 1600:
self.proximity = QAction(
QIcon(":/icons/proximity.png"),
QCoreApplication.translate("GdalTools",
"Proximity (Raster Distance)..."),
self.iface.mainWindow())
self.proximity.setObjectName("proximity")
self.proximity.setStatusTip(
QCoreApplication.translate("GdalTools",
"Produces a raster proximity map"))
QObject.connect(self.proximity, SIGNAL("triggered()"),
self.doProximity)
self.analysisMenu.addAction(self.proximity)
if self.GdalVersionNum >= 1500:
self.grid = QAction(
QIcon(":/icons/grid.png"),
QCoreApplication.translate("GdalTools",
"Grid (Interpolation)..."),
self.iface.mainWindow())
self.grid.setObjectName("grid")
self.grid.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Create raster from the scattered data"))
QObject.connect(self.grid, SIGNAL("triggered()"), self.doGrid)
self.analysisMenu.addAction(self.grid)
if self.GdalVersionNum >= 1700:
self.dem = QAction(
QIcon(":icons/dem.png"),
QCoreApplication.translate("GdalTools",
"DEM (Terrain Models)..."),
self.iface.mainWindow())
self.dem.setObjectName("dem")
self.dem.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Tool to analyze and visualize DEMs"))
QObject.connect(self.dem, SIGNAL("triggered()"), self.doDEM)
self.analysisMenu.addAction(self.dem)
#self.analysisMenu.addActions( [ ] )
# miscellaneous menu (Build overviews (Pyramids), Tile index, Information, Merge, Build Virtual Raster (Catalog))
self.miscellaneousMenu = QMenu(
QCoreApplication.translate("GdalTools", "Miscellaneous"),
self.iface.mainWindow())
self.miscellaneousMenu.setObjectName("miscellaneousMenu")
if self.GdalVersionNum >= 1600:
self.buildVRT = QAction(
QIcon(":/icons/vrt.png"),
QCoreApplication.translate(
"GdalTools", "Build Virtual Raster (Catalog)..."),
self.iface.mainWindow())
self.buildVRT.setObjectName("buildVRT")
self.buildVRT.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Builds a VRT from a list of datasets"))
QObject.connect(self.buildVRT, SIGNAL("triggered()"),
self.doBuildVRT)
self.miscellaneousMenu.addAction(self.buildVRT)
self.merge = QAction(
QIcon(":/icons/merge.png"),
QCoreApplication.translate("GdalTools", "Merge..."),
self.iface.mainWindow())
self.merge.setObjectName("merge")
self.merge.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Build a quick mosaic from a set of images"))
QObject.connect(self.merge, SIGNAL("triggered()"), self.doMerge)
self.info = QAction(
QIcon(":/icons/raster-info.png"),
QCoreApplication.translate("GdalTools", "Information..."),
self.iface.mainWindow())
self.info.setObjectName("info")
self.info.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Lists information about raster dataset"))
QObject.connect(self.info, SIGNAL("triggered()"), self.doInfo)
self.overview = QAction(
QIcon(":icons/raster-overview.png"),
QCoreApplication.translate("GdalTools",
"Build Overviews (Pyramids)..."),
self.iface.mainWindow())
self.overview.setObjectName("overview")
self.overview.setStatusTip(
QCoreApplication.translate("GdalTools",
"Builds or rebuilds overview images"))
QObject.connect(self.overview, SIGNAL("triggered()"), self.doOverview)
self.tileindex = QAction(
QIcon(":icons/tiles.png"),
QCoreApplication.translate("GdalTools", "Tile Index..."),
self.iface.mainWindow())
self.tileindex.setObjectName("tileindex")
self.tileindex.setStatusTip(
QCoreApplication.translate(
"GdalTools", "Build a shapefile as a raster tileindex"))
QObject.connect(self.tileindex, SIGNAL("triggered()"),
self.doTileIndex)
self.miscellaneousMenu.addActions(
[self.merge, self.info, self.overview, self.tileindex])
self.menu.addMenu(self.projectionsMenu)
self.menu.addMenu(self.conversionMenu)
self.menu.addMenu(self.extractionMenu)
if not self.analysisMenu.isEmpty():
self.menu.addMenu(self.analysisMenu)
self.menu.addMenu(self.miscellaneousMenu)
self.settings = QAction(
QCoreApplication.translate("GdalTools", "GdalTools Settings..."),
self.iface.mainWindow())
self.settings.setObjectName("settings")
self.settings.setStatusTip(
QCoreApplication.translate("GdalTools",
"Various settings for Gdal Tools"))
QObject.connect(self.settings, SIGNAL("triggered()"), self.doSettings)
self.menu.addAction(self.settings)
def unload(self):
if not valid:
return
pass
def doBuildVRT(self):
from tools.doBuildVRT import GdalToolsDialog as BuildVRT
d = BuildVRT(self.iface)
self.runToolDialog(d)
def doContour(self):
from tools.doContour import GdalToolsDialog as Contour
d = Contour(self.iface)
self.runToolDialog(d)
def doRasterize(self):
from tools.doRasterize import GdalToolsDialog as Rasterize
d = Rasterize(self.iface)
self.runToolDialog(d)
def doPolygonize(self):
from tools.doPolygonize import GdalToolsDialog as Polygonize
d = Polygonize(self.iface)
self.runToolDialog(d)
def doMerge(self):
from tools.doMerge import GdalToolsDialog as Merge
d = Merge(self.iface)
self.runToolDialog(d)
def doSieve(self):
from tools.doSieve import GdalToolsDialog as Sieve
d = Sieve(self.iface)
self.runToolDialog(d)
def doProximity(self):
from tools.doProximity import GdalToolsDialog as Proximity
d = Proximity(self.iface)
self.runToolDialog(d)
def doNearBlack(self):
from tools.doNearBlack import GdalToolsDialog as NearBlack
d = NearBlack(self.iface)
self.runToolDialog(d)
def doFillNodata(self):
from tools.doFillNodata import GdalToolsDialog as FillNodata
d = FillNodata(self.iface)
self.runToolDialog(d)
def doWarp(self):
from tools.doWarp import GdalToolsDialog as Warp
d = Warp(self.iface)
self.runToolDialog(d)
def doGrid(self):
from tools.doGrid import GdalToolsDialog as Grid
d = Grid(self.iface)
self.runToolDialog(d)
def doTranslate(self):
from tools.doTranslate import GdalToolsDialog as Translate
d = Translate(self.iface)
self.runToolDialog(d)
def doInfo(self):
from tools.doInfo import GdalToolsDialog as Info
d = Info(self.iface)
self.runToolDialog(d)
def doProjection(self):
from tools.doProjection import GdalToolsDialog as Projection
d = Projection(self.iface)
self.runToolDialog(d)
def doOverview(self):
from tools.doOverview import GdalToolsDialog as Overview
d = Overview(self.iface)
self.runToolDialog(d)
def doClipper(self):
from tools.doClipper import GdalToolsDialog as Clipper
d = Clipper(self.iface)
self.runToolDialog(d)
def doPaletted(self):
from tools.doRgbPct import GdalToolsDialog as RgbPct
d = RgbPct(self.iface)
self.runToolDialog(d)
def doRGB(self):
from tools.doPctRgb import GdalToolsDialog as PctRgb
d = PctRgb(self.iface)
self.runToolDialog(d)
def doTileIndex(self):
from tools.doTileIndex import GdalToolsDialog as TileIndex
d = TileIndex(self.iface)
self.runToolDialog(d)
def doExtractProj(self):
from tools.doExtractProj import GdalToolsDialog as ExtractProj
d = ExtractProj(self.iface)
d.exec_()
def doDEM(self):
from tools.doDEM import GdalToolsDialog as DEM
d = DEM(self.iface)
self.runToolDialog(d)
def runToolDialog(self, dlg):
dlg.show_()
dlg.exec_()
del dlg
def doSettings(self):
from tools.doSettings import GdalToolsSettingsDialog as Settings
d = Settings(self.iface)
d.exec_()
class ProfileTableViewer( QWidget ):
" Profiling results table viewer "
escapePressed = pyqtSignal()
def __init__( self, scriptName, params, reportTime,
dataFile, stats, parent = None ):
QWidget.__init__( self, parent )
self.__table = ProfilerTreeWidget( self )
self.__table.escapePressed.connect( self.__onEsc )
self.__script = scriptName
self.__stats = stats
project = GlobalData().project
if project.isLoaded():
self.__projectPrefix = os.path.dirname( project.fileName )
else:
self.__projectPrefix = os.path.dirname( scriptName )
if not self.__projectPrefix.endswith( os.path.sep ):
self.__projectPrefix += os.path.sep
self.__table.setAlternatingRowColors( True )
self.__table.setRootIsDecorated( False )
self.__table.setItemsExpandable( False )
self.__table.setSortingEnabled( True )
self.__table.setItemDelegate( NoOutlineHeightDelegate( 4 ) )
self.__table.setUniformRowHeights( True )
self.__table.setSelectionMode( QAbstractItemView.SingleSelection )
self.__table.setSelectionBehavior( QAbstractItemView.SelectRows )
headerLabels = [ "", "Calls", "Total time", "Per call",
"Cum. time", "Per call", "File name:line",
"Function", "Callers", "Callees" ]
self.__table.setHeaderLabels( headerLabels )
headerItem = self.__table.headerItem()
headerItem.setToolTip( 0, "Indication if it is an outside function" )
headerItem.setToolTip( 1, "Actual number of calls/primitive calls "
"(not induced via recursion)" )
headerItem.setToolTip( 2, "Total time spent in function "
"(excluding time made in calls "
"to sub-functions)" )
headerItem.setToolTip( 3, "Total time divided by number "
"of actual calls" )
headerItem.setToolTip( 4, "Total time spent in function and all "
"subfunctions (from invocation till exit)" )
headerItem.setToolTip( 5, "Cumulative time divided by number "
"of primitive calls" )
headerItem.setToolTip( 6, "Function location" )
headerItem.setToolTip( 7, "Function name" )
headerItem.setToolTip( 8, "Function callers" )
headerItem.setToolTip( 9, "Function callees" )
self.__table.itemActivated.connect( self.__activated )
totalCalls = self.__stats.total_calls
totalPrimitiveCalls = self.__stats.prim_calls # The calls were not induced via recursion
totalTime = self.__stats.total_tt
txt = "<b>Script:</b> " + self.__script + " " + params.arguments + "<br>" \
"<b>Run at:</b> " + reportTime + "<br>" + \
str( totalCalls ) + " function calls (" + \
str( totalPrimitiveCalls ) + " primitive calls) in " + \
FLOAT_FORMAT % totalTime + " CPU seconds"
summary = QLabel( txt )
summary.setToolTip( txt )
summary.setSizePolicy( QSizePolicy.Ignored, QSizePolicy.Fixed )
summary.setFrameStyle( QFrame.StyledPanel )
summary.setAutoFillBackground( True )
summaryPalette = summary.palette()
summaryBackground = summaryPalette.color( QPalette.Background )
summaryBackground.setRgb( min( summaryBackground.red() + 30, 255 ),
min( summaryBackground.green() + 30, 255 ),
min( summaryBackground.blue() + 30, 255 ) )
summaryPalette.setColor( QPalette.Background, summaryBackground )
summary.setPalette( summaryPalette )
vLayout = QVBoxLayout()
vLayout.setContentsMargins( 0, 0, 0, 0 )
vLayout.setSpacing( 0 )
vLayout.addWidget( summary )
vLayout.addWidget( self.__table )
self.setLayout( vLayout )
self.__createContextMenu()
self.__populate( totalTime )
return
def __onEsc( self ):
" Triggered when Esc is pressed "
self.escapePressed.emit()
return
def __createContextMenu( self ):
" Creates context menu for the table raws "
self.__contextMenu = QMenu( self )
self.__callersMenu = QMenu( "Callers", self )
self.__outsideCallersMenu = QMenu( "Outside callers", self )
self.__calleesMenu = QMenu( "Callees", self )
self.__outsideCalleesMenu = QMenu( "Outside callees", self )
self.__contextMenu.addMenu( self.__callersMenu )
self.__contextMenu.addMenu( self.__outsideCallersMenu )
self.__contextMenu.addSeparator()
self.__contextMenu.addMenu( self.__calleesMenu )
self.__contextMenu.addMenu( self.__outsideCalleesMenu )
self.__contextMenu.addSeparator()
self.__disasmAct = self.__contextMenu.addAction(
PixmapCache().getIcon( 'disasmmenu.png' ),
"Disassemble", self.__onDisassemble )
self.__callersMenu.triggered.connect( self.__onCallContextMenu )
self.__outsideCallersMenu.triggered.connect( self.__onCallContextMenu )
self.__calleesMenu.triggered.connect( self.__onCallContextMenu )
self.__outsideCalleesMenu.triggered.connect( self.__onCallContextMenu )
self.__table.setContextMenuPolicy( Qt.CustomContextMenu )
self.__table.customContextMenuRequested.connect( self.__showContextMenu )
return
def __showContextMenu( self, point ):
" Context menu "
self.__callersMenu.clear()
self.__outsideCallersMenu.clear()
self.__calleesMenu.clear()
self.__outsideCalleesMenu.clear()
# Detect what the item was clicked
item = self.__table.itemAt( point )
funcName = item.getFunctionName()
self.__disasmAct.setEnabled( item.getFileName() != "" and \
not funcName.startswith( "<" ) )
# Build the context menu
if item.callersCount() == 0:
self.__callersMenu.setEnabled( False )
self.__outsideCallersMenu.setEnabled( False )
else:
callers = self.__stats.stats[ item.getFuncIDs() ][ 4 ]
callersList = callers.keys()
callersList.sort()
for callerFunc in callersList:
menuText = self.__getCallLine( callerFunc, callers[ callerFunc ] )
if self.__isOutsideItem( callerFunc[ 0 ] ):
act = self.__outsideCallersMenu.addAction( menuText )
else:
act = self.__callersMenu.addAction( menuText )
funcFileName, funcLine, funcName = self.__getLocationAndName( callerFunc )
act.setData( QVariant( funcFileName + ":" + \
str( funcLine ) + ":" + \
funcName ) )
self.__callersMenu.setEnabled( not self.__callersMenu.isEmpty() )
self.__outsideCallersMenu.setEnabled( not self.__outsideCallersMenu.isEmpty() )
if item.calleesCount() == 0:
self.__calleesMenu.setEnabled( False )
self.__outsideCalleesMenu.setEnabled( False )
else:
callees = self.__stats.all_callees[ item.getFuncIDs() ]
calleesList = callees.keys()
calleesList.sort()
for calleeFunc in calleesList:
menuText = self.__getCallLine( calleeFunc, callees[ calleeFunc ] )
if self.__isOutsideItem( calleeFunc[ 0 ] ):
act = self.__outsideCalleesMenu.addAction( menuText )
else:
act = self.__calleesMenu.addAction( menuText )
funcFileName, funcLine, funcName = self.__getLocationAndName( calleeFunc )
act.setData( QVariant( funcFileName + ":" + \
str( funcLine ) + ":" + \
funcName ) )
self.__calleesMenu.setEnabled( not self.__calleesMenu.isEmpty() )
self.__outsideCalleesMenu.setEnabled( not self.__outsideCalleesMenu.isEmpty() )
self.__contextMenu.popup( QCursor.pos() )
return
def __onDisassemble( self ):
" On disassemble something "
item = self.__table.selectedItems()[ 0 ]
GlobalData().mainWindow.showDisassembler( item.getFileName(),
item.getFunctionName() )
return
def __resize( self ):
" Resizes columns to the content "
self.__table.header().resizeSections( QHeaderView.ResizeToContents )
self.__table.header().setStretchLastSection( True )
self.__table.header().resizeSection( OUTSIDE_COL_INDEX, 28 )
self.__table.header().setResizeMode( OUTSIDE_COL_INDEX,
QHeaderView.Fixed )
return
def setFocus( self ):
" Set focus to the proper widget "
self.__table.setFocus()
return
def __isOutsideItem( self, fileName ):
" Detects if the record should be shown as an outside one "
return not fileName.startswith( self.__projectPrefix )
def __activated( self, item, column ):
" Triggered when the item is activated "
try:
line = item.getLineNumber()
fileName = item.getFileName()
if line == 0 or not os.path.isabs( fileName ):
return
GlobalData().mainWindow.openFile( fileName, line )
except:
logging.error( "Could not jump to function location" )
return
@staticmethod
def __getFuncShortLocation( funcFileName, funcLine ):
" Provides unified shortened function location "
if funcFileName == "":
return ""
return os.path.basename( funcFileName ) + ":" + str( funcLine )
def __getCallLine( self, func, props ):
" Provides the formatted call line "
funcFileName, funcLine, funcName = self.__getLocationAndName( func )
if isinstance( props, tuple ):
actualCalls, primitiveCalls, totalTime, cumulativeTime = props
if primitiveCalls != actualCalls:
callsString = str( actualCalls ) + "/" + str( primitiveCalls )
else:
callsString = str( actualCalls )
return callsString + "\t" + FLOAT_FORMAT % totalTime + "\t" + \
FLOAT_FORMAT % cumulativeTime + "\t" + \
self.__getFuncShortLocation( funcFileName, funcLine ) + \
"(" + funcName + ")"
# I've never seen this branch working so it is just in case.
# There was something like this in the pstats module
return self.__getFuncShortLocation( funcFileName, funcLine ) + \
"(" + funcName + ")"
@staticmethod
def __getLocationAndName( func ):
" Provides standardized function file name, line and its name "
if func[ : 2 ] == ( '~', 0 ):
# special case for built-in functions
name = func[ 2 ]
if name.startswith( '<' ) and name.endswith( '>' ):
return "", 0, "{%s}" % name[ 1 : -1 ]
return "", 0, name
return func[ 0 ], func[ 1 ], func[ 2 ]
def __createItem( self, func, totalCPUTime,
primitiveCalls, actualCalls, totalTime,
cumulativeTime, timePerCall, cumulativeTimePerCall,
callers ):
" Creates an item to display "
values = []
values.append( "" )
if primitiveCalls == actualCalls:
values.append( str( actualCalls ) )
else:
values.append( str( actualCalls ) + "/" + str( primitiveCalls ) )
if totalCPUTime == 0.0:
values.append( FLOAT_FORMAT % totalTime )
else:
values.append( FLOAT_FORMAT % totalTime + " \t(%3.2f%%)" % (totalTime / totalCPUTime * 100) )
values.append( FLOAT_FORMAT % timePerCall )
values.append( FLOAT_FORMAT % cumulativeTime )
values.append( FLOAT_FORMAT % cumulativeTimePerCall )
# Location and name will be filled in the item constructor
values.append( "" )
values.append( "" )
# Callers
callersCount = len( callers )
values.append( str( callersCount ) )
# Callees
if func in self.__stats.all_callees:
calleesCount = len( self.__stats.all_callees[ func ] )
else:
calleesCount = 0
values.append( str( calleesCount ) )
item = ProfilingTableItem( values, self.__isOutsideItem( func[ 0 ] ),
func )
if callersCount != 0:
tooltip = ""
callersList = callers.keys()
callersList.sort()
for callerFunc in callersList[ : MAX_CALLS_IN_TOOLTIP ]:
if tooltip != "":
tooltip += "\n"
tooltip += self.__getCallLine( callerFunc, callers[ callerFunc ] )
if callersCount > MAX_CALLS_IN_TOOLTIP:
tooltip += "\n. . ."
item.setToolTip( 8, tooltip )
if calleesCount != 0:
callees = self.__stats.all_callees[ func ]
tooltip = ""
calleesList = callees.keys()
calleesList.sort()
for calleeFunc in calleesList[ : MAX_CALLS_IN_TOOLTIP ]:
if tooltip != "":
tooltip += "\n"
tooltip += self.__getCallLine( calleeFunc, callees[ calleeFunc ] )
if calleesCount > MAX_CALLS_IN_TOOLTIP:
tooltip += "\n. . ."
item.setToolTip( 9, tooltip )
self.__table.addTopLevelItem( item )
return
def __populate( self, totalCPUTime ):
" Populates the data "
for func, ( primitiveCalls, actualCalls, totalTime,
cumulativeTime, callers ) in self.__stats.stats.items():
# Calc time per call
if actualCalls == 0:
timePerCall = 0.0
else:
timePerCall = totalTime / actualCalls
# Calc time per cummulative call
if primitiveCalls == 0:
cumulativeTimePerCall = 0.0
else:
cumulativeTimePerCall = cumulativeTime / primitiveCalls
self.__createItem( func, totalCPUTime,
primitiveCalls, actualCalls, totalTime,
cumulativeTime, timePerCall, cumulativeTimePerCall,
callers )
self.__resize()
self.__table.header().setSortIndicator( 2, Qt.DescendingOrder )
self.__table.sortItems( 2,
self.__table.header().sortIndicatorOrder() )
return
def togglePath( self, state ):
" Switches between showing full paths or file names in locations "
for index in xrange( 0, self.__table.topLevelItemCount() ):
self.__table.topLevelItem( index ).updateLocation( state )
self.__resize()
return
def __onCallContextMenu( self, act ):
" Triggered when a context menu action is requested "
name = str( act.data().toString() )
for index in xrange( 0, self.__table.topLevelItemCount() ):
item = self.__table.topLevelItem( index )
if item.match( name ):
self.__table.clearSelection()
self.__table.scrollToItem( item )
self.__table.setCurrentItem( item )
return
def onSaveAs( self, fileName ):
" Saves the table to a file in CSV format "
try:
f = open( fileName, "wt" )
headerItem = self.__table.headerItem()
outsideIndex = -1
for index in xrange( 0, headerItem.columnCount() ):
title = str( headerItem.text( index ) )
if title == "":
outsideIndex = index
title = "Outside"
if index != 0:
f.write( ',' + title )
else:
f.write( title )
for index in xrange( 0, self.__table.topLevelItemCount() ):
item = self.__table.topLevelItem( index )
f.write( "\n" )
for column in xrange( 0, item.columnCount() ):
if column != 0:
f.write( ',' )
if column == outsideIndex:
if item.isOutside():
f.write( "Y" )
else:
f.write( "N" )
else:
text = str( item.text( column ) )
f.write( text.replace( '\t', '' ) )
f.close()
except Exception, ex:
logging.error( ex )
return
def _show_right_click_menu(self, point):
''' handler for the when users right click on table variables_table '''
index = self.variables_table.indexAt(point)
if not index.isValid:
return
self.variables_table.setCurrentIndex(index)
var = self.model.variables[index.row()]
menu = QMenu(self.variables_table)
# Edit variable action
p = ('edit', 'Edit %s' % var['name'],
lambda x=var: self._edit_variable(x), self)
edit_action = create_qt_action(*p)
font = QFont()
font.setBold(True)
edit_action.setFont(font)
# Clone variable action
p = ('clone', 'Create new variable based on this',
lambda x=var: self._add_variable(x), self)
clone_action = create_qt_action(*p)
def make_local(var=var):
if var['inherited']:
var['dirty'] = True
var['inherited'] = None
self.model.dirty = True
self._update_apply_button()
def delete_var(var=var):
self.model.delete_variable(var)
self._update_apply_button()
p = ('make_local', 'Make local', make_local, self)
make_local_action = create_qt_action(*p)
p = ('delete', 'Delete %s' % var['name'], delete_var, self)
delete_action = create_qt_action(*p)
p = ('revert', 'Revert %s to inherited' % var['name'], delete_var,
self)
revert_action = create_qt_action(*p)
# check to see if we have graphviz installed
p = ('zoom', 'View dependencies',
lambda x=var: self._view_dependencies(x), self)
view_dependencies_action = create_qt_action(*p)
if var['inherited']:
# menu.addAction(edit_action)
menu.addAction(make_local_action)
menu.addAction(clone_action)
menu.addSeparator()
menu.addAction(view_dependencies_action)
else:
menu.addAction(edit_action)
menu.addAction(clone_action)
menu.addSeparator()
# if the node in the table is local, but the original is inherited OR
# if the original node is shadowing an inherited node, allow user to 'revert'
# instead of 'delete'. Read more about prototype nodes in opus_project.py.
if var['originalnode'] is None:
menu.addAction(delete_action)
else:
prototype_node = self.project.get_prototype_node(
var['originalnode'])
if var['originalnode'].get('inherited') or \
(prototype_node is not None and prototype_node.get('inherited')):
# This action will revert the node to the parent state. Show the values
# that it will revert to
tt = ('Revert %s to Name: %s, Definition: %s' %
(var['name'], prototype_node.get('name'),
prototype_node.text))
revert_action.setToolTip(tt)
menu.addAction(revert_action)
else:
menu.addAction(delete_action)
menu.addAction(view_dependencies_action)
# Menu constructed, present to user
if not menu.isEmpty():
menu.exec_(QCursor.pos())
class GdalTools:
def __init__(self, iface):
if not valid:
return
# Save reference to the QGIS interface
self.iface = iface
try:
self.QgisVersion = unicode(QGis.QGIS_VERSION_INT)
except:
self.QgisVersion = unicode(QGis.qgisVersion)[0]
if QGis.QGIS_VERSION[0:3] < "1.5":
# For i18n support
userPluginPath = qgis.utils.home_plugin_path + "/GdalTools"
systemPluginPath = qgis.utils.sys_plugin_path + "/GdalTools"
overrideLocale = QSettings().value("locale/overrideFlag", False, type=bool)
if not overrideLocale:
localeFullName = QLocale.system().name()
else:
localeFullName = QSettings().value("locale/userLocale", "", type=str)
if QFileInfo(userPluginPath).exists():
translationPath = userPluginPath + "/i18n/GdalTools_" + localeFullName + ".qm"
else:
translationPath = systemPluginPath + "/i18n/GdalTools_" + localeFullName + ".qm"
self.localePath = translationPath
if QFileInfo(self.localePath).exists():
self.translator = QTranslator()
self.translator.load(self.localePath)
QCoreApplication.installTranslator(self.translator)
# The list of actions added to menus, so we can remove them when unloading the plugin
self._menuActions = []
def initGui(self):
if not valid:
return
if int(self.QgisVersion) < 1:
QMessageBox.warning(
self.iface.getMainWindow(), "Gdal Tools",
QCoreApplication.translate("GdalTools", "QGIS version detected: ") + unicode(self.QgisVersion) + ".xx\n"
+ QCoreApplication.translate("GdalTools", "This version of Gdal Tools requires at least QGIS version 1.0.0\nPlugin will not be enabled."))
return None
from tools.GdalTools_utils import GdalConfig, LayerRegistry
self.GdalVersionNum = GdalConfig.versionNum()
LayerRegistry.setIface(self.iface)
# find the Raster menu
rasterMenu = None
menu_bar = self.iface.mainWindow().menuBar()
actions = menu_bar.actions()
rasterText = QCoreApplication.translate("QgisApp", "&Raster")
for a in actions:
if a.menu() is not None and a.menu().title() == rasterText:
rasterMenu = a.menu()
break
if rasterMenu is None:
# no Raster menu, create and insert it before the Help menu
self.menu = QMenu(rasterText, self.iface.mainWindow())
lastAction = actions[len(actions) - 1]
menu_bar.insertMenu(lastAction, self.menu)
else:
self.menu = rasterMenu
self._menuActions.append(self.menu.addSeparator())
# projections menu (Warp (Reproject), Assign projection)
self.projectionsMenu = QMenu(QCoreApplication.translate("GdalTools", "Projections"), self.iface.mainWindow())
self.projectionsMenu.setObjectName("projectionsMenu")
self.warp = QAction(QIcon(":/icons/warp.png"), QCoreApplication.translate("GdalTools", "Warp (Reproject)..."), self.iface.mainWindow())
self.warp.setObjectName("warp")
self.warp.setStatusTip(QCoreApplication.translate("GdalTools", "Warp an image into a new coordinate system"))
QObject.connect(self.warp, SIGNAL("triggered()"), self.doWarp)
self.projection = QAction(QIcon(":icons/projection-add.png"), QCoreApplication.translate("GdalTools", "Assign Projection..."), self.iface.mainWindow())
self.projection.setObjectName("projection")
self.projection.setStatusTip(QCoreApplication.translate("GdalTools", "Add projection info to the raster"))
QObject.connect(self.projection, SIGNAL("triggered()"), self.doProjection)
self.extractProj = QAction(QIcon(":icons/projection-export.png"), QCoreApplication.translate("GdalTools", "Extract Projection..."), self.iface.mainWindow())
self.extractProj.setObjectName("extractProj")
self.extractProj.setStatusTip(QCoreApplication.translate("GdalTools", "Extract projection information from raster(s)"))
QObject.connect(self.extractProj, SIGNAL("triggered()"), self.doExtractProj)
self.projectionsMenu.addActions([self.warp, self.projection, self.extractProj])
# conversion menu (Rasterize (Vector to raster), Polygonize (Raster to vector), Translate, RGB to PCT, PCT to RGB)
self.conversionMenu = QMenu(QCoreApplication.translate("GdalTools", "Conversion"), self.iface.mainWindow())
self.conversionMenu.setObjectName("conversionMenu")
if self.GdalVersionNum >= 1300:
self.rasterize = QAction(QIcon(":/icons/rasterize.png"), QCoreApplication.translate("GdalTools", "Rasterize (Vector to Raster)..."), self.iface.mainWindow())
self.rasterize.setObjectName("rasterize")
self.rasterize.setStatusTip(QCoreApplication.translate("GdalTools", "Burns vector geometries into a raster"))
QObject.connect(self.rasterize, SIGNAL("triggered()"), self.doRasterize)
self.conversionMenu.addAction(self.rasterize)
if self.GdalVersionNum >= 1600:
self.polygonize = QAction(QIcon(":/icons/polygonize.png"), QCoreApplication.translate("GdalTools", "Polygonize (Raster to Vector)..."), self.iface.mainWindow())
self.polygonize.setObjectName("polygonize")
self.polygonize.setStatusTip(QCoreApplication.translate("GdalTools", "Produces a polygon feature layer from a raster"))
QObject.connect(self.polygonize, SIGNAL("triggered()"), self.doPolygonize)
self.conversionMenu.addAction(self.polygonize)
self.translate = QAction(QIcon(":/icons/translate.png"), QCoreApplication.translate("GdalTools", "Translate (Convert Format)..."), self.iface.mainWindow())
self.translate.setObjectName("translate")
self.translate.setStatusTip(QCoreApplication.translate("GdalTools", "Converts raster data between different formats"))
QObject.connect(self.translate, SIGNAL("triggered()"), self.doTranslate)
self.paletted = QAction(QIcon(":icons/24-to-8-bits.png"), QCoreApplication.translate("GdalTools", "RGB to PCT..."), self.iface.mainWindow())
self.paletted.setObjectName("paletted")
self.paletted.setStatusTip(QCoreApplication.translate("GdalTools", "Convert a 24bit RGB image to 8bit paletted"))
QObject.connect(self.paletted, SIGNAL("triggered()"), self.doPaletted)
self.rgb = QAction(QIcon(":icons/8-to-24-bits.png"), QCoreApplication.translate("GdalTools", "PCT to RGB..."), self.iface.mainWindow())
self.rgb.setObjectName("rgb")
self.rgb.setStatusTip(QCoreApplication.translate("GdalTools", "Convert an 8bit paletted image to 24bit RGB"))
QObject.connect(self.rgb, SIGNAL("triggered()"), self.doRGB)
self.conversionMenu.addActions([self.translate, self.paletted, self.rgb])
# extraction menu (Clipper, Contour)
self.extractionMenu = QMenu(QCoreApplication.translate("GdalTools", "Extraction"), self.iface.mainWindow())
self.extractionMenu.setObjectName("extractionMenu")
if self.GdalVersionNum >= 1600:
self.contour = QAction(QIcon(":/icons/contour.png"), QCoreApplication.translate("GdalTools", "Contour..."), self.iface.mainWindow())
self.contour.setObjectName("contour")
self.contour.setStatusTip(QCoreApplication.translate("GdalTools", "Builds vector contour lines from a DEM"))
QObject.connect(self.contour, SIGNAL("triggered()"), self.doContour)
self.extractionMenu.addAction(self.contour)
self.clipper = QAction(QIcon(":icons/raster-clip.png"), QCoreApplication.translate("GdalTools", "Clipper..."), self.iface.mainWindow())
self.clipper.setObjectName("clipper")
#self.clipper.setStatusTip( QCoreApplication.translate( "GdalTools", "Converts raster data between different formats") )
QObject.connect(self.clipper, SIGNAL("triggered()"), self.doClipper)
self.extractionMenu.addActions([self.clipper])
# analysis menu (DEM (Terrain model), Grid (Interpolation), Near black, Proximity (Raster distance), Sieve)
self.analysisMenu = QMenu(QCoreApplication.translate("GdalTools", "Analysis"), self.iface.mainWindow())
self.analysisMenu.setObjectName("analysisMenu")
if self.GdalVersionNum >= 1600:
self.sieve = QAction(QIcon(":/icons/sieve.png"), QCoreApplication.translate("GdalTools", "Sieve..."), self.iface.mainWindow())
self.sieve.setObjectName("sieve")
self.sieve.setStatusTip(QCoreApplication.translate("GdalTools", "Removes small raster polygons"))
QObject.connect(self.sieve, SIGNAL("triggered()"), self.doSieve)
self.analysisMenu.addAction(self.sieve)
if self.GdalVersionNum >= 1500:
self.nearBlack = QAction(QIcon(":/icons/nearblack.png"), QCoreApplication.translate("GdalTools", "Near Black..."), self.iface.mainWindow())
self.nearBlack.setObjectName("nearBlack")
self.nearBlack.setStatusTip(QCoreApplication.translate("GdalTools", "Convert nearly black/white borders to exact value"))
QObject.connect(self.nearBlack, SIGNAL("triggered()"), self.doNearBlack)
self.analysisMenu.addAction(self.nearBlack)
if self.GdalVersionNum >= 1700:
self.fillNodata = QAction(QIcon(":/icons/fillnodata.png"), QCoreApplication.translate("GdalTools", "Fill nodata..."), self.iface.mainWindow())
self.fillNodata.setObjectName("fillNodata")
self.fillNodata.setStatusTip(QCoreApplication.translate("GdalTools", "Fill raster regions by interpolation from edges"))
QObject.connect(self.fillNodata, SIGNAL("triggered()"), self.doFillNodata)
self.analysisMenu.addAction(self.fillNodata)
if self.GdalVersionNum >= 1600:
self.proximity = QAction(QIcon(":/icons/proximity.png"), QCoreApplication.translate("GdalTools", "Proximity (Raster Distance)..."), self.iface.mainWindow())
self.proximity.setObjectName("proximity")
self.proximity.setStatusTip(QCoreApplication.translate("GdalTools", "Produces a raster proximity map"))
QObject.connect(self.proximity, SIGNAL("triggered()"), self.doProximity)
self.analysisMenu.addAction(self.proximity)
if self.GdalVersionNum >= 1500:
self.grid = QAction(QIcon(":/icons/grid.png"), QCoreApplication.translate("GdalTools", "Grid (Interpolation)..."), self.iface.mainWindow())
self.grid.setObjectName("grid")
self.grid.setStatusTip(QCoreApplication.translate("GdalTools", "Create raster from the scattered data"))
QObject.connect(self.grid, SIGNAL("triggered()"), self.doGrid)
self.analysisMenu.addAction(self.grid)
if self.GdalVersionNum >= 1700:
self.dem = QAction(QIcon(":icons/dem.png"), QCoreApplication.translate("GdalTools", "DEM (Terrain Models)..."), self.iface.mainWindow())
self.dem.setObjectName("dem")
self.dem.setStatusTip(QCoreApplication.translate("GdalTools", "Tool to analyze and visualize DEMs"))
QObject.connect(self.dem, SIGNAL("triggered()"), self.doDEM)
self.analysisMenu.addAction(self.dem)
#self.analysisMenu.addActions( [ ] )
# miscellaneous menu (Build overviews (Pyramids), Tile index, Information, Merge, Build Virtual Raster (Catalog))
self.miscellaneousMenu = QMenu(QCoreApplication.translate("GdalTools", "Miscellaneous"), self.iface.mainWindow())
self.miscellaneousMenu.setObjectName("miscellaneousMenu")
if self.GdalVersionNum >= 1600:
self.buildVRT = QAction(QIcon(":/icons/vrt.png"), QCoreApplication.translate("GdalTools", "Build Virtual Raster (Catalog)..."), self.iface.mainWindow())
self.buildVRT.setObjectName("buildVRT")
self.buildVRT.setStatusTip(QCoreApplication.translate("GdalTools", "Builds a VRT from a list of datasets"))
QObject.connect(self.buildVRT, SIGNAL("triggered()"), self.doBuildVRT)
self.miscellaneousMenu.addAction(self.buildVRT)
self.merge = QAction(QIcon(":/icons/merge.png"), QCoreApplication.translate("GdalTools", "Merge..."), self.iface.mainWindow())
self.merge.setObjectName("merge")
self.merge.setStatusTip(QCoreApplication.translate("GdalTools", "Build a quick mosaic from a set of images"))
QObject.connect(self.merge, SIGNAL("triggered()"), self.doMerge)
self.info = QAction(QIcon(":/icons/raster-info.png"), QCoreApplication.translate("GdalTools", "Information..."), self.iface.mainWindow())
self.info.setObjectName("info")
self.info.setStatusTip(QCoreApplication.translate("GdalTools", "Lists information about raster dataset"))
QObject.connect(self.info, SIGNAL("triggered()"), self.doInfo)
self.overview = QAction(QIcon(":icons/raster-overview.png"), QCoreApplication.translate("GdalTools", "Build Overviews (Pyramids)..."), self.iface.mainWindow())
self.overview.setObjectName("overview")
self.overview.setStatusTip(QCoreApplication.translate("GdalTools", "Builds or rebuilds overview images"))
QObject.connect(self.overview, SIGNAL("triggered()"), self.doOverview)
self.tileindex = QAction(QIcon(":icons/tiles.png"), QCoreApplication.translate("GdalTools", "Tile Index..."), self.iface.mainWindow())
self.tileindex.setObjectName("tileindex")
self.tileindex.setStatusTip(QCoreApplication.translate("GdalTools", "Build a shapefile as a raster tileindex"))
QObject.connect(self.tileindex, SIGNAL("triggered()"), self.doTileIndex)
self.miscellaneousMenu.addActions([self.merge, self.info, self.overview, self.tileindex])
self._menuActions.append(self.menu.addMenu(self.projectionsMenu))
self._menuActions.append(self.menu.addMenu(self.conversionMenu))
self._menuActions.append(self.menu.addMenu(self.extractionMenu))
if not self.analysisMenu.isEmpty():
self._menuActions.append(self.menu.addMenu(self.analysisMenu))
self._menuActions.append(self.menu.addMenu(self.miscellaneousMenu))
self.settings = QAction(QCoreApplication.translate("GdalTools", "GdalTools Settings..."), self.iface.mainWindow())
self.settings.setObjectName("settings")
self.settings.setStatusTip(QCoreApplication.translate("GdalTools", "Various settings for Gdal Tools"))
QObject.connect(self.settings, SIGNAL("triggered()"), self.doSettings)
self.menu.addAction(self.settings)
self._menuActions.append(self.settings)
def unload(self):
if not valid:
return
for a in self._menuActions:
self.menu.removeAction(a)
def doBuildVRT(self):
from tools.doBuildVRT import GdalToolsDialog as BuildVRT
d = BuildVRT(self.iface)
self.runToolDialog(d)
def doContour(self):
from tools.doContour import GdalToolsDialog as Contour
d = Contour(self.iface)
self.runToolDialog(d)
def doRasterize(self):
from tools.doRasterize import GdalToolsDialog as Rasterize
d = Rasterize(self.iface)
self.runToolDialog(d)
def doPolygonize(self):
from tools.doPolygonize import GdalToolsDialog as Polygonize
d = Polygonize(self.iface)
self.runToolDialog(d)
def doMerge(self):
from tools.doMerge import GdalToolsDialog as Merge
d = Merge(self.iface)
self.runToolDialog(d)
def doSieve(self):
from tools.doSieve import GdalToolsDialog as Sieve
d = Sieve(self.iface)
self.runToolDialog(d)
def doProximity(self):
from tools.doProximity import GdalToolsDialog as Proximity
d = Proximity(self.iface)
self.runToolDialog(d)
def doNearBlack(self):
from tools.doNearBlack import GdalToolsDialog as NearBlack
d = NearBlack(self.iface)
self.runToolDialog(d)
def doFillNodata(self):
from tools.doFillNodata import GdalToolsDialog as FillNodata
d = FillNodata(self.iface)
self.runToolDialog(d)
def doWarp(self):
from tools.doWarp import GdalToolsDialog as Warp
d = Warp(self.iface)
self.runToolDialog(d)
def doGrid(self):
from tools.doGrid import GdalToolsDialog as Grid
d = Grid(self.iface)
self.runToolDialog(d)
def doTranslate(self):
from tools.doTranslate import GdalToolsDialog as Translate
d = Translate(self.iface)
self.runToolDialog(d)
def doInfo(self):
from tools.doInfo import GdalToolsDialog as Info
d = Info(self.iface)
self.runToolDialog(d)
def doProjection(self):
from tools.doProjection import GdalToolsDialog as Projection
d = Projection(self.iface)
self.runToolDialog(d)
def doOverview(self):
from tools.doOverview import GdalToolsDialog as Overview
d = Overview(self.iface)
self.runToolDialog(d)
def doClipper(self):
from tools.doClipper import GdalToolsDialog as Clipper
d = Clipper(self.iface)
self.runToolDialog(d)
def doPaletted(self):
from tools.doRgbPct import GdalToolsDialog as RgbPct
d = RgbPct(self.iface)
self.runToolDialog(d)
def doRGB(self):
from tools.doPctRgb import GdalToolsDialog as PctRgb
d = PctRgb(self.iface)
self.runToolDialog(d)
def doTileIndex(self):
from tools.doTileIndex import GdalToolsDialog as TileIndex
d = TileIndex(self.iface)
self.runToolDialog(d)
def doExtractProj(self):
from tools.doExtractProj import GdalToolsDialog as ExtractProj
d = ExtractProj(self.iface)
d.exec_()
def doDEM(self):
from tools.doDEM import GdalToolsDialog as DEM
d = DEM(self.iface)
self.runToolDialog(d)
def runToolDialog(self, dlg):
dlg.show_()
dlg.exec_()
del dlg
def doSettings(self):
from tools.doSettings import GdalToolsSettingsDialog as Settings
d = Settings(self.iface)
d.exec_()
def process_custom_menu(self, position):
''' See XmlConfig.processCustomMenu for documentation '''
item = self.select_item_at(position)
index = self.view.indexAt(position)
cnt = self.model.rowCount(index.parent())
istop = index.row() == 0
isbottom = index.row() == cnt - 1
isonly = cnt == 1
if not item:
return
node = item.node
menu = QMenu(self.view)
# Tool files are the "actual" tools
if node.tag == "tool":
menu.addAction(self.actExecToolFile)
if not isonly: menu.addSeparator()
if not istop: menu.addAction(self.actMoveNodeUp)
if not isbottom: menu.addAction(self.actMoveNodeDown)
elif node.tag == "class_module":
menu.addAction(self.actChangeClassModule)
elif node.tag == "path_to_tool_modules":
menu.addAction(self.actChangePathToTools)
# "Tool library is a collection of tool groups
elif node.tag == "tool_library":
menu.addAction(self.actAddToolGroup)
# Tool groups are groups of "tool files"
elif node.tag == "tool_group":
menu.addAction(self.actAddToolFile)
if not isonly: menu.addSeparator()
if not istop: menu.addAction(self.actMoveNodeUp)
if not isbottom: menu.addAction(self.actMoveNodeDown)
# Param Template is the parameter node for the tools -- where
# users can build up a list of parameters that gets passed to the
# tool function
elif node.tag == "params":
menu.addAction(self.actAddParam)
elif node.tag == "param":
menu.addAction(self.actEditParam)
# A "tool config" is an alternative configuration for a tool that can be
# put in a Tool Set
elif node.tag == "tool_config":
menu.addAction(self.actExecToolConfig)
if not isonly: menu.addSeparator()
if not istop: menu.addAction(self.actMoveNodeUp)
if not isbottom: menu.addAction(self.actMoveNodeDown)
# "Tool sets" is a collection of multiple tool sets
elif node.tag == "tool_sets":
menu.addAction(self.actAddNewToolSet)
# A Tool set is a collection of (alternative) configurations for
# existing tools.
elif node.tag == "tool_set":
menu.addAction(self.actExecBatch)
menu.addSeparator()
menu.addAction(self.actNewConfig)
if not isonly: menu.addSeparator()
if not istop: menu.addAction(self.actMoveNodeUp)
if not isbottom: menu.addAction(self.actMoveNodeDown)
elif node.tag == "documentation_path":
menu.addAction(self.actOpenDocumentation)
menu.addSeparator()
menu.addAction(self.actCloneNode)
# Default menu items
self.add_default_menu_items_for_node(node, menu)
# Now add the export and import methods
menu.addSeparator()
menu.addAction(self.actExportXMLToFile)
menu.addAction(self.actImportXMLFromFile)
# Check if the menu has any elements before exec is called
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def _show_right_click_menu(self, point):
''' handler for the when users right click on table variables_table '''
index = self.variables_table.indexAt(point)
if not index.isValid:
return
self.variables_table.setCurrentIndex(index)
var = self.model.variables[index.row()]
menu = QMenu(self.variables_table)
# Edit variable action
p = ('edit', 'Edit %s' % var['name'], lambda x=var: self._edit_variable(x), self)
edit_action = create_qt_action(*p)
font = QFont()
font.setBold(True)
edit_action.setFont(font)
# Clone variable action
p = ('clone', 'Create new variable based on this', lambda x=var: self._add_variable(x), self)
clone_action = create_qt_action(*p)
def make_local(var = var):
if var['inherited']:
var['dirty'] = True
var['inherited'] = None
self.model.dirty = True
self._update_apply_button()
def delete_var(var = var):
self.model.delete_variable(var)
self._update_apply_button()
p = ('make_local', 'Make local', make_local, self)
make_local_action = create_qt_action(*p)
p = ('delete', 'Delete %s' % var['name'], delete_var, self)
delete_action = create_qt_action(*p)
p = ('revert', 'Revert %s to inherited' % var['name'], delete_var, self)
revert_action = create_qt_action(*p)
# check to see if we have graphviz installed
p = ('zoom', 'View dependencies', lambda x=var: self._view_dependencies(x), self)
view_dependencies_action = create_qt_action(*p)
if var['inherited']:
# menu.addAction(edit_action)
menu.addAction(make_local_action)
menu.addAction(clone_action)
menu.addSeparator()
menu.addAction(view_dependencies_action)
else:
menu.addAction(edit_action)
menu.addAction(clone_action)
menu.addSeparator()
# if the node in the table is local, but the original is inherited OR
# if the original node is shadowing an inherited node, allow user to 'revert'
# instead of 'delete'. Read more about prototype nodes in opus_project.py.
if var['originalnode'] is None:
menu.addAction(delete_action)
else:
prototype_node = self.project.get_prototype_node(var['originalnode'])
if var['originalnode'].get('inherited') or \
(prototype_node is not None and prototype_node.get('inherited')):
# This action will revert the node to the parent state. Show the values
# that it will revert to
tt = ('Revert %s to Name: %s, Definition: %s' % (var['name'],
prototype_node.get('name'),
prototype_node.text))
revert_action.setToolTip(tt)
menu.addAction(revert_action)
else:
menu.addAction(delete_action)
menu.addAction(view_dependencies_action)
# Menu constructed, present to user
if not menu.isEmpty():
menu.exec_(QCursor.pos())
def process_custom_menu(self, position):
""" See XmlConfig.processCustomMenu for documentation """
item = self.select_item_at(position)
index = self.view.indexAt(position)
cnt = self.model.rowCount(index.parent())
istop = index.row() == 0
isbottom = index.row() == cnt - 1
isonly = cnt == 1
if not item:
return
node = item.node
menu = QMenu(self.view)
# Tool files are the "actual" tools
if node.tag == "tool":
menu.addAction(self.actExecToolFile)
if not isonly:
menu.addSeparator()
if not istop:
menu.addAction(self.actMoveNodeUp)
if not isbottom:
menu.addAction(self.actMoveNodeDown)
elif node.tag == "class_module":
menu.addAction(self.actChangeClassModule)
elif node.tag == "path_to_tool_modules":
menu.addAction(self.actChangePathToTools)
# "Tool library is a collection of tool groups
elif node.tag == "tool_library":
menu.addAction(self.actAddToolGroup)
# Tool groups are groups of "tool files"
elif node.tag == "tool_group":
menu.addAction(self.actAddToolFile)
if not isonly:
menu.addSeparator()
if not istop:
menu.addAction(self.actMoveNodeUp)
if not isbottom:
menu.addAction(self.actMoveNodeDown)
# Param Template is the parameter node for the tools -- where
# users can build up a list of parameters that gets passed to the
# tool function
elif node.tag == "params":
menu.addAction(self.actAddParam)
elif node.tag == "param":
menu.addAction(self.actEditParam)
# A "tool config" is an alternative configuration for a tool that can be
# put in a Tool Set
elif node.tag == "tool_config":
menu.addAction(self.actExecToolConfig)
if not isonly:
menu.addSeparator()
if not istop:
menu.addAction(self.actMoveNodeUp)
if not isbottom:
menu.addAction(self.actMoveNodeDown)
# "Tool sets" is a collection of multiple tool sets
elif node.tag == "tool_sets":
menu.addAction(self.actAddNewToolSet)
# A Tool set is a collection of (alternative) configurations for
# existing tools.
elif node.tag == "tool_set":
menu.addAction(self.actExecBatch)
menu.addSeparator()
menu.addAction(self.actNewConfig)
if not isonly:
menu.addSeparator()
if not istop:
menu.addAction(self.actMoveNodeUp)
if not isbottom:
menu.addAction(self.actMoveNodeDown)
elif node.tag == "documentation_path":
menu.addAction(self.actOpenDocumentation)
menu.addSeparator()
menu.addAction(self.actCloneNode)
# Default menu items
self.add_default_menu_items_for_node(node, menu)
# Now add the export and import methods
menu.addSeparator()
menu.addAction(self.actExportXMLToFile)
menu.addAction(self.actImportXMLFromFile)
# Check if the menu has any elements before exec is called
if not menu.isEmpty():
menu.exec_(QCursor.pos())
