def build_exposure_steps(self):
""" building exposure database from workflow """
if not self.workflow.ready:
raise SIDDException(
'Cannot create exposure with current datasets. Please revise input'
)
if not self.ms.is_valid:
raise SIDDException('Current mapping scheme is not valid')
for zone in self.ms.zones:
zone.stats.refresh_leaves(with_modifier=True,
order_attributes=True)
if getattr(self, 'exposure', None) is not None:
del self.exposure
remove_shapefile(self.exposure_file)
for op in self.workflow.nextstep():
yield op
# when all steps are completed, set resulting exposure
self.exposure = self.workflow.operator_data['exposure'].value
self.exposure_file = self.workflow.operator_data['exposure_file'].value
if self.workflow.operator_data.has_key('exposure_grid'):
self.exposure_grid = self.workflow.operator_data[
'exposure_grid'].value
logAPICall.log('exposure data created %s' % self.exposure_file,
logAPICall.INFO)
def export_data(self):
""" export exposure data """
builder = WorkflowBuilder(self.operator_options)
try:
export_workflow = builder.build_export_workflow(self)
except WorkflowException as err:
raise SIDDException(
"error creating workflow for exporting data\n%s" % err)
try:
# process workflow
export_workflow.process()
logAPICall.log('data export completed', logAPICall.INFO)
except Exception as err:
raise SIDDException("error exporting data\n" % err)
def build_ms(self):
""" build mapping scheme from survey data """
# make sure survey exists
if (self.survey_type == SurveyTypes.None):
raise SIDDException(
'survey is required for creating mapping scheme')
# try to create ms using random
try:
use_sampling = self.operator_options['stratified.sampling']
return self.do_build_ms(isEmpty=False, useSampling=use_sampling)
except Exception as err:
self.create_empty_ms()
raise SIDDException('Unable to create Mapping Scheme:%s' %
str(err))
def verify_result(self):
"""
run data quality tests
"""
builder = WorkflowBuilder(self.operator_options)
try:
verify_workflow = builder.build_verify_result_workflow(self)
except WorkflowException as err:
raise SIDDException(
"error creating workflow for result verification\n%s" % err)
# process workflow
for step in verify_workflow.nextstep():
try:
step.do_operation()
except Exception as err:
logAPICall.log(err, logAPICall.WARNING)
pass
self.quality_reports = {}
if verify_workflow.operator_data.has_key('frag_report'):
self.quality_reports[
'fragmentation'] = verify_workflow.operator_data[
'frag_report'].value
if verify_workflow.operator_data.has_key('count_report'):
self.quality_reports['count'] = verify_workflow.operator_data[
'count_report'].value
try:
if self.zone_type == ZonesTypes.LanduseCount and self.output_type == OutputTypes.Grid:
self.quality_reports['count']['_note'] = ''
except:
pass
logAPICall.log('result verification completed', logAPICall.INFO)
def setData(self, index, value, role):
""" set data modified by cell edit """
if role == Qt.EditRole:
if (index.column() == 0):
# first column, change value
taxStr = str(value.toString())
# make sure there is no repeat
try:
self.values.index(taxStr)
# no error means taxStr already in self.value
found = True
except:
found = False
if found:
raise SIDDException(get_ui_string("dlg.msbranch.error.attribute.exists") % taxStr)
# do nothing for empty string
if taxStr == "":
return False
# verify taxonomy
# passed all checks. set value
self.values[index.row()] = taxStr
else:
# second column, change weight
(dVal, sucess) = value.toDouble()
# conversion to double failed
if not sucess:
raise SIDDException(get_ui_string("dlg.msbranch.edit.warning.invalidweight"))
# make sure 0 <= dVal <= 100
if dVal < 0 or dVal > 100:
raise SIDDException(get_ui_string("dlg.msbranch.edit.warning.invalidweight"))
# passed all checks. set value
self.weights[index.row()] = round(dVal, 1)
self.dataChanged.emit(self.createIndex(0, 0), self.createIndex(self.rowCount(0),self.columnCount(0)))
return True
return False
def delete_branch(self, node):
""" delete branch from mapping scheme tree """
# for MappingSchemeZone delete entire stats tree
# for StaticticNode delete node
if isinstance(node, MappingSchemeZone):
for zone in self.zones:
if zone == node: # found
taxonomy = zone.stats.taxonomy
del zone.stats
# create new empty tree
zone.stats = Statistics(taxonomy)
zone.stats.finalize()
zone.stats.name = zone.name
return
elif isinstance(node, StatisticNode):
for zone in self.zones: # found
if zone.stats.has_node(node):
zone.stats.delete_branch(node)
return
# node not correct type or not found in tree
raise SIDDException('given node does not belong to mapping scheme')
def append_branch(self, node, branch):
""" append a branch (from library) to a node in a mapping scheme tree """
stat_tree = None
if type(node) == MappingSchemeZone:
# selected node is zone
# retrieve root node from stats tree
stat_tree = self.get_assignment(node)
node_to_attach = node.stats.get_tree()
else:
node_to_attach = node
stat_tree = self.get_assignment_by_node(node_to_attach)
if stat_tree is None:
raise SIDDException(
'selected node does not belong to mapping scheme')
# add branch as child
if type(branch) == MappingSchemeZone:
# branch starts from zone node, so it is a full stats tree
# add only the child nodes
logAPICall.log('branch is zone, add children', logAPICall.DEBUG_L2)
# test to make sure append is valid
# exception will be thrown is case of error
for child in branch.stats.get_tree().children:
stat_tree.test_repeated_attribute(node_to_attach, child)
stat_tree.test_repeated_value(node_to_attach, child)
for child in branch.stats.get_tree().children:
stat_tree.add_branch(node_to_attach,
child,
test_repeating=False,
update_stats=False)
node_to_attach.balance_weights()
else:
# branch is from a tree
# add branch as child node
logAPICall.log('branch is node, add branch', logAPICall.DEBUG_L2)
stat_tree.add_branch(node_to_attach, branch)
def export_ms(self, path, export_format):
"""
export mapping scheme according to given format
see constants.MSExportTypes for type supported
"""
if self.ms is None:
raise SIDDException('Mapping Scheme is required for this action')
builder = WorkflowBuilder(self.operator_options)
try:
if export_format == MSExportTypes.XML:
export_workflow = builder.build_export_ms_workflow(self, path)
else:
export_workflow = builder.build_export_distribution_workflow(
self, path)
export_workflow.process()
logAPICall.log('data export completed', logAPICall.INFO)
except WorkflowException:
return False
except Exception as err:
logAPICall.log(err, logAPICall.ERROR)
return False
def do_build_ms(self, isEmpty=False, useSampling=False):
""" create mapping scheme """
builder = WorkflowBuilder(self.operator_options)
# force reload existing survey
self.survey = None
# create workflow
if useSampling:
ms_workflow = builder.build_sampling_ms_workflow(self)
else:
ms_workflow = builder.build_ms_workflow(self, isEmpty)
if not ms_workflow.ready:
raise SIDDException(ms_workflow.errors)
# process workflow
ms_workflow.process()
self.ms = ms_workflow.operator_data['ms'].value
if useSampling:
self.zone_stats = ms_workflow.operator_data['zone_stats'].value
for zone, stats in self.ms.assignments():
stats.refresh_leaves()
logAPICall.log('mapping scheme created', logAPICall.INFO)
self.require_save = True
def build_exposure_total_steps(self):
if not self.workflow.ready:
raise SIDDException('exposure workflow not complete')
return self.workflow.steps()