def testQgsLimitedRandomColorRampV2(self):
        # test random color ramp
        r = QgsLimitedRandomColorRamp(5)
        self.assertEqual(r.type(), 'random')
        self.assertEqual(r.count(), 5)
        self.assertEqual(r.value(0), 0)
        self.assertEqual(r.value(1), 0.25)
        self.assertEqual(r.value(2), 0.5)
        self.assertEqual(r.value(3), 0.75)
        self.assertEqual(r.value(4), 1)

        self.assertTrue(not r.color(-1).isValid())
        self.assertTrue(not r.color(5).isValid())

        # test that generated random colors are all valid
        for i in range(10000):
            r.updateColors()
            for j in range(5):
                self.assertTrue(r.color(r.value(j)).isValid())

        # test setters
        r.setHueMin(10)
        self.assertEqual(r.hueMin(), 10)
        r.setHueMax(60)
        self.assertEqual(r.hueMax(), 60)
        r.setSatMin(70)
        self.assertEqual(r.satMin(), 70)
        r.setSatMax(100)
        self.assertEqual(r.satMax(), 100)
        r.setValMin(150)
        self.assertEqual(r.valMin(), 150)
        r.setValMax(200)
        self.assertEqual(r.valMax(), 200)
        # test that generated random colors are within range
        for i in range(10000):
            r.updateColors()
            for j in range(5):
                c = r.color(r.value(j))
                self.assertTrue(c.isValid())
                self.assertTrue(c.hue() >= r.hueMin())
                self.assertTrue(c.hue() <= r.hueMax())
                self.assertTrue(c.saturation() >= r.satMin())
                self.assertTrue(c.saturation() <= r.satMax())
                self.assertTrue(c.value() >= r.valMin())
                self.assertTrue(c.value() <= r.valMax())

        # test creating from properties
        props = r.properties()
        fromProps = QgsLimitedRandomColorRamp.create(props)
        self.assertEqual(fromProps.count(), 5)
        self.assertEqual(fromProps.hueMin(), 10)
        self.assertEqual(fromProps.hueMax(), 60)
        self.assertEqual(fromProps.satMin(), 70)
        self.assertEqual(fromProps.satMax(), 100)
        self.assertEqual(fromProps.valMin(), 150)
        self.assertEqual(fromProps.valMax(), 200)

        # test cloning ramp
        cloned = r.clone()
        self.assertEqual(cloned.count(), 5)
        self.assertEqual(cloned.hueMin(), 10)
        self.assertEqual(cloned.hueMax(), 60)
        self.assertEqual(cloned.satMin(), 70)
        self.assertEqual(cloned.satMax(), 100)
        self.assertEqual(cloned.valMin(), 150)
        self.assertEqual(cloned.valMax(), 200)

        # test randomColors static method
        for i in range(10000):
            cols = r.randomColors(10, 30, 60, 90, 120, 150, 180)
            self.assertEqual(len(cols), 10)
            for c in cols:
                self.assertTrue(c.isValid())
                self.assertTrue(c.hue() >= 30)
                self.assertTrue(c.hue() <= 60)
                self.assertTrue(c.saturation() >= 90)
                self.assertTrue(c.saturation() <= 120)
                self.assertTrue(c.value() >= 150)
                self.assertTrue(c.value() <= 180)
