def GetRawDICOMData(filenames,fileID): print filenames,fileID vtkRealDcmReader = vtk.vtkDICOMImageReader() vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,filenames[0]) ) vtkRealDcmReader.Update() vtkRealData = vtk.vtkImageCast() vtkRealData.SetOutputScalarTypeToFloat() vtkRealData.SetInput( vtkRealDcmReader.GetOutput() ) vtkRealData.Update( ) real_image = vtkRealData.GetOutput().GetPointData() real_array = vtkNumPy.vtk_to_numpy(real_image.GetArray(0)) vtkImagDcmReader = vtk.vtkDICOMImageReader() vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,filenames[1]) ) vtkImagDcmReader.Update() vtkImagData = vtk.vtkImageCast() vtkImagData.SetOutputScalarTypeToFloat() vtkImagData.SetInput( vtkImagDcmReader.GetOutput() ) vtkImagData.Update( ) imag_image = vtkImagData.GetOutput().GetPointData() imag_array = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0)) vtkAppend = vtk.vtkImageAppendComponents() vtkAppend.SetInput( 0,vtkRealDcmReader.GetOutput() ) vtkAppend.SetInput( 1,vtkImagDcmReader.GetOutput() ) vtkAppend.Update( ) vtkDcmWriter = vtk.vtkDataSetWriter() vtkDcmWriter.SetFileName("rawdata.%04d.vtk" % fileID ) vtkDcmWriter.SetInput(vtkAppend.GetOutput()) vtkDcmWriter.Update() return (real_array,imag_array)
def GetRawDICOMData(filenames,fileID): print filenames,fileID vtkRealDcmReader = vtk.vtkDICOMImageReader() vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,filenames[0]) ) vtkRealDcmReader.Update() vtkRealData = vtk.vtkImageCast() vtkRealData.SetOutputScalarTypeToFloat() vtkRealData.SetInput( vtkRealDcmReader.GetOutput() ) vtkRealData.Update( ) real_image = vtkRealData.GetOutput().GetPointData() real_array = vtkNumPy.vtk_to_numpy(real_image.GetArray(0)) vtkImagDcmReader = vtk.vtkDICOMImageReader() vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,filenames[1]) ) vtkImagDcmReader.Update() vtkImagData = vtk.vtkImageCast() vtkImagData.SetOutputScalarTypeToFloat() vtkImagData.SetInput( vtkImagDcmReader.GetOutput() ) vtkImagData.Update( ) imag_image = vtkImagData.GetOutput().GetPointData() imag_array = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0)) vtkAppend = vtk.vtkImageAppendComponents() vtkAppend.SetInput( 0,vtkRealDcmReader.GetOutput() ) vtkAppend.SetInput( 1,vtkImagDcmReader.GetOutput() ) vtkAppend.Update( ) # write raw data vtkRawData = vtkAppend.GetOutput() vtkRawData.SetSpacing( spacing ) vtkDcmWriter = vtk.vtkDataSetWriter() vtkDcmWriter.SetFileTypeToBinary() vtkDcmWriter.SetFileName("s%d/rawdata.%04d.vtk" % (dirID,fileID) ) vtkDcmWriter.SetInput( vtkRawData ) vtkDcmWriter.Update() # write raw phase data vtkPhase = vtk.vtkImageMathematics() vtkPhase.SetInput1( vtkRealData.GetOutput() ) vtkPhase.SetInput2( vtkImagData.GetOutput() ) vtkPhase.SetOperationToATAN2( ) vtkPhase.Update( ) vtkPhaseData = vtkPhase.GetOutput() vtkPhaseData.SetSpacing( spacing ) vtkDcmWriter = vtk.vtkDataSetWriter() vtkDcmWriter.SetFileTypeToBinary() vtkDcmWriter.SetFileName("s%d/phase.%04d.vtk" % (dirID,fileID) ) vtkDcmWriter.SetInput( vtkPhaseData) vtkDcmWriter.Update() return (real_array,imag_array)
def rendering(dataPath, label, lowerThreshold, upperThreshold, surface, dualSurface, volume, dual_volume, sigmoid): # Read the data if dataPath.endswith('.nrrd'): reader = vtk.vtkNrrdReader() reader.SetFileName(dataPath) reader.Update() # if dataPath.endswith('.nii'): # reader = vtk.vtkNIFTIImageReader() # reader.SetFileName(dataPath) # reader.Update() else: reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(dataPath) reader.Update() if label.endswith('.nrrd'): reader2 = vtk.vtkNrrdReader() reader2.SetFileName(label) reader2.Update() else: reader2 = vtk.vtkDICOMImageReader() reader2.SetDirectoryName(label) reader2.Update() # if sigmoid.endswith('.nii'): # reader3 = vtk.vtkNIFTIImageReader() # reader3.SetFileName(sigmoid) # reader3.Update() # else: # reader3 = vtk.vtkDICOMImageReader() # reader3.SetDirectoryName(sigmoid) # reader3.Update() # Smooth the image filteredImage = gaussianFilter(reader) # Surface rendering if surface: surfaceRendering(reader2.GetOutput(), lowerThreshold, upperThreshold) if dualSurface: dualSurfaceRendering(filteredImage, reader2.GetOutput()) # Volume rendering if volume: volumeRendering(reader2.GetOutput(), lowerThreshold, upperThreshold) if dual_volume: dual_volumeRendering(reader.GetOutput(), reader2.GetOutput(), lowerThreshold, upperThreshold, reader3.GetOutput())
def load_dicom_vtk(path): #Load all the images in the DICOM directory imagevtk = vtk.vtkDICOMImageReader() imagevtk.SetDirectoryName(path) imagevtk.Update() return imagevtk
def loadData(): reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(file_path) reader.Update() imageData = vtk.vtkImageData() imageData.DeepCopy(reader.GetOutput()) return reader
def __init__(self, scan_dir, spacing='auto'): """Load image to scale :param scan_dir: path to dicom file :param spacing: [x,y,z] spacing in mm, or 'auto' if we want to use min spacing already present in a scan, 'none' if we are not doing any resamplig """ # read dicom self.reader = vtkDICOMImageReader() self.reader.ReleaseDataFlagOff() self.reader.SetDirectoryName(scan_dir) self.reader.Update() # prepare parameters for shear transform (gantry tilt) x1, y1, z1, x2, y2, z2 = self.image_orientation = self.reader.GetImageOrientationPatient( ) # if non-standard orientation, then it's non-standard series if y2 == 0: raise Exception( f"Wrong patient orientation: {self.image_orientation}") rad_tilt = atan(z2 / y2) center_z = self.reader.GetOutput().GetBounds()[5] / 2 self.shear_params = ShearParams(rad_tilt, -center_z) self.scan_dir = scan_dir self.spacing = spacing self.angle_z = 0 self.angle_y = 0 self.origin_x = None self.image = None
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkDICOMImageReader(), 'Reading vtkDICOMImage.', (), ('vtkDICOMImage',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def FolderRead(folder_path): """Read DICOM files inside the given folder path, and read them as one 3D array Using: VTK""" reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(folder_path) reader.Update() # Load dimensions using `GetDataExtent` _extent = reader.GetDataExtent() ConstPixelDims = [ _extent[1] - _extent[0] + 1, _extent[3] - _extent[2] + 1, _extent[5] - _extent[4] + 1, 1 ] # Load spacing values ConstPixelSpacing = reader.GetPixelSpacing() # Get the 'vtkImageData' object from the reader imageData = reader.GetOutput() # Get the 'vtkPointData' object from the 'vtkImageData' object pointData = imageData.GetPointData() # Get the `vtkArray` (or whatever derived type) which is needed for the `numpy_support.vtk_to_numpy` function arrayData = pointData.GetArray(0) # Convert the `vtkArray` to a NumPy array ArrayDicom = numpy_support.vtk_to_numpy(arrayData) # Reshape the NumPy array to 3D using 'ConstPixelDims' as a 'shape' data = ArrayDicom.reshape(ConstPixelDims, order='F') if (np.shape(np.shape(data))[0] == 3): #If channel data not present data = np.expand_dims(data, 3) return data
def viz_VisualizeDICOM(self, path): volume = vtk.vtkVolume() dc_img_reader = vtk.vtkDICOMImageReader() dc_img_reader.SetDirectoryName(path) dc_img_reader.Update() dc_color_func = vtk.vtkColorTransferFunction() dc_color_func.AddRGBPoint(-3024, 0.0, 0.0, 0.0) dc_color_func.AddRGBPoint(-77, 0.55, 0.25, 0.15) dc_color_func.AddRGBPoint(94, 0.88, 0.60, 0.29) dc_color_func.AddRGBPoint(179, 1.0, 0.94, 0.95) dc_color_func.AddRGBPoint(260, 0.62, 0.0, 0.0) dc_color_func.AddRGBPoint(3071, 0.82, 0.66, 1.0) dc_alpha_func = vtk.vtkPiecewiseFunction() dc_alpha_func.AddPoint(-3024, 0.0) dc_alpha_func.AddPoint(-77, 0.0) dc_alpha_func.AddPoint(94, 0.29) dc_alpha_func.AddPoint(179, 0.55) dc_alpha_func.AddPoint(260, 0.84) dc_alpha_func.AddPoint(3071, 0.875) volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(dc_color_func) volumeProperty.SetScalarOpacity(dc_alpha_func) volumeProperty.ShadeOn() volumeProperty.SetInterpolationTypeToLinear() volumeMapper = vtk.vtkGPUVolumeRayCastMapper() volumeMapper.SetInputConnection(dc_img_reader.GetOutputPort()) volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) self.__ren.AddVolume(volume)
def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.ui = Ui_Form() self.ui.setupUi(self) self.reader = vtk.vtkDICOMImageReader() #self.viewerL = vtk.vtkImageViewer2() #self.viewerR = vtk.vtkImageViewer2() self.renL = vtk.vtkRenderer() self.ui.leftVtk.GetRenderWindow().AddRenderer(self.renL) self.renR = vtk.vtkRenderer() self.ui.rightVtk.GetRenderWindow().AddRenderer(self.renR) self.mapperL = vtk.vtkImageMapper() self.mapperL.SetInputConnection(self.reader.GetOutputPort()) self.mapperR = vtk.vtkImageMapper() self.actorL = vtk.vtkActor2D() self.actorL.SetMapper(self.mapperL) self.actorR = vtk.vtkActor2D() self.actorR.SetMapper(self.mapperR) self.renL.AddActor2D(self.actorL) self.renR.AddActor2D(self.actorR) self.importer = vtk.vtkImageImport() self.mapperR.SetInputConnection(self.importer.GetOutputPort()) self.loadImage(os.path.join(STARTINGPATH, FILENAME)) self.setWindowingAlg()
def get_vtk_reader(filename): '''Get the appropriate vtkImageReader given the filename This function utilizes the factory method classes in VTK with some added functionality for working with the AIM, nifti, and dicom readers. Args: filename (string): Image to be read in Returns: vtkImageReader: The corresponding vtkImageReader or None if one cannot be found. ''' # Try factory method reader = vtk.vtkImageReader2Factory.CreateImageReader2(filename) # If it doesn't work, try specific cases if reader is None: if filename.lower().endswith('.aim'): reader = vtkbone.vtkboneAIMReader() reader.DataOnCellsOff() elif filename.lower().endswith('.nii'): reader = vtk.vtkNIFTIImageReader() elif filename.lower().endswith('.nii.gz'): reader = vtk.vtkNIFTIImageReader() elif filename.lower().endswith('.dcm'): reader = vtk.vtkDICOMImageReader() return reader
def read_dicom(filename): """ dicomデータの読み込み. Parameters ---------- filename : string dicomデータのディレクトリへのパスを指定. Returns ------- image : vtk型のimage画像. """ reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(filename) reader.Update() # vtkとDICOM画像において,空間座標系が違うため変換が必要. # 詳細は,“https://itk.org/Wiki/Proposals:Orientation” flip = vtk.vtkImageFlip() flip.SetFilteredAxis(1) flip.SetInputData(reader.GetOutput()) flip.SetOutputSpacing(reader.GetDataSpacing()) flip.Update() image = flip return image
def load_dicom(foldername, doflipz = True): reader = vtk.vtkDICOMImageReader() reader.SetFileName(foldername) reader.Update() #note: It workes when the OS sorts the files correctly by itself. If the files weren’t properly named, lexicographical sorting would have given a messed up array. In that # case you need to loop and pass each file to a separate reader through the SetFileName method, or you’d have to create a vtkStringArray, push the sorted filenames, and use # the vtkDICOMImageReader.SetFileNames method. # Load meta data: dimensions using `GetDataExtent` _extent = reader.GetDataExtent() ConstPixelDims = [_extent[1]-_extent[0]+1, _extent[3]-_extent[2]+1, _extent[5]-_extent[4]+1] # Get the 'vtkImageData' object from the reader imageData = reader.GetOutput() # Get the 'vtkPointData' object from the 'vtkImageData' object pointData = imageData.GetPointData() # Ensure that only one array exists within the 'vtkPointData' object assert (pointData.GetNumberOfArrays()==1) # Get the `vtkArray` (or whatever derived type) which is needed for the `numpy_support.vtk_to_numpy` function arrayData = pointData.GetArray(0) # Convert the `vtkArray` to a NumPy array ArrayDicom = numpy_support.vtk_to_numpy(arrayData) # Reshape the NumPy array to 3D using 'ConstPixelDims' as a 'shape' ArrayDicom = ArrayDicom.reshape(ConstPixelDims, order='F') return (ArrayDicom)
def convert(filepath): filepath = "./display/" reader = vtk.vtkDICOMImageReader() #we create a new vtkDICOMImageReader under the name of reader which we use to read the DICOM images. reader.SetDirectoryName(filepath) reader.Update() image = reader.GetOutput() shiftScaleFilter = vtkImageShiftScale() shiftScaleFilter.SetOutputScalarTypeToUnsignedChar() shiftScaleFilter.SetInputConnection(reader.GetOutputPort()) shiftScaleFilter.SetShift(-1.0*image.GetScalarRange()[0]) oldRange = image.GetScalarRange()[1] - image.GetScalarRange()[0] newRange = 255 shiftScaleFilter.SetScale(newRange/oldRange) shiftScaleFilter.Update() writer = vtkPNGWriter() writer.SetFileName('./display/output.png') # you give the path-filename where you want the output to be writer.SetInputConnection(shiftScaleFilter.GetOutputPort()) writer.Write() return 1
def __init__(self, parent=None): QtGui.QMainWindow.__init__(self, parent) self.frame = QtGui.QFrame() self.vl = QtGui.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.vtkWidget) self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() # Create source source = vtk.vtkDICOMImageReader() source.SetFileName("D:\Anaconda\workspace\pytest\patient\\1.dcm") # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.ren.AddActor(actor) self.ren.ResetCamera() self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() self.iren.Initialize()
def view_dicom(PathDicom): reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(PathDicom) reader.Update() # Load dimensions using `GetDataExtent` _extent = reader.GetDataExtent() ConstPixelDims = [ _extent[1] - _extent[0] + 1, _extent[3] - _extent[2] + 1, _extent[5] - _extent[4] + 1 ] # Load spacing values ConstPixelSpacing = reader.GetPixelSpacing() # Get the 'vtkImageData' object from the reader imageData = reader.GetOutput() # Get the 'vtkPointData' object from the 'vtkImageData' object pointData = imageData.GetPointData() # Ensure that only one array exists within the 'vtkPointData' object assert (pointData.GetNumberOfArrays() == 1) # Get the `vtkArray` (or whatever derived type) which is needed for the `numpy_support.vtk_to_numpy` function arrayData = pointData.GetArray(0) # Convert the `vtkArray` to a NumPy array ArrayDicom = numpy_support.vtk_to_numpy(arrayData) # Reshape the NumPy array to 3D using 'ConstPixelDims' as a 'shape' ArrayDicom = ArrayDicom.reshape(ConstPixelDims, order='F')
def __init__(self, parent=None): QtWidgets.QMainWindow.__init__(self, parent) self.frame = QtWidgets.QFrame() self.vl = QtWidgets.QVBoxLayout() self.QtInteractor = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.QtInteractor) self.dicom_image_path = 'IM-0008-0034.dcm' # '----------set up dicom reader---------------' self.dcmReader = vtk.vtkDICOMImageReader() self.dcmReader.SetDataByteOrderToLittleEndian() self.dcmReader.SetFileName(self.dicom_image_path) self.dcmReader.Update() # '----------init render---------------' self.ren = vtk.vtkRenderer() # show the dicom flie self.imageViewer = vtk.vtkImageViewer2() self.imageViewer.SetInputConnection(self.dcmReader.GetOutputPort()) self.renderWindowInteractor = vtk.vtkRenderWindowInteractor() self.imageViewer.SetupInteractor(self.renderWindowInteractor) self.imageViewer.Render() self.imageViewer.GetRenderer().ResetCamera() self.imageViewer.Render() self.renderWindowInteractor.Start()
def read_dicom_vtk(dir_path, show_shape=False): """A function that read dicom series file Args: dir_path, a string for dicom path show_shape, boolean of whether to show image shape Returns: Tuple of dicom image spacing and dicom image in numpy format, note dicom file has origin (0,0,0) """ if not os.path.exists(dir_path): raise ValueError('Input path does not exist!') reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(dir_path) reader.Update() spacing = list(reader.GetPixelSpacing()) # x, y, z spacing.reverse() # z, y, x _extent = reader.GetDataExtent() ConstPixelDims = [ _extent[1] - _extent[0] + 1, _extent[3] - _extent[2] + 1, _extent[5] - _extent[4] + 1 ] imageData = reader.GetOutput() pointData = imageData.GetPointData() assert (pointData.GetNumberOfArrays() == 1) arrayData = pointData.GetArray(0) ArrayDicom = numpy_support.vtk_to_numpy(arrayData) # sometimes vtk does not work if ArrayDicom.sum() == 0: raise ValueError('The output image is empty, try read_dicom_itk!') ArrayDicom = ArrayDicom.reshape(ConstPixelDims, order='F') ArrayDicom = np.rot90(ArrayDicom, 1) ArrayDicom = np.transpose(ArrayDicom, [2, 0, 1]) if show_shape: print "Image shape is %s" % (ArrayDicom.shape, ) return np.array(spacing), ArrayDicom
def __init__(self, parent=None): QtWidgets.QMainWindow.__init__(self, parent) self.frame = QtWidgets.QFrame() self.vl = QtWidgets.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.vtkWidget) self.dicom_image_path = './IM-0008-0034.dcm' # '----------set up dicom reader---------------' self.dcmReader = vtk.vtkDICOMImageReader() self.dcmReader.SetDataByteOrderToLittleEndian() self.dcmReader.SetDirectoryName( r"D:\Users\user\Desktop\NTUCT\1323\Ct_Without_ContrastBrain - 1323\InnerEar_C_06_U70u_4" ) self.dcmReader.Update() # '----------init render---------------' self.ren = vtk.vtkRenderer() # '---------set up mapper----------' self.slice_mapper = vtk.vtkImageSliceMapper() self.slice_mapper.SetInputConnection(self.dcmReader.GetOutputPort()) # set random slice number # self.slice_mapper.SetSliceNumber(50) # set up image_slice self.image_slice = vtk.vtkImageSlice() self.image_slice.SetMapper(self.slice_mapper) # '-----set up window and level of image_slice----' # self.MinMax = self.dcmReader.GetOutput().GetScalarRange() # self.image_slice_property = self.image_slice.GetProperty() # self.image_slice_property.SetColorWindow(self.MinMax[1]) # self.image_slice_property.SetColorLevel((self.MinMax[1] - self.MinMax[0]) / 2) # self.image_slice.Update() # '---------set image_slice as input for renderer------' self.ren.AddViewProp(self.image_slice) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(self.dcmReader.GetOutputPort()) # # Create an actor # actor = vtk.vtkActor() # actor.SetMapper(mapper) # self.ren.AddActor(actor) self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() self.ren.ResetCamera() self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() self.iren.Initialize()
def __init__(self, parent=None): QtWidgets.QMainWindow.__init__(self, parent) self.dicom_image_path = './IM-0008-0034.dcm' # '----------set up dicom reader---------------' self.dcmReader = vtk.vtkDICOMImageReader() self.dcmReader.SetDataByteOrderToLittleEndian() self.dcmReader.SetDirectoryName( r"D:\Users\user\Desktop\NTUCT\1323\Ct_Without_ContrastBrain - 1323\InnerEar_C_06_U70u_4" ) self.dcmRescaleSlope = self.dcmReader.GetRescaleSlope() self.dcmRescaleOffset = self.dcmReader.GetRescaleOffset() self.dcmReader.Update() # '----------viewer---------' self.dcmViewer = vtk.vtkImageViewer2() self.dcmViewer.SetInputConnection(self.dcmReader.GetOutputPort()) # '------deal with WW & WL-----' self.ww = 3500 # WW self.wl = 600 # WL self.dcmViewer.SetColorLevel(self.wl) self.dcmViewer.SetColorWindow(self.ww) # '----------TextOverLay---------' # slice status message self.sliceTextProp = vtk.vtkTextProperty() self.sliceTextProp.SetFontFamilyToCourier() self.sliceTextProp.SetFontSize(20) self.sliceTextProp.SetVerticalJustificationToBottom() self.sliceTextProp.SetJustificationToLeft() # '---------set up Text Overlay mapper----------' self.sliceTextMapper = vtk.vtkTextMapper() cur_slice = self.dcmViewer.GetSlice() print('cur_slice = ', cur_slice, ' viewer.GetSliceMax() = ', self.dcmViewer.GetSliceMax()) msg = ( ' %d / %d ' % (self.dcmViewer.GetSlice() + 1, self.dcmViewer.GetSliceMax() + 1)) # '---------set up Text Overlay Actor----------' self.sliceTextMapper.SetInput(msg) sliceTextActor = vtk.vtkActor2D() sliceTextActor.SetMapper(self.sliceTextMapper) sliceTextActor.SetPosition(15, 10) self.window_interactor = vtk.vtkRenderWindowInteractor() self.dcmViewer.SetupInteractor(self.window_interactor) self.dcmViewer.GetRenderer().AddActor2D(sliceTextActor) '----------add keyboard observer---------' self.window_interactor.AddObserver(vtk.vtkCommand.KeyPressEvent, self.keyboard_callback_func) self.window_interactor.Initialize() self.dcmViewer.Render() self.dcmViewer.GetRenderer().ResetCamera() self.dcmViewer.Render() self.window_interactor.Start()
def __init__(self): QFrame.__init__(self) self.rendering_threshold = 0 self.arter = vtk.vtkActor() self.outline = vtk.vtkActor() self.vtk_image_reader = vtk.vtkDICOMImageReader() self.window_initialization()
def readDICOM(self, *args): # create reader reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(self.directory) reader.Update() return reader
def load_dcm(filename): reader = vtk.vtkDICOMImageReader() if ".dcm" in filename: filename = filename.replace(filename.split('/')[-1], "") reader.SetDirectoryName(filename) reader.Update() return reader.GetOutput()
def DiconSeriesReader(path): ''' http://www.vtk.org/Wiki/VTK/Examples/Cxx/IO/ReadDICOMSeries ''' reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(ff) reader.Update() return reader.GetOutput()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkDICOMImageReader(), 'Reading vtkDICOMImage.', (), ('vtkDICOMImage', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def new(renderWindowInteractor): a = vtk.QVTKWidget() reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName("D:\Anaconda\workspace\pytest\patient") # reader.SetDirectoryName("G:\Win64\Anaconda3.4\workplace\\vtk\dicom") reader.Update() imageViewer = vtk.vtkImageViewer2() imageViewer.SetInputConnection(reader.GetOutputPort()) sliceTextProp = vtk.vtkTextProperty() sliceTextProp.SetFontFamilyToCourier() sliceTextProp.SetFontSize(20) sliceTextProp.SetVerticalJustificationToBottom() sliceTextProp.SetJustificationToLeft() sliceTextMapper = vtk.vtkTextMapper() msg = str(imageViewer.GetSliceMin()) + '/' + str(imageViewer.GetSliceMax()) sliceTextMapper.SetInput(msg) sliceTextMapper.SetTextProperty(sliceTextProp) sliceTextActor = vtk.vtkActor2D() sliceTextActor.SetMapper(sliceTextMapper) sliceTextActor.SetPosition(15, 10) usageTextProp = vtk.vtkTextProperty() usageTextProp.SetFontFamilyToCourier() usageTextProp.SetFontSize(14) usageTextProp.SetVerticalJustificationToTop() usageTextProp.SetJustificationToLeft() usageTextMapper = vtk.vtkTextMapper() usageTextMapper.SetInput( "- Slice with mouse wheel\n or Up/Down-Key\n- Zoom with pressed right\n mouse button while dragging" ) usageTextMapper.SetTextProperty(usageTextProp) usageTextActor = vtk.vtkActor2D() usageTextActor.SetMapper(usageTextMapper) usageTextActor.GetPositionCoordinate( ).SetCoordinateSystemToNormalizedDisplay() usageTextActor.GetPositionCoordinate().SetValue(0.05, 0.95) # renderWindowInteractor =vtk.vtkRenderWindowInteractor() # myInteractorStyle = vtk. myVtkInteractorStyleImage() # # myInteractorStyle.SetImageViewer(imageViewer) # myInteractorStyle.SetStatusMapper(sliceTextMapper) imageViewer.SetupInteractor(renderWindowInteractor) imageViewer.SetSlice(12) # style= vtk.vtkInteractorStyleUser(imageViewer=imageViewer) # renderWindowInteractor.SetInteractorStyle(style) imageViewer.GetRenderer().AddActor2D(sliceTextActor) imageViewer.GetRenderer().AddActor2D(usageTextActor) imageViewer.Render() imageViewer.GetRenderer().ResetCamera() imageViewer.Render()
def createPipeline(self, _filename): # Read in the file if _filename.lower().endswith('.nii'): self.reader = vtk.vtkNIFTIImageReader() self.reader.SetFileName(_filename) elif _filename.lower().endswith('.nii.gz'): self.reader = vtk.vtkNIFTIImageReader() self.reader.SetFileName(_filename) elif _filename.lower().endswith('.dcm'): self.reader = vtk.vtkDICOMImageReader() self.reader.SetDirectoryName(os.path.dirname(_filename)) elif os.path.isdir(_filename): self.reader = vtk.vtkDICOMImageReader() self.reader.SetDirectoryName(_filename) if self.reader is None: os.sys.exit("[ERROR] Cannot find reader for file \"{}\"".format( self.filename)) self.reader.Update() # Gaussian smoothing self.gauss.SetStandardDeviation(self.gaussian, self.gaussian, self.gaussian) self.gauss.SetRadiusFactors(self.radius, self.radius, self.radius) self.gauss.SetInputConnection(self.reader.GetOutputPort()) # Marching Cubes self.marchingCubes.SetInputConnection(self.gauss.GetOutputPort()) self.marchingCubes.ComputeGradientsOn() self.marchingCubes.ComputeNormalsOn() self.marchingCubes.ComputeScalarsOff() self.marchingCubes.SetNumberOfContours(1) self.marchingCubes.SetValue(0, self.isosurface) # Set mapper for image data self.mapper.SetInputConnection(self.marchingCubes.GetOutputPort()) # Actor self.actor.SetMapper(self.mapper) self.actor.GetProperty().SetColor((0.890, 0.855, 0.788)) self.renderer.AddActor(self.actor) self.refreshRenderWindow() return
def readInputFile(self): # Read the file if os.path.isdir(self.inputFileName): # DICOM dir self.reader = vtk.vtkDICOMImageReader() self.reader.SetDirectoryName(self.inputFileName) #print("DICOM dir") elif self.inputFileName.lower().endswith('.nii'): # NIfTI file self.reader = vtk.vtkNIFTIImageReader() self.reader.SetFileName(self.inputFileName) #print("NIfTI file") elif self.inputFileName.lower().endswith(('.dicom', '.dcm')): # DICOM file self.reader = vtk.vtkDICOMImageReader() self.reader.SetFileName(self.inputFileName) #print("DICOM file") else: # Not recognized self.inputFileName = None self.reader = None return self.reader.Update()
def read_dicom(directory): # Create reader object ans set directory name reader = vtkDICOMImageReader() reader.SetDirectoryName(directory) # Set other settings and update reader.SetDataByteOrderToLittleEndian() #data_spacing = (1, 1, 2) #reader.SetDataSpacing(data_spacing[0], data_spacing[1], data_spacing[2]) reader.Update() return reader
def change_data(self, path_to_data, data_type): if data_type is DataType.DICOM: image_reader = vtk.vtkDICOMImageReader() image_reader.SetDirectoryName(path_to_data) self.__setup_default_volume_parameters(image_reader) self.volume_data_changed.emit() elif data_type is DataType.META_IMAGE: image_reader = vtk.vtkMetaImageReader() image_reader.SetFileName(path_to_data) self.__setup_default_volume_parameters(image_reader) self.volume_data_changed.emit()
def read_dicom(dicom_dir): # fnames = os.listdir(dicom_dir) # fnames = [f for f in fnames if ".dcm" in f] # fnames = sorted(fnames) # fnames = [os.path.join(dicom_dir,f) for f in fnames] reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(dicom_dir) reader.Update() return reader.GetOutput()
def __init__(self, inputs, use_vtk=False): self.inputs = inputs if use_vtk: print('Using VTK to read DICOMs ...') self.load_dicom_array = self.load_with_vtk self.reader = vtk.vtkDICOMImageReader() else: print('Using pydicom to read DICOMS ...') self.load_dicom_array = self.load_with_pydicom
def TestGPUVolumeRender(): """ Test GPU DICOM Loader Usage, uncomment the DEBUG TEST lines before use :return: """ reader = vtk.vtkDICOMImageReader() reader.SetDataByteOrderToLittleEndian() reader.SetDirectoryName("../TestData/cta_output") reader.SetDataSpacing(3.2, 3.2, 1.5) reader.SetDataOrigin(0, 0, 0) print "test" vol = VolumeRenderingGPUDICOMLoader(reader)
def rendering( dataPath, dualSurface): import SimpleITK as sitk # # writing_path='data.nii' # reader = itk.ImageFileReader.New(FileName=dataPath) # reader.SetFileName(dataPath) # reader.Update() # image_input=reader.GetOutput() # # # imagee_out=sitk.GetImageFromArray(imagee) # # writer =itk.ImageFileWriter.New() # writer.SetFileName(writing_path) # writer.SetInput(image_input) # writer.Update() img=sitk.ReadImage(dataPath) img.SetSpacing([0.18,0.18,0.18]) sitk.WriteImage(img,dataPath) # Read the data if dataPath.endswith('.nii'): reader = vtk.vtkNIFTIImageReader() # reader.SetSpacing(1,1,1) reader.SetFileName(dataPath) reader.Update() elif dataPath.endswith('.nhdr') or dataPath.endswith('.nrrd'): reader = vtk.vtkNrrdReader() reader.SetFileName(dataPath) # reader.SetSpacing(0.18,0.18,0.18) reader.Update() else: reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(dataPath) reader.Update() # Smooth the image filteredImage = gaussianFilter(reader) # Surface rendering if dualSurface: dualSurfaceRendering(filteredImage)
def GetImageDataFromDirectory(self, dirName): """ This method is just for DICOM image data. So input is a directory name and it will output an vtkImageData object. :type dirName: basestr :rtype: vtkImageData """ imageReader = vtkDICOMImageReader() imageReader.SetDirectoryName(dirName) imageReader.Update() imageData = imageReader.GetOutput() self.SanitizeImageData(imageReader, imageData) return imageData
def readT2(self, path_T2Series): """ ARGUMENTS: ============= StudyID (str) Study CAD patient number DicomExamNumber (str) Imaging Study Number SeriesID (str) T2 Series number (e.g S600, S3) Lesions_id (str) Older database LesionID identifier OUTPUTS: ============= DICOMImages list(vtkImageData) List of vtkImageData objects corresponding to dynamic series """ # Get total number of files and some DICOM tags needed fro DICOM coords [len_listSeries_files, FileNms_slices_sorted_stack] = self.ReadDicomfiles(path_T2Series) mostleft_slice = FileNms_slices_sorted_stack.slices[0] # Get dicom header, retrieve: image_pos_pat and image_ori_pat dicomInfoT2 = dicom.read_file(path_T2Series+os.sep+str(mostleft_slice)) self.slice_thicknT2 = float(dicomInfoT2[0x0018,0x0050].value) # Image Position (0020,0032): specifies the x, y, and z coordinates of the upper left hand corner of the image. This tag specifies the coordinates self.T2image_pos_pat = list(dicomInfoT2[0x0020,0x0032].value) self.T2image_ori_pat = list(dicomInfoT2[0x0020,0x0037].value) self.T2fatsat = dicomInfoT2[0x0019,0x10a4].value os.chdir(path_T2Series) dicomReader = vtk.vtkDICOMImageReader() dicomReader.SetDirectoryName( path_T2Series ) dicomReader.Update() im = vtk.vtkImageData() im = dicomReader.GetOutput() self.T2dims = im.GetDimensions() self.T2spacing = im.GetSpacing() print "VTK Dimensions im.GetDimensions(): %d %d %d" % self.T2dims print "VTK Spacing im.GetSpacing(): %f %f %f\n" % self.T2spacing # to objects image self.T2Images = im return self.T2Images
def TestVolumeRender(): """ Test DICOM loader usage, uncomment the DEBUG TEST lines before use :return: """ reader = vtk.vtkDICOMImageReader() reader.SetDataByteOrderToLittleEndian() reader.SetDirectoryName("../TestData/cta_output") reader.SetDataSpacing(3.2, 3.2, 1.5) reader.SetDataOrigin(0, 0, 0) vol = VolumeRenderingDICOMLoader(reader) renderer = vtk.vtkRenderer() renderer.AddVolume(vol) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) # vdisplay = xvfbwrapper.Xvfb() # vdisplay.start() ImageWriter(renderer, outFileName="tmp") renderer.GetActiveCamera().Azimuth(40) ImageWriter(renderer, outFileName="tmp2")
def main(): argc = len(sys.argv) # Verify input arguments if argc != 2: print "Usage: ", sys.argv[0], " FolderName" return sys.exit(1) folder = sys.argv[1] # Read all the DICOM files in the specified directory. reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(folder) reader.Update() # Visualize imageViewer = vtk.vtkImageViewer2() imageViewer.SetInputConnection(reader.GetOutputPort()) # slice status message sliceTextProp = vtk.vtkTextProperty() sliceTextProp.SetFontFamilyToCourier() sliceTextProp.SetFontSize(20) sliceTextProp.SetVerticalJustificationToBottom() sliceTextProp.SetJustificationToLeft() sliceTextMapper = vtk.vtkTextMapper() msg = "Slice {} out of {}".format(imageViewer.GetSliceMin() + 1, \ imageViewer.GetSliceMax() + 1) sliceTextMapper.SetInput(msg) sliceTextMapper.SetTextProperty(sliceTextProp) sliceTextActor = vtk.vtkActor2D() sliceTextActor.SetMapper(sliceTextMapper) sliceTextActor.SetPosition(15, 10) # usage hint message usageTextProp = vtk.vtkTextProperty() usageTextProp.SetFontFamilyToCourier() usageTextProp.SetFontSize(14) usageTextProp.SetVerticalJustificationToTop() usageTextProp.SetJustificationToLeft() usageTextMapper = vtk.vtkTextMapper() usageTextMapper.SetInput("- Slice with mouse wheel\n or Up/Down-Key\n- Zoom with pressed right\n mouse button while dragging") usageTextMapper.SetTextProperty(usageTextProp) usageTextActor = vtk.vtkActor2D() usageTextActor.SetMapper(usageTextMapper) usageTextActor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay() usageTextActor.GetPositionCoordinate().SetValue( 0.05, 0.95) interactor = vtk.vtkInteractorStyleImage() #interactor.SetImageViewer(imageViewer) #interactor.SetStatusMapper(sliceTextMapper) #imageViewer.SetupInteractor(renWin) #renderWindowInteractor.SetInteractorStyle(myInteractorStyle) # add slice status message and usage hint message to the renderer imageViewer.GetRenderer().AddActor2D(sliceTextActor) imageViewer.GetRenderer().AddActor2D(usageTextActor)
def GetRawDICOMData(self,idtime,outDirectoryID): # loop until files are ready to be read in realImageFilenames = [] imagImageFilenames = [] # FIXME: index fun, slice start from 0, echo start from 1 for idslice in range(self.nslice): for idecho in range(1,self.NumberEcho+1): realImageFilenames.append( self.QueryDictionary( idtime,idecho,idslice,2 ) ) imagImageFilenames.append( self.QueryDictionary( idtime,idecho,idslice,3 ) ) #create local vars rootdir = self.dataDirectory RawDim = self.RawDimensions real_array=numpy.zeros(self.FullSizeRaw,dtype=numpy.float32) imag_array=numpy.zeros(self.FullSizeRaw,dtype=numpy.float32) vtkAppendReal = vtk.vtkImageAppendComponents() vtkAppendImag = vtk.vtkImageAppendComponents() for idEchoLoc,(fileNameReal,fileNameImag) in enumerate(zip(realImageFilenames,imagImageFilenames)): # FIXME: index nightmare # FIXME: will be wrong for different ordering # arrange such that echo varies fast then x, then y, then z # example of how slicing behaves #>>> x = range(100) #>>> x #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] #>>> x[0:100:10] #[0, 10, 20, 30, 40, 50, 60, 70, 80, 90] #>>> x[1:100:10] #[1, 11, 21, 31, 41, 51, 61, 71, 81, 91] #>>> x[2:100:10] #[2, 12, 22, 32, 42, 52, 62, 72, 82, 92] #>>> x[3:100:10] #[3, 13, 23, 33, 43, 53, 63, 73, 83, 93] idEcho = idEchoLoc % RawDim[3] idSlice = idEchoLoc / RawDim[3] beginIndex = RawDim[0]*RawDim[1]*RawDim[3]* idSlice +idEcho finalIndex = RawDim[0]*RawDim[1]*RawDim[3]*(idSlice+1) stepIndex = RawDim[3] ## realds = dicom.read_file( "%s/%s"%(rootdir,fileNameReal) ) ## imagds = dicom.read_file( "%s/%s"%(rootdir,fileNameImag) ) ## realsliceID = int( round((float(realds.SliceLocation) - float(realds[0x0019,0x1019].value))/ realds.SliceThickness)) ## imagsliceID = int( round((float(imagds.SliceLocation) - float(imagds[0x0019,0x1019].value))/ imagds.SliceThickness)) ## print "%03d echo %03d slice %03d slice [%d:%d:%d] %03d %s %03d %s "% (idEchoLoc,idEcho,idSlice,beginIndex,finalIndex,stepIndex,realsliceID,fileNameReal,imagsliceID,fileNameImag ) vtkRealDcmReader = vtk.vtkDICOMImageReader() vtkRealDcmReader.SetFileName("%s/%s"%(rootdir,fileNameReal) ) vtkRealDcmReader.Update() vtkRealData = vtk.vtkImageCast() vtkRealData.SetOutputScalarTypeToFloat() vtkRealData.SetInput( vtkRealDcmReader.GetOutput() ) vtkRealData.Update( ) real_image = vtkRealData.GetOutput().GetPointData() real_array[ beginIndex: finalIndex : stepIndex ] = vtkNumPy.vtk_to_numpy(real_image.GetArray(0)) vtkImagDcmReader = vtk.vtkDICOMImageReader() vtkImagDcmReader.SetFileName("%s/%s"%(rootdir,fileNameImag) ) vtkImagDcmReader.Update() vtkImagData = vtk.vtkImageCast() vtkImagData.SetOutputScalarTypeToFloat() vtkImagData.SetInput( vtkImagDcmReader.GetOutput() ) vtkImagData.Update( ) imag_image = vtkImagData.GetOutput().GetPointData() imag_array[ beginIndex: finalIndex : stepIndex ] = vtkNumPy.vtk_to_numpy(imag_image.GetArray(0)) vtkAppendReal.SetInput( idEchoLoc ,vtkRealDcmReader.GetOutput() ) vtkAppendImag.SetInput( idEchoLoc ,vtkImagDcmReader.GetOutput() ) vtkAppendReal.Update( ) vtkAppendImag.Update( ) if (SetFalseToReduceFileSystemUsage): vtkRealDcmWriter = vtk.vtkDataSetWriter() vtkRealDcmWriter.SetFileName("Processed/%s/realrawdata.%04d.vtk" % (outDirectoryID,idtime) ) vtkRealDcmWriter.SetInput(vtkAppendReal.GetOutput()) vtkRealDcmWriter.Update() if (SetFalseToReduceFileSystemUsage): vtkImagDcmWriter = vtk.vtkDataSetWriter() vtkImagDcmWriter.SetFileName("Processed/%s/imagrawdata.%04d.vtk" % (outDirectoryID,idtime) ) vtkImagDcmWriter.SetInput(vtkAppendImag.GetOutput()) vtkImagDcmWriter.Update() # write numpy to disk in matlab echoTimes = [] for idecho in range(1,self.NumberEcho+1): localKey = self.keyTemplate % ( idtime,idecho,0,2 ) echoTimes.append(self.DicomDataDictionary[localKey][1]) if (SetFalseToReduceFileSystemUsage): scipyio.savemat("Processed/%s/rawdata.%04d.mat"%(outDirectoryID,idtime), {'dimensions':RawDim,'echoTimes':echoTimes,'real':real_array,'imag':imag_array}) # end GetRawDICOMData return ((real_array,imag_array),echoTimes)
file_series = open(filename_series,'r') files_toRead = file_series.read() try: for slicename in files_toRead.split(): print "adding : %s" % slicename vtkStringArray.InsertNextValue( slicename ) finally: file_series.close() # Read dicom Vol from DIRCONTENTS.txt dicomReader = vtkgdcmPython.vtkGDCMImageReader() dicomReader.SetFileNames( vtkStringArray ) dicomReader.FileLowerLeftOn() dicomReader.Update() else: dicomReader = vtk.vtkDICOMImageReader() dicomReader.SetDirectoryName( chosen_folderID ) # neccesarily, most VTK image readers flip the images from their original top-to-bottom rasterization to a bottom-to-top rasterization instead. dicomReader.FileLowerLeftOn() dicomReader.Update() # display the results. renderer1 = vtk.vtkRenderer() renWin1 = vtk.vtkRenderWindow() iren1 = vtk.vtkRenderWindowInteractor() renWin1.SetSize(1000, 800); renWin1.AddRenderer(renderer1); iren1.SetRenderWindow(renWin1); [transform_cube, z_visualSerie] = display(dicomReader.GetOutput(), image_pos_pat_visual_SerieID, image_ori_pat_visual_SerieID)
import sys import vtk import os testReader = vtk.vtkDICOMImageReader() fullPath = os.path.realpath(__file__) projectPath= os.path.dirname(os.path.dirname(os.path.dirname(fullPath))) testReader.SetFileName(projectPath + "/res/3.dcm") testReader.Update() viewer = vtk.vtkImageViewer() viewer.SetInputConnection(testReader.GetOutputPort()) viewer.Render() viewer.GetRenderer().ResetCamera() viewer.Render() b = raw_input("Im Weroniczka and I know it: ")
# generate file names dirID = 115298 rootdir = "/FUS4/data2/CHUN_LI/070131/e114985/s%d" % dirID dirID = 8980 rootdir = "/FUS4/data2/nanorods/20101019nanorods/e7605/s%d" % dirID nsteps = 60 realimagdata = [] for idfile in range(1,nsteps*2,2): realimagdata.append( ("i%d.MRDC.%d"%(dirID+idfile + 0,idfile + 0), "i%d.MRDC.%d"%(dirID+idfile + 1,idfile + 1) ) ) # get some header data vtkDicomInfo = vtk.vtkDICOMImageReader() vtkDicomInfo.SetFileName("%s/%s"%(rootdir,"i%d.MRDC.%d"%(dirID+1,1) ) ) vtkDicomInfo.Update() dimensions = vtkDicomInfo.GetOutput().GetDimensions() spacing_mm = vtkDicomInfo.GetOutput().GetSpacing() origin_mm = vtkDicomInfo.GetOutput().GetOrigin() #convert to meter spacing = [ 0.001 * dXi for dXi in spacing_mm ] origin = [ 0.001 * Xi for Xi in origin_mm ] print dimensions, spacing, origin # temperature map factor alpha = +0.0097 # FIXME should be negative but phase messed up somewhere # FIXME need to extract automagically at some point #(0018|0081) Echo Time = 9.648 #(0018|0082) Inversion Time = 0
def DisplayDicom(folder=directory): reader = vtk.vtkDICOMImageReader() reader.SetDirectoryName(directory) reader.Update() DisplayImageData(reader.GetOutput())
def main(argv): if len(argv) < 2: print "usage: ",argv[0]," <data>" exit(1) data_fn = argv[1] mapper = vtk.vtkPolyDataMapper() if data_fn.find('.vtk') != -1: reader = vtk.vtkPolyDataReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() trianglize = vtk.vtkDelaunay2D() trianglize.SetInput(data) trianglize.Update() mapper.SetInputConnection(trianglize.GetOutputPort()) elif data_fn.find('.pgm') != -1: reader = vtk.vtkPNMReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() trianglize = vtk.vtkImageDataGeometryFilter() trianglize.SetInput(data) trianglize.Update() warp = vtk.vtkWarpScalar() warp.SetScaleFactor(0.2) # arbitrary choice warp.SetInputConnection(trianglize.GetOutputPort()) warp.Update() mapper.SetInputConnection(warp.GetOutputPort()) elif data_fn.find('.dcm') != -1: reader =vtk.vtkDICOMImageReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() trianglize = vtk.vtkImageDataGeometryFilter() trianglize.SetInput(data) trianglize.Update() warp = vtk.vtkWarpScalar() #warp.SetScaleFactor(0.2) # arbitrary choice warp.SetInputConnection(trianglize.GetOutputPort()) warp.Update() mapper.SetInputConnection(warp.GetOutputPort()) else: print "unrecognized data file:",data_fn exit(1) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(700,700) renderWindow.AddRenderer(renderer) renderWindow.SetWindowName("heightfield") renderer.AddActor(actor) renderer.SetBackground(0.4,0.3,0.2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def _VolumeRender(self, m_contrastRange=None): # try: # TODO: Write document for the parameter of Volume Render m_imagePath = str(self._inDataDirectory) # TODO: Fill in document m_acceptedFormat = ['nii', 'vtk', 'DICOM'] # Handle contrast range if m_contrastRange == None: m_contrastUpper = None m_contrastLower = 0 else: m_contrastUpper = m_contrastRange[1] m_contrastLower = m_contrastRange[0] # Image type check TODO: nii.gz, DICOM, ECAT, finish nii.gz first m_imagePathSplitted = m_imagePath.split('.') m_suffix = m_imagePathSplitted[-1] # Create rendere first renderer = config.rendererDict[str(self._visualizationJobID)] renderer.SetBackground(0,0,0) # since nifti might be compressed if m_suffix == 'gz': m_suffix = m_imagePathSplitted[-2] if m_acceptedFormat.count(m_suffix) == 0: raise TypeError("Wrong input format, currently except %s"%m_acceptedFormat) # TODO: Write the following part to a reader function # if nifti - Load image as numpy array if m_suffix == 'nii': m_reader = vtk.vtkNIFTIImageReader() m_reader.SetFileName(self._inDataDirectory) # -- Use function from Main Process. mp = MainProcess.MainProcess() m_volume = mp.VolumeRenderingGPURayCast(m_reader, upperThreshold=m_contrastUpper, lowerThreshold=m_contrastLower) renderer.AddVolume(m_volume) # if vtk - Load by vtk methods elif m_suffix == 'vtk': m_reader = vtk.vtkPolyDataReader() m_reader.SetFileName(m_imagePath) # -- Call volume rendering function mp = MainProcess.MainProcess() m_actor = mp.VolumeRenderingDTILoader(m_reader) renderer.AddActor(m_actor) # if DICOM - Load VolumeRenderingDICOMLoader, note that if data is dicom, suffix ".DICOM" show be added to the inDataDirectory elif m_suffix == 'DICOM': # TODO: allows user defined Threshold # -- Construct dicom reader for function in main process m_reader = vtk.vtkDICOMImageReader() m_reader.SetDataByteOrderToLittleEndian() # TODO: allow user input m_reader.SetDirectoryName(m_imagePath.replace(".DICOM", "")) m_reader.SetDataSpacing(3.2,3.2,1.5) # TODO: allow user input m_reader.SetDataOrigin(0,0,0) # TODO: allow user input mp = MainProcess.MainProcess() m_volume = mp.VolumeRenderingGPUDICOMLoader(m_reader) renderer.AddVolume(m_volume) renWin = config.renWinDict[str(self._visualizationJobID)] renWin.AddRenderer(renderer) result = mp.ImageWriter(renderer, dimension=config.dimensionDict[self._visualizationJobID], outCompressionType=self._outCompressionType) return result
def readVolumes(self, path_rootFolder, StudyID, DicomExamNumber, SeriesID, Lesions_id): """ ARGUMENTS: ============= StudyID (str) Study CAD patient number DicomExamNumber (str) Imaging Study Number SeriesID (str) Dynamic Series number (e.g S600, S3) Lesions_id (str) Older database LesionID identifier OUTPUTS: ============= series_path (str) Path to series location phases_series (list) list of pre and post contrast volume names lesionID_path (str) path to lesion segmentation DICOMImages list(vtkImageData) List of vtkImageData objects corresponding to dynamic series """ series_path = path_rootFolder+os.sep+str(StudyID)+os.sep+str(DicomExamNumber) print series_path # test ############################################################### os.chdir(series_path) if os.path.exists('DynPhases'): print '''DynPhases''' # Get series to load series_path = path_rootFolder+os.sep+str(StudyID)+os.sep+str(DicomExamNumber) lesionID_path = series_path+os.sep+'DynPhases'+os.sep+'VOIlesions_id'+str(Lesions_id) phases_series=[] testSID = str(SeriesID) if 'S' in str(testSID): #print testSID[1:] chosen_phase = int(testSID[1:]) else: chosen_phase = int(testSID) if(testSID[0] == 'S'): phases_series.append('S'+str(chosen_phase)) for chSer in [chosen_phase+1, chosen_phase+2, chosen_phase+3, chosen_phase+4]: phases_series.append( 'S'+str(chSer) ) else: phases_series.append(str(chosen_phase)) for chSer in [chosen_phase+1, chosen_phase+2, chosen_phase+3, chosen_phase+4]: phases_series.append( str(chSer) ) if not os.path.exists('DynPhases'): print '''SeriesPhases''' # Get series to load series_path = path_rootFolder+os.sep+str(StudyID)+os.sep+str(DicomExamNumber)+os.sep+str(SeriesID) lesionID_path = series_path+os.sep+'VOIlesions_id'+str(Lesions_id) # process all Volumes when in stacks of Dyn Volumes if os.path.exists(series_path+os.sep+'pre-Contrast'): phases_series = [] phases_series.append('pre-Contrast') #"Arranging series scans" for i in range(1,5): phases_series.append('post_Contrast-'+str(i)) # Get total number of files and some DICOM tags needed fro DICOM coords pre_abspath_PhaseID = series_path+os.sep+phases_series[0] [len_listSeries_files, FileNms_slices_sorted_stack] = self.ReadDicomfiles(pre_abspath_PhaseID) mostleft_slice = FileNms_slices_sorted_stack.slices[0] # Get dicom header, retrieve: image_pos_pat and image_ori_pat dicomInfo_series = dicom.read_file(pre_abspath_PhaseID+os.sep+str(mostleft_slice)) self.slice_thickn = float(dicomInfo_series[0x0018,0x0050].value) # Image Position (0020,0032): specifies the x, y, and z coordinates of the upper left hand corner of the image. This tag specifies the coordinates # of the the first voxel transmitted. self.image_pos_pat = list(dicomInfo_series[0x0020,0x0032].value) # Image Orientation (0020,0037): specifies the direction cosines # of the first row and the first column with respect to the patient. # The direction of the axes are defined by the patients orientation # to ensure LPS system ( x-axis increasing to the left hand side of the patient, # y-axis increasing to the posterior side of the patient and z-axis increasing toward # the head of the patient ) self.image_ori_pat = list(dicomInfo_series[0x0020,0x0037].value) for i in range(0,len(phases_series)): abspath_PhaseID = series_path+os.sep+phases_series[i] print abspath_PhaseID # Done reading volume filenames now load them to DICOMimageReader os.chdir(abspath_PhaseID) dicomReader = vtk.vtkDICOMImageReader() dicomReader.SetDirectoryName( abspath_PhaseID ) dicomReader.Update() im = vtk.vtkImageData() im = dicomReader.GetOutput() self.dims = im.GetDimensions() self.spacing = im.GetSpacing() print "VTK Dimensions im.GetDimensions(): %d %d %d" % self.dims print "VTK Spacing im.GetSpacing(): %f %f %f\n" % self.spacing # Append to objects image self.DICOMImages.append( im ) return(series_path, phases_series, lesionID_path)
def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.setWindowTitle(self.tr("Nirfast")) # splitters are used for generating the four views self.VSplitter = QSplitter(Qt.Vertical) self.HSplitterTop = QSplitter(Qt.Horizontal) self.HSplitterBottom = QSplitter(Qt.Horizontal) # one instance of each of the VTK_Widget classes self.vtk_widget_2 = VTK_Widget2(0) self.vtk_widget_3 = VTK_Widget2(1) self.vtk_widget_4 = VTK_Widget2(2) self.vtk_widget_1 = VTK_Widget1( self.vtk_widget_2.cutPlaneSlider, self.vtk_widget_3.cutPlaneSlider, self.vtk_widget_4.cutPlaneSlider ) # the VTK widgets are added to the splitters self.VSplitter.addWidget(self.HSplitterTop) self.VSplitter.addWidget(self.HSplitterBottom) self.HSplitterTop.addWidget(self.vtk_widget_1) self.HSplitterTop.addWidget(self.vtk_widget_2) self.HSplitterBottom.addWidget(self.vtk_widget_3) self.HSplitterBottom.addWidget(self.vtk_widget_4) # the top splitter (vertical) is set as central widget self.setCentralWidget(self.VSplitter) # we embed a reader in the main window, which will fan out the data to all VTK views self.reader = vtk.vtkUnstructuredGridReader() self.reader2 = vtk.vtkDICOMImageReader() self.reader.SetFileName("") self.reader2.SetDirectoryName("") # we declare a file open action self.fileOpenAction = QAction("&Open Solution", self) self.fileOpenAction.setShortcut("Ctrl+O") self.fileOpenAction.setToolTip("Opens a VTK volume file") self.fileOpenAction.setStatusTip("Opens a VTK volume file") self.fileOpenAction2 = QAction("&Open DICOMs", self) self.fileOpenAction2.setShortcut("Ctrl+D") self.fileOpenAction2.setToolTip("Opens a set of DICOMs") self.fileOpenAction2.setStatusTip("Opens a set of DICOMs") self.connect(self.fileOpenAction, SIGNAL("triggered()"), self.fileOpen) self.connect(self.fileOpenAction2, SIGNAL("triggered()"), self.fileOpen2) self.fileMenu = self.menuBar().addMenu("&File") self.fileMenu.addAction(self.fileOpenAction) self.fileMenu.addAction(self.fileOpenAction2) # property label self.label_property = QLabel("Property: ") # property dropdown self.dropdown_property = QComboBox() # spacing label self.label_spacing = QLabel(" ") # clip buttons self.button_clipx = QPushButton("Clip x") self.button_clipy = QPushButton("Clip y") self.button_clipz = QPushButton("Clip z") # toolbar self.viewToolbar = self.addToolBar("View") self.viewToolbar.setObjectName("ViewToolbar") self.viewToolbar.addWidget(self.label_property) self.viewToolbar.addWidget(self.dropdown_property) self.viewToolbar.addWidget(self.label_spacing) self.viewToolbar.addWidget(self.button_clipx) self.viewToolbar.addWidget(self.button_clipy) self.viewToolbar.addWidget(self.button_clipz) self.connect(self.button_clipx, SIGNAL("clicked()"), self.Clipx) self.connect(self.button_clipy, SIGNAL("clicked()"), self.Clipy) self.connect(self.button_clipz, SIGNAL("clicked()"), self.Clipz) self.connect(self.dropdown_property, SIGNAL("currentIndexChanged(int)"), self.SetProperty)
''' import vtk dir1 = '/home/qinshuo/Data/Data1' dir2 = '/home/qinshuo/Data/Data2' reader1 = vtk.vtkDICOMImageReader() reader1.SetDirectoryName(dir1) reader1.Update() img1 = reader1.GetOutput() reader2 = vtk.vtkDICOMImageReader() reader2.SetDirectoryName(dir2) reader2.Update() img2 = reader2.GetOutput() # reslice direction dir_X = [0,0,0] dir_Y = [0,0,0] dir_Z = [0,0,0] # reslice center
def __init__(self, parent = None): self.reader = vtk.vtkDICOMImageReader() self.dataExtent = [] self.dataDimensions = [] self.dataRange = () # initialize GUI QtGui.QWidget.__init__(self, parent) self.ui = Ui_Form() self.ui.setupUi(self) self.ui.WindowCenterSlider.setRange(0, 1000) self.ui.WindowWidthSlider.setRange(0, 1000) # define viewers [self.viewerXY, self.viewerYZ, self.viewerXZ] = [vtk.vtkImageViewer2() for x in range(3)] # attach interactors to viewers self.viewerXY.SetupInteractor(self.ui.XYPlaneWidget) self.viewerYZ.SetupInteractor(self.ui.YZPlaneWidget) self.viewerXZ.SetupInteractor(self.ui.XZPlaneWidget) # set render windows for viewers self.viewerXY.SetRenderWindow(self.ui.XYPlaneWidget.GetRenderWindow()) self.viewerYZ.SetRenderWindow(self.ui.YZPlaneWidget.GetRenderWindow()) self.viewerXZ.SetRenderWindow(self.ui.XZPlaneWidget.GetRenderWindow()) # set slicing orientation for viewers self.viewerXY.SetSliceOrientationToXZ() self.viewerYZ.SetSliceOrientationToYZ() self.viewerXZ.SetSliceOrientationToXY() # rotate image act = self.viewerYZ.GetImageActor() act.SetOrientation(90, 0, 0) # setup volume rendering self.volRender = vtk.vtkRenderer() self.volRenWin = self.ui.VolumeWidget.GetRenderWindow() self.volRenWin.AddRenderer(self.volRender) self.rayCastFunction = vtk.vtkVolumeRayCastCompositeFunction() self.volumeMapper = vtk.vtkVolumeRayCastMapper() self.volumeMapper.SetVolumeRayCastFunction(self.rayCastFunction) volumeColor = vtk.vtkColorTransferFunction() volumeColor.AddRGBPoint(0, 0.0, 0.0, 0.0) volumeColor.AddRGBPoint(500, 1.0, 0.5, 0.3) volumeColor.AddRGBPoint(1000, 1.0, 0.5, 0.3) volumeColor.AddRGBPoint(1150, 1.0, 1.0, 0.9) self.volumeColor = volumeColor volumeScalarOpacity = vtk.vtkPiecewiseFunction() volumeScalarOpacity.AddPoint(0, 0.00) volumeScalarOpacity.AddPoint(50, 0.15) volumeScalarOpacity.AddPoint(100, 0.15) volumeScalarOpacity.AddPoint(115, 0.85) self.volumeScalarOpacity = volumeScalarOpacity volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(0, 0.0) volumeGradientOpacity.AddPoint(100, 0.5) volumeGradientOpacity.AddPoint(500, 1) self.volumeGradientOpacity = volumeGradientOpacity volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(volumeColor) volumeProperty.SetScalarOpacity(volumeScalarOpacity) volumeProperty.SetGradientOpacity(volumeGradientOpacity) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOn() volumeProperty.SetAmbient(0.4) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.2) self.volumeProperty = volumeProperty volume = vtk.vtkVolume() volume.SetMapper(self.volumeMapper) volume.SetProperty(self.volumeProperty) self.volume = volume self.volRender.AddViewProp(volume)
def main(argv): if len(argv) < 2: print "usage: ",argv[0]," <data> [flat]" exit(1) data_fn = argv[1] flat = False if len(argv) > 2: flat = True mapper = vtk.vtkPolyDataMapper() if data_fn.find('.vtk') != -1: reader = vtk.vtkPolyDataReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() trianglize = vtk.vtkDelaunay2D() trianglize.SetInput(data) trianglize.Update() mapper.SetInputConnection(trianglize.GetOutputPort()) elif data_fn.find('.pgm') != -1: reader = vtk.vtkPNMReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() geometry = vtk.vtkImageDataGeometryFilter() geometry.SetInputConnection(reader.GetOutputPort()) geometry.Update() if flat: merge = vtk.vtkMergeFilter() merge.SetGeometry(geometry.GetOutput()) merge.SetScalars(data) mapper.SetInputConnection(merge.GetOutputPort()) else: warp = vtk.vtkWarpScalar() warp.SetInputConnection(geometry.GetOutputPort()) warp.SetScaleFactor(0.3) # looked good warp.Update() merge = vtk.vtkMergeFilter() merge.SetGeometry(warp.GetOutput()) merge.SetScalars(data) mapper.SetInputConnection(merge.GetOutputPort()) elif data_fn.find('.dcm') != -1: reader =vtk.vtkDICOMImageReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() geometry = vtk.vtkImageDataGeometryFilter() geometry.SetInput(data) geometry.Update() if flat: mapper.SetInputConnection(geometry.GetOutputPort()) else: warp = vtk.vtkWarpScalar() warp.SetInputConnection(geometry.GetOutputPort()) warp.Update() mapper.SetInputConnection(warp.GetOutputPort()) else: print "unrecognized data file:",data_fn exit(1) lut = vtk.vtkLookupTable() lut.SetNumberOfColors(10) lut.SetHueRange(0.5,0.3) lut.SetSaturationRange(0.6,0.5) lut.SetValueRange(1.0,0.5) lut.Build() mapper.ImmediateModeRenderingOff() mapper.SetLookupTable(lut) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(700,700) renderWindow.AddRenderer(renderer) renderer.AddActor(actor) renderer.SetBackground(0.4,0.3,0.2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def main(argv): if len(argv) < 2: print "usage: ",argv[0]," <data>" exit(1) data_fn = argv[1] data = None if data_fn.find('.vtk') != -1: reader = vtk.vtkStructuredPointsReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() elif data_fn.find('.dcm') != -1: reader =vtk.vtkDICOMImageReader() reader.SetFileName(data_fn) reader.Update() data = reader.GetOutput() ptdata = data.GetPointData() scalars = ptdata.GetScalars() data_range = scalars.GetValueRange() print "data range:",data_range contourer = vtk.vtkContourFilter() if data_fn.find('body') != -1: contourer.GenerateValues(10,data_range[0],data_range[1]) #contourer.GenerateValues(5,data_range[0],data_range[1]) elif data_fn.find('brain') != -1: contourer.GenerateValues(10,data_range[0],data_range[1]) elif data_fn.find('artichoke') != -1: contourer.GenerateValues(50,data_range[0],data_range[1]) elif data_fn.find('watermelon') != -1: contourer.GenerateValues(20,data_range[0],data_range[1]) #contourer.GenerateValues(5,data_range[0],data_range[1]) else: contourer.GenerateValues(10,data_range[0],data_range[1]) #contourer.SetNumberOfContours(3) #contourer.SetValue(0, 100) #contourer.SetValue(1, 300) #contourer.SetValue(2, 400) contourer.SetInput(data) contourer.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(contourer.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(700,700) renderWindow.AddRenderer(renderer) renderer.AddActor(actor) renderer.SetBackground(0.4,0.3,0.2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
import os import numpy import matplotlib.pyplot as plt #function to convert the vtk image into a numpy array, useful for showing images def vtkImageToNumPy(image, pixelDims): pointData = image.GetPointData() arrayData = pointData.GetArray(0) ArrayDicom = numpy_support.vtk_to_numpy(arrayData) ArrayDicom = ArrayDicom.reshape(pixelDims, order = 'F') #reshape the array into Fourier space return ArrayDicom #---code start--- path = os.getcwd() #define path from current working directory reader = vtk.vtkDICOMImageReader() #load DICOM reader reader.SetDirectoryName(path) reader.Update() #read in DICOM files dims = reader.GetDataExtent() #extract pixel dimensions ConstPixelDims = [dims[1]-dims[0]+1, dims[3]-dims[2]+1, dims[5]-dims[4]+1] #calculate true pixel dimensions ConstPixelSpacing = reader.GetPixelSpacing() #extract pixel spacing information #ArrayDicom = vtkImageToNumPy(reader.GetOutput(), ConstPixelDims) img = reader.GetOutputPort() threshold = vtk.vtkImageThreshold () #load threshold function threshold.SetInputConnection(img) #load image from reader threshold.ThresholdByUpper(400) # set the upper Threshold Value, using Hounsfield Values