Python vtk.vtkImageReslice函数代码示例

    def GetROIImage(self, clipDataOn=0):
        """Return ROI Image port from ROIStencil"""
        component.getUtility(ICurrentImage).Update()
        minV, maxV = component.getUtility(ICurrentImage).GetScalarRange()
        reslice = vtk.vtkImageReslice()
        reslice.SetInputConnection(
            component.getUtility(ICurrentImage).GetOutputPort())
        reslice.SetInterpolationModeToCubic()

        # 2014-12-22 this is important
        self.__stencil_data.Update()

        # VTK-6
        if vtk.vtkVersion().GetVTKMajorVersion() > 5:
            reslice.SetStencilData(self.__stencil_data)
        else:
            reslice.SetStencil(self.__stencil_data)

        reslice.SetOutputExtent(self.__stencil_data.GetWholeExtent())
        reslice.SetOutputOrigin(self._Origin)
        reslice.SetOutputSpacing(self._Spacing)
        reslice.SetBackgroundLevel(minV)
        reslice.Update()

        return reslice

    def __init__(
        self, parent=None, x=0, y=0, width=100, height=27, fontsize=_FS,
            **kw):

        kw["height"] = height
        kw["width"] = width
        kw["x"] = x
        kw["y"] = y
        kw["fontsize"] = fontsize
        kw["font"] = "courier"
        kw["text"] = "0.000"

        Label.__init__(*(self, parent), **kw)

        self._Cursor = None

        self._Transform = None

        self._Shift = 0.0

        self._Scale = 1.0

        self._Input = None

        self._Reslice = vtk.vtkImageReslice()
        self._Reslice.SetOutputExtent(0, 0, 0, 0, 0, 0)
        self._Reslice.SetInterpolationModeToLinear()

