class Slider(InputType):
'''
slider input, displays a slider and a number input next to it, both
connected to each other
'''
def __init__(self, minimum: int = 0, maximum: int = 100000000,
step: int = 1, width: int = 300,
lockable: bool = False, locked: bool = False, **kwargs):
'''
Parameters
----------
width : int, optional
width of slider in pixels, defaults to 300 pixels
minimum : int, optional
minimum value that the user can set
maximum : int, optional
maximum value that the user can set
step : int, optional
the tick intervall of the slider and single step of the number
input, defaults to 1
lockable : bool, optional
the slider and number input can be locked by a checkbox that will
be displayed next to them if True, defaults to not lockable
locked : bool, optional
initial lock-state of inputs, only applied if lockable is True,
defaults to inputs being not locked
'''
super().__init__(**kwargs)
self.minimum = minimum
self.maximum = maximum
self.lockable = lockable
self.step = step
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(minimum)
self.slider.setMaximum(maximum)
self.slider.setTickInterval(step)
self.slider.setFixedWidth(width)
self.spinbox = QSpinBox()
self.spinbox.setMinimum(minimum)
self.spinbox.setMaximum(maximum)
self.spinbox.setSingleStep(step)
self.registerFocusEvent(self.spinbox)
self.registerFocusEvent(self.slider)
if lockable:
self.lock_button = QPushButton()
self.lock_button.setCheckable(True)
self.lock_button.setChecked(locked)
self.lock_button.setSizePolicy(
QSizePolicy.Fixed, QSizePolicy.Fixed)
def toggle_icon(emit=True):
is_locked = self.lock_button.isChecked()
fn = '20190619_iconset_mob_lock_locked_02.png' if is_locked \
else '20190619_iconset_mob_lock_unlocked_03.png'
self.slider.setEnabled(not is_locked)
self.spinbox.setEnabled(not is_locked)
icon_path = os.path.join(settings.IMAGE_PATH, 'iconset_mob', fn)
icon = QIcon(icon_path)
self.lock_button.setIcon(icon)
self.locked.emit(is_locked)
toggle_icon(emit=False)
self.lock_button.clicked.connect(lambda: toggle_icon(emit=True))
self.slider.valueChanged.connect(
lambda: self.set_value(self.slider.value()))
self.spinbox.valueChanged.connect(
lambda: self.set_value(self.spinbox.value()))
self.slider.valueChanged.connect(
lambda: self.changed.emit(self.get_value()))
self.spinbox.valueChanged.connect(
lambda: self.changed.emit(self.get_value())
)
def set_value(self, value: int):
'''
set a number to both the slider and the number input
Parameters
----------
checked : int
check-state
'''
for element in [self.slider, self.spinbox]:
# avoid infinite recursion
element.blockSignals(True)
element.setValue(value or 0)
element.blockSignals(False)
@property
def is_locked(self) -> bool:
'''
Returns
-------
bool
current lock-state of slider and number input
'''
if not self.lockable:
return False
return self.lock_button.isChecked()
def draw(self, layout: QLayout, unit: str = ''):
'''
add slider, the connected number and the lock (if lockable) input
to the layout
Parameters
----------
layout : QLayout
layout to add the inputs to
unit : str, optional
the unit shown after the value, defaults to no unit
'''
l = QHBoxLayout()
l.addWidget(self.slider)
l.addWidget(self.spinbox)
if unit:
l.addWidget(QLabel(unit))
if self.lockable:
l.addWidget(self.lock_button)
layout.addLayout(l)
def get_value(self) -> int:
'''
get the currently set number
Returns
-------
int
currently set number
'''
return self.slider.value()
class QvFormSimbMapificacio(QvFormBaseMapificacio):
def __init__(self, llegenda, capa=None, amplada=500):
super().__init__(llegenda, amplada)
if capa is None:
self.capa = llegenda.currentLayer()
else:
self.capa = capa
self.info = None
if not self.iniParams():
return
self.setWindowTitle('Modificar mapa simbòlic ' + self.renderParams.tipusMapa.lower())
self.layout = QVBoxLayout()
self.layout.setSpacing(14)
self.setLayout(self.layout)
self.color = QComboBox(self)
self.color.setEditable(False)
self.comboColors(self.color)
self.contorn = QComboBox(self)
self.contorn.setEditable(False)
self.comboColors(self.contorn, mv.MAP_CONTORNS)
self.color.currentIndexChanged.connect(self.canviaContorns)
self.metode = QComboBox(self)
self.metode.setEditable(False)
if self.renderParams.numCategories > 1:
self.metode.addItems(mv.MAP_METODES_MODIF.keys())
else:
self.metode.addItems(mv.MAP_METODES.keys())
self.metode.setCurrentIndex(-1)
self.metode.currentIndexChanged.connect(self.canviaMetode)
self.nomIntervals = QLabel("Nombre d'intervals:", self)
self.intervals = QSpinBox(self)
self.intervals.setMinimum(min(2, self.renderParams.numCategories))
self.intervals.setMaximum(max(mv.MAP_MAX_CATEGORIES, self.renderParams.numCategories))
self.intervals.setSingleStep(1)
self.intervals.setValue(4)
if self.renderParams.tipusMapa == 'Àrees':
self.intervals.setSuffix(" (depèn del mètode)")
# self.intervals.valueChanged.connect(self.deselectValue)
self.nomTamany = QLabel("Tamany cercle:", self)
self.tamany = QSpinBox(self)
self.tamany.setMinimum(1)
self.tamany.setMaximum(12)
self.tamany.setSingleStep(1)
self.tamany.setValue(4)
self.bInfo = QPushButton('Info')
self.bInfo.clicked.connect(self.veureInfo)
self.buttons = QDialogButtonBox()
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.accepted.connect(self.accept)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.rejected.connect(self.cancel)
self.buttons.addButton(self.bInfo, QDialogButtonBox.ResetRole)
self.gSimb = QGroupBox('Simbologia del mapa')
self.lSimb = QFormLayout()
self.lSimb.setSpacing(14)
self.gSimb.setLayout(self.lSimb)
self.lSimb.addRow('Color base:', self.color)
self.lSimb.addRow('Color contorn:', self.contorn)
if self.renderParams.tipusMapa == 'Àrees':
self.lSimb.addRow('Mètode classificació:', self.metode)
self.lSimb.addRow(self.nomIntervals, self.intervals)
self.nomTamany.setVisible(False)
self.tamany.setVisible(False)
else:
self.metode.setVisible(False)
self.nomIntervals.setVisible(False)
self.intervals.setVisible(False)
self.lSimb.addRow(self.nomTamany, self.tamany)
self.wInterval = []
for w in self.iniIntervals():
self.wInterval.append(w)
self.gInter = self.grupIntervals()
self.layout.addWidget(self.gSimb)
if self.renderParams.tipusMapa == 'Àrees':
self.layout.addWidget(self.gInter)
self.layout.addWidget(self.buttons)
self.valorsInicials()
def iniParams(self):
self.info = QgsExpressionContextUtils.layerScope(self.capa).variable(mv.MAP_ID)
if self.info is None:
return False
self.renderParams = QvMapRendererParams.fromLayer(self.capa)
if self.renderParams.msgError == '':
self.custom = (self.renderParams.modeCategories == 'Personalitzat')
return True
else:
self.msgInfo("No s'han pogut recuperar els paràmetres del mapa simbòlic\n\n" +
"Error: " + self.renderParams.msgError)
return False
@pyqtSlot()
def veureInfo(self):
if self.info is not None:
box = QMessageBox(self)
box.setWindowTitle('Info del mapa simbòlic')
txt = '<table width="600">'
params = self.info.split('\n')
for param in params:
linea = param.strip()
if linea.endswith(':'):
linea += ' ---'
txt += '<tr><td><nobr>· {}</nobr></td></tr>'.format(linea)
txt += '</table>'
box.setTextFormat(Qt.RichText)
box.setText("Paràmetres d'agregació de dades:")
box.setInformativeText(txt)
box.setIcon(QMessageBox.Information)
box.setStandardButtons(QMessageBox.Ok)
box.setDefaultButton(QMessageBox.Ok)
box.exec()
def valorsInicials(self):
self.color.setCurrentIndex(self.color.findText(self.renderParams.colorBase))
self.contorn.setCurrentIndex(self.contorn.findText(self.renderParams.colorContorn))
self.intervals.setValue(self.renderParams.numCategories)
self.tamany.setValue(self.renderParams.increase)
self.metode.setCurrentIndex(self.metode.findText(self.renderParams.modeCategories))
def valorsFinals(self):
self.renderParams.colorBase = self.color.currentText()
self.renderParams.colorContorn = self.contorn.currentText()
self.renderParams.modeCategories = self.metode.currentText()
self.renderParams.numCategories = self.intervals.value()
self.renderParams.increase = self.tamany.value()
if self.custom:
self.renderParams.rangsCategories = []
for fila in self.wInterval:
self.renderParams.rangsCategories.append((fila[0].text(), fila[2].text()))
self.renderParams.numCategories = len(self.renderParams.rangsCategories)
def txtRang(self, num):
if type(num) == str:
return num
return QvApp().locale.toString(num, 'f', self.renderParams.numDecimals)
def iniFilaInterval(self, iniValor, finValor):
maxSizeB = 27
# validator = QDoubleValidator(self)
# validator.setLocale(QvApp().locale)
# validator.setNotation(QDoubleValidator.StandardNotation)
# validator.setDecimals(5)
validator = QvVerifNumero(self)
ini = QLineEdit(self)
ini.setText(self.txtRang(iniValor))
ini.setValidator(validator)
sep = QLabel('-', self)
fin = QLineEdit(self)
fin.setText(self.txtRang(finValor))
fin.setValidator(validator)
fin.editingFinished.connect(self.nouTall)
add = QPushButton('+', self)
add.setMaximumSize(maxSizeB, maxSizeB)
add.setToolTip('Afegeix nou interval')
add.clicked.connect(self.afegirFila)
add.setFocusPolicy(Qt.NoFocus)
rem = QPushButton('-', self)
rem.setMaximumSize(maxSizeB, maxSizeB)
rem.setToolTip('Esborra interval')
rem.clicked.connect(self.eliminarFila)
rem.setFocusPolicy(Qt.NoFocus)
return [ini, sep, fin, add, rem]
def iniIntervals(self):
for cat in self.renderParams.rangsCategories:
yield self.iniFilaInterval(cat.lowerValue(), cat.upperValue())
def grupIntervals(self):
group = QGroupBox('Definició dels intervals')
# group.setMinimumWidth(400)
layout = QGridLayout()
layout.setSpacing(10)
# layout.setColumnMinimumWidth(4, 40)
numFilas = len(self.wInterval)
for fila, widgets in enumerate(self.wInterval):
for col, w in enumerate(widgets):
# Primera fila: solo +
if fila == 0 and col > 3:
w.setVisible(False)
# # Ultima fila: no hay + ni -
elif fila > 0 and fila == (numFilas - 1) and col > 2:
w.setVisible(False)
else:
w.setVisible(True)
# Valor inicial deshabilitado (menos 1a fila)
if col == 0 and fila != 0:
w.setDisabled(True)
w.setProperty('Fila', fila)
layout.addWidget(w, fila, col)
group.setLayout(layout)
return group
def actGrupIntervals(self):
self.intervals.setValue(len(self.wInterval))
self.setUpdatesEnabled(False)
self.buttons.setVisible(False)
self.gInter.setVisible(False)
self.layout.removeWidget(self.buttons)
self.layout.removeWidget(self.gInter)
self.gInter.deleteLater()
self.gInter = self.grupIntervals()
self.layout.addWidget(self.gInter)
self.layout.addWidget(self.buttons)
self.gInter.setVisible(True)
self.buttons.setVisible(True)
self.adjustSize()
self.setUpdatesEnabled(True)
@pyqtSlot()
def afegirFila(self):
masFilas = (len(self.wInterval) < mv.MAP_MAX_CATEGORIES)
if masFilas:
f = self.sender().property('Fila') + 1
ini = self.wInterval[f][0]
val = ini.text()
ini.setText('')
w = self.iniFilaInterval(val, '')
self.wInterval.insert(f, w)
self.actGrupIntervals()
self.wInterval[f][2].setFocus()
else:
self.msgInfo("S'ha arribat al màxim d'intervals possibles")
@pyqtSlot()
def eliminarFila(self):
f = self.sender().property('Fila')
ini = self.wInterval[f][0]
val = ini.text()
del self.wInterval[f]
ini = self.wInterval[f][0]
ini.setText(val)
self.actGrupIntervals()
@pyqtSlot()
def nouTall(self):
w = self.sender()
if w.isModified():
f = w.property('Fila') + 1
if f < len(self.wInterval):
ini = self.wInterval[f][0]
ini.setText(w.text())
w.setModified(False)
@pyqtSlot()
def canviaMetode(self):
self.custom = (self.metode.currentText() == 'Personalitzat')
if self.custom:
self.intervals.setValue(len(self.wInterval))
self.intervals.setEnabled(not self.custom)
self.gInter.setVisible(self.custom)
self.adjustSize()
# print('GSIMB -> Ancho:', self.gSimb.size().width(), '- Alto:', self.gSimb.size().height())
# print('FORM -> Ancho:', self.size().width(), '- Alto:', self.size().height())
@pyqtSlot()
def canviaContorns(self):
self.comboColors(self.contorn, mv.MAP_CONTORNS,
mv.MAP_COLORS[self.color.currentText()], True)
def leSelectFocus(self, wLineEdit):
lon = len(wLineEdit.text())
if lon > 0:
wLineEdit.setSelection(0, lon)
wLineEdit.setFocus()
def validaNum(self, wLineEdit):
val = wLineEdit.validator()
if val is None:
return True
res = val.validate(wLineEdit.text(), 0)
if res[0] == QValidator.Acceptable:
return True
else:
self.msgInfo("Cal introduir un nombre enter o amb decimals.\n"
"Es farà servir la coma (,) per separar els decimals.\n"
"I pels milers, opcionalment, el punt (.)")
self.leSelectFocus(wLineEdit)
return False
def validaInterval(self, wLineEdit1, wLineEdit2):
num1, _ = QvApp().locale.toFloat(wLineEdit1.text())
num2, _ = QvApp().locale.toFloat(wLineEdit2.text())
if num2 >= num1:
return True
else:
self.msgInfo("El segon nombre de l'interval ha de ser major que el primer")
self.leSelectFocus(wLineEdit2)
return False
def validaFila(self, fila):
wLineEdit1 = fila[0]
wLineEdit2 = fila[2]
if not self.validaNum(wLineEdit1):
return False
if not self.validaNum(wLineEdit2):
return False
if not self.validaInterval(wLineEdit1, wLineEdit2):
return False
return True
def valida(self):
if self.custom:
for fila in self.wInterval:
if not self.validaFila(fila):
return False
return True
def procesa(self):
self.valorsFinals()
try:
mapRenderer = self.renderParams.mapRenderer(self.llegenda)
if self.custom:
self.renderParams.colorBase = mv.MAP_COLORS[self.renderParams.colorBase]
self.renderParams.colorContorn = mv.MAP_CONTORNS[self.renderParams.colorContorn]
self.renderer = mapRenderer.customRender(self.capa)
else:
self.renderParams.colorBase = mv.MAP_COLORS[self.renderParams.colorBase]
if self.renderParams.colorContorn == 'Base':
self.renderParams.colorContorn = self.renderParams.colorBase
else:
self.renderParams.colorContorn = mv.MAP_CONTORNS[self.renderParams.colorContorn]
self.renderParams.modeCategories = \
mv.MAP_METODES_MODIF[self.renderParams.modeCategories]
self.renderer = mapRenderer.calcRender(self.capa)
if self.renderer is None:
return "No s'ha pogut elaborar el mapa simbòlic"
err = self.llegenda.saveStyleToGeoPackage(self.capa, mv.MAP_ID)
if err != '':
return "Hi ha hagut problemes al desar la simbologia\n({})".format(err)
# self.llegenda.modificacioProjecte('mapModified')
return ''
except Exception as e:
return "No s'ha pogut modificar el mapa simbòlic\n({})".format(str(e))
class QvFormNovaMapificacio(QvFormBaseMapificacio):
def __init__(self, llegenda, amplada=500, mapificacio=None, simple=True):
super().__init__(llegenda, amplada)
self.fCSV = mapificacio
self.simple = simple
self.taulaMostra = None
self.setWindowTitle('Afegir capa amb mapa simbòlic')
self.layout = QVBoxLayout()
self.layout.setSpacing(14)
self.setLayout(self.layout)
if self.fCSV is None:
self.arxiu = QgsFileWidget()
self.arxiu.setStorageMode(QgsFileWidget.GetFile)
self.arxiu.setDialogTitle('Selecciona fitxer de dades…')
self.arxiu.setDefaultRoot(RUTA_LOCAL)
self.arxiu.setFilter('Arxius CSV (*.csv)')
self.arxiu.setSelectedFilter('Arxius CSV (*.csv)')
self.arxiu.lineEdit().setReadOnly(True)
self.arxiu.fileChanged.connect(self.arxiuSeleccionat)
self.zona = QComboBox(self)
self.zona.setEditable(False)
self.zona.addItem('Selecciona zona…')
self.zona.currentIndexChanged.connect(self.canviaZona)
self.mapa = QComboBox(self)
self.mapa.setEditable(False)
self.mapa.setIconSize(QSize(126, 126))
self.mapa.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
self.mapa.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.mapa.addItem(QIcon(os.path.join(imatgesDir, 'Àrees.PNG')), 'Àrees')
self.mapa.addItem(QIcon(os.path.join(imatgesDir, 'Cercles.PNG')), 'Cercles')
self.capa = QLineEdit(self)
self.capa.setMaxLength(40)
self.tipus = QComboBox(self)
self.tipus.setEditable(False)
self.tipus.addItem('Selecciona tipus…')
self.tipus.addItems(mv.MAP_AGREGACIO.keys())
self.tipus.currentIndexChanged.connect(self.canviaTipus)
self.distribucio = QComboBox(self)
self.distribucio.setEditable(False)
self.distribucio.addItem(next(iter(mv.MAP_DISTRIBUCIO.keys())))
self.calcul = QvComboBoxCamps(self)
self.filtre = QvComboBoxCamps(self, multiple=True)
self.color = QComboBox(self)
self.color.setEditable(False)
self.comboColors(self.color)
self.metode = QComboBox(self)
self.metode.setEditable(False)
self.metode.addItems(mv.MAP_METODES.keys())
self.intervals = QSpinBox(self)
self.intervals.setMinimum(2)
self.intervals.setMaximum(mv.MAP_MAX_CATEGORIES)
self.intervals.setSingleStep(1)
self.intervals.setValue(4)
self.intervals.setSuffix(" (depèn del mètode)")
# self.intervals.valueChanged.connect(self.deselectValue)
self.bTaula = QPushButton('Veure arxiu')
self.bTaula.setEnabled(False)
self.bTaula.clicked.connect(self.veureArxiu)
self.buttons = QDialogButtonBox()
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.accepted.connect(self.accept)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.rejected.connect(self.cancel)
self.buttons.addButton(self.bTaula, QDialogButtonBox.ResetRole)
self.gDades = QGroupBox('Agregació de dades')
self.lDades = QFormLayout()
self.lDades.setSpacing(14)
self.gDades.setLayout(self.lDades)
if self.fCSV is None:
self.lDades.addRow('Arxiu de dades:', self.arxiu)
self.lDades.addRow('Zona:', self.zona)
self.lDades.addRow("Tipus d'agregació:", self.tipus)
self.lDades.addRow('Camp de càlcul:', self.calcul)
if self.simple:
self.filtre.setVisible(False)
self.distribucio.setVisible(False)
else:
self.lDades.addRow('Filtre:', self.filtre)
self.lDades.addRow('Distribució:', self.distribucio)
self.gMapa = QGroupBox('Definició del mapa simbòlic')
self.lMapa = QFormLayout()
self.lMapa.setSpacing(14)
self.gMapa.setLayout(self.lMapa)
self.lMapa.addRow('Nom de capa:', self.capa)
self.lMapa.addRow('Tipus de mapa:', self.mapa)
self.gSimb = QGroupBox('Simbologia del mapa')
self.lSimb = QFormLayout()
self.lSimb.setSpacing(14)
self.gSimb.setLayout(self.lSimb)
self.lSimb.addRow('Color base:', self.color)
self.lSimb.addRow('Mètode classificació:', self.metode)
self.lSimb.addRow("Nombre d'intervals:", self.intervals)
self.layout.addWidget(self.gDades)
self.layout.addWidget(self.gMapa)
if self.simple:
self.gSimb.setVisible(False)
else:
self.layout.addWidget(self.gSimb)
self.layout.addWidget(self.buttons)
self.adjustSize()
self.nouArxiu()
def exec(self):
# La mapificación solo funciona si está instalado el módulo pandas
if PANDAS_ENABLED:
return super().exec()
else:
self.msgError(PANDAS_ERROR)
return QDialog.Rejected
@pyqtSlot()
def veureArxiu(self):
if self.taulaMostra is not None:
self.taulaMostra.show()
self.taulaMostra.activateWindow()
def campsDB(self, nom):
res = []
if nom != '':
fich = RUTA_DADES + mv.MAP_ZONES_DB
if os.path.isfile(fich):
conn = sqlite3.connect('file:' + fich + '?mode=ro', uri=True)
conn.row_factory = sqlite3.Row
c = conn.cursor()
c.execute('select * from ' + nom) # nom.split('.')[0])
row = c.fetchone()
# res = [i[0].upper() for i in c.description]
res = [i.upper() for i in row.keys()]
conn.close()
return res
def soloPrimerItem(self, combo):
combo.setCurrentIndex(0)
ultimo = combo.count() - 1
for n in range(ultimo, 0, -1):
combo.removeItem(n)
@pyqtSlot()
def canviaZona(self):
self.distribucio.setCurrentIndex(0)
self.soloPrimerItem(self.distribucio)
if self.zona.currentIndex() > 0:
z = self.zona.currentText()
campsZona = self.campsDB(mv.MAP_ZONES[z][1])
# Carga combo con distribuciones si el campo correspondiente está en la BBDD
for dist, campo in mv.MAP_DISTRIBUCIO.items():
if campo != '' and campo in campsZona:
self.distribucio.addItem(dist)
@pyqtSlot()
def canviaTipus(self):
if self.tipus.currentText() == 'Recompte':
self.calcul.setCurrentIndex(-1)
self.calcul.setEnabled(False)
else:
self.calcul.setEnabled(True)
def borrarArxiu(self):
if self.taulaMostra is not None:
self.taulaMostra.hide()
self.taulaMostra = None
self.bTaula.setEnabled(False)
self.tipus.setCurrentIndex(0)
self.soloPrimerItem(self.zona)
self.calcul.clear()
self.filtre.clear()
def nouArxiu(self):
if self.fCSV is None:
return
# Carga combo con zonas si el campo correspondiente está en el fichero CSV
num = 0
for zona, val in mv.MAP_ZONES.items():
if val[1] != '' and self.fCSV.prefixe + QvSqlite.getAlias(val[0]) in self.fCSV.camps:
self.zona.addItem(zona)
num = num + 1
# Comprobar si la extensión del mapa está limitada
if num > 0:
extensio = self.fCSV.testExtensioArxiu(mv.MAP_EXTENSIO)
if extensio: # Mapa limitado
self.comboDelete(self.zona, mv.MAP_TRUE_EXTENSIO)
else: # Mapa completo
self.comboDelete(self.zona, mv.MAP_FALSE_EXTENSIO)
# Ajustar combo de zonas
if num == 0:
self.msgInfo("El fitxer " + self.fCSV.fZones + " no té cap camp de zona")
if hasattr(self, 'arxiu'):
self.arxiu.lineEdit().clear()
self.arxiu.setFocus()
return
if num == 1:
self.zona.setCurrentIndex(1)
self.capa.setFocus()
else:
self.zona.setFocus()
self.taulaMostra = QvEditorCsv(self.fCSV.fZones, [], 'utf-8', self.fCSV.separador, self)
self.taulaMostra.setWindowTitle("Vista prèvia d'arxiu geocodificat")
self.taulaMostra.setReadOnly(True)
self.bTaula.setEnabled(True)
self.calcul.setItems(self.fCSV.camps, primer='')
self.filtre.setItems(self.fCSV.camps)
@pyqtSlot(str)
def arxiuSeleccionat(self, nom):
if nom == '':
return
self.borrarArxiu()
self.fCSV = QvMapificacio(nom)
self.nouArxiu()
def validaSortida(self, nom):
fSalida = self.fCSV.nomArxiuSortida(self.fCSV.netejaString(nom, True))
return self.msgSobreescriure(fSalida)
def valida(self):
ok = False
if hasattr(self, 'arxiu') and self.arxiu.filePath() == '':
self.msgInfo("S'ha de seleccionar un arxiu de dades")
self.arxiu.setFocus()
elif self.zona.currentIndex() <= 0:
self.msgInfo("S'ha de seleccionar una zona")
self.zona.setFocus()
elif self.capa.text().strip() == '':
self.msgInfo("S'ha de introduir un nom de capa")
self.capa.setFocus()
elif self.tipus.currentIndex() <= 0:
self.msgInfo("S'ha de seleccionar un tipus d'agregació")
self.tipus.setFocus()
elif self.calcul.currentText().strip() == '' and self.tipus.currentText() != 'Recompte':
self.msgInfo("S'ha de introduir un cálcul per fer l'agregació")
self.calcul.setFocus()
elif self.fCSV is None:
return self.msgInfo("No hi ha cap fitxer seleccionat")
elif not self.validaSortida(self.capa.text().strip()):
self.capa.setFocus()
else:
ok = True
return ok
def setRenderParams(self):
self.renderParams = QvMapRendererParams(self.mapa.currentText())
if self.simple:
self.renderParams.colorBase = mv.MAP_COLORS[self.renderParams.colorBase]
else:
self.renderParams.colorBase = mv.MAP_COLORS[self.color.currentText()]
if self.renderParams.colorContorn is None or self.renderParams.colorContorn == 'Base':
self.renderParams.colorContorn = self.renderParams.colorBase
else:
self.renderParams.colorContorn = mv.MAP_CONTORNS[self.renderParams.colorContorn]
if self.tipus.currentText().startswith('Recompte') and \
self.distribucio.currentText() == "Total":
self.renderParams.numDecimals = 0
else:
self.renderParams.numDecimals = 2
if self.renderParams.tipusMapa == 'Àrees':
self.renderParams.modeCategories = mv.MAP_METODES[self.metode.currentText()]
self.renderParams.numCategories = self.intervals.value()
if self.renderParams.tipusMapa == 'Cercles':
zona = self.zona.currentText()
if zona == 'Districte':
self.renderParams.increase = 8
elif zona == 'Barri':
self.renderParams.increase = 4
elif zona == 'Àrea estadística bàsica':
self.renderParams.increase = 3
elif zona == 'Secció censal':
self.renderParams.increase = 2
else:
self.renderParams.increase = 1
def procesa(self):
if self.taulaMostra is not None:
self.taulaMostra.hide()
self.setRenderParams()
ok = self.fCSV.agregacio(self.llegenda, self.capa.text().strip(),
self.zona.currentText(), self.tipus.currentText(),
self.renderParams,
campAgregat=self.calcul.currentText().strip(),
simple=self.simple,
filtre=self.filtre.currentText().strip(),
tipusDistribucio=self.distribucio.currentText(),
form=self)
if ok:
return ''
else:
return self.fCSV.msgError
class DisplayAequilibraEFormatsDialog(QtWidgets.QDialog, FORM_CLASS):
def __init__(self, iface):
QtWidgets.QDialog.__init__(self)
self.iface = iface
self.setupUi(self)
self.error = None
self.error = None
self.data_path, self.data_type = GetOutputFileName(
self, 'AequilibraE custom formats',
["Aequilibrae dataset(*.aed)", "Aequilibrae matrix(*.aem)"],
'.aed', standard_path())
if self.data_type is None:
self.error = 'Path provided is not a valid dataset'
self.exit_with_error()
self.data_type = self.data_type.upper()
if self.data_type == 'AED':
self.data_to_show = AequilibraEData()
elif self.data_type == 'AEM':
self.data_to_show = AequilibraeMatrix()
try:
self.data_to_show.load(self.data_path)
except:
self.error = 'Could not load dataset'
self.exit_with_error()
# Elements that will be used during the displaying
self._layout = QVBoxLayout()
self.table = QTableView()
self._layout.addWidget(self.table)
# Settings for displaying
self.show_layout = QHBoxLayout()
# Thousand separator
self.thousand_separator = QCheckBox()
self.thousand_separator.setChecked(True)
self.thousand_separator.setText('Thousands separator')
self.thousand_separator.toggled.connect(self.format_showing)
self.show_layout.addWidget(self.thousand_separator)
self.spacer = QSpacerItem(5, 0, QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.show_layout.addItem(self.spacer)
# Decimals
txt = QLabel()
txt.setText('Decimal places')
self.show_layout.addWidget(txt)
self.decimals = QSpinBox()
self.decimals.valueChanged.connect(self.format_showing)
self.decimals.setMinimum(0)
self.decimals.setValue(4)
self.decimals.setMaximum(10)
self.show_layout.addWidget(self.decimals)
self._layout.addItem(self.show_layout)
# differentiates between matrix and dataset
if self.data_type == 'AEM':
self.data_to_show.computational_view([self.data_to_show.names[0]])
# Matrices need cores and indices to be set as well
self.mat_layout = QHBoxLayout()
self.mat_list = QComboBox()
for n in self.data_to_show.names:
self.mat_list.addItem(n)
self.mat_list.currentIndexChanged.connect(self.change_matrix_cores)
self.mat_layout.addWidget(self.mat_list)
self.idx_list = QComboBox()
for i in self.data_to_show.index_names:
self.idx_list.addItem(i)
self.idx_list.currentIndexChanged.connect(self.change_matrix_cores)
self.mat_layout.addWidget(self.idx_list)
self._layout.addItem(self.mat_layout)
self.change_matrix_cores()
self.but_export = QPushButton()
self.but_export.setText('Export')
self.but_export.clicked.connect(self.export)
self.but_close = QPushButton()
self.but_close.clicked.connect(self.exit_procedure)
self.but_close.setText('Close')
self.but_layout = QHBoxLayout()
self.but_layout.addWidget(self.but_export)
self.but_layout.addWidget(self.but_close)
self._layout.addItem(self.but_layout)
# We chose to use QTableView. However, if we want to allow the user to edit the dataset
# The we need to allow them to switch to the slower QTableWidget
# Code below
# self.table = QTableWidget(self.data_to_show.entries, self.data_to_show.num_fields)
# self.table.setHorizontalHeaderLabels(self.data_to_show.fields)
# self.table.setObjectName('data_viewer')
#
# self.table.setVerticalHeaderLabels([str(x) for x in self.data_to_show.index[:]])
# self.table.clearContents()
#
# for i in range(self.data_to_show.entries):
# for j, f in enumerate(self.data_to_show.fields):
# item1 = QTableWidgetItem(str(self.data_to_show.data[f][i]))
# item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
# self.table.setItem(i, j, item1)
self.resize(700, 500)
self.setLayout(self._layout)
self.format_showing()
def format_showing(self):
decimals = self.decimals.value()
separator = self.thousand_separator.isChecked()
if isinstance(self.data_to_show, AequilibraeMatrix):
m = NumpyModel(self.data_to_show, separator, decimals)
else:
m = DatabaseModel(self.data_to_show, separator, decimals)
self.table.clearSpans()
self.table.setModel(m)
def change_matrix_cores(self):
self.data_to_show.computational_view([self.mat_list.currentText()])
self.data_to_show.set_index(self.data_to_show.index_names[0])
self.format_showing()
def export(self):
new_name, file_type = GetOutputFileName(
self, self.data_type, ["Comma-separated file(*.csv)"], ".csv",
self.data_path)
if new_name is not None:
self.data_to_show.export(new_name)
def exit_with_error(self):
qgis.utils.iface.messageBar().pushMessage("Error:",
self.error,
level=1)
self.exit_procedure()
def exit_procedure(self):
self.close()
class QpalsLM(object):
def __init__(self, project, layerlist, iface):
self.tabs = None
self.project = project
self.layerlist = layerlist
self.iface = iface
self.pcfile = None
self.multirunner = None
def switchToNextTab(self):
curridx = self.tabs.currentIndex()
self.tabs.setCurrentIndex(curridx + 1)
self.updateTabs()
def updateTabs(self):
curridx = self.tabs.currentIndex()
# update tabs
infile = self.settings['settings']['inFile'].currentText()
if self.names[curridx] == "DTM":
self.pcfile = "pointcloud.odm"
if infile.endswith(".tif"):
self.widgets['dtmGrid'].setEnabled(False)
self.widgets['dtmImp'].setEnabled(True)
self.modules['dtmImp'].setParam('inFile', infile)
self.modules['dtmImp'].setParam('tileSize', '120')
self.modules['dtmShade'].setParam('inFile', infile)
self.modules['slope'].setParam('inFile', infile)
self.modules['dtmGrid'].setParam('outFile', infile)
self.addDtm()
elif infile.endswith(".odm"):
self.widgets['dtmGrid'].setEnabled(True)
self.widgets['dtmImp'].setEnabled(False)
self.modules['dtmGrid'].setParam('inFile', infile)
self.pcfile = infile
else:
self.widgets['dtmImp'].setEnabled(True)
self.widgets['dtmGrid'].setEnabled(True)
self.modules['dtmImp'].setParam('inFile', infile)
self.modules['dtmGrid'].setParam('inFile', "pointcloud.odm")
tempf = self.settings['settings']['tempFolder'].currentText()
if not os.path.isdir(tempf):
try:
os.makedirs(tempf)
except:
tempf = self.project.tempdir
self.settings['settings']['tempFolder'].setText(tempf)
self.project.tempdir = tempf
self.project.workdir = tempf
if self.names[curridx] == "3D-Modelling":
self.modules['lm'].setParam('inFile', self.pcfile)
if self.names[curridx] != "Editing" or "Editing (3D)":
if self.section.ltool.rb:
self.section.ltool.canvas.scene().removeItem(
self.section.ltool.rb)
self.iface.actionPan().trigger()
if self.names[curridx] == "Export":
outdir = self.settings['settings']['outFolder'].currentText()
self.modules['exp'].setParam('outFile',
os.path.join(outdir, '3DSTRULI.shp'))
if not os.path.isdir(outdir) and outdir:
os.makedirs(outdir)
def switchToPrevTab(self):
curridx = self.tabs.currentIndex()
self.tabs.setCurrentIndex(curridx - 1)
def snapToDtm(self):
player = self.edit3d_pointlayerbox.currentLayer()
llayer = self.edit3d_linelayerbox.currentLayer()
rlayer = self.edit3d_dtmlayerbox.currentLayer()
llayer.startEditing()
points = list(player.getFeatures())
pointid = self.edit3d_currPointId.value()
if points:
point = points[pointid]
pointGeom = point.geometry()
if pointGeom.asMultiPoint():
pointGeom = pointGeom.asMultiPoint()[0]
else:
pointGeom = pointGeom.asPoint()
pid, feat = closestpoint(llayer, QgsGeometry.fromPoint(pointGeom))
linegeom = feat.geometry().asWkb().data()
olinegeom = ogr.CreateGeometryFromWkb(linegeom)
dx = rlayer.rasterUnitsPerPixelX()
dy = rlayer.rasterUnitsPerPixelY()
xpos = pointGeom.x()
ypos = pointGeom.y()
# assume pixel = center
xll = rlayer.extent().xMinimum() + 0.5 * dx
yll = rlayer.extent().yMinimum() + 0.5 * dy
xoffs = (pointGeom.x() - xll) % dx
yoffs = (pointGeom.y() - yll) % dy
dtm_val_ll = rlayer.dataProvider().identify(
QgsPoint(xpos - dx / 2, ypos - dy / 2),
QgsRaster.IdentifyFormatValue).results()[1]
dtm_val_ur = rlayer.dataProvider().identify(
QgsPoint(xpos + dx / 2, ypos + dy / 2),
QgsRaster.IdentifyFormatValue).results()[1]
dtm_val_lr = rlayer.dataProvider().identify(
QgsPoint(xpos + dx / 2, ypos - dy / 2),
QgsRaster.IdentifyFormatValue).results()[1]
dtm_val_ul = rlayer.dataProvider().identify(
QgsPoint(xpos - dx / 2, ypos + dy / 2),
QgsRaster.IdentifyFormatValue).results()[1]
a00 = dtm_val_ll
a10 = dtm_val_lr - dtm_val_ll
a01 = dtm_val_ul - dtm_val_ll
a11 = dtm_val_ur + dtm_val_ll - (dtm_val_lr + dtm_val_ul)
dtm_bilinear = a00 + a10 * xoffs + a01 * yoffs + a11 * xoffs * yoffs
x, y = olinegeom.GetPoint_2D(pid)
olinegeom.SetPoint(pid, x, y, dtm_bilinear)
llayer.beginEditCommand("Snap point height to DTM")
updatedGeom = QgsGeometry()
updatedGeom.fromWkb(olinegeom.ExportToWkb())
llayer.dataProvider().changeGeometryValues(
{feat.id(): updatedGeom})
llayer.endEditCommand()
# refresh vertex editor
self.showProblemPoint()
def removeNode(self):
player = self.edit3d_pointlayerbox.currentLayer()
llayer = self.edit3d_linelayerbox.currentLayer()
llayer.startEditing()
points = list(player.getFeatures())
pointid = self.edit3d_currPointId.value()
if points:
point = points[pointid]
pointGeom = point.geometry()
pid, feat = closestpoint(llayer, pointGeom)
llayer.beginEditCommand("Vertex removed")
llayer.deleteVertex(feat.id(), pid)
llayer.endEditCommand()
def nextProblemPoint(self):
pointid = self.edit3d_currPointId.value()
self.edit3d_currPointId.setValue(pointid + 1)
def showProblemPoint(self):
player = self.edit3d_pointlayerbox.currentLayer()
llayer = self.edit3d_linelayerbox.currentLayer()
self.iface.setActiveLayer(llayer)
mc = self.iface.mapCanvas()
# get first layer
#llayer.startEditing()
#self.iface.actionVertexTool().trigger()
# get point position
points = list(player.getFeatures())
pointid = self.edit3d_currPointId.value()
if points:
point = points[pointid]
pointGeom = point.geometry().asMultiPoint()[0] if point.geometry(
).asMultiPoint() else point.geometry().asPoint()
t = QgsCoordinateTransform(llayer.crs(),
mc.mapSettings().destinationCrs(),
QgsCoordinateTransformContext())
tCenter = t.transform(pointGeom)
rect = QgsRectangle(tCenter, tCenter)
mc.setExtent(rect)
#pos = QgsMapTool(self.iface.mapCanvas()).toCanvasCoordinates(tCenter)
#click = QMouseEvent(QEvent.MouseButtonPress, pos, Qt.LeftButton, Qt.LeftButton, Qt.NoModifier)
#mc.mousePressEvent(click)
#mc.mousePressEvent(click)
mc.refresh()
#vertexDock = \
# [ch for ch in self.iface.mainWindow().findChildren(QDockWidget, "") if
# ch.windowTitle() == u'Vertex Editor']
#if vertexDock:
# vertexDock = vertexDock[0]
# self.editingls.addWidget(vertexDock)
mc.refresh()
def nodeLayerChanged(self):
if self.edit3d_pointlayerbox.currentLayer():
self.selectNodeBtn.setText("Next point")
self.selectNodeBtn.setEnabled(True)
cnt = self.edit3d_pointlayerbox.currentLayer().featureCount() - 1
self.edit3d_countLabel.setText(str(cnt))
self.edit3d_currPointId.setMaximum(cnt)
def createWidget(self):
self.scrollwidget = QtWidgets.QScrollArea()
self.scrollwidget.setWidgetResizable(True)
self.tabs = QtWidgets.QTabWidget()
self.scrollwidget.setWidget(self.tabs)
self.names = [
'Settings', 'DTM', 'Slope', '2D-Approximation',
'Topologic correction', 'Editing', '3D-Modelling', 'Editing (3D)',
'Export'
]
self.widgets = {}
self.settings = {}
self.modules = {}
for idx, name in enumerate(self.names):
self.widgets[name] = QtWidgets.QDialog()
ls = QtWidgets.QFormLayout()
# Tab-specific options
if name == "Settings":
desc = QtWidgets.QLabel(
"Welcome to the qpals LineModeler GUI! \nThis tool will help you to detect and "
"model breaklines based on a DTM and/or a point cloud using the opals module "
"opalsLineModeler.\nThe process includes manual editing in QGIS (\"Editing\") "
"as well as automatic dectection and modelling.\n\n"
"To begin, please enter some basic information.")
desc.setWordWrap(True)
ls.addRow(desc)
boxRun = QtWidgets.QGroupBox(
"Run multiple steps automatically:")
boxVL = QtWidgets.QVBoxLayout()
boxRun.setLayout(boxVL)
self.settings['settings'] = OrderedDict([
('name', QtWidgets.QLineEdit()),
('inFile',
QpalsDropTextbox.QpalsDropTextbox(
layerlist=self.layerlist)),
('tempFolder', QpalsDropTextbox.QpalsDropTextbox()),
('outFolder', QpalsDropTextbox.QpalsDropTextbox()),
('chkDTM', QtWidgets.QCheckBox("DTM")),
('chkSlope', QtWidgets.QCheckBox("Slope")),
('chk2D', QtWidgets.QCheckBox("2D-Approximation")),
('chktopo2D',
QtWidgets.QCheckBox("Topological correction")),
('chkEditing2d',
QtWidgets.QLabel(
"--- Manual editing of 2D-Approximations ---")),
('chk3Dmodel', QtWidgets.QCheckBox("3D-Modelling")),
('chkEditing3d',
QtWidgets.QLabel("--- Manual editing of 3D-Lines ---")),
('chkExport', QtWidgets.QCheckBox("Export")),
])
for key, value in list(self.settings['settings'].items()):
if isinstance(value, QpalsDropTextbox.QpalsDropTextbox):
value.setMinimumContentsLength(20)
value.setSizeAdjustPolicy(
QtWidgets.QComboBox.AdjustToMinimumContentsLength)
if key.startswith("chk"):
boxVL.addWidget(value)
ls.addRow(QtWidgets.QLabel("Project name"),
self.settings['settings']['name'])
hbox_wrap = QtWidgets.QHBoxLayout()
hbox_wrap.addWidget(self.settings['settings']['inFile'],
stretch=1)
ls.addRow(QtWidgets.QLabel("Input file (TIFF/LAS/ODM)"),
hbox_wrap)
hbox_wrap = QtWidgets.QHBoxLayout()
hbox_wrap.addWidget(self.settings['settings']['tempFolder'],
stretch=1)
self.settings['settings']['tempFolder'].setPlaceholderText(
"drop folder here (will be created if not exists)")
ls.addRow(QtWidgets.QLabel("Folder for temporary files"),
hbox_wrap)
hbox_wrap = QtWidgets.QHBoxLayout()
self.settings['settings']['outFolder'].setPlaceholderText(
"drop folder here (will be created if not exists)")
hbox_wrap.addWidget(self.settings['settings']['outFolder'],
stretch=1)
ls.addRow(QtWidgets.QLabel("Folder for output files"),
hbox_wrap)
ls.addRow(QtWidgets.QLabel(""))
boxBtnRun = QtWidgets.QPushButton("Run selected steps now")
boxBtnRun.clicked.connect(lambda: self.run_step("all"))
boxBtnExp = QtWidgets.QPushButton(
"Export selected steps to .bat")
boxBtnExp.clicked.connect(self.createBatFile)
# saveBtn = QtWidgets.QPushButton("Save to project file")
# saveBtn.clicked.connect(self.save)
boxVL.addWidget(boxBtnRun)
boxVL.addWidget(boxBtnExp)
# boxVL.addWidget(saveBtn)
ls.addRow(boxRun)
if name == "DTM":
desc = QtWidgets.QLabel(
"This first step will create a digital terrain model (DTM) from your point cloud data. "
"Also, a shading of your DTM "
"will be created for visualisation purposes. If the input file is not an ODM, one has to be "
"created for the modelling process later on.")
desc.setWordWrap(True)
ls.addRow(desc)
impmod, impscroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsImport", "opalsImport", self.project,
{'outFile': 'pointcloud.odm'}, ["inFile", "outFile"])
self.modules['dtmImp'] = impmod
self.widgets['dtmImp'] = impscroll
ls.addRow(impscroll)
dtmmod, dtmscroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsGrid", "opalsGrid", self.project, {
'interpolation': 'movingPlanes',
'gridSize': '1',
'outFile': 'DTM_1m.tif'
}, [
"inFile", "outFile", "neighbours", "searchRadius",
"interpolation"
])
self.modules['dtmGrid'] = dtmmod
self.widgets['dtmGrid'] = dtmscroll
dtmmod.afterRun = self.addDtm
ls.addRow(dtmscroll)
shdmod, shdscroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsShade", "opalsShade", self.project, {
'inFile': 'DTM_1m.tif',
'outFile': 'DTM_1m_shd.tif'
}, [
"inFile",
"outFile",
])
self.modules['dtmShade'] = shdmod
shdmod.afterRun = self.addShd
ls.addRow(shdscroll)
if name == "Slope":
desc = QtWidgets.QLabel(
"To automatically detect breaklines, a slope map is calculated. This map uses the neighboring 9"
" pixels to estimate a plane. The gradient (steepest slope) is then taken, converted to a slope"
"in degrees, and assigned to the pixel.")
desc.setWordWrap(True)
ls.addRow(desc)
gfmod, gfscroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsGridFeature", "opalsGridFeature", self.project, {
'feature': 'slpDeg',
'inFile': 'DTM_1m.tif',
'outFile': 'DTM_1m_slope.tif'
}, ["inFile", "outFile", "feature"])
self.modules['slope'] = gfmod
ls.addRow(gfscroll)
if name == "2D-Approximation":
desc = QtWidgets.QLabel(
"The slope map is used to detect breaklines. For this, the algorithm by Canny (1986) is used.\n"
"First, the slope map is convoluted with a gaussian kernel for smoothing, then the derivative "
"is calculated. The two threshold parameters represent the upper and lower values for the "
"binarization of the derivative map. Edges that have at least one pixel > upper threshold will be "
"followed until they have a pixel < lower threshold.")
desc.setWordWrap(True)
ls.addRow(desc)
edgeDmod, edgeDscroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsEdgeDetect", "opalsEdgeDetect", self.project, {
'threshold': '2;4',
'sigmaSmooth': '1.8',
'inFile': 'DTM_1m_slope_slpDeg.tif',
'outFile': 'detected_edges.tif'
}, ["inFile", "outFile", "threshold", "sigmaSmooth"])
self.modules['edgeDetect'] = edgeDmod
ls.addRow(edgeDscroll)
desc = QtWidgets.QLabel(
"Since the output of opalsEdgeDetect is still a raster, we need to vectorize it:"
)
desc.setWordWrap(True)
ls.addRow(desc)
vecmod, vecscroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsVectorize", "opalsVectorize", self.project, {
'inFile': 'detected_edges.tif',
'outFile': 'detected_edges.shp'
}, ["inFile", "outFile"])
self.modules['vectorize'] = vecmod
ls.addRow(vecscroll)
if name == "Topologic correction":
desc = QtWidgets.QLabel(
"Vectorized binary rasters usually need some topological cleaning. Here, this is done in three steps: \n"
"1) Find the longest line and remove all lines < 10m\n"
"2) Merge lines iteratively\n"
"3) Clean up")
desc.setWordWrap(True)
ls.addRow(desc)
lt1mod, lt1scroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsLineTopology", "opalsLineTopology (1)", self.project,
{
'method': 'longest',
'minLength': '10',
'snapRadius': '0',
'maxTol': '0.5',
'maxAngleDev': '75;15',
'avgDist': '3',
'inFile': 'detected_edges.shp',
'outFile': 'edges1.shp'
}, ["inFile", "outFile", "method", "minLength", "maxTol"])
self.modules['lt1'] = lt1mod
ls.addRow(lt1scroll)
lt2mod, lt2scroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsLineTopology", "opalsLineTopology (2)", self.project,
{
'method': 'merge',
'minLength': '10',
'snapRadius': '3',
'maxTol': '0',
'maxAngleDev': '150;15',
'avgDist': '3',
'merge.minWeight': '0.75',
'merge.relWeightLead': '0',
'merge.maxIter': '10',
'merge.revertDist': '5',
'merge.revertInterval': '1',
'merge.searchGeneration': '4',
'merge.preventIntersection': '1',
'inFile': 'edges1.shp',
'outFile': 'edges2.shp'
}, [
"inFile", "outFile", "method", "maxAngleDev",
"snapRadius", "merge\..*"
])
lt2scroll.setFixedHeight(lt2scroll.height() - 200)
self.modules['lt2'] = lt2mod
ls.addRow(lt2scroll)
lt3mod, lt3scroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsLineTopology", "opalsLineTopology (3)", self.project,
{
'method': 'longest',
'minLength': '25',
'snapRadius': '0',
'maxTol': '0',
'maxAngleDev': '90;15',
'avgDist': '3',
'inFile': 'edges2.shp',
'outFile': 'edges3.shp'
}, ["inFile", "outFile", "method", "minLength", "maxTol"])
self.modules['lt3'] = lt3mod
ls.addRow(lt3scroll)
lt3mod.afterRun = self.add2DLines
if name == "Editing":
desc = QtWidgets.QLabel(
"Please start editing the 2D approximations that have been loaded into qgis. Here are some tools "
"that might help:")
desc.setWordWrap(True)
ls.addRow(desc)
box1 = QtWidgets.QGroupBox("QuickLineModeller")
from . import QpalsQuickLM
self.quicklm = QpalsQuickLM.QpalsQuickLM(
project=self.project,
layerlist=self.layerlist,
iface=self.iface)
box1.setLayout(self.quicklm.fl)
ls.addRow(box1)
box2 = QtWidgets.QGroupBox("qpalsSection")
from . import QpalsSection
self.section = QpalsSection.QpalsSection(
project=self.project,
layerlist=self.layerlist,
iface=self.iface)
self.section.createWidget()
box2.setLayout(self.section.ls)
box2.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
ls.addRow(box2)
if name == "3D-Modelling":
desc = QtWidgets.QLabel(
"The 2D approximations can now be used to model 3D breaklines in the pointcloud/the DTM."
)
desc.setWordWrap(True)
ls.addRow(desc)
lmmod, lmscroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsLineModeler",
"opalsLineModeler",
self.project,
{ #"filter": "Class[Ground]",
"approxFile": "edges3.shp",
"outFile": "modelled_lines.shp"
},
[
"inFile", "approxFile", "outFile", "filter",
"patchLength", "patchWidth", "overlap", "angle",
"minLength", "pointCount", "sigmaApriori"
])
self.modules['lm'] = lmmod
ls.addRow(lmscroll)
lmmod.afterRun = self.add3DLines
if name == "Editing (3D)":
desc = QtWidgets.QLabel(
"Before exporting the final product, there are a few tools to check the "
"quality of the result. This includes a topological check as well as a search"
"for points that have a big height difference to the DTM - and might be erraneous."
)
desc.setWordWrap(True)
ls.addRow(desc)
self.startQualityCheckBtn = QtWidgets.QPushButton(
"Start calculation")
self.startQualityCheckBtn.clicked.connect(
self.runProblemSearchAsync)
self.QualityCheckbar = QtWidgets.QProgressBar()
self.QualityCheckDtm = QgsMapLayerComboBox()
self.QualityCheckDtm.setFilters(
QgsMapLayerProxyModel.RasterLayer)
self.QualityCheckThreshold = QtWidgets.QLineEdit("0.5")
ls.addRow(
QtWidgets.QLabel("DTM Layer to compare heights with"),
self.QualityCheckDtm)
ls.addRow(
QtWidgets.QLabel("Set height difference threshold [m]"),
self.QualityCheckThreshold)
hb = QtWidgets.QHBoxLayout()
hb.addWidget(self.QualityCheckbar)
hb.addWidget(self.startQualityCheckBtn)
ls.addRow(hb)
line = QtWidgets.QFrame()
line.setFrameShape(QtWidgets.QFrame.HLine)
line.setFrameShadow(QtWidgets.QFrame.Sunken)
ls.addRow(line)
self.editingls = ls
self.edit3d_linelayerbox = QgsMapLayerComboBox()
self.edit3d_linelayerbox.setFilters(
QgsMapLayerProxyModel.LineLayer)
self.edit3d_pointlayerbox = QgsMapLayerComboBox()
self.edit3d_pointlayerbox.setFilters(
QgsMapLayerProxyModel.PointLayer)
self.edit3d_dtmlayerbox = QgsMapLayerComboBox()
self.edit3d_dtmlayerbox.setFilters(
QgsMapLayerProxyModel.RasterLayer)
self.edit3d_pointlayerbox.currentIndexChanged.connect(
self.nodeLayerChanged)
self.edit3d_currPointId = QSpinBox()
self.edit3d_currPointId.setMinimum(0)
self.edit3d_currPointId.valueChanged.connect(
self.showProblemPoint)
ls.addRow("Select Line Layer:", self.edit3d_linelayerbox)
ls.addRow("Select Problem Point layer:",
self.edit3d_pointlayerbox)
self.selectNodeBtn = QtWidgets.QPushButton("Next point")
self.selectNodeBtn.clicked.connect(
lambda: self.edit3d_currPointId.setValue(
self.edit3d_currPointId.value() + 1))
self.selectPrevNodeBtn = QtWidgets.QPushButton("Prev point")
self.selectPrevNodeBtn.clicked.connect(
lambda: self.edit3d_currPointId.setValue(
self.edit3d_currPointId.value() - 1))
self.edit3d_countLabel = QtWidgets.QLabel()
self.snapToDtmBtn = QtWidgets.QPushButton("Snap to:")
self.snapToDtmBtn.clicked.connect(self.snapToDtm)
self.remonveNodeBtn = QtWidgets.QPushButton("Remove")
self.remonveNodeBtn.clicked.connect(self.removeNode)
nextBox = QtWidgets.QHBoxLayout()
nextBox.addWidget(QtWidgets.QLabel("Current point:"))
nextBox.addWidget(self.edit3d_currPointId)
nextBox.addWidget(QtWidgets.QLabel("/"))
nextBox.addWidget(self.edit3d_countLabel)
nextBox.addStretch()
nextBox.addWidget(self.snapToDtmBtn)
nextBox.addWidget(self.edit3d_dtmlayerbox)
nextBox.addWidget(self.remonveNodeBtn)
nextBox.addWidget(self.selectPrevNodeBtn)
nextBox.addWidget(self.selectNodeBtn)
ls.addRow(nextBox)
self.nodeLayerChanged()
if name == "Export":
exp2mod, exp2scroll = QpalsModuleBase.QpalsModuleBase.createGroupBox(
"opalsTranslate", "opalsTranslate", self.project, {
'oformat': 'shp',
'inFile': 'modelled_lines.shp',
'outFile': 'STRULI3D.shp',
}, ["inFile", "outFile"])
self.modules['exp'] = exp2mod
ls.addRow(exp2scroll)
vl = QtWidgets.QVBoxLayout()
vl.addLayout(ls, 1)
navbar = QtWidgets.QHBoxLayout()
next = QtWidgets.QPushButton("Next step >")
next.clicked.connect(self.switchToNextTab)
prev = QtWidgets.QPushButton("< Previous step")
prev.clicked.connect(self.switchToPrevTab)
runcurr = QtWidgets.QPushButton(
"Run this step (all modules above)")
runcurr.clicked.connect(lambda: self.run_step(None))
if idx > 0:
navbar.addWidget(prev)
navbar.addStretch()
if name in [
"DTM", "Slope", "2D-Approximation", "Topologic correction",
"3D-Modelling", "Export"
]:
navbar.addWidget(runcurr)
navbar.addStretch()
if idx < len(self.names):
navbar.addWidget(next)
vl.addLayout(navbar)
self.widgets[name].setLayout(vl)
self.tabs.addTab(self.widgets[name], name)
# set up connections
self.tabs.currentChanged.connect(self.updateTabs)
return self.scrollwidget
def run_step(self, step_name=None):
curridx = self.tabs.currentIndex()
if step_name is None:
step_name = self.names[curridx]
modules = self.get_step_modules(step_name=step_name)
self.multirunner = qMMR()
for mod in modules:
self.multirunner.add_module(mod, mod.updateBar,
mod.run_async_finished, mod.errorBar)
self.multirunner.start()
def get_step_modules(self, step_name=None):
steps_modules = {
"DTM": [
self.modules['dtmImp'], self.modules['dtmGrid'],
self.modules['dtmShade']
],
"Slope": [self.modules['slope']],
"2D-Approximation":
[self.modules['edgeDetect'], self.modules['vectorize']],
"Topologic correction":
[self.modules['lt1'], self.modules['lt2'], self.modules['lt3']],
"3D-Modelling": [self.modules['lm']],
"Export": [self.modules['exp']]
}
if step_name == "all":
modules = []
if self.settings['settings']['chkDTM'].isChecked():
modules += steps_modules["DTM"]
if self.settings['settings']['chkSlope'].isChecked():
modules += steps_modules["Slope"]
if self.settings['settings']['chk2D'].isChecked():
modules += steps_modules["2D-Approximation"]
if self.settings['settings']['chktopo2D'].isChecked():
modules += steps_modules["Topologic correction"]
if self.settings['settings']['chk3Dmodel'].isChecked():
modules += steps_modules["3D-Modelling"]
if self.settings['settings']['chkExport'].isChecked():
modules += steps_modules["Export"]
else:
modules = steps_modules[step_name]
return modules
def createBatFile(self):
saveTo = QtWidgets.QFileDialog.getSaveFileName(None,
caption='Save to file')
try:
f = open(saveTo, 'w')
f.write("rem BATCH FILE CREATED WITH QPALS\r\n")
modules = self.get_step_modules("all")
for module in modules:
f.write(str(module) + "\r\n")
f.close()
except Exception as e:
raise Exception("Saving to batch failed.", e)
def updateBar(self, message):
out_lines = [item for item in re.split("[\n\r\b]", message) if item]
percentage = out_lines[-1]
# print percentage
if r"%" in percentage:
perc = QpalsModuleBase.get_percentage(percentage)
self.secInst.progress.setValue(int(perc))
def addDtm(self):
file = self.modules['dtmGrid'].getParam('outFile').val
if not os.path.isabs(file):
file = os.path.join(self.project.workdir, file)
self.iface.addRasterLayer(file, "DTM")
def addShd(self):
file = self.modules['dtmShade'].getParam('outFile').val
if not os.path.isabs(file):
file = os.path.join(self.project.workdir, file)
self.iface.addRasterLayer(file, "DTM-Shading")
def add2DLines(self):
file = self.modules['lt3'].getParam('outFile').val
if not os.path.isabs(file):
file = os.path.join(self.project.workdir, file)
self.iface.addVectorLayer(file, "2D-Approximations", "ogr")
def add3DLines(self):
file = self.modules['lm'].getParam('outFile').val
if not os.path.isabs(file):
file = os.path.join(self.project.workdir, file)
self.iface.addVectorLayer(file, "3D Modelled Lines", "ogr")
def runProblemSearchAsync(self):
linefile = self.modules['lm'].getParam('outFile').val
if not os.path.isabs(linefile):
linefile = os.path.join(self.project.workdir, linefile)
dtm = self.QualityCheckDtm.currentLayer()
dtm_thres = self.QualityCheckThreshold.text()
try:
dtm_thres = float(dtm_thres)
except:
dtm_thres = 0
self.QualityWorker = findDoubleSegments.RunWorker(
linefile, os.path.join(self.project.workdir, "quality"), dtm,
dtm_thres, 50, 1000)
self.QualityWorker.progress.connect(self.updateQualityBar)
self.QualityWorker.finished.connect(self.QualityFinished)
self.QualityWorker.error.connect(self.problemSearchError)
self.QualityThread = QtCore.QThread()
self.QualityWorker.moveToThread(self.QualityThread)
self.QualityThread.started.connect(self.QualityWorker.run)
self.QualityThread.start()
self.startQualityCheckBtn.setEnabled(False)
self.startQualityCheckBtn.setText("processing...")
def problemSearchError(self, err):
(msg, e, mod) = err
print(msg)
def updateQualityBar(self, fl):
self.QualityCheckbar.setValue(fl)
def QualityFinished(self):
self.startQualityCheckBtn.setEnabled(True)
self.startQualityCheckBtn.setText("Start calculation")
self.updateQualityBar(100)
file = os.path.join(self.project.workdir, "quality", "problems.shp")
self.iface.addVectorLayer(file, "Problems", "ogr")
# def save(self):
# import cPickle
# proj = QgsProject.instance()
# tabs = cPickle.dumps(self.tabs, -1)
# proj.writeEntry("qpals", "linemodelerinst", tabs)
# print tabs
def close(self):
# remove rubber band if present
if self.section.ltool.rb:
self.section.ltool.canvas.scene().removeItem(self.section.ltool.rb)
self.iface.actionPan().trigger()
class DistrictSettingsDialog(QDialog):
"""
A dialog used for plugin settings
"""
def __init__(self, parent=None): # pylint: disable=too-many-statements
super().__init__(parent)
self.setWindowTitle(self.tr('Redistrict Plugin | Settings'))
layout = QVBoxLayout()
self.auth_label = QLabel(self.tr('Authentication configuration'))
layout.addWidget(self.auth_label)
self.auth_value = QgsAuthConfigSelect()
layout.addWidget(self.auth_value)
auth_id = get_auth_config_id()
if auth_id:
self.auth_value.setConfigId(auth_id)
layout.addWidget(QLabel(self.tr('API base URL')))
self.base_url_edit = QLineEdit()
self.base_url_edit.setText(QgsSettings().value('redistrict/base_url', '', str, QgsSettings.Plugins))
layout.addWidget(self.base_url_edit)
h_layout = QHBoxLayout()
h_layout.addWidget(QLabel(self.tr('Check for completed requests every')))
self.check_every_spin = QSpinBox()
self.check_every_spin.setMinimum(10)
self.check_every_spin.setMaximum(600)
self.check_every_spin.setSuffix(' ' + self.tr('s'))
self.check_every_spin.setValue(QgsSettings().value('redistrict/check_every', '30', int, QgsSettings.Plugins))
h_layout.addWidget(self.check_every_spin)
layout.addLayout(h_layout)
self.use_mock_checkbox = QCheckBox(self.tr('Use mock Statistics NZ API'))
self.use_mock_checkbox.setChecked(get_use_mock_api())
layout.addWidget(self.use_mock_checkbox)
self.test_button = QPushButton(self.tr('Test API connection'))
self.test_button.clicked.connect(self.test_api)
layout.addWidget(self.test_button)
self.use_overlays_checkbox = QCheckBox(self.tr('Show updated populations during interactive redistricting'))
self.use_overlays_checkbox.setChecked(
QgsSettings().value('redistrict/show_overlays', False, bool, QgsSettings.Plugins))
layout.addWidget(self.use_overlays_checkbox)
self.use_sound_group_box = QGroupBox(self.tr('Use audio feedback'))
self.use_sound_group_box.setCheckable(True)
self.use_sound_group_box.setChecked(
QgsSettings().value('redistrict/use_audio_feedback', False, bool, QgsSettings.Plugins))
sound_layout = QGridLayout()
sound_layout.addWidget(QLabel(self.tr('When meshblock redistricted')), 0, 0)
self.on_redistrict_file_widget = QgsFileWidget()
self.on_redistrict_file_widget.setDialogTitle(self.tr('Select Audio File'))
self.on_redistrict_file_widget.setStorageMode(QgsFileWidget.GetFile)
self.on_redistrict_file_widget.setFilePath(
QgsSettings().value('redistrict/on_redistrict', '', str, QgsSettings.Plugins))
self.on_redistrict_file_widget.setFilter(self.tr('Wave files (*.wav *.WAV)'))
sound_layout.addWidget(self.on_redistrict_file_widget, 0, 1)
self.play_on_redistrict_sound_button = QPushButton(self.tr('Test'))
self.play_on_redistrict_sound_button.clicked.connect(self.play_on_redistrict_sound)
sound_layout.addWidget(self.play_on_redistrict_sound_button, 0, 2)
self.use_sound_group_box.setLayout(sound_layout)
layout.addWidget(self.use_sound_group_box)
button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
layout.addWidget(button_box)
button_box.rejected.connect(self.reject)
button_box.accepted.connect(self.accept)
self.setLayout(layout)
def accept(self): # pylint: disable=missing-docstring
super().accept()
QgsSettings().setValue('redistrict/auth_config_id', self.auth_value.configId(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/use_mock_api', self.use_mock_checkbox.isChecked(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/base_url', self.base_url_edit.text(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/check_every', self.check_every_spin.value(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/show_overlays', self.use_overlays_checkbox.isChecked(), QgsSettings.Plugins)
QgsSettings().setValue('redistrict/use_audio_feedback', self.use_sound_group_box.isChecked(),
QgsSettings.Plugins)
QgsSettings().setValue('redistrict/on_redistrict', self.on_redistrict_file_widget.filePath(),
QgsSettings.Plugins)
def test_api(self):
"""
Tests the API connection (real or mock!)
"""
connector = get_api_connector(use_mock=self.use_mock_checkbox.isChecked(),
authcfg=self.auth_value.configId(),
base_url=self.base_url_edit.text())
if connector.check():
QMessageBox.information(self, self.tr('Test API Connection'),
self.tr('API responded OK!'), QMessageBox.Ok)
else:
QMessageBox.critical(self, self.tr('Test API Connection'),
self.tr('Could not connect to API!'), QMessageBox.Ok)
def play_on_redistrict_sound(self):
"""
Plays the 'on redistrict' sound
"""
try:
playsound(self.on_redistrict_file_widget.filePath(), block=False)
except FileNotFoundError:
pass