Skip to content

External template

ExternalTemplate

Bases: ITemplate, IApiInterfaceImplementation

Representation of a template instance designed to be shared between processes. It is very important that this class is picklable!

Source code in src/officialeye/_internal/template/external_template.py 
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
class ExternalTemplate(ITemplate, IApiInterfaceImplementation):
    """
    Representation of a template instance designed to be shared between processes.
    It is very important that this class is picklable!
    """

    def __init__(self, template: InternalTemplate, /):
        super().__init__()

        self._context: Context | None = None

        self._identifier: str = template.identifier
        self._name: str = template.name
        self._path: str = template.get_path()
        self._source_image_path: str = template.get_source_image_path()

        self._width = template.width
        self._height = template.height

        self._keypoints: Dict[str, ExternalKeypoint] = {}
        self._features: Dict[str, ExternalFeature] = {}

        for keypoint in template.keypoints:
            self._keypoints[keypoint.identifier] = ExternalKeypoint(keypoint, self)

        for feature in template.features:
            self._features[feature.identifier] = ExternalFeature(feature, self)

        self._source_mutators: List[IMutator] = [
            mutator for mutator in template.get_source_mutators()
        ]

        self._target_mutators: List[IMutator] = [
            mutator for mutator in template.get_target_mutators()
        ]

    def set_api_context(self, context: Context, /) -> None:
        self._context = context

        for external_keypoint in self.keypoints:
            external_keypoint.set_api_context(context)

        for external_feature in self.features:
            external_feature.set_api_context(context)

    def clear_api_context(self) -> None:
        self._context = None

        for external_keypoint in self.keypoints:
            external_keypoint.clear_api_context()

        for external_feature in self.features:
            external_feature.clear_api_context()

    def load(self) -> None:
        raise ErrOperationNotSupported(
            "while accessing an external template instance.",
            "The way in which it was accessed is not supported."
        )

    def detect_async(self, /, *, target: IImage) -> Future:

        # TODO: this is hacky, maybe use a more clean approach here?
        assert isinstance(target, Image)

        # noinspection PyProtectedMember
        return self._context._submit_task(
            template_detect,
            f"Detecting [b]{self._name}[/]...",
            self._path,
            target_path=target._path,
        )

    def detect(self, /, **kwargs) -> ISupervisionResult:
        future = self.detect_async(**kwargs)
        return future.result()

    def get_image(self) -> IImage:
        return Image(self._context, path=self._source_image_path)

    def get_mutated_image(self) -> IImage:
        img = self.get_image()
        img.apply_mutators(*self._source_mutators)
        return img

    @property
    def identifier(self) -> str:
        return self._identifier

    @property
    def name(self) -> str:
        return self._name

    @property
    def width(self) -> int:
        return self._width

    @property
    def height(self) -> int:
        return self._height

    @property
    def keypoints(self) -> Iterable[ExternalKeypoint]:
        return self._keypoints.values()

    @property
    def features(self) -> Iterable[ExternalFeature]:
        return self._features.values()

    def get_feature(self, feature_id: str, /) -> ExternalFeature | None:
        if feature_id not in self._features:
            return None
        return self._features[feature_id]

    def get_keypoint(self, keypoint_id: str, /) -> ExternalKeypoint | None:
        if keypoint_id not in self._keypoints:
            return None
        return self._keypoints[keypoint_id]