def test_contains_w_units(self):
domain = DomainXY.from_linspace(-1 * u.mm, 1 * u.mm, 11)
self.assertTrue(domain.contains(-0.5 * u.mm, 0 * u.mm))
self.assertFalse(domain.contains(2 * u.mm, 0 * u.mm))
self.assertFalse(domain.contains(4 * u.mm, 2 * u.mm))
# Raise if incompatible unit
with self.assertRaises(AssertionError):
domain.contains(-0.5 * u.s, 0 * u.kg)
# Raise if missing unit
with self.assertRaises(AssertionError):
domain.contains(-0.5, 0 * u.mm)
# Raise if missing unit
with self.assertRaises(AssertionError):
domain.contains(-0.5 * u.mm, 0)
def test_rectangular_domain(self):
szx, szy = (20, 10)
stepx, stepy = (0.1, 0.4)
ampl = 1.0
xy = DomainXY.from_shape((szy, szx), (stepy, stepx))
constant_map = ampl * np.ones(xy.shape)
spatial_funct = ScalarBidimensionalFunction(constant_map, domain=xy)
spectr = bfft.direct(spatial_funct)
freq_step_x, freq_step_y = spectr.domain.step
self.assertAlmostEqual(0, spectr.xmap[szy // 2, szx // 2])
self.assertAlmostEqual(0, spectr.ymap[szy // 2, szx // 2])
self.assertAlmostEqual(np.sqrt(ampl * szx * szy),
spectr.values[szy // 2, szx // 2])
self.assertAlmostEqual(-0.5 / stepx, spectr.xcoord[0])
self.assertAlmostEqual(1 / (szx * stepx), freq_step_x)
self.assertAlmostEqual(-0.5 / stepy, spectr.ycoord[0])
self.assertAlmostEqual(1 / (szy * stepy), freq_step_y)
def test_shift_w_units(self):
domain = DomainXY.from_shape((100, 100), pixel_size=1 * u.cm)
self.assertAlmostEqual(domain.origin[0], 49.5)
self.assertAlmostEqual(domain.origin[1], 49.5)
domain.shift(0.1 * u.m, -3.1415 * u.mm)
self.assertAlmostEqual(domain.origin[0], 39.5)
self.assertAlmostEqual(domain.origin[1], 49.81415)
# Raise if incompatible unit
with self.assertRaises(AssertionError):
domain.shift(0.1 * u.s, 0.2 * u.s)
# Raise if missing unit
with self.assertRaises(AssertionError):
domain.shift(0.1 * u.m, 0.2)
# Raise if missing unit
with self.assertRaises(AssertionError):
domain.shift(0.1, 0.2 * u.m)
def test_direct_sinus_x(self):
sizeInPoints = 500
pixelSize = 0.2
periodInLengthUnits = 4.0
amplitude = 13.4
phase = 0.8
spatialMap = self._makeSinusMap(sizeInPoints, pixelSize, amplitude,
periodInLengthUnits, phase)
xyDomain = DomainXY.from_shape((sizeInPoints, sizeInPoints), pixelSize)
xyFunct = ScalarBidimensionalFunction(spatialMap, domain=xyDomain)
fftFunct = bfft.direct(xyFunct)
spectralMap = fftFunct.values
freqX = bfft.frequencies_x_map(sizeInPoints, pixelSize)
freqY = bfft.frequencies_y_map(sizeInPoints, pixelSize)
self.assertEqual((sizeInPoints, sizeInPoints), spectralMap.shape)
self.assertEqual(
1.0 / periodInLengthUnits,
np.abs(freqX.flatten()[np.argmax(np.abs(spectralMap))]))
self.assertEqual(
0.0, np.abs(freqY.flatten()[np.argmax(np.abs(spectralMap))]))
self._checkParseval(spatialMap, spectralMap)
def distances_x_map(sizeInPoints, pixelSize):
domain = DomainXY.from_shape((sizeInPoints, sizeInPoints), pixelSize)
return domain.xcoord
def distances_norm_map(sizeInPoints, pixelSize):
domain = DomainXY.from_shape((sizeInPoints, sizeInPoints), pixelSize)
return np.linalg.norm(np.dstack((domain.xmap, domain.ymap)), axis=2)
def _createFlatPhaseMap(self):
nPx = self._pupilDiameterInPixels
pupPxSize = self.pupilPlanePixelSizeInMeters()
domain = DomainXY.from_shape((nPx, nPx), pupPxSize)
phase = S2DF(np.ones((nPx, nPx)), domain=domain)
return phase
def _createPupilFunction(self):
domain = DomainXY.from_shape((self._pupilDiameterInPixels,
self._pupilDiameterInPixels),
self.pupilPlanePixelSizeInMeters())
self._pupilFunction = S2DF(
self._mask.asTransmissionValue(), domain=domain)
def test_crop_w_units(self):
domain = DomainXY.from_linspace(-1, 1, 11)
with self.assertRaises(AssertionError):
_ = domain.cropped(*([1, 2, 3, 4] * u.cm))
def test_step(self):
domain = DomainXY.from_linspace(-1, 1, 11)
self.assertAlmostEqual(0.2, domain.step[0])
self.assertAlmostEqual(0.2, domain.step[1])
