Skip to content

drawing_target

drawing_target

Target for Draw commands to draw into.

Rasterized2DDrawingTarget

Bases: DrawingTarget

Target for Draw commands to draw into.

Source code in src/pygerber/backend/rasterized_2d/drawing_target.py 
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 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
class Rasterized2DDrawingTarget(DrawingTarget):
    """Target for Draw commands to draw into."""

    target_image: Image.Image
    _target_image_polarity_dark: Optional[Image.Image] = None
    _target_image_polarity_clear: Optional[Image.Image] = None
    _target_image_polarity_region_dark: Optional[Image.Image] = None
    _target_image_polarity_region_clear: Optional[Image.Image] = None
    _mask_image: Optional[Image.Image] = None

    def __init__(
        self,
        coordinate_origin: Vector2D,
        bounding_box: BoundingBox,
        target_image: Image.Image,
    ) -> None:
        """Initialize drawing target."""
        super().__init__(coordinate_origin, bounding_box)
        self.target_image = target_image
        self._target_image_polarity_dark = None
        self._target_image_polarity_clear = None
        self._target_image_polarity_region_dark = None
        self._target_image_polarity_region_clear = None
        self._mask_image = None
        self._is_finalized = False

    @property
    def image_draw(self) -> ImageDraw.ImageDraw:
        """Acquire drawing interface."""
        return ImageDraw.Draw(self.target_image)

    def _finalize(self) -> None:
        self._is_finalized = True

    @property
    def mask_image(self) -> Image.Image:
        """Inverted aperture image."""
        if not self._is_finalized:
            raise ApertureImageNotInitializedError

        if self._mask_image is None:
            self._mask_image = self.target_image.point(
                lambda p: 255 if p > GRAYSCALE_CENTER_VALUE else 0,
            )

        return self._mask_image

    @property
    def image_polarity_dark(self) -> Image.Image:
        """Inverted aperture image."""
        if not self._is_finalized:
            raise ApertureImageNotInitializedError

        if self._target_image_polarity_dark is None:
            color = Polarity.Dark.get_2d_rasterized_color()
            self._target_image_polarity_dark = self.mask_image.point(
                lambda p: color if p else 0,
            )

        return self._target_image_polarity_dark

    @property
    def image_polarity_clear(self) -> Image.Image:
        """Inverted aperture image."""
        if not self._is_finalized:
            raise ApertureImageNotInitializedError

        if self._target_image_polarity_clear is None:
            color = Polarity.Clear.get_2d_rasterized_color()
            self._target_image_polarity_clear = self.mask_image.point(
                lambda p: color if p else 0,
            )

        return self._target_image_polarity_clear

    @property
    def image_polarity_region_dark(self) -> Image.Image:
        """Inverted aperture image."""
        if not self._is_finalized:
            raise ApertureImageNotInitializedError

        if self._target_image_polarity_region_dark is None:
            color = Polarity.DarkRegion.get_2d_rasterized_color()
            self._target_image_polarity_region_dark = self.mask_image.point(
                lambda p: color if p else 0,
            )

        return self._target_image_polarity_region_dark

    @property
    def image_polarity_region_clear(self) -> Image.Image:
        """Inverted aperture image."""
        if not self._is_finalized:
            raise ApertureImageNotInitializedError

        if self._target_image_polarity_region_clear is None:
            color = Polarity.ClearRegion.get_2d_rasterized_color()
            self._target_image_polarity_region_clear = self.mask_image.point(
                lambda p: color if p else 0,
            )

        return self._target_image_polarity_region_clear

image_draw property 

image_draw: ImageDraw

Acquire drawing interface.

mask_image property 

mask_image: Image

Inverted aperture image.

image_polarity_dark property 

image_polarity_dark: Image

Inverted aperture image.

image_polarity_clear property 

image_polarity_clear: Image

Inverted aperture image.

image_polarity_region_dark property 

image_polarity_region_dark: Image

Inverted aperture image.

image_polarity_region_clear property 

image_polarity_region_clear: Image

Inverted aperture image.

__init__ 

__init__(
    coordinate_origin: Vector2D,
    bounding_box: BoundingBox,
    target_image: Image.Image,
) -> None

Initialize drawing target.

Source code in src/pygerber/backend/rasterized_2d/drawing_target.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
def __init__(
    self,
    coordinate_origin: Vector2D,
    bounding_box: BoundingBox,
    target_image: Image.Image,
) -> None:
    """Initialize drawing target."""
    super().__init__(coordinate_origin, bounding_box)
    self.target_image = target_image
    self._target_image_polarity_dark = None
    self._target_image_polarity_clear = None
    self._target_image_polarity_region_dark = None
    self._target_image_polarity_region_clear = None
    self._mask_image = None
    self._is_finalized = False