def testSubstitutionMap(self):
        """Test that we can use degree symbols in substitutions.
        """
        # Create a point and convert it to text containing a degree symbol.
        myPoint = QgsPoint(12.3, -33.33)
        myCoordinates = myPoint.toDegreesMinutesSeconds(2)
        myTokens = myCoordinates.split(',')
        myLongitude = myTokens[0]
        myLatitude = myTokens[1]
        myText = 'Latitude: %s, Longitude: %s' % (myLatitude, myLongitude)

        # Load the composition with the substitutions
        myComposition = QgsComposition(self.iface.mapCanvas().mapRenderer())
        mySubstitutionMap = {'replace-me': myText}
        myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
        myTemplateFile = file(myFile, 'rt')
        myTemplateContent = myTemplateFile.read()
        myTemplateFile.close()
        myDocument = QDomDocument()
        myDocument.setContent(myTemplateContent)
        myComposition.loadFromTemplate(myDocument, mySubstitutionMap)

        # We should be able to get map0
        myMap = myComposition.getComposerMapById(0)
        myMessage = ('Map 0 could not be found in template %s', myFile)
        assert myMap is not None, myMessage

 def __init__(self, p1, p2, p3=None):
     if p3 is None:
         p3 = QgsPoint(p2)
         p2 = self.createMiddlePoint(p1, p3)
     self.p1 = QgsPoint(p1)
     self.p2 = QgsPoint(p2)
     self.p3 = QgsPoint(p3)

    def _calc_north(self):
        extent = self.canvas.extent()
        if self.canvas.layerCount() == 0 or extent.isEmpty():
            print "No layers or extent"
            return 0

        outcrs = self.canvas.mapSettings().destinationCrs()

        if outcrs.isValid() and not outcrs.geographicFlag():
            crs = QgsCoordinateReferenceSystem()
            crs.createFromOgcWmsCrs("EPSG:4326")

            transform = QgsCoordinateTransform(outcrs, crs)

            p1 = QgsPoint(extent.center())
            p2 = QgsPoint(p1.x(), p1.y() + extent.height() * 0.25)

            try:
                pp1 = transform.transform(p1)
                pp2 = transform.transform(p2)
            except QgsCsException:
                roam.utils.warning("North arrow. Error transforming.")
                return None

            area = QgsDistanceArea()
            area.setEllipsoid(crs.ellipsoidAcronym())
            area.setEllipsoidalMode(True)
            area.setSourceCrs(crs)
            distance, angle, _ = area.computeDistanceBearing(pp1, pp2)
            angle = math.degrees(angle)
            return angle
        else:
            return 0

