Example #1
0
 def canvasReleaseEvent(self,event):
     if self.rb2 <> None:
         ## Reset the rubberband.
         self.rb2.reset()
         self.rb2 = None
         
         ## What happens to newPoint???? Even as self.newPoint it 
         ## does not work....
         ## We just snap again....
         x = event.pos().x()
         y = event.pos().y()
         startingPoint = QPoint(x,y)            
         snapper = QgsMapCanvasSnapper(self.canvas)
         (retval,result) = snapper.snapToCurrentLayer (startingPoint,QgsSnapper.SnapToVertex)   
         if result <> []:
             newPoint = result[0].snappedVertex
         else:
             (retval,result) = snapper.snapToBackgroundLayers(startingPoint)
             if result <> []:
                 newPoint = result[0].snappedVertex
             else:
                 newPoint = self.toLayerCoordinates( self.layer, event.pos() )
     
         ## Modify the feature.
         settings = QSettings("CatAIS","cadtools")
         method = settings.value("arcs/featuremethod",  "pitch")
         if method == "pitch":
             value = settings.value("arcs/featurepitch",  2, type=float)
         else:
             value = settings.value("arcs/featureangle",  1, type=float)
         if self.movingVertex == "arc":
             g = CircularArc.getInterpolatedArc(self.ptStart,  newPoint,  self.ptEnd,  method,   value)
         elif self.movingVertex == "start":
             g = CircularArc.getInterpolatedArc(newPoint,  self.ptArc,  self.ptEnd,  method, value)
         elif self.movingVertex == "end":
             g = CircularArc.getInterpolatedArc(self.ptStart,  self.ptArc,  newPoint,  method, value)
             
         ## On the Fly reprojection of the geometry (only if needed)
         layerEPSG = cadutils.authidToCrs(self.layer.crs().authid())
         projectEPSG = cadutils.authidToCrs(self.canvas.mapRenderer().destinationCrs().authid())
         if layerEPSG != projectEPSG:
             layerCrs = self.layer.crs()
             projectCrs = self.canvas.mapRenderer().destinationCrs()
             coordtrans = QgsCoordinateTransform(layerCrs,  projectCrs)
             g.transform(coordtrans)
     
         self.layer.beginEditCommand("Geometry modified.")
         self.layer.changeGeometry(self.featId,  g)
         self.layer.endEditCommand()
         self.layer.reload()
         self.canvas.refresh()
         
     ## Reset some stuff.
     self.clicked = False
     self.featId = None
     
     pass
Example #2
0
    def createFeature(self):
        layer = self.canvas.currentLayer()
        provider = layer.dataProvider()
        fields = layer.pendingFields()
        f = QgsFeature(fields)

        coords = []
        [
            coords.append(self.rb.getPoint(0, i))
            for i in range(self.rb.numberOfVertices())
        ]

        ## On the Fly reprojection.
        layerEPSG = cadutils.authidToCrs(layer.crs().authid())
        projectEPSG = cadutils.authidToCrs(
            self.canvas.mapRenderer().destinationCrs().authid())

        if layerEPSG != projectEPSG:
            coords_tmp = coords[:]
            coords = []
            for point in coords_tmp:
                transformedPoint = self.canvas.mapRenderer(
                ).mapToLayerCoordinates(layer, point)
                coords.append(transformedPoint)

        ## Add geometry to feature.
        if self.isPolygon == True:
            g = QgsGeometry().fromPolygon([coords])
        else:
            g = QgsGeometry().fromPolyline(coords)
        f.setGeometry(g)

        ## Add attributefields to feature.
        for field in fields.toList():
            ix = fields.indexFromName(field.name())
            f[field.name()] = provider.defaultValue(ix)

        layer.beginEditCommand("Feature added")
        layer.addFeature(f)
        layer.endEditCommand()

        # reset rubberband and refresh the canvas
        if self.type == 1:
            self.isPolygon = False
            self.rb.reset()
        else:
            self.isPolygon = True
            self.rb.reset(QGis.Polygon)

        self.canvas.refresh()
