Added rotation code to image so it doesn't expose internals anymore

Author: kbialowas

Lib/turtle.py

@@ -860,26 +860,140 @@ class TurtleGraphicsError(Exception):
     """Some TurtleGraphics Error
     """
 
-class BaseShapeDrawer(object):
-    """Base class that allows for taking over controll of drawing process
-    for custom turtle shapes
-    """
-    def __init__(self, screen):
-        self.screen = screen
+class TransformableImage(object):
+    """Class that handles rotation of image based turtle shape"""
+    def __init__(self, screen, image):
+        assert(isinstance(image, TK.PhotoImage))
+        self._screen = screen
+        self._originalImage = image
+        self._rotationCenter = (image.width() / 2, image.height() / 2)
+        self._tkPhotoImage = image.copy()
+        self._currentOrientation = (1.0, 0)
+        self._currentTilt = 0.0
+        self._transformMatrix = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+        self._item = screen._createimage(self._tkPhotoImage)
+
     def clone(self, *args, **kwargs):
-        return self.__class__(self.screen, *args, **kwargs)
-    def draw(self, position, orientation, pen_color, fill_color, transform, pen_size):
-        pass
+        return self.__class__(self._screen, self._originalImage, *args, **kwargs)
+
+    def _transform_coordinates(self, x, y):
+        m = self._transformMatrix
+        return (m[0][0] * x + m[0][1] * y + m[0][2],
+                m[1][0] * x + m[1][1] * y + m[1][2])
+
+    def _get_new_bounding_box(self):
+        w, h = self._originalImage.width(), self._originalImage.height()
+        c = [self._transform_coordinates(x, y)
+             for x, y in [(0, 0), (w, 0), (w, h), (0, h)]]
+        min_x = min(x for x, _ in c)
+        min_y = min(y for _, y in c)
+        max_x = max(x for x, _ in c)
+        max_y = max(y for _, y in c)
+        return {
+            "min_x": min_x,
+            "min_y": min_y,
+            "max_x": max_x,
+            "max_y": max_y,
+            "width": math.ceil(max_x - min_x),
+            "height": math.ceil(max_y - min_y)
+        }
+
+    def _interpolate_color(self, x, y):
+        """Interpolates color based on neighboring pixels."""
+        x_floor, y_floor = int(x), int(y)
+        x_ceil, y_ceil = math.ceil(x), math.ceil(y)
+
+        if x_floor == x_ceil and y_floor == y_ceil:
+            return self._originalImage.get(x_floor, y_floor)
+
+        if x_floor == x_ceil:
+            c1 = self._originalImage.get(x_floor, y_floor)
+            c2 = self._originalImage.get(x_floor, y_ceil)
+            alpha = y - y_floor
+            return (
+                int(c1[0] * (1 - alpha) + c2[0] * alpha),
+                int(c1[1] * (1 - alpha) + c2[1] * alpha),
+                int(c1[2] * (1 - alpha) + c2[2] * alpha),
+            )
+
+        if y_floor == y_ceil:
+            c1 = self._originalImage.get(x_floor, y_floor)
+            c2 = self._originalImage.get(x_ceil, y_floor)
+            alpha = x - x_floor
+            return (
+                int(c1[0] * (1 - alpha) + c2[0] * alpha),
+                int(c1[1] * (1 - alpha) + c2[1] * alpha),
+                int(c1[2] * (1 - alpha) + c2[2] * alpha),
+            )
+
+        c11 = self._originalImage.get(x_floor, y_floor)
+        c12 = self._originalImage.get(x_floor, y_ceil)
+        c21 = self._originalImage.get(x_ceil, y_floor)
+        c22 = self._originalImage.get(x_ceil, y_ceil)
+
+        alpha_x = x - x_floor
+        alpha_y = y - y_floor
+
+        c1 = (
+            int(c11[0] * (1 - alpha_y) + c12[0] * alpha_y),
+            int(c11[1] * (1 - alpha_y) + c12[1] * alpha_y),
+            int(c11[2] * (1 - alpha_y) + c12[2] * alpha_y),
+        )
+        c2 = (
+            int(c21[0] * (1 - alpha_y) + c22[0] * alpha_y),
+            int(c21[1] * (1 - alpha_y) + c22[1] * alpha_y),
+            int(c21[2] * (1 - alpha_y) + c22[2] * alpha_y),
+        )
+
+        return (
+            int(c1[0] * (1 - alpha_x) + c2[0] * alpha_x),
+            int(c1[1] * (1 - alpha_x) + c2[1] * alpha_x),
+            int(c1[2] * (1 - alpha_x) + c2[2] * alpha_x),
+        )
+
+    def draw(self, position, orientation, tilt):
+        if (self._currentOrientation != orientation or self._currentTilt != tilt):
+            angle = math.atan2(orientation[1], orientation[0]) + tilt
+            cos_theta = math.cos(angle)
+            sin_theta = math.sin(angle)
+            x, y = self._rotationCenter
+            self._transformMatrix = [
+                [cos_theta, -sin_theta, x * (1 - cos_theta) + y * sin_theta],
+                [sin_theta, cos_theta, y * (1 - cos_theta) - x * sin_theta],
+                [0, 0, 1]
+            ]
+            bounding_box = self._get_new_bounding_box()
+            offset_x = bounding_box["min_x"] * -1
+            offset_y = bounding_box["min_y"] * -1
+            self._tkPhotoImage = TK.PhotoImage(width=bounding_box["width"], height=bounding_box["height"])
+
+            for new_y in range(bounding_box["height"]):
+                for new_x in range(bounding_box["width"]):
+                    original_x, original_y = self._transform_coordinates(new_x - offset_x, new_y - offset_y)
+
+                    if 0 <= original_x < self._originalImage.width() - 1 and 0 <= original_y < self._originalImage.height() - 1:
+                        rgb = self._interpolate_color(original_x, original_y)
+                        is_transparent = self._originalImage.transparency_get(int(original_x), int(original_y))
+                        self._tkPhotoImage.put("#{:02x}{:02x}{:02x}".format(rgb[0], rgb[1], rgb[2]), (new_x, new_y))
+                        self._tkPhotoImage.transparency_set(new_x, new_y, is_transparent)
+                    elif 0 <= int(original_x) < self._originalImage.width() and 0 <= int(original_y) < self._originalImage.height():
+                        rgb = self._originalImage.get(int(original_x),int(original_y))
+                        is_transparent = self._originalImage.transparency_get(int(original_x), int(original_y))
+                        self._tkPhotoImage.put("#{:02x}{:02x}{:02x}".format(rgb[0], rgb[1], rgb[2]), (new_x, new_y))
+                        self._tkPhotoImage.transparency_set(new_x, new_y, is_transparent)
+            self._currentOrientation = orientation
+            self._currentTilt = tilt
+        self._screen._drawimage(self._item, position, self._tkPhotoImage)
+
     def delete(self):