class TestQgsPoint(unittest.TestCase):

    def __init__(self, methodName):
        """Run once on class initialization."""
        unittest.TestCase.__init__(self, methodName)

    def setUp(self):
        self.mPoint = QgsPoint(10.0, 10.0)

    def test_Point(self):
        myExpectedValue = 10.0
        myActualValue = self.mPoint.x()
        myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myActualValue)
        assert myExpectedValue == myActualValue, myMessage

    def test_pointToString(self):
        myExpectedValue = '10, 10'
        myActualValue = self.mPoint.toString()
        myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myActualValue)
        assert myExpectedValue == myActualValue, myMessage

    def test_hash(self):
        a = QgsPoint(2.0, 1.0)
        b = QgsPoint(2.0, 2.0)
        c = QgsPoint(1.0, 2.0)
        d = QgsPoint(1.0, 1.0)
        e = QgsPoint(2.0, 1.0)
        assert a.__hash__() != b.__hash__()
        assert e.__hash__() == a.__hash__()

        mySet = set([a, b, c, d, e])
        assert len(mySet) == 4

 def canvasMoveEvent(self, event):
     if self.snapCursorRubberBand:
         self.snapCursorRubberBand.hide()
         self.snapCursorRubberBand.reset(geometryType=QGis.Point)
         self.snapCursorRubberBand = None
     oldPoint = QgsPoint(event.mapPoint())
     event.snapPoint(QgsMapMouseEvent.SnapProjectConfig)
     point = QgsPoint(event.mapPoint())
     if oldPoint != point:
         self.createSnapCursor(point)
     point = QgsPoint(event.mapPoint())   
     if self.qntPoint == 1:
         self.distanceToolTip.canvasMoveEvent(self.geometry[0], point)
         geom = QgsGeometry.fromPolyline([self.geometry[0], point])
         self.rubberBand.setToGeometry(geom, None)
     elif self.qntPoint >= 2:
         self.distanceToolTip.canvasMoveEvent(self.geometry[-1], point)
         if self.free:
             geom = QgsGeometry.fromPolygon([self.geometry+[QgsPoint(point.x(), point.y())]])
             self.rubberBand.setToGeometry(geom, None)             
         else:       
             if (self.qntPoint % 2 == 1): 
                 self.setAvoidStyleSnapRubberBand()
             else:
                 self.setAllowedStyleSnapRubberBand()
             projectedMousePoint = self.projectPoint(self.geometry[-2], self.geometry[-1], point)
             if projectedMousePoint:
                 geom, pf = self.completePolygon(self.geometry, projectedMousePoint)
                 self.rubberBand.setToGeometry(geom, None)

    def draw_position(self,Latitud,Longitud,v_layer,option):

        #create the provider and add the layer
        pr = v_layer.dataProvider()
        QgsMapLayerRegistry.instance().addMapLayers([v_layer])
        seg = QgsFeature()

        #create the point and paint it
        try:
            point_A = QgsPoint((float(Longitud)-181-6.339908),(float(Latitud)-91+39.478360))
            seg.setGeometry(QgsGeometry.fromPoint(point_A))
            pr.addFeatures( [ seg ] )
            v_layer.updateExtents()
            v_layer.triggerRepaint()
            label=None
            if option==1:
                label=self.dlg.label_6
            elif option==2:
                label=self.dlg.label_7
            elif option==3:
                label=self.dlg.label_8
            if  self.pointInLimits(point_A.x(),point_A.y())==True:
                label.setText("IN")
                self.distances(point_A.x(),point_A.y(),option)

            else:
                label.setText("OUT")

            self.deletePoints(v_layer)
        except:
                pass

    def calculateSquare(self, point):
        '''
        point in layer coordinates(QgsPoint)
        '''
        mapCrs = self.canvas.mapSettings().destinationCrs()
        utmCrs = QgsCoordinateReferenceSystem()
        utmCrs.createFromProj4(self.proj4Utm(point))
        ctFwd = QgsCoordinateTransform(mapCrs, utmCrs)
        ctBwd = QgsCoordinateTransform(utmCrs, mapCrs)

        pointGeom = QgsGeometry.fromPoint(point)
        pointGeom.transform(ctFwd)
        pointUtm = QgsPoint(pointGeom.asPoint())

        # calculate d
        d = self.diagonal/(2*(2**0.5))

        l = pointUtm.x() - d
        b = pointUtm.y() - d
        r = pointUtm.x() + d
        t = pointUtm.y() + d

        p1 = QgsGeometry.fromPoint(QgsPoint(l, b))
        p2 = QgsGeometry.fromPoint(QgsPoint(r, b))
        p3 = QgsGeometry.fromPoint(QgsPoint(r, t))
        p4 = QgsGeometry.fromPoint(QgsPoint(l, t))

        p1.transform(ctBwd)
        p2.transform(ctBwd)
        p3.transform(ctBwd)
        p4.transform(ctBwd)

        mapPol = [p1.asPoint(), p2.asPoint(), p3.asPoint(), p4.asPoint(), p1.asPoint()]

        return mapPol

 def normalizePoint(self, x, y):
   """Normalize given point. In result, lower-left is (0, 0) and upper-right is (1, 1)."""
   pt = QgsPoint(x, y)
   if self._rotation:
     pt = self.rotatePoint(pt, -self._rotation, self._center)
   rect = self._unrotated_rect
   return QgsPoint((pt.x() - rect.xMinimum()) / rect.width(),
                   (pt.y() - rect.yMinimum()) / rect.height())

    def processAlgorithm(self, parameters, context, feedback):
        source = self.parameterAsSource(parameters, self.INPUT, context)

        fields = source.fields()
        x_field_index = fields.lookupField(self.parameterAsString(parameters, self.XFIELD, context))
        y_field_index = fields.lookupField(self.parameterAsString(parameters, self.YFIELD, context))
        z_field_index = -1
        if self.parameterAsString(parameters, self.ZFIELD, context):
            z_field_index = fields.lookupField(self.parameterAsString(parameters, self.ZFIELD, context))
        m_field_index = -1
        if self.parameterAsString(parameters, self.MFIELD, context):
            m_field_index = fields.lookupField(self.parameterAsString(parameters, self.MFIELD, context))

        wkb_type = QgsWkbTypes.Point
        if z_field_index >= 0:
            wkb_type = QgsWkbTypes.addZ(wkb_type)
        if m_field_index >= 0:
            wkb_type = QgsWkbTypes.addM(wkb_type)

        target_crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)

        (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
                                               fields, wkb_type, target_crs)

        request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
        features = source.getFeatures()
        total = 100.0 / source.featureCount() if source.featureCount() else 0

        for current, feature in enumerate(features):
            if feedback.isCanceled():
                break

            feedback.setProgress(int(current * total))
            attrs = feature.attributes()

            try:
                x = float(attrs[x_field_index])
                y = float(attrs[y_field_index])

                point = QgsPoint(x, y)

                if z_field_index >= 0:
                    try:
                        point.addZValue(float(attrs[z_field_index]))
                    except:
                        point.addZValue(0.0)

                if m_field_index >= 0:
                    try:
                        point.addMValue(float(attrs[m_field_index]))
                    except:
                        point.addMValue(0.0)

                feature.setGeometry(QgsGeometry(point))
            except:
                pass  # no geometry

            sink.addFeature(feature)

        return {self.OUTPUT: dest_id}

