Skip to content

backend_cls

backend_cls

Class interface for visualizing gerber files.

BackendOptions

Additional configuration which can be passed to backend.

Source code in src/pygerber/backend/abstract/backend_cls.py 
38
39
40
41
42
43
44
45
46
47
48
49
class BackendOptions:
    """Additional configuration which can be passed to backend."""

    def __init__(
        self,
        dump_apertures: Optional[Path] = None,
        *,
        draw_region_outlines: bool = False,
    ) -> None:
        """Initialize options."""
        self.dump_apertures = dump_apertures
        self.draw_region_outlines = draw_region_outlines

__init__ 

__init__(
    dump_apertures: Optional[Path] = None,
    *,
    draw_region_outlines: bool = False
) -> None

Initialize options.

Source code in src/pygerber/backend/abstract/backend_cls.py 
41
42
43
44
45
46
47
48
49
def __init__(
    self,
    dump_apertures: Optional[Path] = None,
    *,
    draw_region_outlines: bool = False,
) -> None:
    """Initialize options."""
    self.dump_apertures = dump_apertures
    self.draw_region_outlines = draw_region_outlines

Backend

Bases: ABC

Drawing backend interface.

Source code in src/pygerber/backend/abstract/backend_cls.py 
 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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
class Backend(ABC):
    """Drawing backend interface."""

    handles: list[PrivateApertureHandle]
    drawing_target: DrawingTarget
    bounding_box: BoundingBox
    coordinate_origin: Vector2D

    options_class: ClassVar[type[BackendOptions]] = BackendOptions

    def __init__(self, options: Optional[BackendOptions] = None) -> None:
        """Initialize backend."""
        self.options = self.options_class() if options is None else options
        self.handles = []

    def create_aperture_handle(self, aperture_id: ApertureID) -> PrivateApertureHandle:
        """Create new aperture handle."""
        handle = self.get_aperture_handle_cls()(
            aperture_id=aperture_id,
            private_id=len(self.handles),
            backend=self,
        )
        self.handles.append(handle)
        return handle

    def get_private_aperture_handle(
        self,
        public_aperture_handle: PublicApertureHandle,
    ) -> PrivateApertureHandle:
        """Get private aperture handle."""
        return self.handles[public_aperture_handle.private_id]

    def draw(self, draws: List[DrawCommand]) -> ResultHandle:
        """Execute all draw actions to create visualization."""
        self.draws = draws

        self.finalize_aperture_creation()
        self.bounding_box = self._get_draws_bounding_box(draws)
        self.coordinate_origin = self._get_coordinate_origin()
        self.drawing_target = self._create_drawing_target()
        self._pre_drawing_hook()

        with self.drawing_target:
            for draw_action in draws:
                draw_action.draw(self.drawing_target)

        self._post_drawing_hook()

        return self.get_result_handle()

    def finalize_aperture_creation(self) -> None:
        """Apply draw operations to aperture handles."""
        for handle in self.handles:
            handle.finalize_aperture_creation()

    def _get_draws_bounding_box(self, draws: List[DrawCommand]) -> BoundingBox:
        bbox: Optional[BoundingBox] = None

        for draw in draws:
            if bbox is not None:
                bbox += draw.get_bounding_box()
            else:
                bbox = draw.get_bounding_box()

        if bbox is not None:
            return bbox

        return BoundingBox.NULL

    def _get_coordinate_origin(self) -> Vector2D:
        return self.bounding_box.get_min_vector()

    @abstractmethod
    def _create_drawing_target(self) -> DrawingTarget:
        """Create drawing target object."""

    def _pre_drawing_hook(self) -> None:  # noqa: B027
        """Perform custom actions before drawing."""

    def _post_drawing_hook(self) -> None:  # noqa: B027
        """Perform custom actions after drawing."""

    @abstractmethod
    def get_result_handle(self) -> ResultHandle:
        """Return result handle to visualization."""

    @abstractmethod
    def get_aperture_handle_cls(self) -> Type[PrivateApertureHandle]:
        """Get backend-specific implementation of aperture handle class."""

    @abstractmethod
    def get_draw_circle_cls(self) -> Type[DrawCircle]:
        """Get backend-specific implementation of aperture circle component class."""

    @abstractmethod
    def get_draw_rectangle_cls(self) -> Type[DrawRectangle]:
        """Get backend-specific implementation of aperture rectangle component class."""

    @abstractmethod
    def get_draw_polygon_cls(self) -> Type[DrawPolygon]:
        """Get backend-specific implementation of aperture polygon component class."""

    @abstractmethod
    def get_draw_commands_handle_cls(self) -> type[DrawCommandsHandle]:
        """Return backend-specific implementation of draw actions handle."""

    @abstractmethod
    def get_draw_paste_cls(self) -> type[DrawPaste]:
        """Return backend-specific implementation of draw paste."""

    @abstractmethod
    def get_draw_region_cls(self) -> type[DrawRegion]:
        """Return backend-specific implementation of draw action region."""

    @abstractmethod
    def get_draw_vector_line_cls(self) -> type[DrawVectorLine]:
        """Return backend-specific implementation of draw action line."""

    @abstractmethod
    def get_draw_arc_cls(self) -> type[DrawArc]:
        """Return backend-specific implementation of draw action arc."""