Beispiel #2
0
    def test_mixed_style(self):
        """
        Test style with both symbols and ramps
        """
        style = QgsStyle()
        style.createMemoryDatabase()

        # style with only symbols

        symbol_a = createMarkerSymbol()
        symbol_a.setColor(QColor(255, 10, 10))
        self.assertTrue(style.addSymbol('a', symbol_a, True))
        style.tagSymbol(QgsStyle.SymbolEntity, 'a', ['tag 1', 'tag 2'])
        symbol_B = createMarkerSymbol()
        symbol_B.setColor(QColor(10, 255, 10))
        self.assertTrue(style.addSymbol('B ', symbol_B, True))
        symbol_b = createFillSymbol()
        symbol_b.setColor(QColor(10, 255, 10))
        self.assertTrue(style.addSymbol('b', symbol_b, True))
        symbol_C = createLineSymbol()
        symbol_C.setColor(QColor(10, 255, 10))
        self.assertTrue(style.addSymbol('C', symbol_C, True))
        style.tagSymbol(QgsStyle.SymbolEntity, 'C', ['tag 3'])
        symbol_C = createMarkerSymbol()
        symbol_C.setColor(QColor(10, 255, 10))
        self.assertTrue(style.addSymbol(' ----c/- ', symbol_C, True))
        ramp_a = QgsLimitedRandomColorRamp(5)
        self.assertTrue(style.addColorRamp('ramp a', ramp_a, True))
        style.tagSymbol(QgsStyle.ColorrampEntity, 'ramp a', ['tag 1', 'tag 2'])
        symbol_B = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('ramp B ', symbol_B, True))
        symbol_b = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('ramp c', symbol_b, True))

        model = QgsStyleModel(style)
        self.assertEqual(model.rowCount(), 8)
        self.assertEqual(model.columnCount(), 2)

        self.assertTrue(model.index(0, 0).isValid())
        self.assertFalse(model.index(10, 0).isValid())
        self.assertFalse(model.index(0, 10).isValid())

        self.assertFalse(model.parent(model.index(0, 0)).isValid())

        for role in (Qt.DisplayRole, Qt.EditRole):
            self.assertIsNone(model.data(model.index(-1, 0), role))
            self.assertIsNone(model.data(model.index(-1, 1), role))
            self.assertEqual(model.data(model.index(0, 0), role), ' ----c/- ')
            self.assertFalse(model.data(model.index(0, 1), role))
            self.assertIsNone(model.data(model.index(0, 2), role))
            self.assertIsNone(model.data(model.index(0, -1), role))
            self.assertEqual(model.data(model.index(1, 0), role), 'B ')
            self.assertFalse(model.data(model.index(1, 1), role))
            self.assertEqual(model.data(model.index(2, 0), role), 'C')
            self.assertEqual(model.data(model.index(2, 1), role), 'tag 3')
            self.assertEqual(model.data(model.index(3, 0), role), 'a')
            self.assertEqual(model.data(model.index(3, 1), role),
                             'tag 1, tag 2')
            self.assertEqual(model.data(model.index(4, 0), role), 'b')
            self.assertFalse(model.data(model.index(4, 1), role))
            self.assertEqual(model.data(model.index(5, 0), role), 'ramp B ')
            self.assertFalse(model.data(model.index(5, 1), role))
            self.assertEqual(model.data(model.index(6, 0), role), 'ramp a')
            self.assertEqual(model.data(model.index(6, 1), role),
                             'tag 1, tag 2')
            self.assertEqual(model.data(model.index(7, 0), role), 'ramp c')
            self.assertFalse(model.data(model.index(7, 1), role))
            self.assertIsNone(model.data(model.index(8, 0), role))
            self.assertIsNone(model.data(model.index(8, 1), role))

        # decorations
        self.assertIsNone(model.data(model.index(-1, 0), Qt.DecorationRole))
        self.assertIsNone(model.data(model.index(0, 1), Qt.DecorationRole))
        self.assertIsNone(model.data(model.index(8, 0), Qt.DecorationRole))
        self.assertFalse(
            model.data(model.index(0, 0), Qt.DecorationRole).isNull())
        self.assertFalse(
            model.data(model.index(5, 0), Qt.DecorationRole).isNull())

        self.assertEqual(model.data(model.index(0, 0), QgsStyleModel.TypeRole),
                         QgsStyle.SymbolEntity)
        self.assertEqual(model.data(model.index(1, 0), QgsStyleModel.TypeRole),
                         QgsStyle.SymbolEntity)
        self.assertEqual(model.data(model.index(4, 0), QgsStyleModel.TypeRole),
                         QgsStyle.SymbolEntity)
        self.assertEqual(model.data(model.index(5, 0), QgsStyleModel.TypeRole),
                         QgsStyle.ColorrampEntity)
        self.assertEqual(model.data(model.index(6, 0), QgsStyleModel.TypeRole),
                         QgsStyle.ColorrampEntity)
        self.assertEqual(model.data(model.index(7, 0), QgsStyleModel.TypeRole),
                         QgsStyle.ColorrampEntity)