Example #3
0
    def createFeature(self):
        layer = self.canvas.currentLayer() 
        provider = layer.dataProvider()
        fields = layer.pendingFields()
        f = QgsFeature(fields)
            
        coords = []
        coords = self.interpolate ( self.points )
        
        ## On the Fly reprojection.
        layerEPSG = cadutils.authidToCrs(layer.crs().authid())
        projectEPSG = cadutils.authidToCrs(self.canvas.mapRenderer().destinationCrs().authid())
        
        if layerEPSG != projectEPSG:
            coords_tmp = coords[:]
            coords = []
            for point in coords_tmp:
                transformedPoint = self.canvas.mapRenderer().mapToLayerCoordinates( layer, point )
                coords.append(transformedPoint)
              
        ## Add geometry to feature.
        if self.isPolygon == True:
            g = QgsGeometry().fromPolygon([coords])
        else:
            g = QgsGeometry().fromPolyline(coords)
        f.setGeometry(g)
            
        ## Add attributefields to feature.
        for field in fields.toList():
            ix = fields.indexFromName(field.name())
            f[field.name()] = provider.defaultValue(ix)

        layer.beginEditCommand("Feature added")
        
        settings = QSettings()
        disable_attributes = settings.value( "/qgis/digitizing/disable_enter_attribute_values_dialog", False, type=bool)
        if disable_attributes:
            layer.addFeature(f)
            layer.endEditCommand()
        else:
            dlg = self.iface.getFeatureForm(layer, f)
            if dlg.exec_():
                layer.addFeature(f)
                layer.endEditCommand()
            else:
                layer.destroyEditCommand()
    def createFeature(self):
        layer = self.canvas.currentLayer() 
        provider = layer.dataProvider()
        fields = layer.pendingFields()
        f = QgsFeature(fields)
            
        coords = []
        [coords.append(self.rb.getPoint(0, i)) for i in range(self.rb.numberOfVertices())]
        
        ## On the Fly reprojection.
        layerEPSG = cadutils.authidToCrs(layer.crs().authid())
        projectEPSG = cadutils.authidToCrs(self.canvas.mapRenderer().destinationCrs().authid())
        
        if layerEPSG != projectEPSG:
            coords_tmp = coords[:]
            coords = []
            for point in coords_tmp:
                transformedPoint = self.canvas.mapRenderer().mapToLayerCoordinates( layer, point )
                coords.append(transformedPoint)
              
        ## Add geometry to feature.
        if self.isPolygon == True:
            g = QgsGeometry().fromPolygon([coords])
        else:
            g = QgsGeometry().fromPolyline(coords)
        f.setGeometry(g)
            
        ## Add attributefields to feature.
        for field in fields.toList():
            ix = fields.indexFromName(field.name())
            f[field.name()] = provider.defaultValue(ix)

        layer.beginEditCommand("Feature added")
        layer.addFeature(f)
        layer.endEditCommand()
            
        # reset rubberband and refresh the canvas
        if self.type == 1:
            self.isPolygon = False
            self.rb.reset()
        else:
            self.isPolygon = True
            self.rb.reset(QGis.Polygon)

        self.canvas.refresh()
Example #5
0
    def canvasReleaseEvent(self, event):
        if self.rb2 <> None:
            ## Reset the rubberband.
            self.rb2.reset()
            self.rb2 = None

            ## What happens to newPoint???? Even as self.newPoint it
            ## does not work....
            ## We just snap again....
            x = event.pos().x()
            y = event.pos().y()
            startingPoint = QPoint(x, y)
            snapper = QgsMapCanvasSnapper(self.canvas)
            (retval,
             result) = snapper.snapToCurrentLayer(startingPoint,
                                                  QgsSnapper.SnapToVertex)
            if result <> []:
                newPoint = result[0].snappedVertex
            else:
                (retval,
                 result) = snapper.snapToBackgroundLayers(startingPoint)
                if result <> []:
                    newPoint = result[0].snappedVertex
                else:
                    newPoint = self.toLayerCoordinates(self.layer, event.pos())

            ## Modify the feature.
            settings = QSettings("CatAIS", "cadtools")
            method = settings.value("arcs/featuremethod", "pitch")
            if method == "pitch":
                value = settings.value("arcs/featurepitch", 2, type=float)
            else:
                value = settings.value("arcs/featureangle", 1, type=float)
            if self.movingVertex == "arc":
                g = CircularArc.getInterpolatedArc(self.ptStart, newPoint,
                                                   self.ptEnd, method, value)
            elif self.movingVertex == "start":
                g = CircularArc.getInterpolatedArc(newPoint, self.ptArc,
                                                   self.ptEnd, method, value)
            elif self.movingVertex == "end":
                g = CircularArc.getInterpolatedArc(self.ptStart, self.ptArc,
                                                   newPoint, method, value)

            ## On the Fly reprojection of the geometry (only if needed)
            layerEPSG = cadutils.authidToCrs(self.layer.crs().authid())
            projectEPSG = cadutils.authidToCrs(
                self.canvas.mapRenderer().destinationCrs().authid())
            if layerEPSG != projectEPSG:
                layerCrs = self.layer.crs()
                projectCrs = self.canvas.mapRenderer().destinationCrs()
                coordtrans = QgsCoordinateTransform(layerCrs, projectCrs)
                g.transform(coordtrans)

            self.layer.beginEditCommand("Geometry modified.")
            self.layer.changeGeometry(self.featId, g)
            self.layer.endEditCommand()
            self.layer.reload()
            self.canvas.refresh()

        ## Reset some stuff.
        self.clicked = False
        self.featId = None

        pass
