Refactor primitive unit conversion and add regression coverage to tests

2 files changed, 414 insertions, 280 deletions

diff --git a/gerber/primitives.py b/gerber/primitives.py
index 4c027d2..bdd49f7 100644
--- a/gerber/primitives.py
+++ b/gerber/primitives.py
@@ -40,6 +40,7 @@ class Primitive(object):
         self.level_polarity = level_polarity

         self.rotation = rotation

         self.units = units

+        self._to_convert = list()

 

     def bounding_box(self):

         """ Calculate bounding box

@@ -52,10 +53,39 @@ class Primitive(object):
                                   'implemented in subclass')

 

     def to_inch(self):

-        pass

+        if self.units == 'metric':

+            self.units = 'inch'

+            for attr, value in [(attr, getattr(self, attr)) for attr in self._to_convert]:

+                if hasattr(value, 'to_inch'):

+                    value.to_inch()

+                else:

+                    try:

+                        if len(value) > 1:

+                            if isinstance(value[0], tuple):

+                                setattr(self, attr, [tuple(map(inch, point)) for point in value])

+                            else:

+                                setattr(self, attr, tuple(map(inch, value)))

+                    except:

+                        if value is not None:

+                            setattr(self, attr, inch(value))

+

 

     def to_metric(self):

-        pass

+        if self.units == 'inch':

+            self.units = 'metric'

+            for attr, value in [(attr, getattr(self, attr)) for attr in self._to_convert]:

+                if hasattr(value, 'to_metric'):

+                    value.to_metric()

+                else:

+                    try:

+                        if len(value) > 1:

+                            if isinstance(value[0], tuple):

+                                setattr(self, attr, [tuple(map(metric, point)) for point in value])

+                            else:

+                                setattr(self, attr, tuple(map(metric, value)))

+                    except:

+                        if value is not None:

+                            setattr(self, attr, metric(value))

 

     def offset(self, x_offset=0, y_offset=0):

         pass

@@ -72,6 +102,7 @@ class Line(Primitive):
         self.start = start

         self.end = end

         self.aperture = aperture

+        self._to_convert = ['start', 'end', 'aperture']

 

     @property

     def angle(self):

@@ -141,20 +172,6 @@ class Line(Primitive):
                 return (start_ll, start_lr, start_ur, end_ur, end_ul, end_ll)

 

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.aperture.to_inch()

-            self.start = tuple(map(inch, self.start))

-            self.end = tuple(map(inch, self.end))

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.aperture.to_metric()

-            self.start = tuple(map(metric, self.start))

-            self.end = tuple(map(metric, self.end))

-

     def offset(self, x_offset=0, y_offset=0):

         self.start = tuple(map(add, self.start, (x_offset, y_offset)))

         self.end = tuple(map(add, self.end, (x_offset, y_offset)))

@@ -170,6 +187,7 @@ class Arc(Primitive):
         self.center = center

         self.direction = direction

         self.aperture = aperture

+        self._to_convert = ['start', 'end', 'center', 'aperture']

 

     @property

     def radius(self):

@@ -236,22 +254,6 @@ class Arc(Primitive):
         max_y = max(y) + self.aperture.radius

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.aperture.to_inch()

-            self.start = tuple(map(inch, self.start))

-            self.end = tuple(map(inch, self.end))

-            self.center = tuple(map(inch, self.center))

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.aperture.to_metric()

-            self.start = tuple(map(metric, self.start))

-            self.end = tuple(map(metric, self.end))

-            self.center = tuple(map(metric, self.center))

-

     def offset(self, x_offset=0, y_offset=0):

         self.start = tuple(map(add, self.start, (x_offset, y_offset)))

         self.end = tuple(map(add, self.end, (x_offset, y_offset)))

@@ -266,6 +268,7 @@ class Circle(Primitive):
         validate_coordinates(position)

         self.position = position

         self.diameter = diameter

+        self._to_convert = ['position', 'diameter']

 

     @property

     def radius(self):

@@ -279,20 +282,6 @@ class Circle(Primitive):
         max_y = self.position[1] + self.radius

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            if self.position is not None:

-                self.position = tuple(map(inch, self.position))

-            self.diameter = inch(self.diameter)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            if self.position is not None:

-                self.position = tuple(map(metric, self.position))

-            self.diameter = metric(self.diameter)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

@@ -306,13 +295,8 @@ class Ellipse(Primitive):
         self.position = position

         self.width = width

         self.height = height

-        # Axis-aligned width and height

-        ux = (self.width / 2.) * math.cos(math.radians(self.rotation))

-        uy = (self.width / 2.) * math.sin(math.radians(self.rotation))

-        vx = (self.height / 2.) * math.cos(math.radians(self.rotation) + (math.pi / 2.))

-        vy = (self.height / 2.) * math.sin(math.radians(self.rotation) + (math.pi / 2.))

-        self._abs_width = 2 * math.sqrt((ux * ux) + (vx * vx))

-        self._abs_height = 2 * math.sqrt((uy * uy) + (vy * vy))

+        self._to_convert = ['position', 'width', 'height']

+

 

     @property

     def bounding_box(self):

@@ -322,23 +306,21 @@ class Ellipse(Primitive):
         max_y = self.position[1] + (self._abs_height / 2.0)

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.width = inch(self.width)

-            self.height = inch(self.height)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.width = metric(self.width)

-            self.height = metric(self.height)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

+    @property

+    def _abs_width(self):

+        ux = (self.width / 2.) * math.cos(math.radians(self.rotation))

+        vx = (self.height / 2.) * math.cos(math.radians(self.rotation) + (math.pi / 2.))

+        return 2 * math.sqrt((ux * ux) + (vx * vx))

+    

+    @property

+    def _abs_height(self):

+        uy = (self.width / 2.) * math.sin(math.radians(self.rotation))

+        vy = (self.height / 2.) * math.sin(math.radians(self.rotation) + (math.pi / 2.))

+        return 2 * math.sqrt((uy * uy) + (vy * vy))

+

 

 class Rectangle(Primitive):

     """

