Exemplo n.º 1
0
    def testUsedAttributes(self):
        renderer = QgsPointCloudAttributeByRampRenderer()
        renderer.setAttribute('attr')

        rc = QgsRenderContext()
        prc = QgsPointCloudRenderContext(rc, QgsVector3D(), QgsVector3D())

        self.assertEqual(renderer.usedAttributes(prc), {'attr'})
    def testUsedAttributes(self):
        renderer = QgsPointCloudRgbRenderer()
        renderer.setBlueAttribute('b')
        renderer.setGreenAttribute('g')
        renderer.setRedAttribute('r')

        rc = QgsRenderContext()
        prc = QgsPointCloudRenderContext(rc, QgsVector3D(), QgsVector3D())

        self.assertEqual(renderer.usedAttributes(prc), {'r', 'g', 'b'})
Exemplo n.º 3
0
    def testUsedAttributes(self):
        renderer = QgsPointCloudRgbRenderer()
        renderer.setBlueAttribute('b')
        renderer.setGreenAttribute('g')
        renderer.setRedAttribute('r')

        rc = QgsRenderContext()
        prc = QgsPointCloudRenderContext(rc, QgsVector3D(), QgsVector3D())

        self.assertEqual(renderer.usedAttributes(prc), {'r', 'g', 'b'})

        # if context is filtering by z, we also need the z attribute
        rc.setZRange(QgsDoubleRange(1, 10))
        prc = QgsPointCloudRenderContext(rc, QgsVector3D(), QgsVector3D())
        self.assertEqual(renderer.usedAttributes(prc), {'r', 'g', 'b', 'Z'})
Exemplo n.º 4
0
    def testQgsVector(self):
        v = QgsVector(1, 2)
        self.assertEqual(v.__repr__(), '<QgsVector: Vector (1, 2)>')

        v = QgsVector3D(1, 2, 3)
        self.assertEqual(v.__repr__(), '<QgsVector3D: Vector3D (1, 2, 3)>')
Exemplo n.º 5
0
    def run(self):
        f_count = 0

        if self.only_selected:
            f_count += len(self.source_layer.selectedFeatures())
            features = [i for i in self.source_layer.selectedFeatures()]
        else:
            f_count += self.source_layer.featureCount()
            features = [i for i in self.source_layer.getFeatures()]
        i = 0
        prg = 0

        for f in features:
            f_geom = f.geometry()

            for part in f_geom.parts():
                part_geom = QgsGeometry.fromWkt(part.asWkt())
                part_geom_sections = self.generateSections(
                    part_geom, self.distance)
                part_geom_sections_len = len(part_geom_sections)
                i2 = 0

                for pgs in part_geom_sections:
                    if not self.stopTask:
                        att = f.attributes()
                        geom_z = self.addZvalue(pgs)
                        if geom_z[0] == False:
                            self.error.emit(geom_z[1])
                            return
                        feature = QgsFeature()
                        v_lst = [i for i in geom_z[1].vertices()]

                        # roznica_z
                        z_diff = round(abs(v_lst[0].z() - v_lst[-1].z()), 2)
                        att.append(z_diff)

                        # dl_3d
                        dl_3d = [
                            QgsVector3D(i.x(), i.y(), i.z()) for i in v_lst
                        ]
                        dl_3d = [
                            dl_3d[i].distance(dl_3d[i + 1])
                            for i, e in enumerate(dl_3d[:-1])
                        ]
                        dl_3d = round(sum(dl_3d), 2)
                        att.append(dl_3d)
                        # spadek
                        if dl_3d == 0:
                            continue
                        spadek = round((z_diff / dl_3d) * 100, 2)
                        att.append(spadek)

                        feature.setAttributes(att)
                        feature.setGeometry(geom_z[1])
                        self.add_feature.emit(feature)

                        i2 += 1
                        prg2 = ((i2 / part_geom_sections_len / f_count) *
                                100) + prg
                        if (prg2 - prg) > 1:
                            self.progress.emit(prg2)
                    else:
                        return
            i += 1
            prg = (i / f_count) * 100
            self.progress.emit(prg)

        self.end.emit()