def getPoint(self, mapPoint):
        self.set_rad.setEnabled(True)
        # change tool so you don't get more than one POI
        self.canvas.unsetMapTool(self.emitPoint)
        self.canvas.setMapTool(self.userTool)
        # Get the click
        if mapPoint:
            self.atk_pt = QgsPoint(mapPoint)
            self.distance()
            # Specify the geometry type
            layer = QgsVectorLayer('Point?crs=epsg:28992', 'Attack Point',
                                   'memory')

            style = "style_attack.qml"
            qml_path = self.plugin_dir + "/data/" + style
            layer.loadNamedStyle(qml_path)
            layer.triggerRepaint()

            # Set the provider to accept the data source
            prov = layer.dataProvider()

            # Add a new feature and assign the geometry
            feat = QgsFeature()
            feat.setGeometry(QgsGeometry.fromPoint(mapPoint))
            prov.addFeatures([feat])

            # Update extent of the layer
            layer.updateExtents()

            # Add the layer to the Layers panel
            QgsMapLayerRegistry.instance().addMapLayers([layer])
Exemple #2
0
    def create_point(self, p1, name):
        layer = QgsVectorLayer('Point?crs=%s' % int(self.crs), name, "memory")
        mycrs = QgsCoordinateReferenceSystem(int(self.crs), 0)
        self.reprojectgeographic = QgsCoordinateTransform(
            self.iface.mapCanvas().mapRenderer().destinationCrs(), mycrs)
        pr = layer.dataProvider()
        point = QgsFeature()
        point.setGeometry(
            QgsGeometry.fromPoint(self.reprojectgeographic.transform(p1)))
        pr.addFeatures([point])
        #layer.setCrs(QgsCoordinateReferenceSystem(int(self.crs), 0))
        layer.updateExtents()

        QgsMapLayerRegistry.instance().addMapLayer(layer)

        return p1
Exemple #3
0
class Create_vlayer(object):
    '''creation of a virtual layer'''
    def __init__(self, nom, type):
        self.type = type
        self.name = nom
        self.layer = QgsVectorLayer(self.type, self.name, "memory")
        self.pr = self.layer.dataProvider()

    def create_point(self, geometry):
        # add point to the layer
        self.seg = QgsFeature()
        self.seg.setGeometry(QgsGeometry.fromPoint(geometry))
        self.pr.addFeatures([self.seg])
        self.layer.updateExtents()

    @property
    def display_layer(self):
        #end of layer and display layer
        QgsProject.instance().addMapLayers([self.layer])