Beispiel #3
0
    def test_renamed(self):
        style = QgsStyle()
        style.createMemoryDatabase()

        model = QgsStyleModel(style)
        symbol = createMarkerSymbol()
        self.assertTrue(style.addSymbol('a', symbol, True))
        symbol = createMarkerSymbol()
        self.assertTrue(style.addSymbol('c', symbol, True))
        ramp_a = QgsLimitedRandomColorRamp(5)
        self.assertTrue(style.addColorRamp('ramp a', ramp_a, True))
        symbol_B = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('ramp c', symbol_B, True))

        self.assertEqual(model.rowCount(), 4)
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'a')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'c')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp a')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp c')

        self.assertTrue(style.renameSymbol('a', 'b'))
        self.assertEqual(model.rowCount(), 4)
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'b')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'c')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp a')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp c')

        self.assertTrue(style.renameSymbol('b', 'd'))
        self.assertEqual(model.rowCount(), 4)
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'c')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'd')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp a')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp c')

        self.assertTrue(style.renameSymbol('d', 'e'))
        self.assertEqual(model.rowCount(), 4)
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'c')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'e')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp a')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp c')

        self.assertTrue(style.renameSymbol('c', 'f'))
        self.assertEqual(model.rowCount(), 4)
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'e')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'f')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp a')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp c')

        self.assertTrue(style.renameColorRamp('ramp a', 'ramp b'))
        self.assertEqual(model.rowCount(), 4)
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'e')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'f')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp b')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp c')

        self.assertTrue(style.renameColorRamp('ramp b', 'ramp d'))
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'e')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'f')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp c')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp d')

        self.assertTrue(style.renameColorRamp('ramp d', 'ramp e'))
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'e')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'f')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp c')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp e')

        self.assertTrue(style.renameColorRamp('ramp c', 'ramp f'))
        self.assertEqual(model.data(model.index(0, 0), Qt.DisplayRole), 'e')
        self.assertEqual(model.data(model.index(1, 0), Qt.DisplayRole), 'f')
        self.assertEqual(model.data(model.index(2, 0), Qt.DisplayRole),
                         'ramp e')
        self.assertEqual(model.data(model.index(3, 0), Qt.DisplayRole),
                         'ramp f')