Example #6
0
    def createFeature(self):

        layer = self.canvas.currentLayer()
        provider = layer.dataProvider()
        fields = layer.pendingFields()
        f = QgsFeature(fields)

        if self.isPolygon and self.mCtrl and self.rb.numberOfVertices() > 3:
            # we will move the first point to close the polygon square... (square??)
            # NO: move the last point!

            # the last segment
            #            pn = self.rb.getPoint(0,  self.rb.numberOfVertices()-2)
            #            pm = self.rb.getPoint(0,  self.rb.numberOfVertices()-1)
            pn = self.rb.getPoint(0, self.rb.numberOfVertices() - 2)
            pm = self.rb.getPoint(0, self.rb.numberOfVertices() - 1)

            p1 = self.rb.getPoint(0, 0)
            p2 = self.rb.getPoint(0, 1)

            # but we need a line segment that is orthogonal to the last segment
            # der letzte Punkt ist der Aufpunkt
            # der Richtungsvektor ist der Vektor, der rechwinklig zum Differenzvektor pn-pm liegt (-> x/y vertauschen)
            d = ((pn.x() - pm.x())**2 + (pn.y() - pm.y())**2)**0.5
            xp = p1.x() + (p1.y() - p2.y())
            yp = p1.y() - (p1.x() - p2.x())
            pp = QgsPoint(xp, yp)

            p0 = LineIntersection.intersectionPoint(pn, pm, p1, pp)
            self.rb.movePoint(self.rb.numberOfVertices() - 1, p0, 0)

        coords = []
        [
            coords.append(self.rb.getPoint(0, i))
            for i in range(self.rb.numberOfVertices())
        ]

        ## On the Fly reprojection.
        layerEPSG = cadutils.authidToCrs(layer.crs().authid())
        projectEPSG = cadutils.authidToCrs(
            self.canvas.mapRenderer().destinationCrs().authid())

        if layerEPSG != projectEPSG:
            coords_tmp = coords[:]
            coords = []
            for point in coords_tmp:
                transformedPoint = self.canvas.mapRenderer(
                ).mapToLayerCoordinates(layer, point)
                coords.append(transformedPoint)

        ## Add geometry to feature.
        if self.isPolygon == True:
            g = QgsGeometry().fromPolygon([coords])
        else:
            g = QgsGeometry().fromPolyline(coords)
        f.setGeometry(g)

        ## Add attributefields to feature.
        for field in fields.toList():
            ix = fields.indexFromName(field.name())
            f[field.name()] = provider.defaultValue(ix)

        layer.beginEditCommand("Feature added")
        layer.addFeature(f)
        layer.endEditCommand()

        # reset rubberband and refresh the canvas
        if self.type == 1:
            self.isPolygon = False
            self.rb.reset()
        else:
            self.isPolygon = True
            self.rb.reset(QGis.Polygon)

        self.canvas.refresh()
Example #7
0
  def createFeature(self):
     
    layer = self.canvas.currentLayer() 
    provider = layer.dataProvider()
    fields = layer.pendingFields()
    f = QgsFeature(fields)

    if self.isPolygon and self.mCtrl and self.rb.numberOfVertices() > 3:
        # we will move the first point to close the polygon square... (square??)
        # NO: move the last point!

        # the last segment
