def init_analysis(self):
"""Setup analysis to make it ready to work.
.. note:: Copied or adapted from the dock
"""
self.analysis = Analysis()
# Impact Function
impact_function = self.impact_function_manager.get(
self.parent.selected_function()['id'])
impact_function.parameters = self.parent.if_params
self.analysis.impact_function = impact_function
# Layers
self.analysis.hazard = self.parent.hazard_layer
self.analysis.exposure = self.parent.exposure_layer
self.analysis.aggregation = self.parent.aggregation_layer
# TODO test if the implement aggregation layer works!
# Variables
self.analysis.clip_hard = self.clip_hard
self.analysis.show_intermediate_layers = self.show_intermediate_layers
viewport = viewport_geo_array(self.iface.mapCanvas())
self.analysis.viewport_extent = viewport
# Extent
if self.analysis.user_extent:
self.analysis.user_extent = self.extent.user_extent
self.analysis.user_extent_crs = self.extent.user_extent_crs
def analysis_setup(command_line_arguments, hazard, exposure, aggregation=None):
"""Sets up an analysis object.
.. versionadded:: 3.2
:param command_line_arguments: User inputs.
:type command_line_arguments: CommandLineArguments
:param hazard: Hazard layer
:type hazard: QgsLayer
:param exposure: Exposure Layer
:type exposure: QgsLayer
:param aggregation: Aggregation Layer
:type aggregation: QgsLayer
:raises: Exception
"""
# IF
impact_function_manager = ImpactFunctionManager()
impact_function = impact_function_manager.get(
command_line_arguments.impact_function)
keyword_io = KeywordIO()
try:
from safe.utilities.analysis import Analysis
except ImportError as ie:
LOGGER.debug('Import error for Analysis module')
print ie.message
raise ImportError
analysis = Analysis()
analysis.impact_function = impact_function
analysis.hazard = hazard
analysis.exposure = exposure
analysis.aggregation = aggregation
# analysis.hazard_keyword = keyword_io.read_keywords(hazard)
# analysis.exposure_keyword = keyword_io.read_keywords(exposure)
analysis.clip_hard = False
analysis.show_intermediate_layers = False
analysis.run_in_thread_flag = False
analysis.map_canvas = CANVAS
# QSetting context
settings = QSettings()
crs = settings.value('inasafe/analysis_extent_crs', '', type=str)
analysis.user_extent_crs = QgsCoordinateReferenceSystem(crs)
try:
analysis.user_extent = QgsRectangle(
float(command_line_arguments.extent[0]),
float(command_line_arguments.extent[1]),
float(command_line_arguments.extent[2]),
float(command_line_arguments.extent[3]))
except AttributeError:
print "No extents"
pass
analysis.setup_analysis()
return analysis
def analysis_execution():
from safe.test.utilities import get_qgis_app
# get_qgis_app must be called before importing Analysis
QGIS_APP, CANVAS, IFACE, PARENT = get_qgis_app()
from safe.utilities.analysis import Analysis
from safe.utilities.keyword_io import KeywordIO
analysis = Analysis()
arg = AnalysisArguments.read_arguments()
register_impact_functions()
registry = ImpactFunctionManager().registry
function = registry.get_instance(arg.impact_function_name)
hazard_layer = safe_to_qgis_layer(read_layer(arg.hazard_filename))
exposure_layer = safe_to_qgis_layer(read_layer(arg.exposure_filename))
if arg.aggregation_filename:
aggregation_layer = safe_to_qgis_layer(
read_layer(arg.aggregation_filename))
keywords_io = KeywordIO()
try:
analysis.map_canvas = IFACE.mapCanvas()
analysis.hazard_layer = hazard_layer
analysis.hazard_keyword = keywords_io.read_keywords(hazard_layer)
analysis.exposure_layer = exposure_layer
analysis.exposure_keyword = keywords_io.read_keywords(exposure_layer)
if aggregation_layer:
analysis.aggregation_layer = aggregation_layer
analysis.aggregation_keyword = keywords_io.read_keywords(
aggregation_layer)
analysis.impact_function = function
analysis.setup_analysis()
print 'Setup analysis done'
analysis.run_analysis()
print 'Analysis done'
except Exception as e:
print e.message
impact = analysis.impact_layer
qgis_impact = safe_to_qgis_layer(impact)
generate_styles(impact, qgis_impact)
copy_impact_layer(impact, arg.impact_filename)
def init_analysis(self):
"""Setup analysis to make it ready to work.
.. note:: Copied or adapted from the dock
"""
self.analysis = Analysis()
# Layers
self.analysis.hazard_layer = self.parent.hazard_layer
self.analysis.exposure_layer = self.parent.exposure_layer
self.analysis.aggregation_layer = self.parent.aggregation_layer
# TODO test if the implement aggregation layer works!
# noinspection PyTypeChecker
self.analysis.hazard_keyword = self.keyword_io.read_keywords(
self.parent.hazard_layer)
self.analysis.exposure_keyword = self.keyword_io.read_keywords(
self.parent.exposure_layer)
# Need to check since aggregation layer is not mandatory
if self.analysis.aggregation_layer:
self.analysis.aggregation_keyword = self.keyword_io.read_keywords(
self.parent.aggregation_layer)
# Impact Function
impact_function = self.impact_function_manager.get(
self.parent.selected_function()['id'])
impact_function.parameters = self.parent.if_params
self.analysis.impact_function = impact_function
# Variables
self.analysis.clip_hard = self.clip_hard
self.analysis.show_intermediate_layers = self.show_intermediate_layers
self.analysis.run_in_thread_flag = self.run_in_thread_flag
self.analysis.map_canvas = self.iface.mapCanvas()
# Extent
if self.parent.rbExtentUser.isChecked():
self.analysis.user_extent = self.extent.user_extent
else:
self.analysis.user_extent = None
self.analysis.user_extent_crs = self.extent.user_extent_crs
self.analysis.clip_to_viewport = self.parent.rbExtentScreen.isChecked()
def test_clip_both(self):
"""Raster and Vector layers can be clipped."""
# Create a vector layer
layer_name = 'padang'
vector_layer = QgsVectorLayer(VECTOR_PATH, layer_name, 'ogr')
message = ('Did not find layer "%s" in path "%s"' %
(layer_name, VECTOR_PATH))
assert vector_layer.isValid(), message
# Create a raster layer
layer_name = 'shake'
raster_layer = QgsRasterLayer(RASTERPATH, layer_name)
message = ('Did not find layer "%s" in path "%s"' %
(layer_name, RASTERPATH))
assert raster_layer.isValid(), message
# Create a bounding box
view_port_geo_extent = [99.53, -1.22, 101.20, -0.36]
# Get the Hazard extents as an array in EPSG:4326
hazard_geo_extent = [
raster_layer.extent().xMinimum(),
raster_layer.extent().yMinimum(),
raster_layer.extent().xMaximum(),
raster_layer.extent().yMaximum()
]
# Get the Exposure extents as an array in EPSG:4326
exposure_geo_extent = [
vector_layer.extent().xMinimum(),
vector_layer.extent().yMinimum(),
vector_layer.extent().xMaximum(),
vector_layer.extent().yMaximum()
]
# Now work out the optimal extent between the two layers and
# the current view extent. The optimal extent is the intersection
# between the two layers and the viewport.
# Extent is returned as an array [xmin,ymin,xmax,ymax]
analysis = Analysis()
geo_extent = analysis.get_optimal_extent(hazard_geo_extent,
exposure_geo_extent,
view_port_geo_extent)
# Clip the vector to the bbox
result = clip_layer(vector_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# Clip the raster to the bbox
result = clip_layer(raster_layer, geo_extent)
# Check the output is valid
assert os.path.exists(result.source())
read_safe_layer(result.source())
# -------------------------------
# Check the extra keywords option
# -------------------------------
# Clip the vector to the bbox
result = clip_layer(vector_layer,
geo_extent,
extra_keywords={'kermit': 'piggy'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
# message = 'Extra keyword was not found in %s: %s' % (myResult,
# keywords)
assert keywords['kermit'] == 'piggy'
# Clip the raster to the bbox
result = clip_layer(raster_layer,
geo_extent,
extra_keywords={'zoot': 'animal'})
# Check the output is valid
assert os.path.exists(result.source())
safe_layer = read_safe_layer(result.source())
keywords = safe_layer.get_keywords()
message = ('Extra keyword was not found in %s: %s' %
(result.source(), keywords))
assert keywords['zoot'] == 'animal', message
def setUp(self):
self.analysis = Analysis()