-        pass
+        self._screen._delete(self._item)
 
 class Shape(object):
     """Data structure modeling shapes.
 
-    attribute _type is one of "polygon", "image", "compound", "shape_drawer"
+    attribute _type is one of "polygon", "image", "compound", "transformable_image"
     attribute _data is - depending on _type a poygon-tuple,
-    an image, a list constructed using the addcomponent method or a subclass of
-    BaseShapeDrawer.
+    an image or a list constructed using the addcomponent method
     """
     def __init__(self, type_, data=None):
         self._type = type_
@@ -888,8 +1002,8 @@ def __init__(self, type_, data=None):
                 data = tuple(data)
         elif type_ == "image":
             assert(isinstance(data, TK.PhotoImage))
-        elif type_ == "shape_drawer":
-            assert(issubclass(data, BaseShapeDrawer))
+        elif type_ == "transformable_image":
+            assert(isinstance(data, TK.PhotoImage))
         elif type_ == "compound":
             data = []
         else:
@@ -1126,7 +1240,7 @@ def register_shape(self, name, shape=None):
             of pairs of coordinates. Installs the corresponding
             polygon shape
         (4) name is an arbitrary string and shape is a
-            (compound or shape_drawer) Shape object. Installs the corresponding
+            (compound or transformable_image) Shape object. Installs the corresponding
             shape.
         To use a shape, you have to issue the command shape(shapename).
 
