def compute_relative_transform(psx_EM, psy_EM, ro_EM, sh_EM, trx_EM, try_EM,
psx_FM, psy_FM, ro_FM, sh_FM, trx_FM, try_FM):
"""Compute relative affine transformation
Parameters
----------
psx_EM, psy_EM : float
EM pixel size in x, y [m]
ro_EM : float
EM rotation (should be ~0)
sh_EM : float
EM shear
trx_EM, try_EM : float
EM translation in x, y [m]
psx_FM, psy_FM : float
FM pixel size in x, y [m]
ro_FM : float
FM rotation
sh_FM : float
FM shear (should be ~0)
trx_FM, try_FM : float
FM translation in x, y [m]
Returns
-------
A : 3x3 array
Relative affine transformation
"""
A = AffineMPL().rotate(-ro_FM)\
.skew(0, -sh_EM)\
.scale(psx_FM / psx_EM,
psy_FM / psy_EM)\
.translate((trx_FM - trx_EM) / psx_EM,
(try_FM - try_EM) / -psy_EM)
return A.get_matrix()
def rotate_stack(stack_in, stack_out=None, r=0, render=None):
"""Rotate stack by an arbitrary rotation
Parameters
----------
stack_in : str
Input stack name
stack_out : str (optional)
Output stack name
Overwrites input stack if not provided
r : float
rotation angle [rad]
"""
# Create DataFrame for input stack
df_stack = create_stack_DataFrame(stack=stack_in, render=render)
# Create scaling transform
T = AffineMPL().rotate(r)
A = AffineRender()
A.M = T.get_matrix()
# Add rotation transform to DataFrame
for i, tile in df_stack.iterrows():
df_stack.at[i, 'tforms'] += [A]
# Set output stack name
stack_out = stack_out if stack_out is not None else stack_in
# Create scaled stack
create_stack_from_DataFrame(df=df_stack, name=stack_out, render=render)
def translate_stack(stack_in, stack_out=None, tx=0.0, ty=0.0, render=None):
"""Translate stack by an arbitrary translation
Parameters
----------
stack_in : str
Input stack name
stack_out : str (optional)
Output stack name
Overwrites input stack if not provided
tx : float
x translation [px]
ty : float
y translation [px]
"""
# Create DataFrame for input stack
df_stack = create_stack_DataFrame(stack=stack_in, render=render)
# Create scaling transform
T = AffineMPL().translate(tx, ty)
A = AffineRender()
A.M = T.get_matrix()
# Add translation transform to DataFrame
for i, tile in df_stack.iterrows():
df_stack.at[i, 'tforms'] += [A]
# Set output stack name
stack_out = stack_out if stack_out is not None else stack_in
# Create scaled stack
create_stack_from_DataFrame(df=df_stack, name=stack_out, render=render)
def scale_stack(stack_in, stack_out=None, sx=1.0, sy=1.0, render=None):
"""Scale stack by an arbitrary scale factor
Parameters
----------
stack_in : str
Input stack name
stack_out : str (optional)
Output stack name
Overwrites input stack if not provided
sx : float
x scale factor
sy : float
y scale factor
"""
# Create DataFrame for input stack
df_stack = create_stack_DataFrame(stack=stack_in, render=render)
# Create scaling transform
T = AffineMPL().scale(sx, sy)
A = AffineRender()
A.M = T.get_matrix()
# Add scale transform to DataFrame
for i, tile in df_stack.iterrows():
df_stack.at[i, 'tforms'] += [A]
# Set output stack name
stack_out = stack_out if stack_out is not None else stack_in
# Create scaled stack
create_stack_from_DataFrame(df=df_stack, name=stack_out, render=render)