@@ -349,11 +331,8 @@ class Rectangle(Primitive):
         self.position = position

         self.width = width

         self.height = height

-        # Axis-aligned width and height

-        self._abs_width = (math.cos(math.radians(self.rotation)) * self.width +

-                           math.sin(math.radians(self.rotation)) * self.height)

-        self._abs_height = (math.cos(math.radians(self.rotation)) * self.height +

-                            math.sin(math.radians(self.rotation)) * self.width)

+        self._to_convert = ['position', 'width', 'height']

+        

 

     @property

     def lower_left(self):

@@ -373,23 +352,18 @@ class Rectangle(Primitive):
         max_y = self.upper_right[1]

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.width = inch(self.width)

-            self.height = inch(self.height)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.width = metric(self.width)

-            self.height = metric(self.height)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

+    @property

+    def _abs_width(self):

+        return (math.cos(math.radians(self.rotation)) * self.width +

+                math.sin(math.radians(self.rotation)) * self.height)

+    @property

+    def _abs_height(self):

+        return (math.cos(math.radians(self.rotation)) * self.height +

+                math.sin(math.radians(self.rotation)) * self.width)

+        

 

 class Diamond(Primitive):

     """

@@ -400,11 +374,7 @@ class Diamond(Primitive):
         self.position = position

         self.width = width

         self.height = height

-        # Axis-aligned width and height

-        self._abs_width = (math.cos(math.radians(self.rotation)) * self.width +

-                           math.sin(math.radians(self.rotation)) * self.height)

-        self._abs_height = (math.cos(math.radians(self.rotation)) * self.height +

-                            math.sin(math.radians(self.rotation)) * self.width)

+        self._to_convert = ['position', 'width', 'height']

 

     @property

     def lower_left(self):

@@ -424,23 +394,18 @@ class Diamond(Primitive):
         max_y = self.upper_right[1]

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.width = inch(self.width)

-            self.height = inch(self.height)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.width = metric(self.width)

-            self.height = metric(self.height)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

+    @property

+    def _abs_width(self):

+        return (math.cos(math.radians(self.rotation)) * self.width +

+                math.sin(math.radians(self.rotation)) * self.height)

+    @property

+    def _abs_height(self):

+        return (math.cos(math.radians(self.rotation)) * self.height +

+                math.sin(math.radians(self.rotation)) * self.width)

+

 

 class ChamferRectangle(Primitive):

     """

@@ -453,11 +418,7 @@ class ChamferRectangle(Primitive):
         self.height = height

         self.chamfer = chamfer

         self.corners = corners

-        # Axis-aligned width and height

-        self._abs_width = (math.cos(math.radians(self.rotation)) * self.width +

-                           math.sin(math.radians(self.rotation)) * self.height)

-        self._abs_height = (math.cos(math.radians(self.rotation)) * self.height +

-                            math.sin(math.radians(self.rotation)) * self.width)

+        self._to_convert = ['position', 'width', 'height', 'chamfer']

 

     @property

     def lower_left(self):

