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
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")