How can I calculate the coordinates of a point on the intersection of two parallel lines with a bisecting line with pyQGIS?

Question

I am building some sort of homemade pyQGIS-Buffer-tool as the existing flat-end-buffer-tools are not working for me ( see v.distance.buffer does not create proper buffers with flat endcaps)

Therefore I am looking for a solution how to get the polygon-vertices of my buffer-polygon where the linesegments have an angle <>180° to each other (see image below). For start- and endpoint I just make a linear interpolation with 90° angle to the line direction.

Now i wonder how I could get the two points that are marked red in the picture? ( The orange line is my source line I would like to "buffer".) Note: I am not looking for a flat buffer tool but just for a pythonic solution how to get the vertexpoints that are marked in the picture. My first idea was to make parallel lines to my source line, elongate them if nesccessary and find the intersection but this seems a bit cumbersome.

Any ideas how to solve this with pyQGIS or some math.xxx magic?

Here a picture how it looks like at the moment if I just interpolate every vertex 5m with -90° to the line direction:

and here a picture how it should look like:

Answer 1

Combining grass:v.parallel and saga:convertlinestopolygons (both processing methods) in a PyQGIS code, it is possible to accomplish this task. For this situation:

and this code:

import processing

layer = processing.getObjectFromName('my_line1')

extent = layer.extent()

xmin, ymin, xmax, ymax = extent.toRectF().getCoords()

distance = 5

path = processing.runalg('grass:v.parallel',
                         layer,      #input <ParameterVector>
                         distance,   #distance <ParameterNumber>
                         distance,   #minordistance <ParameterNumber>
                         0,          #angle <ParameterNumber>
                         2,          #side <ParameterSelection>
                         1,          #tolerance <ParameterNumber>
                         False,      #-r <ParameterBoolean>
                         True,       #-b <ParameterBoolean>
                         "%f,%f,%f,%f" % (xmin, xmax, ymin, ymax), #GRASS_REGION_PARAMETER <ParameterExtent>
                         -1,         #GRASS_SNAP_TOLERANCE_PARAMETER <ParameterNumber>
                         0,          #GRASS_MIN_AREA_PARAMETER <ParameterNumber>
                         2,
                         None)

output = QgsVectorLayer(path['output'],
                        'buffer',
                        'ogr')

path = processing.runalg('saga:convertlinestopolygons',
                         output,
                         None)

buffer = QgsVectorLayer(path['POLYGONS'],
                        'buffer',
                        'ogr')

QgsMapLayerRegistry.instance().addMapLayer(buffer)

after running it at the Python Console de PyQGIS, I got:

Answer 2

The Shapely geometry library has the necessary tools to do what you're looking for. In particular the buffer() function accepts a parameter that tells it to calculate "butt" ends on the lines. Something like this should work:

import shapely.wkb
from shapely.geometry import CAP_STYLE
from shapely.geometry import JOIN_STYLE

# For testing, get the first geometry of the active layer
qgisLine = iface.activeLayer().getFeatures().next().geometry()
line = shapely.wkb.loads(qgisLine.asWkb())

# First parameter is buffer distance.
# "resolution" is ignored in this case, but would be used to
# approximate rounded corners if join_style were different.
poly = line.buffer(5.0, resolution=16, \
    cap_style=CAP_STYLE.flat, \
    join_style=JOIN_STYLE.mitre)

You'd need to add a little bit of Python glue code to convert the poly back to a feature.

Also note that Shapely may not be installed by default. On my (Fedora) machine, I had to install the python-shapely package.