def buildNetwork(self):
# edges
edges = vector.values(
self.linksLayer,
'source_vert',
'target_vert',
'link_cost',
'link_id',
'link_stress',
'int_id'
)
edgeCount = len(edges['link_id'])
for i in range(edgeCount):
self.DG.add_edge(
int(edges['source_vert'][i]),
int(edges['target_vert'][i]),
weight=max(edges['link_cost'][i],0),
link_id=edges['link_id'][i],
stress=min(edges['link_stress'][i],99),
int_id=edges['int_id'][i]
)
# vertices
verts = vector.values(
self.vertsLayer,
'vert_id',
'vert_cost',
'road_id'
)
vertCount = len(verts['vert_id'])
for i in range(vertCount):
vid = verts['vert_id'][i]
self.DG.node[vid]['weight'] = max(verts['vert_cost'][i],0)
self.DG.node[vid]['road_id'] = verts['road_id'][i]
def testValues(self):
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
res = vector.values(test_layer, 1)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# field by name
res = vector.values(test_layer, 'id')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# two fields
res = vector.values(test_layer, 1, 2)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name
res = vector.values(test_layer, 'id', 'id2')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res['id2'], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name and index
res = vector.values(test_layer, 'id', 2)
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, namefieldname, valuefieldname)
d = {}
for i in range(len(values[namefieldname])):
v = values[namefieldname][i]
if v not in d:
d[v] = [values[valuefieldname][i]]
else:
d[v].append(values[valuefieldname][i])
data = []
for k, v in d.items():
data.append(go.Box(y=list(v),
boxmean='sd',
name=k
))
plt.offline.plot(data, filename=output, auto_open=False)
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
namefieldname = self.parameterAsString(parameters, self.NAME_FIELD, context)
valuefieldname = self.parameterAsString(parameters, self.VALUE_FIELD, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, namefieldname, valuefieldname)
d = {}
for i in range(len(values[namefieldname])):
v = values[namefieldname][i]
if v not in d:
d[v] = [values[valuefieldname][i]]
else:
d[v].append(values[valuefieldname][i])
data = []
for k, v in d.items():
data.append(go.Box(y=list(v),
boxmean='sd',
name=k
))
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
namefieldname = self.parameterAsString(parameters, self.NAME_FIELD, context)
valuefieldname = self.parameterAsString(parameters, self.VALUE_FIELD, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, valuefieldname)
x_index = source.fields().lookupField(namefieldname)
x_var = vector.convert_nulls([i[namefieldname] for i in source.getFeatures(QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry).setSubsetOfAttributes([x_index]))], '<NULL>')
msdIndex = self.parameterAsEnum(parameters, self.MSD, context)
msd = True
if msdIndex == 1:
msd = 'sd'
elif msdIndex == 2:
msd = False
data = [go.Box(
x=x_var,
y=values[valuefieldname],
boxmean=msd)]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, valuefieldname)
x_var = [i[namefieldname] for i in layer.getFeatures()]
msdIndex = self.getParameterValue(self.MSD)
msd = True
if msdIndex == 1:
msd = 'sd'
elif msdIndex == 2:
msd = False
data = [go.Box(
x=x_var,
y=values[valuefieldname],
boxmean=msd)]
plt.offline.plot(data, filename=output, auto_open=False)
def test_attributeValues(self):
layer = processing.getObject(points())
attributeValues = values(layer, "ID")
i = 1
for value in attributeValues['ID']:
self.assertEqual(int(i), int(value))
i+=1
self.assertEquals(13,i)
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
fieldname = self.getParameterValue(self.FIELD)
bins = self.getParameterValue(self.BINS)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, fieldname)
data = [go.Histogram(x=values[fieldname],
nbinsx=bins)]
plt.offline.plot(data, filename=output, auto_open=False)
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
xfieldname = self.getParameterValue(self.XFIELD)
yfieldname = self.getParameterValue(self.YFIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, xfieldname, yfieldname)
data = [go.Scatter(x=values[xfieldname],
y=values[yfieldname],
mode='markers')]
plt.offline.plot(data, filename=output, auto_open=False)
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
namefieldname = self.getParameterValue(self.NAME_FIELD) # NOQA FIXME unused?
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, valuefieldname)
data = [go.Area(r=values[valuefieldname],
t=np.degrees(np.arange(0.0, 2 * np.pi, 2 * np.pi / len(values[valuefieldname]))))]
plt.offline.plot(data, filename=output, auto_open=False)
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, valuefieldname)
data = [go.Area(r=values[valuefieldname],
t=np.degrees(np.arange(0.0, 2 * np.pi, 2 * np.pi / len(values[valuefieldname]))))]
plt.offline.plot(data, filename=output, auto_open=False)
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
fieldname = self.getParameterValue(self.FIELD)
bins = self.getParameterValue(self.BINS)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, fieldname)
data = [go.Histogram(x=values[fieldname],
nbinsx=bins)]
plt.offline.plot(data, filename=output, auto_open=False)
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
namefieldname = self.parameterAsString(parameters, self.NAME_FIELD, context) # NOQA FIXME unused?
valuefieldname = self.parameterAsString(parameters, self.VALUE_FIELD, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, valuefieldname)
data = [go.Area(r=values[valuefieldname],
t=np.degrees(np.arange(0.0, 2 * np.pi, 2 * np.pi / len(values[valuefieldname]))))]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
xfieldname = self.parameterAsString(parameters, self.XFIELD, context)
yfieldname = self.parameterAsString(parameters, self.YFIELD, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, xfieldname, yfieldname)
data = [go.Scatter(x=values[xfieldname],
y=values[yfieldname],
mode='markers')]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, namefieldname, valuefieldname)
ind = np.arange(len(values[namefieldname]))
data = [go.Bar(x=ind,
y=values[valuefieldname])]
plt.offline.plot(data, filename=output, auto_open=False)
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
fieldname = self.parameterAsString(parameters, self.FIELD, context)
bins = self.parameterAsInt(parameters, self.BINS, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, fieldname)
data = [go.Histogram(x=values[fieldname],
nbinsx=bins)]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
fieldname = self.getParameterValue(self.FIELD)
bins = self.getParameterValue(self.BINS)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, fieldname)
plt.close()
plt.hist(values[fieldname], bins)
plotFilename = output + '.png'
lab.savefig(plotFilename)
with open(output, 'w') as f:
f.write('<html><img src="' + plotFilename + '"/></html>')
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
xfieldname = self.getParameterValue(self.XFIELD)
yfieldname = self.getParameterValue(self.YFIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, xfieldname, yfieldname)
plt.close()
plt.scatter(values[xfieldname], values[yfieldname])
plt.ylabel(yfieldname)
plt.xlabel(xfieldname)
plotFilename = output + ".png"
lab.savefig(plotFilename)
with open(output, "w") as f:
f.write('<html><img src="' + plotFilename + '"/></html>')
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
xfieldname = self.getParameterValue(self.YFIELD)
yfieldname = self.getParameterValue(self.XFIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, xfieldname, yfieldname)
plt.close()
plt.scatter(values[xfieldname], values[yfieldname])
plotFilename = output + '.png'
lab.savefig(plotFilename)
f = open(output, 'w')
f.write('<img src="' + plotFilename + '"/>')
f.close()
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
namefieldname = self.parameterAsString(parameters, self.NAME_FIELD, context)
valuefieldname = self.parameterAsString(parameters, self.VALUE_FIELD, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, valuefieldname)
x_var = [i[namefieldname] for i in source.getFeatures()]
data = [go.Bar(x=x_var,
y=values[valuefieldname])]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, namefieldname, valuefieldname)
plt.close()
ind = np.arange(len(values[namefieldname]))
width = 0.8
plt.bar(ind, values[valuefieldname], width, color='r')
plt.xticks(ind, values[namefieldname], rotation=45)
plotFilename = output + '.png'
lab.savefig(plotFilename)
with open(output, 'w') as f:
f.write('<html><img src="' + plotFilename + '"/></html>')
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
namefieldname = self.parameterAsString(parameters, self.NAME_FIELD, context)
valuefieldname = self.parameterAsString(parameters, self.VALUE_FIELD, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, valuefieldname)
x_var = vector.convert_nulls([i[namefieldname] for i in source.getFeatures(QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))], '<NULL>')
data = [go.Bar(x=x_var,
y=values[valuefieldname])]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, namefieldname, valuefieldname)
plt.close()
fig = figure(figsize=(8, 8))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)
N = len(values[valuefieldname])
theta = np.arange(0.0, 2 * np.pi, 2 * np.pi / N)
radii = values[valuefieldname]
width = 2 * np.pi / N
ax.bar(theta, radii, width=width, bottom=0.0)
plotFilename = output + ".png"
lab.savefig(plotFilename)
with open(output, "w") as f:
f.write('<html><img src="' + plotFilename + '"/></html>')
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
namefieldname = self.getParameterValue(self.NAME_FIELD)
meanfieldname = self.getParameterValue(self.MEAN_FIELD)
stddevfieldname = self.getParameterValue(self.STDDEV_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, namefieldname, meanfieldname, stddevfieldname)
plt.close()
ind = np.arange(len(values[namefieldname]))
width = 0.8
plt.bar(
ind, values[meanfieldname], width, color="r", yerr=values[stddevfieldname], error_kw=dict(ecolor="yellow")
)
plt.xticks(ind, values[namefieldname], rotation=45)
plotFilename = output + ".png"
lab.savefig(plotFilename)
with open(output, "w") as f:
f.write('<html><img src="' + plotFilename + '"/></html>')
def testValues(self):
ProcessingConfig.initialize()
# disable check for geometry validity
prevInvalidGeoms = ProcessingConfig.getSetting(
ProcessingConfig.FILTER_INVALID_GEOMETRIES)
ProcessingConfig.setSettingValue(
ProcessingConfig.FILTER_INVALID_GEOMETRIES, 0)
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
res = vector.values(test_layer, 1)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# field by name
res = vector.values(test_layer, 'id')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# two fields
res = vector.values(test_layer, 1, 2)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name
res = vector.values(test_layer, 'id', 'id2')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res['id2'], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name and index
res = vector.values(test_layer, 'id', 2)
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# test with selected features
previous_value = ProcessingConfig.getSetting(
ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
res = vector.values(test_layer, 1)
self.assertEqual(set(res[1]), set([5, 7, 3]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED,
previous_value)
ProcessingConfig.setSettingValue(
ProcessingConfig.FILTER_INVALID_GEOMETRIES, prevInvalidGeoms)
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
xfieldname = self.parameterAsString(parameters, self.XFIELD, context)
yfieldname = self.parameterAsString(parameters, self.YFIELD, context)
zfieldname = self.parameterAsString(parameters, self.ZFIELD, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, xfieldname, yfieldname, zfieldname)
data = [go.Scatter3d(
x=values[xfieldname],
y=values[yfieldname],
z=values[zfieldname],
mode='markers')]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, context, feedback):
layer = dataobjects.getLayerFromString(
self.getParameterValue(self.INPUT))
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, context, valuefieldname)
x_var = [i[namefieldname] for i in layer.getFeatures()]
msdIndex = self.getParameterValue(self.MSD)
msd = True
if msdIndex == 1:
msd = 'sd'
elif msdIndex == 2:
msd = False
data = [go.Box(x=x_var, y=values[valuefieldname], boxmean=msd)]
plt.offline.plot(data, filename=output, auto_open=False)
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
namefieldname = self.getParameterValue(self.NAME_FIELD)
meanfieldname = self.getParameterValue(self.MEAN_FIELD)
stddevfieldname = self.getParameterValue(self.STDDEV_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, namefieldname, meanfieldname, stddevfieldname)
plt.close()
ind = np.arange(len(values[namefieldname]))
width = 0.8
plt.bar(ind, values[meanfieldname], width, color='r',
yerr=values[stddevfieldname],
error_kw=dict(ecolor='yellow'),
)
plt.xticks(ind, values[namefieldname], rotation=45)
plotFilename = output + '.png'
lab.savefig(plotFilename)
with open(output, 'w') as f:
f.write('<html><img src="' + plotFilename + '"/></html>')
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
xfieldname = self.parameterAsString(parameters, self.XFIELD, context)
yfieldname = self.parameterAsString(parameters, self.YFIELD, context)
zfieldname = self.parameterAsString(parameters, self.ZFIELD, context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, xfieldname, yfieldname, zfieldname)
data = [
go.Scatter3d(x=values[xfieldname],
y=values[yfieldname],
z=values[zfieldname],
mode='markers')
]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
namefieldname = self.parameterAsString(parameters, self.NAME_FIELD,
context) # NOQA FIXME unused?
valuefieldname = self.parameterAsString(parameters, self.VALUE_FIELD,
context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, valuefieldname)
data = [
go.Area(r=values[valuefieldname],
t=np.degrees(
np.arange(0.0, 2 * np.pi,
2 * np.pi / len(values[valuefieldname]))))
]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
namefieldname = self.parameterAsString(parameters, self.NAME_FIELD,
context)
valuefieldname = self.parameterAsString(parameters, self.VALUE_FIELD,
context)
output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
values = vector.values(source, valuefieldname)
x_var = vector.convert_nulls([
i[namefieldname] for i in source.getFeatures(
QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
], '<NULL>')
data = [go.Bar(x=x_var, y=values[valuefieldname])]
plt.offline.plot(data, filename=output, auto_open=False)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
namefieldname = self.getParameterValue(self.NAME_FIELD)
valuefieldname = self.getParameterValue(self.VALUE_FIELD)
output = self.getOutputValue(self.OUTPUT)
values = vector.values(layer, namefieldname, valuefieldname)
d = {}
for i in range(len(values[namefieldname])):
v = values[namefieldname][i]
if v not in d:
d[v] = [values[valuefieldname][i]]
else:
d[v].append(values[valuefieldname][i])
data = []
for k, v in d.items():
data.append(go.Box(y=list(v),
boxmean='sd',
name=k
))
plt.offline.plot(data, filename=output, auto_open=False)
def testValues(self):
ProcessingConfig.initialize()
# disable check for geometry validity
prevInvalidGeoms = ProcessingConfig.getSetting(ProcessingConfig.FILTER_INVALID_GEOMETRIES)
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, 0)
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
res = vector.values(test_layer, 1)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# field by name
res = vector.values(test_layer, 'id')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# two fields
res = vector.values(test_layer, 1, 2)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name
res = vector.values(test_layer, 'id', 'id2')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res['id2'], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name and index
res = vector.values(test_layer, 'id', 2)
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
res = vector.values(test_layer, 1)
self.assertEqual(set(res[1]), set([5, 7, 3]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, prevInvalidGeoms)
def testValues(self):
ProcessingConfig.initialize()
test_data = points2()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
res = vector.values(test_layer, 0)
self.assertEqual(res[0], [1, 2, 3, 4, 5, 6, 7, 8])
# field by name
res = vector.values(test_layer, 'id')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8])
# two fields
res = vector.values(test_layer, 0, 3)
self.assertEqual(res[0], [1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(res[3], [2, 1, 0, 2, 1, 0, 0, 0])
# two fields by name
res = vector.values(test_layer, 'id', 'id_2')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(res['id_2'], [2, 1, 0, 2, 1, 0, 0, 0])
# two fields by name and index
res = vector.values(test_layer, 'id', 3)
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(res[3], [2, 1, 0, 2, 1, 0, 0, 0])
# test with selected features
previous_value = ProcessingConfig.getSetting(
ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
res = vector.values(test_layer, 0)
self.assertEqual(set(res[0]), set([5, 7, 3]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED,
previous_value)
def testValues(self):
ProcessingConfig.initialize()
test_data = points2()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
res = vector.values(test_layer, 0)
self.assertEqual(res[0], [1, 2, 3, 4, 5, 6, 7, 8])
# field by name
res = vector.values(test_layer, 'id')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8])
# two fields
res = vector.values(test_layer, 0, 3)
self.assertEqual(res[0], [1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(res[3], [2, 1, 0, 2, 1, 0, 0, 0])
# two fields by name
res = vector.values(test_layer, 'id', 'id_2')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(res['id_2'], [2, 1, 0, 2, 1, 0, 0, 0])
# two fields by name and index
res = vector.values(test_layer, 'id', 3)
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8])
self.assertEqual(res[3], [2, 1, 0, 2, 1, 0, 0, 0])
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
res = vector.values(test_layer, 0)
self.assertEqual(set(res[0]), set([5, 7, 3]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
def testValues(self):
context = QgsProcessingContext()
# disable check for geometry validity
context.setFlags(QgsProcessingContext.Flags(0))
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
res = vector.values(test_layer, context, 1)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# field by name
res = vector.values(test_layer, context, 'id')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# two fields
res = vector.values(test_layer, context, 1, 2)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name
res = vector.values(test_layer, context, 'id', 'id2')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res['id2'], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name and index
res = vector.values(test_layer, context, 'id', 2)
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# test with selected features
context.setFlags(QgsProcessingContext.UseSelectionIfPresent)
test_layer.selectByIds([2, 4, 6])
res = vector.values(test_layer, context, 1)
self.assertEqual(set(res[1]), set([5, 7, 3]))
def processAlgorithm(self, progress):
progress.setPercentage(0)
# Retrieve the values of the parameters entered by the user
roadsLayer = dataobjects.getObjectFromUri(
self.getParameterValue(self.ROADS_LAYER))
destsLayer = dataobjects.getObjectFromUri(
self.getParameterValue(self.DESTINATIONS_LAYER))
stress = self.getParameterValue(self.STRESS)
maxCost = self.getParameterValue(self.MAX_COST)
keepRaw = self.getParameterValue(self.KEEP_RAW)
keepRoutes = self.getParameterValue(self.KEEP_ROUTES)
keepSums = self.getParameterValue(self.KEEP_SUMS)
# build the raw output layer
if keepRaw:
rawFields = QgsFields()
rawFields.append(QgsField('path_id', QVariant.Int))
rawFields.append(QgsField('sequence', QVariant.Int))
rawFields.append(QgsField('from_road_id', QVariant.Int))
rawFields.append(QgsField('to_road_id', QVariant.Int))
rawFields.append(QgsField('int_id', QVariant.Int))
rawFields.append(QgsField('int_cost', QVariant.Int))
rawFields.append(QgsField('road_id', QVariant.Int))
rawFields.append(QgsField('road_cost', QVariant.Int))
rawFields.append(QgsField('cmtve_cost', QVariant.Int))
rawWriter = self.getOutputFromName(self.RAW_LAYER).getVectorWriter(
rawFields, QGis.WKBLineString, roadsLayer.crs())
if keepRoutes:
routeFields = QgsFields()
routeFields.append(QgsField('path_id', QVariant.Int))
routeFields.append(QgsField('from_road_id', QVariant.Int))
routeFields.append(QgsField('to_road_id', QVariant.Int))
routeFields.append(QgsField('cmtve_cost', QVariant.Int))
routeWriter = self.getOutputFromName(self.ROUTES_LAYER).getVectorWriter(
routeFields, QGis.WKBLineString, roadsLayer.crs())
sumFields = QgsFields()
sumFields.append(QgsField('road_id', QVariant.Int))
sumFields.append(QgsField('use_count', QVariant.Int))
if keepSums:
sumWriter = self.getOutputFromName(self.SUMS_LAYER).getVectorWriter(
sumFields, QGis.WKBLineString, roadsLayer.crs())
progress.setPercentage(2)
# establish db connection
progress.setInfo('Getting DB connection')
self.setDbFromRoadsLayer(roadsLayer)
self.setLayersFromDb()
# get network
progress.setInfo('Building network')
nu = NXUtils(self.vertsLayer,self.linksLayer)
nu.buildNetwork()
if not stress:
DG = nu.getNetwork()
else:
DG = nu.getStressNetwork(stress)
progress.setPercentage(10)
'''# Build spatial index of road features
progress.setInfo('Indexing road features')
index = vector.spatialindex(roadsLayer)
# Get nearest Road ID for input layer
progress.setInfo('Getting road IDs')
destinations = {}
for feat in vector.features(destsLayer):
roadMatch = QgsFeatureId()
destGeom = QgsGeometry(feat.geometry())
roadMatch = index.nearestNeighbor(destGeom.asPoint(),1)[0]
roadFeat = roadsLayer.getFeatures(QgsFeatureRequest().setFilterFid(roadMatch))[0]
roadGeom = QgsGeometry(roadFeat.geometry())
destinations[feat.id()] = {
'roadId': roadMatch,
'distance': 0
}'''
# Assume nearest Road ID and distance fields exist as road_id and road_dist
roadIds = list()
for val in vector.values(destsLayer,'road_id')['road_id']:
if val.is_integer():
roadIds.append(int(val))
else:
raise GeoAlgorithmExecutionException(
self.tr('Bad road_id values. Input field was %s. Check that \
these are integer values.' % 'road_id'))
# count pairs
roadPairCount = len(roadIds) ** 2 - len(roadIds)
progress.setInfo('%i total destination pairs identified' % roadPairCount)
# loop through each destination and get shortest routes to all others
try:
rowCount = 0
pairCount = 0
for fromRoad in roadIds:
for toRoad in roadIds:
if not fromRoad == toRoad:
# set counts
pairCount += 1
seq = 0
cost = 0
if pairCount % 1000 == 0:
progress.setInfo('Shortest path for pair %i of %i'
% (pairCount, RoadPairCount))
# set feature for route output
routeFeat = None
if keepRoutes:
routeFeat = QgsFeature(routeFields)
routeFeat.setAttribute(0,pairCount) #path_id
routeFeat.setAttribute(1,fromRoad) #from_road_id
routeFeat.setAttribute(2,toRoad) #to_road_id
# check the path and iterate through it
if nx.has_path(DG,source=fromRoad,target=toRoad):
shortestPath = nx.shortest_path(
DG,
source=fromRoad,
target=toRoad,
weight='weight'
)
for i, v1 in enumerate(shortestPath, start=1):
if i == len(shortestPath):
continue #Leave out because this is the last Roadex
rowCount += 1
v2 = shortestPath[i]
seq += 1
roads[roadId]['count'] += 1
# set costs
linkCost = DG.edge[v1][v2]['weight']
intCost = 0
cost += linkCost
cost += intCost
# create the new features
if roadId in roads and roads.get(roadId).get('geom'):
geom = roads.get(roadId).get('geom')
if keepRaw:
rawFeat = QgsFeature(rawFields)
rawFeat.setAttribute(0,pairCount) #path_id
rawFeat.setAttribute(1,seq) #sequence
rawFeat.setAttribute(2,fromRoad) #from_road_id
rawFeat.setAttribute(3,toRoad) #to_road_id
rawFeat.setAttribute(4,DG.node[v2]['int_id']) #int_id
rawFeat.setAttribute(5,intCost) #int_cost
rawFeat.setAttribute(6,roadId) #road_id
rawFeat.setAttribute(7,linkCost) #road_cost
rawFeat.setAttribute(8,cost) #cmtve_cost
rawFeat.setGeometry(geom)
rawWriter.addFeature(rawFeat)
del rawFeat
if keepRoutes:
routeFeat.setAttribute(3,cost) #cmtve_cost
if not routeFeat.constGeometry():
routeFeat.setGeometry(geom)
else:
routeFeat.setGeometry(
geom.combine(routeFeat.constGeometry())
)
routeWriter.addFeature(routeFeat)
if keepSums:
sumFeat = roads.get(roadId).get('feat')
useCount = roads.get(roadId).get('count')
sumFeat.setAttribute(1,useCount) #use_count
del routeFeat
progress.setPercentage(10 + 90*pairCount/RoadPairCount)
for roadId, r in roads.iteritems():
if r.get('count') > 0:
if keepSums:
sumWriter.addFeature(r.get('feat'))
except Exception, e:
raise GeoAlgorithmExecutionException('Uncaught error: %s' % e)
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
# Retrieve the feature source and sink. The 'dest_id' variable is used
# to uniquely identify the feature sink, and must be included in the
# dictionary returned by the processAlgorithm function.
source = self.parameterAsSource(
parameters,
self.INPUT,
context
)
# If source was not found, throw an exception to indicate that the
# algorithm encountered a fatal error. The exception text can be any
# string, but in this case we use the pre-built invalidSourceError
# method to return a standard helper text for when a source cannot be
# evaluated
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
fields_to_transform = self.parameterAsFields(
parameters, self.FIELDS_TO_TRANSFORM, context)
source_fields = source.fields()
if not fields_to_transform:
# no fields selected, use all numeric ones
fields_to_transform = [source_fields.at(i).name()
for i in range(len(source_fields))
if source_fields.at(i).isNumeric()]
self.transformed_fields = QgsFields()
transformation_name = self.name()
fields_to_transform_idxs = []
for f in fields_to_transform:
idx = source.fields().lookupField(f)
if idx >= 0:
fields_to_transform_idxs.append(idx)
field_to_transform = source.fields().at(idx)
if field_to_transform.isNumeric():
transformed_field = QgsField(field_to_transform)
transformed_field.setName(
"%s_%s" % (field_to_transform.name(),
transformation_name))
transformed_field.setType(QVariant.Double)
transformed_field.setLength(20)
transformed_field.setPrecision(6)
self.transformed_fields.append(transformed_field)
out_fields = QgsProcessingUtils.combineFields(
source_fields, self.transformed_fields)
(sink, self.dest_id) = self.parameterAsSink(
parameters,
self.OUTPUT,
context,
out_fields,
source.wkbType(),
source.sourceCrs()
)
# Send some information to the user
feedback.pushInfo('CRS is {}'.format(source.sourceCrs().authid()))
# If sink was not created, throw an exception to indicate that the
# algorithm encountered a fatal error. The exception text can be any
# string, but in this case we use the pre-built invalidSinkError method
# to return a standard helper text for when a sink cannot be evaluated
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
total = 100.0 / len(fields_to_transform)
transformed_values = {}
for current, fieldname_to_transform in enumerate(fields_to_transform):
original_values = vector.values(
source, fieldname_to_transform)[fieldname_to_transform]
transformed_values[fieldname_to_transform] = self.transform_values(
original_values, parameters, context)
feedback.setProgress(int(current * total))
feedback.setProgress(0)
# Compute the number of steps to display within the progress bar and
# get features from source
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, source_feature in enumerate(source.getFeatures()):
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
break
sink_feature = QgsFeature(out_fields)
# copy original fields
for field in source.fields():
sink_feature[field.name()] = source_feature[field.name()]
for original_fieldname, transformed_field in zip(
fields_to_transform, self.transformed_fields):
sink_feature[transformed_field.name()] = \
transformed_values[original_fieldname][current]
sink_feature.setGeometry(source_feature.geometry())
# Add a feature in the sink
sink.addFeature(sink_feature, QgsFeatureSink.FastInsert)
# Update the progress bar
feedback.setProgress(int(current * total))
# Return the results of the algorithm. In this case our only result is
# the feature sink which contains the processed features, but some
# algorithms may return multiple feature sinks, calculated numeric
# statistics, etc. These should all be included in the returned
# dictionary, with keys matching the feature corresponding parameter
# or output names.
return {self.OUTPUT: self.dest_id}
