def process(self, dataset, i):
print 'Register Data %s with mask...' % (self.ini.file.name_result[i])
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'],
1,
useMask=True)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
for j in range(3):
self.sheet.write(j + 1, i + 2, mean_dis[j])
self.sheet.write(4, i + 2, mean_whole)
self.book.save(self.path + self.ini.file.savedir + 'mask.xls')
del data, point, resultData
print 'Register Data %s without mask...' % (
self.ini.file.name_result[i])
data, point, para = self.icp.register(dataset['fix'], dataset['mov'],
1)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
for j in range(3):
self.sheet.write(j + 5, i + 2, mean_dis[j])
self.sheet.write(8, i + 2, mean_whole)
self.book.save(self.path + self.ini.file.savedir + 'mask.xls')
del data, point, resultData
def process(self, dataset, k, i):
self.sheet.write(0, k * 20 + i + 1, self.ini.file.name_result[i] + str(k))
print 'Register Data %s...' % self.ini.file.name_result[i]
if k == 0:
data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 1, op = True)
elif k == 1:
data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 1)
elif k == 2:
data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 0, op = True)
else:
data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 0)
resultData = db.ResultData(data, db.ImageInfo(dataset['fix'].info.data), point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
mean_dis, mean_whole, max_dis, max_whole = self.contourerror.analysis(resultData, dataset['fix'].getPointSet('Contour').copy())
self.sheet.write(1, k * 20 + i + 1, mean_whole)
mean_dis, mean_whole, max_dis, max_whole = self.contourareaerror.analysis(resultData, dataset['fix'].getPointSet('Contour').copy())
self.sheet.write(2, k * 20 + i + 1, mean_whole)
mean_dis, mean_whole, max_dis, max_whole = self.contourweigherror.analysis(resultData, dataset['fix'].getPointSet('Contour').copy())
self.sheet.write(3, k * 20 + i + 1, mean_whole)
mean_dis, mean_whole, max_dis, max_whole = self.contourweigherror.analysis(resultData, dataset['fix'].getPointSet('Contour').copy(), True)
self.sheet.write(4, k * 20 + i + 1, mean_whole)
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
self.book.save(self.path + self.ini.file.savedir + 'AllTest.xls')
del data, point, resultData, para
def process(self, dataset, i):
# ICP with centerline
print 'Register Data %s with ICP(centerline)...' % self.ini.file.name_result[
i]
for sample in range(self.len):
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'],
0,
MaxRate=self.para[sample],
op=False)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Downsample %d Done!' % (sample)
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
self.error[sample, 0] += mean_whole
self.error[sample, 1] += mean_whole**2
del data, point, resultData
def process(self, dataset, i, k):
print 'Register Data %s with ICP(centerline)...(Type %d)' % (
self.ini.file.name_result[i], k)
dataset['fix'].pointSet.data['Centerline'] = calCenterlineFromContour(
dataset['fix'].pointSet.data, k, dataset['fix'].getData())
dataset['mov'].pointSet.data['Centerline'] = calCenterlineFromContour(
dataset['mov'].pointSet.data, k, dataset['mov'].getData())
data, point, para = self.icp.register(dataset['fix'], dataset['mov'],
1)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
for j in range(3):
self.sheet.write(j + 1 + 4 * k, i + 2, float(mean_dis[j]))
self.sheet.write(4 + 4 * k, i + 2, mean_whole)
self.book.save('./Result/Center_merge.xls')
del data, point, resultData
def loadDicomInfo(self, dir, dimension):
# Only available for special data (Need to modify for more universal usage)
info = db.ImageInfo()
data = dicom.read_file(dir)
modality = data.Modality
info.addData('modality', modality)
if modality == 'MR' or modality == 'CT':
ps = data.PixelSpacing
if modality == 'MR':
z = data.SpacingBetweenSlices
else:
z = data.SliceThickness
if dimension == 3:
resolution = [float(z), float(ps[0]), float(ps[1])]
else:
resolution = [float(ps[0]), float(ps[1])]
resolution = npy.array(resolution)
info.addData('resolution', resolution)
orientation = npy.array(map(float, data.ImageOrientationPatient))
info.addData('orientation', orientation)
elif modality == 'US':
r = data[0x200d, 0x3303].value
resolution = npy.array([float(r[2]), float(r[1]), float(r[0])])
info.addData('resolution', resolution)
orientation = npy.array(map(float, data[0x200d, 0x3d00].value[0][0x0020, 0x9116].value[0][0x200d, 0x3d16].value))
info.addData('orientation', orientation)
# To make the orientation of images compatible
view, flip = db.getViewAndFlipFromOrientation(orientation, resolution.shape[0])
info.addData('view', view)
info.addData('flip', flip)
return info
def process(self, dataset, i):
# ICP with centerline
print 'Register Data %s with ICP(centerline)...' % self.ini.file.name_result[
i]
for sample in range(1, 11):
if dataset['mov'].getResolution()[-1] < 0.2:
times = 2
else:
times = 1
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'], 1, False, 0,
9999.0, sample * times)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Downsample %d Done!' % (sample)
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
self.error[sample - 1, :3] += mean_dis
self.error[sample - 1, 3] += mean_whole
del data, point, resultData
def KeyPressCallback(self, obj, event):
ch = self.parent.window_interactor.GetKeySym()
if ch == 'Return':
if (self.X1, self.Y1) == (self.X2, self.Y2):
return
point = npy.round(self.getAllPoint())
if self.parent.dimension:
max = npy.max(point, axis=0)
min = npy.min(point, axis=0)
bound = [(min[i], max[i] + 1) for i in range(2)]
bound = bound[::-1]
else:
point[0, self.parent.view] = 0
point[1,
self.parent.view] = self.parent.parent.getData().getData(
).shape[0] - 1
max = npy.max(point, axis=0)
min = npy.min(point, axis=0)
bound = [(min[i], max[i] + 1) for i in range(3)]
bound = bound[::-1]
info = db.ImageInfo(self.parent.parent.getData().getInfo().data)
info.setName(None)
if not self.parent.dimension:
orientation = npy.array([1, 0, 0, 0, 1, 0])
info.addData('orientation', orientation)
resolution = self.parent.parent.getData().getResolution()[::-1]
info.addData('resolution', resolution)
view, flip = db.getViewAndFlipFromOrientation(
orientation, resolution.shape[0])
info.addData('view', view)
info.addData('flip', flip)
info.addData(
'clip',
npy.array([
bound[0][0], bound[0][1], bound[1][0], bound[1][1],
bound[2][0], bound[2][1]
]))
data = db.BasicData(
data=self.parent.parent.getData().getData()[
bound[0][0]:bound[0][1], bound[1][0]:bound[1][1],
bound[2][0]:bound[2][1]],
info=info)
else:
info.addData(
'clip',
npy.array(
[bound[0][0], bound[0][1], bound[1][0], bound[1][1]]))
data = db.BasicData(
data=self.parent.parent.getData().getData()[
bound[0][0]:bound[0][1], bound[1][0]:bound[1][1]],
info=info)
self.parent.parent.gui.addNewDataView(data)
def process(self, dataset, i):
# ICP with centerline
print 'Register Data %s with ICP(centerline)...' % self.ini.file.name_result[i]
for i in range(len(self.dis)):
data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 1, w_wrong = self.dis[i]) # CLICP
#data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 0, False, delta) #SICP
resultData = db.ResultData(data, db.ImageInfo(dataset['fix'].info.data), point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Weight %f Done!' % self.dis[i]
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(resultData, dataset['fix'].getPointSet('Contour').copy(), dataset['mov'].getPointSet('Contour').copy(), dataset['mov'].getPointSet('Mask').copy(), dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
self.error[i] += mean_whole
del data, point, resultData
def process(self, dataset, i):
# ICP with centerline
print 'Register Data %s with ICP(centerline)...' % self.ini.file.name_result[i]
for i in self.dis:
for j in self.dis:
data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 1, down_fix = i, down_mov = j, MaxRate = 1.0) # CLICP
#data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 0, False, delta) #SICP
#data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 1, False, delta, op = True) #CICP
#data, point, para = self.icp.register(dataset['fix'], dataset['mov'], 0, False, delta, op = True) #SLICP
resultData = db.ResultData(data, db.ImageInfo(dataset['fix'].info.data), point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Sample (%d, %d) Done!' % (i, j)
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(resultData, dataset['fix'].getPointSet('Contour').copy(), dataset['mov'].getPointSet('Contour').copy(), dataset['mov'].getPointSet('Mask').copy(), dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
self.error[i - 1, j - 1] += mean_whole
del data, point, resultData
def run(self, *args, **kwargs):
indexes = self.gui.getRegisterDataIndex()
if indexes:
if len(indexes) == 2:
data, point, para = self.register(
self.gui.dataModel[indexes[0]],
self.gui.dataModel[indexes[1]])
if data is None:
return
resultData = db.ResultData(
data,
db.ImageInfo(self.gui.dataModel[indexes[0]].info.data),
point)
resultData.addDetail('fix', indexes[0])
resultData.addDetail('move', indexes[1])
resultData.addDetail('transform', para)
resultData.setName(None)
return resultData
def process(self, dataset, i):
'''
mean_dis, mean_whole, max_dis, max_whole = self.contourerror.analysis(dataset['seg'], dataset['fix'].getPointSet('Contour').copy())
print 'Segmentation Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
self.sheet1.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet1.write(j + 1, i + 2, mean_dis[j])
self.sheet1.write(4, i + 2, mean_whole)
self.book.save(self.path + self.ini.file.savedir + 'Test_segmentation.xls')
'''
# ICP with centerline
print 'Register Data %s with ICP(centerline)...' % self.ini.file.name_result[
i]
data, point, para = self.icp.register(dataset['seg'], dataset['mov'],
1)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getResolution().tolist())
#mean_dis, mean_whole, max_dis, max_whole = self.contourerror.analysis(resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
#dice_index, dice_index_all = self.areaerror.analysis(resultData, dataset['fix'].getPointSet('Contour').copy())
#print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet2.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet2.write(j + 1, i + 2, mean_dis[j])
self.sheet2.write(j + 5, i + 2, max_dis[j])
#self.sheet2.write(j + 9, i + 2, dice_index[j])
self.sheet2.write(4, i + 2, mean_whole)
self.sheet2.write(8, i + 2, max_whole)
#self.sheet2.write(12, i + 2, dice_index_all)
self.book.save(self.path + self.ini.file.savedir +
'Test_segmentation_surface.xls')
del data, point, resultData
def getInfo(self, res=[1.0, 1.0, 1.0], ori=0):
info = db.ImageInfo()
info.addData('modality', 'MR')
resolution = npy.array(res)
info.addData('resolution', resolution)
if ori == 0: # z
orientation = npy.array([1, 0, 0, 0, 1, 0])
elif ori == 1: # y
orientation = npy.array([1, 0, 0, 0, 0, -1])
elif ori == 2: # x
orientation = npy.array([0, 1, 0, 0, 0, -1])
info.addData('orientation', orientation)
view, flip = db.getViewAndFlipFromOrientation(orientation,
resolution.shape[0])
info.addData('view', view)
info.addData('flip', flip)
return info
def process(self, dataset, i):
# ICP with centerline
print 'Register Data %s with ICP(centerline)...' % self.ini.file.name_result[
i]
for fov in range(7):
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'], 1, False, 0,
9999.0, 1, fov + 1)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'FOV %dmm Done!' % (fov + 1)
mean_dis, mean_whole, max_dis, max_whole = self.contourerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
self.error[fov, :3] += mean_dis
self.error[fov, 3] += mean_whole
del data, point, resultData
def process(self, dataset, i):
print 'Register Data %s with ICP(centerline) with label...' % self.ini.file.name_result[
i]
data, point, para = self.icp.register(dataset['fix'], dataset['mov'],
1)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
print 'Evaluation Data %s...' % self.ini.file.name_result[i]
mean_dis, mean_whole, max_dis, max_whole, result = self.contourerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(), True)
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
print result
for cnt in range(3):
for x in result[cnt].keys():
self.result[cnt][x] = self.result[cnt].get(x,
0) + result[cnt][x]
self.resultCnt[cnt][x] = self.resultCnt[cnt].get(x, 0) + 1
def process(self, dataset, i):
def autoDetectContour(point, cnt, start, end, delta, res, type):
self.new_points = npy.append(self.new_points, point, 0)
points = point[:, :-2]
d = 20
count = 0
for i in range(start + delta, end + delta, delta):
center = calCentroidFromContour(points).reshape(2)
image = dataset[type].getData()[i, :, :].transpose().copy()
image = (image - npy.min(image)) / (npy.max(image) -
npy.min(image)) * 255
down = npy.max([npy.ceil(center[0] - d / res[0]), 0])
up = npy.min(
[npy.floor(center[0] + d / res[0]), image.shape[0]])
left = npy.max([npy.ceil(center[1] - d / res[1]), 0])
right = npy.min(
[npy.floor(center[1] + d / res[1]), image.shape[1]])
crop_image = image[down:up, left:right]
center -= [down, left]
result = ac_segmentation(center, crop_image)
a1 = ac_area(points.transpose(), image.shape)
a2 = ac_area(result, crop_image.shape)
rate = a2 * 1.0 / a1
if rate >= min(1.5 + count * 0.2, 2.1) or rate <= 0.7:
temp_array = points.copy()
if cnt != 1 and rate > 0.7:
count += 1
else:
temp_array = result.transpose().copy()
temp_array[:, :2] += [down, left]
count = 0
points = temp_array.copy()
temp_array = npy.insert(temp_array, 2, [[i], [cnt]], 1)
self.new_points = npy.append(self.new_points, temp_array, 0)
sys.stdout.write(str(i) + ',')
sys.stdout.flush()
print ' '
# Segmentation of data
print 'Segment Data %s...' % self.ini.file.name_result[i]
tmp = dataset['fix'].pointSet.data['Contour']
tmp = tmp[tmp[:, 0] >= 0]
self.new_points = npy.array([[-1, -1, -1, -1]], dtype=npy.float32)
bottom = int(npy.round(npy.min(tmp[:, 2])))
bif = int(db.getBifurcation(tmp) + 0.5)
up = int(npy.round(npy.max(tmp[:, 2])))
bottom += (bif - bottom) / 2
up -= (up - bif) / 2
point_vital = [0] * 3
point_vital[0] = tmp[(npy.round(tmp[:, -1]) == 0)
& (npy.round(tmp[:, 2]) == bottom)].copy()
point_vital[1] = tmp[(npy.round(tmp[:, -1]) == 1)
& (npy.round(tmp[:, 2]) == up)].copy()
point_vital[2] = tmp[(npy.round(tmp[:, -1]) == 2)
& (npy.round(tmp[:, 2]) == up)].copy()
autoDetectContour(point_vital[0], 0, bottom, bif, 1,
dataset['fix'].getResolution().tolist(), 'fix')
autoDetectContour(point_vital[1], 1, up, bif, -1,
dataset['fix'].getResolution().tolist(), 'fix')
autoDetectContour(point_vital[2], 2, up, bif, -1,
dataset['fix'].getResolution().tolist(), 'fix')
print ' '
print 'Finish segmentation for fix data. '
pointset = {'Contour': self.new_points}
dataset['fix'].pointSet.data['Centerline'] = calCenterlineFromContour(
pointset)
self.new_points_fix = self.new_points.copy()
# For mov data
tmp = dataset['mov'].pointSet.data['Contour']
tmp = tmp[tmp[:, 0] >= 0]
self.new_points = npy.array([[-1, -1, -1, -1]], dtype=npy.float32)
bottom = int(npy.round(npy.min(tmp[:, 2])))
bif = int(db.getBifurcation(tmp) + 0.5)
up = int(npy.round(npy.max(tmp[:, 2])))
bottom += (bif - bottom) / 2
up -= (up - bif) / 2
point_vital = [0] * 3
point_vital[0] = tmp[(npy.round(tmp[:, -1]) == 0)
& (npy.round(tmp[:, 2]) == bottom)].copy()
point_vital[1] = tmp[(npy.round(tmp[:, -1]) == 1)
& (npy.round(tmp[:, 2]) == up)].copy()
point_vital[2] = tmp[(npy.round(tmp[:, -1]) == 2)
& (npy.round(tmp[:, 2]) == up)].copy()
autoDetectContour(point_vital[0], 0, bottom, bif, 1,
dataset['mov'].getResolution().tolist(), 'mov')
autoDetectContour(point_vital[1], 1, up, bif, -1,
dataset['mov'].getResolution().tolist(), 'mov')
autoDetectContour(point_vital[2], 2, up, bif, -1,
dataset['mov'].getResolution().tolist(), 'mov')
print ' '
print 'Finish segmentation for mov data. '
pointset = {'Contour': self.new_points}
dataset['mov'].pointSet.data['Centerline'] = calCenterlineFromContour(
pointset)
self.new_points_mov = self.new_points.copy()
# ICP with centerline without label
print 'Register Data %s with ICP(centerline) without label...' % self.ini.file.name_result[
i]
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'],
1,
op=True)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
dice_index, dice_index_all = self.areaerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet2.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet2.write(j + 1, i + 2, mean_dis[j])
self.sheet2.write(j + 5, i + 2, max_dis[j])
self.sheet2.write(j + 9, i + 2, dice_index[j])
self.sheet2.write(4, i + 2, mean_whole)
self.sheet2.write(8, i + 2, max_whole)
self.sheet2.write(12, i + 2, dice_index_all)
self.book.save(self.path + self.ini.file.savedir +
'multicontrast_seg_feature.xls')
del data, point, resultData
# ICP with centerline with label
print 'Register Data %s with ICP(centerline) with label...' % self.ini.file.name_result[
i]
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'],
1,
op=False)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
dice_index, dice_index_all = self.areaerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet4.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet4.write(j + 1, i + 2, mean_dis[j])
self.sheet4.write(j + 5, i + 2, max_dis[j])
self.sheet4.write(j + 9, i + 2, dice_index[j])
self.sheet4.write(4, i + 2, mean_whole)
self.sheet4.write(8, i + 2, max_whole)
self.sheet4.write(12, i + 2, dice_index_all)
self.book.save(self.path + self.ini.file.savedir +
'multicontrast_seg_feature.xls')
del data, point, resultData
fix_points = dataset['fix'].getPointSet('Contour').copy()
dataset['fix'].pointSet.data['Contour'] = self.new_points_fix
mov_points = dataset['mov'].getPointSet('Contour').copy()
dataset['mov'].pointSet.data['Contour'] = self.new_points_mov
print 'Saving Data %s...' % self.ini.file.name_result[i]
db.saveMatData(
self.path + self.ini.file.savedir + self.ini.file.name_result[i] +
'_snap.mat', [dataset['fix']], 0)
db.saveMatData(
self.path + self.ini.file.savedir + self.ini.file.name_result[i] +
'_merge.mat', [dataset['mov']], 0)
print 'Done!'
# ICP with contour without label
print 'Register Data %s with ICP(contour) without label...' % self.ini.file.name_result[
i]
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'],
0,
op=False)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, fix_points.copy(), mov_points.copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
para = resultData.info.getData('transform')
R = ml.mat(para[:9]).reshape(3, 3)
T = ml.mat(para[9:12]).T
T = R.I * T
T = -T
tmp_con, result_center_points = util.resliceTheResultPoints(
mov_points, None, 20, dataset['mov'].getResolution().tolist(),
dataset['fix'].getResolution().tolist(), False, R, T)
resultData.pointSet.data['Contour'] = tmp_con
dice_index, dice_index_all = self.areaerror.analysis(
resultData, fix_points.copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet1.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet1.write(j + 1, i + 2, mean_dis[j])
self.sheet1.write(j + 5, i + 2, max_dis[j])
self.sheet1.write(j + 9, i + 2, dice_index[j])
self.sheet1.write(4, i + 2, mean_whole)
self.sheet1.write(8, i + 2, max_whole)
self.sheet1.write(12, i + 2, dice_index_all)
self.book.save(self.path + self.ini.file.savedir +
'multicontrast_seg_feature.xls')
del data, point, resultData
# ICP with contour with label
print 'Register Data %s with ICP(contour) with label...' % self.ini.file.name_result[
i]
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'],
0,
op=True)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, fix_points.copy(), mov_points.copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
para = resultData.info.getData('transform')
R = ml.mat(para[:9]).reshape(3, 3)
T = ml.mat(para[9:12]).T
T = R.I * T
T = -T
tmp_con, result_center_points = util.resliceTheResultPoints(
mov_points, None, 20, dataset['mov'].getResolution().tolist(),
dataset['fix'].getResolution().tolist(), False, R, T)
resultData.pointSet.data['Contour'] = tmp_con
dice_index, dice_index_all = self.areaerror.analysis(
resultData, fix_points.copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet3.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet3.write(j + 1, i + 2, mean_dis[j])
self.sheet3.write(j + 5, i + 2, max_dis[j])
self.sheet3.write(j + 9, i + 2, dice_index[j])
self.sheet3.write(4, i + 2, mean_whole)
self.sheet3.write(8, i + 2, max_whole)
self.sheet3.write(12, i + 2, dice_index_all)
self.book.save(self.path + self.ini.file.savedir +
'multicontrast_seg_feature.xls')
del data, point, resultData
del self.new_points, fix_points, self.new_points_fix, self.new_points_mov, mov_points, tmp_con, result_center_points
def process(self, dataset, i):
def autoDetectContour(point, cnt, start, end, delta):
self.new_points = npy.append(self.new_points, point, 0)
points = point[:, :-2]
count = 0
for j in range(start + delta, end + delta, delta):
center = calCentroidFromContour(points).reshape(2)
image = dataset['fix'].getData()[j, :, :].transpose().copy()
image = (image - npy.min(image)) / (npy.max(image) -
npy.min(image)) * 255
result = ac_segmentation(center, image)
a1 = ac_area(points.transpose(), image.shape)
a2 = ac_area(result, image.shape)
rate = a2 * 1.0 / a1
if rate >= min(1.5 + count * 0.2, 2.1) or rate <= 0.7:
temp_array = points.copy()
if cnt != 1 and rate > 0.7:
count += 1
else:
temp_array = result.transpose().copy()
count = 0
points = temp_array.copy()
temp_array = npy.insert(temp_array, 2, [[j], [cnt]], 1)
self.new_points = npy.append(self.new_points, temp_array, 0)
sys.stdout.write(str(j) + ',')
sys.stdout.flush()
print ' '
print 'Segment Data %s...' % self.ini.file.name_result[i]
tmp = dataset['fix'].pointSet.data['Contour']
tmp = tmp[tmp[:, 0] >= 0]
self.new_points = npy.array([[-1, -1, -1, -1]], dtype=npy.float32)
time1 = time.time()
bottom = int(npy.round(npy.min(tmp[:, 2])))
bif = int(db.getBifurcation(tmp) + 0.5)
up = int(npy.round(npy.max(tmp[:, 2])))
point_vital = [0] * 3
point_vital[0] = tmp[(npy.round(tmp[:, -1]) == 0)
& (npy.round(tmp[:, 2]) == bottom)].copy()
point_vital[1] = tmp[(npy.round(tmp[:, -1]) == 1)
& (npy.round(tmp[:, 2]) == up)].copy()
point_vital[2] = tmp[(npy.round(tmp[:, -1]) == 2)
& (npy.round(tmp[:, 2]) == up)].copy()
autoDetectContour(point_vital[0], 0, bottom, bif, 1)
autoDetectContour(point_vital[1], 1, up, bif, -1)
autoDetectContour(point_vital[2], 2, up, bif, -1)
time2 = time.time()
'''
# Use centerline for contour
j = 0
for center in tmp:
image = dataset['fix'].getData()[npy.round(center[2]), :, :].transpose().copy()
image = (image - npy.min(image)) / (npy.max(image) - npy.min(image)) * 255
result = ac_segmentation(center[:2], image)
point_array = npy.insert(result.transpose(), 2, [[center[2]],[center[3]]], axis = 1)
new_points = npy.append(new_points, point_array, 0)
j += 1
if j % 10 == 0:
sys.stdout.write(str(j) + ',')
sys.stdout.flush()
'''
print ' '
print 'Done! Time for segmentation is %0.2fs' % (time2 - time1)
pointset = {'Contour': self.new_points}
pointset['Centerline'] = calCenterlineFromContour(pointset)
print 'Saving Data %s...' % self.ini.file.name_result[i]
new_data = db.BasicData(dataset['fix'].data,
db.ImageInfo(dataset['fix'].info.data),
pointset)
db.saveMatData(
self.savepath + self.ini.file.name_result[i] + '_mr.mat',
[new_data], 0)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.contourerror.analysis(
new_data, dataset['fix'].getPointSet('Contour').copy())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
self.sheet1.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet1.write(j + 1, i + 2, mean_dis[j])
self.sheet1.write(4, i + 2, mean_whole)
self.sheet1.write(5, i + 2, time2 - time1)
self.book.save(self.path + self.ini.file.savedir +
'Test_segmentation_final_refined.xls')
# ICP with centerline
print 'Register Data %s with ICP(centerline)...' % self.ini.file.name_result[
i]
time1 = time.time()
data, point, para = self.icp.register(new_data, dataset['mov'], 1)
time2 = time.time()
print 'Done! Time for registration is %0.2fs' % (time2 - time1)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
mean_dis, mean_whole, max_dis, max_whole = self.contourerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
dice_index, dice_index_all = self.areaerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet2.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet2.write(j + 1, i + 2, mean_dis[j])
self.sheet2.write(j + 5, i + 2, max_dis[j])
self.sheet2.write(j + 9, i + 2, dice_index[j])
self.sheet2.write(4, i + 2, mean_whole)
self.sheet2.write(8, i + 2, max_whole)
self.sheet2.write(12, i + 2, dice_index_all)
self.sheet2.write(13, i + 2, time2 - time1)
self.book.save(self.path + self.ini.file.savedir +
'Test_segmentation_final_refined2.xls')
del data, point, resultData
def process(self, dataset, i):
# ICP with contour without label
print 'Register Data %s with ICP(contour) without label...' % self.ini.file.name_result[
i]
data, point, para, time = self.icp.register(dataset['fix'],
dataset['mov'],
0,
op=False,
isTime=True)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
dice_index, dice_index_all = self.areaerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet1.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet1.write(j + 1, i + 2, mean_dis[j])
self.sheet1.write(j + 5, i + 2, max_dis[j])
self.sheet1.write(j + 9, i + 2, dice_index[j])
self.sheet1.write(4, i + 2, mean_whole)
self.sheet1.write(8, i + 2, max_whole)
self.sheet1.write(12, i + 2, dice_index_all)
self.sheet1.write(13, i + 2, time)
self.book.save(self.path + self.ini.file.savedir + 'snap_feature.xls')
del data, point, resultData
# ICP with centerline without label
print 'Register Data %s with ICP(centerline) without label...' % self.ini.file.name_result[
i]
data, point, para, time = self.icp.register(dataset['fix'],
dataset['mov'],
1,
op=True,
isTime=True)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
dice_index, dice_index_all = self.areaerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet2.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet2.write(j + 1, i + 2, mean_dis[j])
self.sheet2.write(j + 5, i + 2, max_dis[j])
self.sheet2.write(j + 9, i + 2, dice_index[j])
self.sheet2.write(4, i + 2, mean_whole)
self.sheet2.write(8, i + 2, max_whole)
self.sheet2.write(12, i + 2, dice_index_all)
self.sheet2.write(13, i + 2, time)
self.book.save(self.path + self.ini.file.savedir + 'snap_feature.xls')
del data, point, resultData
# ICP with contour with label
print 'Register Data %s with ICP(contour) with label...' % self.ini.file.name_result[
i]
data, point, para, time = self.icp.register(dataset['fix'],
dataset['mov'],
0,
op=True,
isTime=True)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
dice_index, dice_index_all = self.areaerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet3.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet3.write(j + 1, i + 2, mean_dis[j])
self.sheet3.write(j + 5, i + 2, max_dis[j])
self.sheet3.write(j + 9, i + 2, dice_index[j])
self.sheet3.write(4, i + 2, mean_whole)
self.sheet3.write(8, i + 2, max_whole)
self.sheet3.write(12, i + 2, dice_index_all)
self.sheet3.write(13, i + 2, time)
self.book.save(self.path + self.ini.file.savedir + 'snap_feature.xls')
del data, point, resultData
# ICP with centerline with label
print 'Register Data %s with ICP(centerline) with label...' % self.ini.file.name_result[
i]
data, point, para, time = self.icp.register(dataset['fix'],
dataset['mov'],
1,
op=False,
isTime=True)
resultData = db.ResultData(data,
db.ImageInfo(dataset['fix'].info.data),
point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
print 'Done!'
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
print 'Contour Error Done! Whole mean is %0.2fmm.' % mean_whole
dice_index, dice_index_all = self.areaerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy())
print 'Area Error Done! Whole Dice index is %0.3f.' % dice_index_all
self.sheet4.write(0, i + 2, self.ini.file.name_result[i])
for j in range(3):
self.sheet4.write(j + 1, i + 2, mean_dis[j])
self.sheet4.write(j + 5, i + 2, max_dis[j])
self.sheet4.write(j + 9, i + 2, dice_index[j])
self.sheet4.write(4, i + 2, mean_whole)
self.sheet4.write(8, i + 2, max_whole)
self.sheet4.write(12, i + 2, dice_index_all)
self.sheet4.write(13, i + 2, time)
self.book.save(self.path + self.ini.file.savedir + 'time_feature.xls')
del data, point, resultData
def register(self, fixedData, movingData, index = -1, isRigid = False, isTime = False): # For simple test
if index == -1:
if self.gui is not None:
index = self.gui.getDataIndex({'Contour': 0, 'Centerline': 1}, 'Select the object')
else:
index = 1
if index is None:
return None, None, None
if index == 0:
fixed_points = fixedData.getPointSet('Contour')
moving_points = movingData.getPointSet('Contour')
else:
fixed_points = fixedData.getPointSet('Centerline')
moving_points = movingData.getPointSet('Centerline')
time1 = time.time()
# Initial data
fixed_res = fixedData.getResolution().tolist()
moving_res = movingData.getResolution().tolist()
fixed_points_con = fixedData.getPointSet('Contour')
moving_points_con = movingData.getPointSet('Contour')
fixed_points_cen = fixedData.getPointSet('Centerline')
moving_points_cen = movingData.getPointSet('Centerline')
fixed_points_ori = fixed_points.copy()[npy.where(fixed_points[:, 0] >= 0)]
moving_points_ori = moving_points.copy()[npy.where(moving_points[:, 0] >= 0)]
fixed_points_con_ori = fixed_points_con.copy()[npy.where(fixed_points_con[:, 0] >= 0)]
moving_points_con_ori = moving_points_con.copy()[npy.where(moving_points_con[:, 0] >= 0)]
fixed_points_cen_ori = fixed_points_cen.copy()[npy.where(fixed_points_cen[:, 0] >= 0)]
moving_points_cen_ori = moving_points_cen.copy()[npy.where(moving_points_cen[:, 0] >= 0)]
fixed_points = fixed_points_ori.copy()
moving_points = moving_points_ori.copy()
fixed_points_con = fixed_points_con_ori.copy()
moving_points_con = moving_points_con_ori.copy()
fixed_points_cen = fixed_points_cen_ori.copy()
moving_points_cen = moving_points_cen_ori.copy()
init_time = 0.0
time1 = time.time()
fix_img = fixedData.getData()
mov_img = movingData.getData()
# Calculate the initial rigid transformation for 9 points T0
fix_key_point = eutil.getKeyPoints(fixed_points_cen, fixed_res)
mov_key_point = eutil.getKeyPoints(moving_points_cen, moving_res)
T0, mov_bif = eutil.getRigidTransform(fix_key_point, mov_key_point) # 4 * 4 Matrix
moving_points = eutil.applyRigidTransformOnPoints(moving_points, moving_res, T0)
moving_points_con = eutil.applyRigidTransformOnPoints(moving_points_con, moving_res, T0)
moving_points_cen_result = eutil.applyRigidTransformOnPoints(moving_points_cen, moving_res, T0)
crop_fixed_index, crop_moving_index = eutil.cropCenterline(fixed_points_cen, moving_points_cen_result, fixed_res, moving_res, fix_key_point[0, 2] / fixed_res[2], mov_bif[2] / moving_res[2])
# Use GMMREG for centerline-based rigid registration T1
gmm = GmmregPointsetRegistration(self.gui)
new_fixedData = db.BasicData(fix_img, db.ImageInfo(fixedData.getInfo().data),
{'Contour': fixed_points_con, 'Centerline': fixed_points_cen[crop_fixed_index]})
new_movingData = db.BasicData(mov_img, db.ImageInfo(movingData.getInfo().data),
{'Contour': moving_points_con, 'Centerline': moving_points_cen_result[crop_moving_index]})
tmp_img, points, para = gmm.register(new_fixedData, new_movingData, index, False, "rigid")
T1 = eutil.getMatrixFromGmmPara(para)
T_init = T0 * T1
moving_points = points['Contour'].copy()
moving_points_cen_result = points['Centerline'].copy()
del new_movingData
# Use GMMREG for centerline-based TPS registration
if not isRigid:
new_movingData = db.BasicData(mov_img, db.ImageInfo(fixedData.getInfo().data),
{'Contour': moving_points, 'Centerline': moving_points_cen_result}) # The image has been resampled into fixed resolution
tmp_img, points, para = gmm.register(new_fixedData, new_movingData, index, False, "EM_TPS")
time2 = time.time()
sa = SurfaceErrorAnalysis(None)
dataset = db.BasicData(npy.array([[[0]]]), fixedData.getInfo(), points)
mean_dis, mean_whole, max_dis, max_whole = sa.analysis(dataset, point_data_fix = fixed_points_con.copy(), useResult = True)
del dataset
print mean_dis
print mean_whole
if isTime:
return tmp_img, points, [mean_dis, mean_whole], time2 - time1
return tmp_img, points, [mean_dis, mean_whole]
def process(self, dataset, i):
# ICP with centerline
print 'Register Data %s with ICP...' % self.ini.file.name_result[i]
tmp = dataset['mov'].pointSet.data['Contour'].copy()
for sd in range(0, 16):
mean_dis_all = npy.zeros([4, 3], dtype=npy.float32)
mean_whole_all = npy.zeros([4, 1], dtype=npy.float32)
if sd > 0:
repeat = self.repeat
else:
repeat = 1
for i in range(repeat):
dataset['mov'].pointSet.data['Contour'] = AddNoise(
tmp,
float(sd) / 5)
dataset['mov'].pointSet.data[
'Centerline'] = calCenterlineFromContour(
dataset['mov'].pointSet.data)
# Centerline label
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'], 1)
resultData = db.ResultData(
data, db.ImageInfo(dataset['fix'].info.data), point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
mean_dis_all[0, :] += mean_dis
mean_whole_all[0] += mean_whole
del data, point, resultData, para
# Contour label
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'],
0,
op=True)
resultData = db.ResultData(
data, db.ImageInfo(dataset['fix'].info.data), point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
mean_dis_all[1, :] += mean_dis
mean_whole_all[1] += mean_whole
del data, point, resultData, para
# Centerline no-label
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'],
1,
op=True)
resultData = db.ResultData(
data, db.ImageInfo(dataset['fix'].info.data), point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
mean_dis_all[2, :] += mean_dis
mean_whole_all[2] += mean_whole
del data, point, resultData, para
# Contour no-label
data, point, para = self.icp.register(dataset['fix'],
dataset['mov'], 0)
resultData = db.ResultData(
data, db.ImageInfo(dataset['fix'].info.data), point)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', para)
mean_dis, mean_whole, max_dis, max_whole = self.surfaceerror.analysis(
resultData, dataset['fix'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Contour').copy(),
dataset['mov'].getPointSet('Mask').copy(),
dataset['mov'].getResolution().tolist())
mean_dis_all[3, :] += mean_dis
mean_whole_all[3] += mean_whole
del data, point, resultData, para
sys.stdout.write(str(i) + ',')
sys.stdout.flush()
mean_dis_all /= repeat
mean_whole_all /= repeat
print ' '
print 'Noise level %fmm Done!' % (float(sd) / 5)
print 'Contour Error Done! Whole mean is %0.2fmm vs %0.2fmm.' % (
mean_whole_all[0], mean_whole_all[1])
for i in range(4):
self.error[i, sd, :3] += mean_dis_all[i, :]
self.error[i, sd, 3] += mean_whole_all[i]
def register(self, fixedData, movingData, regPara = [(40.0, 1000.0, "SSD")], w2 = 1.0, true_fixed_points = None, true_moving_points = None): # For simple test
# Initial data
fixed_res = fixedData.getResolution().tolist()
moving_res = movingData.getResolution().tolist()
fixed_points = fixedData.getPointSet('Contour')
moving_points = movingData.getPointSet('Contour')
fixed_points_cen = fixedData.getPointSet('Centerline')
moving_points_cen = movingData.getPointSet('Centerline')
fixed_points_ori = fixed_points.copy()[npy.where(fixed_points[:, 0] >= 0)]
moving_points_ori = moving_points.copy()[npy.where(moving_points[:, 0] >= 0)]
fixed_points_cen_ori = fixed_points_cen.copy()[npy.where(fixed_points_cen[:, 0] >= 0)]
moving_points_cen_ori = moving_points_cen.copy()[npy.where(moving_points_cen[:, 0] >= 0)]
if true_fixed_points is None:
true_fixed_points = fixed_points_ori
if true_moving_points is None:
true_moving_points = moving_points_ori
fixed_points = fixed_points_ori.copy()
moving_points = moving_points_ori.copy()
fixed_points_cen = fixed_points_cen_ori.copy()
moving_points_cen = moving_points_cen_ori.copy()
fix_img = fixedData.getData()
mov_img = movingData.getData()
init_time = 0.0
time1 = time.time()
# Calculate the initial rigid transformation for 9 points T0
fix_key_point = eutil.getKeyPoints(fixed_points_cen, fixed_res)
mov_key_point = eutil.getKeyPoints(moving_points_cen, moving_res)
T0, mov_bif = eutil.getRigidTransform(fix_key_point, mov_key_point) # 4 * 4 Matrix
moving_points = eutil.applyRigidTransformOnPoints(moving_points, moving_res, T0)
moving_points_cen_result = eutil.applyRigidTransformOnPoints(moving_points_cen, moving_res, T0)
crop_fixed_index, crop_moving_index = eutil.cropCenterline(fixed_points_cen, moving_points_cen_result, fixed_res, moving_res, fix_key_point[0, 2] / fixed_res[2], mov_bif[2] / moving_res[2])
# Use GMMREG for centerline-based rigid registration T1
gmm = GmmregPointsetRegistration(self.gui)
new_fixedData = db.BasicData(fix_img, db.ImageInfo(fixedData.getInfo().data),
{'Contour': fixed_points, 'Centerline': fixed_points_cen[crop_fixed_index]})
new_movingData = db.BasicData(mov_img, db.ImageInfo(movingData.getInfo().data),
{'Contour': moving_points, 'Centerline': moving_points_cen_result[crop_moving_index]})
tmp_img, points, para = gmm.register(new_fixedData, new_movingData, 1, False, "rigid")
T1 = eutil.getMatrixFromGmmPara(para)
T_init = T0 * T1
moving_points = points['Contour'].copy()
moving_points_cen_result = points['Centerline'].copy()
del new_movingData
# Use GMMREG for centerline-based TPS registration
new_movingData = db.BasicData(mov_img, db.ImageInfo(fixedData.getInfo().data),
{'Contour': moving_points, 'Centerline': moving_points_cen_result}) # The image has been resampled into fixed resolution
tmp_img, points, para = gmm.register(new_fixedData, new_movingData, 1, False, "EM_TPS")
result_points_cen = points['Centerline'].copy()
result_points_cen = result_points_cen[result_points_cen[:, -1] >= 0]
result_points_cen[:, :3] *= fixed_res
del new_movingData
del new_fixedData
del moving_points_cen_result
# Save the images for Elastix registration
ee.writeImageFile(fixedData, "fix")
ee.writeImageFile(movingData, "mov")
fix_binary_mask = eutil.getBinaryImageFromSegmentation(fix_img, fixed_points_ori)
fix_binary_data = db.BasicData(fix_binary_mask, db.ImageInfo(fixedData.getInfo().data))
ee.writeImageFile(fix_binary_data, "fixmm")
del fix_binary_data
del fix_binary_mask
fix_binary_mask = eutil.getBinaryImageFromSegmentation(fix_img, true_fixed_points)
fix_binary_data = db.BasicData(fix_binary_mask, db.ImageInfo(fixedData.getInfo().data))
ee.writeImageFile(fix_binary_data, "fixmmm")
del fix_binary_data
del fix_binary_mask
mov_binary_mask = eutil.getBinaryImageFromSegmentation(mov_img, moving_points_ori)
mov_binary_data = db.BasicData(mov_binary_mask, db.ImageInfo(movingData.getInfo().data))
ee.writeImageFile(mov_binary_data, "movmm")
del mov_binary_data
del mov_binary_mask
mov_binary_mask = eutil.getBinaryImageFromSegmentation(mov_img, true_moving_points)
mov_binary_data = db.BasicData(mov_binary_mask, db.ImageInfo(movingData.getInfo().data))
ee.writeImageFile(mov_binary_data, "movmmm")
del mov_binary_data
del mov_binary_mask
fix_binary_mask = eutil.getMaskFromCenterline(fix_img, fixed_points_cen_ori, fixed_res)
fix_binary_data = db.BasicData(fix_binary_mask, db.ImageInfo(fixedData.getInfo().data))
ee.writeImageFile(fix_binary_data, "fixm")
del fix_binary_data
del fix_binary_mask
mov_binary_mask = eutil.getMaskFromCenterline(mov_img, moving_points_cen_ori, moving_res)
mov_binary_data = db.BasicData(mov_binary_mask, db.ImageInfo(movingData.getInfo().data))
ee.writeImageFile(mov_binary_data, "movm")
del mov_binary_data
del mov_binary_mask
tmp = moving_points_cen.copy()
tmp[:, :3] *= moving_res
ee.writePointsetFile(tmp[crop_moving_index], "movp.txt")
ee.writePointsetFile(result_points_cen, "fixp.txt")
init_para_inv = eutil.getElastixParaFromMatrix(T_init.I)
ee.writeTransformFile(init_para_inv, fix_img.shape, fixed_res, type = "MI") # For transformation of image
ee.writeTransformFile(init_para_inv, fix_img.shape, fixed_res, "transparassd.txt") # For transformation of image
init_para = eutil.getElastixParaFromMatrix(T_init)
ee.writeTransformFile(init_para, fix_img.shape, fixed_res, "transpara2.txt") # For transformation of points
# Apply the initial transformation (It seems -t0 didn't work in Elastix)
ee.run_executable(type = "transformix", mov = "movp.txt", tp = "transpara2.txt")
ee.writePointsetFileFromResult("Output/outputpoints.txt", "movp0.txt")
tmp = moving_points_ori.copy()
tmp[:, :3] *= moving_res
ee.writePointsetFile(tmp, "mov.txt")
ee.run_executable(type = "transformix", mov = "mov.txt", tp = "transpara2.txt") # Transform the moving segmentation result using initial transformation
ee.writePointsetFileFromResult("Output/outputpoints.txt", "mov0.txt")
ee.changeOutputBSplineOrder("transpara.txt", 3)
ee.run_executable(type = "transformix", mov = "mov.mhd", tp = "transpara.txt", outDir = "")
ee.renameImage("result", "mov0")
ee.changeOutputBSplineOrder("transpara.txt", 0)
ee.run_executable(type = "transformix", mov = "movmm.mhd", tp = "transparassd.txt", outDir = "")
ee.renameImage("result", "movmm0")
ee.run_executable(type = "transformix", mov = "movm.mhd", tp = "transparassd.txt", outDir = "")
ee.renameImage("result", "movm0")
ee.run_executable(type = "transformix", mov = "movmmm.mhd", tp = "transparassd.txt", outDir = "")
ee.renameImage("result", "movmmm0")
sa = SurfaceErrorAnalysis(None)
# Start registration of different parameters
cnt = len(regPara)
result = npy.zeros([cnt, 3], dtype = npy.float32)
fix_img_mask = ee.readImageFile("fixmmm.mhd")
time2 = time.time()
init_time = time2 - time1
for i in range(0, cnt):
if regPara[i][2] == "MI" and regPara[i][1] > 0:
ww = regPara[i][1] / 1000
else:
ww = regPara[i][1]
isRigid = regPara[i][0] < 0
# Save Elastix registration configuration
ee.writeParameterFile("para_rigid.txt", "rigid", regPara[i][2], regPara[i][0], ww, w2)
if not isRigid:
ee.writeParameterFile("para_spline.txt", "bspline", regPara[i][2], regPara[i][0], ww, w2)
# Use Elastix for hybrid registration
if isRigid:
para_elastix = ["para_rigid.txt"]
else:
para_elastix = ["para_rigid.txt", "para_spline.txt"]
if regPara[i][2] == "SSD":
mov_name = "movmm0.mhd"
fix_name = "fixmm.mhd"
else:
mov_name = "mov0.mhd"
fix_name = "fix.mhd"
time1 = time.time()
code = ee.run_executable(type = "elastix", para = para_elastix,
fix = fix_name, mov = mov_name, movm = "movm0.mhd", movp = "movp0.txt", mask = (regPara[i][2] != "SSD"))
time2 = time.time()
if code != 0:
print "Elastix error!"
continue
# Read the output files into self data formats
ee.changeOutputBSplineOrder("Output/TransformParameters.0.txt", 0)
if not isRigid:
ee.changeOutputBSplineOrder("Output/TransformParameters.1.txt", 0)
ee.run_executable(type = "transformix", mov = "movmmm0.mhd", tp = "Output/TransformParameters.1.txt") # Non-rigid transformation
ee.changeOutputInitTransform("Output/TransformParameters.1.txt")
else:
ee.run_executable(type = "transformix", mov = "movmmm0.mhd", tp = "Output/TransformParameters.0.txt")
ee.changeOutputBSplineOrder("Output/TransformParameters.0.txt", 0)
result_img_mask = ee.readImageFile("Output/result.mhd")
if regPara[i][2] == "SSD":
# Transform the segmentation result for evaluation
'''
if isRigid:
result_img_mask = ee.readImageFile("Output/result.0.mhd")
else:
result_img_mask = ee.readImageFile("Output/result.1.mhd")
'''
if cnt == 1:
#if True:
ee.changeOutputBSplineOrder("Output/TransformParameters.0.txt", 3)
if not isRigid:
ee.changeOutputBSplineOrder("Output/TransformParameters.1.txt", 3)
ee.run_executable(type = "transformix", mov = "mov0.mhd", tp = "Output/TransformParameters.1.txt") # Non-rigid transformation
ee.changeOutputInitTransform("Output/TransformParameters.1.txt")
else:
ee.run_executable(type = "transformix", mov = "mov0.mhd", tp = "Output/TransformParameters.0.txt")
result_img = ee.readImageFile("Output/result.mhd")
print i, 'SSD'
else:
if cnt == 1:
#if True:
if isRigid:
result_img = ee.readImageFile("Output/result.0.mhd")
print i, 'Other'
else:
result_img = ee.readImageFile("Output/result.1.mhd")
ee.generateInverseTransformFile("Output/TransformParameters.0.txt", "fix.mhd")
# Delete the mask slice from the moving points
tmp = true_moving_points.copy()
for point in movingData.getPointSet('Mask'):
tmp = npy.delete(tmp, npy.where((npy.abs(tmp[:, 2] - point[2]) < 0.0001) & (npy.round(tmp[:, -1]) == point[3])), axis = 0)
tmp[:, :3] *= moving_res
ee.writePointsetFile(tmp, "movm.txt")
ee.run_executable(type = "transformix", mov = "movm.txt", tp = "transpara2.txt") # Transform the moving segmentation result using initial transformation
ee.writePointsetFileFromResult("Output/outputpoints.txt", "mov0m.txt")
ee.run_executable(type = "transformix", mov = "mov0m.txt", tp = "TransformParameters.0.txt") # Transform the moving segmentation result using rigid transformation
if not isRigid:
ee.generateInverseTransformFile("Output/TransformParameters.1.txt", "fix.mhd")
ee.writePointsetFile(ee.readPointsetFile("Output/outputpoints.txt"), "Output/outputpoints2.txt")
ee.run_executable(type = "transformix", mov = "Output/outputpoints2.txt", tp = "TransformParameters.0.txt") # Non-rigid transformation
result_con = tmp.copy()
result_con[:, :3] = ee.readPointsetFile("Output/outputpoints.txt")
result_con[:, :3] /= fixed_res
result_pointset = {'Contour': result_con}
if cnt > 1:
#if False:
dataset = db.BasicData(npy.array([[[0]]]), fixedData.getInfo(), result_pointset)
mean_dis, mean_whole, max_dis, max_whole = sa.analysis(dataset, point_data_fix = true_fixed_points, useResult = True)
del dataset
dice_index = eutil.calDiceIndexFromMask(fix_img_mask, result_img_mask)
del result_img_mask
del result_pointset
del result_con
result[i, :] = [mean_whole, dice_index, time2 - time1]# + init_time]
print "Result of spacing %fmm, weight %f and metric %s: %fmm, %f. " % (regPara[i][0], ww, regPara[i][2], mean_whole, dice_index)
'''
# Save the result
resultData = db.ResultData(result_img, db.ImageInfo(fixedData.info.data), result_pointset)
resultData.info.addData('fix', 1)
resultData.info.addData('move', 2)
resultData.info.addData('transform', [0, 0, 0])
db.saveMatData('D:/Python src/MIRVAP/Result/Result' + str(i) + '_37L.mat', [resultData, fixedData, movingData], 0)
del resultData
'''
del fix_img_mask
if cnt > 1:
result_img = None
result_pointset = None
else:
result = [0, 0, 0]
return result_img, result_pointset, result
