Merge pull request #166 from chris-greening/add-noise-feature

Implementing add noise method

Author: chris-greening

setup.py

@@ -7,7 +7,7 @@
 
 setuptools.setup(
     name="spyrograph",
-    version="0.28.1",
+    version="0.29.0",
     author="Chris Greening",
     author_email="[email protected]",
     description="Library for drawing spirographs in Python",

spyrograph/core/_cycloid.py

@@ -17,9 +17,9 @@ def __init__(
             self, R: Number, r: Number, thetas: List[Number] = None,
             theta_start: Number = None, theta_stop: Number = None,
             theta_step: Number = None, origin: Tuple[Number, Number] = (0, 0),
-            orientation: Number = 0
+            orientation: Number = 0, noise: Number = None
         ) -> None:
-        super().__init__(R, r, r, thetas, theta_start, theta_stop, theta_step, origin, orientation)
+        super().__init__(R, r, r, thetas, theta_start, theta_stop, theta_step, origin, orientation, noise)
         # pylint: disable=pointless-string-statement
         """Instantiate a cycloid curve from given input parameters. A
         hypocycloid is a curve drawn by tracing a point from a circle as it

spyrograph/core/_trochoid.py

@@ -34,7 +34,7 @@ def __init__(
             self, R: Number, r: Number, d: Number, thetas: List[Number] = None,
             theta_start: Number = None, theta_stop: Number = None,
             theta_step: Number = None, origin: Tuple[Number, Number] = (0, 0),
-            orientation: Number = 0
+            orientation: Number = 0, noise: List["np.array"] = None
         ) -> None:
         """Model of a trochoid curve from given input parameters. A trochoid is
         a curve drawn by tracing a point from a circle as it rolls around the
@@ -76,6 +76,7 @@ def __init__(
         self.thetas = _validate_theta(thetas, theta_start, theta_stop, theta_step)
         self.origin = origin
         self.orientation = orientation
+        self.noise = noise
 
         self._validate_inputs()
         self._calculate_path()
@@ -109,15 +110,17 @@ def translate(self, x: Number = 0, y: Number = 0) -> "_Trochoid":
                 d=self.d,
                 thetas=self.thetas,
                 origin=(self.origin[0]+x, self.origin[1]+y),
-                orientation=self.orientation
+                orientation=self.orientation,
+                noise=self.noise
             )
         except TypeError:
             translated_shape = self.__class__(
                 R=self.R,
                 r=self.r,
                 thetas=self.thetas,
                 origin=(self.origin[0]+x, self.origin[1]+y),
-                orientation=self.orientation
+                orientation=self.orientation,
+                noise=self.noise
             )
         return translated_shape
 
@@ -157,15 +160,18 @@ def scale(self, factor: Number) -> Union["_Trochoid", "_Cycloid"]:
                 d=self.d*factor,
                 thetas=self.thetas,
                 origin=self.origin,
-                orientation=self.orientation
+                orientation=self.orientation,
+                noise=[self.noise[0]*factor, self.noise[1]*factor]
             )
         except TypeError:
             scaled_shape = self.__class__(
                 R=self.R*factor,
                 r=self.r*factor,
                 thetas=self.thetas,
                 origin=self.origin,
-                orientation=self.orientation
+                orientation=self.orientation,
+                noise=[self.noise[0]*factor, self.noise[1]*factor]
+
             )
         return scaled_shape
 
@@ -205,18 +211,45 @@ def rotate(self, angle: float, degrees: bool = False):
                 d=self.d,
                 thetas=self.thetas,
                 origin=self.origin,
-                orientation=self.orientation + angle
+                orientation=self.orientation + angle,
+                noise=self.noise
             )
         except TypeError:
             rotated_shape = self.__class__(
                 R=self.R,
                 r=self.r,
                 thetas=self.thetas,
                 origin=self.origin,
-                orientation=self.orientation + angle
+                orientation=self.orientation + angle,
+                noise=self.noise
             )
         return rotated_shape
 