#            pn = self.rb.getPoint(0,  self.rb.numberOfVertices()-2)
#            pm = self.rb.getPoint(0,  self.rb.numberOfVertices()-1)
        pn = self.rb.getPoint(0,  self.rb.numberOfVertices()-2)
        pm = self.rb.getPoint(0,  self.rb.numberOfVertices()-1)

        p1 = self.rb.getPoint(0, 0)
        p2 = self.rb.getPoint(0, 1)

        # but we need a line segment that is orthogonal to the last segment
        # der letzte Punkt ist der Aufpunkt
        # der Richtungsvektor ist der Vektor, der rechwinklig zum Differenzvektor pn-pm liegt (-> x/y vertauschen)
        d = ( (pn.x()-pm.x())**2 + (pn.y()-pm.y())**2 )**0.5
        xp = p1.x() + (p1.y()-p2.y())
        yp = p1.y() - (p1.x()-p2.x())
        pp = QgsPoint(xp,  yp)

        p0 = LineIntersection.intersectionPoint(pn, pm, p1, pp)
        self.rb.movePoint(self.rb.numberOfVertices()-1, p0, 0)
        
    coords = []
    [coords.append(self.rb.getPoint(0, i)) for i in range(self.rb.numberOfVertices())]
    
    ## On the Fly reprojection.
    layerEPSG = cadutils.authidToCrs(layer.crs().authid())
    projectEPSG = cadutils.authidToCrs(self.canvas.mapRenderer().destinationCrs().authid())
    
    if layerEPSG != projectEPSG:
        coords_tmp = coords[:]
        coords = []
        for point in coords_tmp:
            transformedPoint = self.canvas.mapRenderer().mapToLayerCoordinates( layer, point )
            coords.append(transformedPoint)
          
    ## Add geometry to feature.
    if self.isPolygon == True:
        g = QgsGeometry().fromPolygon([coords])
    else:
        g = QgsGeometry().fromPolyline(coords)
    f.setGeometry(g)
        
    ## Add attributefields to feature.
    for field in fields.toList():
        ix = fields.indexFromName(field.name())
        f[field.name()] = provider.defaultValue(ix)

    layer.beginEditCommand("Feature added")
    layer.addFeature(f)
    layer.endEditCommand()
        
    # reset rubberband and refresh the canvas
    if self.type == 1:
        self.isPolygon = False
        self.rb.reset()
    else:
        self.isPolygon = True
        self.rb.reset(QGis.Polygon)
        
    self.canvas.refresh()
Example #8
0
  def createFeature(self):
     
    layer = self.canvas.currentLayer() 
    provider = layer.dataProvider()
    fields = layer.pendingFields()
    f = QgsFeature(fields)

    # make polygon orthogonal if Ctrl is pressed *and* if it has at least 4 points
    if self.isPolygon and self.mCtrl and self.rb.numberOfVertices() > 3:
        # the last segment, actually clicked points
        pn = self.rb.getPoint(0,  self.rb.numberOfVertices()-2)
        pm = self.rb.getPoint(0,  self.rb.numberOfVertices()-1)

        p1 = self.rb.getPoint(0, 0)
        # p2 = self.rb.getPoint(0, 1)

        # but we need a line segment that is orthogonal to the last segment
        # der letzte Punkt ist der Aufpunkt
        # der Richtungsvektor ist der Vektor, der rechwinklig zum Differenzvektor pn-pm liegt (-> x/y vertauschen)
        # d = ( (pn.x()-pm.x())**2 + (pn.y()-pm.y())**2 )**0.5
        # xp = p1.x() + (p1.y()-p2.y())
        # yp = p1.y() - (p1.x()-p2.x())
        # pp = QgsPoint(xp,  yp)

        # p0 = LineIntersection.intersectionPoint(pn, pm, p1, pp)
#            self.rb.movePoint(self.rb.numberOfVertices()-1, p0, 0)

        # ODER:
        dx = math.fabs(pn.x() - pm.x())
        # Use a small value as tolerance in order to determine if the last segment is a vertical or horizontal one
        if dx < self.offset:
            self.rb.movePoint(self.rb.numberOfVertices()-1, QgsPoint(pm.x(), p1.y()), 0)
        else:
            self.rb.movePoint(self.rb.numberOfVertices()-1, QgsPoint(p1.x(), pm.y()), 0)
        
    coords = []
    [coords.append(self.rb.getPoint(0, i)) for i in range(self.rb.numberOfVertices())]
    
    ## On the Fly reprojection.
    layerEPSG = cadutils.authidToCrs(layer.crs().authid())
    projectEPSG = cadutils.authidToCrs(self.canvas.mapRenderer().destinationCrs().authid())
    
    if layerEPSG != projectEPSG:
        coords_tmp = coords[:]
        coords = []
        for point in coords_tmp:
            transformedPoint = self.canvas.mapRenderer().mapToLayerCoordinates(layer, point);
            coords.append(transformedPoint)
          
    # Add geometry to feature.
    if self.isPolygon == True:
        g = QgsGeometry().fromPolygon([coords])
    else:
        g = QgsGeometry().fromPolyline(coords)
        
    if g is None:
        pass
    else:
        f.setGeometry(g)
            
        # Add attributefields to feature.
        for field in fields.toList():
            ix = fields.indexFromName(field.name())
            f[field.name()] = provider.defaultValue(ix)



        layer.beginEditCommand("Feature added")
        layer.addFeature(f)
        layer.endEditCommand()
            
        # reset rubberband and refresh the canvas
        if self.type == 1:
            self.isPolygon = False
            self.rb.reset()
        else:
            self.isPolygon = True
            self.rb.reset(QGis.Polygon)
            
        self.canvas.refresh()