Beispiel #4
0
    def test_style_with_ramps(self):
        style = QgsStyle()
        style.createMemoryDatabase()

        # style with only ramps

        ramp_a = QgsLimitedRandomColorRamp(5)
        self.assertTrue(style.addColorRamp('a', ramp_a, True))
        style.tagSymbol(QgsStyle.ColorrampEntity, 'a', ['tag 1', 'tag 2'])
        symbol_B = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('B ', symbol_B, True))
        symbol_b = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('b', symbol_b, True))
        symbol_C = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('C', symbol_C, True))
        style.tagSymbol(QgsStyle.ColorrampEntity, 'C', ['tag 3'])
        symbol_C = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp(' ----c/- ', symbol_C, True))

        model = QgsStyleModel(style)
        self.assertEqual(model.rowCount(), 5)
        self.assertEqual(model.columnCount(), 2)

        self.assertTrue(model.index(0, 0).isValid())
        self.assertFalse(model.index(10, 0).isValid())
        self.assertFalse(model.index(0, 10).isValid())

        self.assertFalse(model.parent(model.index(0, 0)).isValid())

        for role in (Qt.DisplayRole, Qt.EditRole):
            self.assertIsNone(model.data(model.index(-1, 0), role))
            self.assertIsNone(model.data(model.index(-1, 1), role))
            self.assertEqual(model.data(model.index(0, 0), role), ' ----c/- ')
            self.assertFalse(model.data(model.index(0, 1), role))
            self.assertIsNone(model.data(model.index(0, 2), role))
            self.assertIsNone(model.data(model.index(0, -1), role))
            self.assertEqual(model.data(model.index(1, 0), role), 'B ')
            self.assertFalse(model.data(model.index(1, 1), role))
            self.assertEqual(model.data(model.index(2, 0), role), 'C')
            self.assertEqual(model.data(model.index(2, 1), role), 'tag 3')
            self.assertEqual(model.data(model.index(3, 0), role), 'a')
            self.assertEqual(model.data(model.index(3, 1), role),
                             'tag 1, tag 2')
            self.assertEqual(model.data(model.index(4, 0), role), 'b')
            self.assertFalse(model.data(model.index(4, 1), role))
            self.assertIsNone(model.data(model.index(5, 0), role))
            self.assertIsNone(model.data(model.index(5, 1), role))

        # decorations
        self.assertIsNone(model.data(model.index(-1, 0), Qt.DecorationRole))
        self.assertIsNone(model.data(model.index(0, 1), Qt.DecorationRole))
        self.assertIsNone(model.data(model.index(5, 0), Qt.DecorationRole))
        self.assertFalse(
            model.data(model.index(0, 0), Qt.DecorationRole).isNull())

        self.assertEqual(model.data(model.index(0, 0), QgsStyleModel.TypeRole),
                         QgsStyle.ColorrampEntity)
        self.assertEqual(model.data(model.index(1, 0), QgsStyleModel.TypeRole),
                         QgsStyle.ColorrampEntity)
        self.assertEqual(model.data(model.index(4, 0), QgsStyleModel.TypeRole),
                         QgsStyle.ColorrampEntity)
    def testQgsLimitedRandomColorRampV2(self):
        # test random color ramp
        r = QgsLimitedRandomColorRamp(5)
        self.assertEqual(r.type(), 'random')
        self.assertEqual(r.count(), 5)
        self.assertEqual(r.value(0), 0)
        self.assertEqual(r.value(1), 0.25)
        self.assertEqual(r.value(2), 0.5)
        self.assertEqual(r.value(3), 0.75)
        self.assertEqual(r.value(4), 1)

        self.assertTrue(not r.color(-1).isValid())
        self.assertTrue(not r.color(5).isValid())

        # test that generated random colors are all valid
        for i in range(10000):
            r.updateColors()
            for j in range(5):
                self.assertTrue(r.color(r.value(j)).isValid())

        # test setters
        r.setHueMin(10)
        self.assertEqual(r.hueMin(), 10)
        r.setHueMax(60)
        self.assertEqual(r.hueMax(), 60)
        r.setSatMin(70)
        self.assertEqual(r.satMin(), 70)
        r.setSatMax(100)
        self.assertEqual(r.satMax(), 100)
        r.setValMin(150)
        self.assertEqual(r.valMin(), 150)
        r.setValMax(200)
        self.assertEqual(r.valMax(), 200)
        # test that generated random colors are within range
        for i in range(10000):
            r.updateColors()
            for j in range(5):
                c = r.color(r.value(j))
                self.assertTrue(c.isValid())
                self.assertTrue(c.hue() >= r.hueMin())
                self.assertTrue(c.hue() <= r.hueMax())
                self.assertTrue(c.saturation() >= r.satMin())
                self.assertTrue(c.saturation() <= r.satMax())
                self.assertTrue(c.value() >= r.valMin())
                self.assertTrue(c.value() <= r.valMax())

        # test creating from properties
        props = r.properties()
        fromProps = QgsLimitedRandomColorRamp.create(props)
        self.assertEqual(fromProps.count(), 5)
        self.assertEqual(fromProps.hueMin(), 10)
        self.assertEqual(fromProps.hueMax(), 60)
        self.assertEqual(fromProps.satMin(), 70)
        self.assertEqual(fromProps.satMax(), 100)
        self.assertEqual(fromProps.valMin(), 150)
        self.assertEqual(fromProps.valMax(), 200)

        # test cloning ramp
        cloned = r.clone()
        self.assertEqual(cloned.count(), 5)
        self.assertEqual(cloned.hueMin(), 10)
        self.assertEqual(cloned.hueMax(), 60)
        self.assertEqual(cloned.satMin(), 70)
        self.assertEqual(cloned.satMax(), 100)
        self.assertEqual(cloned.valMin(), 150)
        self.assertEqual(cloned.valMax(), 200)

        # test randomColors static method
        for i in range(10000):
            cols = r.randomColors(10, 30, 60, 90, 120, 150, 180)
            self.assertEqual(len(cols), 10)
            for c in cols:
                self.assertTrue(c.isValid())
                self.assertTrue(c.hue() >= 30)
                self.assertTrue(c.hue() <= 60)
                self.assertTrue(c.saturation() >= 90)
                self.assertTrue(c.saturation() <= 120)
                self.assertTrue(c.value() >= 150)
                self.assertTrue(c.value() <= 180)
