def test_boundaries_are_not_split(self):
print('\nINFO: Validating boundaries are not split...')
gpkg_path = get_test_copy_path('geopackage/tests_data.gpkg')
uri_bad_boundary = gpkg_path + '|layername={layername}'.format(
layername='bad_boundary')
uri_bbox_boundary = gpkg_path + '|layername={layername}'.format(
layername='bbox_intersect_boundary')
uri_good_boundary = gpkg_path + '|layername={layername}'.format(
layername='good_boundary')
bad_boundary_layer = QgsVectorLayer(uri_bad_boundary, 'bad_boundary',
'ogr')
bbox_boundary_layer = QgsVectorLayer(uri_bbox_boundary,
'bbox_intersect_boundary', 'ogr')
good_boundary_layer = QgsVectorLayer(uri_good_boundary,
'good_boundary', 'ogr')
bad_boundary_errors = self.qgis_utils.geometry.get_boundaries_connected_to_single_boundary(
bad_boundary_layer)
bad_boundary_errors_list = [item for item in bad_boundary_errors]
self.assertEquals(len(bad_boundary_errors_list), 4)
bbox_boundary_errors = self.qgis_utils.geometry.get_boundaries_connected_to_single_boundary(
bbox_boundary_layer)
bbox_boundary_errors_list = [item for item in bbox_boundary_errors]
self.assertEquals(len(bbox_boundary_errors_list), 9)
good_boundary_errors = self.qgis_utils.geometry.get_boundaries_connected_to_single_boundary(
good_boundary_layer)
good_boundary_errors_list = [item for item in good_boundary_errors]
self.assertEquals(len(good_boundary_errors_list), 0)
def test_check_right_of_way_overlaps_buildings(self):
print('\nINFO: Validating Right of Way-Building overlaps...')
gpkg_path = get_test_copy_path('db/static/gpkg/quality_validations.gpkg')
uri = gpkg_path + '|layername={layername}'.format(layername='construccion')
building_layer = QgsVectorLayer(uri, 'construccion', 'ogr')
uri = gpkg_path + '|layername={layername}'.format(layername='servidumbre_transito')
right_of_way_layer = QgsVectorLayer(uri, 'servidumbre_transito', 'ogr')
building_features = [feature for feature in building_layer.getFeatures()]
self.assertEqual(len(building_features), 4)
right_of_way_features = [feature for feature in right_of_way_layer.getFeatures()]
self.assertEqual(len(right_of_way_features), 6)
ids, over_pol = self.geometry.get_inner_intersections_between_polygons(right_of_way_layer, building_layer)
geometries = [v.asWkt() for v in over_pol.asGeometryCollection()]
self.assertEqual(len(geometries), 4)
self.assertIn('Polygon ((1091354.41819027159363031 1121694.23184006474912167, 1091354.2822037145961076 1121696.81558464490808547, 1091355.59206581697799265 1121695.52748471638187766, 1091354.41819027159363031 1121694.23184006474912167))', geometries)
self.assertIn('Polygon ((1091254.39762192475609481 1121590.49773243162781, 1091250.73030774760991335 1121597.99486360652372241, 1091259.24529790692031384 1121594.80259312898851931, 1091254.39762192475609481 1121590.49773243162781))', geometries)
self.assertIn('Polygon ((1091236.35652560647577047 1121774.96929413848556578, 1091240.31053024088032544 1121761.7039380690548569, 1091224.81715030129998922 1121764.51856614812277257, 1091236.35652560647577047 1121774.96929413848556578))', geometries)
self.assertIn('Polygon ((1091210.77726722555235028 1121751.80323319789022207, 1091216.81715549202635884 1121740.58629784546792507, 1091200.99485773546621203 1121742.94371541915461421, 1091210.77726722555235028 1121751.80323319789022207))', geometries)
def test_boundaries_are_not_split(self):
print('\nINFO: Validating boundaries are not split...')
gpkg_path = get_test_copy_path('db/static/gpkg/quality_validations.gpkg')
self.db_gpkg = get_gpkg_conn('tests_quality_validations_gpkg')
names = self.db_gpkg.names
names.T_ID_F = 't_id' # Static label is set because the database does not have the ladm structure
names.T_ILI_TID_F = 't_ili_tid' # Static label is set because the database does not have the ladm structure
uri_bad_boundary = gpkg_path + '|layername={layername}'.format(layername='bad_boundary')
uri_bbox_boundary = gpkg_path + '|layername={layername}'.format(layername='bbox_intersect_boundary')
uri_good_boundary = gpkg_path + '|layername={layername}'.format(layername='good_boundary')
bad_boundary_layer = QgsVectorLayer(uri_bad_boundary, 'bad_boundary', 'ogr')
bbox_boundary_layer = QgsVectorLayer(uri_bbox_boundary, 'bbox_intersect_boundary', 'ogr')
good_boundary_layer = QgsVectorLayer(uri_good_boundary, 'good_boundary', 'ogr')
bad_boundary_errors = self.geometry.get_boundaries_connected_to_single_boundary(names, bad_boundary_layer)
bad_boundary_errors_list = [item for item in bad_boundary_errors]
self.assertEqual(len(bad_boundary_errors_list), 4)
self.assertEqual([2, 3, 6, 7], [f['t_id'] for f in bad_boundary_errors])
bbox_boundary_errors = self.geometry.get_boundaries_connected_to_single_boundary(names, bbox_boundary_layer)
bbox_boundary_errors_list = [item for item in bbox_boundary_errors]
self.assertEqual(len(bbox_boundary_errors_list), 9)
self.assertEqual([39185, 39193, 39207, 39209, 39210, 39231, 39232, 48767, 48768], [f['t_id'] for f in bbox_boundary_errors_list])
good_boundary_errors = self.geometry.get_boundaries_connected_to_single_boundary(names, good_boundary_layer)
good_boundary_errors_list = [item for item in good_boundary_errors]
self.assertEqual(len(good_boundary_errors_list), 0)
def test_export_data_in_gpkg(self):
print("\nINFO: Validate Export Data in GPKG...")
gpkg_path = get_test_copy_path(
'geopackage/test_export_data_ladm_v1_0.gpkg')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = ExportConfiguration()
configuration.base_configuration = base_config
configuration.ilimodels = ';'.join([
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()
])
configuration.dbfile = gpkg_path
exporter = iliexporter.Exporter()
exporter.tool = DbIliMode.ili2gpkg
exporter.configuration = configuration
exporter.configuration.xtffile = os.path.join(self.base_test_path,
'test_export_data.xtf')
# exporter.stderr.connect(self.on_stderr)
self.assertEqual(exporter.run(), iliexporter.Exporter.SUCCESS)
self.check_export_xtf(exporter.configuration.xtffile)
def setUpClass(self):
print("\nINFO: Setting up copy Layer With different Geometries to DB validation...")
self.qgis_utils = QGISUtils()
# resore schemas
restore_schema('test_distinct_geoms')
restore_schema('test_ladm_col')
restore_schema('test_ladm_col_3d')
self.db_distinct_geoms = get_dbconn('test_distinct_geoms')
result = self.db_distinct_geoms.test_connection()
print('test_connection for: '.format('test_distinct_geoms'), result)
if not result[1]:
print('The test connection with {} db is not working'.format("test_distinct_geoms"))
return
self.db_connection = get_dbconn('test_ladm_col')
result = self.db_connection.test_connection()
print('test_connection for: '.format('test_ladm_col'), result)
if not result[1]:
print('The test connection with {} db is not working'.format("test_ladm_col"))
return
self.db_connection_3d = get_dbconn('test_ladm_col_3d')
result = self.db_connection_3d.test_connection()
print('test_connection for: '.format('test_ladm_col_3d'), result)
if not result[1]:
print('The test connection with {} db is not working'.format("test_ladm_col_3d"))
return
self.gpkg_path = get_test_copy_path('geopackage/points_z_m_zm.gpkg')
def test_multiparts_in_right_of_way(self):
print('\nINFO: Validating right_of_way for no multipart geometries...')
gpkg_path = get_test_copy_path('db/static/gpkg/quality_validations.gpkg')
uri = gpkg_path + '|layername={layername}'.format(layername='right_of_way')
right_of_way = QgsVectorLayer(uri, 'right_of_way', 'ogr')
self.assertEqual(right_of_way.featureCount(), 6)
single_parts, single_ids = GeometryUtils.get_multipart_geoms(right_of_way)
unique_single_ids = set(single_ids)
self.assertEqual(len(single_parts), 8)
self.assertEqual(len(unique_single_ids), 3)
geometries = [g.asWkt() for g in single_parts]
expected_list = [
'Polygon ((1091145.85694021754898131 1121724.4278288041241467, 1091173.73775773262605071 1121765.70312499976716936, 1091206.17259239125996828 1121797.18358423886820674, 1091254.27673969138413668 1121818.85067654610611498, 1091289.43588917586021125 1121819.66833118535578251, 1091291.07119845412671566 1121759.97954252548515797, 1091260.00032216543331742 1121759.97954252548515797, 1091223.61469072219915688 1121742.80879510287195444, 1091197.44974226853810251 1121710.92026417492888868, 1091175.37306701089255512 1121673.30815077293664217, 1091177.00837628915905952 1121614.43701675231568515, 1091122.48462500004097819 1121616.61360054323449731, 1091119.46884239139035344 1121678.4371440215036273, 1091145.85694021754898131 1121724.4278288041241467))',
'Polygon ((1091336.04220360890030861 1121821.30364046362228692, 1091432.52545103151351213 1121818.85067654610611498, 1091433.34310567076317966 1121757.52657860796898603, 1091336.04220360890030861 1121762.4325064430013299, 1091336.04220360890030861 1121821.30364046362228692))',
'Polygon ((1091123.04317010380327702 1121561.28946520597673953, 1091175.37306701089255512 1121560.471810566727072, 1091172.10244845412671566 1121306.18121778313070536, 1091121.40786082530394197 1121307.81652706163004041, 1091123.04317010380327702 1121561.28946520597673953))',
'Polygon ((1091487.30831185611896217 1121755.89126932970248163, 1091747.3224871139973402 1121750.16768685542047024, 1091747.3224871139973402 1121813.94474871107377112, 1091487.30831185611896217 1121818.85067654610611498, 1091487.30831185611896217 1121755.89126932970248163))',
'Polygon ((1091747.3224871139973402 1121813.94474871107377112, 1091751.00193299050442874 1121954.58134664944373071, 1091806.6024484543595463 1121951.31072809267789125, 1091804.9671391760930419 1121217.05686211329884827, 1091749.36662371223792434 1121218.69217139179818332, 1091036.37177835148759186 1121226.86871778359636664, 1091039.64239690802060068 1121298.8223260308150202, 1091041.27770618651993573 1121310.26949097937904298, 1091121.40786082530394197 1121307.81652706163004041, 1091172.10244845412671566 1121306.18121778313070536, 1091425.57538659870624542 1121310.26949097937904298, 1091474.63466494926251471 1121316.81072809267789125, 1091749.36662371223792434 1121300.45763530931435525, 1091747.3224871139973402 1121750.16768685542047024, 1091747.3224871139973402 1121813.94474871107377112))',
'Polygon ((1091041.27770618651993573 1121310.26949097937904298, 1091039.64239690802060068 1121298.8223260308150202, 1091036.37177835148759186 1121226.86871778359636664, 1090936.91814493527635932 1121227.28393303113989532, 1090936.91814493527635932 1122080.91537633049301803, 1091813.44391813105903566 1122080.91537633049301803, 1091806.6024484543595463 1121951.31072809267789125, 1091751.00193299050442874 1121954.58134664944373071, 1091754.57278410973958671 1122030.62961602141149342, 1090996.1981062744744122 1122030.62961602141149342, 1090996.1981062744744122 1121309.86705158883705735, 1091033.88846642058342695 1121310.19713682751171291, 1091038.64362105960026383 1121310.19713682751171291, 1091041.27770618651993573 1121310.26949097937904298))',
'Polygon ((1090495.31252119154669344 1121959.44378872332163155, 1090784.3099831254221499 1121950.85970569564960897, 1090784.3099831254221499 1121676.16904880781657994, 1090501.03524321014992893 1121679.03040981711819768, 1090495.31252119154669344 1121959.44378872332163155),(1090604.04423954291269183 1121859.29615339962765574, 1090698.46915284800343215 1121856.434792390326038, 1090701.3305138573050499 1121753.4257960575632751, 1090615.48968357988633215 1121756.28715706686489284, 1090604.04423954291269183 1121859.29615339962765574))',
'Polygon ((1090592.59879550593905151 1121550.26916440110653639, 1090724.22140193125233054 1121547.40780339180491865, 1090724.22140193125233054 1121398.61703091091476381, 1090592.59879550593905151 1121407.20111393858678639, 1090592.59879550593905151 1121550.26916440110653639))'
]
for expected in expected_list:
self.assertIn(expected, geometries)
def test_find_boundary_points_not_covered_by_boundaries(self):
print(
'\nINFO: Validating boundary points not covered by boundaries...')
gpkg_path = get_test_copy_path('geopackage/tests_data.gpkg')
uri_boundary = gpkg_path + '|layername={layername}'.format(
layername='boundary_lamd')
uri_point_boundary = gpkg_path + '|layername={layername}'.format(
layername='point_boundary_ladm')
uri_point_boundary_fixed = gpkg_path + '|layername={layername}'.format(
layername='point_boundary_ladm_fixed')
boundary_layer = QgsVectorLayer(uri_boundary, 'boundary', 'ogr')
point_boundary_layer = QgsVectorLayer(uri_point_boundary,
'point_boundary', 'ogr')
point_boundary_fixed_layer = QgsVectorLayer(uri_point_boundary_fixed,
'point_boundary', 'ogr')
boundary_points = self.qgis_utils.geometry.get_boundary_points_not_covered_by_boundary_nodes(
point_boundary_layer, boundary_layer)
self.assertEqual(len(boundary_points), 8)
boundary_points = self.qgis_utils.geometry.get_boundary_points_not_covered_by_boundary_nodes(
point_boundary_fixed_layer, boundary_layer)
self.assertEqual(len(boundary_points), 0)
def test_polygons_must_be_covered_by_lines(self):
print('\nINFO: Validating polygons must be covered by lines...')
gpkg_path = get_test_copy_path('geopackage/topology_cases.gpkg')
diff_geom = [
'MultiLineString ((780300.30731518880929798 1225605.22174088703468442, 780297.95234157983213663 1225599.8581298291683197, 780292.44514157995581627 1225602.31722982972860336, 780294.34505024075042456 1225606.57437412883155048))',
'MultiLineString ((780300.30731518880929798 1225605.22174088703468442, 780297.95234157983213663 1225599.8581298291683197, 780292.44514157995581627 1225602.31722982972860336, 780294.34505024075042456 1225606.57437412883155048))',
'MultiLineString ((780309.73902403307147324 1225602.49830744392238557, 780308.30989155941642821 1225603.05408118362538517, 780307.64825615496374667 1225603.95390533376485109),(780310.01870060083456337 1225599.16431454825215042, 780310.03014361101668328 1225598.66082209814339876, 780311.16639214521273971 1225598.61655267467722297))',
'MultiLineString ((780307.7805832359008491 1225598.39616793626919389, 780307.60049424471799284 1225599.58559290133416653),(780308.69099051796365529 1225598.27522822353057563, 780307.7805832359008491 1225598.39616793626919389),(780315.57867445563897491 1225608.45340170268900692, 780315.45555392769165337 1225607.63259818265214562, 780314.78905752801802009 1225607.92419035756029189),(780317.62428020488005131 1225603.16991792898625135, 780318.36674970726016909 1225602.84235785435885191, 780318.29131162946578115 1225603.45340628433041275))',
'MultiLineString ((780306.77080396702513099 1225605.06540775927715003, 780306.64257034030742943 1225605.91234613093547523, 780307.906158416881226 1225605.63026071945205331),(780314.52926436136476696 1225599.74590416136197746, 780312.94133939070161432 1225600.03702373942360282, 780312.34155925654340535 1225600.40004855743609369),(780312.43979134678374976 1225599.65884278574958444, 780314.52926436136476696 1225599.74590416136197746),(780318.10209554550237954 1225604.98605656484141946, 780317.2287368115503341 1225605.14484906173311174, 780316.19658558059018105 1225606.12406946043483913))',
''
]
for i in range(len(diff_geom)):
uri_polygon = gpkg_path + '|layername={layername}_case{case}'.format(
layername='polygon', case=i + 1)
uri_lines = gpkg_path + '|layername={layername}_case{case}'.format(
layername='lines', case=i + 1)
polygon_layer = QgsVectorLayer(uri_polygon,
'polygon_layer_{}'.format(i + 1),
'ogr')
lines_layer = QgsVectorLayer(uri_lines,
'lines_layer_{}'.format(i + 1), 'ogr')
diff_plot_boundary = self.qgis_utils.geometry.difference_plot_boundary(
polygon_layer, lines_layer, 'fid')
if diff_plot_boundary is not None:
if len(diff_plot_boundary) > 0:
self.assertEqual(diff_plot_boundary[0]['geometry'].asWkt(),
diff_geom[i], 'case_{}'.format(i + 1))
else:
self.assertEqual('', diff_geom[i], 'case_{}'.format(i + 1))
def test_lines_must_be_covered_by_polygons(self):
print('\nINFO: Validating lines must be covered by polygons...')
gpkg_path = get_test_copy_path('geopackage/topology_cases.gpkg')
diff_geom = [
'', '',
'MultiLineString ((780309.73902403307147324 1225602.49830744392238557, 780307.83351406815927476 1225602.05170354596339166, 780307.64825615496374667 1225603.95390533376485109))',
'',
'MultiLineString ((780318.10209554550237954 1225604.98605656484141946, 780317.50662368256598711 1225605.92888701660558581, 780316.19658558059018105 1225606.12406946043483913))',
'MultiLineString ((780314.52926436136476696 1225599.74590416136197746, 780312.94133939070161432 1225600.03702373942360282, 780310.92996776115614921 1225601.25443288357928395, 780310.00367819482926279 1225599.82530040992423892, 780310.03014361101668328 1225598.66082209814339876, 780312.06798065674956888 1225598.5814258495811373, 780311.35341442003846169 1225599.61357708042487502, 780314.52926436136476696 1225599.74590416136197746))'
]
for i in range(len(diff_geom)):
uri_polygon = gpkg_path + '|layername={layername}_case{case}'.format(
layername='polygon', case=i + 1)
uri_lines = gpkg_path + '|layername={layername}_case{case}'.format(
layername='lines', case=i + 1)
polygon_layer = QgsVectorLayer(uri_polygon,
'polygon_layer_{}'.format(i + 1),
'ogr')
lines_layer = QgsVectorLayer(uri_lines,
'lines_layer_{}'.format(i + 1), 'ogr')
diff_boundary_plot = self.qgis_utils.geometry.difference_boundary_plot(
lines_layer, polygon_layer, 'fid')
if diff_boundary_plot is not None:
if len(diff_boundary_plot) > 0:
self.assertEqual(diff_boundary_plot[0]['geometry'].asWkt(),
diff_geom[i], 'case_{}'.format(i + 1))
else:
self.assertEqual('', diff_geom[i], 'case_{}'.format(i + 1))
def test_calculate_automatic_values_in_batch_mode(self):
print('\nINFO: Validating automatic values in batch...')
# Config settings
QSettings().setValue(
'Asistente-LADM-COL/automatic_values/automatic_values_in_batch_mode',
True)
source_layer_path = get_test_copy_path(
"db/ladm/gpkg/insert_features_to_layer.gpkg") + "|layername=a"
layer_cadastral_parcel = self.app.core.get_layer(
self.db, self.db.names.GC_PARCEL_T, load=True)
# self.set_automatic_fields(db, layer, layer_name) # Since this is the first get_layer(), no need to call it
delete_features(layer_cadastral_parcel)
count_before = layer_cadastral_parcel.featureCount()
res = processing.run("ladm_col:insertfeaturestolayer", {
'INPUT': source_layer_path,
'OUTPUT': layer_cadastral_parcel
})
output = res['OUTPUT']
self.assertIsNotNone(output)
count_after = output.featureCount()
print("New features in output: {}".format(count_after - count_before))
self.assertGreater(
count_after, count_before,
"There should be new features in the output layer!")
print("Iterating {} features in output...".format(count_after))
for feature in output.getFeatures():
self.assertEqual(len(feature[self.db.names.T_ILI_TID_F]), 36)
def test_overlapping_points(self):
print('\nINFO: Validating overlaps in points...')
test_layer = 'overlapping_points'
gpkg_path = get_test_copy_path('db/static/gpkg/geometry_utils.gpkg')
uri = gpkg_path + '|layername={}'.format(test_layer)
overlapping_points_layer = QgsVectorLayer(uri,
'test_overlapping_points',
'ogr')
self.assertEqual(overlapping_points_layer.featureCount(), 286,
'The number of features differs')
expected_overlaps = {
'286, 285':
'Point (963166.65579999983310699 1077249.80199999921023846)'
}
overlapping = self.geometry.get_overlapping_points(
overlapping_points_layer)
self.assertTrue(len(overlapping), 1) # One list of overlapping ids
for overlapping_ids in overlapping:
self.assertTrue(len(overlapping_ids), 2) # Two points overlap
points = []
for feature in overlapping_points_layer.getFeatures(
overlapping_ids):
points.append(feature.geometry().asWkt())
unique_points = set(points) # get unique values
self.assertEqual(len(unique_points), 1,
'The intersection failed, points are not equal')
self.assertEqual(
list(unique_points)[0],
list(expected_overlaps.values())[0])
def setUpClass(self):
print("\nINFO: Setting up copy layer With different Geometries to DB validation...")
self.qgis_utils = QGISUtils()
# resore schemas
restore_schema(SCHEMA_DISTINCT_GEOMS)
restore_schema(SCHEMA_LADM_COL)
restore_schema(SCHEMA_LADM_COL_3D)
self.db_distinct_geoms = get_dbconn(SCHEMA_DISTINCT_GEOMS)
result = self.db_distinct_geoms.test_connection()
print('Test_connection for: '.format(SCHEMA_DISTINCT_GEOMS), result)
if not result[1]:
print('The test connection with {} db is not working'.format(SCHEMA_DISTINCT_GEOMS))
return
self.db_connection = get_dbconn(SCHEMA_LADM_COL)
result = self.db_connection.test_connection()
print('Test_connection for: '.format(SCHEMA_LADM_COL), result)
if not result[1]:
print('The test connection with {} db is not working'.format(SCHEMA_LADM_COL))
return
self.db_connection_3d = get_dbconn(SCHEMA_LADM_COL_3D)
result = self.db_connection_3d.test_connection()
print('Test_connection for: '.format(SCHEMA_LADM_COL_3D), result)
if not result[1]:
print('The test connection with {} db is not working'.format(SCHEMA_LADM_COL_3D))
return
self.gpkg_path = get_test_copy_path('geopackage/points_z_m_zm.gpkg')
clean_table(SCHEMA_LADM_COL, BOUNDARY_POINT_TABLE)
clean_table(SCHEMA_LADM_COL_3D, BOUNDARY_POINT_TABLE)
def test_export_data_in_gpkg(self):
print("\nINFO: Validate Export Data in GPKG...")
gpkg_path = get_test_copy_path('geopackage/test_export_data.gpkg')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path('models/LADM_COL')
base_config.custom_model_directories_enabled = True
configuration = ExportConfiguration()
configuration.base_configuration = base_config
configuration.ilimodels = ';'.join([
LADMNames.SUPPORTED_LADM_MODEL, LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL, LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_VALUATION_MODEL
])
configuration.dbfile = gpkg_path
exporter = iliexporter.Exporter()
exporter.tool = DbIliMode.ili2gpkg
exporter.configuration = configuration
exporter.configuration.xtffile = os.path.join(self.base_test_path,
'test_export_data.xtf')
self.assertEqual(exporter.run(), iliexporter.Exporter.SUCCESS)
self.check_export_xtf(exporter.configuration.xtffile)
def test_overlapping_polygons(self):
print('\nINFO: Validating overlaps in polygons (plots)...')
gpkg_path = get_test_copy_path('db/static/gpkg/geometry_utils.gpkg')
uri = gpkg_path + '|layername={layername}'.format(
layername='overlapping_polygons')
polygons_overlap_layer = QgsVectorLayer(uri, 'overlapping_polygons',
'ogr')
if QgsWkbTypes.isMultiType(polygons_overlap_layer.wkbType()) and \
polygons_overlap_layer.geometryType() == QgsWkbTypes.PolygonGeometry:
polygons_overlap_layer = processing.run(
"native:multiparttosingleparts", {
'INPUT': polygons_overlap_layer,
'OUTPUT': 'TEMPORARY_OUTPUT'
})['OUTPUT']
expected_overlaps = [[11, 44], [11, 47], [12, 44], [12, 45], [12, 57],
[48, 49], [53, 55], [61, 62], [63, 64], [63, 65],
[64, 65], [66, 68], [67, 68]]
flat_expected_overlaps = list(
set([id for items in expected_overlaps
for id in items])) # Build a flat list of uniques ids
overlapping = self.geometry.get_overlapping_polygons(
polygons_overlap_layer)
flat_overlapping = list(
set([id for items in overlapping for id in items]))
# checks
self.assertEqual(len(flat_overlapping), 18)
flat_expected_overlaps.sort()
flat_overlapping.sort()
self.assertEqual(flat_expected_overlaps, flat_overlapping)
def test_polygons_must_be_covered_by_lines(self):
print('\nINFO: Validating polygons must be covered by lines...')
gpkg_path = get_test_copy_path('db/static/gpkg/topology_cases.gpkg')
self.db_gpkg = get_gpkg_conn('topology_cases_gpkg')
names = self.db_gpkg.names
names.T_ID_F = 't_id' # Static label is set because the database does not have the ladm structure
diff_geom = [
[
'MultiLineString ((780300.30731518880929798 1225605.22174088703468442, 780297.95234157983213663 1225599.8581298291683197, 780292.44514157995581627 1225602.31722982972860336, 780294.34505024075042456 1225606.57437412883155048))'
],
[
'MultiLineString ((780300.30731518880929798 1225605.22174088703468442, 780297.95234157983213663 1225599.8581298291683197, 780292.44514157995581627 1225602.31722982972860336, 780294.34505024075042456 1225606.57437412883155048))'
],
[
'MultiLineString ((780309.73902403307147324 1225602.49830744392238557, 780308.30989155941642821 1225603.05408118362538517, 780307.64825615496374667 1225603.95390533376485109),(780310.01870060083456337 1225599.16431454825215042, 780310.03014361101668328 1225598.66082209814339876, 780311.16639214521273971 1225598.61655267467722297))'
],
[
'MultiLineString ((780307.7805832359008491 1225598.39616793626919389, 780307.60049424471799284 1225599.58559290133416653),(780308.69099051796365529 1225598.27522822353057563, 780307.7805832359008491 1225598.39616793626919389),(780315.57867445563897491 1225608.45340170268900692, 780315.45555392769165337 1225607.63259818265214562, 780314.78905752801802009 1225607.92419035756029189),(780317.62428020488005131 1225603.16991792898625135, 780318.36674970726016909 1225602.84235785435885191, 780318.29131162946578115 1225603.45340628433041275))'
],
[
'MultiLineString ((780306.77080396702513099 1225605.06540775927715003, 780306.64257034030742943 1225605.91234613093547523, 780307.906158416881226 1225605.63026071945205331),(780314.52926436136476696 1225599.74590416136197746, 780312.94133939070161432 1225600.03702373942360282, 780312.34155925654340535 1225600.40004855743609369),(780312.43979134678374976 1225599.65884278574958444, 780314.52926436136476696 1225599.74590416136197746),(780318.10209554550237954 1225604.98605656484141946, 780317.2287368115503341 1225605.14484906173311174, 780316.19658558059018105 1225606.12406946043483913))'
], '',
[
'MultiLineString ((871560.66490000020712614 1554564.43640000000596046, 871561.29310000035911798 1554568.61969999969005585, 871565.18800000008195639 1554569.14470000006258488, 871582.36809999961405993 1554569.08310000039637089, 871586.65579999983310699 1554568.74300000071525574, 871586.17630000039935112 1554559.7443000003695488, 871586.15149999968707561 1554558.96719999983906746))',
'MultiLineString ((871581.97680000029504299 1554559.16310000047087669, 871583.06890000030398369 1554559.11189999990165234, 871586.15149999968707561 1554558.96719999983906746),(871586.15149999968707561 1554558.96719999983906746, 871585.68250000011175871 1554551.27449999935925007, 871585.4917000001296401 1554549.15570000000298023, 871584.2698999997228384 1554549.2476000003516674, 871576.33000000007450581 1554549.84439999982714653, 871561.16789999976754189 1554551.16310000047087669, 871545.42370000015944242 1554551.99960000067949295, 871546.30889999959617853 1554566.21570000052452087, 871560.66490000020712614 1554564.43640000000596046))'
]
]
for i in range(len(diff_geom)):
uri_polygon = gpkg_path + '|layername={layername}_case{case}'.format(
layername='polygon', case=i + 1)
uri_lines = gpkg_path + '|layername={layername}_case{case}'.format(
layername='lines', case=i + 1)
polygon_layer = QgsVectorLayer(uri_polygon,
'polygon_layer_{}'.format(i + 1),
'ogr')
lines_layer = QgsVectorLayer(uri_lines,
'lines_layer_{}'.format(i + 1), 'ogr')
polygon_as_lines_layer = processing.run(
"ladm_col:polygonstolines", {
'INPUT': polygon_layer,
'OUTPUT': 'TEMPORARY_OUTPUT'
})['OUTPUT']
diff_plot_boundary = self.geometry.difference_plot_boundary(
polygon_as_lines_layer, lines_layer, 'fid')
if diff_plot_boundary is not None:
if len(diff_plot_boundary) > 0:
for element in range(len(diff_plot_boundary)):
self.assertIn(
diff_plot_boundary[element]['geometry'].asWkt(),
diff_geom[i],
'case_{}, element_{}'.format(i + 1, element))
else: # Case 6
self.assertEqual('', diff_geom[i], 'case_{}'.format(i + 1))
def test_import_data_in_gpkg(self):
print("\nINFO: Validate Import Data in GPKG...")
gpkg_path = get_test_copy_path(
'geopackage/test_import_data_ladm_v1_0.gpkg')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2gpkg
configuration.dbfile = gpkg_path
configuration.srs_auth = DEFAULT_SRS_AUTH
configuration.srs_code = DEFAULT_SRS_CODE
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.delete_data = True
configuration.ilimodels = ';'.join([
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()
])
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2gpkg
importer.configuration = configuration
importer.configuration.xtffile = testdata_path(
'xtf/test_ladm_col_queries_v1_0.xtf')
# importer.stderr.connect(self.on_stderr)
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
config_manager = GpkgCommandConfigManager(importer.configuration)
generator = Generator(DbIliMode.ili2gpkg, config_manager.get_uri(),
configuration.inheritance)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 156)
db_gpkg = get_gpkg_conn_from_path(config_manager.get_uri())
res, code, msg = db_gpkg.test_connection()
self.assertTrue(res, msg)
test_layer = self.app.core.get_layer(db_gpkg,
db_gpkg.names.LC_BOUNDARY_POINT_T,
load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_gpkg.conn.close()
def test_check_missing_survey_points_in_buildings(self):
print('\nINFO: Validating missing survey points in buildings...')
gpkg_path = get_test_copy_path('geopackage/tests_data.gpkg')
uri = gpkg_path + '|layername={layername}'.format(
layername='construccion')
building_layer = QgsVectorLayer(uri, 'construccion', 'ogr')
uril = gpkg_path + '|layername={layername}'.format(
layername='p_levantamiento')
survey_layer = QgsVectorLayer(uril, 'p_levantamiento', 'ogr')
building_features = [
feature for feature in building_layer.getFeatures()
]
self.assertEqual(len(building_features), 4)
survey_features = [feature for feature in survey_layer.getFeatures()]
self.assertEqual(len(survey_features), 11)
missing_points = self.quality.get_missing_boundary_points_in_boundaries(
survey_layer, building_layer)
geometries = [
geom.asWkt() for k, v in missing_points.items() for geom in v
]
self.assertEqual(len(geometries), 9)
self.assertIn(
'Point (1091236.35652560647577047 1121774.96929413848556578)',
geometries)
self.assertIn(
'Point (1091186.87442427431233227 1121732.1977132954634726)',
geometries)
self.assertIn(
'Point (1091077.77337037585675716 1121602.12974193692207336)',
geometries)
self.assertIn(
'Point (1091205.35301685449667275 1121546.94486430194228888)',
geometries)
self.assertIn(
'Point (1091305.89359214110299945 1121627.02843385003507137)',
geometries)
self.assertIn(
'Point (1091408.70686221891082823 1121544.53974786633625627)',
geometries)
self.assertIn(
'Point (1091371.58370406995527446 1121507.19097788003273308)',
geometries)
self.assertIn(
'Point (1091314.24563915398903191 1121448.97160633862949908)',
geometries)
self.assertIn(
'Point (1091213.62314918311312795 1121543.89559642062522471)',
geometries)
def test_boundary_dangles_no_dangles(self):
print('\nINFO: Validating boundary_dangles with no dangles...')
gpkg_path = get_test_copy_path('db/static/gpkg/quality_validations.gpkg')
uri = gpkg_path + '|layername={layername}'.format(layername='boundary')
boundary_layer = QgsVectorLayer(uri, 'dangles', 'ogr')
features = [feature for feature in boundary_layer.getFeatures()]
self.assertEqual(len(features), 8)
end_points, dangle_ids = self.geometry.get_dangle_ids(boundary_layer)
self.assertEqual(len(dangle_ids), 0)
def test_get_too_long_segments_from_simple_line(self):
print('\nINFO: Validating too long segments...')
gpkg_path = get_test_copy_path('geopackage/tests_data.gpkg')
uri = gpkg_path + '|layername={layername}'.format(
layername='too_long_lines')
boundary_layer = QgsVectorLayer(uri, 'too_long_lines', 'ogr')
tolerance = 200 # meters
features = [feature for feature in boundary_layer.getFeatures()]
self.assertEqual(len(features), 2)
### feature 1 ###
feature = features[0]
lines = feature.geometry()
self.assertTrue(lines.isMultipart())
self.assertEqual(lines.constGet().numGeometries(), 4)
line = lines.constGet().geometryN(0)
segments_info = self.qgis_utils.geometry.get_too_long_segments_from_simple_line(
line, tolerance)
self.assertEqual(len(segments_info), 2)
self.validate_segments(segments_info, tolerance)
line = lines.constGet().geometryN(1)
segments_info = self.qgis_utils.geometry.get_too_long_segments_from_simple_line(
line, tolerance)
self.assertEqual(len(segments_info), 1)
self.validate_segments(segments_info, tolerance)
line = lines.constGet().geometryN(2)
segments_info = self.qgis_utils.geometry.get_too_long_segments_from_simple_line(
line, tolerance)
self.assertEqual(len(segments_info), 0)
self.validate_segments(segments_info, tolerance)
line = lines.constGet().geometryN(3)
segments_info = self.qgis_utils.geometry.get_too_long_segments_from_simple_line(
line, tolerance)
self.assertEqual(len(segments_info), 1)
self.validate_segments(segments_info, tolerance)
### feature 2 ###
feature = features[1]
lines = feature.geometry()
self.assertTrue(lines.isMultipart())
self.assertEqual(lines.constGet().numGeometries(), 1)
line = lines.constGet().geometryN(0)
segments_info = self.qgis_utils.geometry.get_too_long_segments_from_simple_line(
line, tolerance)
self.assertEqual(len(segments_info), 1)
self.validate_segments(segments_info, tolerance)
def test_intersection_polygons_tolerance(self):
print('\nINFO: Validating intersection in polygons (plots)...')
gpkg_path = get_test_copy_path('geopackage/tests_data.gpkg')
uri = gpkg_path + '|layername={layername}'.format(
layername='topology_polygons_overlap')
polygons_intersection_layer = QgsVectorLayer(
uri, 'test_polygons_intersection_tolerance', 'ogr')
polygon_id = 61
overlapping_id = 62
polygon_intersection = self.qgis_utils.geometry.get_intersection_polygons(
polygons_intersection_layer, polygon_id, overlapping_id)
self.assertEqual(polygon_intersection, None)
def setUpClass(cls):
print("\nINFO: Setting up copy layer With different Geometries to DB validation...")
cls.app = AppInterface()
import_qgis_model_baker()
# restore schemas
print("INFO: Restoring databases to be used")
restore_schema(SCHEMA_DISTINCT_GEOMS)
restore_schema(SCHEMA_LADM_COL_EMPTY)
cls.gpkg_path = get_test_copy_path(GPKG_PATH_DISTINCT_GEOMS)
cls.db_distinct_geoms = get_pg_conn(SCHEMA_DISTINCT_GEOMS)
cls.db_pg = get_pg_conn(SCHEMA_LADM_COL_EMPTY)
def test_import_data_in_gpkg(self):
print("\nINFO: Validate Import Data in GPKG...")
gpkg_path = get_test_copy_path('geopackage/test_import_data.gpkg')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path('models/LADM_COL')
base_config.custom_model_directories_enabled = True
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.tool = DbIliMode.ili2gpkg
configuration.dbfile = gpkg_path
configuration.epsg = DEFAULT_EPSG
configuration.inheritance = LADMNames.DEFAULT_INHERITANCE
configuration.create_basket_col = LADMNames.CREATE_BASKET_COL
configuration.create_import_tid = LADMNames.CREATE_IMPORT_TID
configuration.stroke_arcs = LADMNames.STROKE_ARCS
configuration.delete_data = True
configuration.ilimodels = ';'.join([
LADMNames.SUPPORTED_LADM_MODEL, LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL, LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_VALUATION_MODEL
])
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2gpkg
importer.configuration = configuration
importer.configuration.xtffile = testdata_path(
'xtf/test_ladm_col_queries_v2.9.6.xtf')
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
config_manager = GpkgCommandConfigManager(importer.configuration)
generator = Generator(DbIliMode.ili2gpkg, config_manager.get_uri(),
configuration.inheritance)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 189)
db_gpkg = get_gpkg_conn_from_path(config_manager.get_uri())
res, code, msg = db_gpkg.test_connection()
self.assertTrue(res, msg)
test_layer = self.qgis_utils.get_layer(
db_gpkg, db_gpkg.names.OP_BOUNDARY_POINT_T, load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_gpkg.conn.close()
def test_get_missing_boundary_points_in_boundaries(self):
print('\nINFO: Validating missing boundary points in boundaries...')
gpkg_path = get_test_copy_path('geopackage/tests_data.gpkg')
uri = gpkg_path + '|layername={layername}'.format(layername='boundary')
boundary_layer = QgsVectorLayer(uri, 'boundary', 'ogr')
uri = gpkg_path + '|layername={layername}'.format(
layername='boundary_points_')
point_layer = QgsVectorLayer(uri, 'boundary_points_', 'ogr')
boundary_features = [
feature for feature in boundary_layer.getFeatures()
]
self.assertEqual(len(boundary_features), 8)
point_features = [feature for feature in point_layer.getFeatures()]
self.assertEqual(len(point_features), 9)
missing_points = self.quality.get_missing_boundary_points_in_boundaries(
point_layer, boundary_layer)
geometries = [
geom.asWkt() for k, v in missing_points.items() for geom in v
]
self.assertEqual(len(geometries), 7)
self.assertIn(
'Point (962933.31867467891424894 1077991.8205501982010901)',
geometries)
self.assertIn(
'Point (963525.77339165192097425 1078270.34507849626243114)',
geometries)
self.assertIn(
'Point (963820.82056145928800106 1078251.46205962845124304)',
geometries)
self.assertIn(
'Point (963202.40169354318641126 1078020.14507849956862628)',
geometries)
self.assertIn(
'Point (963287.37527844763826579 1078395.44507849449291825)',
geometries)
self.assertIn(
'Point (963353.46584448451176286 1078440.2922483051661402)',
geometries)
self.assertIn(
'Point (963447.88093882286921144 1078482.77904075756669044)',
geometries)
def test_intersection_polygons_tolerance(self):
print('\nINFO: Validating intersection in polygons (plots)...')
gpkg_path = get_test_copy_path('db/static/gpkg/geometry_utils.gpkg')
uri = gpkg_path + '|layername={layername}'.format(
layername='overlapping_polygons')
polygons_intersection_layer = QgsVectorLayer(uri,
'overlapping_polygons',
'ogr')
polygon_id = 61
overlapping_id = 62
test_overlapping_polygon = 'MultiPolygon (((779846.53495819831732661 1225249.26543459924869239, 779783.95215819834265858 1225214.60283459979109466, 779755.42265819816384465 1225312.01313459943048656, 779751.20725819806102663 1225339.76893460075370967, 779753.92445819883141667 1225441.12693459982983768, 779750.35635819809976965 1225530.46543460036627948, 779822.77425819879863411 1225579.77523459936492145, 779989.38215819804463536 1225693.37413460086099803, 780035.07055819837842137 1225719.08503460022620857, 780048.81795819813851267 1225694.37763460050337017, 780107.8898581980029121 1225665.00753459963016212, 780145.38955819851253182 1225642.4988345995079726, 780156.81765819864813238 1225634.07963460008613765, 780178.43775819859001786 1225625.24393460038118064, 780098.00075819867197424 1225413.46203460055403411, 779976.68275819870177656 1225330.46993460017256439, 779918.56405819824431092 1225292.73203460010699928, 779846.53495819831732661 1225249.26543459924869239)))'
polygon_intersection = GeometryUtils.get_intersection_polygons(
polygons_intersection_layer, polygon_id, overlapping_id)
self.assertEqual(polygon_intersection.asWkt(),
test_overlapping_polygon)
def test_pair_boundary_plot(self):
print('\nValidating boundaries plots')
# extracted with: iface.activeLayer().dataProvider().dataSourceUri() in qgis console
# and type is: layer.providerType()
gpkg_path = get_test_copy_path('geopackage/tests_data.gpkg')
uri = gpkg_path + '|layername={layername}'.format(
layername='tests_boundaries')
boundary_layer = QgsVectorLayer(uri, 'tests_boundaries', 'ogr')
uri = gpkg_path + '|layername={layername}'.format(
layername='tests_plots')
plot_layer = QgsVectorLayer(uri, 'tests_plots', 'ogr')
result1, result2 = self.qgis_utils.geometry.get_pair_boundary_plot(
boundary_layer, plot_layer, use_selection=False)
self.assertEqual(result1, [(1, 3), (3, 3)])
self.assertEqual(result2, [(1, 4)])
def test_calculate_automatic_values_in_batch_mode_but_setting_is_disabled(
self):
print(
'\nINFO: Validating automatic values in batch, but setting is disabled...'
)
# Config settings
QSettings().setValue(
'Asistente-LADM-COL/automatic_values/automatic_values_in_batch_mode',
True)
QSettings().setValue(
'Asistente-LADM-COL/automatic_values/t_ili_tid_enabled', False)
source_layer_path = get_test_copy_path(
"db/ladm/gpkg/insert_features_to_layer.gpkg") + "|layername=a"
layer_cadastral_parcel = self.app.core.get_layer(
self.db, self.db.names.GC_PARCEL_T, load=True)
self.app.core.set_automatic_fields(
self.db, layer_cadastral_parcel, self.db.names.GC_PARCEL_T,
self.app.core.get_active_models_per_db(self.db))
delete_features(layer_cadastral_parcel)
count_before = layer_cadastral_parcel.featureCount()
res = processing.run("ladm_col:insertfeaturestolayer", {
'INPUT': source_layer_path,
'OUTPUT': layer_cadastral_parcel
})
output = res['OUTPUT']
self.assertIsNotNone(output)
count_after = output.featureCount()
print("New features in output: {}".format(count_after - count_before))
self.assertGreater(
count_after, count_before,
"There should be new features in the output layer!")
print("Iterating {} features in output...".format(count_after))
for feature in output.getFeatures():
self.assertEqual(feature[self.db.names.T_ILI_TID_F], NULL)
def test_boundary_dangles(self):
print('\nINFO: Validating boundary_dangles...')
gpkg_path = get_test_copy_path('db/static/gpkg/geometry_utils.gpkg')
self.db_gpkg = get_gpkg_conn('tests_geometry_util_gpkg')
names = self.db_gpkg.names
names.T_ID_F = 't_id' # Static label is set because the database does not have the ladm structure
uri = gpkg_path + '|layername={layername}'.format(layername='overlapping_lines')
boundary_layer = QgsVectorLayer(uri, 'dangles', 'ogr')
features = [feature for feature in boundary_layer.getFeatures()]
self.assertEqual(len(features), 15)
end_points, dangle_ids = self.geometry.get_dangle_ids(boundary_layer)
self.assertEqual(len(dangle_ids), 19)
boundary_ids = [feature[names.T_ID_F] for feature in end_points.getFeatures(dangle_ids)]
boundary_ids.sort()
expected_boundary_ids = [4, 4, 5, 6, 6, 7, 8, 10, 10, 13, 14, 325, 325, 334, 334, 335, 336, 336, 337]
self.assertEqual(boundary_ids, expected_boundary_ids)
def test_find_vertices(self):
print('\nINFO: Validating search for missing vertices...')
gpkg_path = get_test_copy_path('geopackage/topology_cases.gpkg')
# Map between case number and number of vertices that should be added
# For instance, the 4th case (reflected in the layer's name) should
# have 6 vertices found
vertices_test_values = [2, 2, 2, 6, 4, 0]
for i in range(len(vertices_test_values)):
uri_polygon = gpkg_path + '|layername={layername}_case{case}'.format(
layername='polygon', case=i + 1)
uri_lines = gpkg_path + '|layername={layername}_case{case}'.format(
layername='lines', case=i + 1)
polygon_layer = QgsVectorLayer(uri_polygon,
'polygon_layer_{}'.format(i + 1),
'ogr')
lines_layer = QgsVectorLayer(uri_lines,
'lines_layer_{}'.format(i + 1), 'ogr')
# We don't want to overwrite the original layer
clone_polygons = self.qgis_utils.geometry.clone_layer(
polygon_layer)
geom_polygon = clone_polygons.getFeature(1).geometry()
init_vertex_geom = [vertex for vertex in geom_polygon.vertices()]
self.qgis_utils.geometry.add_topological_vertices(
clone_polygons, lines_layer)
geom_polygon = clone_polygons.getFeature(1).geometry()
adjusted_vertex_geom = [
vertex for vertex in geom_polygon.vertices()
]
num_vertices_added = len(adjusted_vertex_geom) - len(
init_vertex_geom)
self.assertEqual(num_vertices_added, vertices_test_values[i])
def test_pair_boundary_plot(self):
print('\nValidating pairs boundary-plot')
gpkg_path = get_test_copy_path(
'db/static/gpkg/quality_validations.gpkg')
self.db_gpkg = get_gpkg_conn('tests_quality_validations_gpkg')
self.names = self.db_gpkg.names
self.names.T_ID_F = 't_id' # Static label is set because the database does not have the ladm structure
uri = gpkg_path + '|layername={layername}'.format(
layername='topology_boundaries')
boundary_layer = QgsVectorLayer(uri, 'topology_boundaries', 'ogr')
uri = gpkg_path + '|layername={layername}'.format(
layername='topology_plots')
plot_layer = QgsVectorLayer(uri, 'topology_plots', 'ogr')
result1, result2 = GeometryUtils().get_pair_boundary_plot(
boundary_layer, plot_layer, self.names.T_ID_F, use_selection=False)
self.assertEqual(result1, [(1, 3), (3, 3)])
self.assertEqual(result2, [(1, 4)])
def test_find_vertices(self):
print('\nINFO: Validating search for missing vertices...')
gpkg_path = get_test_copy_path('db/static/gpkg/topology_cases.gpkg')
self.db_gpkg = get_gpkg_conn('topology_cases_gpkg')
names = self.db_gpkg.names
names.T_ID_F = 't_id' # Static label is set because the database does not have the ladm structure
# Map between case number and number of vertices that should be added
# For instance, the 4th case (reflected in the layer's name) should
# have 6 vertices found
vertices_test_values = [2, 2, 2, 6, 4, 0]
for i in range(len(vertices_test_values)):
uri_polygon = gpkg_path + '|layername={layername}_case{case}'.format(
layername='polygon', case=i + 1)
uri_lines = gpkg_path + '|layername={layername}_case{case}'.format(
layername='lines', case=i + 1)
polygon_layer = QgsVectorLayer(uri_polygon,
'polygon_layer_{}'.format(i + 1),
'ogr')
lines_layer = QgsVectorLayer(uri_lines,
'lines_layer_{}'.format(i + 1), 'ogr')
geom_polygon = polygon_layer.getFeature(1).geometry()
init_vertex_geom = [vertex for vertex in geom_polygon.vertices()]
# We don't overwrite the original layer, changes are made on a copy
mod_polygon_layer = self.geometry.add_topological_vertices(
polygon_layer, lines_layer)
geom_polygon = mod_polygon_layer.getFeature(1).geometry()
adjusted_vertex_geom = [
vertex for vertex in geom_polygon.vertices()
]
num_vertices_added = len(adjusted_vertex_geom) - len(
init_vertex_geom)
self.assertEqual(num_vertices_added, vertices_test_values[i])
