def test_axpby2(self):
# test axpby with BlockDataContainer and DataContainer
ig0 = ImageGeometry(2, 3, 4)
# ig1 = ImageGeometry(2,3,5)
data0 = ig0.allocate(-1)
data2 = ig0.allocate(1)
data1 = ig0.allocate(2)
# data3 = ig1.allocate(3)
cp0 = BlockDataContainer(data0, data2)
# cp1 = BlockDataContainer(data1,data3)
out = cp0 * 0. - 10
cp0.axpby(3, -2, data1, out)
# operation should be [ 3 * -1 + (-2) * 2 , 3 * 1 + (-2) * 2 ]
# output should be [ -7 , -1 ]
res0 = ig0.allocate(-7)
res2 = ig0.allocate(-1)
res = BlockDataContainer(res0, res2)
self.assertBlockDataContainerEqual(out, res)
def test_sapyb_datacontainer_c(self):
#a vec, b vec
ig = ImageGeometry(10,10)
d1 = ig.allocate(dtype=numpy.complex64)
d2 = ig.allocate(dtype=numpy.complex64)
a = ig.allocate(dtype=numpy.complex64)
b = ig.allocate(dtype=numpy.complex64)
arr = numpy.empty(ig.shape, dtype=numpy.complex64)
arr.real = numpy.asarray(numpy.arange(1,101).reshape(10,10), dtype=numpy.float32)
arr.imag = numpy.asarray(numpy.arange(1,101).reshape(10,10), dtype=numpy.float32)
d1.fill(arr)
arr.imag = -1* arr.imag
d2.fill(arr)
a.fill(d2.as_array())
b.fill(d1.as_array())
out = ig.allocate(-1,dtype=numpy.complex64)
# equals to d1^ * d1 + d2^*d2 = d1**2 + d2**2 = 2* arr.norm = 2 * (arr.real **2 + arr.imag **2)
out = d1.sapyb(a,d2,b)
res = 2* (arr.real * arr.real + arr.imag * arr.imag)
numpy.testing.assert_array_equal(res, out.as_array())
out.fill(0)
d1.sapyb(a,d2,b, out)
numpy.testing.assert_array_equal(res, out.as_array())
def test_axpby(self):
# test axpby between BlockDataContainers
ig0 = ImageGeometry(2,3,4)
ig1 = ImageGeometry(2,3,5)
data0 = ig0.allocate(-1)
data2 = ig0.allocate(1)
data1 = ig0.allocate(2)
data3 = ig0.allocate(3)
cp0 = BlockDataContainer(data0,data2)
cp1 = BlockDataContainer(data1,data3)
out = cp0 * 0. - 10
cp0.axpby(3,-2,cp1,out, num_threads=4)
# operation should be [ 3 * -1 + (-2) * 2 , 3 * 1 + (-2) * 3 ]
# output should be [ -7 , -3 ]
res0 = ig0.allocate(-7)
res2 = ig0.allocate(-3)
res = BlockDataContainer(res0, res2)
print ("res0", res0.as_array())
print ("res2", res2.as_array())
print ("###############################")
print ("out_0", out.get_item(0).as_array())
print ("out_1", out.get_item(1).as_array())
self.assertBlockDataContainerEqual(out, res)
def test_FISTA_catch_Lipschitz(self):
if debug_print:
print("Test FISTA catch Lipschitz")
ig = ImageGeometry(127, 139, 149)
initial = ImageData(geometry=ig)
initial = ig.allocate()
b = initial.copy()
# fill with random numbers
b.fill(numpy.random.random(initial.shape))
initial = ig.allocate(ImageGeometry.RANDOM)
identity = IdentityOperator(ig)
#### it seems FISTA does not work with Nowm2Sq
norm2sq = LeastSquares(identity, b)
if debug_print:
print('Lipschitz', norm2sq.L)
# norm2sq.L = None
#norm2sq.L = 2 * norm2sq.c * identity.norm()**2
#norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity)
opt = {'tol': 1e-4, 'memopt': False}
if debug_print:
print("initial objective", norm2sq(initial))
try:
alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction())
self.assertTrue(False)
except ValueError as ve:
print(ve)
self.assertTrue(True)
def test_ConstantFunction(self):
M, N, K = 3,4,5
ig = ImageGeometry(M, N, K)
tmp = ig.allocate('random_int')
constant = 10
f = ConstantFunction(constant)
# check call
res1 = f(tmp)
self.assertAlmostEqual(res1, constant)
# check gradient with and without out
res1 = f.gradient(tmp)
out = ig.allocate()
self.assertNumpyArrayAlmostEqual(res1.as_array(), out)
out1 = ig.allocate()
f.gradient(tmp, out=out1)
self.assertNumpyArrayAlmostEqual(res1.as_array(), out1)
# check convex conjugate
res1 = f.convex_conjugate(tmp)
res2 = tmp.maximum(0).sum()
self.assertNumpyArrayAlmostEqual(res1.as_array(), res2.as_array())
# check proximal
tau = 0.4
res1 = f.proximal(tmp, tau)
self.assertNumpyArrayAlmostEqual(res1.as_array(), tmp.as_array())
def test_axpby_b_blockdc(self):
# test axpby between BlockDataContainers, with b as a blockdatacontainer
ig0 = ImageGeometry(2, 3, 4)
ig1 = ImageGeometry(2, 3, 5)
data0 = ig0.allocate(-1)
data2 = ig0.allocate(1)
data1 = ig0.allocate(2)
data3 = ig0.allocate(3)
b1 = ig0.allocate(-2)
b2 = ig0.allocate(-3)
cp0 = BlockDataContainer(data0, data2)
cp1 = BlockDataContainer(data1, data3)
b = BlockDataContainer(b1, b2)
out = cp0 * 0. - 10
cp0.axpby(3, b, cp1, out, num_threads=4)
# operation should be [ 3 * -1 + (-2) * 2 , 3 * 1 + (-3) * 3 ]
# output should be [ -7 , -3 ]
res0 = ig0.allocate(-7)
res2 = ig0.allocate(-6)
res = BlockDataContainer(res0, res2)
self.assertBlockDataContainerEqual(out, res)
def test_ImageDataSubset(self):
new_order = ['horizontal_x', 'channel', 'horizontal_y']
vgeometry = ImageGeometry(voxel_num_x=4, voxel_num_y=3, channels=2, dimension_labels=new_order)
# expected dimension_labels
self.assertListEqual(new_order,
list(vgeometry.dimension_labels))
vol = vgeometry.allocate()
# test reshape
new_order = ['channel', 'horizontal_y','horizontal_x']
vol.reorder(new_order)
self.assertListEqual(new_order, list(vol.geometry.dimension_labels))
ss1 = vol.get_slice(horizontal_x = 0)
self.assertListEqual(['channel', 'horizontal_y'], list(ss1.geometry.dimension_labels))
vg = ImageGeometry(3,4,5,channels=2)
self.assertListEqual([ImageGeometry.CHANNEL, ImageGeometry.VERTICAL,
ImageGeometry.HORIZONTAL_Y, ImageGeometry.HORIZONTAL_X],
list(vg.dimension_labels))
ss2 = vg.allocate()
ss3 = vol.get_slice(channel=0)
self.assertListEqual([ImageGeometry.HORIZONTAL_Y, ImageGeometry.HORIZONTAL_X], list(ss3.geometry.dimension_labels))
def test_ImageData(self):
# create ImageData from geometry
vgeometry = ImageGeometry(voxel_num_x=4, voxel_num_y=3, channels=2)
#vol = ImageData(geometry=vgeometry)
vol = vgeometry.allocate()
self.assertEqual(vol.shape, (2, 3, 4))
vol1 = vol + 1
self.assertNumpyArrayEqual(vol1.as_array(), numpy.ones(vol.shape))
vol1 = vol - 1
self.assertNumpyArrayEqual(vol1.as_array(), -numpy.ones(vol.shape))
vol1 = 2 * (vol + 1)
self.assertNumpyArrayEqual(vol1.as_array(), 2 * numpy.ones(vol.shape))
vol1 = (vol + 1) / 2
self.assertNumpyArrayEqual(vol1.as_array(), numpy.ones(vol.shape) / 2)
vol1 = vol + 1
self.assertEqual(vol1.sum(), 2*3*4)
vol1 = (vol + 2) ** 2
self.assertNumpyArrayEqual(vol1.as_array(), numpy.ones(vol.shape) * 4)
self.assertEqual(vol.number_of_dimensions, 3)
ig2 = ImageGeometry (voxel_num_x=2,voxel_num_y=3,voxel_num_z=4,
dimension_labels=[ImageGeometry.HORIZONTAL_X, ImageGeometry.HORIZONTAL_Y,
ImageGeometry.VERTICAL])
data = ig2.allocate()
self.assertNumpyArrayEqual(numpy.asarray(data.shape), numpy.asarray(ig2.shape))
self.assertNumpyArrayEqual(numpy.asarray(data.shape), data.as_array().shape)
def test_GD(self):
print("Test GD")
ig = ImageGeometry(12, 13, 14)
initial = ig.allocate()
# b = initial.copy()
# fill with random numbers
# b.fill(numpy.random.random(initial.shape))
b = ig.allocate('random')
identity = IdentityOperator(ig)
norm2sq = LeastSquares(identity, b)
rate = norm2sq.L / 3.
alg = GD(initial=initial,
objective_function=norm2sq,
rate=rate,
atol=1e-9,
rtol=1e-6)
alg.max_iteration = 1000
alg.run(verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
alg = GD(initial=initial,
objective_function=norm2sq,
rate=rate,
max_iteration=20,
update_objective_interval=2,
atol=1e-9,
rtol=1e-6)
alg.max_iteration = 20
self.assertTrue(alg.max_iteration == 20)
self.assertTrue(alg.update_objective_interval == 2)
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def test_mixedL12Norm(self):
numpy.random.seed(1)
M, N, K = 2, 3, 5
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
u1 = ig.allocate('random')
u2 = ig.allocate('random')
U = BlockDataContainer(u1, u2, shape=(2, 1))
# Define no scale and scaled
f_no_scaled = MixedL21Norm()
f_scaled = 1 * MixedL21Norm()
# call
a1 = f_no_scaled(U)
a2 = f_scaled(U)
self.assertNumpyArrayAlmostEqual(a1, a2)
tmp = [el**2 for el in U.containers]
self.assertBlockDataContainerEqual(BlockDataContainer(*tmp),
U.power(2))
z1 = f_no_scaled.proximal_conjugate(U, 1)
u3 = ig.allocate('random')
u4 = ig.allocate('random')
z3 = BlockDataContainer(u3, u4, shape=(2, 1))
f_no_scaled.proximal_conjugate(U, 1, out=z3)
self.assertBlockDataContainerAlmostEqual(z3, z1, decimal=5)
def test_CGLS(self):
print("Test CGLS")
#ig = ImageGeometry(124,153,154)
ig = ImageGeometry(10, 2)
numpy.random.seed(2)
initial = ig.allocate(0.)
b = ig.allocate('random')
# b = initial.copy()
# fill with random numbers
# b.fill(numpy.random.random(initial.shape))
# b = ig.allocate()
# bdata = numpy.reshape(numpy.asarray([i for i in range(20)]), (2,10))
# b.fill(bdata)
identity = IdentityOperator(ig)
alg = CGLS(initial=initial, operator=identity, data=b)
alg.max_iteration = 200
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
alg = CGLS(initial=initial,
operator=identity,
data=b,
max_iteration=200,
update_objective_interval=2)
self.assertTrue(alg.max_iteration == 200)
self.assertTrue(alg.update_objective_interval == 2)
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def test_ChannelwiseOperator(self):
print("test_ChannelwiseOperator")
M = 3
channels = 4
ig = ImageGeometry(M, M, channels=channels)
igs = ImageGeometry(M, M)
x = ig.allocate('random', seed=100)
diag = igs.allocate('random', seed=101)
D = DiagonalOperator(diag)
C = ChannelwiseOperator(D, channels)
y = C.direct(x)
y2 = ig.allocate()
C.direct(x, y2)
for c in range(channels):
numpy.testing.assert_array_equal(y.subset(channel=2).as_array(), \
(diag*x.subset(channel=2)).as_array())
numpy.testing.assert_array_equal(y2.subset(channel=2).as_array(), \
(diag*x.subset(channel=2)).as_array())
z = C.adjoint(y)
z2 = ig.allocate()
C.adjoint(y, z2)
for c in range(channels):
numpy.testing.assert_array_equal(z.subset(channel=2).as_array(), \
(diag*(diag*x.subset(channel=2))).as_array())
numpy.testing.assert_array_equal(z2.subset(channel=2).as_array(), \
(diag*(diag*x.subset(channel=2))).as_array())
def test_FISTA_Norm2Sq(self):
print("Test FISTA Norm2Sq")
ig = ImageGeometry(127, 139, 149)
b = ig.allocate(ImageGeometry.RANDOM)
# fill with random numbers
initial = ig.allocate(ImageGeometry.RANDOM)
identity = IdentityOperator(ig)
#### it seems FISTA does not work with Nowm2Sq
norm2sq = LeastSquares(identity, b)
#norm2sq.L = 2 * norm2sq.c * identity.norm()**2
#norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity)
opt = {'tol': 1e-4, 'memopt': False}
if debug_print:
print("initial objective", norm2sq(initial))
alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction())
alg.max_iteration = 2
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
alg = FISTA(initial=initial,
f=norm2sq,
g=ZeroFunction(),
max_iteration=2,
update_objective_interval=3)
self.assertTrue(alg.max_iteration == 2)
self.assertTrue(alg.update_objective_interval == 3)
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def test_axpby(self):
print ("test axpby")
ig = ImageGeometry(10,10)
d1 = ig.allocate(1)
d2 = ig.allocate(2)
out = ig.allocate(None)
a = 2
b = 1
# equals to 2 * [1] + 1 * [2] = [4]
d1.axpby(a,b,d2,out)
res = numpy.ones_like(d1.as_array()) * 4.
numpy.testing.assert_array_equal(res, out.as_array())
def test_Norm2sq_as_OperatorCompositionFunction(self):
print('Test for OperatorCompositionFunction')
M, N = 50, 50
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
#numpy.random.seed(1)
b = ig.allocate('random', seed=1)
print('Check call with IdentityOperator operator... OK\n')
operator = 3 * IdentityOperator(ig)
u = ig.allocate('random', seed=50)
f = 0.5 * L2NormSquared(b=b)
func1 = OperatorCompositionFunction(f, operator)
func2 = LeastSquares(operator, b, 0.5)
print("f.L {}".format(f.L))
print("0.5*f.L {}".format((0.5 * f).L))
print("type func1 {}".format(type(func1)))
print("func1.L {}".format(func1.L))
print("func2.L {}".format(func2.L))
print("operator.norm() {}".format(operator.norm()))
numpy.testing.assert_almost_equal(func1(u), func2(u))
print('Check gradient with IdentityOperator operator... OK\n')
tmp1 = ig.allocate()
tmp2 = ig.allocate()
res_gradient1 = func1.gradient(u)
res_gradient2 = func2.gradient(u)
func1.gradient(u, out=tmp1)
func2.gradient(u, out=tmp2)
self.assertNumpyArrayAlmostEqual(res_gradient1.as_array(),
res_gradient2.as_array())
self.assertNumpyArrayAlmostEqual(tmp1.as_array(), tmp2.as_array())
print('Check call with MatrixOperator... OK\n')
mat = np.random.randn(M, N)
operator = MatrixOperator(mat)
vg = VectorGeometry(N)
b = vg.allocate('random')
u = vg.allocate('random')
func1 = OperatorCompositionFunction(0.5 * L2NormSquared(b=b), operator)
func2 = LeastSquares(operator, b, 0.5)
self.assertNumpyArrayAlmostEqual(func1(u), func2(u))
numpy.testing.assert_almost_equal(func1.L, func2.L)
def test_exception_initial_CGLS(self):
if debug_print:
print ("Test CGLS")
ig = ImageGeometry(10,2)
numpy.random.seed(2)
initial = ig.allocate(0.)
b = ig.allocate('random')
identity = IdentityOperator(ig)
try:
alg = CGLS(initial=initial, operator=identity, data=b, x_init=initial)
assert False
except ValueError as ve:
assert True
def setUp(self):
ig0 = ImageGeometry(2, 3, 4)
ig1 = ImageGeometry(2, 3, 5)
data0 = ig0.allocate(-1)
data2 = ig1.allocate(1)
# data1 = ig0.allocate(2)
# data3 = ig1.allocate(3)
cp0 = BlockDataContainer(data0, data2)
self.ig0 = ig0
self.ig1 = ig1
self.cp0 = cp0
def test_axpby2(self):
print ("test axpby2")
N = 100
ig = ImageGeometry(N,2*N,N*10)
d1 = ig.allocate(1)
d2 = ig.allocate(2)
out = ig.allocate(None)
a = 2
b = 1
print ("allocated")
# equals to 2 * [1] + 1 * [2] = [4]
d1.axpby(a,b,d2,out, num_threads=4)
print ("calculated")
res = numpy.ones_like(d1.as_array()) * 4.
numpy.testing.assert_array_equal(res, out.as_array())
def test_ConstantFunction(self):
k = ConstantFunction(constant=1)
ig = ImageGeometry(1,2,3)
x = ig.allocate(2)
grad = k.gradient(x)
out = ig.allocate(-1)
k.gradient(x, out=out)
#out.fill(-3)
self.assertNumpyArrayEqual(numpy.zeros(x.shape), grad.as_array())
self.assertNumpyArrayEqual(out.as_array(), grad.as_array())
def test_fill_dimension_ImageData(self):
ig = ImageGeometry(2, 3, 4)
u = ig.allocate(0)
a = numpy.ones((4, 2))
# default_labels = [ImageGeometry.VERTICAL, ImageGeometry.HORIZONTAL_Y, ImageGeometry.HORIZONTAL_X]
data = u.as_array()
axis_number = u.get_dimension_axis('horizontal_y')
u.fill(a, horizontal_y=0)
numpy.testing.assert_array_equal(
u.subset(horizontal_y=0).as_array(), a)
u.fill(2, horizontal_y=1)
numpy.testing.assert_array_equal(
u.subset(horizontal_y=1).as_array(), 2 * a)
u.fill(2, horizontal_y=1)
numpy.testing.assert_array_equal(
u.subset(horizontal_y=1).as_array(), 2 * a)
b = u.subset(horizontal_y=2)
b.fill(3)
u.fill(b, horizontal_y=2)
numpy.testing.assert_array_equal(
u.subset(horizontal_y=2).as_array(), 3 * a)
def setUp(self):
ig = ImageGeometry(2, 3, 2)
data = ig.allocate(1, dtype=np.float32)
noisy_data = data + 1
# TV regularisation parameter
self.alpha = 1
self.fidelities = [
0.5 * L2NormSquared(b=noisy_data),
L1Norm(b=noisy_data),
KullbackLeibler(b=noisy_data, use_numba=False)
]
F = self.alpha * MixedL21Norm()
K = GradientOperator(ig)
# Compute operator Norm
normK = K.norm()
# Primal & dual stepsizes
self.sigma = 1. / normK
self.tau = 1. / normK
self.F = F
self.K = K
def test_L1Norm_2D(self):
model = 12 # select a model number from the library
N = 400 # set dimension of the phantom
path = os.path.dirname(tomophantom.__file__)
path_library2D = os.path.join(path, "Phantom2DLibrary.dat")
phantom_2D = TomoP2D.Model(model, N, path_library2D)
# data = ImageData(phantom_2D)
ig = ImageGeometry(voxel_num_x=N, voxel_num_y=N)
data = ig.allocate(None)
data.fill(phantom_2D)
# Create acquisition data and geometry
detectors = N
angles = np.linspace(0, 180, 120, dtype=np.float32)
ag = AcquisitionGeometry.create_Parallel2D()\
.set_angles(angles, angle_unit=AcquisitionGeometry.DEGREE)\
.set_panel(detectors)
sin = ag.allocate(None)
sino = TomoP2D.ModelSino(model, detectors, detectors, angles, path_library2D)
sin.fill(sino)
sin_stripe = sin.copy()
# sin_stripe = sin
tmp = sin_stripe.as_array()
tmp[:,::27]=tmp[:,::28]
sin_stripe.fill(tmp)
ring_recon = RingRemover(20, "db15", 21, info = True)(sin_stripe)
error = (ring_recon - sin).abs().as_array().mean()
print ("L1Norm ", error)
np.testing.assert_almost_equal(error, 83.20592, 4)
def test_Norm(self):
print("test_BlockOperator")
##
numpy.random.seed(1)
N, M = 200, 300
ig = ImageGeometry(N, M)
G = GradientOperator(ig)
t0 = timer()
norm = G.norm()
t1 = timer()
norm2 = G.norm()
t2 = timer()
norm3 = G.norm(force=True)
t3 = timer()
print("Norm dT1 {} dT2 {} dT3 {}".format(t1 - t0, t2 - t1, t3 - t2))
self.assertLess(t2 - t1, t1 - t0)
self.assertLess(t2 - t1, t3 - t2)
numpy.random.seed(1)
t4 = timer()
norm4 = G.norm(iterations=50, force=True)
t5 = timer()
self.assertLess(t2 - t1, t5 - t4)
numpy.random.seed(1)
t4 = timer()
norm5 = G.norm(x_init=ig.allocate('random'), iterations=50, force=True)
t5 = timer()
self.assertLess(t2 - t1, t5 - t4)
for n in [norm, norm2, norm3, norm4, norm5]:
print("norm {}", format(n))
def test_Lipschitz(self):
print('Test for OperatorCompositionFunction')
M, N = 50, 50
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
b = ig.allocate('random', seed=1)
print('Check call with IdentityOperator operator... OK\n')
operator = 3 * IdentityOperator(ig)
u = ig.allocate('random_int', seed=50)
func2 = LeastSquares(operator, b, 0.5)
assert func2.L != 2
print(func2.L)
func2.L = 2
assert func2.L == 2
def test_PDHG_strongly_convex_gamma_g(self):
ig = ImageGeometry(3,3)
data = ig.allocate('random')
f = L2NormSquared(b=data)
g = L2NormSquared()
operator = IdentityOperator(ig)
# sigma, tau
sigma = 1.0
tau = 1.0
pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau,
max_iteration=5, gamma_g=0.5)
pdhg.run(1, verbose=0)
self.assertAlmostEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_g * tau))
self.assertAlmostEquals(pdhg.tau, tau * pdhg.theta)
self.assertAlmostEquals(pdhg.sigma, sigma / pdhg.theta)
pdhg.run(4, verbose=0)
self.assertNotEqual(pdhg.sigma, sigma)
self.assertNotEqual(pdhg.tau, tau)
# check negative strongly convex constant
with self.assertRaises(ValueError):
pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau,
max_iteration=5, gamma_g=-0.5)
# check strongly convex constant not a number
with self.assertRaises(ValueError):
pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau,
max_iteration=5, gamma_g="-0.5")
def test_NestedBlockDataContainer2(self):
M, N = 2, 3
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
ag = ig
u = ig.allocate(1)
op1 = GradientOperator(ig)
op2 = IdentityOperator(ig, ag)
operator = BlockOperator(op1, op2, shape=(2, 1))
d1 = op1.direct(u)
d2 = op2.direct(u)
d = operator.direct(u)
dd = operator.domain_geometry()
ww = operator.range_geometry()
c1 = d + d
c2 = 2 * d
c3 = d / (d + 0.0001)
c5 = d.get_item(0).power(2).sum()
def test_ScaledOperator(self):
print("test_ScaledOperator")
ig = ImageGeometry(10, 20, 30)
img = ig.allocate()
scalar = 0.5
sid = scalar * IdentityOperator(ig)
numpy.testing.assert_array_equal(scalar * img.as_array(),
sid.direct(img).as_array())
def test_reorder_with_list(self):
vgeometry = ImageGeometry(voxel_num_x=4, voxel_num_y=3, channels=2)
data = vgeometry.allocate(0)
new_order = ['horizontal_y', 'horizontal_x', 'channel']
data.reorder(new_order)
self.assertListEqual(list(new_order),
list(data.geometry.dimension_labels))
self.assertListEqual(list(new_order), list(data.dimension_labels))
def test_BlockOperatorLinearValidity(self):
print("test_BlockOperatorLinearValidity")
M, N = 3, 4
ig = ImageGeometry(M, N)
arr = ig.allocate('random', seed=1)
G = GradientOperator(ig)
Id = IdentityOperator(ig)
B = BlockOperator(G, Id)
# Nx1 case
u = ig.allocate('random', seed=2)
w = B.range_geometry().allocate(ImageGeometry.RANDOM, seed=3)
w1 = B.direct(u)
u1 = B.adjoint(w)
self.assertAlmostEqual((w * w1).sum(), (u1 * u).sum(), places=5)
def test_max(self):
print ("test max")
ig = ImageGeometry(10,10)
a = numpy.asarray(numpy.linspace(-10,10, num=100, endpoint=True), dtype=numpy.float32)
a = a.reshape((10,10))
d1 = ig.allocate(1)
d1.fill(a)
self.assertAlmostEqual(d1.max(), 10.)
