def test_rat_save_xml(self): tmp_dir = QTemporaryDir() shutil.copy(os.path.join(os.path.dirname( __file__), 'data', 'NBS_US5PSMBE_20200923_0_generalized_p.source_information.tiff'), tmp_dir.path()) shutil.copy(os.path.join(os.path.dirname( __file__), 'data', 'NBS_US5PSMBE_20200923_0_generalized_p.tiff.aux.xml'), tmp_dir.path()) dest_raster_layer = QgsRasterLayer(os.path.join( tmp_dir.path(), 'NBS_US5PSMBE_20200923_0_generalized_p.source_information.tiff'), 'rat_test', 'gdal') rat = get_rat(dest_raster_layer, 1) self.assertFalse(rat.isValid()) raster_layer = QgsRasterLayer(os.path.join(os.path.dirname( __file__), 'data', 'NBS_US5PSMBE_20200923_0_generalized_p.source_information.tiff'), 'rat_test', 'gdal') rat = get_rat(raster_layer, 1) self.assertTrue(rat.isValid()) # Note: band 1 self.assertTrue(rat.save_as_xml(os.path.join( tmp_dir.path(), 'NBS_US5PSMBE_20200923_0_generalized_p.source_information.tiff'), 1)) dest_raster_layer = QgsRasterLayer(os.path.join( tmp_dir.path(), 'NBS_US5PSMBE_20200923_0_generalized_p.source_information.tiff'), 'rat_test', 'gdal') rat_new = get_rat(dest_raster_layer, 1) self.assertTrue(rat_new.isValid()) self.assertEqual(rat_new.data, rat.data)
def test_rat_save_dbf(self): tmp_dir = QTemporaryDir() shutil.copy( os.path.join(os.path.dirname(__file__), 'data', 'ExistingVegetationTypes_sample.img'), tmp_dir.path()) dest_raster_layer = QgsRasterLayer( os.path.join(tmp_dir.path(), 'ExistingVegetationTypes_sample.img'), 'rat_test', 'gdal') rat = get_rat(dest_raster_layer, 1) self.assertFalse(rat.isValid()) raster_layer = QgsRasterLayer( os.path.join(os.path.dirname(__file__), 'data', 'ExistingVegetationTypes_sample.img'), 'rat_test', 'gdal') rat = get_rat(raster_layer, 1) self.assertTrue(rat.isValid()) self.assertTrue( rat.save_as_dbf( os.path.join(tmp_dir.path(), 'ExistingVegetationTypes_sample.img'))) dest_raster_layer = QgsRasterLayer( os.path.join(tmp_dir.path(), 'ExistingVegetationTypes_sample.img'), 'rat_test', 'gdal') rat_new = get_rat(dest_raster_layer, 1) self.assertTrue(rat_new.isValid()) self.assertEqual(rat_new.data, rat.data)
def test_xml_rat(self): raster_layer = QgsRasterLayer(os.path.join(os.path.dirname( __file__), 'data', 'NBS_US5PSMBE_20200923_0_generalized_p.source_information.tiff'), 'rat_test', 'gdal') self.assertTrue(raster_layer.isValid()) rat = get_rat(raster_layer, 1) self.assertEqual(rat.thematic_type, gdal.GRTT_THEMATIC) self.assertFalse(rat.is_sidecar) self.assertEqual(list(rat.keys), ['Value', 'Count', 'data_assessment', 'feature_least_depth', 'significant_features', 'feature_size', 'full_coverage', 'bathy_coverage', 'horizontal_uncert_fixed', 'horizontal_uncert_var', 'License_Name', 'License_URL', 'Source_Survey_ID', 'Source_Institution', 'survey_date_start', 'survey_date_end']) self.assertEqual(rat.data['Value'][:10], [7, 15, 23, 24, 49, 54, 61, 63, 65, 79]) rat = get_rat(raster_layer, 2) self.assertEqual(rat.data, {})
def test_athematic_dbf_roundtrip(self): """Test that saving as athematic and reloading does not loose type""" rat = get_rat(self.raster_layer_athematic, 1) self.assertTrue(rat.has_color) self.assertTrue(rat.isValid()) self.assertEqual(rat.thematic_type, gdal.GRTT_ATHEMATIC) # Delete the layer and the PAM file raster_source = self.raster_layer_athematic.source() pam_path = raster_source + '.aux.xml' del (self.raster_layer_athematic) os.unlink(pam_path) rat.save_as_dbf(raster_source) self.assertTrue(os.path.exists(raster_source + '.vat.dbf')) self.raster_layer_athematic = QgsRasterLayer(raster_source, 'rat_test', 'gdal') rat_dbf = get_rat(self.raster_layer_athematic, 1) self.assertTrue(rat_dbf.has_color) self.assertTrue(rat_dbf.isValid()) self.assertEqual(rat_dbf.thematic_type, gdal.GRTT_ATHEMATIC) self.assertEqual( rat_dbf.field_usages, { gdal.GFU_Generic, gdal.GFU_Red, gdal.GFU_Green, gdal.GFU_Blue, gdal.GFU_Min, gdal.GFU_Max, })
def test_qgis_features(self): rat = get_rat(self.raster_layer_dbf, 1) features = rat.qgis_features() self.assertEqual(len(features), 59) rat = get_rat(self.raster_layer, 1) features = rat.qgis_features() self.assertEqual(len(features), 27)
def test_update_color_from_raster_athematic(self): rat = get_rat(self.raster_layer_athematic, 1) self.assertTrue(rat.has_color) rat_classify(self.raster_layer_athematic, 1, rat, 'Class') shader = self.raster_layer_athematic.renderer().shader() colorRampShaderFcn = shader.rasterShaderFunction() classes = classes = colorRampShaderFcn.colorRampItemList() color_map = {klass.value: klass.color for klass in classes} # Remove color self.assertTrue(rat.remove_color_fields()) self.assertFalse(rat.has_color) # Add color result, error_message = rat.insert_color_fields(len(rat.keys) - 1) self.assertTrue(result, error_message) self.assertTrue(rat.has_color) for color in rat.data[RAT_COLOR_HEADER_NAME]: self.assertEqual(color, QColor(Qt.black)) # Update color from raster self.assertTrue( rat.update_colors_from_raster(self.raster_layer_athematic)) value_column = rat.value_columns[1] self.assertEqual(value_column, rat.field_name(gdal.GFU_Max)) for row_index in range(len(rat.data[RAT_COLOR_HEADER_NAME])): self.assertEqual(rat.data[RAT_COLOR_HEADER_NAME][row_index], color_map[rat.data[value_column][row_index]])
def test_rat_xml_no_data_thematic(self): """Test we can open an XML rat with a missing value (band 1, value 4)""" tmp_dir = QTemporaryDir() shutil.copy( os.path.join(os.path.dirname(__file__), 'data', '2x2_2_BANDS_INT16_NODATA.tif'), tmp_dir.path()) shutil.copy( os.path.join(os.path.dirname(__file__), 'data', '2x2_2_BANDS_INT16_NODATA.tif.aux.xml'), tmp_dir.path()) raster_layer = QgsRasterLayer( os.path.join(tmp_dir.path(), '2x2_2_BANDS_INT16_NODATA.tif'), 'rat_test', 'gdal') rat = get_rat(raster_layer, 1) self.assertTrue(rat.isValid()) self.assertEqual(rat.thematic_type, gdal.GRTT_THEMATIC) self.assertIn(gdal.GFU_PixelCount, rat.field_usages) unique_row_indexes = rat_classify(raster_layer, 1, rat, 'Class') if Qgis.QGIS_VERSION_INT >= 31800: self.assertEqual(unique_row_indexes, [1, 2]) else: self.assertEqual(unique_row_indexes, [0, 1])
def test_remove_color(self): rat = get_rat(self.raster_layer_color, 1) model = RATModel(rat) tester = QAbstractItemModelTester( model, QAbstractItemModelTester.FailureReportingMode.Warning) self.assertTrue({'R', 'G', 'B'}.issubset(rat.keys)) self.assertTrue({'R', 'G', 'B'}.issubset(model.headers)) self.assertTrue(model.has_color) column_count = model.columnCount(QModelIndex()) self.assertEqual(column_count, 17) # Remove colors self.assertTrue(model.remove_color()) self.assertEqual(model.columnCount(QModelIndex()), column_count - 4) self.assertFalse(rat.has_color) self.assertFalse(model.has_color) self.assertFalse({'R', 'G', 'B'}.issubset(rat.keys)) self.assertFalse({'R', 'G', 'B'}.issubset(model.headers)) # Add color back (with alpha) self.assertTrue(model.insert_color(2)) self.assertEqual(model.columnCount(QModelIndex()), column_count + 1) self.assertTrue({'R', 'G', 'B'}.issubset(rat.keys)) self.assertTrue({'R', 'G', 'B'}.issubset(model.headers)) self.assertTrue(rat.has_color) self.assertTrue(model.has_color) self.assertTrue(RAT_COLOR_HEADER_NAME in rat.keys)
def test_update_color_from_raster(self): rat = get_rat(self.raster_layer_dbf, 1) self.assertTrue(rat.has_color) rat_classify(self.raster_layer_dbf, 1, rat, 'EVT_NAME') color_map = { klass.value: klass.color for klass in self.raster_layer_dbf.renderer().classes() } # Remove color self.assertTrue(rat.remove_color_fields()) self.assertFalse(rat.has_color) # Add color result, error_message = rat.insert_color_fields(len(rat.keys) - 1) self.assertTrue(result, error_message) self.assertTrue(rat.has_color) for color in rat.data[RAT_COLOR_HEADER_NAME]: self.assertEqual(color, QColor(Qt.black)) # Update color from raster self.assertTrue(rat.update_colors_from_raster(self.raster_layer_dbf)) value_column = rat.value_columns[0] self.assertEqual(value_column, rat.field_name(gdal.GFU_MinMax)) for row_index in range(len(rat.data[RAT_COLOR_HEADER_NAME])): self.assertEqual(rat.data[RAT_COLOR_HEADER_NAME][row_index], color_map[rat.data[value_column][row_index]])
def test_dialog(self): raster_layer = QgsRasterLayer( os.path.join(os.path.dirname(__file__), 'data', 'ExistingVegetationTypes_sample.img'), 'rat_test', 'gdal') self.assertTrue(raster_layer.isValid()) rat = get_rat(raster_layer, 1) rat_classify(raster_layer, 1, rat, 'EVT_NAME') dialog = RasterAttributeTableDialog(raster_layer) model = dialog.mRATView.model() self.assertEqual(model.rowCount(QModelIndex()), 59) self.assertEqual(model.columnCount(QModelIndex()), 17) header_model = dialog.mRATView.horizontalHeader().model() self.assertEqual(header_model.headerData(0, Qt.Horizontal), RAT_COLOR_HEADER_NAME) model = dialog.mRATView.model() color = model.data(model.index(0, 0), Qt.ItemDataRole.BackgroundColorRole) self.assertEqual(color.red(), 0) self.assertEqual(color.green(), 0) self.assertEqual(color.blue(), 255) self.assertEqual(header_model.headerData(0, Qt.Horizontal), RAT_COLOR_HEADER_NAME) self.assertEqual(header_model.headerData(1, Qt.Horizontal), 'VALUE') if not os.environ.get('CI', False): dialog.exec_()
def test_edit_rat(self): raster_layer = QgsRasterLayer( os.path.join(self.tmp_path, '2x2_2_BANDS_INT16.tif'), 'rat_test', 'gdal') self.assertTrue(raster_layer.isValid()) band = 1 rat = get_rat(raster_layer, band) self.assertTrue(rat.isValid()) self.assertEqual(rat.data['Red'], [0, 100, 200]) rat.data['Red'] = [111, 222, 123] rat.save(band) rat = get_rat(raster_layer, band) self.assertTrue(rat.isValid()) self.assertEqual(rat.data['Red'], [111, 222, 123])
def test_athematic_rat(self): """Test RAT from single band with range values""" tmp_dir = QTemporaryDir() shutil.copy(os.path.join(os.path.dirname( __file__), 'data', '2x2_1_BAND_FLOAT.tif'), tmp_dir.path()) shutil.copy(os.path.join(os.path.dirname( __file__), 'data', '2x2_1_BAND_FLOAT.tif.aux.xml'), tmp_dir.path()) raster_layer = QgsRasterLayer(os.path.join( tmp_dir.path(), '2x2_1_BAND_FLOAT.tif'), 'rat_test', 'gdal') band = 1 rat = get_rat(raster_layer, band) self.assertTrue(rat.isValid()) self.assertEqual(rat.thematic_type, gdal.GRTT_ATHEMATIC) self.assertEqual(rat.value_columns, ['Value Min', 'Value Max']) self.assertEqual(rat.field_usages, { gdal.GFU_Generic, gdal.GFU_Name, gdal.GFU_Min, gdal.GFU_Max, gdal.GFU_Red, gdal.GFU_Green, gdal.GFU_Blue}) self.assertEqual(rat.data[rat.value_columns[0]], [-1e+25, 3000000000000.0, 1e+20]) self.assertEqual(rat.data[rat.value_columns[1]], [ 3000000000000.0, 1e+20, 5e+25]) # Round trip tests unique_indexes = rat_classify(raster_layer, band, rat, 'Class', ramp=None) self.assertEqual(unique_indexes, [1, 2, 3]) rat2 = create_rat_from_raster(raster_layer, True, os.path.join( tmp_dir.path(), '2x2_1_BAND_FLOAT.tif.vat.dbf')) self.assertTrue(rat2.isValid()) # Generic (Class3) is gone self.assertEqual(rat2.field_usages, { gdal.GFU_Name, gdal.GFU_Min, gdal.GFU_Max, gdal.GFU_Red, gdal.GFU_Green, gdal.GFU_Blue, gdal.GFU_Alpha}) self.assertEqual( rat2.data['Value Min'], [-3.40282e+38, 3000000000000.0, 1e+20]) self.assertEqual( rat2.data['Value Max'], [3000000000000.0, 1e+20, 5e+25]) # Reclass on class 2 unique_indexes = rat_classify(raster_layer, band, rat, 'Class2', ramp=None) self.assertEqual(unique_indexes, [1, 2]) rat2 = create_rat_from_raster(raster_layer, True, os.path.join( tmp_dir.path(), '2x2_1_BAND_FLOAT.tif.vat.dbf')) self.assertTrue(rat2.isValid()) # Generic (Class3) is gone self.assertEqual(rat2.field_usages, { gdal.GFU_Name, gdal.GFU_Min, gdal.GFU_Max, gdal.GFU_Red, gdal.GFU_Green, gdal.GFU_Blue, gdal.GFU_Alpha}) self.assertEqual( rat2.data['Value Min'], [-3.40282e+38, 3000000000000.0, 1e+20]) self.assertEqual( rat2.data['Value Max'], [3000000000000.0, 1e+20, 5e+25])
def test_dbf_rat(self): raster_layer = QgsRasterLayer( os.path.join(os.path.dirname(__file__), 'data', 'ExistingVegetationTypes_sample.img'), 'rat_test', 'gdal') self.assertTrue(raster_layer.isValid()) rat = get_rat(raster_layer, 1) self.assertEqual(rat.thematic_type, gdal.GRTT_THEMATIC) self.assertIsNotNone(rat.path) self.assertIn('ExistingVegetationTypes_sample.img.vat.dbf', rat.path) self.assertTrue(rat.is_dbf) self.assertEqual(rat.keys, [ 'VALUE', 'COUNT', 'EVT_NAME', 'SYSTEMGROU', 'SYSTMGRPNA', 'SAF_SRM', 'NVCSORDER', 'NVCSCLASS', 'NVCSSUBCLA', 'SYSTMGRPPH', 'R', 'G', 'B', 'RED', 'GREEN', 'BLUE', RAT_COLOR_HEADER_NAME ]) self.assertEqual(rat.values[0][:10], [11, 12, 13, 14, 16, 17, 21, 22, 23, 24]) color = rat.data[RAT_COLOR_HEADER_NAME][0] self.assertEqual(color.red(), 0) self.assertEqual(color.green(), 0) self.assertEqual(color.blue(), 255) # Test RED, GREEN, BLUE rat = get_rat(raster_layer, 1, ('RED', 'GREEN', 'BLUE')) self.assertEqual(rat.thematic_type, gdal.GRTT_THEMATIC) self.assertTrue(rat.is_dbf) self.assertEqual(rat.keys, [ 'VALUE', 'COUNT', 'EVT_NAME', 'SYSTEMGROU', 'SYSTMGRPNA', 'SAF_SRM', 'NVCSORDER', 'NVCSCLASS', 'NVCSSUBCLA', 'SYSTMGRPPH', 'R', 'G', 'B', 'RED', 'GREEN', 'BLUE', RAT_COLOR_HEADER_NAME ]) self.assertEqual(rat.values[0][:10], [11, 12, 13, 14, 16, 17, 21, 22, 23, 24]) color = rat.data[RAT_COLOR_HEADER_NAME][0] self.assertEqual(color.red(), 0) self.assertEqual(color.green(), 0) self.assertEqual(color.blue(), 255)
def test_charset(self): """Test that we can save/load non-ASCII chars""" rat = get_rat(self.raster_layer, 1) self.assertTrue(rat.isValid()) # Delete the layer and the PAM file raster_source = self.raster_layer.source() pam_path = raster_source + '.aux.xml' dbf_path = raster_source + '.vat.dbf' del (self.raster_layer) os.unlink(pam_path) rat.data['License_Name'][0] = 'Some accented chars èé 😁' rat.save_as_dbf(raster_source) self.assertTrue(os.path.exists(dbf_path)) self.raster_layer = QgsRasterLayer(raster_source, 'rat_test', 'gdal') rat_dbf = get_rat(self.raster_layer, 1) self.assertTrue(rat_dbf.isValid()) self.assertEqual(rat_dbf.data['License_Na'][0], 'Some accented chars èé 😁') # Save as XML rat.save_as_xml(raster_source, 1) self.assertTrue(os.path.exists(pam_path)) del (self.raster_layer) os.unlink(dbf_path) self.raster_layer = QgsRasterLayer(raster_source, 'rat_test', 'gdal') rat_xml = get_rat(self.raster_layer, 1) self.assertTrue(rat_xml.isValid()) self.assertEqual(rat_xml.data['License_Name'][0], 'Some accented chars èé 😁')
def test_edit_color(self): rat = get_rat(self.raster_layer_color, 1) model = RATModel(rat) tester = QAbstractItemModelTester( model, QAbstractItemModelTester.FailureReportingMode.Warning) index = model.index(0, 0) value = QColor(Qt.magenta) model.setData(index, value) self.assertEqual(model.data(index, Qt.BackgroundColorRole), value)
def test_header_tooltip(self): rat = get_rat(self.raster_layer_color, 1) model = RATModel(rat) tooltip = model.getHeaderTooltip(1) self.assertIn('<dt>Role</dt><dd>Class value(min=max)</dd>', tooltip) self.assertIn('<dt>Type</dt><dd>Integer</dd>', tooltip) tooltip = model.getHeaderTooltip(2) self.assertIn('<dt>Role</dt><dd>Histogram pixel count</dd>', tooltip) self.assertIn('<dt>Type</dt><dd>Integer</dd>', tooltip) tooltip = model.getHeaderTooltip(3) self.assertIn('<dt>Role</dt><dd>General purpose field</dd>', tooltip) self.assertIn('<dt>Type</dt><dd>String</dd>', tooltip)
def test_remove_column(self): rat = get_rat(self.raster_layer, 1) self.assertTrue(rat.isValid()) model = RATModel(rat) tester = QAbstractItemModelTester( model, QAbstractItemModelTester.FailureReportingMode.Warning) column_count = model.columnCount(QModelIndex()) self.assertFalse(model.remove_column(0)[0]) self.assertFalse(model.remove_column(1)[0]) self.assertTrue(model.remove_column(2)[0]) self.assertEqual(model.columnCount(QModelIndex()), column_count - 1)
def test_get_set_color(self): rat = get_rat(self.raster_layer_dbf, 1) color = rat.get_color(0) self.assertTrue(color.isValid()) # Invalid self.assertFalse(rat.get_color(-1).isValid()) self.assertFalse(rat.get_color(100).isValid()) # Setter self.assertTrue(rat.set_color(1, QColor(10, 20, 30, 120))) self.assertEqual(rat.get_color(1), QColor(10, 20, 30, 120))
def test_field_name(self): rat = get_rat(self.raster_layer_dbf, 1) usages = [] for field in rat.fields.values(): if field.usage not in usages: usages.append(field.usage) self.assertEqual(rat.field_name(field.usage), field.name) self.assertEqual(rat.field_name(gdal.GFU_AlphaMax), '') self.assertEqual(rat.field_name(gdal.GFU_RedMax), '') self.assertEqual(rat.field_name(gdal.GFU_RedMin), '')
def loadRat(self, band_0_based) -> bool: """Load RAT for raster band 0-based""" if type(band_0_based) != int: rat_log( QCoreApplication.translate( 'RAT', 'Invalid band number for the selected raster.'), Qgis.Critical) return False self.mClassifyComboBox.clear() self.rat = get_rat(self.raster_layer, band_0_based + 1) if self.rat.keys: self.model = RATModel(self.rat) if os.environ.get('CI'): self.tester = QAbstractItemModelTester(self.model) self.model.dataChanged.connect(self.dirty) self.model.rowsInserted.connect(self.dirty) self.model.rowsRemoved.connect(self.dirty) self.model.columnsInserted.connect(self.dirty) self.model.columnsRemoved.connect(self.dirty) self.model.columnsInserted.connect(self.updateClassify) self.model.columnsRemoved.connect(self.updateClassify) self.proxyModel = QSortFilterProxyModel(self) self.proxyModel.setSourceModel(self.model) self.mRATView.setModel(self.proxyModel) self.mRATView.selectionModel().selectionChanged.connect( self.updateButtons) # Color picker if self.rat.has_color: if gdal.GFU_Alpha in self.rat.field_usages: colorDelegate = ColorAlphaDelegate(self.mRATView) else: colorDelegate = ColorDelegate(self.mRATView) self.mRATView.setItemDelegateForColumn(0, colorDelegate) self.updateClassify() self.mRATView.sortByColumn( self.model.headers.index(self.rat.value_columns[0]), Qt.AscendingOrder) return True else: rat_log( QCoreApplication.translate( 'RAT', 'There is no Raster Attribute Table for the selected raster.' ), Qgis.Critical) return False
def test_classify_athematic(self): """Test issue with athematic RAT classification dedup""" tmp_dir = QTemporaryDir() shutil.copy(os.path.join(os.path.dirname( __file__), 'data', 'band1_float32_noct_epsg4326.tif'), tmp_dir.path()) shutil.copy(os.path.join(os.path.dirname( __file__), 'data', 'band1_float32_noct_epsg4326.tif.aux.xml'), tmp_dir.path()) raster_layer = QgsRasterLayer(os.path.join( tmp_dir.path(), 'band1_float32_noct_epsg4326.tif'), 'rat_test', 'gdal') rat = get_rat(raster_layer, 1) self.assertTrue(rat.isValid()) unique_indexes = rat_classify(raster_layer, 1, rat, 'class2') self.assertEqual(unique_indexes, [1, 2, 3])
def _test(raster_layer): rat = get_rat(self.raster_layer_color, 1) model = RATModel(rat) tester = QAbstractItemModelTester( model, QAbstractItemModelTester.FailureReportingMode.Warning) row_count = model.rowCount(QModelIndex()) value_index = 1 if model.has_color else 0 value_0 = model.data(model.index(0, value_index, QModelIndex())) value_last = model.data( model.index(row_count - 1, value_index, QModelIndex())) # Insert first self.assertTrue(model.insert_row(0)) self.assertEqual(model.rowCount(QModelIndex()), row_count + 1) self.assertNotEqual( model.data(model.index(0, value_index, QModelIndex())), value_0) self.assertEqual( model.data(model.index(0, value_index, QModelIndex())), 0) self.assertTrue(model.remove_row(0)) self.assertEqual(model.rowCount(QModelIndex()), row_count) self.assertEqual( model.data(model.index(0, value_index, QModelIndex())), value_0) # Insert last self.assertTrue(model.insert_row(row_count)) self.assertEqual(model.rowCount(QModelIndex()), row_count + 1) self.assertNotEqual( model.data(model.index(row_count, value_index, QModelIndex())), value_last) self.assertEqual( model.data(model.index(row_count, value_index, QModelIndex())), 0) self.assertEqual( model.data( model.index(row_count - 1, value_index, QModelIndex())), value_last) self.assertTrue(model.remove_row(row_count)) self.assertEqual(model.rowCount(QModelIndex()), row_count) self.assertEqual( model.data( model.index(row_count - 1, value_index, QModelIndex())), value_last)
def test_insert_column_dbf(self): rat = get_rat(self.raster_layer_dbf, 1) self.assertTrue(rat.isValid()) self.assertEqual(len(rat.keys), 17) # has color, so fields are one more than keys self.assertEqual(len(rat.keys), len(rat.fields) + 1) # Not valid insertions field = RATField('f1', gdal.GFU_MinMax, gdal.GFT_Real) self.assertFalse(rat.insert_column(4, field)[0]) field = RATField('f1', gdal.GFU_Generic, gdal.GFT_Real) self.assertFalse(rat.insert_column(0, field)[0]) field = RATField('f1', gdal.GFU_Generic, gdal.GFT_Real) self.assertFalse(rat.insert_column(1, field)[0]) field = RATField('f1', gdal.GFU_Generic, gdal.GFT_Real) self.assertFalse(rat.insert_column(100, field)[0]) field = RATField('SYSTMGRPNA', gdal.GFU_Generic, gdal.GFT_Real) self.assertFalse(rat.insert_column(4, field)[0]) # Valid insertions field = RATField('f1', gdal.GFU_Generic, gdal.GFT_Real) self.assertEqual(field.qgis_type, QVariant.Double) self.assertTrue(rat.insert_column(4, field)[0]) self.assertIn('f1', rat.fields.keys()) self.assertEqual(len(rat.data['f1']), len(rat.data['VALUE'])) field = RATField('f2', gdal.GFU_Generic, gdal.GFT_Integer) self.assertEqual(field.qgis_type, QVariant.Int) self.assertTrue(rat.insert_column(2, field)[0]) self.assertIn('f2', rat.fields.keys()) self.assertEqual(len(rat.data['f2']), len(rat.data['VALUE'])) self.assertEqual(rat.data['f2'][0], 0) field = RATField('f3', gdal.GFU_Generic, gdal.GFT_String) self.assertEqual(field.qgis_type, QVariant.String) self.assertTrue(rat.insert_column(len(rat.keys) - 1, field)[0]) self.assertIn('f3', rat.fields.keys()) self.assertEqual(len(rat.data['f3']), len(rat.data['VALUE'])) self.assertEqual(rat.data['f3'][0], '') field = RATField('R', gdal.GFU_Red, gdal.GFT_Integer) self.assertFalse(rat.insert_column(len(rat.keys) - 1, field)[0])
def test_remove_column(self): rat = get_rat(self.raster_layer, 1) self.assertTrue(rat.isValid()) self.assertEqual(len(rat.keys), 16) self.assertEqual(len(rat.keys), len(rat.fields)) # Invalid removals self.assertFalse(rat.remove_column('Value')[0]) self.assertFalse(rat.remove_column('Count')[0]) self.assertFalse(rat.remove_column('not found')[0]) # Valid removals self.assertTrue(rat.remove_column('data_assessment')[0]) self.assertEqual(len(rat.keys), 15) self.assertEqual(len(rat.keys), len(rat.fields))
def test_remove_column_dbf(self): rat = get_rat(self.raster_layer_dbf, 1) self.assertTrue(rat.isValid()) self.assertEqual(len(rat.keys), 17) self.assertEqual(len(rat.keys), len(rat.fields) + 1) # Invalid removals self.assertFalse(rat.remove_column('VALUE')[0]) self.assertFalse(rat.remove_column('COUNT')[0]) self.assertFalse(rat.remove_column('not found')[0]) # Valid removals self.assertTrue(rat.remove_column('SYSTMGRPNA')[0]) self.assertEqual(len(rat.keys), 16) self.assertEqual(len(rat.keys), len(rat.fields) + 1)
def test_insert_column(self): rat = get_rat(self.raster_layer, 1) self.assertTrue(rat.isValid()) self.assertEqual(len(rat.keys), 16) self.assertEqual(len(rat.keys), len(rat.fields)) # Not valid insertions field = RATField('f1', gdal.GFU_MinMax, gdal.GFT_Real) self.assertFalse(rat.insert_column(4, field)[0]) field = RATField('f1', gdal.GFU_Generic, gdal.GFT_Real) self.assertFalse(rat.insert_column(0, field)[0]) field = RATField('f1', gdal.GFU_Generic, gdal.GFT_Real) self.assertFalse(rat.insert_column(1, field)[0]) field = RATField('f1', gdal.GFU_Generic, gdal.GFT_Real) self.assertFalse(rat.insert_column(100, field)[0]) field = RATField('significant_features', gdal.GFU_Generic, gdal.GFT_Real) self.assertFalse(rat.insert_column(4, field)[0]) # Valid insertions field = RATField('f1', gdal.GFU_Generic, gdal.GFT_Real) self.assertEqual(field.qgis_type, QVariant.Double) self.assertTrue(rat.insert_column(4, field)[0]) self.assertIn('f1', rat.fields.keys()) self.assertEqual(len(rat.data['f1']), len(rat.data['Value'])) field = RATField('f2', gdal.GFU_Generic, gdal.GFT_Integer) self.assertEqual(field.qgis_type, QVariant.Int) self.assertTrue(rat.insert_column(2, field)[0]) self.assertIn('f2', rat.fields.keys()) self.assertEqual(len(rat.data['f2']), len(rat.data['Value'])) self.assertEqual(rat.data['f2'][0], 0) field = RATField('f3', gdal.GFU_Generic, gdal.GFT_String) self.assertEqual(field.qgis_type, QVariant.String) self.assertTrue(rat.insert_column(len(rat.keys) - 1, field)[0]) self.assertIn('f3', rat.fields.keys()) self.assertEqual(len(rat.data['f3']), len(rat.data['Value'])) self.assertEqual(rat.data['f3'][0], '')
def test_insert_column_color(self): rat = get_rat(self.raster_layer_color, 1) self.assertTrue(rat.isValid()) model = RATModel(rat) tester = QAbstractItemModelTester( model, QAbstractItemModelTester.FailureReportingMode.Warning) column_count = model.columnCount(QModelIndex()) field = RATField('f1', gdal.GFU_Generic, gdal.GFT_String) self.assertTrue(model.insert_column(3, field)[0]) self.assertEqual(model.columnCount(QModelIndex()), column_count + 1) self.assertEqual(model.headers.index('f1'), 3) # Error field = RATField('f1', gdal.GFU_Generic, gdal.GFT_String) self.assertFalse(model.insert_column(3, field)[0]) self.assertEqual(model.columnCount(QModelIndex()), column_count + 1)
def test_rat_xml_no_usage(self): """Test we can open an XML rat with no usage""" tmp_dir = QTemporaryDir() shutil.copy( os.path.join(os.path.dirname(__file__), 'data', '2x2_2_BANDS_INT16_NO_USAGE.tif'), tmp_dir.path()) shutil.copy( os.path.join(os.path.dirname(__file__), 'data', '2x2_2_BANDS_INT16_NO_USAGE.tif.aux.xml'), tmp_dir.path()) raster_layer = QgsRasterLayer( os.path.join(tmp_dir.path(), '2x2_2_BANDS_INT16_NO_USAGE.tif'), 'rat_test', 'gdal') rat = get_rat(raster_layer, 1) self.assertTrue(rat.isValid()) self.assertEqual(rat.thematic_type, gdal.GRTT_THEMATIC) self.assertIn(gdal.GFU_PixelCount, rat.field_usages)
def _test_classify(self, raster_layer, criteria): self.assertTrue(raster_layer.isValid()) rat = get_rat(raster_layer, 1) unique_values_count = len(set(rat.data[criteria])) unique_row_indexes = rat_classify(raster_layer, 1, rat, criteria) self.assertEqual(len(unique_row_indexes), unique_values_count) renderer = raster_layer.renderer() classes = renderer.classes() colors = {} for idx in unique_row_indexes: klass = classes[idx - 1] colors[klass.label] = klass.color.name() for klass in classes: self.assertEqual(klass.color.name(), colors[klass.label])
def _test(raster_layer): rat = get_rat(raster_layer, 1) value_column = rat.value_columns[0] self.assertEqual(value_column, rat.field_name(gdal.GFU_MinMax)) self.assertNotEqual(rat.data[value_column][-1], 0) row_count = len(rat.data[value_column]) result, error_message = rat.insert_row(0) self.assertTrue(result) self.assertEqual(len(rat.data[value_column]), row_count + 1) self.assertEqual(rat.data[value_column][0], 0) result, error_message = rat.remove_row(0) self.assertTrue(result) self.assertEqual(len(rat.data[value_column]), row_count) self.assertNotEqual(rat.data[value_column][0], 0) last = len(rat.data[value_column]) result, error_message = rat.insert_row(last) self.assertTrue(result) self.assertEqual(len(rat.data[value_column]), row_count + 1) self.assertEqual(rat.data[value_column][last], 0) result, error_message = rat.remove_row(last) self.assertTrue(result) self.assertEqual(len(rat.data[value_column]), row_count) self.assertNotEqual(rat.data[value_column][last - 1], 0) # Invalid ranges last = len(rat.data[value_column]) self.assertFalse(rat.insert_row(-1)[0]) self.assertFalse(rat.insert_row(last + 1)[0]) self.assertFalse(rat.remove_row(-1)[0]) self.assertFalse(rat.remove_row(last)[0])