Merge pull request #140 from djkapner/fix_poly_scale

Fix poly scale

Author: RussTorres

renderapi/transform/leaf/affine_models.py

@@ -1,4 +1,5 @@
 from .transform import Transform, logger
+from .common import calc_first_order_properties
 import numpy as np
 from renderapi.errors import ConversionError, EstimationError
 
@@ -306,32 +307,9 @@ def inverse_tform(self, points):
         return self.convert_points_vector_to_array(pt, Nd)
 
     def calc_properties(self):
-        if self.force_shear == 'x':
-            sy = np.sqrt(self.M[1, 0] ** 2 + self.M[1, 1] ** 2)
-            theta = np.arctan2(self.M[1, 0], self.M[1, 1])
-            rc = np.cos(theta)
-            rs = np.sin(theta)
-            sx = rc * self.M[0, 0] - rs * self.M[0, 1]
-            if rs != 0:
-                cx = (self.M[0, 0] - sx*rc) / (sx * rs)
-            else:
-                cx = (self.M[0, 1] - sx*rs) / (sx * rc)
-            cy = 0.0
-        else:
-            # shear in y direction
-            sx = np.sqrt(self.M[0, 0] ** 2 + self.M[0, 1] ** 2)
-            theta = np.arctan2(-self.M[0, 1], self.M[0, 0])
-            rc = np.cos(theta)
-            rs = np.sin(theta)
-            sy = rs * self.M[1, 0] + rc * self.M[1, 1]
-            if rs != 0:
-                cy = (self.M[1, 1] - sy * rc) / (-sy * rs)
-            else:
-                cy = (self.M[1, 0] - sy * rs) / (sy * rc)
-            cx = 0.0
-        # room for other cases, for example cx = cy
-
-        return sx, sy, cx, cy, theta
+        return calc_first_order_properties(
+                self.M[0:2, 0:2],
+                force_shear=self.force_shear)
 
     @property
     def scale(self):

renderapi/transform/leaf/common.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+
+def calc_first_order_properties(M, force_shear='x'):
+    """calculate scale shear and rotation from a 2x2 matrix
+       could be M[0:2, 0:2] from an AffineModel or params[:, 1:3]
+       from a Polynomial2DTransform
+
+    Parameters
+    ----------
+    M : numpy array
+        2x2
+    force_shear : str
+        'x' or 'y'
+
+    Returns
+    -------
+    sx : float
+        scale in x direction
+    sy : float
+        scale in y direction
+    cx : float
+        shear in x direction
+    cy : float
+        shear in y direction
+    theta : float
+        rotation angle in radians
+    """
+    if force_shear == 'x':
+        sy = np.sqrt(M[1, 0] ** 2 + M[1, 1] ** 2)
+        theta = np.arctan2(M[1, 0], M[1, 1])
+        rc = np.cos(theta)
+        rs = np.sin(theta)
+        sx = rc * M[0, 0] - rs * M[0, 1]
+        if rs != 0:
+            cx = (M[0, 0] - sx*rc) / (sx * rs)
+        else:
+            cx = (M[0, 1] - sx*rs) / (sx * rc)
+        cy = 0.0
+    elif force_shear == 'y':
+        # shear in y direction
+        sx = np.sqrt(M[0, 0] ** 2 + M[0, 1] ** 2)
+        theta = np.arctan2(-M[0, 1], M[0, 0])
+        rc = np.cos(theta)
+        rs = np.sin(theta)
+        sy = rs * M[1, 0] + rc * M[1, 1]
+        if rs != 0:
+            cy = (M[1, 1] - sy * rc) / (-sy * rs)
+        else:
+            cy = (M[1, 0] - sy * rs) / (sy * rc)
+        cx = 0.0
+    else:
+        raise ValueError("%s not a valid option for force_shear."
+                         " should be 'x' or 'y'")
+    # room for other cases, for example cx = cy
+
+    return sx, sy, cx, cy, theta

renderapi/transform/leaf/polynomial_models.py

@@ -1,6 +1,7 @@
 from .transform import Transform, logger
 from .affine_models import AffineModel
 import numpy as np
+from .common import calc_first_order_properties
 from renderapi.errors import ConversionError, EstimationError, RenderError
 
 try:
@@ -29,7 +30,8 @@ class Polynomial2DTransform(Transform):
 
     def __init__(self, dataString=None, src=None, dst=None, order=2,
                  force_polynomial=True, params=None, identity=False,
-                 labels=None, transformId=None, json=None, **kwargs):
+                 labels=None, transformId=None, json=None,
+                 force_shear='x', **kwargs):
         """Initialize Polynomial2DTransform
         This provides 5 different ways to initialize the transform which are
         mutually exclusive and applied in the order specified here.
@@ -58,6 +60,7 @@ def __init__(self, dataString=None, src=None, dst=None, order=2,
 
 
         """
+        self.force_shear = force_shear
         if json is not None:
             self.from_dict(json)
         else:
@@ -89,15 +92,38 @@ def order(self):
         no_coeffs = len(self.params.ravel())
         return int((abs(np.sqrt(4 * no_coeffs + 1)) - 3) / 2)
 
+    def calc_properties(self):
+        if self.order == 0:
+            return 1.0, 1.0, 0.0, 0.0, 0.0
+        return calc_first_order_properties(
+                self.params[:, 1:3],
+                force_shear=self.force_shear)
+
     @property
     def scale(self):
         """tuple of scale for x, y"""
-        if self.order > 0:
-            scale = (self.params[0, 1], self.params[1, 2])
+        sx, sy, cx, cy, theta = self.calc_properties()
+        return (sx, sy)
+
+    @property
+    def shear(self):
+        """shear"""
+        sx, sy, cx, cy, theta = self.calc_properties()
+        if self.force_shear == 'x':
+            return cx
         else:
-            # translation only has no scale impact
-            scale = (1.0, 1.0)
-        return scale
+            return cy
+
+    @property
+    def translation(self):
+        """tuple of translation in x, y"""
+        return tuple(self.params[:, 0])
+
+    @property
+    def rotation(self):
+        """counter-clockwise rotation"""
+        sx, sy, cx, cy, theta = self.calc_properties()
+        return theta
 
     @property
     def dataString(self):

test/test_transform.py

@@ -1011,3 +1011,29 @@ def test_adaptive_estimate():
     dsta = tf.tform(src)
     dstb = ntf.tform(src)
     assert(np.linalg.norm(dsta - dstb, axis=1).max() <= tol)
+
+
+def test_polynomial_shear():
+    # make sure it gives the same answer as affine
+    M = np.array([
+        [1.1, -0.2, 7.0],
+        [0.3, 0.8, -9.0],
+        [0.0, 0.0, 1.0]])
+
+    atf = renderapi.transform.AffineModel()
+    atf.M = M
+
+    params = np.zeros((2, 3))
+    params[:, 1:] = M[0:2, 0:2]
+    params[:, 0] = M[0:2, 2]
+
+    ptf = renderapi.transform.Polynomial2DTransform(params=params)
+
+    for shear in ['x', 'y']:
+        atf.force_shear = shear
+        ptf.force_shear = shear
+
+        assert atf.scale == ptf.scale
+        assert atf.shear == ptf.shear
+        assert atf.rotation == ptf.rotation
+        assert atf.translation == ptf.translation