@@ -477,25 +438,17 @@ class ChamferRectangle(Primitive):
         max_y = self.upper_right[1]

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.width = inch(self.width)

-            self.height = inch(self.height)

-            self.chamfer = inch(self.chamfer)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.width = metric(self.width)

-            self.height = metric(self.height)

-            self.chamfer = metric(self.chamfer)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

+    @property

+    def _abs_width(self):

+        return (math.cos(math.radians(self.rotation)) * self.width +

+                math.sin(math.radians(self.rotation)) * self.height)

+    @property

+    def _abs_height(self):

+        return (math.cos(math.radians(self.rotation)) * self.height +

+                math.sin(math.radians(self.rotation)) * self.width)

 

 class RoundRectangle(Primitive):

     """

@@ -508,11 +461,7 @@ class RoundRectangle(Primitive):
         self.height = height

         self.radius = radius

         self.corners = corners

-        # Axis-aligned width and height

-        self._abs_width = (math.cos(math.radians(self.rotation)) * self.width +

-                           math.sin(math.radians(self.rotation)) * self.height)

-        self._abs_height = (math.cos(math.radians(self.rotation)) * self.height +

-                            math.sin(math.radians(self.rotation)) * self.width)

+        self._to_convert = ['position', 'width', 'height', 'radius']

 

     @property

     def lower_left(self):

@@ -532,25 +481,17 @@ class RoundRectangle(Primitive):
         max_y = self.upper_right[1]

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.width = inch(self.width)

-            self.height = inch(self.height)

-            self.radius = inch(self.radius)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.width = metric(self.width)

-            self.height = metric(self.height)

-            self.radius = metric(self.radius)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

+    @property

+    def _abs_width(self):

+        return (math.cos(math.radians(self.rotation)) * self.width +

+                math.sin(math.radians(self.rotation)) * self.height)

+    @property

+    def _abs_height(self):

+        return (math.cos(math.radians(self.rotation)) * self.height +

+                math.sin(math.radians(self.rotation)) * self.width)

 

 class Obround(Primitive):

     """

@@ -561,11 +502,7 @@ class Obround(Primitive):
         self.position = position

         self.width = width

         self.height = height

-        # Axis-aligned width and height

-        self._abs_width = (math.cos(math.radians(self.rotation)) * self.width +

-                           math.sin(math.radians(self.rotation)) * self.height)

-        self._abs_height = (math.cos(math.radians(self.rotation)) * self.height +

-                            math.sin(math.radians(self.rotation)) * self.width)

+        self._to_convert = ['position', 'width', 'height']

 

     @property

     def lower_left(self):

@@ -607,23 +544,17 @@ class Obround(Primitive):
                             self.height)

         return {'circle1': circle1, 'circle2': circle2, 'rectangle': rect}

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.width = inch(self.width)

-            self.height = inch(self.height)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.width = metric(self.width)

-            self.height = metric(self.height)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

+    @property

+    def _abs_width(self):

+        return (math.cos(math.radians(self.rotation)) * self.width +

+                math.sin(math.radians(self.rotation)) * self.height)

+    @property

+    def _abs_height(self):