@@ -2574,7 +2688,7 @@ def _setshape(self, shapeIndex):
         elif self._type == "compound":
             for item in self._item:
                 screen._delete(item)
-        elif self._type == "shape_drawer":
+        elif self._type == "transformable_image":
             del self._item
 
         self._type = screen._shapes[shapeIndex]._type
@@ -2587,8 +2701,8 @@ def _setshape(self, shapeIndex):
         elif self._type == "compound":
             self._item = [screen._createpoly() for item in
                                           screen._shapes[shapeIndex]._data]
-        elif self._type == "shape_drawer":
-            self._item = screen._shapes[self.shapeIndex]._data(screen)
+        elif self._type == "transformable_image":
+            self._item = TransformableImage(screen, screen._shapes[self.shapeIndex]._data)
 
 
 class RawTurtle(TPen, TNavigator):
@@ -2876,8 +2990,8 @@ def clone(self):
         elif ttype == "compound":
             q.turtle._item = [screen._createpoly() for item in
                               screen._shapes[self.turtle.shapeIndex]._data]
-        elif ttype == "shape_drawer":
-            q.turtle._item = screen._shapes[self.turtle.shapeIndex]._data(screen)
+        elif ttype == "transformable_image":
+            q.turtle._item = TransformableImage(screen, screen._shapes[self.turtle.shapeIndex]._data)
         q.currentLineItem = screen._createline()
         q._update()
         return q
@@ -3134,10 +3248,8 @@ def _drawturtle(self):
                     poly = self._polytrafo(self._getshapepoly(poly, True))
                     screen._drawpoly(item, poly, fill=self._cc(fc),
                                      outline=self._cc(oc), width=self._outlinewidth, top=True)
-            elif ttype == "shape_drawer":
-                titem.draw(self._position, self._orient, pen_color = self._pencolor,
-                          fill_color = self._fillcolor, transform = self._shapetrafo,
-                          pen_size = self._pensize)
+            elif ttype == "transformable_image":
+                titem.draw(self._position, self._orient, self._tilt)
         else:
             if self._hidden_from_screen:
                 return
@@ -3194,11 +3306,9 @@ def stamp(self):
                 poly = self._polytrafo(self._getshapepoly(poly, True))
                 screen._drawpoly(item, poly, fill=self._cc(fc),
                                  outline=self._cc(oc), width=self._outlinewidth, top=True)
-        elif ttype == "shape_drawer":
+        elif ttype == "transformable_image":
             stitem = self.turtle._item.clone()
-            stitem.draw(self._position, self._orient, pen_color = self._pencolor,
-                          fill_color = self._fillcolor, transform = self._shapetrafo,
-                          pen_size = self._pensize)
+            stitem.draw(self._position, self._orient, self._tilt)
         self.stampItems.append(stitem)
         self.undobuffer.push(("stamp", stitem))
         return stitem
@@ -3210,7 +3320,7 @@ def _clearstamp(self, stampid):
             if isinstance(stampid, tuple):
                 for subitem in stampid:
                     self.screen._delete(subitem)
-            elif not isinstance(stampid, BaseShapeDrawer):
+            elif not isinstance(stampid, TransformableImage):
                 self.screen._delete(stampid)
             self.stampItems.remove(stampid)
 
@@ -3224,7 +3334,7 @@ def _clearstamp(self, stampid):
             if index <= buf.ptr:
                 buf.ptr = (buf.ptr - 1) % buf.bufsize
             buf.buffer.insert((buf.ptr+1)%buf.bufsize, [None])
-        if isinstance(stampid, BaseShapeDrawer):
+        if isinstance(stampid, TransformableImage):
             stampid.delete()
 
     def clearstamp(self, stampid):