def chunk_contour(data, prev, *args): envelope, values = args vti = vtk.vtkImageData() vti.SetOrigin(data.origin) vti.SetDimensions(np.array(data.shape) - np.array(envelope)) vti.SetSpacing(data.spacing) series_name = "sparse" add_np_to_vti(vti, data[:-envelope[0], :-envelope[1], :-envelope[2]], series_name) vti.GetPointData().SetActiveScalars(series_name) contour = vtk.vtkImageMarchingCubes() contour.SetInputData(vti) contour.SetNumberOfContours(values.shape[0]) for i, v in enumerate(values): contour.SetValue(i, v) contour.ComputeScalarsOn() contour.Update() writer = vtk.vtkPolyDataWriter() writer.SetInputData(contour.GetOutput()) writer.WriteToOutputStringOn() writer.Update() prev.append(writer.GetOutputString()) # TODO: could this return (None, prev) after issue #16 ? return data, prev
def setupImageProcessingPipeline(self): # Gaussian Smooth the image first # http://www.vtk.org/doc/nightly/html/classvtkImageGaussianSmooth.html self.noiseFilter = vtk.vtkImageGaussianSmooth() self.noiseFilter.SetStandardDeviation(1, 1, 1) self.noiseFilter.SetRadiusFactors(10, 10, 10) # Image Resize for resampler # http://www.vtk.org/doc/nightly/html/classvtkImageResize.html self.resampler = vtk.vtkImageResize() self.resampler.SetResizeMethodToMagnificationFactors() self.resampler.SetMagnificationFactors(1, 1, 1) self.resampler.BorderOn() self.resampler.SetInputConnection(self.noiseFilter.GetOutputPort()) # Marching cubes for iso value # http://www.vtk.org/doc/nightly/html/classvtkImageMarchingCubes.html self.marchingCubes = vtk.vtkImageMarchingCubes() self.marchingCubes.SetInputConnection(self.resampler.GetOutputPort()) self.marchingCubes.ComputeGradientsOn() self.marchingCubes.ComputeNormalsOn() self.marchingCubes.ComputeScalarsOn() self.marchingCubes.SetNumberOfContours(1) self.marchingCubes.SetValue(0, 0) # Create mapper and actor for renderer self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.marchingCubes.GetOutputPort()) self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) self.actor.GetProperty().SetInterpolationToGouraud()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkImageMarchingCubes(), 'Processing.', ('vtkImageData',), ('vtkPolyData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def vtk_marching_cubes(field,iso=0.5): import vtk int_field = (np.minimum(field*255,255)).astype(np.uint8) nx, ny, nz = int_field.shape data_string = int_field.tostring('F') reader = vtk.vtkImageImport() reader.CopyImportVoidPointer(data_string, len(data_string)) reader.SetDataScalarTypeToUnsignedChar() reader.SetNumberOfScalarComponents(1) reader.SetDataExtent(0, nx - 1, 0, ny - 1, 0, nz - 1) reader.SetWholeExtent(0, nx - 1, 0, ny - 1, 0, nz - 1) reader.Update() contour = vtk.vtkImageMarchingCubes() if vtk.VTK_MAJOR_VERSION <= 5: contour.SetInput(reader.GetOutput()) else: contour.SetInputData(reader.GetOutput()) contour.ComputeNormalsOn() contour.ComputeGradientsOn() contour.SetValue(0,int(iso*255)) contour.Update() field_polydata = contour.GetOutput() polydata_points = np.array([field_polydata.GetPoints().GetPoint(p) for p in xrange(field_polydata.GetPoints().GetNumberOfPoints())]) polydata_triangles = np.array([[field_polydata.GetCell(t).GetPointIds().GetId(i) for i in xrange(3)] for t in xrange(field_polydata.GetNumberOfCells())]) return polydata_points, polydata_triangles
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkImageMarchingCubes(), 'Processing.', ('vtkImageData', ), ('vtkPolyData', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def __init__(self): super(DualFlouroSceneVisualizer, self).__init__() # Remove origin information self.xray_changer_1 = vtk.vtkImageChangeInformation() self.xray_changer_1.SetOutputOrigin(0, 0, 0) self.xray_changer_2 = vtk.vtkImageChangeInformation() self.xray_changer_2.SetOutputOrigin(0, 0, 0) self.ct_changer = vtk.vtkImageChangeInformation() self.ct_changer.SetOutputOrigin(0, 0, 0) # Setup mapper and actor for x-ray images self.xray_mapper_1 = vtk.vtkImageSliceMapper() self.xray_mapper_1.SetInputConnection( self.xray_changer_1.GetOutputPort()) self.xray_mapper_2 = vtk.vtkImageSliceMapper() self.xray_mapper_2.SetInputConnection( self.xray_changer_2.GetOutputPort()) self.xray_property = vtk.vtkImageProperty() self.xray_property.SetInterpolationTypeToNearest() self.xray_slice_1 = vtk.vtkImageSlice() self.xray_slice_1.SetMapper(self.xray_mapper_1) self.xray_slice_1.SetProperty(self.xray_property) self.xray_slice_2 = vtk.vtkImageSlice() self.xray_slice_2.SetMapper(self.xray_mapper_2) self.xray_slice_2.SetProperty(self.xray_property) self.marchingCubes = vtk.vtkImageMarchingCubes() self.marchingCubes.SetInputConnection(self.ct_changer.GetOutputPort()) self.marchingCubes.ComputeGradientsOn() self.marchingCubes.ComputeNormalsOn() self.marchingCubes.ComputeScalarsOn() self.marchingCubes.SetNumberOfContours(1) self.marchingCubes.SetValue(0, 0) self.ct_mapper = vtk.vtkPolyDataMapper() self.ct_mapper.SetInputConnection(self.marchingCubes.GetOutputPort()) self.ct_mapper.ScalarVisibilityOff() self.ct_actor = vtk.vtkActor() self.ct_actor.SetMapper(self.ct_mapper) self.ct_actor.GetProperty().SetInterpolationToGouraud() self.ct_actor.GetProperty().SetColor(GetRGBColor('antique_white')) self.renderer = vtk.vtkRenderer() self.renderer.AddViewProp(self.ct_actor) self.renderer.AddViewProp(self.xray_slice_1) self.renderer.AddViewProp(self.xray_slice_2) self.renderer.SetBackground(0.1, 0.2, 0.3) self.interactor = vtk.vtkRenderWindowInteractor() self.interactor_style = vtk.vtkInteractorStyleTrackballCamera() self.interactor.SetInteractorStyle(self.interactor_style)
def _update_region(self, org_x, org_y, org_z, update_size): ''' :param pa, pb, pc: Requires tuple format of 3 coordinates TCL Update region inside the box constructed by pa, pb and pc ''' for i in range(org_x, org_x + update_size): for j in range(org_y, org_y + update_size): for k in range(org_z, org_z + update_size): self.reader.GetOutput().SetScalarComponentFromFloat(i, j, k, 0, 255) # self.voi = vtk.vtkExtractVOI() # self.voi.SetInputConnection(self.reader.GetOutputPort()) # self.voi.SetVOI(org_x, org_x + update_size, # org_y, org_y + update_size, # org_z, org_z + update_size) # self.voi.Update() self.regionMC = vtk.vtkImageMarchingCubes() self.regionMC.SetInputConnection(self.reader.GetOutputPort()) self.regionMC.SetValue(0, self.ui.mc_spin.value()) self.regionMC.Update() # self.mc.SetInputConnection(self.reader.GetOutputPort()) # self.mc.Update() # self.appendData = vtk.vtkAppendPolyData() # self.appendData.AddInputData(self.mc.GetOutput()) # self.appendData.AddInputData(self.regionMC.GetOutput()) # self.mapper.SetInputConnection(self.appendData.GetOutputPort()) self.mapper2 = vtk.vtkPolyDataMapper() self.mapper2.SetInputConnection(self.regionMC.GetOutputPort()) self.volumeMapper = vtk.vtkVolumeMapper() self.volumeMapper.SetCropping(1) self.volumeMapper.SetCroppingRegionPlanes(org_x, org_x + update_size, org_y, org_y + update_size, org_z, org_z + update_size) self.volumeMapper.SetCroppingRegionFlags(0x0002000) self.volume = vtk.vtkVolume() self.volume.SetMapper(self.volumeMapper) self.upperRender = vtk.vtkRenderer() self.upperRender.AddVolume(self.volume) self.upperRender.SetBackground(0.9, 0.9, 0.9) self.upperRender.SetLayer(2) self.vtk3DWidget.GetRenderWindow().AddRenderer(self.upperRender)
def createMesh(self, polyData, spacing): dv = 1.75 rf = 1 data_matrix = polyData data_matrix = np.rot90(data_matrix, 1) data_matrix = data_matrix.astype(np.uint8) xSize, ySize, zSize = data_matrix.shape #================================BoneExtrctor================================== dataImporter = vtk.vtkImageImport() data_string = data_matrix.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) dataImporter.SetDataScalarTypeToUnsignedChar() dataImporter.SetNumberOfScalarComponents(1) dataImporter.SetDataExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1) dataImporter.SetWholeExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1) dataImporter.SetDataExtentToWholeExtent() #============================= Smoothed pipeline ============================== smooth = vtk.vtkImageGaussianSmooth() smooth.SetDimensionality(3) smooth.SetInputConnection(dataImporter.GetOutputPort()) smooth.SetStandardDeviations(dv, dv, dv) smooth.SetRadiusFactor(rf) subsampleSmoothed = vtk.vtkImageShrink3D() subsampleSmoothed.SetInputConnection(smooth.GetOutputPort()) subsampleSmoothed.SetShrinkFactors(4, 4, 1) isoSmoothed = vtk.vtkImageMarchingCubes() isoSmoothed.SetInputConnection(smooth.GetOutputPort()) isoSmoothed.SetValue(0, 10) isoSmoothedMapper = vtk.vtkPolyDataMapper() isoSmoothedMapper.SetInputConnection(isoSmoothed.GetOutputPort()) isoSmoothedMapper.ScalarVisibilityOff() tmpTransfor = vtk.vtkTransform() tmpTransfor.Scale(spacing) meshActor = vtk.vtkActor() meshActor.SetMapper(isoSmoothedMapper) meshActor.SetUserTransform(tmpTransfor) return meshActor
def __init__(self, parent=None): # Defaults self.filename = "" self.gaussStandardDeviation = 1.2 self.gaussRadius = 2 self.magnification = 1 self.isosurface = 1 self.actorColor = [1.000, 0.000, 0.000] self.actorOpacity = 1.0 self.actorVisibility = 1 self.actorPickable = 1 self.pipelineType = "MarchingCubes" # In the future we could define other types of pipelines self.pipelineDataType = None self.actorAdded = False self.processing_log = None self.image_info = None # Elements of the VTK pipeline self.reader = None self.gauss = vtk.vtkImageGaussianSmooth() self.pad = vtk.vtkImageConstantPad() self.resampler = vtk.vtkImageResize() self.marchingCubes = vtk.vtkImageMarchingCubes() self.mapper = vtk.vtkPolyDataMapper() self.mapperDS = vtk.vtkDataSetMapper() self.actor = vtk.vtkActor() self.transformPolyData = vtk.vtkTransformPolyDataFilter() # The vtkTransform is part of the pipeline. The matrix defines the vtkTransform, but we # store a copy in self.matrix for retrieval later. self.rigidBodyTransform = vtk.vtkTransform() self.rigidBodyTransform.Identity() self.rigidBodyTransform.PostMultiply() # Important so that transform concatenations is correct! self.matrix = vtk.vtkMatrix4x4() self.dim = [1,1,1] self.pos = [0,0,0] self.el_size_mm = [0.082,0.082,0.082] self.extent = [0,1,0,1,0,1] self.origin = [0,0,0] self.validForExtrusion = False
def __init__(self, input_file, gaussian, radius, isosurface, window_size, *args, **kwargs): """MainWindow constructor""" super().__init__(*args, **kwargs) # Window setup self.resize(window_size[0], window_size[1]) self.title = "Basic Qt Viewer for MDSC 689.03" self.statusBar().showMessage("Welcome.", 8000) # Capture defaults self.gaussian = gaussian self.radius = radius self.isosurface = isosurface # Initialize the window self.initUI() # Set up some VTK pipeline classes self.reader = None self.gauss = vtk.vtkImageGaussianSmooth() self.marchingCubes = vtk.vtkImageMarchingCubes() self.mapper = vtk.vtkPolyDataMapper() self.actor = vtk.vtkActor() # Take inputs from command line. Only use these if there is an input file specified if (input_file != None): if (not os.path.exists(input_file)): qtw.QMessageBox.warning(self, "Error", "Invalid input file.") return #_,ext = os.path.splitext(input_file) #if not (self.validExtension(ext.lower())): # qtw.QMessageBox.warning(self, "Error", "Invalid file type.") # return self.createPipeline(input_file) self.statusBar().showMessage("Loading file " + input_file, 4000) self.changeSigma(gaussian) self.changeRadius(radius) self.changeIsosurface(isosurface)
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)
ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # create pipeline # v16 = vtk.vtkVolume16Reader() v16.SetDataDimensions(64,64) v16.GetOutput().SetOrigin(0.0,0.0,0.0) v16.SetDataByteOrderToLittleEndian() v16.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter") v16.SetImageRange(1,93) v16.SetDataSpacing(3.2,3.2,1.5) v16.Update() iso = vtk.vtkImageMarchingCubes() iso.SetInputConnection(v16.GetOutputPort()) iso.SetValue(0,1150) iso.SetInputMemoryLimit(1000) topPlane = vtk.vtkPlane() topPlane.SetNormal(0,0,1) topPlane.SetOrigin(0,0,0.5) botPlane = vtk.vtkPlane() botPlane.SetNormal(0,0,-1) botPlane.SetOrigin(0,0,137.0) sagPlane = vtk.vtkPlane() sagPlane.SetNormal(1,0,0) sagPlane.SetOrigin(100.8,0,0) capPlanes = vtk.vtkPlaneCollection() capPlanes.AddItem(topPlane) capPlanes.AddItem(botPlane)
print("Error: output directory '" + output_folder_name + "' does not exist") exit() # Very important! The following values are for the virtual fish project voxel_size = [0.798, 0.798, 2.0] print("\nIMPORTANT: using the following voxel size: " + str(voxel_size[0]) + ", " + str(voxel_size[1]) + ", " + str(voxel_size[2])) print("the meshes will be saved in " + output_folder_name) # The VTK stuff img_reader = vtk.vtkTIFFReader() # Gaussian image filter img_smoother = vtk.vtkImageGaussianSmooth() img_smoother.SetDimensionality(3) img_smoother.SetRadiusFactor(3) # Marching cubes marching_cubes = vtk.vtkImageMarchingCubes() marching_cubes.SetValue(0, 128) # Mesh writer mesh_writer = vtk.vtkPLYWriter() # First of all, we collect the names of the tiff files tiff_file_names = list() # Get the file names of the tif images in the provided folder for file_name in os.listdir(input_folder_name): full_file_name = os.path.join(input_folder_name, file_name) # We want files only if not os.path.isfile(full_file_name): continue
def aim2stl(input_file, output_file, transform_file, gaussian, radius, marching_cubes, decimation, visualize, overwrite, func): if os.path.isfile(output_file) and not overwrite: result = input('File \"{}\" already exists. Overwrite? [y/n]: '.format(output_file)) if result.lower() not in ['y', 'yes']: print('Not overwriting. Exiting...') os.sys.exit() message("Reading AIM file " + input_file) reader = vtkbone.vtkboneAIMReader() reader.SetFileName(input_file) reader.DataOnCellsOff() reader.Update() image = reader.GetOutput() message("Read %d points from AIM file" % image.GetNumberOfPoints()) image_bounds = image.GetBounds() message("Image bounds:", (" %.4f"*6) % image_bounds) image_extent = image.GetExtent() message("Image extent:", (" %d"*6) % image_extent) message("Gaussian smoothing") gauss = vtk.vtkImageGaussianSmooth() gauss.SetStandardDeviation(gaussian) gauss.SetRadiusFactor(radius) gauss.SetInputConnection(reader.GetOutputPort()) gauss.Update() message("Total of %d voxels" % gauss.GetOutput().GetNumberOfCells()) message("Padding the data") pad = vtk.vtkImageConstantPad() pad.SetConstant(0) pad.SetOutputWholeExtent(image_extent[0]-1,image_extent[1]+1, image_extent[2]-1,image_extent[3]+1, image_extent[4]-1,image_extent[5]+1) pad.SetInputConnection(gauss.GetOutputPort()) pad.Update() message("Total of %d padded voxels" % pad.GetOutput().GetNumberOfCells()) message("Extracting isosurface") mcube = vtk.vtkImageMarchingCubes() mcube.ComputeScalarsOff() mcube.ComputeNormalsOff() mcube.SetValue(0,marching_cubes) mcube.SetInputConnection(pad.GetOutputPort()) mcube.Update() message("Generated %d triangles" % mcube.GetOutput().GetNumberOfCells()) if (decimation>0.0): message("Decimating the isosurface. Targeting {:.1f}%".format(decimation*100.0)) deci = vtk.vtkDecimatePro() deci.SetInputConnection(mcube.GetOutputPort()) deci.SetTargetReduction(decimation) # 0 is none, 1 is maximum decimation. deci.Update() message("Decimated to %d triangles" % deci.GetOutput().GetNumberOfCells()) mesh = deci else: message("No decimation of the isosurface") mesh = mcube mesh = applyTransform(transform_file, mesh) if (visualize): mat4x4 = visualize_actors( mesh.GetOutputPort(), None ) else: mat4x4 = vtk.vtkMatrix4x4() write_stl( mesh.GetOutputPort(), output_file, mat4x4 )
def setup_vis(file_name): print('Reading in {}'.format(file_name)) # Reader vtk.vtkImageReader2Factory.RegisterReader(vtk.vtkNIFTIImageReader()) reader = vtk.vtkImageReader2Factory.CreateImageReader2(file_name) if reader is None: os.sys.exit('Cannot find reader for {}'.format(image_file_name)) reader.SetFileName(file_name) reader.Update() extent = list(reader.GetOutput().GetExtent()) print(extent) for i in range(0, len(extent), 2): extent[i] = extent[i] - 1 extent[i + 1] = extent[i + 1] + 1 print(extent) # Pad padder = vtk.vtkImageConstantPad() padder.SetInputConnection(reader.GetOutputPort()) padder.SetConstant(1) padder.SetOutputWholeExtent(extent) # Grab surface iso = vtk.vtkImageMarchingCubes() iso.SetInputConnection(padder.GetOutputPort()) iso.SetValue(0, 0) iso.ComputeNormalsOn() iso.ComputeGradientsOn() iso.ComputeScalarsOn() #iso = vtk.vtkFlyingEdges3D() #iso.SetInputConnection(padder.GetOutputPort()) #iso.SetValue(0,0) #iso.ComputeNormalsOn() #iso.ComputeGradientsOn() #iso.ComputeScalarsOn() #iso.InterpolateAttributesOff() # Smoother #smoother = vtk.vtkWindowedSincPolyDataFilter() #smoother.SetInputConnection(iso.GetOutputPort()) #smoother.SetNumberOfIterations(15) #smoother.BoundarySmoothingOff() #smoother.FeatureEdgeSmoothingOff() #smoother.SetFeatureAngle(120.0) #smoother.SetPassBand(0.001) #smoother.NonManifoldSmoothingOn() #smoother.NormalizeCoordinatesOn() # Mapper isoMapper = vtk.vtkPolyDataMapper() #isoMapper.SetInputConnection(smoother.GetOutputPort()) isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetColor(1, 1, 1) isoActor.GetProperty().SetOpacity(1) return isoActor
renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # create pipeline # v16 = vtk.vtkVolume16Reader() v16.SetDataDimensions(64, 64) v16.GetOutput().SetOrigin(0.0, 0.0, 0.0) v16.SetDataByteOrderToLittleEndian() v16.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter") v16.SetImageRange(1, 93) v16.SetDataSpacing(3.2, 3.2, 1.5) v16.Update() iso = vtk.vtkImageMarchingCubes() iso.SetInputConnection(v16.GetOutputPort()) iso.SetValue(0, 1150) iso.SetInputMemoryLimit(1000) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoMapper.ImmediateModeRenderingOn() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetColor(GetRGBColor('antique_white')) outline = vtk.vtkOutlineFilter() outline.SetInputConnection(v16.GetOutputPort())
dataImporter.SetWholeExtent(0, xSize - 1, 0, ySize - 1, 0, zSize - 1) dataImporter.SetDataExtentToWholeExtent() #============================================================================= # Smoothed pipeline. smooth = vtk.vtkImageGaussianSmooth() smooth.SetDimensionality(3) smooth.SetInputConnection(dataImporter.GetOutputPort()) smooth.SetStandardDeviations(dv, dv, dv) smooth.SetRadiusFactor(rf) subsampleSmoothed = vtk.vtkImageShrink3D() subsampleSmoothed.SetInputConnection(smooth.GetOutputPort()) subsampleSmoothed.SetShrinkFactors(4, 4, 1) isoSmoothed = vtk.vtkImageMarchingCubes() isoSmoothed.SetInputConnection(smooth.GetOutputPort()) isoSmoothed.SetValue(0, 10) isoSmoothedMapper = vtk.vtkPolyDataMapper() isoSmoothedMapper.SetInputConnection(isoSmoothed.GetOutputPort()) isoSmoothedMapper.ScalarVisibilityOff() colors = vtk.vtkNamedColors() colors.SetColor("ActorColor", [235, 235, 235, 255]) ''' threshold = vtk.vtkImageThreshold () threshold.SetInputConnection(smooth.GetOutputPort()) threshold.ThresholdByLower(10) # remove all soft tissue threshold.ReplaceInOn() threshold.SetInValue(0) # set all values below 400 to 0
def main(): colors = vtk.vtkNamedColors() colors.SetColor("ActorColor", [235, 235, 235, 255]) fileName = get_program_parameters() # Read the image. readerFactory = vtk.vtkImageReader2Factory() reader = readerFactory.CreateImageReader2(fileName) reader.SetFileName(fileName) reader.Update() # Smoothed pipeline. smooth = vtk.vtkImageGaussianSmooth() smooth.SetDimensionality(3) smooth.SetInputConnection(reader.GetOutputPort()) smooth.SetStandardDeviations(1.75, 1.75, 0.0) smooth.SetRadiusFactor(2) subsampleSmoothed = vtk.vtkImageShrink3D() subsampleSmoothed.SetInputConnection(smooth.GetOutputPort()) subsampleSmoothed.SetShrinkFactors(4, 4, 1) isoSmoothed = vtk.vtkImageMarchingCubes() isoSmoothed.SetInputConnection(smooth.GetOutputPort()) isoSmoothed.SetValue(0, 1150) isoSmoothedMapper = vtk.vtkPolyDataMapper() isoSmoothedMapper.SetInputConnection(isoSmoothed.GetOutputPort()) isoSmoothedMapper.ScalarVisibilityOff() isoSmoothedActor = vtk.vtkActor() isoSmoothedActor.SetMapper(isoSmoothedMapper) isoSmoothedActor.GetProperty().SetColor(colors.GetColor3d("ActorColor")) # Unsmoothed pipeline. # Sub sample the data. subsample = vtk.vtkImageShrink3D() subsample.SetInputConnection(reader.GetOutputPort()) subsample.SetShrinkFactors(4, 4, 1) iso = vtk.vtkImageMarchingCubes() iso.SetInputConnection(subsample.GetOutputPort()) iso.SetValue(0, 1150) isoMapper = vtk.vtkPolyDataMapper() isoMapper.SetInputConnection(iso.GetOutputPort()) isoMapper.ScalarVisibilityOff() isoActor = vtk.vtkActor() isoActor.SetMapper(isoMapper) isoActor.GetProperty().SetColor(colors.GetColor3d("ActorColor")) # The rendering Pipeline. # Setup the render window, renderer, and interactor. leftViewport = [0.0, 0.0, 0.5, 1.0] rightViewport = [0.5, 0.0, 1.0, 1.0] rendererLeft = vtk.vtkRenderer() rendererLeft.SetViewport(leftViewport) rendererRight = vtk.vtkRenderer() rendererRight.SetViewport(rightViewport) renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(rendererLeft) renderWindow.AddRenderer(rendererRight) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) rendererLeft.AddActor(isoActor) rendererRight.AddActor(isoSmoothedActor) rendererLeft.GetActiveCamera().SetFocalPoint(0.0, 0.0, 0.0) rendererLeft.GetActiveCamera().SetPosition(0.0, -1.0, 0.0) rendererLeft.GetActiveCamera().SetViewUp(0.0, 0.0, -1.0) rendererLeft.ResetCamera() rendererLeft.GetActiveCamera().Azimuth(-20.0) rendererLeft.GetActiveCamera().Elevation(20.0) rendererLeft.ResetCameraClippingRange() rendererLeft.SetBackground(colors.GetColor3d("SlateGray")) rendererRight.SetBackground(colors.GetColor3d("LightSlateGray")) rendererRight.SetActiveCamera(rendererLeft.GetActiveCamera()) renderWindow.SetSize(640, 480) renderWindow.Render() renderWindowInteractor.Start()