def testImportExport(self):
"Testing if images can be imported to and from numeric arrays."
imp = vtkImageImportFromArray()
exp = vtkImageExportToArray()
idiff = vtk.vtkImageDifference()
img_dir = Testing.getAbsImagePath("")
for i in glob.glob(os.path.join(img_dir, "*.png")):
# Putting the reader outside the loop causes bad problems.
reader = vtk.vtkPNGReader()
reader.SetFileName(i)
reader.Update()
# convert the image to a Numeric Array and convert it back
# to an image data.
exp.SetInputConnection(reader.GetOutputPort())
imp.SetArray(exp.GetArray())
# ensure there is no difference between orig image and the
# one we converted and un-converted.
idiff.SetInputConnection(imp.GetOutputPort())
idiff.SetImage(reader.GetOutput())
idiff.Update()
err = idiff.GetThresholdedError()
msg = "Test failed on image %s, with threshold "\
"error: %d"%(i, err)
self.assertEqual(err, 0.0, msg)
def testImportExport(self):
"Testing if images can be imported to and from numeric arrays."
imp = vtkImageImportFromArray()
exp = vtkImageExportToArray()
idiff = vtk.vtkImageDifference()
img_dir = Testing.getAbsImagePath("")
for i in glob.glob(os.path.join(img_dir, "*.png")):
# Putting the reader outside the loop causes bad problems.
reader = vtk.vtkPNGReader()
reader.SetFileName(i)
reader.Update()
# convert the image to a Numeric Array and convert it back
# to an image data.
exp.SetInputConnection(reader.GetOutputPort())
imp.SetArray(exp.GetArray())
# ensure there is no difference between orig image and the
# one we converted and un-converted.
idiff.SetInputConnection(imp.GetOutputPort())
idiff.SetImage(reader.GetOutput())
idiff.Update()
err = idiff.GetThresholdedError()
msg = "Test failed on image %s, with threshold "\
"error: %d"%(i, err)
self.assertEqual(err, 0.0, msg)
def setupReader(img):
rd = vtk.vtkPNGReader()
rd.SetFileName(img1)
rd.Update()
imp = vtkImageImportFromArray()
exp = vtkImageExportToArray()
exp.SetInputConnection(rd.GetOutputPort())
imp.SetArray(exp.GetArray())
return imp
def image_from_file(fname):
try:
rd = vtk.vtkPNGReader()
rd.SetFileName(fname)
rd.Update()
exp = vtkImageExportToArray()
exp.SetInputConnection(rd.GetOutputPort())
areader = exp.GetArray()
except Exception,err:
print "Problem opening file",err
return None
def _makeSTL(self):
local_dir = self._gray_dir
surface_dir = self._vol_dir+'_surfaces'+self._path_dlm
try:
os.mkdir(surface_dir)
except:
pass
files = fnmatch.filter(sorted(os.listdir(local_dir)),'*.tif')
counter = re.search("[0-9]*\.tif", files[0]).group()
prefix = self._path_dlm+string.replace(files[0],counter,'')
counter = str(len(counter)-4)
prefixImageName = local_dir + prefix
### Create the renderer, the render window, and the interactor. The renderer
# The following reader is used to read a series of 2D slices (images)
# that compose the volume. The slice dimensions are set, and the
# pixel spacing. The data Endianness must also be specified. The reader
v16=vtk.vtkTIFFReader()
v16.SetFilePrefix(prefixImageName)
v16.SetDataExtent(0,100,0,100,1,len(files))
v16.SetFilePattern("%s%0"+counter+"d.tif")
v16.Update()
im = v16.GetOutput()
im.SetSpacing(self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2])
v = vte.vtkImageExportToArray()
v.SetInputData(im)
n = np.float32(v.GetArray())
idx = np.argwhere(n)
(ystart,xstart,zstart), (ystop,xstop,zstop) = idx.min(0),idx.max(0)+1
I,J,K = n.shape
if ystart > 5:
ystart -= 5
else:
ystart = 0
if ystop < I-5:
ystop += 5
else:
ystop = I
if xstart > 5:
xstart -= 5
else:
xstart = 0
if xstop < J-5:
xstop += 5
else:
xstop = J
if zstart > 5:
zstart -= 5
else:
zstart = 0
if zstop < K-5:
zstop += 5
else:
zstop = K
a = n[ystart:ystop,xstart:xstop,zstart:zstop]
itk_img = sitk.GetImageFromArray(a)
itk_img.SetSpacing([self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2]])
print "\n"
print "-------------------------------------------------------"
print "-- Applying Patch Based Denoising - this can be slow --"
print "-------------------------------------------------------"
print "\n"
pb = sitk.PatchBasedDenoisingImageFilter()
pb.KernelBandwidthEstimationOn()
pb.SetNoiseModel(3) #use a Poisson noise model since this is confocal
pb.SetNoiseModelFidelityWeight(1)
pb.SetNumberOfSamplePatches(20)
pb.SetPatchRadius(4)
pb.SetNumberOfIterations(10)
fimg = pb.Execute(itk_img)
b = sitk.GetArrayFromImage(fimg)
intensity = b.max()
#grad = sitk.GradientMagnitudeRecursiveGaussianImageFilter()
#grad.SetSigma(0.05)
gf = sitk.GradientMagnitudeImageFilter()
gf.UseImageSpacingOn()
grad = gf.Execute(fimg)
edge = sitk.Cast(sitk.BoundedReciprocal( grad ),sitk.sitkFloat32)
print "\n"
print "-------------------------------------------------------"
print "---- Thresholding to deterimine initial level sets ----"
print "-------------------------------------------------------"
print "\n"
t = 0.5
seed = sitk.BinaryThreshold(fimg,t*intensity)
#Opening (Erosion/Dilation) step to remove islands smaller than 2 voxels in radius)
seed = sitk.BinaryMorphologicalOpening(seed,2)
seed = sitk.BinaryFillhole(seed!=0)
#Get connected regions
r = sitk.ConnectedComponent(seed)
labels = sitk.GetArrayFromImage(r)
ids = sorted(np.unique(labels))
N = len(ids)
if N > 2:
i = np.copy(N)
while i == N and (t-self._tratio)>-1e-7:
t -= 0.01
seed = sitk.BinaryThreshold(fimg,t*intensity)
#Opening (Erosion/Dilation) step to remove islands smaller than 2 voxels in radius)
seed = sitk.BinaryMorphologicalOpening(seed,2)
seed = sitk.BinaryFillhole(seed!=0)
#Get connected regions
r = sitk.ConnectedComponent(seed)
labels = sitk.GetArrayFromImage(r)
i = len(np.unique(labels))
if i > N:
N = np.copy(i)
t+=0.01
else:
t = np.copy(self._tratio)
seed = sitk.BinaryThreshold(fimg,t*intensity)
#Opening (Erosion/Dilation) step to remove islands smaller than 2 voxels in radius)
seed = sitk.BinaryMorphologicalOpening(seed,2)
seed = sitk.BinaryFillhole(seed!=0)
#Get connected regions
r = sitk.ConnectedComponent(seed)
labels = sitk.GetArrayFromImage(r)
labels = np.unique(labels)[1:]
'''
labels[labels==0] = -1
labels = sitk.GetImageFromArray(labels)
labels.SetSpacing([self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2]])
#myshow3d(labels,zslices=range(20))
#plt.show()
ls = sitk.ScalarChanAndVeseDenseLevelSetImageFilter()
ls.UseImageSpacingOn()
ls.SetLambda2(1.5)
#ls.SetCurvatureWeight(1.0)
ls.SetAreaWeight(1.0)
#ls.SetReinitializationSmoothingWeight(1.0)
ls.SetNumberOfIterations(100)
seg = ls.Execute(sitk.Cast(labels,sitk.sitkFloat32),sitk.Cast(fimg,sitk.sitkFloat32))
seg = sitk.Cast(seg,sitk.sitkUInt8)
seg = sitk.BinaryMorphologicalOpening(seg,1)
seg = sitk.BinaryFillhole(seg!=0)
#Get connected regions
#r = sitk.ConnectedComponent(seg)
contours = sitk.BinaryContour(seg)
myshow3d(sitk.LabelOverlay(sitk.Cast(fimg,sitk.sitkUInt8),contours),zslices=range(fimg.GetSize()[2]))
plt.show()
'''
segmentation = sitk.Image(r.GetSize(),sitk.sitkUInt8)
segmentation.SetSpacing([self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2]])
for l in labels:
d = sitk.SignedMaurerDistanceMap(r==l,insideIsPositive=False,squaredDistance=True,useImageSpacing=True)
#d = sitk.BinaryThreshold(d,-1000,0)
#d = sitk.Cast(d,edge.GetPixelIDValue() )*-1+0.5
#d = sitk.Cast(d,edge.GetPixelIDValue() )
seg = sitk.GeodesicActiveContourLevelSetImageFilter()
seg.SetPropagationScaling(1.0)
seg.SetAdvectionScaling(1.0)
seg.SetCurvatureScaling(0.5)
seg.SetMaximumRMSError(0.01)
levelset = seg.Execute(d,edge)
levelset = sitk.BinaryThreshold(levelset,-1000,0)
segmentation = sitk.Add(segmentation,levelset)
print ("RMS Change for Cell %d: "% l,seg.GetRMSChange())
print ("Elapsed Iterations for Cell %d: "% l, seg.GetElapsedIterations())
'''
contours = sitk.BinaryContour(segmentation)
myshow3d(sitk.LabelOverlay(sitk.Cast(fimg,sitk.sitkUInt8),contours),zslices=range(fimg.GetSize()[2]))
plt.show()
'''
n[ystart:ystop,xstart:xstop,zstart:zstop] = sitk.GetArrayFromImage(segmentation)*100
i = vti.vtkImageImportFromArray()
i.SetDataSpacing([self._pixel_dim[0],self._pixel_dim[1],self._pixel_dim[2]])
i.SetDataExtent([0,100,0,100,1,len(files)])
i.SetArray(n)
i.Update()
thres=vtk.vtkImageThreshold()
thres.SetInputData(i.GetOutput())
thres.ThresholdByLower(0)
thres.ThresholdByUpper(101)
iso=vtk.vtkImageMarchingCubes()
iso.SetInputConnection(thres.GetOutputPort())
iso.SetValue(0,1)
regions = vtk.vtkConnectivityFilter()
regions.SetInputConnection(iso.GetOutputPort())
regions.SetExtractionModeToAllRegions()
regions.ColorRegionsOn()
regions.Update()
N = regions.GetNumberOfExtractedRegions()
for i in xrange(N):
r = vtk.vtkConnectivityFilter()
r.SetInputConnection(iso.GetOutputPort())
r.SetExtractionModeToSpecifiedRegions()
r.AddSpecifiedRegion(i)
g = vtk.vtkExtractUnstructuredGrid()
g.SetInputConnection(r.GetOutputPort())
geo = vtk.vtkGeometryFilter()
geo.SetInputConnection(g.GetOutputPort())
geo.Update()
t = vtk.vtkTriangleFilter()
t.SetInputConnection(geo.GetOutputPort())
t.Update()
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(t.GetOutputPort())
s = vtk.vtkSmoothPolyDataFilter()
s.SetInputConnection(cleaner.GetOutputPort())
s.SetNumberOfIterations(50)
dl = vtk.vtkDelaunay3D()
dl.SetInputConnection(s.GetOutputPort())
dl.Update()
self.cells.append(dl)
for i in xrange(N):
g = vtk.vtkGeometryFilter()
g.SetInputConnection(self.cells[i].GetOutputPort())
t = vtk.vtkTriangleFilter()
t.SetInputConnection(g.GetOutputPort())
#get the surface points of the cells and save to points attribute
v = t.GetOutput()
points = []
for j in xrange(v.GetNumberOfPoints()):
p = [0,0,0]
v.GetPoint(j,p)
points.append(p)
self.points.append(points)
#get the volume of the cell
vo = vtk.vtkMassProperties()
vo.SetInputConnection(t.GetOutputPort())
self.volumes.append(vo.GetVolume())
stl = vtk.vtkSTLWriter()
stl.SetInputConnection(t.GetOutputPort())
stl.SetFileName(surface_dir+'cell%02d.stl' % (i+self._counter))
stl.Write()
if self._display:
skinMapper = vtk.vtkDataSetMapper()
skinMapper.SetInputConnection(regions.GetOutputPort())
skinMapper.SetScalarRange(regions.GetOutput().GetPointData().GetArray("RegionId").GetRange())
skinMapper.SetColorModeToMapScalars()
#skinMapper.ScalarVisibilityOff()
skinMapper.Update()
skin = vtk.vtkActor()
skin.SetMapper(skinMapper)
#skin.GetProperty().SetColor(0,0,255)
# An outline provides context around the data.
#
outlineData = vtk.vtkOutlineFilter()
outlineData.SetInputConnection(v16.GetOutputPort())
mapOutline = vtk.vtkPolyDataMapper()
mapOutline.SetInputConnection(outlineData.GetOutputPort())
outline = vtk.vtkActor()
#outline.SetMapper(mapOutline)
#outline.GetProperty().SetColor(0,0,0)
colorbar = vtk.vtkScalarBarActor()
colorbar.SetLookupTable(skinMapper.GetLookupTable())
colorbar.SetTitle("Cells")
colorbar.SetNumberOfLabels(N)
# Create the renderer, the render window, and the interactor. The renderer
# draws into the render window, the interactor enables mouse- and
# keyboard-based interaction with the data within the render window.
#
aRenderer = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(aRenderer)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# It is convenient to create an initial view of the data. The FocalPoint
# and Position form a vector direction. Later on (ResetCamera() method)
# this vector is used to position the camera to look at the data in
# this direction.
aCamera = vtk.vtkCamera()
aCamera.SetViewUp (0, 0, -1)
aCamera.SetPosition (0, 1, 0)
aCamera.SetFocalPoint (0, 0, 0)
aCamera.ComputeViewPlaneNormal()
# Actors are added to the renderer. An initial camera view is created.
# The Dolly() method moves the camera towards the FocalPoint,
# thereby enlarging the image.
aRenderer.AddActor(outline)
aRenderer.AddActor(skin)
aRenderer.AddActor(colorbar)
aRenderer.SetActiveCamera(aCamera)
aRenderer.ResetCamera ()
aCamera.Dolly(1.5)
# Set a background color for the renderer and set the size of the
# render window (expressed in pixels).
aRenderer.SetBackground(0.0,0.0,0.0)
renWin.SetSize(800, 600)
# Note that when camera movement occurs (as it does in the Dolly()
# method), the clipping planes often need adjusting. Clipping planes
# consist of two planes: near and far along the view direction. The
# near plane clips out objects in front of the plane the far plane
# clips out objects behind the plane. This way only what is drawn
# between the planes is actually rendered.
aRenderer.ResetCameraClippingRange()
im=vtk.vtkWindowToImageFilter()
im.SetInput(renWin)
iren.Initialize();
iren.Start();
#remove gray directory
shutil.rmtree(local_dir)
def get_threshold(self):
converter = vtkImageExportToArray()
converter.SetInputConnection(self.__threshold.GetOutputPort())
return converter.GetArray()
