def polar_hull(slc):
"""Find the largest convex region using a polar transform."""
old_dtype = slc.dtype
# Convert to polar coordinates
slc = slc.astype('uint8') * 256
center = center_of_mass(slc)
center_is_valid = not np.any(np.isnan(center))
if not center_is_valid:
log.warning("Unvalid center by center of mass method. "
"Defaulting to center of image")
center = None
log.debug("Performing polar transform")
pim, ptSettings = polarTransform.convertToPolarImage(slc, center=center)
log.debug("Applying anisotropic morphology filters to polar image.")
pim = pim.astype('bool')
pim = ndimage.median_filter(pim, size=9)
pim = closing(pim, selem=np.ones((10, 1)))
pim = opening(pim, selem=np.ones((1, 10)))
# Mesh grid in order to compare edge positions
my, mx = np.mgrid[:pim.shape[0], :pim.shape[1]]
# Find the outside of the shape in the x direction
log.debug("Calculating hull boundary")
edge_r_idx = pim.shape[1] - np.argmax(pim[:, ::-1], axis=1)
edge_r_idx[edge_r_idx == pim.shape[1]] = 0
edge_r = mx < edge_r_idx[:, np.newaxis]
edge_r = ndimage.median_filter(edge_r, size=9)
log.debug("Performing inverse polar transform")
hull, uptSetting = polarTransform.convertToCartesianImage(
edge_r.astype('uint8') * 256, settings=ptSettings)
return hull.astype(old_dtype)
def generateVerticalLinesCartesian4():
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(verticalLinesPolarImage_scaled3,
initialRadius=30,
finalRadius=100, initialAngle=2 / 4 * np.pi,
finalAngle=5 / 4 * np.pi, center=[128, 128],
imageSize=[256, 256])
saveImage('verticalLinesCartesianImage_scaled3.png', cartesianImage)
def test_cartesianConversion(self):
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(
self.shortAxisApexPolarImage,
center=[401, 365],
imageSize=[608, 800],
finalRadius=543)
np.testing.assert_array_equal(
ptSettings.getCartesianPointsImage([0, 0]), np.array([401, 365]))
np.testing.assert_array_equal(
ptSettings.getCartesianPointsImage([[0, 0], [0, 0]]),
np.array([[401, 365], [401, 365]]))
np.testing.assert_array_equal(
ptSettings.getCartesianPointsImage((0, 0)), np.array([401, 365]))
np.testing.assert_array_equal(
ptSettings.getCartesianPointsImage(((0, 0), (0, 0))),
np.array([[401, 365], [401, 365]]))
np.testing.assert_array_equal(
ptSettings.getCartesianPointsImage(np.array([0, 0])),
np.array([401, 365]))
np.testing.assert_array_equal(
ptSettings.getCartesianPointsImage(np.array([[0, 0], [0, 0]])),
np.array([[401, 365], [401, 365]]))
np.testing.assert_array_equal(
ptSettings.getCartesianPointsImage(
np.array([[50 * 802 / 543, 0], [35 * 802 / 543, 400],
[53 * 802 / 543, 800], [60 * 802 / 543, 1200]])),
np.array([[451, 365], [401, 400], [348, 365], [401, 305]]))
def test_centerOrientationsWithImageSize(self):
orientations = [('bottom-left', np.array([0, 0]), [0, 128], [0, 128],
[128, 256], [128, 256]),
('bottom-middle', np.array([128, 0]), [0, 128],
[0, 256], [128, 256], [0, 256]),
('bottom-right', np.array([256, 0]), [0, 128],
[128, 256], [128, 256], [0, 128]),
('middle-left', np.array([0, 128]), [0, 256], [0, 128],
[0, 256], [128, 256]),
('middle-middle', np.array([128, 128]), [0, 256],
[0, 256], [0, 256], [0, 256]),
('middle-right', np.array([256, 128]), [0, 256],
[128, 256], [0, 256], [0, 128]),
('top-left', np.array([0, 256]), [128, 256], [0, 128],
[0, 128], [128, 256]),
('top-middle', np.array([128, 256]),
[128, 256], [0, 256], [0, 128], [0, 256]),
('top-right', np.array([256, 256]),
[128, 256], [128, 256], [0, 128], [0, 128])]
for row in orientations:
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(
self.verticalLinesPolarImage_scaled2,
center=row[0],
imageSize=(256, 256),
initialRadius=30,
finalRadius=100)
np.testing.assert_array_equal(ptSettings.center, row[1])
self.assertEqual(ptSettings.cartesianImageSize, (256, 256))
np.testing.assert_almost_equal(
cartesianImage[row[2][0]:row[2][1], row[3][0]:row[3][1], :],
self.verticalLinesCartesianImage_scaled2[
row[4][0]:row[4][1], row[5][0]:row[5][1], :])
def test_centerOrientationsWithoutImageSize(self):
orientations = [
('bottom-left', (100, 100), np.array([0, 0]), [128, 228], [128, 228]),
('bottom-middle', (100, 200), np.array([100, 0]), [128, 228], [28, 228]),
('bottom-right', (100, 100), np.array([100, 0]), [128, 228], [28, 128]),
('middle-left', (200, 100), np.array([0, 100]), [28, 228], [128, 228]),
('middle-middle', (200, 200), np.array([100, 100]), [28, 228], [28, 228]),
('middle-right', (200, 100), np.array([100, 100]), [28, 228], [28, 128]),
('top-left', (100, 100), np.array([0, 100]), [28, 128], [128, 228]),
('top-middle', (100, 200), np.array([100, 100]), [28, 128], [28, 228]),
('top-right', (100, 100), np.array([100, 100]), [28, 128], [28, 128])
]
for row in orientations:
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(self.verticalLinesPolarImage_scaled2,
center=row[0], initialRadius=30,
finalRadius=100, hasColor=True)
self.assertEqual(ptSettings.cartesianImageSize, row[1])
np.testing.assert_array_equal(ptSettings.center, row[2])
np.testing.assert_almost_equal(cartesianImage,
self.verticalLinesCartesianImage_scaled2[row[3][0]:row[3][1],
row[4][0]:row[4][1], :])
def generateVerticalLinesCartesian3():
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(
verticalLinesPolarImage_scaled2,
center=[128, 128],
imageSize=[256, 256],
initialRadius=30,
finalRadius=100)
saveImage('verticalLinesCartesianImage_scaled2.png', cartesianImage)
def scan_convert(image, irad, frad, iang, fang):
image, _ = polarTransform.convertToCartesianImage(np.transpose(image),
initialRadius=irad,
finalRadius=frad,
initialAngle=iang,
finalAngle=fang,
hasColor=False,
order=1)
return np.transpose(image[:, int(irad):])
def polar2cart(image):
# 180x103x? -> 128x128x?
if image.shape[0] != 180 or image.shape[1] != 103:
print('ERROR! wrong image size: ' + str(image.shape))
return None
cartesianImage, _ = pt.convertToCartesianImage(image,
hasColor=True,
finalRadius=64,
imageSize=(128, 128))
return cartesianImage
def test_settings(self):
cartesianImage1, ptSettings1 = polarTransform.convertToCartesianImage(self.verticalLinesPolarImage_scaled,
initialRadius=30, finalRadius=100,
initialAngle=2 / 4 * np.pi,
finalAngle=5 / 4 * np.pi,
imageSize=(256, 256), center=(128, 128),
hasColor=True)
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(self.verticalLinesPolarImage_scaled,
settings=ptSettings1)
np.testing.assert_array_equal(ptSettings.center, np.array([128, 128]))
self.assertEqual(ptSettings.initialRadius, 30)
self.assertEqual(ptSettings.finalRadius, 100)
self.assertEqual(ptSettings.initialAngle, 2 / 4 * np.pi)
self.assertEqual(ptSettings.finalAngle, 5 / 4 * np.pi)
self.assertEqual(ptSettings.cartesianImageSize, (256, 256))
self.assertEqual(ptSettings.polarImageSize, self.verticalLinesPolarImage_scaled.shape[-3:-1])
np.testing.assert_almost_equal(cartesianImage, self.verticalLinesCartesianImage_scaled)
def scan_convert(image, irad, frad, iang, fang):
"""Scan converts beam lines"""
image, _ = polarTransform.convertToCartesianImage(
np.transpose(image),
initialRadius=irad.numpy(),
finalRadius=frad.numpy(),
initialAngle=iang.numpy(),
finalAngle=fang.numpy(),
hasColor=False,
order=1)
image = np.transpose(image[:, int(irad):])
return image
def test_notNumpyArrayCenter(self):
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(self.shortAxisApexPolarImage_centerMiddle,
imageSize=(608, 800), finalRadius=503)
np.testing.assert_array_equal(ptSettings.center, np.array([400, 304]))
self.assertEqual(ptSettings.initialRadius, 0)
self.assertEqual(ptSettings.finalRadius, 503)
self.assertEqual(ptSettings.initialAngle, 0.0)
self.assertEqual(ptSettings.finalAngle, 2 * np.pi)
self.assertEqual(ptSettings.cartesianImageSize, (608, 800))
self.assertEqual(ptSettings.polarImageSize, self.shortAxisApexPolarImage_centerMiddle.shape[-2:])
assert_image_approx_equal_average(cartesianImage, self.shortAxisApexImage, 5)
def test_3d_support_grayscale_multithreaded(self):
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(self.horizontalLinesAnimatedPolar,
center=(512, 384), imageSize=(768, 1024),
finalRadius=640, useMultiThreading=True)
np.testing.assert_array_equal(ptSettings.center, np.array([512, 384]))
self.assertEqual(ptSettings.initialRadius, 0)
self.assertEqual(ptSettings.finalRadius, 640)
self.assertEqual(ptSettings.initialAngle, 0.0)
self.assertEqual(ptSettings.finalAngle, 2 * np.pi)
self.assertEqual(ptSettings.cartesianImageSize, (768, 1024))
self.assertEqual(ptSettings.polarImageSize, self.horizontalLinesAnimatedPolar.shape[-2:])
assert_image_approx_equal_average(cartesianImage, self.horizontalLinesAnimated, 10)
def test_RGBA(self):
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(self.verticalLinesPolarImage,
center=(128, 128), imageSize=(256, 256),
finalRadius=182, hasColor=True)
np.testing.assert_array_equal(ptSettings.center, np.array([128, 128]))
self.assertEqual(ptSettings.initialRadius, 0)
self.assertEqual(ptSettings.finalRadius, 182)
self.assertEqual(ptSettings.initialAngle, 0.0)
self.assertEqual(ptSettings.finalAngle, 2 * np.pi)
self.assertEqual(ptSettings.cartesianImageSize, (256, 256))
self.assertEqual(ptSettings.polarImageSize, self.verticalLinesPolarImage.shape[-3:-1])
assert_image_approx_equal_average(cartesianImage, self.verticalLinesImage, 10)
def test_defaultCenter(self):
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(self.shortAxisApexPolarImage,
center=(401, 365), imageSize=(608, 800),
finalRadius=543)
np.testing.assert_array_equal(ptSettings.center, np.array([401, 365]))
self.assertEqual(ptSettings.initialRadius, 0)
self.assertEqual(ptSettings.finalRadius, 543)
self.assertEqual(ptSettings.initialAngle, 0.0)
self.assertEqual(ptSettings.finalAngle, 2 * np.pi)
self.assertEqual(ptSettings.cartesianImageSize, (608, 800))
self.assertEqual(ptSettings.polarImageSize, self.shortAxisApexPolarImage.shape[-2:])
assert_image_approx_equal_average(cartesianImage, self.shortAxisApexImage, 5)
def test_default_horizontalLines(self):
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(self.horizontalLinesPolarImage,
center=(512, 384), imageSize=(768, 1024),
finalRadius=640)
np.testing.assert_array_equal(ptSettings.center, np.array([512, 384]))
self.assertEqual(ptSettings.initialRadius, 0)
self.assertEqual(ptSettings.finalRadius, 640)
self.assertEqual(ptSettings.initialAngle, 0.0)
self.assertEqual(ptSettings.finalAngle, 2 * np.pi)
self.assertEqual(ptSettings.cartesianImageSize, (768, 1024))
self.assertEqual(ptSettings.polarImageSize, self.horizontalLinesPolarImage.shape)
assert_image_approx_equal_average(cartesianImage, self.horizontalLinesImage, 5)
def test_3d_support_rgb_multithreaded(self):
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(self.verticalLinesAnimatedPolar,
center=(128, 128), imageSize=(256, 256),
finalRadius=182, hasColor=True,
useMultiThreading=True)
np.testing.assert_array_equal(ptSettings.center, np.array([128, 128]))
self.assertEqual(ptSettings.initialRadius, 0)
self.assertEqual(ptSettings.finalRadius, 182)
self.assertEqual(ptSettings.initialAngle, 0.0)
self.assertEqual(ptSettings.finalAngle, 2 * np.pi)
self.assertEqual(ptSettings.cartesianImageSize, (256, 256))
self.assertEqual(ptSettings.polarImageSize, self.verticalLinesAnimatedPolar.shape[-3:-1])
assert_image_approx_equal_average(cartesianImage, self.verticalLinesAnimated, 10)
def test_IFRadius(self):
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(
self.verticalLinesPolarImage_scaled2,
center=(128, 128),
imageSize=(256, 256),
initialRadius=30,
finalRadius=100)
np.testing.assert_array_equal(ptSettings.center, np.array([128, 128]))
self.assertEqual(ptSettings.initialRadius, 30)
self.assertEqual(ptSettings.finalRadius, 100)
self.assertEqual(ptSettings.initialAngle, 0.0)
self.assertEqual(ptSettings.finalAngle, 2 * np.pi)
self.assertEqual(ptSettings.cartesianImageSize, (256, 256))
self.assertEqual(ptSettings.polarImageSize,
self.verticalLinesPolarImage_scaled2.shape[0:2])
np.testing.assert_almost_equal(
cartesianImage, self.verticalLinesCartesianImage_scaled2)
def generateShortAxisApexCartesian2():
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(shortAxisApexPolarImage_centerMiddle,
imageSize=[608, 800], finalRadius=503)
saveImage('shortAxisApexCartesianImage2.png', cartesianImage)
def generateShortAxisApexCartesian():
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(shortAxisApexPolarImage, center=[401, 365],
imageSize=[608, 800], finalRadius=543)
saveImage('shortAxisApexCartesianImage.png', cartesianImage)
def generateVerticalLinesCartesian():
cartesianImage, ptSettings = polarTransform.convertToCartesianImage(verticalLinesPolarImage, center=[128, 128],
imageSize=[256, 256], finalRadius=182)
saveImage('verticalLinesCartesianImage.png', cartesianImage)
