def help_blur():
title = tr('Blurring')
intro = tr('Plugin to blur point data, such as health personal data, and '
'get some statistics about this blurring.')
inputs = [
tr('Point layer'),
tr('Radius'),
tr('Enveloppe : The layer will force the algorithm to have an '
'intersection between the centroid and this layer. This is like a '
'mask.')
]
outputs = [
tr('Blurred layer (polygon)')
]
more = [
tr('1 : Creating a buffer (radius r)'),
picture('blurring_1.png'),
tr('2 : Random selection of a point in each buffer'),
picture('blurring_2.png'),
tr('3 : Creating a buffer around the new point with the same radius. '
'The initial point is at a maximal distance 2r of the centroid of '
'the buffer.'),
picture('blurring_3.png'),
tr('4 : Deleting the random point and the first buffer'),
picture('blurring_4.png'),
]
html = html_table(title, intro, inputs, outputs, more)
return html
def help_open_xy():
title = tr('Import CSV table')
intro = tr('CSV format with geometry.')
inputs = [
tr('CSV file')
]
outputs = [
tr('New layer')
]
more = [
]
html = html_table(title, intro, inputs, outputs, more)
return html
def help_attribute_table():
title = tr('Export attribute table')
intro = tr('Export as CSV format without geometry.')
inputs = [
tr('Vector layer')
]
outputs = [
tr('A new CSV file')
]
more = [
]
html = html_table(title, intro, inputs, outputs, more)
return html
def help_open_table():
title = tr('Import table')
intro = tr('XLS or DBF format.')
inputs = [
tr('Table file')
]
outputs = [
tr('New table')
]
more = [
]
html = html_table(title, intro, inputs, outputs, more)
return html
def help_open_raster():
title = tr('Import raster')
intro = tr('Import a raster into QGIS.')
inputs = [
tr('Raster file')
]
outputs = [
tr('New layer')
]
more = [
]
html = html_table(title, intro, inputs, outputs, more)
return html
def help_open_shapefile():
title = tr('Import shapefile')
intro = tr('Import a shapefile into QGIS.')
inputs = [
tr('Shapefile')
]
outputs = [
tr('New layer')
]
more = [
]
html = html_table(title, intro, inputs, outputs, more)
return html
def help_export_kml():
title = tr('Export KML')
intro = tr('Export a vector layer as KML')
inputs = [
tr('Choose a vector layer')
]
outputs = [
tr('Choose a path and name to store the KML file')
]
more = [
]
html = html_table(title, intro, inputs, outputs, more)
return html
def save_csv(self):
path = self.le_output.text()
layer = self.cbx_layer.currentLayer()
if self.tab_delimiter.isChecked():
delimiter = self.delimiters['tab']
elif self.pipe_delimiter.isChecked():
delimiter = self.delimiters['pipe']
elif self.semicolon_delimiter.isChecked():
delimiter = self.delimiters['semicolon']
else:
delimiter = self.delimiters['comma']
csv_file = codecs.open(path, 'w', 'utf-8')
provider = layer.dataProvider()
fields = provider.fieldNameMap()
header = u'%s\n' % delimiter.join(fields)
csv_file.write(header)
for feature in layer.getFeatures():
attributes = feature.attributes()
line = u'%s\n' % delimiter.join([unicode(i) for i in attributes])
csv_file.write(line)
csv_file.close()
self.signalStatus.emit(3, tr('Successful export to %s' % path))
def open_file_browser(self):
# noinspection PyArgumentList
output_file = QFileDialog.getSaveFileNameAndFilter(
parent=self.parent,
caption=tr('Export as CSV'),
filter='CSV (*.csv)')
self.le_output.setText(output_file[0])
def save_y_values(self):
if not self.tableWidget.rowCount():
return False
csv_string = 'parameter,values\n'
for value in self.tab:
csv_string += str(value) + '\n'
last_directory = get_last_input_path()
# noinspection PyArgumentList
output_file, __ = QFileDialog.getSaveFileName(
parent=self,
caption=tr('Select file'),
directory=last_directory,
filter='CSV (*.csv)')
if output_file:
path = dirname(output_file)
set_last_input_path(path)
fh = open(output_file, 'w')
fh.write(csv_string)
fh.close()
return True
def save_table(self):
if not self.tableWidget.rowCount():
return False
csv_string = 'parameter,values\n'
for i in range(self.tableWidget.rowCount()):
item_param = self.tableWidget.item(i, 0)
item_value = self.tableWidget.item(i, 1)
csv_string += \
str(item_param.text()) + ',' + item_value.text() + '\n'
last_directory = get_last_input_path()
# noinspection PyArgumentList
output_file, __ = QFileDialog.getSaveFileName(
parent=self,
caption=tr('Select file'),
directory=last_directory,
filter='CSV (*.csv)')
if output_file:
path = dirname(output_file)
set_last_input_path(path)
fh = open(output_file, 'w')
fh.write(csv_string)
fh.close()
return True
def add_layer(self, layer, layer_name):
"""Add a layer to the datastore.
:param layer: The layer to add.
:type layer: QgsMapLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if self._use_index:
layer_name = '%s-%s' % (self._index, layer_name)
self._index += 1
if self.layer_uri(layer_name):
return False, tr('The layer already exists in the datastore.')
if isinstance(layer, QgsRasterLayer):
result = self._add_raster_layer(layer, layer_name)
else:
if layer.wkbType() == QGis.WKBNoGeometry:
result = self._add_tabular_layer(layer, layer_name)
else:
result = self._add_vector_layer(layer, layer_name)
return result
def open_file_browser(self):
# noinspection PyArgumentList
shapefile, __ = QFileDialog.getOpenFileName(
parent=self.parent,
caption=tr('Select table'),
filter='Table (*.xls *.xlsx *.dbf)')
self.le_shapefile.setText(shapefile)
def save_y_values(self):
if not self.tableWidget.rowCount():
return False
csv_string = 'parameter,values\n'
for value in self.tab:
csv_string += str(value) + '\n'
last_directory = get_last_input_path()
# noinspection PyArgumentList
output_file = QFileDialog.getSaveFileName(
parent=self,
caption=tr('Select file'),
directory=last_directory,
filter='CSV (*.csv)')
if output_file:
path = dirname(output_file)
set_last_input_path(path)
fh = open(output_file, 'w')
fh.write(csv_string)
fh.close()
return True
def open_file_browser(self):
# noinspection PyArgumentList
shapefile = QFileDialog.getOpenFileName(
parent=self.parent,
caption=tr('Select shapefile'),
filter='Shapefile (*.shp)')
self.le_shapefile.setText(shapefile)
def add_layer(self, layer, layer_name):
"""Add a layer to the datastore.
:param layer: The layer to add.
:type layer: QgsMapLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if self._use_index:
layer_name = '%s-%s' % (self._index, layer_name)
self._index += 1
if self.layer_uri(layer_name):
return False, tr('The layer already exists in the datastore.')
if isinstance(layer, QgsRasterLayer):
result = self._add_raster_layer(layer, layer_name)
else:
if layer.wkbType() == Qgis.WKBNoGeometry:
result = self._add_tabular_layer(layer, layer_name)
else:
result = self._add_vector_layer(layer, layer_name)
return result
def open_file_browser(self):
# noinspection PyArgumentList
output_file, __ = QFileDialog.getSaveFileName(
parent=self.parent,
caption=tr('Export as KML'),
filter='KML (*.kml)')
self.le_output.setText(output_file[0])
def save_table(self):
if not self.tableWidget.rowCount():
return False
csv_string = 'parameter,values\n'
for i in range(self.tableWidget.rowCount()):
item_param = self.tableWidget.item(i, 0)
item_value = self.tableWidget.item(i, 1)
csv_string += \
str(item_param.text()) + ',' + item_value.text() + '\n'
last_directory = get_last_input_path()
# noinspection PyArgumentList
output_file = QFileDialog.getSaveFileName(
parent=self,
caption=tr('Select file'),
directory=last_directory,
filter='CSV (*.csv)')
if output_file:
path = dirname(output_file)
set_last_input_path(path)
fh = open(output_file, 'w')
fh.write(csv_string)
fh.close()
return True
def save_csv(self):
path = self.le_output.text()
layer = self.cbx_layer.currentLayer()
if self.tab_delimiter.isChecked():
delimiter = self.delimiters['tab']
elif self.pipe_delimiter.isChecked():
delimiter = self.delimiters['pipe']
elif self.semicolon_delimiter.isChecked():
delimiter = self.delimiters['semicolon']
else:
delimiter = self.delimiters['comma']
csv_file = codecs.open(path, 'w', 'utf-8')
provider = layer.dataProvider()
fields = provider.fieldNameMap()
header = u'%s\n' % delimiter.join(fields)
csv_file.write(header)
for feature in layer.getFeatures():
attributes = feature.attributes()
line = u'%s\n' % delimiter.join([str(i) for i in attributes])
csv_file.write(line)
csv_file.close()
self.signalStatus.emit(3, tr('Successful export to %s' % path))
def open_raster(self):
path = self.le_shapefile.text()
file_info = QFileInfo(path)
layer = QgsRasterLayer(path, file_info.baseName())
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayer(layer)
self.signalStatus.emit(3, tr('Successful import from %s' % path))
def open_raster(self):
path = self.le_shapefile.text()
file_info = QFileInfo(path)
layer = QgsRasterLayer(path, file_info.baseName())
# noinspection PyArgumentList
QgsProject.instance().addMapLayer(layer)
self.signalStatus.emit(3, tr('Successful import from %s' % path))
def open_file_browser(self):
# noinspection PyArgumentList
raster_filter = QgsProviderRegistry.instance().fileRasterFilters()
# noinspection PyArgumentList
raster, __ = QFileDialog.getOpenFileName(parent=self.parent,
caption=tr('Select raster'),
filter=raster_filter)
self.le_shapefile.setText(raster)
def help_incidence_point():
title = tr('Incidence with case layer')
intro = tr('You can create an incidence map about a disease.')
inputs = [
tr('Point layer : disease'),
tr('Polygon layer : administrative boundary with a population field'),
tr('Population field'),
tr('Ratio'),
tr('New column')
]
outputs = [
tr('New polygon layer with the incidence')
]
more = [
tr('This algorithm will count the number of points inside each '
'polygons and run a formula to get the incidence.'),
tr('number of cases / population * ratio')
]
html = html_table(title, intro, inputs, outputs, more)
return html
def open_table(self):
path = self.le_shapefile.text()
if not path:
return
name = basename(splitext(path)[0])
layer = QgsVectorLayer(path, name, 'ogr')
# noinspection PyArgumentList
QgsProject.instance().addMapLayer(layer)
self.signalStatus.emit(3, tr('Successful import from %s' % path))
def open_file_browser(self):
# noinspection PyArgumentList
raster_filter = QgsProviderRegistry.instance().fileRasterFilters()
# noinspection PyArgumentList
raster = QFileDialog.getOpenFileName(
parent=self.parent,
caption=tr('Select raster'),
filter=raster_filter)
self.le_shapefile.setText(raster)
def open_shapefile(self):
path = self.le_shapefile.text()
if not path:
return
name = basename(splitext(path)[0])
layer = QgsVectorLayer(path, name, 'ogr')
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayer(layer)
self.signalStatus.emit(3, tr('Successful import from %s' % path))
def help_density():
title = tr('Density')
intro = tr('Compute density')
inputs = [
tr('Point layer : disease'),
tr('Polygon layer : administrative boundary'),
tr('Case field'),
tr('Ratio'),
tr('New column')
]
outputs = [
tr('New polygon layer with the density')
]
more = [
tr('This algorithm will count the number of points inside each '
'polygons and run a formula to get the density.'),
tr('number of cases / area * ratio')
]
html = html_table(title, intro, inputs, outputs, more)
return html
def select_file(self):
last_folder = get_last_input_path()
# noinspection PyArgumentList
output_file = QFileDialog.getSaveFileName(
parent=self,
caption=tr('Select file'),
directory=last_folder,
filter='Shapefiles (*.shp)')
if output_file:
self.lineEdit_outputFile.setText(output_file)
path = dirname(output_file)
set_last_input_path(path)
else:
self.lineEdit_outputFile.setText('')
def select_file(self):
last_folder = get_last_input_path()
# noinspection PyArgumentList
output_file, __ = QFileDialog.getSaveFileName(
parent=self,
caption=tr('Select file'),
directory=last_folder,
filter='Shapefiles (*.shp)')
if output_file:
self.lineEdit_outputFile.setText(output_file)
path = dirname(output_file)
set_last_input_path(path)
else:
self.lineEdit_outputFile.setText('')
def help_composite_index():
title = tr('Composite Index')
intro = tr('You can create an Unmet Health Index Map using several indicators.')
inputs = [
tr('Polygon layer : administrative boundary with the indicators fields'),
tr('Indicators field'),
tr('New column')
]
outputs = [
tr('New polygon layer with the Unmet Health Index ')
]
more = [
tr('This algorithm will use the Z-scores for each selected indicator to have a Composite index'),
tr('Please be sure to check the vector direction for each Indicator')
]
html = html_table(title, intro, inputs, outputs, more)
return html
def __init__(self, parent=None):
self.parent = parent
super(OpenCsv, self).__init__()
mdi_area = QMdiArea()
# noinspection PyArgumentList
dialog = QgsProviderRegistry.instance().selectWidget('delimitedtext')
dialog.setWindowTitle(tr('Open a CSV'))
layout = QVBoxLayout(self)
layout.addWidget(mdi_area)
mdi_area.addSubWindow(dialog)
dialog.addVectorLayer[str, str, str].connect(self.success)
dialog.rejected.connect(self.signalAskCloseWindow.emit)
def help_stats_blurring():
title = tr('Stats')
intro = tr('With two layers, the plugin will count the number of '
'intersections between them and produces some stats.')
inputs = [
tr('Blurred layer'),
tr('Stats layer : buildings for instanceon layer : administrative '
'boundary')]
outputs = [
tr('New polygon layer with the density')
]
more = [
tr('This is usefull if you want to rate your blurring.'),
]
html = html_table(title, intro, inputs, outputs, more)
return html
def run_stats(self):
"""Main function which do the process."""
# Get the common fields.
self.admin_layer = self.cbx_aggregation_layer.currentLayer()
selected_indicators = self.indicators_list()
if not self.name_field:
self.name_field = self.le_new_column.placeholderText()
# Output.
self.output_file_path = self.le_output_filepath.text()
try:
self.button_box_ok.setDisabled(True)
# noinspection PyArgumentList
QApplication.setOverrideCursor(Qt.WaitCursor)
# noinspection PyArgumentList
QApplication.processEvents()
if not self.admin_layer:
raise NoLayerProvidedException
if not self.admin_layer and self.use_point_layer:
raise NoLayerProvidedException
crs_admin_layer = self.admin_layer.crs()
if not self.use_point_layer and not self.use_area:
if not self.cbx_list_indicators:
raise FieldException(
field_1='List Indicators should not empty')
# Output
if not self.output_file_path:
temp_file = NamedTemporaryFile(delete=False,
suffix='-geopublichealth.shp')
self.output_file_path = temp_file.name
temp_file.flush()
temp_file.close()
admin_layer_provider = self.admin_layer.dataProvider()
fields = self.admin_layer.fields()
if admin_layer_provider.fields().indexFromName(
self.name_field) != -1:
raise FieldExistingException(field=self.name_field)
for indicator_selected in selected_indicators:
fields.append(
QgsField("Z" + indicator_selected[0], QVariant.Double))
fields.append(QgsField(self.name_field, QVariant.Double))
file_writer = QgsVectorFileWriter(self.output_file_path, 'utf-8',
fields, QgsWkbTypes.Polygon,
self.admin_layer.crs(),
'ESRI Shapefile')
count = self.admin_layer.featureCount()
stats = {}
for indicator_selected in selected_indicators:
values = []
indicator_selected_name = str(indicator_selected[0])
for i, feature in enumerate(self.admin_layer.getFeatures()):
index = self.admin_layer.fields().indexFromName(
indicator_selected_name)
if feature[index]:
value = float(feature[index])
else:
value = 0.0
values.append(value)
stats[indicator_selected_name] = Stats(values)
for i, feature in enumerate(self.admin_layer.getFeatures()):
attributes = feature.attributes()
composite_index_value = 0.0
for indicator_selected in selected_indicators:
indicator_selected_name = str(indicator_selected[0])
index = self.admin_layer.fields().indexFromName(
indicator_selected_name)
if feature[index]:
value = float(feature[index])
else:
value = 0.0
zscore = (value - stats[indicator_selected_name].average(
)) / stats[indicator_selected_name].standard_deviation()
attributes.append(float(zscore))
if indicator_selected[1] == '+':
composite_index_value -= zscore
else:
composite_index_value += zscore
attributes.append(float(composite_index_value))
new_feature = QgsFeature()
new_geom = QgsGeometry(feature.geometry())
new_feature.setAttributes(attributes)
new_feature.setGeometry(new_geom)
file_writer.addFeature(new_feature)
del file_writer
self.output_layer = QgsVectorLayer(self.output_file_path,
self.name_field, 'ogr')
QgsProject.instance().addMapLayer(self.output_layer)
if self.symbology.isChecked():
self.add_symbology()
self.signalStatus.emit(3, tr('Successful process'))
except GeoPublicHealthException as e:
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
finally:
self.button_box_ok.setDisabled(False)
# noinspection PyArgumentList
QApplication.restoreOverrideCursor()
# noinspection PyArgumentList
QApplication.processEvents()
def open_file_browser(self):
output_file, __ = QFileDialog.getSaveFileName(self.parent,
tr('Save shapefile'),
filter='SHP (*.shp)')
self.le_output_filepath.setText(output_file[0])
def run_stats(self):
self.progressBar_stats.setValue(0)
self.label_progressStats.setText('')
# noinspection PyArgumentList
QApplication.processEvents()
blurred_layer = self.comboBox_blurredLayer.currentLayer()
stats_layer = self.comboBox_statsLayer.currentLayer()
try:
if not blurred_layer or not stats_layer:
raise NoLayerProvidedException
crs_blurred_layer = blurred_layer.crs()
crs_stats_layer = stats_layer.crs()
if crs_blurred_layer != crs_stats_layer:
raise DifferentCrsException(
epsg1=crs_blurred_layer.authid(),
epsg2=crs_stats_layer.authid())
if blurred_layer == stats_layer:
raise NoLayerProvidedException
if not blurred_layer or not stats_layer:
raise NoLayerProvidedException
nb_feature_stats = stats_layer.featureCount()
nb_feature_blurred = blurred_layer.featureCount()
features_stats = {}
label_preparing = tr('Preparing index on the stats layer')
label_creating = tr('Creating index on the stats layer')
label_calculating = tr('Calculating')
if QGis.QGIS_VERSION_INT < 20700:
self.label_progressStats.setText('%s 1/3' % label_preparing)
for i, feature in enumerate(stats_layer.getFeatures()):
features_stats[feature.id()] = feature
percent = int((i + 1) * 100 / nb_feature_stats)
self.progressBar_stats.setValue(percent)
# noinspection PyArgumentList
QApplication.processEvents()
self.label_progressStats.setText('%s 2/3' % label_creating)
# noinspection PyArgumentList
QApplication.processEvents()
index = QgsSpatialIndex()
for i, f in enumerate(stats_layer.getFeatures()):
index.insertFeature(f)
percent = int((i + 1) * 100 / nb_feature_stats)
self.progressBar_stats.setValue(percent)
# noinspection PyArgumentList
QApplication.processEvents()
self.label_progressStats.setText('%s 3/3' % label_calculating)
else:
# If QGIS >= 2.7, we can speed up the spatial index.
# From 1 min 15 to 7 seconds on my PC.
self.label_progressStats.setText('%s 1/2' % label_creating)
# noinspection PyArgumentList
QApplication.processEvents()
index = QgsSpatialIndex(stats_layer.getFeatures())
self.label_progressStats.setText('%s 2/2' % label_calculating)
# noinspection PyArgumentList
QApplication.processEvents()
self.tab = []
for i, feature in enumerate(blurred_layer.getFeatures()):
count = 0
ids = index.intersects(feature.geometry().boundingBox())
for unique_id in ids:
request = QgsFeatureRequest().setFilterFid(unique_id)
f = stats_layer.getFeatures(request).next()
if f.geometry().intersects(feature.geometry()):
count += 1
self.tab.append(count)
percent = int((i + 1) * 100 / nb_feature_blurred)
self.progressBar_stats.setValue(percent)
# noinspection PyArgumentList
QApplication.processEvents()
stats = Stats(self.tab)
items_stats = [
'Count(blurred),%d' % nb_feature_blurred,
'Count(stats),%d' % nb_feature_stats,
'Min,%d' % stats.min(),
'Average,%f' % stats.average(),
'Max,%d' % stats.max(), 'Median,%f' % stats.median(),
'Range,%d' % stats.range(),
'Variance,%f' % stats.variance(),
'Standard deviation,%f' % stats.standard_deviation()
]
self.tableWidget.clear()
self.tableWidget.setColumnCount(2)
labels = ['Parameters', 'Values']
self.tableWidget.setHorizontalHeaderLabels(labels)
self.tableWidget.setRowCount(len(items_stats))
for i, item in enumerate(items_stats):
s = item.split(',')
self.tableWidget.setItem(i, 0, QTableWidgetItem(s[0]))
self.tableWidget.setItem(i, 1, QTableWidgetItem(s[1]))
self.tableWidget.resizeRowsToContents()
self.draw_plot(self.tab)
except GeoPublicHealthException, e:
self.label_progressStats.setText('')
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
def __init__(self, msg=None, suffix=None):
if not msg:
msg = tr(u'It\'s not a number')
if suffix:
msg += " : %s" % suffix
GeoPublicHealthException.__init__(self, msg)
def help_autocorrelation():
title = tr('Autocorrelation')
intro = tr('Local Moran / LISA')
inputs = [
tr('Polygon layer : administrative boundary with the indicators fields'),
tr('Field: for calculating the LISA (Local Moran)'),
tr('Contiguity: Contiguity Based Weights criteria "Rook" (takes as neighbors any pair of cells that share an edge) or "Queen" (include the vertices of the lattice to define contiguitie)'),
tr('Output: the shapefile were the calcultaions will be available')
]
outputs = [
tr('New polygon layer with:'),
tr('LISA_P = pseudo p-values for each LISA'),
tr('LISA_Z = standardized Moran\'s I for each LISA based on permutations'),
tr('LISA_Q = values or each LISA indicate quandrant location 1 HH, 2 LH, 3 LL, 4 HL'),
tr('LISA_I = local Moran\’s I values for each LISA'),
tr('LISA_C = significance level ')
]
more = [
tr('Local Moran\'s I measures local autocorrelation quantitatively which results in n values of local spatial autocorrelation, one for each spatial unit.'),
]
html = html_table(title, intro, inputs, outputs, more)
return html
def __init__(self, msg=None, field_1=None, field_2=None):
if not msg:
msg = tr(u'Fields are not different')
if field_1 and field_2:
msg += " : %s and %s " % (field_1, field_2)
GeoPublicHealthException.__init__(self, msg)
def run_blur(self):
self.progressBar_blur.setValue(0)
self.label_progress.setText('')
# Get all the fields.
layer_to_blur = self.comboBox_layerToBlur.currentLayer()
radius = self.spinBox_radius.value()
display = self.checkBox_addToMap.isChecked()
selected_features_only = self.checkBox_selectedOnlyFeatures.isChecked()
file_name = self.lineEdit_outputFile.text()
export_radius = self.checkBox_exportRadius.isChecked()
export_centroid = self.checkBox_exportCentroid.isChecked()
if self.checkBox_envelope.isChecked():
layer_envelope = self.comboBox_envelope.currentLayer()
else:
layer_envelope = None
# Test values
try:
if not layer_to_blur:
raise NoLayerProvidedException
if not file_name and not display:
raise NoFileNoDisplayException
if layer_to_blur.crs().mapUnits() != 0:
msg = tr('The projection of the map or of the layer is not '
'in meters. These parameters should be in meters.')
display_message_bar(
msg, level=QgsMessageBar.WARNING, duration=5)
if not file_name:
file_name = getTempFilenameInTempFolder('blurring.shp')
pass
if layer_envelope:
if layer_to_blur.crs() != layer_envelope.crs():
raise DifferentCrsException(
epsg1=layer_to_blur.crs().authid(),
epsg2=layer_envelope.crs().authid())
self.label_progress.setText('Creating index ...')
layer_envelope = LayerIndex(layer_envelope)
self.progressBar_blur.setValue(0)
self.label_progress.setText('Blurring ...')
if selected_features_only:
features = layer_to_blur.selectedFeatures()
nb_features = layer_to_blur.selectedFeatureCount()
else:
features = layer_to_blur.getFeatures()
nb_features = layer_to_blur.featureCount()
# Fields
fields = layer_to_blur.pendingFields()
if export_radius:
fields.append(QgsField(u"Radius", QVariant.Int))
if export_centroid:
fields.append(QgsField(u"X centroid", QVariant.Int))
fields.append(QgsField(u"Y centroid", QVariant.Int))
# Creating the output shapefile
file_writer = QgsVectorFileWriter(
file_name,
'utf-8',
fields,
QGis.WKBPolygon,
layer_to_blur.crs(),
'ESRI Shapefile')
if file_writer.hasError() != QgsVectorFileWriter.NoError:
raise CreatingShapeFileException(suffix=file_writer.hasError())
# Creating the algorithm with radius
algo = Blur(radius, layer_envelope, export_radius, export_centroid)
for j, feature in enumerate(features):
feature = algo.blur(feature)
file_writer.addFeature(feature)
# Update progress bar
percent = int((j + 1) * 100 / nb_features)
self.progressBar_blur.setValue(percent)
# Write all features in the file
del file_writer
if display:
old_default_projection = self.settings.value(
'/Projections/defaultBehaviour')
self.settings.setValue(
'/Projections/defaultBehaviour', 'useProject')
layer_name = basename(file_name)
new_layer = QgsVectorLayer(file_name, layer_name, 'ogr')
new_layer.commitChanges()
new_layer.clearCacheImage()
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayers([new_layer])
self.settings.setValue(
'/Projections/defaultBehaviour', old_default_projection)
msg = tr('Successful export in %s' % file_name)
iface.messageBar().pushMessage(
msg, level=QgsMessageBar.INFO, duration=5)
self.signalAskCloseWindow.emit()
except GeoPublicHealthException, e:
self.label_progress.setText('')
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
def success(self, path, base_name, provider_key):
iface.addVectorLayer(path, base_name, provider_key)
self.signalStatus.emit(3, tr('Successful import'))
def open_file_browser(self):
output_file = QFileDialog.getSaveFileNameAndFilter(
self.parent, tr('Save shapefile'), filter='SHP (*.shp)')
self.le_output_filepath.setText(output_file[0])
def run_blur(self):
self.progressBar_blur.setValue(0)
self.label_progress.setText('')
# Get all the fields.
layer_to_blur = self.comboBox_layerToBlur.currentLayer()
radius = self.spinBox_radius.value()
display = self.checkBox_addToMap.isChecked()
selected_features_only = self.checkBox_selectedOnlyFeatures.isChecked()
file_name = self.lineEdit_outputFile.text()
export_radius = self.checkBox_exportRadius.isChecked()
export_centroid = self.checkBox_exportCentroid.isChecked()
if self.checkBox_envelope.isChecked():
layer_envelope = self.comboBox_envelope.currentLayer()
else:
layer_envelope = None
# Test values
try:
if not layer_to_blur:
raise NoLayerProvidedException
if not file_name and not display:
raise NoFileNoDisplayException
if layer_to_blur.crs().mapUnits() != 0:
msg = tr('The projection of the map or of the layer is not '
'in meters. These parameters should be in meters.')
display_message_bar(msg, level=Qgis.Warning, duration=5)
#https://github.com/qgis/QGIS/commit/9302613f28207910608fe538a03e0bff82ca5629
if not file_name:
file_name = getTempFilename('blurring.shp')
pass
if layer_envelope:
if layer_to_blur.crs() != layer_envelope.crs():
raise DifferentCrsException(
epsg1=layer_to_blur.crs().authid(),
epsg2=layer_envelope.crs().authid())
self.label_progress.setText('Creating index ...')
layer_envelope = LayerIndex(layer_envelope)
self.progressBar_blur.setValue(0)
self.label_progress.setText('Blurring ...')
if selected_features_only:
features = layer_to_blur.selectedFeatures()
nb_features = layer_to_blur.selectedFeatureCount()
else:
features = layer_to_blur.getFeatures()
nb_features = layer_to_blur.featureCount()
# Fields
fields = layer_to_blur.fields()
if export_radius:
fields.append(QgsField(u"Radius", QVariant.Int))
if export_centroid:
fields.append(QgsField(u"X centroid", QVariant.Int))
fields.append(QgsField(u"Y centroid", QVariant.Int))
# Creating the output shapefile
file_writer = QgsVectorFileWriter(file_name, 'utf-8', fields,
Qgis.WKBPolygon,
layer_to_blur.crs(),
'ESRI Shapefile')
if file_writer.hasError() != QgsVectorFileWriter.NoError:
raise CreatingShapeFileException(suffix=file_writer.hasError())
# Creating the algorithm with radius
algo = Blur(radius, layer_envelope, export_radius, export_centroid)
for j, feature in enumerate(features):
feature = algo.blur(feature)
file_writer.addFeature(feature)
# Update progress bar
percent = int((j + 1) * 100 / nb_features)
self.progressBar_blur.setValue(percent)
# Write all features in the file
del file_writer
if display:
old_default_projection = self.settings.value(
'/Projections/defaultBehaviour')
self.settings.setValue('/Projections/defaultBehaviour',
'useProject')
layer_name = basename(file_name)
new_layer = QgsVectorLayer(file_name, layer_name, 'ogr')
new_layer.commitChanges()
new_layer.clearCacheImage()
# noinspection PyArgumentList
QgsProject.instance().addMapLayers([new_layer])
self.settings.setValue('/Projections/defaultBehaviour',
old_default_projection)
msg = tr('Successful export in %s' % file_name)
iface.messageBar().pushMessage(msg, level=Qgis.Info, duration=5)
self.signalAskCloseWindow.emit()
except GeoPublicHealthException as e:
self.label_progress.setText('')
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
finally:
# noinspection PyArgumentList
QApplication.restoreOverrideCursor()
# noinspection PyArgumentList
QApplication.processEvents()
def save_kml(self):
path = self.le_output.text()
layer = self.cbx_layer.currentLayer()
QgsVectorFileWriter.writeAsVectorFormat(layer, path, 'utf-8', None,
'kml')
self.signalStatus.emit(3, tr('Successful export to %s' % path))
def success(self, path, base_name, provider_key):
iface.addVectorLayer(path, base_name, provider_key)
self.signalStatus.emit(3, tr('Successful import'))
def run_stats(self):
"""Main function which do the process."""
# Get the common fields..currentField()
self.admin_layer = self.cbx_aggregation_layer.currentLayer()
input_name = self.admin_layer.name()
field = self.cbx_indicator_field.currentField()
self.layer = QgsProject.instance().mapLayersByName(input_name)[0]
# Output.
self.output_file_path = self.le_output_filepath.text()
try:
self.button_box_ok.setDisabled(True)
# noinspection PyArgumentList
QApplication.setOverrideCursor(Qt.WaitCursor)
# noinspection PyArgumentList
QApplication.processEvents()
if not self.admin_layer:
raise NoLayerProvidedException
if not self.admin_layer and self.use_point_layer:
raise NoLayerProvidedException
crs_admin_layer = self.admin_layer.crs()
# Output
if not self.output_file_path:
temp_file = NamedTemporaryFile(delete=False,
suffix='-geopublichealth.shp')
self.output_file_path = temp_file.name
temp_file.flush()
temp_file.close()
else:
with open(self.output_file_path, 'w') as document:
pass
admin_layer_provider = self.layer.dataProvider()
fields = admin_layer_provider.fields()
if admin_layer_provider.fields().indexFromName(
self.name_field) != -1:
raise FieldExistingException(field=self.name_field)
fields.append(QgsField('LISA_P', QVariant.Double))
fields.append(QgsField('LISA_Z', QVariant.Double))
fields.append(QgsField('LISA_Q', QVariant.Int))
fields.append(QgsField('LISA_I', QVariant.Double))
fields.append(QgsField('LISA_C', QVariant.Double))
# The QgsVectorFileWriter was Deprecated since 3.10 However,.......
#The create() function DOEST NOT Flush the feature unless QGIS close.
#options = QgsVectorFileWriter.SaveVectorOptions()
#options.driverName = "ESRI Shapefile"
#file_writer=QgsVectorFileWriter.create(self.output_file_path,fields,QgsWkbTypes.Polygon,self.admin_layer.crs(),QgsCoordinateTransformContext(),options)
#It's currently a bug https://github.com/qgis/QGIS/issues/35021
# So I will keep it for now
file_writer = QgsVectorFileWriter(self.output_file_path, 'utf-8',
fields, QgsWkbTypes.Polygon,
self.admin_layer.crs(),
'ESRI Shapefile')
if self.cbx_contiguity.currentIndex() == 0: # queen
# fix_print_with_import
print('Info: Local Moran\'s using queen contiguity')
#Pysal 2.0 change
#https://github.com/pysal/pysal/blob/master/MIGRATING.md
w = Queen.from_shapefile(self.admin_layer.source())
else: # 1 for rook
# fix_print_with_import
print('Info: Local Moran\'s using rook contiguity')
w = Rook.from_shapefile(self.admin_layer.source())
#Pysal 2.0
#https://stackoverflow.com/questions/59455383/pysal-does-not-have-attribute-open
import geopandas
f = geopandas.read_file(self.admin_layer.source().replace(
'.shp', '.dbf'))
y = f[str(field)]
lm = Moran_Local(y, w, transformation="r", permutations=999)
sig_q = lm.q * (lm.p_sim <= 0.05
) # could make significance level an option
outFeat = QgsFeature()
i = 0
count = self.admin_layer.featureCount()
for i, feature in enumerate(self.admin_layer.getFeatures()):
attributes = feature.attributes()
attributes.append(float(lm.p_sim[i]))
attributes.append(float(lm.z_sim[i]))
attributes.append(int(lm.q[i]))
attributes.append(float(lm.Is[i]))
attributes.append(int(sig_q[i]))
new_feature = QgsFeature()
new_geom = QgsGeometry(feature.geometry())
new_feature.setAttributes(attributes)
new_feature.setGeometry(new_geom)
file_writer.addFeature(new_feature)
del file_writer
self.output_layer = QgsVectorLayer(self.output_file_path,
"LISA Moran's I - " + field,
'ogr')
QgsProject.instance().addMapLayer(self.output_layer)
self.add_symbology()
self.signalStatus.emit(3, tr('Successful process'))
except GeoPublicHealthException as e:
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
finally:
self.button_box_ok.setDisabled(False)
# noinspection PyArgumentList
QApplication.restoreOverrideCursor()
# noinspection PyArgumentList
QApplication.processEvents()
def run_stats(self):
"""Main function which do the process."""
# Get the common fields.
self.admin_layer = self.cbx_aggregation_layer.currentLayer()
if self.use_point_layer:
# If we use a point layer.
point_layer = self.cbx_case_layer.currentLayer()
else:
# If we use a column with number of case.
case_column = self.cbx_case_field.currentField()
index_case = self.admin_layer.fieldNameIndex(case_column)
if not self.use_area:
# If we don't use density.
population = self.cbx_population_field.currentField()
index_population = self.admin_layer.fieldNameIndex(population)
if not self.name_field:
self.name_field = self.le_new_column.placeholderText()
# Add new column.
add_nb_intersections = self.checkBox_addNbIntersections.isChecked()
# Ratio
ratio = self.cbx_ratio.currentText()
ratio = ratio.replace(' ', '')
# Output.
self.output_file_path = self.le_output_filepath.text()
try:
self.button_box_ok.setDisabled(True)
# noinspection PyArgumentList
QApplication.setOverrideCursor(Qt.WaitCursor)
# noinspection PyArgumentList
QApplication.processEvents()
if not self.admin_layer:
raise NoLayerProvidedException
if not self.admin_layer and self.use_point_layer:
raise NoLayerProvidedException
crs_admin_layer = self.admin_layer.crs()
if self.use_point_layer:
crs_point_layer = point_layer.crs()
if crs_admin_layer != crs_point_layer:
raise DifferentCrsException(
epsg1=crs_point_layer.authid(),
epsg2=crs_admin_layer.authid())
if not self.use_point_layer and not self.use_area:
if index_population == index_case:
raise FieldException(field_1='Population', field_2='Case')
try:
ratio = float(ratio)
except ValueError:
raise NotANumberException(suffix=ratio)
# Output
if not self.output_file_path:
temp_file = NamedTemporaryFile(
delete=False,
suffix='-geohealth.shp')
self.output_file_path = temp_file.name
temp_file.flush()
temp_file.close()
admin_layer_provider = self.admin_layer.dataProvider()
fields = self.admin_layer.pendingFields()
if admin_layer_provider.fieldNameIndex(self.name_field) != -1:
raise FieldExistingException(field=self.name_field)
fields.append(QgsField(self.name_field, QVariant.Double))
if add_nb_intersections:
fields.append(QgsField('nb_of_intersections', QVariant.Int))
data = []
file_writer = QgsVectorFileWriter(
self.output_file_path,
'utf-8',
fields,
QGis.WKBPolygon,
self.admin_layer.crs(),
'ESRI Shapefile')
if self.use_point_layer:
total_case = point_layer.featureCount()
else:
total_case = 0
for i, feature in enumerate(self.admin_layer.getFeatures()):
attributes = feature.attributes()
if self.use_point_layer:
count = 0
for f in point_layer.getFeatures():
if f.geometry().intersects(feature.geometry()):
count += 1
else:
count = int(attributes[index_case])
total_case += count
try:
if self.use_area:
area = feature.geometry().area()
value = float(count) / area * ratio
else:
try:
population = float(attributes[index_population])
except ValueError:
raise NotANumberException(
suffix=attributes[index_population])
value = float(count) / population * ratio
except ZeroDivisionError:
value = None
except TypeError:
value = None
data.append(value)
attributes.append(value)
if add_nb_intersections:
attributes.append(count)
new_feature = QgsFeature()
new_geom = QgsGeometry(feature.geometry())
new_feature.setAttributes(attributes)
new_feature.setGeometry(new_geom)
file_writer.addFeature(new_feature)
del file_writer
self.output_layer = QgsVectorLayer(
self.output_file_path,
self.name_field,
'ogr')
QgsMapLayerRegistry.instance().addMapLayer(self.output_layer)
if self.checkBox_incidence_runStats.isChecked():
stats = Stats(data)
items_stats = [
'Incidence null,%d' % stats.null_values(),
'Count(point),%d' % total_case,
'Count(polygon),%d' % self.admin_layer.featureCount(),
'Min,%d' % stats.min(),
'Average,%f' % stats.average(),
'Max,%d' % stats.max(),
'Median,%f' % stats.median(),
'Range,%d' % stats.range(),
'Variance,%f' % stats.variance(),
'Standard deviation,%f' % stats.standard_deviation()
]
self.tableWidget.clear()
self.tableWidget.setColumnCount(2)
labels = ['Parameters', 'Values']
self.tableWidget.setHorizontalHeaderLabels(labels)
self.tableWidget.setRowCount(len(items_stats))
for i, item in enumerate(items_stats):
s = item.split(',')
self.tableWidget.setItem(i, 0, QTableWidgetItem(s[0]))
self.tableWidget.setItem(i, 1, QTableWidgetItem(s[1]))
self.tableWidget.resizeRowsToContents()
self.draw_plot(data)
else:
self.hide()
if self.symbology.isChecked():
self.add_symbology()
self.signalStatus.emit(3, tr('Successful process'))
except GeoPublicHealthException, e:
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
def run_stats(self):
"""Main function which do the process."""
# Get the common fields.
self.admin_layer = self.cbx_aggregation_layer.currentLayer()
selected_indicators = self.indicators_list()
if not self.name_field:
self.name_field = self.le_new_column.placeholderText()
# Output.
self.output_file_path = self.le_output_filepath.text()
try:
self.button_box_ok.setDisabled(True)
# noinspection PyArgumentList
QApplication.setOverrideCursor(Qt.WaitCursor)
# noinspection PyArgumentList
QApplication.processEvents()
if not self.admin_layer:
raise NoLayerProvidedException
if not self.admin_layer and self.use_point_layer:
raise NoLayerProvidedException
crs_admin_layer = self.admin_layer.crs()
if not self.use_point_layer and not self.use_area:
if not self.cbx_list_indicators:
raise FieldException(field_1='List Indicators should not empty')
# Output
if not self.output_file_path:
temp_file = NamedTemporaryFile(
delete=False,
suffix='-geopublichealth.shp')
self.output_file_path = temp_file.name
temp_file.flush()
temp_file.close()
admin_layer_provider = self.admin_layer.dataProvider()
fields = self.admin_layer.pendingFields()
if admin_layer_provider.fieldNameIndex(self.name_field) != -1:
raise FieldExistingException(field=self.name_field)
for indicator_selected in selected_indicators:
fields.append(QgsField("Z" + indicator_selected[0], QVariant.Double))
fields.append(QgsField(self.name_field, QVariant.Double))
file_writer = QgsVectorFileWriter(
self.output_file_path,
'utf-8',
fields,
QGis.WKBPolygon,
self.admin_layer.crs(),
'ESRI Shapefile')
count = self.admin_layer.featureCount()
stats = {}
for indicator_selected in selected_indicators:
values = []
indicator_selected_name = str(indicator_selected[0])
for i, feature in enumerate(self.admin_layer.getFeatures()):
index = self.admin_layer.fieldNameIndex(indicator_selected_name)
if feature[index]:
value = float(feature[index])
else:
value = 0.0
values.append(value)
stats[indicator_selected_name] = Stats(values)
for i, feature in enumerate(self.admin_layer.getFeatures()):
attributes = feature.attributes()
composite_index_value = 0.0
for indicator_selected in selected_indicators:
indicator_selected_name = str(indicator_selected[0])
index = self.admin_layer.fieldNameIndex(indicator_selected_name)
if feature[index]:
value = float(feature[index])
else:
value = 0.0
zscore = (value - stats[indicator_selected_name].average()) / stats[indicator_selected_name].standard_deviation()
attributes.append(float(zscore))
#msgBox = QMessageBox()
#msgBox.setText("indicator_selected: " + str(indicator_selected) + " value: " + str(value) + " stats[indicator_selected_name].average(): " + str(stats[indicator_selected_name].average()) + " zscore: " + str(zscore))
#msgBox.exec_()
if indicator_selected[1] == '+':
composite_index_value -= zscore
else:
composite_index_value += zscore
attributes.append(float(composite_index_value))
new_feature = QgsFeature()
new_geom = QgsGeometry(feature.geometry())
new_feature.setAttributes(attributes)
new_feature.setGeometry(new_geom)
file_writer.addFeature(new_feature)
del file_writer
self.output_layer = QgsVectorLayer(
self.output_file_path,
self.name_field,
'ogr')
QgsMapLayerRegistry.instance().addMapLayer(self.output_layer)
if self.symbology.isChecked():
self.add_symbology()
self.signalStatus.emit(3, tr('Successful process'))
except GeoPublicHealthException, e:
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
