sketchingpy.shape_struct

  1"""Data structures describing shapes.
  2
  3License:
  4    BSD
  5"""
  6
  7import typing
  8
  9
 10class Line:
 11    """Data structure describing a segment.
 12
 13    Data structure describing a segment which can be a straight line but also a curve like a bezier
 14    curve.
 15    """
 16
 17    def get_destination_x(self) -> float:
 18        """Get the ending horizontal coordinate of this segment.
 19
 20        Returns:
 21            The x coordinate that this segment ends on.
 22        """
 23        raise NotImplementedError('Use implementor.')
 24
 25    def get_destination_y(self) -> float:
 26        """Get the ending vertical coordinate of this segment.
 27
 28        Returns:
 29            The y coordinate that this segment ends on.
 30        """
 31        raise NotImplementedError('Use implementor.')
 32
 33    def get_min_x(self) -> float:
 34        """Get the minimum of the x coordinates in this segment.
 35
 36        Returns:
 37            Minimum x coordinate of this segment.
 38        """
 39        raise NotImplementedError('Use impelentor.')
 40
 41    def get_max_x(self) -> float:
 42        """Get the maximum of the x coordinates in this segment.
 43
 44        Returns:
 45            Maximum x coordinate of this segment.
 46        """
 47        raise NotImplementedError('Use impelentor.')
 48
 49    def get_min_y(self) -> float:
 50        """Get the minimum of the y coordinates in this segment.
 51
 52        Returns:
 53            Minimum y coordinate of this segment.
 54        """
 55        raise NotImplementedError('Use impelentor.')
 56
 57    def get_max_y(self) -> float:
 58        """Get the maximum of the y coordinates in this segment.
 59
 60        Returns:
 61            Maximum y coordinate of this segment.
 62        """
 63        raise NotImplementedError('Use impelentor.')
 64
 65    def get_strategy(self) -> str:
 66        """Get the type of line that this segment represents.
 67
 68        Returns:
 69            Line strategy like "straight" or "bezier" as a string.
 70        """
 71        raise NotImplementedError('Use implementor.')
 72
 73    def get_control_x1(self):
 74        """Get the horizontal coordinate of the first control point.
 75
 76        Returns:
 77            The x coordinate of the first control point.
 78        """
 79        raise NotImplementedError('Not supported by strategy.')
 80
 81    def get_control_y1(self):
 82        """Get the vertical coordinate of the first control point.
 83
 84        Returns:
 85            The y coordinate of the first control point.
 86        """
 87        raise NotImplementedError('Not supported by strategy.')
 88
 89    def get_control_x2(self):
 90        """Get the horizontal coordinate of the second control point.
 91
 92        Returns:
 93            The x coordinate of the second control point.
 94        """
 95        raise NotImplementedError('Not supported by strategy.')
 96
 97    def get_control_y2(self):
 98        """Get the vertical coordinate of the second control point.
 99
100        Returns:
101            The y coordinate of the second control point.
102        """
103        raise NotImplementedError('Not supported by strategy.')
104
105
106class StraightLine(Line):
107    """A segment which is a straight line between two points."""
108
109    def __init__(self, destination_x: float, destination_y: float):
110        """Create a new straight line segmenet.
111
112        Args:
113            destination_x: The vertical location of the end coordinate.
114            destination_y: The horizontal location of the end coordinate.
115        """
116        self._destination_x = destination_x
117        self._destination_y = destination_y
118
119    def get_destination_x(self) -> float:
120        return self._destination_x
121
122    def get_destination_y(self) -> float:
123        return self._destination_y
124
125    def get_min_x(self) -> float:
126        return self._destination_x
127
128    def get_max_x(self) -> float:
129        return self._destination_x
130
131    def get_min_y(self) -> float:
132        return self._destination_y
133
134    def get_max_y(self) -> float:
135        return self._destination_y
136
137    def get_strategy(self) -> str:
138        return 'straight'
139
140
141class BezierLine(Line):
142    """A segment which is a bezier curve between two points."""
143
144    def __init__(self, control_x1: float, control_y1: float, control_x2: float, control_y2: float,
145        destination_x: float, destination_y: float):
146        """Create a new bezier curve.
147
148        Args:
149            control_x1: The horizontal location of the first control point.
150            control_y1: The vertical location of the first control point.
151            control_x2: The horizontal location of the second control point.
152            control_y2: The vertical location of the second control point.
153            destination_x: The vertical location of the end coordinate.
154            destination_y: The horizontal location of the end coordinate.
155        """
156        self._control_x1 = control_x1
157        self._control_y1 = control_y1
158        self._control_x2 = control_x2
159        self._control_y2 = control_y2
160        self._destination_x = destination_x
161        self._destination_y = destination_y
162
163    def get_control_x1(self):
164        return self._control_x1
165
166    def get_control_y1(self):
167        return self._control_y1
168
169    def get_control_x2(self):
170        return self._control_x2
171
172    def get_control_y2(self):
173        return self._control_y2
174
175    def get_destination_x(self):
176        return self._destination_x
177
178    def get_destination_y(self):
179        return self._destination_y
180
181    def get_min_x(self) -> float:
182        return min([
183            self._control_x1,
184            self._control_x2,
185            self._destination_x
186        ])
187
188    def get_max_x(self) -> float:
189        return max([
190            self._control_x1,
191            self._control_x2,
192            self._destination_x
193        ])
194
195    def get_min_y(self) -> float:
196        return min([
197            self._control_y1,
198            self._control_y2,
199            self._destination_y
200        ])
201
202    def get_max_y(self) -> float:
203        return max([
204            self._control_y1,
205            self._control_y2,
206            self._destination_y
207        ])
208
209    def get_strategy(self) -> str:
210        return 'bezier'
211
212
213class Shape:
214    """Structure describing a multi-segement shape."""
215
216    def __init__(self, start_x: float, start_y: float):
217        """Create a new multi-segment shape.
218
219        Args:
220            start_x: The starting x position of the shape.
221            start_y: The starting y position of the shape.
222        """
223        self._start_x = start_x
224        self._start_y = start_y
225        self._closed = False
226        self._finished = False
227        self._segments: typing.List[Line] = []
228
229    def add_line_to(self, x: float, y: float):
230        """Add a straight line to a shape.
231
232        Draw a straight line from the current position to a new destination which is used as the
233        next "current" position.
234
235        Args:
236            x: The x coordinate to which the line should be drawn.
237            y: The y coordinate to which the line should be drawn.
238        """
239        self._assert_not_finished()
240        self._segments.append(StraightLine(x, y))
241
242    def add_bezier_to(self, control_x1: float, control_y1: float, control_x2: float,
243        control_y2: float, destination_x: float, destination_y: float):
244        """Add a bezier curve to a shape.
245
246        Draw a bezier curve from the current position to a new destination which is used as the next
247        "current" position.
248
249        Args:
250            control_x1: The horizontal location of the first control point.
251            control_y1: The vertical location of the first control point.
252            control_x2: The horizontal location of the second control point.
253            control_y2: The vertical location of the second control point.
254            destination_x: The vertical location of the end coordinate.
255            destination_y: The horizontal location of the end coordinate.
256        """
257        self._assert_not_finished()
258        self._segments.append(BezierLine(
259            control_x1,
260            control_y1,
261            control_x2,
262            control_y2,
263            destination_x,
264            destination_y
265        ))
266
267    def get_start_x(self) -> float:
268        """Retrieve the first x coordinate of this shape.
269
270        Get the horizontal coordinate from which the first segment draws.
271
272        Returns:
273            The starting x coordinate.
274        """
275        return self._start_x
276
277    def get_start_y(self) -> float:
278        """Retrieve the first y coordinate of this shape.
279
280        Get the vertical coordinate from which the first segment draws.
281
282        Returns:
283            The starting y coordinate.
284        """
285        return self._start_y
286
287    def get_segments(self) -> typing.Iterable[Line]:
288        """Retrieve shape segments.
289
290        Retrieve objects describing each of the segments in a shape.
291
292        Returns:
293            Segements in this shape.
294        """
295        return self._segments
296
297    def get_is_finished(self) -> bool:
298        """Determine if a shape is finished.
299
300        Determine if the shape is finished so can be drawn. Returns true if finished (can be drawn)
301        and false otherwise (still building). A shape cannot be drawn until it is finished which can
302        be accomplished by either calling end or close.
303
304        Returns:
305            True if finished and false otherwise.
306        """
307        return self._finished
308
309    def end(self):
310        """Draw a shape.
311
312        Draw a shape which consists of multiple line or curve segments and which can be either open
313        (stroke only) or closed (can be filled).
314        """
315        self._assert_not_finished()
316        self._finished = True
317        self._closed = False
318
319    def close(self):
320        """Add a straight line to the starting coordinate.
321
322        Add a line in the shape from the current position to the start position, marking the shape
323        as finished and closed which allows it to be filled.
324        """
325        self._assert_not_finished()
326        self._finished = True
327        self._closed = True
328
329    def get_is_closed(self) -> bool:
330        """Determine if a shape can be filled.
331
332        Determine if the shape is closed so can be filled. Returns true if closed (can be filled)
333        and false otherwise.
334
335        Returns:
336            True if closed and false otherwise.
337        """
338        self._assert_finished()
339        return self._closed
340
341    def get_min_x(self):
342        """Determine the minimum x coordinate of a shape.
343
344        Determine the minimum x coordinate (relative to start position) that this shape may reach
345        to. This includes bezier control points but does not try to include stroke weight in its
346        calculation.
347
348        Returns:
349            Minimum x coordinate.
350        """
351        self._assert_finished()
352        return min([self._start_x] + [x.get_min_x() for x in self._segments])
353
354    def get_max_x(self):
355        """Determine the maximum x coordinate of a shape.
356
357        Determine the maximum x coordinate (relative to start position) that this shape may reach
358        to. This includes bezier control points but does not try to include stroke weight in its
359        calculation.
360
361        Returns:
362            Maximum x coordinate.
363        """
364        self._assert_finished()
365        return max([self._start_x] + [x.get_max_x() for x in self._segments])
366
367    def get_min_y(self):
368        """Determine the minimum y coordinate of a shape.
369
370        Determine the minimum y coordinate (relative to start position) that this shape may reach
371        to. This includes bezier control points but does not try to include stroke weight in its
372        calculation.
373
374        Returns:
375            Minimum y coordinate.
376        """
377        self._assert_finished()
378        return min([self._start_y] + [x.get_min_y() for x in self._segments])
379
380    def get_max_y(self):
381        """Determine the maximum y coordinate of a shape.
382
383        Determine the maximum y coordinate (relative to start position) that this shape may reach
384        to. This includes bezier control points but does not try to include stroke weight in its
385        calculation.
386
387        Returns:
388            Maximum y coordinate.
389        """
390        self._assert_finished()
391        return max([self._start_y] + [x.get_max_y() for x in self._segments])
392
393    def _assert_not_finished(self):
394        if self._finished:
395            raise RuntimeError('Whoops! This shape is already finished.')
396
397    def _assert_finished(self):
398        if not self._finished:
399            raise RuntimeError('Whoops! This shape is not yet finished.')