+    def add_noise(self, x_scale: Number = 0, y_scale: Number = 0) -> Union["_Trochoid", "_Cycloid"]:
+        x_noise = np.random.normal(0, x_scale, size=len(self.x))
+        y_noise = np.random.normal(0, y_scale, size=len(self.y))
+        noise = [x_noise, y_noise]
+        try:
+            noisy_shape = self.__class__(
+                R=self.R,
+                r=self.r,
+                d=self.d,
+                thetas=self.thetas,
+                origin=self.origin,
+                orientation=self.orientation,
+                noise=noise
+            )
+        except TypeError:
+            noisy_shape = self.__class__(
+                R=self.R,
+                r=self.r,
+                thetas=self.thetas,
+                origin=self.origin,
+                orientation=self.orientation,
+                noise=noise
+            )
+        return noisy_shape
+
     def plot(self, **kwargs) -> Tuple["matplotlib.matplotlib.Figure", "matplotlib.axes._axes.Axes"]:
         """
         Plot the shape and return the associated matplotlib Figure and Axes objects.
@@ -642,12 +675,19 @@ def _calculate_path(self) -> None:
         self.x, self.y = _apply_rotation(self.x, self.y, self.orientation)
         self.x += self.origin[0]
         self.y += self.origin[1]
+        if self.noise is None:
+            self.noise = [
+                np.zeros(len(self.x)),
+                np.zeros(len(self.y))
+            ]
+        # self.noise = _apply_rotation(self.noise[0], self.noise[1], self.orientation)
+        self.x += self.noise[0]
+        self.y += self.noise[1]
         self.min_x = min(self.x)
         self.max_x = max(self.x)
         self.min_y = min(self.y)
         self.max_y = max(self.y)
-
-        self.coords = list(zip(self.x, self.y, self.thetas))
+        self.coords = list(zip(self.x + self.noise[0], self.y+self.noise[1], self.thetas))
 
     def _validate_inputs(self) -> None:
         """Validate input parameters"""
@@ -796,7 +836,7 @@ def _draw_circle(
             y: The y-coordinate of the center of the circle.
             radius: The radius of the circle to be drawn.
 
-            The circle drawn, uses steps = 200 that defines the smoothness of the circle. 
+            The circle drawn, uses steps = 200 that defines the smoothness of the circle.
         """
         t.up()
         t.seth(0)

tests/_trochoid.py

@@ -74,6 +74,11 @@ def test_dunder_repr_values(self, instance):
         assert f"r={instance.r}" in repr_val
         assert f"d={instance.d}" in repr_val
 
+    def test_add_noise_return_instance_is_same_class(self, instance):
+        """Test that the return instance is from the same class"""
+        noisy_instance = instance.add_noise(x_scale=2, y_scale=2)
+        assert noisy_instance.__class__ is instance.__class__
+
     def test_scale_return_instance_is_same_class(self, instance):
         """Test that the return instance is from the same class"""
         scaled_instance = instance.scale(factor=2)
@@ -101,43 +106,62 @@ def test_scale_factor_parameters_smaller(self, instance):
         assert smaller_scaled_instance.d == instance.d*.5
         assert (smaller_scaled_instance.thetas == instance.thetas).all()
 
+    def test_add_noise_origin_is_preserved(self, thetas):
+        if issubclass(self.class_name, _Cycloid):
+            shape = self.class_name(
+                R=100,
+                r=200,
+                thetas=thetas,
+                origin=(100,100)
+            )
+        elif issubclass(self.class_name, _Trochoid):
+            shape = self.class_name(
+                R=100,
+                r=200,
+                d=300,
+                thetas=thetas,
+                origin=(100, 100)
+            )
+        noisy_shape = shape.add_noise(x_scale=10, y_scale=10)
+        assert noisy_shape.origin == shape.origin
+
     def test_scale_origin_is_preserved(self, thetas):
         if issubclass(self.class_name, _Cycloid):
-            translated_shape = self.class_name(
+            shape = self.class_name(
                 R=100,
                 r=200,
                 thetas=thetas,
                 origin=(100,100)
             )
         elif issubclass(self.class_name, _Trochoid):
-            translated_shape = self.class_name(
+            shape = self.class_name(
                 R=100,
                 r=200,
                 d=300,
                 thetas=thetas,
                 origin=(100, 100)
             )
-        scaled_shape = translated_shape.scale(2)
-        assert scaled_shape.origin == translated_shape.origin
+        scaled_shape = shape.scale(2)
+        assert scaled_shape.origin == shape.origin
 
     def test_rotate_origin_is_preserved(self, thetas):
         if issubclass(self.class_name, _Cycloid):
-            translated_shape = self.class_name(
+            shape = self.class_name(
                 R=100,
                 r=200,
                 thetas=thetas,
                 origin=(100, 100)
             )
         elif issubclass(self.class_name, _Trochoid):
-            translated_shape = self.class_name(
+            shape = self.class_name(
                 R=100,
                 r=200,
                 d=300,
                 thetas=thetas,
                 origin=(100, 100)
             )
-        rotated_shape = translated_shape.rotate(2)
-        assert rotated_shape.origin == rotated_shape.origin
+        rotated_shape = shape.rotate(2)
+        assert rotated_shape.origin == shape.origin
 
     def test_create_range_theta_inputs(self, thetas):
         R = 5