Exemple #4
0
    def exit_dialog(self, points, crs):
        self.dialog.close()

        layer = QgsVectorLayer('LineString', self.name_tracado, "memory")
        pr = layer.dataProvider()
        print points
        anterior = QgsPoint(points[0])
        fets = []
        for p in points[1:]:
            fet = QgsFeature(layer.pendingFields())
            fet.setGeometry(QgsGeometry.fromPolyline([anterior, QgsPoint(p)]))
            fets.append(fet)
            anterior = QgsPoint(p)
        pr.addFeatures(fets)
        self.crs = crs
        layer.setCrs(QgsCoordinateReferenceSystem(int(crs), 0))
        layer.updateExtents()

        QgsMapLayerRegistry.instance().addMapLayer(layer)
    def painting(self, data, fileType):
        currentInputCRS = self.dlg.inputCRS.text().replace(" ", "")
        table = data.sheets()[0]
        nrows = table.nrows
        if fileType == '4G':
            vl = QgsVectorLayer("Polygon?crs=EPSG:"+currentInputCRS, u"4G基础信息图层", "memory")
            vlLabel = QgsVectorLayer("Polygon?crs=EPSG:"+currentInputCRS, u"4G基础信息标签层", "memory")
        elif fileType == '3G':
            vl = QgsVectorLayer("Polygon?crs=EPSG:"+currentInputCRS, u"3G基础信息图层", "memory")
            vlLabel = QgsVectorLayer("Polygon?crs=EPSG:"+currentInputCRS, u"3G基础信息标签层", "memory")
        elif fileType == '2G':
            vl = QgsVectorLayer("Polygon?crs=EPSG:"+currentInputCRS, u"2G基础信息图层", "memory")
            vlLabel = QgsVectorLayer("Polygon?crs=EPSG:"+currentInputCRS, u"2G基础信息标签层", "memory")

        pr = vl.dataProvider()
        vlLabelPr = vlLabel.dataProvider()

        attrs = self.createAttributesTable(fileType)

        pr.addAttributes(attrs)
        vlLabelPr.addAttributes(attrs)
        vl.updateFields()
        vlLabel.updateFields()

        fet = QgsFeature()
        self.dlg.progressBar.setVisible(True)
        '''开始读取到内存'''
        list = [[] for row in range(nrows-1)]
        for i in range(nrows):
            if i > 0:
                try:
                    if fileType == '4G':
                        for j in range(21):
                             list[i - 1].append(table.cell(i, j).value)
                             if j == 20:
                                 list[i - 1].append(table.cell(i, 13).value % 3)
                    if fileType == '3G':
                        for j in range(73):
                             list[i - 1].append(table.cell(i, j).value)
                             if j == 72:
                                 list[i - 1].append(int(table.cell(i, 5).value) % 3)
                    if fileType =='2G':
                        for j in range(67):
                             list[i - 1].append(table.cell(i, j).value)
                             if j == 66:
                                 list[i - 1].append(int(table.cell(i, 2).value) % 3)
                except:
                    self.showErrorDialog(u'文档读取出错', u'文档可能存在错误或格式不符合规范')
                    self.dlg.progressBar.setVisible(False)
                    return
        '''完成读取到内存'''

        PCI_Types = {
            '0': ('#F49ECC', 'Mod3=0'),
            '1': ('#65F0FF', 'Mod3=1'),
            '2': ('#00FF00', 'Mod3=2'),
            '3': ('#000', u'未知值'),
        }
        categories = []
        for pci_type, (color, label) in PCI_Types.items():
            symbol = QgsSymbolV2.defaultSymbol(vl.geometryType())
            # symbol = QgsFillSymbolV2.createSimple({'color': color, 'color_border': color, 'width_border': '2'})
            symbol.setColor(QColor(color))
            # symbol.symbolLayer(0).setOutlineColor(QColor('#75263b'))
            category = QgsRendererCategoryV2(pci_type, symbol, label)
            categories.append(category)

        for i in range(len(list)):
            fetAttrs =[]
            if fileType == '4G':
                for j in range(22):
                    fetAttrs.append(list[i][j])
            elif fileType == '3G':
                for j in range(74):
                    fetAttrs.append(list[i][j])
            elif fileType == '2G':
                for j in range(68):
                    fetAttrs.append(list[i][j])
            fet.setAttributes(fetAttrs)
            if fileType == '4G':
                Longitude = 11
                Latitude = 12
                Azimuth = list[i][14]
            elif fileType == '3G':
                Longitude = 12
                Latitude = 13
                Azimuth = list[i][15]
            elif fileType == '2G':
                Longitude = 15
                Latitude = 16
                Azimuth = list[i][5]

            points = [QgsPoint(list[i][Longitude], list[i][Latitude])]  # start point
            startAngle = -20
            endAngle = 20
            while startAngle <= endAngle:
                # midway points
                points.append(QgsPoint(list[i][Longitude] + 0.001 * math.sin(math.radians(Azimuth + startAngle)),
                                       list[i][Latitude] + 0.001 * math.cos(math.radians(Azimuth + startAngle))))
                startAngle += 2
            points.append(QgsPoint(list[i][Longitude], list[i][Latitude]))  # end point

            # create the renderer and assign it to a layer
            expression = 'Mod3'  # field name
            renderer = QgsCategorizedSymbolRendererV2(expression, categories)
            vl.setRendererV2(renderer)

            fet.setGeometry(QgsGeometry.fromPolygon([points]))
            pr.addFeatures([fet])

            # fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(Longitude, Latitude)))
            vlLabelPr.addFeatures([fet])

            vlLabel.setLayerTransparency(100)

            vl.updateExtents()
            vlLabel.updateExtents()
            vl.commitChanges()
            vlLabel.commitChanges()
            vl.updateFields()
            vlLabel.updateFields()
            if i % 200 == 0:
                print 'progress:', float(pr.featureCount()) / nrows * 100
                self.dlg.progressBar.setValue(float(pr.featureCount()) / nrows * 100.0)

            palyr = QgsPalLayerSettings()
            # palyr.readFromLayer(vl)
            palyr.enabled = True
            palyr.fieldName = 'CellName'
            if fileType =='2G':
                palyr.fieldName = 'CELL_NAME'
            palyr.placement = QgsPalLayerSettings.OverPoint
            # palyr.setDataDefinedProperty(QgsPalLayerSettings.Size,False,False,'','')
            palyr.writeToLayer(vlLabel)
            QgsMapLayerRegistry.instance().addMapLayer(vl)
            QgsMapLayerRegistry.instance().addMapLayer(vlLabel)
        print 'progress:', 100
        self.dlg.progressBar.setValue(0)
        self.dlg.progressBar.setVisible(False)
        self.iface.messageBar().clearWidgets()
        qgis.utils.iface.setActiveLayer(vl)
        self.saveEPSGChange()
        self.dlg.close()
    def ltefpsOKBtn(self):
        currentInputCRS = self.dlg.inputCRS.text().replace(" ", "")
        try:
            sourceLayer = QgsMapLayerRegistry.instance().mapLayersByName(u'4G基础信息图层')[0]
        except:
            self.showErrorDialog(u'未找到图层', u'请检查是否已加载“4G基础信息图层”')
            return
        try:
            inputFreq = int(self.ltefpsdlg.inputFreq.text())
            inputPCI = int(self.ltefpsdlg.inputPCI.text())
        except:
            self.showErrorDialog(u'错误的输入', u'请输入数字')
            return

        # 隐藏之前的同名图层
        try:
            sameLayers = QgsMapLayerRegistry.instance().mapLayersByName(u'4G图层频点PCI查找')
            for oneLayer in sameLayers:
                qgis.utils.iface.legendInterface().setLayerVisible(oneLayer, False)
        except:
            pass

        ltefpsLayer = QgsVectorLayer("Polygon?crs=EPSG:"+currentInputCRS, u"4G图层频点PCI查找", "memory")
        ltefpsPr = ltefpsLayer.dataProvider()
        ltefpsPr.addAttributes(self.createAttributesTable('4GFreqPCISearch'))
        ltefpsLayer.updateFields()
        qgis.utils.iface.legendInterface().setLayerVisible(sourceLayer, False)
        ltefpsFet = QgsFeature()

        PCI_Types = {
            1: ('#FFFF00', u'频点='+str(inputFreq)+',PCI='+str(inputPCI)),
            0: ('#EEEEEE', u'无关频点PCI')
        }
        categories = []
        for pci_type, (color, label) in PCI_Types.items():
            symbol = QgsSymbolV2.defaultSymbol(ltefpsLayer.geometryType())
            symbol.setColor(QColor(color))
            category = QgsRendererCategoryV2(pci_type, symbol, label)
            categories.append(category)
            # 创建属性表
            fetAttrs = []
            relatedAttrs = []
            Longitude, Latitude, Azimuth = 11, 12, 14
            for feature in sourceLayer.getFeatures():
                attrs = feature.attributes()
                if (inputFreq == attrs[9]) & (inputPCI == int(attrs[13])):
                    temp = []
                    for j in range(21):
                        temp.append(attrs[j])
                    temp.append(1)
                    relatedAttrs.append(temp)
                else:
                    temp = []
                    for j in range(21):
                        temp.append(attrs[j])
                    temp.append(0)
                    fetAttrs.append(temp)
            for one in relatedAttrs:
                fetAttrs.append(one)
            for fetAttr in fetAttrs:
                ltefpsFet.setAttributes(fetAttr)
                # 开始画图
                points = [QgsPoint(fetAttr[Longitude], fetAttr[Latitude])]  # start point
                startAngle = -20
                endAngle = 20
                while startAngle <= endAngle:
                    points.append(
                        QgsPoint(fetAttr[Longitude] + 0.001 * math.sin(math.radians(fetAttr[Azimuth] + startAngle)),
                                 fetAttr[Latitude] + 0.001 * math.cos(math.radians(fetAttr[Azimuth] + startAngle))))
                    startAngle += 2
                points.append(QgsPoint(fetAttr[Longitude], fetAttr[Latitude]))  # end point
                ltefpsFet.setGeometry(QgsGeometry.fromPolygon([points]))
                ltefpsPr.addFeatures([ltefpsFet])
                # 根据字段值渲染颜色
                expression = 'FreqPCI'  # field name
                renderer = QgsCategorizedSymbolRendererV2(expression, categories)
                ltefpsLayer.setRendererV2(renderer)

                ltefpsLayer.updateExtents()
                ltefpsLayer.commitChanges()
                ltefpsLayer.updateFields()
                # 更新图层
                QgsMapLayerRegistry.instance().addMapLayer(ltefpsLayer)
        self.ltefpsdlg.close()
        self.saveEPSGChange()
        self.dlg.close()
    def gsmfsOKBtn(self):

        currentInputCRS = self.dlg.inputCRS.text().replace(" ", "")

        inputFreq = self.gsmfsdlg.inputFreq.text()
        try:
            sourceLayer = QgsMapLayerRegistry.instance().mapLayersByName(u'2G基础信息图层')[0]
        except:
            self.showErrorDialog(u'未找到图层', u'请检查是否已加载“2G基础信息图层”')
            return

        # 隐藏之前的同名图层
        try:
            sameLayer = QgsMapLayerRegistry.instance().mapLayersByName(u'2G图层频点查找')
            for oneLayer in sameLayer:
                qgis.utils.iface.legendInterface().setLayerVisible(oneLayer, False)
        except:
            pass
        gsmfsLayer = QgsVectorLayer("Polygon?crs=EPSG:"+currentInputCRS, u"2G图层频点查找", "memory")
        gsmfsPr = gsmfsLayer.dataProvider()
        gsmfsPr.addAttributes(self.createAttributesTable('2GFreqSearch'))
        gsmfsLayer.updateFields()

        # QgsMapLayerRegistry.instance().addMapLayer(gsmfsLayer)
        qgis.utils.iface.legendInterface().setLayerVisible(sourceLayer, False)
        gsmfsFet = QgsFeature()
        try:
            inputFreq.replace(" ", "")
            B = int(inputFreq)
        except:
            self.showErrorDialog(u'错误的输入', u'请输入数字')
            return
        A = B - 1
        C = B + 1
        PCI_Types = {
            A: ('#FF63F2', u'频点='+ str(A)),
            B: ('#FFFF00', u'指定频点='+ str(B)),
            C: ('#01FF8D', u'频点='+ str(C)),
            '-1': ('#eeeeee', u'无关频点')
        }
        categories = []
        for pci_type, (color, label) in PCI_Types.items():
            symbol = QgsSymbolV2.defaultSymbol(gsmfsLayer.geometryType())
            symbol.setColor(QColor(color))
            category = QgsRendererCategoryV2(pci_type, symbol, label)
            categories.append(category)

        # 创建属性表
        fetAttrs = []
        relatedAttrs = []
        Longitude, Latitude, Azimuth = 15, 16, 5
        for feature in sourceLayer.getFeatures():
            attrs = feature.attributes()
            if (int(inputFreq) == attrs[3]):
                temp = []
                for j in range(67):
                    temp.append(attrs[j])
                temp.append(B)
                relatedAttrs.append(temp)
            elif int(inputFreq) == int(attrs[3]) - 1:
                temp = []
                for j in range(67):
                    temp.append(attrs[j])
                temp.append(A)
                relatedAttrs.append(temp)
            elif int(inputFreq) == int(attrs[3]) + 1:
                temp = []
                for j in range(67):
                    temp.append(attrs[j])
                temp.append(C)
                relatedAttrs.append(temp)
            else:
                temp = []
                for j in range(67):
                    temp.append(attrs[j])
                    if j == 66:
                        if (int(inputFreq) != attrs[3]) & (int(inputFreq) != int(attrs[3])-1) & (int(inputFreq) != int(attrs[3])+1):
                            temp.append('-1')
                fetAttrs.append(temp)
        for one in relatedAttrs:
            fetAttrs.append(one)
        for fetAttr in fetAttrs:
            gsmfsFet.setAttributes(fetAttr)
            #开始画图
            points = [QgsPoint(fetAttr[Longitude], fetAttr[Latitude])]  # start point
            startAngle = -20
            endAngle = 20
            while startAngle <= endAngle:
                points.append(QgsPoint(fetAttr[Longitude] + 0.001 * math.sin(math.radians(fetAttr[Azimuth] + startAngle)),
                                       fetAttr[Latitude] + 0.001 * math.cos(math.radians(fetAttr[Azimuth] + startAngle))))
                startAngle += 2
            points.append(QgsPoint(fetAttr[Longitude], fetAttr[Latitude]))  # end point
            gsmfsFet.setGeometry(QgsGeometry.fromPolygon([points]))
            gsmfsPr.addFeatures([gsmfsFet])
            #根据字段值渲染颜色
            expression = 'Condition'  # field name
            renderer = QgsCategorizedSymbolRendererV2(expression, categories)
            gsmfsLayer.setRendererV2(renderer)

            gsmfsLayer.updateExtents()
            gsmfsLayer.commitChanges()
            gsmfsLayer.updateFields()
            QgsMapLayerRegistry.instance().addMapLayer(gsmfsLayer)
        self.gsmfsdlg.close()
        self.saveEPSGChange()
        self.dlg.close()