Results¶

def top_candidate(self) -> str:
    """The candidate with the highest confidence score"""
    return self.texts[self.scores.index(self.top_score())]

def top_score(self):
    """The highest confidence score"""
    return max(self.scores)

def drop_indices(self, index: Sequence[int]) -> None:
    """Drop segments from result

    Example: Given a `Result` with three segments s0, s1 and s2,
    index = [0, 2] will drop segments s0 and s2.

    Arguments:
        index: Indices of segments to drop
    """
    keep = [i for i in range(len(self.segments)) if i not in index]
    self.reorder(keep)

def filter(self, key: str, predicate: Callable[[Any], bool]) -> None:
    """Filter segments and data based on a predicate applied to a specified key.

    Args:
        key: The key in the data dictionary to test the predicate against.
        predicate [Callable]: A function that takes a value associated with the key
        and returns True if the segment should be kept.

    Example:
    ```
    >>> def remove_certain_text(text_results):
    >>>    return text_results != 'lorem'
    >>> result.filter('text_results', remove_certain_text)
    True
    ```
    """
    keep = [i for i, item in enumerate(self.data) if predicate(item.get(key, None))]
    self.reorder(keep)

def reorder(self, index: Sequence[int]) -> None:
    """Reorder result

    Example: Given a `Result` with three segments s0, s1 and s2,
    index = [2, 0, 1] will put the segments in order [s2, s0, s1].
    Any indices not in `index` will be dropped from the result.

    Arguments:
        index: A list of indices representing the new ordering.
    """
    if self.segments:
        self.segments = [self.segments[i] for i in index]

def rescale(self, factor: float):
    """Rescale the Result's segments"""
    for segment in self.segments:
        segment.rescale(factor)

@classmethod
def segmentation_result(
    cls,
    orig_shape: tuple[int, int],
    metadata: dict[str, Any],
    bboxes: Sequence[Bbox | Iterable[int]] | None = None,
    masks: Sequence[Mask] | None = None,
    polygons: Sequence[Polygon] | None = None,
    scores: Iterable[float] | None = None,
    labels: Iterable[str] | None = None,
) -> "Result":
    """Create a segmentation result

    Arguments:
        image: The original image
        metadata: Result metadata
        segments: The segments

    Returns:
        A Result instance with the specified data and no texts.
    """
    segments = []
    for item in _zip_longest_none(bboxes, masks, scores, labels, polygons):
        segment = Segment(*item, orig_shape=orig_shape)
        if segment.bbox.area > 0:
            segments.append(segment)
    return cls(metadata, segments=segments)

@classmethod
def text_recognition_result(cls, metadata: dict[str, Any], texts: list[str], scores: list[float]) -> "Result":
    """Create a text recognition result

    Arguments:
        metadata: Result metadata
        text: The recognized text

    Returns:
        A Result instance with the specified data and no segments.
    """
    return cls(metadata, text=RecognizedText(texts, scores))

def approximate_mask(self, ratio: float) -> Mask | None:
    """A lower resolution version of the global mask

    Arguments:
        ratio: Size of approximate mask relative to the original.
    """
    global_mask = self.global_mask
    if global_mask is None:
        return None
    return imgproc.rescale(global_mask, ratio)

def rescale(self, factor: float) -> None:
    """Rescale the segment's mask, bounding box and polygon by `factor`"""
    if self.mask is not None:
        self.mask = imgproc.rescale_linear(self.mask, factor)
    self.bbox = self.bbox.rescale(factor)
    if self.polygon is not None:
        self.polygon = self.polygon.rescale(factor)