__init__ 

__init__(options: Optional[BackendOptions] = None) -> None

Initialize backend.

Source code in src/pygerber/backend/abstract/backend_cls.py 
62
63
64
65
def __init__(self, options: Optional[BackendOptions] = None) -> None:
    """Initialize backend."""
    self.options = self.options_class() if options is None else options
    self.handles = []

create_aperture_handle 

create_aperture_handle(
    aperture_id: ApertureID,
) -> PrivateApertureHandle

Create new aperture handle.

Source code in src/pygerber/backend/abstract/backend_cls.py 
67
68
69
70
71
72
73
74
75
def create_aperture_handle(self, aperture_id: ApertureID) -> PrivateApertureHandle:
    """Create new aperture handle."""
    handle = self.get_aperture_handle_cls()(
        aperture_id=aperture_id,
        private_id=len(self.handles),
        backend=self,
    )
    self.handles.append(handle)
    return handle

get_private_aperture_handle 

get_private_aperture_handle(
    public_aperture_handle: PublicApertureHandle,
) -> PrivateApertureHandle

Get private aperture handle.

Source code in src/pygerber/backend/abstract/backend_cls.py 
77
78
79
80
81
82
def get_private_aperture_handle(
    self,
    public_aperture_handle: PublicApertureHandle,
) -> PrivateApertureHandle:
    """Get private aperture handle."""
    return self.handles[public_aperture_handle.private_id]

draw 

draw(draws: List[DrawCommand]) -> ResultHandle

Execute all draw actions to create visualization.

Source code in src/pygerber/backend/abstract/backend_cls.py 
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def draw(self, draws: List[DrawCommand]) -> ResultHandle:
    """Execute all draw actions to create visualization."""
    self.draws = draws

    self.finalize_aperture_creation()
    self.bounding_box = self._get_draws_bounding_box(draws)
    self.coordinate_origin = self._get_coordinate_origin()
    self.drawing_target = self._create_drawing_target()
    self._pre_drawing_hook()

    with self.drawing_target:
        for draw_action in draws:
            draw_action.draw(self.drawing_target)

    self._post_drawing_hook()

    return self.get_result_handle()

finalize_aperture_creation 

finalize_aperture_creation() -> None

Apply draw operations to aperture handles.

Source code in src/pygerber/backend/abstract/backend_cls.py 
102
103
104
105
def finalize_aperture_creation(self) -> None:
    """Apply draw operations to aperture handles."""
    for handle in self.handles:
        handle.finalize_aperture_creation()