Beispiel #6
0
    def test_filter_proxy(self):
        style = QgsStyle()
        style.createMemoryDatabase()

        symbol_a = createMarkerSymbol()
        symbol_a.setColor(QColor(255, 10, 10))
        self.assertTrue(style.addSymbol('a', symbol_a, True))
        style.tagSymbol(QgsStyle.SymbolEntity, 'a', ['tag 1', 'tag 2'])
        symbol_B = createMarkerSymbol()
        symbol_B.setColor(QColor(10, 255, 10))
        self.assertTrue(style.addSymbol('BB', symbol_B, True))
        symbol_b = createFillSymbol()
        symbol_b.setColor(QColor(10, 255, 10))
        self.assertTrue(style.addSymbol('b', symbol_b, True))
        symbol_C = createLineSymbol()
        symbol_C.setColor(QColor(10, 255, 10))
        self.assertTrue(style.addSymbol('C', symbol_C, True))
        style.tagSymbol(QgsStyle.SymbolEntity, 'C', ['tag 3'])
        symbol_C = createMarkerSymbol()
        symbol_C.setColor(QColor(10, 255, 10))
        self.assertTrue(style.addSymbol('another', symbol_C, True))
        ramp_a = QgsLimitedRandomColorRamp(5)
        self.assertTrue(style.addColorRamp('ramp a', ramp_a, True))
        style.tagSymbol(QgsStyle.ColorrampEntity, 'ramp a', ['tag 1', 'tag 2'])
        symbol_B = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('ramp BB', symbol_B, True))
        symbol_b = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('ramp c', symbol_b, True))

        model = QgsStyleProxyModel(style)
        self.assertEqual(model.rowCount(), 8)

        # filter string
        model.setFilterString('xx')
        self.assertEqual(model.filterString(), 'xx')
        self.assertEqual(model.rowCount(), 0)
        model.setFilterString('b')
        self.assertEqual(model.rowCount(), 3)
        self.assertEqual(model.data(model.index(0, 0)), 'b')
        self.assertEqual(model.data(model.index(1, 0)), 'BB')
        self.assertEqual(model.data(model.index(2, 0)), 'ramp BB')
        model.setFilterString('bb')
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'BB')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp BB')
        model.setFilterString('tag 1')
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'a')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp a')
        model.setFilterString('TAG 1')
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'a')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp a')
        model.setFilterString('ram b')
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'ramp BB')
        model.setFilterString('ta ram') # match ta -> "tag 1", ram -> "ramp a"
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'ramp a')
        model.setFilterString('')
        self.assertEqual(model.rowCount(), 8)

        # entity type
        model.setEntityFilter(QgsStyle.SymbolEntity)
        self.assertEqual(model.rowCount(), 8)
        model.setEntityFilter(QgsStyle.ColorrampEntity)
        self.assertEqual(model.rowCount(), 8)
        model.setEntityFilterEnabled(True)
        self.assertEqual(model.rowCount(), 3)
        self.assertEqual(model.data(model.index(0, 0)), 'ramp a')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp BB')
        self.assertEqual(model.data(model.index(2, 0)), 'ramp c')
        model.setFilterString('BB')
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'ramp BB')
        model.setFilterString('')

        model.setEntityFilter(QgsStyle.SymbolEntity)
        self.assertEqual(model.rowCount(), 5)
        self.assertEqual(model.data(model.index(0, 0)), 'a')
        self.assertEqual(model.data(model.index(1, 0)), 'another')
        self.assertEqual(model.data(model.index(2, 0)), 'b')
        self.assertEqual(model.data(model.index(3, 0)), 'BB')
        self.assertEqual(model.data(model.index(4, 0)), 'C')
        model.setFilterString('ot')
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'another')
        model.setFilterString('')

        model.setEntityFilterEnabled(False)
        self.assertEqual(model.rowCount(), 8)

        # symbol type filter
        model.setSymbolType(QgsSymbol.Line)
        self.assertEqual(model.rowCount(), 8)
        model.setSymbolType(QgsSymbol.Marker)
        self.assertEqual(model.rowCount(), 8)
        model.setSymbolTypeFilterEnabled(True)
        self.assertEqual(model.rowCount(), 6)
        self.assertEqual(model.data(model.index(0, 0)), 'a')
        self.assertEqual(model.data(model.index(1, 0)), 'another')
        self.assertEqual(model.data(model.index(2, 0)), 'BB')
        self.assertEqual(model.data(model.index(3, 0)), 'ramp a')
        self.assertEqual(model.data(model.index(4, 0)), 'ramp BB')
        model.setEntityFilterEnabled(True)
        self.assertEqual(model.rowCount(), 3)
        self.assertEqual(model.data(model.index(0, 0)), 'a')
        self.assertEqual(model.data(model.index(1, 0)), 'another')
        self.assertEqual(model.data(model.index(2, 0)), 'BB')
        model.setFilterString('oth')
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'another')
        model.setEntityFilterEnabled(False)
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'another')
        model.setEntityFilterEnabled(True)
        model.setFilterString('')
        model.setSymbolType(QgsSymbol.Line)
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'C')
        model.setSymbolType(QgsSymbol.Fill)
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'b')
        model.setSymbolTypeFilterEnabled(False)
        model.setEntityFilterEnabled(False)
        self.assertEqual(model.rowCount(), 8)

        # tag filter
        self.assertEqual(model.tagId(), -1)
        tag_1_id = style.tagId('tag 1')
        tag_3_id = style.tagId('tag 3')
        model.setTagId(tag_1_id)
        self.assertEqual(model.tagId(), tag_1_id)
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'a')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp a')
        model.setEntityFilterEnabled(True)
        model.setEntityFilter(QgsStyle.ColorrampEntity)
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'ramp a')
        model.setEntityFilterEnabled(False)
        model.setFilterString('ra')
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'ramp a')
        model.setEntityFilterEnabled(False)
        model.setFilterString('')
        model.setTagId(-1)
        self.assertEqual(model.rowCount(), 8)
        model.setTagId(tag_3_id)
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'C')
        style.tagSymbol(QgsStyle.ColorrampEntity, 'ramp c', ['tag 3'])
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'C')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp c')
        style.detagSymbol(QgsStyle.ColorrampEntity, 'ramp c')
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'C')
        model.setTagId(-1)
        self.assertEqual(model.rowCount(), 8)

        # favorite filter
        style.addFavorite(QgsStyle.ColorrampEntity, 'ramp c')
        style.addFavorite(QgsStyle.SymbolEntity, 'another')
        self.assertEqual(model.favoritesOnly(), False)
        model.setFavoritesOnly(True)
        self.assertEqual(model.favoritesOnly(), True)
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'another')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp c')
        model.setEntityFilterEnabled(True)
        model.setEntityFilter(QgsStyle.ColorrampEntity)
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'ramp c')
        model.setEntityFilterEnabled(False)
        model.setFilterString('er')
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'another')
        model.setEntityFilterEnabled(False)
        model.setFilterString('')
        self.assertEqual(model.rowCount(), 2)
        style.addFavorite(QgsStyle.ColorrampEntity, 'ramp a')
        self.assertEqual(model.rowCount(), 3)
        self.assertEqual(model.data(model.index(0, 0)), 'another')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp a')
        self.assertEqual(model.data(model.index(2, 0)), 'ramp c')
        style.removeFavorite(QgsStyle.ColorrampEntity, 'ramp a')
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'another')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp c')
        style.addFavorite(QgsStyle.SymbolEntity, 'BB')
        self.assertEqual(model.rowCount(), 3)
        self.assertEqual(model.data(model.index(0, 0)), 'another')
        self.assertEqual(model.data(model.index(1, 0)), 'BB')
        self.assertEqual(model.data(model.index(2, 0)), 'ramp c')
        style.removeFavorite(QgsStyle.SymbolEntity, 'another')
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'BB')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp c')
        model.setFavoritesOnly(False)
        self.assertEqual(model.rowCount(), 8)

        # smart group filter
        style.addSmartgroup('smart', 'AND', ['tag 3'], [], ['c'], [])
        self.assertEqual(model.smartGroupId(), -1)
        model.setSmartGroupId(1)
        self.assertEqual(model.smartGroupId(), 1)
        self.assertEqual(model.rowCount(), 1)
        self.assertEqual(model.data(model.index(0, 0)), 'C')
        style.addSmartgroup('smart', 'OR', ['tag 3'], [], ['c'], [])
        model.setSmartGroupId(2)
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'C')
        self.assertEqual(model.data(model.index(1, 0)), 'ramp c')
        style.tagSymbol(QgsStyle.SymbolEntity, 'a', ['tag 3'])
        self.assertEqual(model.rowCount(), 3)
        self.assertEqual(model.data(model.index(0, 0)), 'a')
        self.assertEqual(model.data(model.index(1, 0)), 'C')
        self.assertEqual(model.data(model.index(2, 0)), 'ramp c')
        style.renameColorRamp('ramp c', 'x')
        self.assertEqual(model.rowCount(), 2)
        self.assertEqual(model.data(model.index(0, 0)), 'a')
        self.assertEqual(model.data(model.index(1, 0)), 'C')
        model.setSmartGroupId(-1)
        self.assertEqual(model.rowCount(), 8)