def vtkZoomImage(image, zoomInFactor):
    """
	Zoom a volume
	"""
    zoomOutFactor = 1.0 / zoomInFactor
    reslice = vtk.vtkImageReslice()
    reslice.SetInputConnection(image.GetProducerPort())

    spacing = image.GetSpacing()
    extent = image.GetExtent()
    origin = image.GetOrigin()
    extent = (extent[0], extent[1] / zoomOutFactor, extent[2], extent[3] / zoomOutFactor, extent[4], extent[5])

    spacing = (spacing[0] * zoomOutFactor, spacing[1] * zoomOutFactor, spacing[2])
    reslice.SetOutputSpacing(spacing)
    reslice.SetOutputExtent(extent)
    reslice.SetOutputOrigin(origin)

    # These interpolation settings were found to have the
    # best effect:
    # If we zoom out, no interpolation
    if zoomOutFactor > 1:
        reslice.InterpolateOff()
    else:
        # If we zoom in, use cubic interpolation
        reslice.SetInterpolationModeToCubic()
        reslice.InterpolateOn()
    data = optimize.execute_limited(reslice)
    data.Update()
    return data

 def __init__(self):
     self.__vtkimport=vtk.vtkImageImport()
     self.__vtkimport.SetDataScalarTypeToFloat()
     self.__vtkimport.SetNumberOfScalarComponents(1)
     self.__filePattern=self.__defaultFilePattern
     self.__data = None
     self._irs = vtk.vtkImageReslice()

    def __init__(self,data_reader,origin,normal,camera_normal):
        self.axial=self.get_matrix(data_reader,origin,normal,camera_normal)
        # Extract a slice in the desired orientation
        self.reslice = vtk.vtkImageReslice()
        self.reslice.SetInput(data_reader.get_data_set())
        self.reslice.SetOutputDimensionality(2)
        self.reslice.SetResliceAxes(self.axial)
        self.reslice.SetInterpolationModeToLinear()
        
        self.contour=vtk.vtkContourFilter()
        self.contour.SetInputConnection(self.reslice.GetOutputPort())

        self.contour.GenerateValues(25, data_reader.get_scalar_range())
        self.contour.ComputeScalarsOn()
        self.contour.ComputeGradientsOn()      
        self.cutmapper=vtk.vtkPolyDataMapper()
        self.cutmapper.SetInputConnection(self.contour.GetOutputPort())  
        self.actor=vtk.vtkActor()
        self.actor.SetMapper(self.cutmapper)
        self.actor.PokeMatrix(self.axial)
        c="c"
        if origin[0]==c or origin[1]==c or origin[2]==c:
			origin=self.center
        
        origin=(float(origin[0]),float(origin[1]),float(origin[2]))
        self.actor.SetOrigin(origin)		  

 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkImageReslice(), 'Processing.',
         ('vtkImageData', 'vtkImageStencilData'), ('vtkImageData',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)

    def __init__(self, ren):
        self.volume = self.LoadVolume()
        self.ren = ren

        # next initialize the pipeline
        self.slicer = vtk.vtkImageReslice()
        self.slicer.SetInput( self.volume )
        self.slicer.SetOutputDimensionality(2)

        # the next filter provides a mechanism for slice selection
        self.selector = SliceSelector(self.volume)
        self.slicer.SetResliceAxes( self.selector.GetDirectionCosines() )
        self.slicer.SetResliceAxesOrigin( self.selector.GetAxesOrigin() )

        # setup link for adjusting the contrast of the image
        r = self.volume.GetScalarRange()
        self.lutBuilder = LUTBuilder(r[0],r[1],1)
        lut = self.lutBuilder.Build()

        self.colors = vtk.vtkImageMapToColors()
        self.colors.SetInputConnection( self.slicer.GetOutputPort() )
        self.colors.SetLookupTable( lut )

        self.actor = vtk.vtkImageActor()
        self.actor.SetInput( self.colors.GetOutput() )

    def __init__(self, module_manager):
        # initialise our base class
        ModuleBase.__init__(self, module_manager)
        # initialise any mixins we might have
        NoConfigModuleMixin.__init__(self)


        self._imageReslice = vtk.vtkImageReslice()
        self._imageReslice.SetInterpolationModeToCubic()

        self._matrixToHT = vtk.vtkMatrixToHomogeneousTransform()
        self._matrixToHT.Inverse()


        module_utils.setup_vtk_object_progress(self, self._imageReslice,
                                           'Resampling volume')

        self._viewFrame = self._createViewFrame(
            {'Module (self)' : self,
             'vtkImageReslice' : self._imageReslice})

        # pass the data down to the underlying logic
        self.config_to_logic()
        # and all the way up from logic -> config -> view to make sure
        self.syncViewWithLogic()     

    def __init__(self, module_manager):
        # initialise our base class
        ModuleBase.__init__(self, module_manager)

        self._reslicer = vtk.vtkImageReslice()
        self._probefilter = vtk.vtkProbeFilter()

        self._config.paddingValue = 0.0
        
        #This is retarded - we (sometimes, see below) need the padder 
        #to get the image extent big enough to satisfy the probe filter. 
        #No apparent logical reason, but it throws an exception if we don't.
        self._padder = vtk.vtkImageConstantPad()

        configList = [
            ('Padding value:', 'paddingValue', 'base:float', 'text',
             'The value used to pad regions that are outside the supplied volume.')]        
        
        # initialise any mixins we might have
        ScriptedConfigModuleMixin.__init__(
            self, configList,
            {'Module (self)': self,
             'vtkImageReslice': self._reslicer,
             'vtkProbeFilter': self._probefilter,
             'vtkImageConstantPad': self._padder})

        module_utils.setup_vtk_object_progress(self, self._reslicer,
                                               'Transforming image (Image Reslice)')
        module_utils.setup_vtk_object_progress(self, self._probefilter,
                                               'Performing remapping (Probe Filter)')

        self.sync_module_logic_with_config()

