def get_segmentation(recording,
                     single_clf,
                     single_stroke_clf,
                     stroke_segmented_classifier):
    """
    Get a list of segmentations of recording with the probability of the
    segmentation being correct.

    Parameters
    ----------
    recording : A list of lists
        Each sublist represents a stroke
    single_clf : object
        A classifier for single symbols
    single_stroke_clf : object
        A classifier which decides if a single stroke is a complete symbol
    stroke_segmented_classifier : object
        Classifier which decides if two strokes belong to one symbol or not

    Returns
    -------
    list of tuples :
        Segmentations together with their probabilities. Each probability
        has to be positive and the sum may not be bigger than 1.0.

    Examples
    --------
    >>> stroke1 = [{'x': 0, 'y': 0, 'time': 0}, {'x': 12, 'y': 12, 'time': 1}]
    >>> stroke2 = [{'x': 0, 'y': 10, 'time': 2}, {'x': 12, 'y': 0, 'time': 3}]
    >>> stroke3 = [{'x': 14, 'y': 0, 'time': 5}, {'x': 14, 'y': 12, 'time': 6}]
    >>> #get_segmentation([stroke1, stroke2, stroke3], single_clf)
    [
      ([[0, 1], [2]], 0.8),
      ([[0], [1,2]], 0.1),
      ([[0,2], [1]], 0.05)
    ]
    """
    mst_wood = get_mst_wood(recording, single_clf)
    return [(normalize_segmentation([mst['strokes'] for mst in mst_wood]),
             1.0)]

    # HandwrittenData(json.dumps(recording)).show()
    # return [([[i for i in range(len(recording))]], 1.0)]
    # #mst_wood = break_mst(mst, recording)  # TODO

    # for i in range(0, 2**len(points)):
    #     segmentation = get_segmentation_from_mst(mst, i)
    # TODO

    X_symbol = [get_median_stroke_distance(recording)]

    # Pre-segment to 8 strokes
    # TODO: Take first 4 strokes and add strokes within their bounding box
    # TODO: What if that is more then 8 strokes?
    # -> Geometry
    #    Build tree structure. A stroke `c` is the child of another stroke `p`,
    #    if the bounding box of `c` is within the bounding box of `p`.
    #       Problem: B <-> 13
    g_top_segmentations = [([], 1.0)]  # g_top_segmentations

    # range(int(math.ceil(float(len(recording))/8))):
    for chunk_part in mst_wood:
        # chunk = recording[8*chunk_part:8*(chunk_part+1)]
        chunk = [recording[stroke] for stroke in chunk_part['strokes']]

        # Segment after pre-segmentation
        prob = [[1.0 for _ in chunk] for _ in chunk]
        for strokeid1, strokeid2 in itertools.product(range(len(chunk)),
                                                      range(len(chunk))):
            if strokeid1 == strokeid2:
                continue
            X = get_stroke_features(chunk, strokeid1, strokeid2)
            X += X_symbol
            X = numpy.array([X], dtype=numpy.float32)
            prob[strokeid1][strokeid2] = stroke_segmented_classifier(X)

        # Top segmentations
        ts = list(partitions.get_top_segmentations(prob, 500))
        for i, segmentation in enumerate(ts):
            symbols = apply_segmentation(chunk, segmentation)
            min_top2 = partitions.TopFinder(1, find_min=True)
            for i, symbol in enumerate(symbols):
                predictions = single_clf.predict(symbol)
                min_top2.push("value-%i" % i,
                              predictions[0]['probability'] +
                              predictions[1]['probability'])
            ts[i][1] *= list(min_top2)[0][1]
        # for i, segmentation in enumerate(ts):
        #     ts[i][0] = update_segmentation_data(ts[i][0], 8*chunk_part)
        g_top_segmentations = merge_segmentations(g_top_segmentations,
                                                  ts,
                                                  chunk_part['strokes'])
    return [(normalize_segmentation(seg), probability)
            for seg, probability in g_top_segmentations]
Get a list of segmentations of recording with the probability of the
    segmentation being correct.

    Parameters
    ----------
    recording : A list of lists
        Each sublist represents a stroke
    single_clf : object
        A classifier for single symbols
    single_stroke_clf : object
        A classifier which decides if a single stroke is a complete symbol
    stroke_segmented_classifier : object
        Classifier which decides if two strokes belong to one symbol or not

    Returns
    -------
    list of tuples :
        Segmentations together with their probabilities. Each probability
        has to be positive and the sum may not be bigger than 1.0.

    Examples
    --------
    >>> stroke1 = [{'x': 0, 'y': 0, 'time': 0}, {'x': 12, 'y': 12, 'time': 1}]
    >>> stroke2 = [{'x': 0, 'y': 10, 'time': 2}, {'x': 12, 'y': 0, 'time': 3}]
    >>> stroke3 = [{'x': 14, 'y': 0, 'time': 5}, {'x': 14, 'y': 12, 'time': 6}]
    >>> #get_segmentation([stroke1, stroke2, stroke3], single_clf)
    [
      ([[0, 1], [2]], 0.8),
      ([[0], [1,2]], 0.1),
      ([[0,2], [1]], 0.05)
    ]