Beispiel #7
0
    def test_tags_changed(self):
        style = QgsStyle()
        style.createMemoryDatabase()

        model = QgsStyleModel(style)
        symbol = createMarkerSymbol()
        self.assertTrue(style.addSymbol('a', symbol, True))
        symbol = createMarkerSymbol()
        self.assertTrue(style.addSymbol('c', symbol, True))
        ramp_a = QgsLimitedRandomColorRamp(5)
        self.assertTrue(style.addColorRamp('ramp a', ramp_a, True))
        symbol_B = QgsLimitedRandomColorRamp()
        self.assertTrue(style.addColorRamp('ramp c', symbol_B, True))

        self.assertFalse(model.data(model.index(0, 1), Qt.DisplayRole))
        self.assertFalse(model.data(model.index(1, 1), Qt.DisplayRole))
        self.assertFalse(model.data(model.index(2, 1), Qt.DisplayRole))
        self.assertFalse(model.data(model.index(3, 1), Qt.DisplayRole))

        style.tagSymbol(QgsStyle.SymbolEntity, 'a', ['t1', 't2'])
        self.assertEqual(model.data(model.index(0, 1), Qt.DisplayRole),
                         't1, t2')
        self.assertFalse(model.data(model.index(1, 1), Qt.DisplayRole))
        self.assertFalse(model.data(model.index(2, 1), Qt.DisplayRole))
        self.assertFalse(model.data(model.index(3, 1), Qt.DisplayRole))

        style.tagSymbol(QgsStyle.SymbolEntity, 'a', ['t3'])
        self.assertEqual(model.data(model.index(0, 1), Qt.DisplayRole),
                         't1, t2, t3')
        self.assertFalse(model.data(model.index(1, 1), Qt.DisplayRole))
        self.assertFalse(model.data(model.index(2, 1), Qt.DisplayRole))
        self.assertFalse(model.data(model.index(3, 1), Qt.DisplayRole))

        style.tagSymbol(QgsStyle.ColorrampEntity, 'ramp a', ['t1', 't2'])
        self.assertEqual(model.data(model.index(0, 1), Qt.DisplayRole),
                         't1, t2, t3')
        self.assertFalse(model.data(model.index(1, 1), Qt.DisplayRole))
        self.assertEqual(model.data(model.index(2, 1), Qt.DisplayRole),
                         't1, t2')
        self.assertFalse(model.data(model.index(3, 1), Qt.DisplayRole))

        style.tagSymbol(QgsStyle.ColorrampEntity, 'ramp c', ['t3'])
        self.assertEqual(model.data(model.index(0, 1), Qt.DisplayRole),
                         't1, t2, t3')
        self.assertFalse(model.data(model.index(1, 1), Qt.DisplayRole))
        self.assertEqual(model.data(model.index(2, 1), Qt.DisplayRole),
                         't1, t2')
        self.assertEqual(model.data(model.index(3, 1), Qt.DisplayRole), 't3')

        style.tagSymbol(QgsStyle.SymbolEntity, 'c', ['t4'])
        self.assertEqual(model.data(model.index(0, 1), Qt.DisplayRole),
                         't1, t2, t3')
        self.assertEqual(model.data(model.index(1, 1), Qt.DisplayRole), 't4')
        self.assertEqual(model.data(model.index(2, 1), Qt.DisplayRole),
                         't1, t2')
        self.assertEqual(model.data(model.index(3, 1), Qt.DisplayRole), 't3')

        style.detagSymbol(QgsStyle.SymbolEntity, 'c', ['t4'])
        self.assertEqual(model.data(model.index(0, 1), Qt.DisplayRole),
                         't1, t2, t3')
        self.assertFalse(model.data(model.index(1, 1), Qt.DisplayRole))
        self.assertEqual(model.data(model.index(2, 1), Qt.DisplayRole),
                         't1, t2')
        self.assertEqual(model.data(model.index(3, 1), Qt.DisplayRole), 't3')

        style.detagSymbol(QgsStyle.ColorrampEntity, 'ramp a', ['t1'])
        self.assertEqual(model.data(model.index(0, 1), Qt.DisplayRole),
                         't1, t2, t3')
        self.assertFalse(model.data(model.index(1, 1), Qt.DisplayRole))
        self.assertEqual(model.data(model.index(2, 1), Qt.DisplayRole), 't2')
        self.assertEqual(model.data(model.index(3, 1), Qt.DisplayRole), 't3')
