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 writeMhdFile(array, filePath):
from vtk.util import vtkImageImportFromArray as viifa
import time
import vtk
if (array.ndim == 2):
arrayTMP = np.zeros((1, ) + np.shape(array)) # Make it 3D
arrayTMP[0, :, :] = array
array = arrayTMP
T2 = viifa.vtkImageImportFromArray()
T2.SetArray(array)
T2.SetDataSpacing([1, 1, 1]) # Is dit wat je wil? De voxel spacing...
FineDensiteDims = np.shape(array)
T2.SetDataExtent([
0, FineDensiteDims[0] - 1, 0, FineDensiteDims[1] - 1, 0,
FineDensiteDims[2] - 1
])
T2.Update()
DensiteSurEchan = T2.GetOutput()
#Ecriture
imageWriter = vtk.vtkMetaImageWriter()
imageWriter.SetCompression(False)
imageWriter.SetFileName(filePath)
imageWriter.SetInputData(DensiteSurEchan)
imageWriter.Write()
def dump_image_to_file(fname,img): print "Writing to:",fname wr = vtk.vtkPNGWriter() wr.SetFileName(fname) imp = vtkImageImportFromArray() imp.SetArray((img+255/510)) wr.SetInputConnection(imp.GetOutputPort()) wr.Update() wr.Write()
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 create_3dquad_imageactor(image):
w=image.shape[0]
h=image.shape[1]
p0 = [-w/2, h/2, 0.0]
p1 = [w/2, h/2, 0.0]
p2 = [w/2, -h/2, 0.0]
p3 = [-w/2, -h/2, 0.0]
points = vtk.vtkPoints()
points.InsertNextPoint(p0)
points.InsertNextPoint(p1)
points.InsertNextPoint(p2)
points.InsertNextPoint(p3)
quad = vtk.vtkQuad()
quad.GetPointIds().SetNumberOfIds(4)
quad.GetPointIds().SetId(0,0)
quad.GetPointIds().SetId(1,1)
quad.GetPointIds().SetId(2,2)
quad.GetPointIds().SetId(3,3)
quads = vtk.vtkCellArray()
quads.InsertNextCell(quad)
polydata = vtk.vtkPolyData()
polydata.SetPoints(points)
polydata.SetPolys(quads)
textureCoordinates = vtk.vtkFloatArray()
textureCoordinates.SetNumberOfComponents(2)
textureCoordinates.InsertNextTuple2(0.0, 0.0)
textureCoordinates.InsertNextTuple2(1.0, 0.0)
textureCoordinates.InsertNextTuple2(1.0, 1.0)
textureCoordinates.InsertNextTuple2(0.0, 1.0)
polydata.GetPointData().SetTCoords(textureCoordinates)
reader = vtkImageImportFromArray()
reader.SetArray(image)
texture = vtk.vtkTexture()
if vtk.VTK_MAJOR_VERSION <= 5:
texture.SetInput(reader.GetOutput())
else:
texture.SetInputConnection(reader.GetOutputPort())
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(polydata)
else:
mapper.SetInputData(polydata)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetTexture(texture)
return actor
def buildOutlineMap(self):
# This function load a binary image (black and white)
# and create a default grid for it. Then it uses re-gridding algorithms
# to scale in the correct domain.
from pylab import imread
import vtk.util.vtkImageImportFromArray as vtkUtil
# read outline image and convert to gray scale
try:
data = imread(defaultOutlineMapFile)
data = data.mean(axis=2)
# # create a variable using the data loaded in the image and an uniform grid
dims = data.shape
reso = [180.0 / dims[0], 360.0 / dims[1]]
var = cdms2.createVariable(data)
lat = cdms2.createUniformLatitudeAxis(90, dims[0], -reso[0])
lon = cdms2.createUniformLongitudeAxis(-180, dims[1], reso[1])
var.setAxis(0, lat)
var.setAxis(1, lon)
# create the final map using the ROI
ROI = self.roi[:]
if ROI[2] < -90.0: ROI[2] = -90.0
if ROI[3] > 90.0: ROI[3] = 90.0
odims = [(ROI[3] - ROI[2]) / reso[0], (ROI[1] - ROI[0]) / reso[1]]
ogrid = cdms2.createUniformGrid(ROI[2], odims[0], reso[0], ROI[0],
odims[1], reso[1])
ovar = var.regrid(ogrid, regridTool='regrid2')
# replace outlier numbers
d = ovar.data
d[d == 1e+20] = d[d <> 1e+20].max()
img = vtkUtil.vtkImageImportFromArray()
img.SetArray(ovar.data)
img.Update()
except Exception:
print >> sys.stderr, "Error building Outline Map"
traceback.print_exc()
return None
# convert to vtkImageData
return img.GetOutput()
def buildOutlineMap(self):
# This function load a binary image (black and white)
# and create a default grid for it. Then it uses re-gridding algorithms
# to scale in the correct domain.
from pylab import imread
import vtk.util.vtkImageImportFromArray as vtkUtil
# read outline image and convert to gray scale
try:
data = imread(defaultOutlineMapFile)
data = data.mean(axis=2)
# # create a variable using the data loaded in the image and an uniform grid
dims = data.shape
reso = [180.0/dims[0], 360.0/dims[1]]
var = cdms2.createVariable(data)
lat = cdms2.createUniformLatitudeAxis(90, dims[0], -reso[0])
lon = cdms2.createUniformLongitudeAxis(-180, dims[1], reso[1])
var.setAxis(0, lat)
var.setAxis(1, lon)
# create the final map using the ROI
ROI = self.roi[:]
if ROI[2] < -90.0: ROI[2] = -90.0
if ROI[3] > 90.0: ROI[3] = 90.0
odims = [ (ROI[3]-ROI[2])/reso[0] , (ROI[1]-ROI[0])/reso[1] ]
ogrid = cdms2.createUniformGrid( ROI[2], odims[0], reso[0], ROI[0], odims[1], reso[1] )
ovar = var.regrid(ogrid, regridTool='regrid2')
# replace outlier numbers
d = ovar.data
d[d==1e+20] = d[d<>1e+20].max()
img = vtkUtil.vtkImageImportFromArray()
img.SetArray(ovar.data)
img.Update()
except Exception:
print>>sys.stderr, "Error building Outline Map"
traceback.print_exc()
return None
# convert to vtkImageData
return img.GetOutput()
def ImageActor(img):
reader = vtkImageImportFromArray()
reader.SetArray(img)
ImageDataGeometryFilter = vtk.vtkImageDataGeometryFilter()
ImageDataGeometryFilter.SetInputConnection(reader.GetOutputPort())
ImageDataGeometryFilter.Update()
# textureCoordinates = vtk.vtkFloatArray()
# textureCoordinates.SetNumberOfComponents(2)
# textureCoordinates.InsertNextTuple2(0.0, 1.0)
# textureCoordinates.InsertNextTuple2(1.0, 1.0)
# textureCoordinates.InsertNextTuple2(1.0, 0.0)
# textureCoordinates.InsertNextTuple2(0.0, 0.0)
mag = vtk.vtkImageMagnify()
mag.SetMagnificationFactors(512, 512, 1)
mag.InterpolateOff()
mag.SetInputConnection(reader.GetOutputPort())
mapper = vtk.vtkImageMapper()
# mapper.SetInputConnection(reader.GetOutputPort())
# mapper.SetColorWindow(4)
# mapper.SetColorLevel(255)
# mapper.SetZSlice(0)
mapper.SetInputConnection(mag.GetOutputPort())
# mapper.SetColorlevel(1000)
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(reader.GetOutputPort())
viewer.SetColorWindow(4)
viewer.SetColorLevel(255)
# viewer.SetZSlice(0)
viewer.Render()
actor = vtk.vtkActor2D()
actor.SetMapper(mapper.GetOutputPort())
# actor=vtk.vtkImageActor()
# actor.SetMapper(mapper)
# actor.SetInputData(reader.GetOutput())
return actor, viewer
def _poly2img(self, ind):
"""
Helper function called by **deformableRegistration()** that generates
images from polygonal surfaces in reference/deformed pairs. The voxel
dimension of these images is determined by the value for **Precision**
in **deformableSettings**.
Parameters
----------
ind : int
The list index for the current object pair being analyzed.
Returns
-------
(Reference Image, Deformed Image, Tranformed Reference Surface)
"""
dim = int(np.ceil(old_div(1.0,
self.deformableSettings['Precision']))) + 10
rpoly = vtk.vtkPolyData()
rpoly.DeepCopy(self.rsurfs[ind])
dpoly = self.dsurfs[ind]
if self.rigidInitial:
rot = vtk.vtkTransformPolyDataFilter()
rot.SetInputData(rpoly)
rot.SetTransform(self.rigidTransforms[ind])
rot.Update()
rpoly = rot.GetOutput()
rbounds = np.zeros(6, np.float32)
dbounds = np.copy(rbounds)
rpoly.GetBounds(rbounds)
dpoly.GetBounds(dbounds)
spacing = np.zeros(3, np.float32)
for i in range(3):
rspan = rbounds[2 * i + 1] - rbounds[2 * i]
dspan = dbounds[2 * i + 1] - dbounds[2 * i]
spacing[i] = (np.max([rspan, dspan]) *
self.deformableSettings['Precision'])
imgs = []
half = old_div(float(dim), 2.0)
for i in range(2):
arr = np.ones((dim, dim, dim), np.uint8)
arr2img = vti.vtkImageImportFromArray()
arr2img.SetDataSpacing(spacing)
arr2img.SetDataExtent((0, dim - 1, 0, dim - 1, 0, dim - 1))
arr2img.SetArray(arr)
arr2img.Update()
if i == 0:
rimg = arr2img.GetOutput()
rimg.SetOrigin((np.mean(rbounds[0:2]) - half * spacing[0] +
old_div(spacing[0], 2), np.mean(rbounds[2:4]) -
half * spacing[1] + old_div(spacing[1], 2),
np.mean(rbounds[4:]) - half * spacing[2] +
old_div(spacing[2], 2)))
else:
dimg = arr2img.GetOutput()
dimg.SetOrigin((np.mean(dbounds[0:2]) - half * spacing[0] +
old_div(spacing[0], 2), np.mean(dbounds[2:4]) -
half * spacing[1] + old_div(spacing[1], 2),
np.mean(dbounds[4:]) - half * spacing[2] +
old_div(spacing[2], 2)))
imgs = []
for (pd, img) in [(rpoly, rimg), (dpoly, dimg)]:
pol2stenc = vtk.vtkPolyDataToImageStencil()
pol2stenc.SetInputData(pd)
pol2stenc.SetOutputOrigin(img.GetOrigin())
pol2stenc.SetOutputSpacing(img.GetSpacing())
pol2stenc.SetOutputWholeExtent(img.GetExtent())
pol2stenc.SetTolerance(0.0001)
pol2stenc.Update()
imgstenc = vtk.vtkImageStencil()
imgstenc.SetInputData(img)
imgstenc.SetStencilConnection(pol2stenc.GetOutputPort())
imgstenc.ReverseStencilOff()
imgstenc.SetBackgroundValue(0)
imgstenc.Update()
arr = vtk_to_numpy(imgstenc.GetOutput().GetPointData().GetArray(0))
arr = arr.reshape(dim, dim, dim)
itk_img = sitk.GetImageFromArray(arr)
itk_img.SetSpacing(img.GetSpacing())
itk_img.SetOrigin(img.GetOrigin())
imgs.append(itk_img)
return (imgs[0], imgs[1], rpoly)
def __init__(self):
self.__vtkimport = vtkImageImportFromArray()
self.__filePattern = self.__defaultFilePattern
self.__data = 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 render(Data1, Data2, point):
ren = vtk.vtkRenderer()
ren.SetBackground(.1, .2, .5)
ren2dimg1 = vtk.vtkRenderer()
ren2dimg2 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.AddRenderer(ren2dimg1)
renWin.AddRenderer(ren2dimg2)
renWin.SetSize(1536, 1024)
# Create a render window
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
pts = vtk.vtkPoints()
[img1_position, img2_position, epi_point1,
epi_point2] = epigeometry_points(pts, point, Data1, Data2)
colors = vtk.vtkUnsignedCharArray()
colors.SetNumberOfComponents(3)
colors.SetName("Colors")
lines = vtk.vtkCellArray()
add_3dline(lines, pts, 0, 1, colors, 'r')
add_3dline(lines, pts, 2, 3, colors, 'g')
add_3dline(lines, pts, 1, 4, colors, 'w')
add_3dline(lines, pts, 3, 5, colors, 'w')
add_3dline(lines, pts, 3, 6, colors, 'w')
add_3dline(lines, pts, 5, 6, colors, 'w')
linesPolyData = vtk.vtkPolyData()
linesPolyData.SetPoints(pts)
linesPolyData.SetLines(lines)
linesPolyData.GetCellData().SetScalars(colors)
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(linesPolyData)
else:
mapper.SetInputData(linesPolyData)
lineactor = vtk.vtkActor()
lineactor.SetMapper(mapper)
img1 = Data1.img.copy()
img2 = Data2.img.copy()
cv2.circle(img1, (point[0], point[1]), 10, (255, 0, 0), -1)
cv2.line(img2, (int(epi_point1[0]), int(epi_point1[1])),
(int(epi_point2[0]), int(epi_point2[1])), (255, 0, 0), 5)
cv2.putText(
img1,
str(int(np.rad2deg(Data1.PA))) + ', ' + str(int(np.rad2deg(Data1.SA))),
(10, 100), 1, 4, (255, 255, 255), 2, cv2.LINE_AA)
cv2.putText(
img2,
str(int(np.rad2deg(Data2.PA))) + ', ' + str(int(np.rad2deg(Data2.SA))),
(10, 100), 1, 4, (255, 255, 255), 2, cv2.LINE_AA)
reader1 = vtkImageImportFromArray()
reader1.SetArray(img1)
reader1.Update()
fliper1 = vtk.vtkImageFlip()
fliper1.SetFilteredAxis(1)
fliper1.SetInputConnection(reader1.GetOutputPort())
fliper1.Update()
reader2 = vtkImageImportFromArray()
reader2.SetArray(img2)
reader2.Update()
fliper2 = vtk.vtkImageFlip()
fliper2.SetFilteredAxis(1)
fliper2.SetInputConnection(reader2.GetOutputPort())
fliper2.Update()
# transform1 = vtk.vtkTransform()
# transform1.Translate(img1_position)
# transform1.RotateY(np.rad2deg(Data1.PA))
# transform1.RotateX(-np.rad2deg(Data1.SA))
# transform1.Scale(img1.shape[0]*Data1.PS[0],img1.shape[1]*Data1.PS[1],1)
# transform2 = vtk.vtkTransform()
# transform2.Translate(img2_position)
# transform2.RotateY(np.rad2deg(Data2.PA))
# transform2.RotateZ(-np.rad2deg(Data2.SA))
# transform2.Scale(img2.shape[0]*Data2.PS[0],img2.shape[1]*Data2.PS[1],1)
planeA_actor = createQuad(img1)
planeA_actor.SetPosition(img1_position)
planeA_actor.SetScale(Data1.PS[0], Data1.PS[1], 1)
planeA_actor.RotateY(np.rad2deg(Data1.PA))
planeA_actor.RotateX(-np.rad2deg(Data1.SA))
# planeA_actor.SetUserTransform(transform1)
planeB_actor = createQuad(img2)
planeB_actor.SetPosition(img2_position)
planeB_actor.SetScale(Data2.PS[0], Data2.PS[1], 1)
planeB_actor.RotateY(np.rad2deg(Data2.PA))
planeB_actor.RotateZ(-np.rad2deg(Data2.SA))
# planeB_actor.SetUserTransform(transform2)
axes = vtk.vtkAxesActor()
transform = vtk.vtkTransform()
transform.Scale(100, 100, 100)
axes.SetUserTransform(transform)
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(25)
textProperty.SetJustificationToCentered()
textMapper = vtk.vtkTextMapper()
textActor = vtk.vtkActor2D()
textMapper.SetInput('Epipolar Geometry')
textMapper.SetTextProperty(textProperty)
textActor.SetMapper(textMapper)
textActor.SetPosition(512, 950)
ren.AddActor(lineactor)
ren.AddActor(planeA_actor)
ren.AddActor(planeB_actor)
ren.AddActor(axes)
ren.AddViewProp(textActor)
ren.SetViewport([0.0, 0.0, 2 / 3, 1.0])
mapper2d1 = vtk.vtkImageMapper()
mapper2d1.SetInputConnection(fliper1.GetOutputPort())
mapper2d1.SetColorWindow(255)
mapper2d1.SetColorLevel(127.5)
actor2d1 = vtk.vtkActor2D()
actor2d1.SetMapper(mapper2d1)
ren2dimg1.AddActor2D(actor2d1)
ren2dimg1.SetViewport([2 / 3, 0.5, 1.0, 1.0])
mapper2d2 = vtk.vtkImageMapper()
mapper2d2.SetInputConnection(fliper2.GetOutputPort())
mapper2d2.SetColorWindow(255)
mapper2d2.SetColorLevel(127.5)
actor2d2 = vtk.vtkActor2D()
actor2d2.SetMapper(mapper2d2)
ren2dimg2.AddActor2D(actor2d2)
ren2dimg2.SetViewport([2 / 3, 0.0, 1.0, 0.5])
iren.Initialize()
renWin.Render()
iren.Start()
def __init__(self):
self.__vtkimport=vtkImageImportFromArray()
self.__filePattern=self.__defaultFilePattern
self.__data = None
def _poly2img(self, ind):
"""
Helper function called by **deformableRegistration()** that generates
images from polygonal surfaces in reference/deformed pairs. The voxel
dimension of these images is determined by the value for **Precision**
in **deformableSettings**.
Parameters
----------
ind : int
The list index for the current object pair being analyzed.
Returns
-------
(Reference Image, Deformed Image, Tranformed Reference Surface)
"""
dim = int(np.ceil(old_div(1.0, self.deformableSettings['Precision']))) + 10
rpoly = vtk.vtkPolyData()
rpoly.DeepCopy(self.rsurfs[ind])
dpoly = self.dsurfs[ind]
if self.rigidInitial:
rot = vtk.vtkTransformPolyDataFilter()
rot.SetInputData(rpoly)
rot.SetTransform(self.rigidTransforms[ind])
rot.Update()
rpoly = rot.GetOutput()
rbounds = np.zeros(6, np.float32)
dbounds = np.copy(rbounds)
rpoly.GetBounds(rbounds)
dpoly.GetBounds(dbounds)
spacing = np.zeros(3, np.float32)
for i in range(3):
rspan = rbounds[2 * i + 1] - rbounds[2 * i]
dspan = dbounds[2 * i + 1] - dbounds[2 * i]
spacing[i] = (np.max([rspan, dspan])
* self.deformableSettings['Precision'])
imgs = []
half = old_div(float(dim), 2.0)
for i in range(2):
arr = np.ones((dim, dim, dim), np.uint8)
arr2img = vti.vtkImageImportFromArray()
arr2img.SetDataSpacing(spacing)
arr2img.SetDataExtent((0, dim - 1, 0, dim - 1, 0, dim - 1))
arr2img.SetArray(arr)
arr2img.Update()
if i == 0:
rimg = arr2img.GetOutput()
rimg.SetOrigin((np.mean(rbounds[0:2]) -
half * spacing[0] + old_div(spacing[0], 2),
np.mean(rbounds[2:4]) -
half * spacing[1] + old_div(spacing[1], 2),
np.mean(rbounds[4:]) -
half * spacing[2] + old_div(spacing[2], 2)))
else:
dimg = arr2img.GetOutput()
dimg.SetOrigin((np.mean(dbounds[0:2]) -
half * spacing[0] + old_div(spacing[0], 2),
np.mean(dbounds[2:4]) -
half * spacing[1] + old_div(spacing[1], 2),
np.mean(dbounds[4:]) -
half * spacing[2] + old_div(spacing[2], 2)))
imgs = []
for (pd, img) in [(rpoly, rimg), (dpoly, dimg)]:
pol2stenc = vtk.vtkPolyDataToImageStencil()
pol2stenc.SetInputData(pd)
pol2stenc.SetOutputOrigin(img.GetOrigin())
pol2stenc.SetOutputSpacing(img.GetSpacing())
pol2stenc.SetOutputWholeExtent(img.GetExtent())
pol2stenc.SetTolerance(0.0001)
pol2stenc.Update()
imgstenc = vtk.vtkImageStencil()
imgstenc.SetInputData(img)
imgstenc.SetStencilConnection(pol2stenc.GetOutputPort())
imgstenc.ReverseStencilOff()
imgstenc.SetBackgroundValue(0)
imgstenc.Update()
arr = vtk_to_numpy(imgstenc.GetOutput().GetPointData().GetArray(0))
arr = arr.reshape(dim, dim, dim)
itk_img = sitk.GetImageFromArray(arr)
itk_img.SetSpacing(img.GetSpacing())
itk_img.SetOrigin(img.GetOrigin())
imgs.append(itk_img)
return (imgs[0], imgs[1], rpoly)
from paraview.simple import *
import npimporters
import numpy as np
# create a regular cartesian grid, a.k.a. vtkImageData
dims = [64, 64, 64]
bounds = (-10.0, 10.0, -10.0, 10.0, -10.0, 10.0)
xaxis = np.linspace(bounds[0], bounds[1], dims[0])
yaxis = np.linspace(bounds[2], bounds[3], dims[1])
zaxis = np.linspace(bounds[4], bounds[5], dims[2])
[xc, yc, zc] = np.meshgrid(zaxis, yaxis, xaxis, indexing="ij")
data = xc**2 + yc**2 + zc**2
from vtk.util.vtkImageImportFromArray import vtkImageImportFromArray
iD = vtkImageImportFromArray()
iD.SetArray(data)
iD.SetDataOrigin((bounds[0], bounds[2], bounds[4]))
iD.SetDataSpacing(((bounds[1] - bounds[0]) / (dims[0] - 1),
(bounds[3] - bounds[2]) / (dims[0] - 1),
(bounds[5] - bounds[4]) / (dims[0] - 1)))
iD.Update()
iD.GetOutput().GetPointData().SetActiveScalars("scalars")
print("mesh dimensions = ", iD.GetOutput().GetDimensions())
assert iD.GetOutput().GetPointData().GetArray(0).GetName() == 'scalars'
datarange = iD.GetOutput().GetPointData().GetArray(0).GetRange()
print("data scalar range = ", datarange)
# create a new 'PVTrivialProducer'
pVTrivialProducer0 = PVTrivialProducer(guiName="UniformGrid")