class Observation():
    def __init__(self, iface, obsType, point, observation, precision):
        memoryLayers = MemoryLayers(iface)
        self.lineLayer = memoryLayers.line_layer()
        self.pointLayer = memoryLayers.point_layer()

        # generate ID;
        self.id = datetime.now().strftime("%Y%m%d%H%M%S%f")

        # obsservations are stored in the lineLayer layer attributes:
        #   0: id
        #   1: observation type
        #   2: x
        #   3: y
        #   4: observation
        #   5: precision

        self.obsType = obsType
        self.point = QgsPoint(point)
        self.observation = observation
        self.precision = precision

    def geometry(self):
        return QgsGeometry()

    def save(self):
        # observation
        f = QgsFeature()
        fields = self.lineLayer.dataProvider().fields()
        f.setFields(fields)
        f["id"] = self.id
        f["type"] = self.obsType
        f["x"] = self.point.x()
        f["y"] = self.point.y()
        f["observation"] = self.observation
        f["precision"] = self.precision
        f.setGeometry(self.geometry())
        ok, l = self.lineLayer.dataProvider().addFeatures([f])
        self.lineLayer.updateExtents()
        self.lineLayer.setCacheImage(None)
        self.lineLayer.triggerRepaint()
        self.lineLayer.featureAdded.emit(l[0].id())  # emit signal so feature is added to snapping index

        # center
        f = QgsFeature()
        fields = self.pointLayer.dataProvider().fields()
        f.setFields(fields)
        f["id"] = self.id
        f.setGeometry(QgsGeometry().fromPoint(self.point))
        ok, l = self.pointLayer.dataProvider().addFeatures([f])
        self.pointLayer.updateExtents()
        self.pointLayer.setCacheImage(None)
        self.pointLayer.triggerRepaint()
        self.pointLayer.featureAdded.emit(l[0].id())  # emit signal so feature is added to snapping index

    def processAlgorithm(self, parameters, context, feedback):
        source = self.getParameterValue(self.INPUT)
        vlayer = QgsProcessingUtils.mapLayerFromString(source, context)
        output = self.getOutputFromName(self.OUTPUT)

        fields = vlayer.fields()
        x_field_index = fields.lookupField(self.getParameterValue(self.XFIELD))
        y_field_index = fields.lookupField(self.getParameterValue(self.YFIELD))
        z_field_index = None
        if self.getParameterValue(self.ZFIELD):
            z_field_index = fields.lookupField(self.getParameterValue(self.ZFIELD))
        m_field_index = None
        if self.getParameterValue(self.MFIELD):
            m_field_index = fields.lookupField(self.getParameterValue(self.MFIELD))

        wkb_type = QgsWkbTypes.Point
        if z_field_index is not None:
            wkb_type = QgsWkbTypes.addZ(wkb_type)
        if m_field_index is not None:
            wkb_type = QgsWkbTypes.addM(wkb_type)

        crsId = self.getParameterValue(self.TARGET_CRS)
        target_crs = QgsCoordinateReferenceSystem()
        target_crs.createFromUserInput(crsId)

        writer = output.getVectorWriter(fields, wkb_type, target_crs, context)

        features = QgsProcessingUtils.getFeatures(vlayer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(vlayer, context)

        for current, feature in enumerate(features):
            feedback.setProgress(int(current * total))
            attrs = feature.attributes()

            try:
                x = float(attrs[x_field_index])
                y = float(attrs[y_field_index])

                point = QgsPoint(x, y)

                if z_field_index is not None:
                    try:
                        point.addZValue(float(attrs[z_field_index]))
                    except:
                        point.addZValue(0.0)

                if m_field_index is not None:
                    try:
                        point.addMValue(float(attrs[m_field_index]))
                    except:
                        point.addMValue(0.0)

                feature.setGeometry(QgsGeometry(point))
            except:
                pass  # no geometry

            writer.addFeature(feature)

        del writer

 def event_dict(self):
     tz = pytz.timezone("Asia/Jakarta")
     timestamp = self.time.astimezone(tz=tz)
     time_format = "%-d-%b-%Y %H:%M:%S"
     timestamp_string = timestamp.strftime(time_format)
     point = QgsPoint(self.longitude, self.latitude)
     coordinates = point.toDegreesMinutesSeconds(2)
     tokens = coordinates.split(",")
     longitude_string = tokens[0]
     latitude_string = tokens[1]
     elapsed_time = datetime.datetime.utcnow().replace(tzinfo=pytz.utc) - self.time
     elapsed_hour = elapsed_time.seconds / 3600
     elapsed_minute = (elapsed_time.seconds / 60) % 60
     event = {
         "report-title": self.tr("Volcanic Ash Impact"),
         "report-timestamp": self.tr("Volcano: %s, Alert Level: %s %s")
         % (self.volcano_name, self.alert_level, timestamp_string),
         "report-province": self.tr("Province: %s") % (self.region,),
         "report-location": self.tr("Longitude %s Latitude %s;" " Eruption Column Height (a.s.l) - %d m")
         % (longitude_string, latitude_string, self.erupction_height),
         "report-elapsed": self.tr("Elapsed time since event %s hour(s) and %s minute(s)")
         % (elapsed_hour, elapsed_minute),
         "header-impact-table": self.tr("Potential impact at each fallout level"),
         "header-nearby-table": self.tr("Nearby places"),
         "header-landcover-table": self.tr("Land Cover Impact"),
         "content-disclaimer": self.tr(
             "The impact estimation is automatically generated and only "
             "takes into account the population, cities and land cover "
             "affected by different levels of volcanic ash fallout at "
             "surface level. The estimate is based on volcanic ash "
             "fallout data from Badan Geologi, population count data "
             "derived by DMInnovation from worldpop.org.uk, place "
             "information from geonames.org, land cover classification "
             "data provided by Indonesian Geospatial Portal at "
             "http://portal.ina-sdi.or.id and software developed by BNPB. "
             "Limitation in the estimates of surface fallout, population "
             "and place names datasets may result in significant "
             "misrepresentation of the on-the-surface situation in the "
             "figures shown here. Consequently decisions should not be "
             "made soley on the information presented here and should "
             "always be verified by ground truthing and other reliable "
             "information sources."
         ),
         "content-notes": self.tr(
             "This report was created using InaSAFE version %s. Visit " "http://inasafe.org for more information. "
         )
         % get_version(),
     }
     return event

    def cntr2bugs(self):
        mLayer = self.checklayer()
        if mLayer is not None:
            QApplication.setOverrideCursor(Qt.WaitCursor)

            dlg = editor.Dialog()
            dlg.setModal(True)
            dlg.setWindowTitle("Centroids in BUGS format")

            provider = mLayer.dataProvider()
            e = provider.featureCount()

            ids = []
            x = "x = c("
            y = "y = c("

            feats = provider.getFeatures()
            dlg.emit(SIGNAL("runStatus(PyQt_PyObject)"), 0)
            dlg.emit(SIGNAL("runRange(PyQt_PyObject)"), (0, e))
            ne = 0
            feat = QgsFeature()
            while feats.nextFeature(feat):
                ne += 1
                dlg.emit(SIGNAL("runStatus(PyQt_PyObject)"), ne)
                ids.append(feat.id())

            mod = min(ids)

            for ne in range(mod, e + mod):
                feat = QgsFeature()
                pt = QgsPoint()
                fiter = mLayer.getFeatures(QgsFeatureRequest(ne))
                if fiter.nextFeature(feat):
                    pt = QgsGeometry(feat.geometry().centroid()).asPoint()
                    # pt = QgsGeometry(geom.centroid()).asPoint()

                x += '%s, ' % pt.x()
                y += '%s, ' % pt.y()

            dlg.plainTextEdit.appendPlainText(x[:-2]+')')
            dlg.plainTextEdit.appendPlainText(y[:-2]+')')

            QApplication.restoreOverrideCursor()

            dlg.exec_()

class TestQgsPoint(TestCase):

    def __init__(self, methodName):
        """Run once on class initialisation."""
        unittest.TestCase.__init__(self, methodName)


    def setUp(self):
        self.mPoint = QgsPoint(10.0, 10.0)

    def test_Point(self):
        myExpectedValue = 10.0
        myActualValue = self.mPoint.x()
        myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myActualValue)
        assert myExpectedValue == myActualValue, myMessage


    def test_pointToString(self):
        myExpectedValue = '10, 10'
        myActualValue = self.mPoint.toString()
        myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myActualValue)
        assert myExpectedValue == myActualValue, myMessage

    def test_hash(self):
        a = QgsPoint(2.0, 1.0)
        b = QgsPoint(2.0, 2.0)
        c = QgsPoint(1.0, 2.0)
        d = QgsPoint(1.0, 1.0)
        e = QgsPoint(2.0, 1.0)
        assert a.__hash__() != b.__hash__()
        assert e.__hash__() == a.__hash__()

        mySet = set([a, b, c, d, e])
        assert len(mySet) == 4

    def processNewData(self, data):
        '''
        Process incoming data from the data provider
        :param data: Positon or attitude data
        :type data: dict
        '''
        if not self.enabled:
            return
        try:
            name = data['name']
            if name in self.messageFilter.keys():
                if data['id'] != self.messageFilter[name]:
                    return
        except:
            pass
        self.extData.update(data)

        if 'lat' in data and 'lon' in data:
            self.position = QgsPoint(data['lon'], data['lat'])
            self.heading = data.get('heading', -9999.9)
            self.depth = data.get('depth', -9999.9)
            try:
                self.coordinates = self.crsXform.transform(self.position)
                self.marker.setMapPosition(self.coordinates)
                if 'time' in data:
                    self.lastFix = data['time']
                    self.newPosition.emit(self.lastFix, self.position,
                                          self.extData.get('depth', -9999.9),
                                          self.extData.get('altitude', -9999.9))
                    self.timer.start(self.timeoutTime)
                    self.timeoutCount = 0
            except QgsCsException:
                pass

        elif self.position is not None:
            if 'depth' in data or 'altitude' in data:
                self.newPosition.emit(self.lastFix, self.position,
                                      self.extData.get('depth', -9999.9),
                                      self.extData.get('altitude', -9999.9))

        if 'heading' in data:
            self.newAttitude.emit(data['heading'], data.get('pitch', 0.0),
                                  data.get('roll', 0.0))
            self.marker.newHeading(data['heading'])

    def __init__(self, iface, obsType, point, observation, precision):
        memoryLayers = MemoryLayers(iface)
        self.lineLayer = memoryLayers.line_layer()
        self.pointLayer = memoryLayers.point_layer()

        # generate ID;
        self.id = datetime.now().strftime("%Y%m%d%H%M%S%f")

        # obsservations are stored in the lineLayer layer attributes:
        #   0: id
        #   1: observation type
        #   2: x
        #   3: y
        #   4: observation
        #   5: precision

        self.obsType = obsType
        self.point = QgsPoint(point)
        self.observation = observation
        self.precision = precision

 def __init__(self,parent = None,x=0,y=0):
     QWidget.__init__(self,parent)
     self.resize(270, 130)
     
     self._gridLayout = QGridLayout(self)
     self._sbYCoord = QDoubleSpinBox(self)
     self._sbYCoord.setMinimumSize(QSize(0, 30))
     self._sbYCoord.setDecimals(5)
     self._sbYCoord.setMinimum(-180.0)
     self._sbYCoord.setMaximum(180.0)
     self._gridLayout.addWidget(self._sbYCoord, 2, 1, 1, 1)
     self._label_2 = QLabel(self)
     self._label_2.setText(QApplication.translate("CoordinatesWidget","Y-Coordinate"))
     self._gridLayout.addWidget(self._label_2, 2, 0, 1, 1)
     self._label = QLabel(self)
     self._label.setMaximumSize(QSize(80, 16777215))
     self._label.setText(QApplication.translate("CoordinatesWidget","X-Coordinate"))
     self._gridLayout.addWidget(self._label, 1, 0, 1, 1)
     self._sbXCoord = QDoubleSpinBox(self)
     self._sbXCoord.setMinimumSize(QSize(0, 30))
     self._sbXCoord.setDecimals(5)
     self._sbXCoord.setMinimum(-180.0)
     self._sbXCoord.setMaximum(180.0)
     self._gridLayout.addWidget(self._sbXCoord, 1, 1, 1, 1)
     self.vlNotification = QVBoxLayout()
     self._gridLayout.addLayout(self.vlNotification, 0, 0, 1, 2)
     
     #Set X and Y values
     self._sbXCoord.setValue(float(x))
     self._sbYCoord.setValue(float(y))
     
     self._geomPoint = QgsPoint(x,y)
     
     #Use default SRID
     self._srid = 4326
     
     #Connect signals
     self._sbXCoord.valueChanged.connect(self.onXCoordValueChanged)
     self._sbYCoord.valueChanged.connect(self.onYCoordValueChanged)