Beispiel #8
0
    def testPaletted(self):
        """ test paletted raster renderer with raster with color table"""
        path = os.path.join(unitTestDataPath('raster'),
                            'with_color_table.tif')
        info = QFileInfo(path)
        base_name = info.baseName()
        layer = QgsRasterLayer(path, base_name)
        self.assertTrue(layer.isValid(), 'Raster not loaded: {}'.format(path))

        renderer = QgsPalettedRasterRenderer(layer.dataProvider(), 1,
                                             [QgsPalettedRasterRenderer.Class(1, QColor(0, 255, 0), 'class 2'),
                                              QgsPalettedRasterRenderer.Class(3, QColor(255, 0, 0), 'class 1')])

        self.assertEqual(renderer.nColors(), 2)
        self.assertEqual(renderer.usesBands(), [1])

        # test labels
        self.assertEqual(renderer.label(1), 'class 2')
        self.assertEqual(renderer.label(3), 'class 1')
        self.assertFalse(renderer.label(101))

        # test legend symbology - should be sorted by value
        legend = renderer.legendSymbologyItems()
        self.assertEqual(legend[0][0], 'class 2')
        self.assertEqual(legend[1][0], 'class 1')
        self.assertEqual(legend[0][1].name(), '#00ff00')
        self.assertEqual(legend[1][1].name(), '#ff0000')

        # test retrieving classes
        classes = renderer.classes()
        self.assertEqual(classes[0].value, 1)
        self.assertEqual(classes[1].value, 3)
        self.assertEqual(classes[0].label, 'class 2')
        self.assertEqual(classes[1].label, 'class 1')
        self.assertEqual(classes[0].color.name(), '#00ff00')
        self.assertEqual(classes[1].color.name(), '#ff0000')

        # test set label
        # bad index
        renderer.setLabel(1212, 'bad')
        renderer.setLabel(3, 'new class')
        self.assertEqual(renderer.label(3), 'new class')

        # color ramp
        r = QgsLimitedRandomColorRamp(5)
        renderer.setSourceColorRamp(r)
        self.assertEqual(renderer.sourceColorRamp().type(), 'random')
        self.assertEqual(renderer.sourceColorRamp().count(), 5)

        # clone
        new_renderer = renderer.clone()
        classes = new_renderer.classes()
        self.assertEqual(classes[0].value, 1)
        self.assertEqual(classes[1].value, 3)
        self.assertEqual(classes[0].label, 'class 2')
        self.assertEqual(classes[1].label, 'new class')
        self.assertEqual(classes[0].color.name(), '#00ff00')
        self.assertEqual(classes[1].color.name(), '#ff0000')
        self.assertEqual(new_renderer.sourceColorRamp().type(), 'random')
        self.assertEqual(new_renderer.sourceColorRamp().count(), 5)

        # write to xml and read
        doc = QDomDocument('testdoc')
        elem = doc.createElement('qgis')
        renderer.writeXml(doc, elem)
        restored = QgsPalettedRasterRenderer.create(elem.firstChild().toElement(), layer.dataProvider())
        self.assertTrue(restored)
        self.assertEqual(restored.usesBands(), [1])
        classes = restored.classes()
        self.assertTrue(classes)
        self.assertEqual(classes[0].value, 1)
        self.assertEqual(classes[1].value, 3)
        self.assertEqual(classes[0].label, 'class 2')
        self.assertEqual(classes[1].label, 'new class')
        self.assertEqual(classes[0].color.name(), '#00ff00')
        self.assertEqual(classes[1].color.name(), '#ff0000')
        self.assertEqual(restored.sourceColorRamp().type(), 'random')
        self.assertEqual(restored.sourceColorRamp().count(), 5)

        # render test
        layer.setRenderer(renderer)
        ms = QgsMapSettings()
        ms.setLayers([layer])
        ms.setExtent(layer.extent())

        checker = QgsRenderChecker()
        checker.setControlName("expected_paletted_renderer")
        checker.setMapSettings(ms)

        self.assertTrue(checker.runTest("expected_paletted_renderer"), "Paletted rendering test failed")