def dicom_to_vti(imagedata, filename):
    logging.debug("In data.dicom_to_vti()")
    extent = imagedata.GetWholeExtent()
    spacing = imagedata.GetSpacing()
    origin = imagedata.GetOrigin()

    center = (
        origin[0] + spacing[0] * 0.5 * (extent[0] + extent[1]),
        origin[1] + spacing[1] * 0.5 * (extent[2] + extent[3]),
        origin[2] + spacing[2] * 0.5 * (extent[4] + extent[5]),
    )

    resliceAxes = vtk.vtkMatrix4x4()
    vtkMatrix = (1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
    resliceAxes.DeepCopy(vtkMatrix)
    resliceAxes.SetElement(0, 3, center[0])
    resliceAxes.SetElement(1, 3, center[1])
    resliceAxes.SetElement(2, 3, center[2])

    reslice = vtk.vtkImageReslice()
    reslice.SetInput(imagedata)
    reslice.SetInformationInput(imagedata)
    reslice.SetResliceAxes(resliceAxes)
    reslice.SetOutputDimensionality(3)
    reslice.Update()

    imagedata = reslice.GetOutput()
    writer = vtk.vtkXMLImageDataWriter()
    writer.SetInput(imagedata)
    writer.SetFileName(filename)
    writer.Write()

def transform_all_images(register, image_datas, defining_image):
    image_list = list()
    idx = 0
    transform_list = register.convert_transforms_to_vtk()
    image_datas = [image_datas[0]]
    info = vtk.vtkImageChangeInformation()
    info.SetInput(defining_image)
    info.CenterImageOn()
        
    for image in image_datas:
        change = vtk.vtkImageChangeInformation()
        change.SetInput(image)
        change.CenterImageOn()
        #change.SetOutputSpacing(1,1,1)
        #spacing = image.GetSpacing()
        
        if 1:
            trans = vtk.vtkTransform()
            # this is right except scaling is 1/correct
            tx = transform_list[idx]
            trans.Concatenate(tx)
            #trans = tx
            #trans.Scale(-1,-1,-1)
            trans.Inverse()
            #trans.Scale(-1,-1,-1)
        if 0:
            transform = numpy.zeros(15)
            transform2 = numpy.zeros(15)
            tform = register._subjects[idx].transform
            # rotation and translation are "already inverted"
            # from images being in LPS
            transform[0:6] = tform[0:6]
            # invert scaling
            transform[6:9] = numpy.divide(1.0, tform[6:9])
            # invert shear
            transform2[6:9] = 1.0
            transform2[9:15] = tform[9:15]             
            reg_ops = wma.register.RegistrationInformation()
            trans = reg_ops.convert_transform_to_vtk(transform)
            trans2 = reg_ops.convert_transform_to_vtk(transform2)
            trans2.Scale(-1,-1,-1)
            trans2.Inverse()
            trans.Concatenate(trans2)
            
        resample = vtk.vtkImageReslice()
        #resample.SetResliceAxesDirectionCosines(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
        #resample.SetResliceAxesDirectionCosines(-1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, -1.0)
        #resample.SetInput(image)
        resample.SetInput(change.GetOutput())
        resample.SetResliceTransform(trans)
        print trans
        #resample.SetInformationInput(info.GetOutput())
        #resample.SetOutputSpacing(spacing)
        resample.Update()
        #resample.SetOutputOrigin(origin)
        image_list.append(resample.GetOutput())
        idx += 1
    del resample
    return image_list

    def __init__(self, module_manager):
        # initialise our base class
        ModuleBase.__init__(self, module_manager)

        NoConfigModuleMixin.__init__(
            self, {'Module (self)' : self})

        self.sync_module_logic_with_config()    
        self._ir = vtk.vtkImageReslice()
        self._ici = vtk.vtkImageChangeInformation()

 def __init__(self):
     # index
     self.ori_index = [0,0,0]
     self.ori_direction = [1,1,1] #cosine
     self.cur_index = [0,0,0]
     self.cur_direction = [1,1,1] #cosine
     #define reslice fileter
     self.reslicer = vtk.vtkImageReslice()
     self.reslicer.SetOutputDimensionality(2) #output 2D resliced image
     self.reslicer.SetResliceAxesDirectionCosines([0,0,0,0,0,0,0,0,0])#(self.cur_direction[1],self.cur_direction[1],self.cur_direction[1])
     self.reslicer.SetResliceAxesOrigin(0,0,0)#(self.cur_index)
     self.reslicer.SetInterpolationModeToLinear()

def reslice(img, transform, data):
    reslicer=vtk.vtkImageReslice()

    reslicer.SetInputData(img)

    transform = numpy2vtkMatrix(transform)
    vtkTrans = vtk.vtkMatrixToHomogeneousTransform()
    vtkTrans.SetInput(transform)

    reslicer.SetResliceTransform(vtkTrans)
    reslicer.SetOutputOrigin(data.GetOrigin())
    reslicer.SetOutputSpacing(data.GetSpacing())
    reslicer.SetOutputExtent(data.GetExtent())

    def SetImageTransform(self, transform):
        """Set optionally the transform to the image data."""

        # TODO: this code is broken...

        self._imageTransform = transform
        reslice = vtk.vtkImageReslice()
        reslice.SetInterpolationModeToCubic()
        image = component.getUtility(ICurrentImage)
        reslice.SetInputConnection(image.GetOutputPort())
        reslice.SetResliceTransform(self._imageTransform.GetInverse())
        self._imageStats.SetInputConnection(reslice.GetOutputPort())
        self._imageStats.SetProgressText("Calculating image stats...")