def arc(p1, p2, offset=1):

    # point in middle
    mp = QgsPoint((p1.x()+p2.x())/2, (p1.y()+p2.y())/2)
    # distance between the two points
    d = sqrt(p1.sqrDist(p2))
    # orthogonal direction to segment p1-p2
    az = (p1.azimuth(p2)+90)*pi/180
    # create point distant to segment of offset of segment length, will be center of circular arc
    cp = QgsPoint(mp.x()+d*offset*sin(az),
                  mp.y()+d*offset*cos(az))
    # radius
    r = d*sqrt(4*offset*offset+1)/2
    # calculate start and end azimuth of circular arc
    az1 = cp.azimuth(p1)
    az2 = cp.azimuth(p2)
    if az2 < az1:
        az2 += 360
    # draw arc
    vx = [cp.x()+r*sin(az*pi/180) for az in floatrange(az1, az2, 5)]
    vy = [cp.y()+r*cos(az*pi/180) for az in floatrange(az1, az2, 5)]
    arcLine = [QgsPoint(vx[i], vy[i]) for i in range(len(vx))]
    return QgsGeometry().fromPolyline(arcLine)

    def processAlgorithm(self, feedback):
        layer = dataobjects.getObjectFromUri(
            self.getParameterValue(self.INPUT_VECTOR))
        startPoint = self.getParameterValue(self.START_POINT)
        endPoint = self.getParameterValue(self.END_POINT)
        strategy = self.getParameterValue(self.STRATEGY)

        directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
        forwardValue = self.getParameterValue(self.VALUE_FORWARD)
        backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
        bothValue = self.getParameterValue(self.VALUE_BOTH)
        defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
        bothValue = self.getParameterValue(self.VALUE_BOTH)
        defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
        speedFieldName = self.getParameterValue(self.SPEED_FIELD)
        defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
        tolerance = self.getParameterValue(self.TOLERANCE)

        fields = QgsFields()
        fields.append(QgsField('start', QVariant.String, '', 254, 0))
        fields.append(QgsField('end', QVariant.String, '', 254, 0))
        fields.append(QgsField('cost', QVariant.Double, '', 20, 7))

        writer = self.getOutputFromName(
            self.OUTPUT_LAYER).getVectorWriter(
                fields.toList(),
                QgsWkbTypes.LineString,
                layer.crs())

        tmp = startPoint.split(',')
        startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
        tmp = endPoint.split(',')
        endPoint = QgsPoint(float(tmp[0]), float(tmp[1]))

        directionField = -1
        if directionFieldName is not None:
            directionField = layer.fields().lookupField(directionFieldName)
        speedField = -1
        if speedFieldName is not None:
            speedField = layer.fields().lookupField(speedFieldName)

        director = QgsVectorLayerDirector(layer,
                                          directionField,
                                          forwardValue,
                                          backwardValue,
                                          bothValue,
                                          defaultDirection)

        distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
        multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters)
        if strategy == 0:
            strategy = QgsNetworkDistanceStrategy()
        else:
            strategy = QgsNetworkSpeedStrategy(speedField,
                                               defaultSpeed,
                                               multiplier * 1000.0 / 3600.0)
            multiplier = 3600

        director.addStrategy(strategy)
        builder = QgsGraphBuilder(iface.mapCanvas().mapSettings().destinationCrs(),
                                  iface.mapCanvas().hasCrsTransformEnabled(),
                                  tolerance)
        feedback.pushInfo(self.tr('Building graph...'))
        snappedPoints = director.makeGraph(builder, [startPoint, endPoint])

        feedback.pushInfo(self.tr('Calculating shortest path...'))
        graph = builder.graph()
        idxStart = graph.findVertex(snappedPoints[0])
        idxEnd = graph.findVertex(snappedPoints[1])

        tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
        if tree[idxEnd] == -1:
            raise GeoAlgorithmExecutionException(
                self.tr('There is no route from start point to end point.'))

        route = []
        cost = 0.0
        current = idxEnd
        while current != idxStart:
            cost += graph.edge(tree[current]).cost(0)
            route.append(graph.vertex(graph.edge(tree[current]).inVertex()).point())
            current = graph.edge(tree[current]).outVertex()

        route.append(snappedPoints[0])
        route.reverse()

        self.setOutputValue(self.TRAVEL_COST, cost / multiplier)

        feedback.pushInfo(self.tr('Writing results...'))
        geom = QgsGeometry.fromPolyline(route)
        feat = QgsFeature()
        feat.setFields(fields)
        feat['start'] = startPoint.toString()
        feat['end'] = endPoint.toString()
        feat['cost'] = cost / multiplier
        feat.setGeometry(geom)
        writer.addFeature(feat)
        del writer