docs: 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]