+        return (math.cos(math.radians(self.rotation)) * self.height +

+                math.sin(math.radians(self.rotation)) * self.width)

 

 class Polygon(Primitive):

     """

@@ -634,6 +565,7 @@ class Polygon(Primitive):
         self.position = position

         self.sides = sides

         self.radius = radius

+        self._to_convert = ['position', 'radius']

 

     @property

     def bounding_box(self):

@@ -643,18 +575,6 @@ class Polygon(Primitive):
         max_y = self.position[1] + self.radius

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.radius = inch(self.radius)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.radius = metric(self.radius)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

@@ -665,6 +585,7 @@ class Region(Primitive):
     def __init__(self, points, **kwargs):

         super(Region, self).__init__(**kwargs)

         self.points = points

+        self._to_convert = ['points']

 

     @property

     def bounding_box(self):

@@ -675,16 +596,6 @@ class Region(Primitive):
         max_y = max(y_list)

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.points = [tuple(map(inch, point)) for point in self.points]

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.points = [tuple(map(metric, point)) for point in self.points]

-

     def offset(self, x_offset=0, y_offset=0):

         self.points = [tuple(map(add, point, (x_offset, y_offset)))

                        for point in self.points]

@@ -698,6 +609,7 @@ class RoundButterfly(Primitive):
         validate_coordinates(position)

         self.position = position

         self.diameter = diameter

+        self._to_convert = ['position', 'diameter']

 

     @property

     def radius(self):

@@ -711,18 +623,6 @@ class RoundButterfly(Primitive):
         max_y = self.position[1] + self.radius

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.diameter = inch(self.diameter)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.diameter = metric(self.diameter)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

@@ -735,6 +635,7 @@ class SquareButterfly(Primitive):
         validate_coordinates(position)

         self.position = position

         self.side = side

+        self._to_convert = ['position', 'side']

 

 

     @property

@@ -745,18 +646,6 @@ class SquareButterfly(Primitive):
         max_y = self.position[1] + (self.side / 2.)

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.side = inch(self.side)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.side = metric(self.side)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

@@ -782,6 +671,7 @@ class Donut(Primitive):
             # Hexagon

             self.width = 0.5 * math.sqrt(3.) * outer_diameter

             self.height = outer_diameter

+        self._to_convert = ['position', 'width', 'height', 'inner_diameter', 'outer_diameter']

 

     @property

     def lower_left(self):

@@ -801,24 +691,6 @@ class Donut(Primitive):
         max_y = self.upper_right[1]

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.width = inch(self.width)

-            self.height = inch(self.height)

-            self.inner_diameter = inch(self.inner_diameter)

-            self.outer_diameter = inch(self.outer_diameter)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.width = metric(self.width)

-            self.height = metric(self.height)

-            self.inner_diameter = metric(self.inner_diameter)

-            self.outer_diameter = metric(self.outer_diameter)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

@@ -834,6 +706,7 @@ class SquareRoundDonut(Primitive):
             raise ValueError('Outer diameter must be larger than inner diameter.')

         self.inner_diameter = inner_diameter

         self.outer_diameter = outer_diameter

+        self._to_convert = ['position', 'inner_diameter', 'outer_diameter']

 

     @property

     def lower_left(self):

@@ -851,20 +724,6 @@ class SquareRoundDonut(Primitive):
         max_y = self.upper_right[1]

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.inner_diameter = inch(self.inner_diameter)

-            self.outer_diameter = inch(self.outer_diameter)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.inner_diameter = metric(self.inner_diameter)

-            self.outer_diameter = metric(self.outer_diameter)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

@@ -877,6 +736,7 @@ class Drill(Primitive):
         validate_coordinates(position)

         self.position = position

         self.diameter = diameter

+        self._to_convert = ['position', 'diameter']

 

     @property

     def radius(self):

@@ -890,18 +750,6 @@ class Drill(Primitive):
         max_y = self.position[1] + self.radius

         return ((min_x, max_x), (min_y, max_y))

 

-    def to_inch(self):

-        if self.units == 'metric':

-            self.units = 'inch'

-            self.position = tuple(map(inch, self.position))

-            self.diameter = inch(self.diameter)

-

-    def to_metric(self):

-        if self.units == 'inch':

-            self.units = 'metric'

-            self.position = tuple(map(metric, self.position))

-            self.diameter = metric(self.diameter)

-

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

 

diff --git a/gerber/tests/test_primitives.py b/gerber/tests/test_primitives.py
index c438735..67c7822 100644
--- a/gerber/tests/test_primitives.py
+++ b/gerber/tests/test_primitives.py
@@ -77,18 +77,18 @@ def test_line_vertices():
 def test_line_conversion():
     c = Circle((0, 0), 25.4, units='metric')
     l = Line((2.54, 25.4), (254.0, 2540.0), c, units='metric')
-    
+
     # No effect
     l.to_metric()
     assert_equal(l.start, (2.54, 25.4))
     assert_equal(l.end, (254.0, 2540.0))
     assert_equal(l.aperture.diameter, 25.4)
-    
+
     l.to_inch()
     assert_equal(l.start, (0.1, 1.0))
     assert_equal(l.end, (10.0, 100.0))
     assert_equal(l.aperture.diameter, 1.0)
-    
+
     # No effect
     l.to_inch()
     assert_equal(l.start, (0.1, 1.0))
@@ -97,19 +97,19 @@ def test_line_conversion():
 
     c = Circle((0, 0), 1.0, units='inch')
     l = Line((0.1, 1.0), (10.0, 100.0), c, units='inch')
-    
+
     # No effect
     l.to_inch()
     assert_equal(l.start, (0.1, 1.0))
     assert_equal(l.end, (10.0, 100.0))
     assert_equal(l.aperture.diameter, 1.0)
-    
-    
+
+
     l.to_metric()
     assert_equal(l.start, (2.54, 25.4))
     assert_equal(l.end, (254.0, 2540.0))
     assert_equal(l.aperture.diameter, 25.4)
-    
+
     #No effect
     l.to_metric()
     assert_equal(l.start, (2.54, 25.4))
@@ -180,6 +180,21 @@ def test_arc_bounds():
 def test_arc_conversion():
     c = Circle((0, 0), 25.4, units='metric')
     a = Arc((2.54, 25.4), (254.0, 2540.0), (25400.0, 254000.0),'clockwise', c, units='metric')
+
+    #No effect
+    a.to_metric()
+    assert_equal(a.start, (2.54, 25.4))
+    assert_equal(a.end, (254.0, 2540.0))
+    assert_equal(a.center, (25400.0, 254000.0))
+    assert_equal(a.aperture.diameter, 25.4)
+
+    a.to_inch()
+    assert_equal(a.start, (0.1, 1.0))
+    assert_equal(a.end, (10.0, 100.0))
+    assert_equal(a.center, (1000.0, 10000.0))
+    assert_equal(a.aperture.diameter, 1.0)
+
+    #no effect
     a.to_inch()
     assert_equal(a.start, (0.1, 1.0))
     assert_equal(a.end, (10.0, 100.0))
@@ -220,14 +235,31 @@ def test_circle_bounds():
 
 def test_circle_conversion():
     c = Circle((2.54, 25.4), 254.0, units='metric')
+
     c.to_metric()   #shouldn't do antyhing
+    assert_equal(c.position, (2.54, 25.4))
+    assert_equal(c.diameter, 254.)
+
+    c.to_inch()
+    assert_equal(c.position, (0.1, 1.))
+    assert_equal(c.diameter, 10.)
+
+    #no effect
     c.to_inch()
-    c.to_inch()     #shouldn't do anything
     assert_equal(c.position, (0.1, 1.))
     assert_equal(c.diameter, 10.)
+
     c = Circle((0.1, 1.0), 10.0, units='inch')
+    #No effect
     c.to_inch()
+    assert_equal(c.position, (0.1, 1.))
+    assert_equal(c.diameter, 10.)
+
     c.to_metric()
+    assert_equal(c.position, (2.54, 25.4))
+    assert_equal(c.diameter, 254.)
+
+    #no effect
     c.to_metric()
     assert_equal(c.position, (2.54, 25.4))
     assert_equal(c.diameter, 254.)
@@ -261,16 +293,38 @@ def test_ellipse_bounds():
 
 def test_ellipse_conversion():
     e = Ellipse((2.54, 25.4), 254.0, 2540., units='metric')
+
+    #No effect
     e.to_metric()
+    assert_equal(e.position, (2.54, 25.4))
+    assert_equal(e.width, 254.)
+    assert_equal(e.height, 2540.)
+
     e.to_inch()
+    assert_equal(e.position, (0.1, 1.))
+    assert_equal(e.width, 10.)
+    assert_equal(e.height, 100.)
+
+    #No effect
     e.to_inch()
     assert_equal(e.position, (0.1, 1.))
     assert_equal(e.width, 10.)
     assert_equal(e.height, 100.)
 
     e = Ellipse((0.1, 1.), 10.0, 100., units='inch')
+
+    #no effect
     e.to_inch()
+    assert_equal(e.position, (0.1, 1.))
+    assert_equal(e.width, 10.)
+    assert_equal(e.height, 100.)
+
     e.to_metric()
+    assert_equal(e.position, (2.54, 25.4))
+    assert_equal(e.width, 254.)
+    assert_equal(e.height, 2540.)
+
+    # No effect
     e.to_metric()
     assert_equal(e.position, (2.54, 25.4))
     assert_equal(e.width, 254.)
@@ -307,15 +361,33 @@ def test_rectangle_bounds():
 
 def test_rectangle_conversion():
     r = Rectangle((2.54, 25.4), 254.0, 2540.0, units='metric')
+
     r.to_metric()
+    assert_equal(r.position, (2.54,25.4))
+    assert_equal(r.width, 254.0)
+    assert_equal(r.height, 2540.0)
+
     r.to_inch()
+    assert_equal(r.position, (0.1, 1.0))
+    assert_equal(r.width, 10.0)
+    assert_equal(r.height, 100.0)
+
     r.to_inch()
     assert_equal(r.position, (0.1, 1.0))
     assert_equal(r.width, 10.0)
     assert_equal(r.height, 100.0)
+
     r = Rectangle((0.1, 1.0), 10.0, 100.0, units='inch')
     r.to_inch()
+    assert_equal(r.position, (0.1, 1.0))
+    assert_equal(r.width, 10.0)
+    assert_equal(r.height, 100.0)
+
     r.to_metric()
+    assert_equal(r.position, (2.54,25.4))
+    assert_equal(r.width, 254.0)
+    assert_equal(r.height, 2540.0)
+
     r.to_metric()
     assert_equal(r.position, (2.54,25.4))
     assert_equal(r.width, 254.0)
@@ -352,12 +424,34 @@ def test_diamond_bounds():
 
 def test_diamond_conversion():
     d = Diamond((2.54, 25.4), 254.0, 2540.0, units='metric')
+
+    d.to_metric()
+    assert_equal(d.position, (2.54, 25.4))
+    assert_equal(d.width, 254.0)
+    assert_equal(d.height, 2540.0)
+
+    d.to_inch()
+    assert_equal(d.position, (0.1, 1.0))
+    assert_equal(d.width, 10.0)
+    assert_equal(d.height, 100.0)
+
     d.to_inch()
     assert_equal(d.position, (0.1, 1.0))
     assert_equal(d.width, 10.0)
     assert_equal(d.height, 100.0)
 
     d = Diamond((0.1, 1.0), 10.0, 100.0, units='inch')
+
+    d.to_inch()
+    assert_equal(d.position, (0.1, 1.0))
+    assert_equal(d.width, 10.0)
+    assert_equal(d.height, 100.0)
+
+    d.to_metric()
+    assert_equal(d.position, (2.54, 25.4))
+    assert_equal(d.width, 254.0)
+    assert_equal(d.height, 2540.0)
+
     d.to_metric()
     assert_equal(d.position, (2.54, 25.4))
     assert_equal(d.width, 254.0)
@@ -398,6 +492,19 @@ def test_chamfer_rectangle_bounds():
 
 def test_chamfer_rectangle_conversion():
     r = ChamferRectangle((2.54, 25.4), 254.0, 2540.0, 0.254, (True, True, False, False), units='metric')
+
+    r.to_metric()
+    assert_equal(r.position, (2.54,25.4))
+    assert_equal(r.width, 254.0)
+    assert_equal(r.height, 2540.0)
+    assert_equal(r.chamfer, 0.254)
+
+    r.to_inch()
+    assert_equal(r.position, (0.1, 1.0))
+    assert_equal(r.width, 10.0)
+    assert_equal(r.height, 100.0)
+    assert_equal(r.chamfer, 0.01)
+
     r.to_inch()
     assert_equal(r.position, (0.1, 1.0))
     assert_equal(r.width, 10.0)
@@ -405,6 +512,18 @@ def test_chamfer_rectangle_conversion():
     assert_equal(r.chamfer, 0.01)
 
     r = ChamferRectangle((0.1, 1.0), 10.0, 100.0, 0.01, (True, True, False, False), units='inch')
+    r.to_inch()
+    assert_equal(r.position, (0.1, 1.0))
+    assert_equal(r.width, 10.0)
+    assert_equal(r.height, 100.0)
+    assert_equal(r.chamfer, 0.01)
+
+    r.to_metric()
+    assert_equal(r.position, (2.54,25.4))
+    assert_equal(r.width, 254.0)
+    assert_equal(r.height, 2540.0)
+    assert_equal(r.chamfer, 0.254)
+
     r.to_metric()
     assert_equal(r.position, (2.54,25.4))
     assert_equal(r.width, 254.0)
@@ -446,6 +565,19 @@ def test_round_rectangle_bounds():
 
 def test_round_rectangle_conversion():
     r = RoundRectangle((2.54, 25.4), 254.0, 2540.0, 0.254, (True, True, False, False), units='metric')
+
+    r.to_metric()
+    assert_equal(r.position, (2.54,25.4))
+    assert_equal(r.width, 254.0)
+    assert_equal(r.height, 2540.0)
+    assert_equal(r.radius, 0.254)
+
+    r.to_inch()
+    assert_equal(r.position, (0.1, 1.0))
+    assert_equal(r.width, 10.0)
+    assert_equal(r.height, 100.0)
+    assert_equal(r.radius, 0.01)
+
     r.to_inch()
     assert_equal(r.position, (0.1, 1.0))
     assert_equal(r.width, 10.0)
@@ -453,6 +585,19 @@ def test_round_rectangle_conversion():
     assert_equal(r.radius, 0.01)
 
     r = RoundRectangle((0.1, 1.0), 10.0, 100.0, 0.01, (True, True, False, False), units='inch')
+
+    r.to_inch()
+    assert_equal(r.position, (0.1, 1.0))
+    assert_equal(r.width, 10.0)
+    assert_equal(r.height, 100.0)
+    assert_equal(r.radius, 0.01)
+
+    r.to_metric()
+    assert_equal(r.position, (2.54,25.4))
+    assert_equal(r.width, 254.0)
+    assert_equal(r.height, 2540.0)
+    assert_equal(r.radius, 0.254)
+
     r.to_metric()
     assert_equal(r.position, (2.54,25.4))
     assert_equal(r.width, 254.0)
@@ -510,12 +655,38 @@ def test_obround_subshapes():
 
 def test_obround_conversion():
     o = Obround((2.54,25.4), 254.0, 2540.0, units='metric')
+
+    #No effect
+    o.to_metric()
+    assert_equal(o.position, (2.54, 25.4))
+    assert_equal(o.width, 254.0)
+    assert_equal(o.height, 2540.0)
+
+    o.to_inch()
+    assert_equal(o.position, (0.1, 1.0))
+    assert_equal(o.width, 10.0)
+    assert_equal(o.height, 100.0)
+
+    #No effect
     o.to_inch()
     assert_equal(o.position, (0.1, 1.0))
     assert_equal(o.width, 10.0)
     assert_equal(o.height, 100.0)
 
     o= Obround((0.1, 1.0), 10.0, 100.0, units='inch')
+
+    #No effect
+    o.to_inch()
+    assert_equal(o.position, (0.1, 1.0))
+    assert_equal(o.width, 10.0)
+    assert_equal(o.height, 100.0)
+
+    o.to_metric()
+    assert_equal(o.position, (2.54, 25.4))
+    assert_equal(o.width, 254.0)
+    assert_equal(o.height, 2540.0)
+
+    #No effect
     o.to_metric()
     assert_equal(o.position, (2.54, 25.4))
     assert_equal(o.width, 254.0)
@@ -554,11 +725,33 @@ def test_polygon_bounds():
 
 def test_polygon_conversion():
     p = Polygon((2.54, 25.4), 3, 254.0, units='metric')
+    
+    #No effect
+    p.to_metric()
+    assert_equal(p.position, (2.54, 25.4))
+    assert_equal(p.radius, 254.0)
+    
+    p.to_inch()
+    assert_equal(p.position, (0.1, 1.0))
+    assert_equal(p.radius, 10.0)
+    
+    #No effect
     p.to_inch()
     assert_equal(p.position, (0.1, 1.0))
     assert_equal(p.radius, 10.0)
 
     p = Polygon((0.1, 1.0), 3, 10.0, units='inch')
+    
+     #No effect
+    p.to_inch()
+    assert_equal(p.position, (0.1, 1.0))
+    assert_equal(p.radius, 10.0)
+    
+    p.to_metric()
+    assert_equal(p.position, (2.54, 25.4))
+    assert_equal(p.radius, 254.0)
+    
+    #No effect
     p.to_metric()
     assert_equal(p.position, (2.54, 25.4))
     assert_equal(p.radius, 254.0)
@@ -623,15 +816,37 @@ def test_round_butterfly_ctor_validation():
     assert_raises(TypeError, RoundButterfly, (3,4,5), 5)
 
 def test_round_butterfly_conversion():
-     b = RoundButterfly((2.54, 25.4), 254.0, units='metric')
-     b.to_inch()
-     assert_equal(b.position, (0.1, 1.0))
-     assert_equal(b.diameter, 10.0)
+    b = RoundButterfly((2.54, 25.4), 254.0, units='metric')
+    
+    #No Effect
+    b.to_metric()
+    assert_equal(b.position, (2.54, 25.4))
+    assert_equal(b.diameter, (254.0))
+    
+    b.to_inch()
+    assert_equal(b.position, (0.1, 1.0))
+    assert_equal(b.diameter, 10.0)
+    
+    #No effect
+    b.to_inch()
+    assert_equal(b.position, (0.1, 1.0))
+    assert_equal(b.diameter, 10.0)
 
-     b = RoundButterfly((0.1, 1.0), 10.0, units='inch')
-     b.to_metric()
-     assert_equal(b.position, (2.54, 25.4))
-     assert_equal(b.diameter, (254.0))
+    b = RoundButterfly((0.1, 1.0), 10.0, units='inch')
+    
+    #No effect
+    b.to_inch()
+    assert_equal(b.position, (0.1, 1.0))
+    assert_equal(b.diameter, 10.0)
+    
+    b.to_metric()
+    assert_equal(b.position, (2.54, 25.4))
+    assert_equal(b.diameter, (254.0))
+    
+    #No Effect
+    b.to_metric()
+    assert_equal(b.position, (2.54, 25.4))
+    assert_equal(b.diameter, (254.0))
 
 def test_round_butterfly_offset():
     b = RoundButterfly((0, 0), 1)
@@ -672,15 +887,37 @@ def test_square_butterfly_bounds():
     assert_array_almost_equal(ybounds, (-1, 1))
 
 def test_squarebutterfly_conversion():
-     b = SquareButterfly((2.54, 25.4), 254.0, units='metric')
-     b.to_inch()
-     assert_equal(b.position, (0.1, 1.0))
-     assert_equal(b.side, 10.0)
+    b = SquareButterfly((2.54, 25.4), 254.0, units='metric')
+     
+    #No effect
+    b.to_metric()
+    assert_equal(b.position, (2.54, 25.4))
+    assert_equal(b.side, (254.0))
+    
+    b.to_inch()
+    assert_equal(b.position, (0.1, 1.0))
+    assert_equal(b.side, 10.0)
+    
+    #No effect
+    b.to_inch()
+    assert_equal(b.position, (0.1, 1.0))
+    assert_equal(b.side, 10.0)
 
-     b = SquareButterfly((0.1, 1.0), 10.0, units='inch')
-     b.to_metric()
-     assert_equal(b.position, (2.54, 25.4))
-     assert_equal(b.side, (254.0))
+    b = SquareButterfly((0.1, 1.0), 10.0, units='inch')
+    
+    #No effect
+    b.to_inch()
+    assert_equal(b.position, (0.1, 1.0))
+    assert_equal(b.side, 10.0)
+    
+    b.to_metric()
+    assert_equal(b.position, (2.54, 25.4))
+    assert_equal(b.side, (254.0))
+    
+    #No effect
+    b.to_metric()
+    assert_equal(b.position, (2.54, 25.4))
+    assert_equal(b.side, (254.0))
 
 def test_square_butterfly_offset():
     b = SquareButterfly((0, 0), 1)
@@ -717,12 +954,38 @@ def test_donut_bounds():
 
 def test_donut_conversion():
     d = Donut((2.54, 25.4), 'round', 254.0, 2540.0, units='metric')
+    
+    #No effect
+    d.to_metric()
+    assert_equal(d.position, (2.54, 25.4))
+    assert_equal(d.inner_diameter, 254.0)
+    assert_equal(d.outer_diameter, 2540.0)
+    
+    d.to_inch()
+    assert_equal(d.position, (0.1, 1.0))
+    assert_equal(d.inner_diameter, 10.0)
+    assert_equal(d.outer_diameter, 100.0)
+    
+    #No effect
     d.to_inch()
     assert_equal(d.position, (0.1, 1.0))
     assert_equal(d.inner_diameter, 10.0)
     assert_equal(d.outer_diameter, 100.0)
 
     d = Donut((0.1, 1.0), 'round', 10.0, 100.0, units='inch')
+    
+    #No effect
+    d.to_inch()
+    assert_equal(d.position, (0.1, 1.0))
+    assert_equal(d.inner_diameter, 10.0)
+    assert_equal(d.outer_diameter, 100.0)
+    
+    d.to_metric()
+    assert_equal(d.position, (2.54, 25.4))
+    assert_equal(d.inner_diameter, 254.0)
+    assert_equal(d.outer_diameter, 2540.0)
+    
+    #No effect
     d.to_metric()
     assert_equal(d.position, (2.54, 25.4))
     assert_equal(d.inner_diameter, 254.0)
@@ -763,11 +1026,34 @@ def test_drill_bounds():
 
 def test_drill_conversion():
     d = Drill((2.54, 25.4), 254., units='metric')
+    
+    #No effect
+    d.to_metric()
+    assert_equal(d.position, (2.54, 25.4))
+    assert_equal(d.diameter, 254.0)
+    
     d.to_inch()
     assert_equal(d.position, (0.1, 1.0))
     assert_equal(d.diameter, 10.0)
+    
+    #No effect
+    d.to_inch()
+    assert_equal(d.position, (0.1, 1.0))
+    assert_equal(d.diameter, 10.0)
+    
 
     d = Drill((0.1, 1.0), 10., units='inch')
+    
+    #No effect
+    d.to_inch()
+    assert_equal(d.position, (0.1, 1.0))
+    assert_equal(d.diameter, 10.0)
+    
+    d.to_metric()
+    assert_equal(d.position, (2.54, 25.4))
+    assert_equal(d.diameter, 254.0)
+    
+    #No effect
     d.to_metric()
     assert_equal(d.position, (2.54, 25.4))
     assert_equal(d.diameter, 254.0)