Method Facade

scripts/gdb_printers.py:220–356

(facade, width, height, arg)

    @staticmethod
    def Facade(facade, width, height, arg):

        result = ''

        ## parse additional facade arguments
        re_float = '[-+]?[0-9]*\.?[0-9]+'
        bbox = re.search('(' + re_float + '),(' + re_float + ');(' + re_float + '),(' + re_float +')', arg)
        bbox = [float(x) for x in bbox.groups()] if bbox else [-180, -90, 180, 90]
        mld_level = re.search('L:([0-9]+)', arg)
        mld_level = int(mld_level.group(1)) if mld_level else 0

        marginx, marginy = 75, 75
        INVALID_SEGMENT_WEIGHT, MAX_SEGMENT_WEIGHT = gdb.parse_and_eval('INVALID_SEGMENT_WEIGHT'), gdb.parse_and_eval('INVALID_SEGMENT_WEIGHT')
        segment_weight = lambda x: str(x) + (' invalid' if x == INVALID_SEGMENT_WEIGHT else ' max' if x == MAX_SEGMENT_WEIGHT else '')

        if mld_level > 0:
            mld_facade = facade.cast(gdb.lookup_type('osrm::engine::datafacade::ContiguousInternalMemoryAlgorithmDataFacade<osrm::engine::routing_algorithms::mld::Algorithm>'))
            mld_partition = mld_facade['mld_partition']
            mld_levels = call(mld_partition, 'GetNumberOfLevels')
            if mld_level < mld_levels:
                sentinel_node = call(mld_partition['partition'], 'size') - 1 # GetSentinelNode
                number_of_cells = call(mld_partition, 'GetCell', mld_level, sentinel_node) # GetNumberOfCells
                result += "<defs>"
                for cell in range(number_of_cells):
                    result += """
<filter x="0" y="0" width="1" height="1" id="cellid-{}"><feFlood flood-color="hsl({}, 100%, 82%)"/><feComposite in="SourceGraphic"/></filter>""" \
                    .format(cell, int(256 * cell / number_of_cells))
                result += "\n</defs>"
            else:
                mld_level = 0
        else:
            mld_levels = 0

        ## get nodes
        nodes, longitudes, latitudes = SVGPrinter.getNodesInBoundingBox(facade, bbox)
        if len(nodes) == 0:
            return ''

        ## create transformations (lon,lat) -> (x,y)
        minx, miny, maxx, maxy = min(longitudes), min(latitudes), max(longitudes), max(latitudes)
        if abs(maxx - minx) < 1e-8:
            maxx += (maxy - miny) / 2
            minx -= (maxy - miny) / 2
        if abs(maxy - miny) < 1e-8:
            maxy += (maxx - minx) / 2
            miny -= (maxx - minx) / 2
        tx = lambda x: marginx + (x - minx) * (width - 2 * marginx) / (maxx - minx)
        ty = lambda y: marginy + (maxy - y) * (height - 2 * marginy) / (maxy - miny)
        t = lambda x: str(tx(x[0])) + ',' + str(ty(x[1]))

        print ('Graph has {} nodes and {} edges and {} nodes in the input bounding box {},{};{},{} -> {},{};{},{}'
               .format(call(facade, 'GetNumberOfNodes'), call(facade, 'GetNumberOfEdges'), len(nodes), *bbox, minx, miny, maxx, maxy))

        for node in nodes:
            geometry_id = call(facade, 'GetGeometryIndex', node)
            direction = 'forward' if geometry_id['forward'] else 'reverse'
            print (geometry_id, direction)
            geometry = SVGPrinter.getByGeometryId(facade, geometry_id, 'Geometry')