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])