get_result_handle abstractmethod 

get_result_handle() -> ResultHandle

Return result handle to visualization.

Source code in src/pygerber/backend/abstract/backend_cls.py 
134
135
136
@abstractmethod
def get_result_handle(self) -> ResultHandle:
    """Return result handle to visualization."""

get_aperture_handle_cls abstractmethod 

get_aperture_handle_cls() -> Type[PrivateApertureHandle]

Get backend-specific implementation of aperture handle class.

Source code in src/pygerber/backend/abstract/backend_cls.py 
138
139
140
@abstractmethod
def get_aperture_handle_cls(self) -> Type[PrivateApertureHandle]:
    """Get backend-specific implementation of aperture handle class."""

get_draw_circle_cls abstractmethod 

get_draw_circle_cls() -> Type[DrawCircle]

Get backend-specific implementation of aperture circle component class.

Source code in src/pygerber/backend/abstract/backend_cls.py 
142
143
144
@abstractmethod
def get_draw_circle_cls(self) -> Type[DrawCircle]:
    """Get backend-specific implementation of aperture circle component class."""

get_draw_rectangle_cls abstractmethod 

get_draw_rectangle_cls() -> Type[DrawRectangle]

Get backend-specific implementation of aperture rectangle component class.

Source code in src/pygerber/backend/abstract/backend_cls.py 
146
147
148
@abstractmethod
def get_draw_rectangle_cls(self) -> Type[DrawRectangle]:
    """Get backend-specific implementation of aperture rectangle component class."""

get_draw_polygon_cls abstractmethod 

get_draw_polygon_cls() -> Type[DrawPolygon]

Get backend-specific implementation of aperture polygon component class.

Source code in src/pygerber/backend/abstract/backend_cls.py 
150
151
152
@abstractmethod
def get_draw_polygon_cls(self) -> Type[DrawPolygon]:
    """Get backend-specific implementation of aperture polygon component class."""

get_draw_commands_handle_cls abstractmethod 

get_draw_commands_handle_cls() -> type[DrawCommandsHandle]

Return backend-specific implementation of draw actions handle.

Source code in src/pygerber/backend/abstract/backend_cls.py 
154
155
156
@abstractmethod
def get_draw_commands_handle_cls(self) -> type[DrawCommandsHandle]:
    """Return backend-specific implementation of draw actions handle."""

get_draw_paste_cls abstractmethod 

get_draw_paste_cls() -> type[DrawPaste]

Return backend-specific implementation of draw paste.

Source code in src/pygerber/backend/abstract/backend_cls.py 
158
159
160
@abstractmethod
def get_draw_paste_cls(self) -> type[DrawPaste]:
    """Return backend-specific implementation of draw paste."""

get_draw_region_cls abstractmethod 

get_draw_region_cls() -> type[DrawRegion]

Return backend-specific implementation of draw action region.

Source code in src/pygerber/backend/abstract/backend_cls.py 
162
163
164
@abstractmethod
def get_draw_region_cls(self) -> type[DrawRegion]:
    """Return backend-specific implementation of draw action region."""

get_draw_vector_line_cls abstractmethod 

get_draw_vector_line_cls() -> type[DrawVectorLine]

Return backend-specific implementation of draw action line.

Source code in src/pygerber/backend/abstract/backend_cls.py 
166
167
168
@abstractmethod
def get_draw_vector_line_cls(self) -> type[DrawVectorLine]:
    """Return backend-specific implementation of draw action line."""

get_draw_arc_cls abstractmethod 

get_draw_arc_cls() -> type[DrawArc]

Return backend-specific implementation of draw action arc.

Source code in src/pygerber/backend/abstract/backend_cls.py 
170
171
172
@abstractmethod
def get_draw_arc_cls(self) -> type[DrawArc]:
    """Return backend-specific implementation of draw action arc."""