def test3(self):
import sys
data1 = np.array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0]],
np.float32)
bl1 = np.zeros(data1.shape, np.int32)
np1 = cImageD11.connectedpixels(data1, bl1, 0.1)
data2 = np.array([[0, 0, 0, 0, 0, 0, 0], [0, 2, 0, 0, 0, 2, 0],
[0, 2, 0, 0, 0, 2, 0], [0, 2, 0, 0, 0, 2, 0]],
np.float32)
bl2 = np.zeros(data2.shape, np.int32)
np2 = cImageD11.connectedpixels(data2, bl2, 0.1)
r1 = cImageD11.blobproperties(data1, bl1, np1)
r2 = cImageD11.blobproperties(data2, bl2, np2)
cImageD11.bloboverlaps(bl1, np1, r1, bl2, np2, r2, verbose=0)
# check which peaks are zeroed
self.assertAlmostEqual(np.sum(r1[0]), 0., 6)
# Results pile up all in r2[0]
self.assertAlmostEqual(np.sum(r2[1]), 0., 6)
from ImageD11.cImageD11 import s_1, s_I, s_I2, \
s_fI, s_ffI, s_sI, s_ssI, s_sfI, \
bb_mn_f, bb_mn_s, bb_mx_f, bb_mx_s,\
mx_I, mx_I_f, mx_I_s
self.assertAlmostEqual(r2[0, s_1], 11, 6)
self.assertAlmostEqual(r2[0, s_I], 17, 6)
def test1(self):
import sys
data1 = np.array([[1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0],
[1, 0, 1, 1, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0]],
np.float32)
bl1 = np.zeros(data1.shape, np.int32)
np1 = cImageD11.connectedpixels(data1, bl1, 0.1)
data2 = np.array([[0, 0, 0, 0, 2, 0, 2], [0, 0, 0, 0, 2, 0, 2],
[0, 0, 0, 2, 0, 2, 0], [0, 0, 0, 0, 2, 0, 2]],
np.float32)
bl2 = np.zeros(data2.shape, np.int32)
np2 = cImageD11.connectedpixels(data2, bl2, 0.1)
r1 = cImageD11.blobproperties(data1, bl1, np1, omega=-10.0)
r2 = cImageD11.blobproperties(data2, bl2, np2, omega=10.0)
cImageD11.bloboverlaps(bl1, np1, r1, bl2, np2, r2, verbose=0)
# check r1 is zeroed
err = np.sum(np.ravel(r1))
self.assertAlmostEqual(err, 0., 6)
from ImageD11.cImageD11 import s_1, s_I, s_I2, \
s_fI, s_ffI, s_sI, s_ssI, s_sfI, \
bb_mn_f, bb_mn_s, bb_mx_f, bb_mx_s,\
bb_mn_o, bb_mx_o,\
mx_I, mx_I_f, mx_I_s
# check total pixels
self.assertAlmostEqual(r2[0, s_1], 18.0, 6)
self.assertAlmostEqual(r2[0, s_I], 26.0, 6)
self.assertAlmostEqual(r2[0, bb_mn_f], 0.0, 6)
self.assertAlmostEqual(r2[0, bb_mx_f], 6.0, 6)
self.assertAlmostEqual(r2[0, bb_mn_s], 0.0, 6)
self.assertAlmostEqual(r2[0, bb_mx_s], 3.0, 6)
self.assertAlmostEqual(r2[0, bb_mn_o], -10.0, 6)
self.assertAlmostEqual(r2[0, bb_mx_o], 10.0, 6)
def test_2_shapes(self):
for t in [
np.uint8, np.int8, np.uint16, np.int16, np.int32, np.uint32,
np.float32, np.float
]:
data = np.array([[1, 0, 1, 0, 2, 0, 2], [1, 0, 1, 0, 2, 0, 2],
[1, 0, 1, 0, 0, 2, 0], [1, 1, 1, 0, 2, 0, 2]], t)
bl = np.zeros(data.shape, np.int32)
cImageD11.connectedpixels(data.astype(np.float32), bl,
0.1) # threshold
err = np.sum(np.ravel(data - bl))
self.assertEqual(err, 0)
def test_find_max(self):
for t in [
np.uint8, np.int8, np.uint16, np.int16, np.int32, np.uint32,
np.float32, np.float
]:
data = np.array([[1, 0, 1], [1, 0, 1], [1, 8, 1], [1, 1, 1]], t)
bl = np.zeros(data.shape, np.int32)
npx = cImageD11.connectedpixels(data.astype(np.float32), bl, 0.1)
self.assertEqual(npx, 1)
err = np.sum(np.ravel(data - bl))
self.assertEqual(err, 7) # 8-1
res = cImageD11.blobproperties(data.astype(np.float32),
bl,
npx,
omega=22.)
from ImageD11.cImageD11 import s_1, s_I, s_I2, \
s_fI, s_ffI, s_sI, s_ssI, s_sfI, \
bb_mn_f, bb_mn_s, bb_mx_f, bb_mx_s,\
bb_mn_o, bb_mx_o, \
mx_I, mx_I_f, mx_I_s, mx_I_o
# print res,res.shape
self.assertAlmostEqual(res[0][s_1], 10)
self.assertAlmostEqual(res[0][mx_I], 8)
self.assertAlmostEqual(res[0][mx_I_f], 1)
self.assertAlmostEqual(res[0][mx_I_s], 2)
self.assertAlmostEqual(res[0][mx_I_o], 22)
def testOK(self):
#import pdb; pdb.set_trace()
i = self.s.row.astype(np.uint16)
j = self.s.col.astype(np.uint16)
v = self.s.data
self.assertTrue((self.s.todense() == self.a).all())
dl = np.zeros(self.a.shape, 'i')
nd = cImageD11.connectedpixels(self.a, dl, self.threshold)
dstart = timer()
nd = cImageD11.connectedpixels(self.a, dl, self.threshold)
dend = timer()
sl = np.zeros(v.shape, 'i')
ns = cImageD11.sparse_connectedpixels(v, i, j, self.threshold, sl)
sbegin = timer()
ns = cImageD11.sparse_connectedpixels(v, i, j, self.threshold, sl)
send = timer()
sld = scipy.sparse.coo_matrix((sl, (i, j)), shape=self.a.shape)
testcase = (sld.todense() == dl).all()
densetime = dend - dstart
sparsetime = send - sbegin
print(
"sp_cp: %.3f ms vs %.3f ms, ratio %.1f nnz %d" %
(1e3 * sparsetime, 1e3 * densetime, densetime / sparsetime,
sld.nnz), " t=%.0f" % (self.threshold))
if ~testcase:
import pylab as pl
pl.ioff()
pl.figure()
pl.subplot(311)
pl.title("t=%f" % (self.threshold))
pl.imshow(dl, interpolation='nearest')
pl.colorbar()
pl.subplot(312)
pl.imshow(sld.todense(), interpolation='nearest')
pl.colorbar()
pl.subplot(313)
pl.imshow(sld.todense() - dl, interpolation='nearest')
pl.colorbar()
pl.show()
self.assertTrue(testcase)
def check_moments():
from ImageD11.cImageD11 import connectedpixels, blobproperties, \
blob_moments, s_1, s_I, s_fI, s_sI, s_ssI, s_sfI, s_ffI, \
s_raw, f_raw, m_ss, m_ff, m_sf
from ImageD11 import cImageD11
p = {
'm0': 10.,
'm1x': 80.,
'm1y': 77.5,
'm2xx': 5.,
'm2xy': 2.,
'm2yy': 3.,
}
pk = testpeak(**p).astype(np.float32)
blob = np.zeros(pk.shape, np.int32)
npk = connectedpixels(pk, blob, 0., 0)
res = blobproperties(pk, blob, npk, 0)
err = blob_moments(res)
mss = res[0, s_ssI] / res[0, s_I] - res[0, s_raw] * res[0, s_raw]
mff = res[0, s_ffI] / res[0, s_I] - res[0, f_raw] * res[0, f_raw]
msf = res[0, s_sfI] / res[0, s_I] - res[0, f_raw] * res[0, s_raw]
assert np.isclose(res[0, s_raw], p['m1x'])
assert np.isclose(res[0, f_raw], p['m1y'])
assert np.isclose(mss, p['m2xx'])
assert np.isclose(mff, p['m2yy'])
assert np.isclose(msf, p['m2xy'])
print("Moments look OK")
if 0:
for adr, name in zip((
s_1, s_I, s_fI, s_sI, s_ssI, s_sfI, s_ffI, s_raw, f_raw, m_ss,
m_ff, m_sf
), "s_1,s_I,s_fI,s_sI,s_ssI,s_sfI,s_ffI,s_raw,f_raw,m_ss,m_ff,m_sf".
split(",")):
print(name, res[0, adr])
print(res[0, s_raw], p['m1x'])
print(res[0, f_raw], p['m1y'])
print([[mss, msf], [msf, mff]])
import pylab as pl
pl.imshow(np.log(pk), origin='lower')
pl.show()
def bench(int_im):
im = int_im
float_im = int_im.astype(np.float32)
labelc = np.zeros(im.shape, np.int32)
labelm = np.zeros(im.shape, np.int32)
work = np.zeros(im.shape, np.int8)
end0 = time.time()
nc = cImageD11.connectedpixels(float_im, labelc, 1000)
end1 = time.time()
rc = cImageD11.blobproperties(float_im, labelc, nc, 0)
cImageD11.blob_moments(rc)
end2 = time.time()
print("cptime", nc,
"%.3f %.3f" % ((end1 - end0) * 1000, (end2 - end1) * 1000))
wfloatim = np.where(float_im > 1000, float_im, 0)
#import scipy.ndimage as ndi
#wfloatim= (float_im - ndi.gaussian_filter( float_im , 32)).clip(0,1e9)
end0 = time.time()
nw = cImageD11.localmaxlabel(wfloatim, labelm, work)
end1 = time.time()
rw = cImageD11.blobproperties(wfloatim, labelm, nw, 0)
cImageD11.blob_moments(rw)
end2 = time.time()
print("lmtime", nw,
"%.3f %.3f" % ((end1 - end0) * 1000, (end2 - end1) * 1000))
if 0:
pks = np.array(pks).T
import pylab as pl
pl.imshow(pl.log(float_im),
origin='lower',
interpolation='nearest',
aspect='auto')
pl.plot(pks[1], pks[0], "r+", label="ideal")
pl.plot(rc[:, cImageD11.f_raw],
rc[:, cImageD11.s_raw],
"wx",
label="connect")
pl.plot(rw[:, cImageD11.f_raw],
rw[:, cImageD11.s_raw],
"ko",
label="watershed",
markerfacecolor='None')
pl.legend()
pl.figure()
dci = [
np.sqrt(np.min((pks[1] - x)**2 + (pks[0] - y)**2))
for x, y in zip(rc[:, cImageD11.f_raw], rc[:, cImageD11.s_raw])
]
pl.subplot(121)
pl.plot(rc[:, cImageD11.s_raw], dci, '.', label="sconnected")
pl.plot(rc[:, cImageD11.f_raw], dci, '.', label="fconnected")
dwi = [
np.sqrt(np.min((pks[1] - x)**2 + (pks[0] - y)**2))
for x, y in zip(rw[:, cImageD11.f_raw], rw[:, cImageD11.s_raw])
]
pl.subplot(122)
pl.plot(rw[:, cImageD11.s_raw], dwi, '.', label="slocalmax")
pl.plot(rw[:, cImageD11.f_raw], dwi, '.', label="flocalmax")
pl.legend()
pl.show()
pl.imshow( pl.log(im ))
pl.show()
s = 30000/im.max()
int_im = (im*s).astype( np.uint16 )
fabio.edfimage.edfimage( int_im ).write( "testoverlaps0000.edf" )
im = int_im
float_im=int_im.astype(np.float32)
labelc = np.zeros( im.shape, np.int32 )
labelm = np.zeros( im.shape, np.int32 )
work = np.zeros( im.shape, np.int8 )
end0 = time.time()
nc = cImageD11.connectedpixels( float_im, labelc, 1000 )
end1 = time.time()
rc = cImageD11.blobproperties( float_im, labelc, nc, 0 )
cImageD11.blob_moments(rc)
end2 = time.time()
print(nc,"%.3f %.3f"%((end1-end0)*1000,(end2-end1)*1000))
wfloatim = np.where( float_im > 1000, float_im, float_im)
end0 = time.time()
nw = cImageD11.localmaxlabel( wfloatim, labelm, work )
end1 = time.time()
rw = cImageD11.blobproperties( wfloatim, labelm, nw, 0 )
cImageD11.blob_moments(rw)
end2 = time.time()
print(nw,"%.3f %.3f"%((end1-end0)*1000,(end2-end1)*1000))
if 0:
pks=np.array(pks).T
