def keypressCallback(obj, ev):
    key = obj.GetKeySym()
    if key == "s":
        filter.Modified()
        filter.SetInputBufferTypeToZBuffer()
        filter.Update()

        scale = vtk.vtkImageShiftScale()
        scale.SetOutputScalarTypeToUnsignedChar()
        scale.SetInputConnection(filter.GetOutputPort())
        scale.SetShift(0)
        scale.SetScale(-300)

        scale2 = vtk.vtkImageShiftScale()
        scale2.SetOutputScalarTypeToUnsignedChar()
        scale2.SetInputConnection(scale.GetOutputPort())
        scale2.SetShift(255)

        global iteration
        iteration = iteration + 1

        file_name = "/home/vishnusanjay/cmpt764/Final project/last_examples/depthimages_1/chair_" + \
                    str(iteration) + ".bmp"
        imageWriter = vtk.vtkBMPWriter()
        imageWriter.SetFileName(file_name)
        imageWriter.SetInputConnection(scale2.GetOutputPort())
        imageWriter.Write()
Пример #2
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No input image.')

        if self.MapRanges:
            if self.InputRange == [0.0, 0.0]:
                self.InputRange = self.Image.GetScalarRange()
            if self.InputRange[1] == self.InputRange[0]:
                self.PrintError(
                    'Error: Input range has zero width. Cannot map values')
            self.Shift = -self.InputRange[0]
            self.Scale = (self.OutputRange[1] - self.OutputRange[0]) / (
                self.InputRange[1] - self.InputRange[0])

        shiftScale = vtk.vtkImageShiftScale()
        shiftScale.SetInputData(self.Image)
        shiftScale.SetShift(self.Shift)
        shiftScale.SetScale(self.Scale)

        if self.OutputType == 'double':
            shiftScale.SetOutputScalarTypeToDouble()
        elif self.OutputType == 'uchar':
            shiftScale.SetOutputScalarTypeToUnsignedChar()
        elif self.OutputType == 'char':
            shiftScale.SetOutputScalarTypeToChar()
        elif self.OutputType == 'ushort':
            shiftScale.SetOutputScalarTypeToUnsignedShort()
        elif self.OutputType == 'short':
            shiftScale.SetOutputScalarTypeToShort()
        elif self.OutputType == 'ulong':
            shiftScale.SetOutputScalarTypeToUnsignedLong()
        elif self.OutputType == 'long':
            shiftScale.SetOutputScalarTypeToLong()
        elif self.OutputType == 'uint':
            shiftScale.SetOutputScalarTypeToUnsignedInt()
        elif self.OutputType == 'int':
            shiftScale.SetOutputScalarTypeToInt()
        elif self.OutputType == 'float':
            shiftScale.SetOutputScalarTypeToFloat()

        if self.OutputType != 'unchanged':
            if self.ClampOverflowOn:
                shiftScale.ClampOverflowOn()

        shiftScale.ClampOverflowOff()
        shiftScale.Update()

        self.Image = shiftScale.GetOutput()

        if self.MapRanges and self.OutputRange[0] != 0.0:
            shiftScale2 = vtk.vtkImageShiftScale()
            shiftScale2.SetInputData(self.Image)
            shiftScale2.SetShift(self.OutputRange[0])
            shiftScale2.SetScale(1.0)
            shiftScale2.Update()
            self.Image = shiftScale2.GetOutput()
Пример #3
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No input image.')

        if self.MapRanges:
            if self.InputRange == [0.0,0.0]:
                self.InputRange = self.Image.GetScalarRange()
            if self.InputRange[1] == self.InputRange[0]:
                self.PrintError('Error: Input range has zero width. Cannot map values')
            self.Shift = -self.InputRange[0]
            self.Scale = (self.OutputRange[1] - self.OutputRange[0]) / (self.InputRange[1] - self.InputRange[0])

        shiftScale = vtk.vtkImageShiftScale()
        shiftScale.SetInput(self.Image)
        shiftScale.SetShift(self.Shift)
        shiftScale.SetScale(self.Scale)

        if self.OutputType == 'double':
            shiftScale.SetOutputScalarTypeToDouble()
        elif self.OutputType == 'uchar':
            shiftScale.SetOutputScalarTypeToUnsignedChar()
        elif self.OutputType == 'char':
            shiftScale.SetOutputScalarTypeToChar()
        elif self.OutputType == 'ushort':
            shiftScale.SetOutputScalarTypeToUnsignedShort()
        elif self.OutputType == 'short':
            shiftScale.SetOutputScalarTypeToShort()
        elif self.OutputType == 'ulong':
            shiftScale.SetOutputScalarTypeToUnsignedLong()
        elif self.OutputType == 'long':
            shiftScale.SetOutputScalarTypeToLong()
        elif self.OutputType == 'uint':
            shiftScale.SetOutputScalarTypeToUnsignedInt()
        elif self.OutputType == 'int':
            shiftScale.SetOutputScalarTypeToInt()
        elif self.OutputType == 'float':
            shiftScale.SetOutputScalarTypeToFloat()

        if self.OutputType != 'unchanged':
            if self.ClampOverflowOn:
                shiftScale.ClampOverflowOn()

        shiftScale.ClampOverflowOff()
        shiftScale.Update()

        self.Image = shiftScale.GetOutput()

        if self.MapRanges and self.OutputRange[0] != 0.0:
            shiftScale2 = vtk.vtkImageShiftScale()
            shiftScale2.SetInput(self.Image)
            shiftScale2.SetShift(self.OutputRange[0])
            shiftScale2.SetScale(1.0)
            shiftScale2.Update()
            self.Image = shiftScale2.GetOutput()
Пример #4
0
    def __init__(self, comedi, cfg_dict):
        self._comedi = comedi
        self._cfg = cfg_dict

        # we'll store our local bindings here
        self._d1 = None
        self._d2m = None
        self._conf = None
        self._cmap_range = [-1024, 3072]
        self._cmap_type = CMAP_BLUE_TO_YELLOW_PL

        # color scales thingy
        self._color_scales = vtk_kit.color_scales.ColorScales()

        # instantiate us a slice viewer
        rwi,ren = comedi.get_compvis_vtk()
        self._sv = comedi_utils.CMSliceViewer(rwi, ren)
        # now make our own MapToColors
        ct = 32
        lut = self._sv.ipws[0].GetLookupTable()
        self._cmaps = [vtktudoss.vtkCVImageMapToColors() for _ in range(3)]
        for i,cmap in enumerate(self._cmaps):
            cmap.SetLookupTable(lut)
            cmap.SetConfidenceThreshold(ct)
            self._sv.ipws[i].SetColorMap(cmap)

        self._set_confidence_threshold_ui(ct)


        comedi.sync_slice_viewers.add_slice_viewer(self._sv)

        # now build up the VTK pipeline #############################
        # we'll use these to scale data between 0 and max.
        self._ss1 = vtk.vtkImageShiftScale()
        self._ss1.SetOutputScalarTypeToShort()
        self._ss2 = vtk.vtkImageShiftScale()
        self._ss2.SetOutputScalarTypeToShort()

        # we have to cast the confidence to shorts as well
        self._ssc = vtk.vtkImageShiftScale()
        self._ssc.SetOutputScalarTypeToShort()

        self._iac = vtk.vtkImageAppendComponents()
        # data1 will form the context
        self._iac.SetInput(0, self._ss1.GetOutput())
        # subtraction will form the focus
        self._iac.SetInput(1, self._ss2.GetOutput())
        # third input will be the confidence
        self._iac.SetInput(2, self._ssc.GetOutput())

        # event bindings ############################################
        self._bind_events()
Пример #5
0
    def Get_filter(self):

        x1 = float(self.gui.m_textCtrlOldValue1.GetValue())
        y1 = float(self.gui.m_textCtrlOldValue2.GetValue())
        x2 = float(self.gui.m_textCtrlNewValue1.GetValue())
        y2 = float(self.gui.m_textCtrlNewValue2.GetValue())

        if x1 == x2 and y1 == y2:
            logging.info("Current values will have no effect.")
            return None

        if x1 == y1 or x2 == y2:
            logging.info("Cannot satisfy these shift/scale")
            return None

        shift = x2 - x1
        scale = (y2 - x2) / (y1 - x1)

        _type = [
            vtk.VTK_CHAR, vtk.VTK_UNSIGNED_CHAR, vtk.VTK_SHORT,
            vtk.VTK_UNSIGNED_SHORT, vtk.VTK_INT, vtk.VTK_FLOAT, vtk.VTK_DOUBLE
        ][self.gui.m_choiceScalarType.GetSelection()]

        _filter = vtk.vtkImageShiftScale()
        _filter.SetInput(component.getUtility(ICurrentImage).GetRealImage())
        _filter.SetOutputScalarType(_type)
        _filter.SetScale(scale)
        _filter.SetShift(shift)
        _filter.SetClampOverflow(
            int(self.gui.m_checkBoxClampOverflow.GetValue()))

        return _filter
    def DownsampleImage(self, image, nbits=8):
        """Downsamples an image"""

        image.SetReleaseDataFlag(1)

        # get the min and max values from the image
        (minval, maxval) = image.GetScalarRange()

        # create an 8-bit version of this image
        _filter = vtk.vtkImageShiftScale()
        _filter.SetInput(image.GetRealImage())
        _filter.SetShift(-minval)
        try:
            if nbits == 8:
                _filter.SetScale(255.0 / (maxval - minval))
            elif nbits == 16:
                _filter.SetScale(65535.0 / (maxval - minval))
        except ZeroDivisionError:
            logging.exception("DownsampleImage")
            _filter.SetScale(1.0)
        if nbits == 8:
            _filter.SetOutputScalarTypeToUnsignedChar()
        elif nbits == 16:
            _filter.SetOutputScalarTypeToShort()
        elif nbits == 32:
            _filter.SetOutputScalarTypeToFloat()
        elif nbits == 64:
            _filter.SetOutputScalarTypeToDouble()

        _filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
        _filter.SetProgressText("Downsampling to %d-bit..." % nbits)
        logging.info("Image downsampled to {0}-bit".format(nbits))
        _filter.Update()

        return MVImage.MVImage(_filter.GetOutputPort(), input=image)
Пример #7
0
 def WritePNGImageFile(self):
     if self.OutputFileName == "":
         self.PrintError("Error: no OutputFileName.")
     self.PrintLog("Writing PNG image file.")
     outputImage = self.Image
     if self.Image.GetScalarTypeAsString() != "unsigned char":
         shiftScale = vtk.vtkImageShiftScale()
         shiftScale.SetInput(self.Image)
         if self.WindowLevel[0] == 0.0:
             scalarRange = self.Image.GetScalarRange()
             shiftScale.SetShift(-scalarRange[0])
             shiftScale.SetScale(255.0 / (scalarRange[1] - scalarRange[0]))
         else:
             shiftScale.SetShift(-(self.WindowLevel[1] - self.WindowLevel[0] / 2.0))
             shiftScale.SetScale(255.0 / self.WindowLevel[0])
         shiftScale.SetOutputScalarTypeToUnsignedChar()
         shiftScale.ClampOverflowOn()
         shiftScale.Update()
         outputImage = shiftScale.GetOutput()
     writer = vtk.vtkPNGWriter()
     writer.SetInput(outputImage)
     if self.Image.GetDimensions()[2] == 1:
         writer.SetFileName(self.OutputFileName)
     else:
         writer.SetFilePrefix(self.OutputFileName)
         writer.SetFilePattern("%s%04d.png")
     writer.Write()
Пример #8
0
def ipl_maskaimpeel(image_in1, image_in2, peel_iter):
    ipl_maskaimpeel_settings(peel_iter)

    extent = image_in1.GetExtent()

    voi = vtk.vtkExtractVOI()
    voi.SetInput(image_in1)
    voi.SetVOI(extent[0], extent[1], extent[2], extent[3], extent[4],
               extent[5])
    voi.Update()

    shift = vtk.vtkImageShiftScale()
    shift.SetInputConnection(voi.GetOutputPort())
    shift.SetOutputScalarTypeToUnsignedChar()
    shift.Update()

    mask = vtk.vtkImageMask()
    mask.SetImageInput(image_in2)
    mask.SetMaskInput(shift.GetOutput())
    mask.SetMaskedOutputValue(0)
    mask.Update()

    if peel_iter != 0:
        erode = vtk.vtkImageContinuousErode3D()
        erode.SetInputConnection(mask.GetOutputPort())
        erode.SetKernelSize(peel_iter + 1, peel_iter + 1, peel_iter + 1)
        erode.Update()

        mask = erode

    image_out = mask.GetOutput()
    return image_out
Пример #9
0
    def getIntensityScaledData(self, data):
        """
		Return the data shifted and scaled to appropriate intensity range
		"""
        if not self.explicitScale:
            return data

        if self.intensityScale == -1:
            return data

        if not self.shift:
            self.shift = vtk.vtkImageShiftScale()
            self.shift.SetOutputScalarTypeToUnsignedChar()
            self.shift.SetClampOverflow(1)

        self.shift.SetInputConnection(data.GetProducerPort())
        # Need to call this or it will remember the whole extent it got from resampling
        self.shift.UpdateWholeExtent()

        if self.intensityScale:
            self.shift.SetScale(self.intensityScale)
            currScale = self.intensityScale
        else:
            minval, maxval = self.originalScalarRange
            scale = 255.0 / maxval
            self.shift.SetScale(scale)
            currScale = scale

        self.shift.SetShift(self.intensityShift)

        Logging.info("Intensity shift = %d, scale = %f" %
                     (self.intensityShift, currScale),
                     kw="datasource")

        return self.shift.GetOutput()
Пример #10
0
def _handleFailedImage(idiff, pngr, img_fname):
    """Writes all the necessary images when an image comparison
    failed."""
    f_base, f_ext = os.path.splitext(img_fname)

    # write the difference image gamma adjusted for the dashboard.
    gamma = vtk.vtkImageShiftScale()
    gamma.SetInputConnection(idiff.GetOutputPort())
    gamma.SetShift(0)
    gamma.SetScale(10)

    pngw = vtk.vtkPNGWriter()
    pngw.SetFileName(_getTempImagePath(f_base + ".diff.png"))
    pngw.SetInputConnection(gamma.GetOutputPort())
    pngw.Write()

    # Write out the image that was generated.  Write it out as full so that
    # it may be used as a baseline image if the tester deems it valid.
    pngw.SetInputConnection(idiff.GetInputConnection(0,0))
    pngw.SetFileName(_getTempImagePath(f_base + ".png"))
    pngw.Write()

    # write out the valid image that matched.
    pngw.SetInputConnection(idiff.GetInputConnection(1,0))
    pngw.SetFileName(_getTempImagePath(f_base + ".valid.png"))
    pngw.Write()
def getMIP(imageData, color):
    """
	A function that will take a volume and do a simple
				 maximum intensity projection that will be converted to a
				 wxBitmap
	"""
    maxval = imageData.GetScalarRange()[1]
    imageData.SetUpdateExtent(imageData.GetWholeExtent())

    if maxval > 255:
        shiftscale = vtk.vtkImageShiftScale()
        shiftscale.SetInputConnection(imageData.GetProducerPort())
        shiftscale.SetScale(255.0 / maxval)
        shiftscale.SetOutputScalarTypeToUnsignedChar()
        imageData = shiftscale.GetOutput()

    mip = vtkbxd.vtkImageSimpleMIP()
    mip.SetInputConnection(imageData.GetProducerPort())

    if color == None:
        output = optimize.execute_limited(mip)
        return output

    if mip.GetOutput().GetNumberOfScalarComponents() == 1:
        ctf = getColorTransferFunction(color)

        maptocolor = vtk.vtkImageMapToColors()
        maptocolor.SetInputConnection(mip.GetOutputPort())
        maptocolor.SetLookupTable(ctf)
        maptocolor.SetOutputFormatToRGB()
        imagedata = optimize.execute_limited(maptocolor)

    else:
        imagedata = output = optimize.execute_limited(mip)
    return imagedata
Пример #12
0
    def convert_scene_to_numpy_array(self):
        """
        Convert the current window view to a numpy array.

        :return output: Scene as numpy array
        """
        vtk_win_to_img_filter = vtk.vtkWindowToImageFilter()
        vtk_win_to_img_filter.SetInput(self.GetRenderWindow())

        if not self.zbuffer:
            vtk_win_to_img_filter.SetInputBufferTypeToRGB()
            vtk_win_to_img_filter.Update()
            self.vtk_image = vtk_win_to_img_filter.GetOutput()
        else:
            vtk_win_to_img_filter.SetInputBufferTypeToZBuffer()
            vtk_scale = vtk.vtkImageShiftScale()
            vtk_scale.SetInputConnection(vtk_win_to_img_filter.GetOutputPort())
            vtk_scale.SetOutputScalarTypeToUnsignedChar()
            vtk_scale.SetShift(0)
            vtk_scale.SetScale(-255)
            vtk_scale.Update()
            self.vtk_image = vtk_scale.GetOutput()

        width, height, _ = self.vtk_image.GetDimensions()
        self.vtk_array = self.vtk_image.GetPointData().GetScalars()
        number_of_components = self.vtk_array.GetNumberOfComponents()

        np_array = vtk_to_numpy(self.vtk_array).reshape(
            height, width, number_of_components)
        self.output = cv2.flip(np_array, flipCode=0)
        return self.output
Пример #13
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No input image.')

        if self.OutputType == 'uchar' and self.ShiftScale:
            shiftScale = vtk.vtkImageShiftScale()
            shiftScale.SetInputData(self.Image)
            if self.WindowLevel[0] == 0.0:
                scalarRange = self.Image.GetScalarRange()
                scale = 255.0
                if (scalarRange[1]-scalarRange[0]) > 0.0:
                    scale = 255.0/(scalarRange[1]-scalarRange[0])
                shiftScale.SetShift(-scalarRange[0])
                shiftScale.SetScale(scale)
            else:
                shiftScale.SetShift(-(self.WindowLevel[1]-self.WindowLevel[0]/2.0))
                shiftScale.SetScale(255.0/self.WindowLevel[0])
            shiftScale.SetOutputScalarTypeToUnsignedChar()
            shiftScale.ClampOverflowOn()
            shiftScale.Update()
            self.Image = shiftScale.GetOutput()
        else:
            cast = vtk.vtkImageCast()
            cast.SetInputData(self.Image)
            if self.OutputType == 'float':
                cast.SetOutputScalarTypeToFloat()
            elif self.OutputType == 'double':
                cast.SetOutputScalarTypeToDouble()
            elif self.OutputType == 'uchar':
                cast.SetOutputScalarTypeToUnsignedChar()
            elif self.OutputType == 'short':
                cast.SetOutputScalarTypeToShort()
            cast.Update()
            self.Image = cast.GetOutput()
Пример #14
0
 def WriteTIFFImageFile(self):
     if (self.OutputFileName == ''):
         self.PrintError('Error: no OutputFileName.')
     self.PrintLog('Writing TIFF image file.')
     outputImage = self.Image
     if self.Image.GetScalarTypeAsString() != 'unsigned char':
         shiftScale = vtk.vtkImageShiftScale()
         shiftScale.SetInputData(self.Image)
         if self.WindowLevel[0] == 0.0:
             scalarRange = self.Image.GetScalarRange()
             shiftScale.SetShift(-scalarRange[0])
             shiftScale.SetScale(255.0 / (scalarRange[1] - scalarRange[0]))
         else:
             shiftScale.SetShift(-(self.WindowLevel[1] -
                                   self.WindowLevel[0] / 2.0))
             shiftScale.SetScale(255.0 / self.WindowLevel[0])
         shiftScale.SetOutputScalarTypeToUnsignedChar()
         shiftScale.ClampOverflowOn()
         shiftScale.Update()
         outputImage = shiftScale.GetOutput()
     writer = vtk.vtkTIFFWriter()
     writer.SetInputData(outputImage)
     if self.Image.GetDimensions()[2] == 1:
         writer.SetFileName(self.OutputFileName)
     else:
         writer.SetFilePrefix(self.OutputFileName)
         writer.SetFilePattern("%s%04d.tif")
     writer.Write()
	def getIntensityScaledData(self, data):
		"""
		Return the data shifted and scaled to appropriate intensity range
		"""
		if not self.explicitScale:
			return data
		
		if self.intensityScale == -1:
			return data
		
		if not self.shift:
			self.shift = vtk.vtkImageShiftScale()
			self.shift.SetOutputScalarTypeToUnsignedChar()
			self.shift.SetClampOverflow(1)
		
		self.shift.SetInputConnection(data.GetProducerPort())
		# Need to call this or it will remember the whole extent it got from resampling
		self.shift.UpdateWholeExtent()

		if self.intensityScale:
			self.shift.SetScale(self.intensityScale)
			currScale = self.intensityScale
		else:
			minval, maxval = self.originalScalarRange
			scale = 255.0 / maxval
			self.shift.SetScale(scale)
			currScale = scale
		
		self.shift.SetShift(self.intensityShift)
		
		Logging.info("Intensity shift = %d, scale = %f"%(self.intensityShift, currScale), kw="datasource")
		
		return self.shift.GetOutput()
Пример #16
0
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 avgProjectionsVtk(self, filenames , extent):
     '''Returns the average of the input images
     
     Input is passed as filenames pointing to 2D TIFF
     Output is a vtkImageData
     gives the same result as avgProjections within machine precision.
     '''
     num = len(filenames)
     readers = [vtk.vtkTIFFReader() for i in range(num)]
     scalers = [vtk.vtkImageShiftScale() for i in range(num)]
     vois = [vtk.vtkExtractVOI() for i in range(num)]
     avger = vtk.vtkImageWeightedSum()
     counter = 0
     for reader, voi, scaler, filename in zip(readers, vois , scalers ,filenames):
         reader.SetFileName(filename)
         reader.Update()
         print ("reading {0}".format(filename))
         voi.SetInputData(reader.GetOutput())
         voi.SetVOI(extent)
         voi.Update()
         print ("extracting VOI")
         scaler.SetInputData(voi.GetOutput())
         scaler.SetOutputScalarTypeToDouble()
         scaler.SetScale(1)
         scaler.SetShift(0)
         scaler.Update()
         avger.AddInputData(scaler.GetOutput())
         avger.SetWeight(counter , 1/float(num))
         counter = counter + 1
         print ("adding input connection {0}".format(counter))
         
     
     avger.Update()
     return avger.GetOutput()
	def execute(self, inputs, update = 0, last = 0):
		"""
		Execute the filter with given inputs and return the output
		"""			   
		if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
			return None
		
		image = self.getInput(1)
		self.vtkfilter.SetInput(image)
		
		self.vtkfilter.SetConsiderAnisotropy(self.parameters["ConsiderAnisotropy"])
		self.vtkfilter.SetAlgorithm(self.parameters["Algorithm"])
		data = self.vtkfilter.GetOutput()
		if self.parameters["CastToUnsignedChar"]:
			self.vtkfilter.Update()
			cast = vtk.vtkImageShiftScale()
			x0, x1 = data.GetScalarRange()
			print data
			print "Scalar range=",x0,x1
			cast.SetInput(self.vtkfilter.GetOutput())
			cast.SetOutputScalarTypeToUnsignedChar()
			#cast.SetClampOverflow(1)
			cast.SetScale(255.0/x1)
			print "Setting scale to ", 255.0/x1
			data = cast.GetOutput()
		if update:
			self.vtkfilter.Update()
		return data  
Пример #19
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkImageShiftScale(), 'Processing.',
         ('vtkImageData',), ('vtkImageData',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
Пример #20
0
def getMIP(imageData, color):
    """
	A function that will take a volume and do a simple
				 maximum intensity projection that will be converted to a
				 wxBitmap
	"""
    maxval = imageData.GetScalarRange()[1]
    imageData.SetUpdateExtent(imageData.GetWholeExtent())

    if maxval > 255:
        shiftscale = vtk.vtkImageShiftScale()
        shiftscale.SetInputConnection(imageData.GetProducerPort())
        shiftscale.SetScale(255.0 / maxval)
        shiftscale.SetOutputScalarTypeToUnsignedChar()
        imageData = shiftscale.GetOutput()

    mip = vtkbxd.vtkImageSimpleMIP()
    mip.SetInputConnection(imageData.GetProducerPort())

    if color == None:
        output = optimize.execute_limited(mip)
        return output

    if mip.GetOutput().GetNumberOfScalarComponents() == 1:
        ctf = getColorTransferFunction(color)

        maptocolor = vtk.vtkImageMapToColors()
        maptocolor.SetInputConnection(mip.GetOutputPort())
        maptocolor.SetLookupTable(ctf)
        maptocolor.SetOutputFormatToRGB()
        imagedata = optimize.execute_limited(maptocolor)

    else:
        imagedata = output = optimize.execute_limited(mip)
    return imagedata
        def CreateVolumeSource(self):
            imageReader = vtk.vtkMetaImageReader()
            imageReader.SetFileName(self.ImageFileName)

            compSrc = vtk.vtkImageExtractComponents()
            compSrc.SetInputConnection(imageReader.GetOutputPort())
            compSrc.SetComponents(self.ComponentIndex)
            compSrc.Update()

            valueMin, valueMax = compSrc.GetOutput().GetPointData().GetArray(
                'MetaImage').GetValueRange()
            valueMin = 0.0

            toUnsignedShort = vtk.vtkImageShiftScale()
            toUnsignedShort.ClampOverflowOn()
            toUnsignedShort.SetShift(-valueMin)
            if valueMax - valueMin != 0:
                toUnsignedShort.SetScale(
                    512.0 /
                    (valueMax -
                     valueMin))  #randomly cause error that "zerodivision"
            toUnsignedShort.SetInputConnection(compSrc.GetOutputPort())
            toUnsignedShort.SetOutputScalarTypeToUnsignedShort()

            return toUnsignedShort
Пример #22
0
def _handleFailedImage(idiff, pngr, img_fname):
    """Writes all the necessary images when an image comparison
    failed."""
    f_base, f_ext = os.path.splitext(img_fname)

    # write the difference image gamma adjusted for the dashboard.
    gamma = vtk.vtkImageShiftScale()
    gamma.SetInputConnection(idiff.GetOutputPort())
    gamma.SetShift(0)
    gamma.SetScale(10)

    pngw = vtk.vtkPNGWriter()
    pngw.SetFileName(_getTempImagePath(f_base + ".diff.png"))
    pngw.SetInputConnection(gamma.GetOutputPort())
    pngw.Write()

    # Write out the image that was generated.  Write it out as full so that
    # it may be used as a baseline image if the tester deems it valid.
    pngw.SetInputConnection(idiff.GetInputConnection(0,0))
    pngw.SetFileName(_getTempImagePath(f_base + ".png"))
    pngw.Write()

    # write out the valid image that matched.
    pngw.SetInputConnection(idiff.GetInputConnection(1,0))
    pngw.SetFileName(_getTempImagePath(f_base + ".valid.png"))
    pngw.Write()
Пример #23
0
    def setInputAsNumpy(self, numpyarray):
        if (len(numpy.shape(numpyarray)) == 3):
            doubleImg = vtk.vtkImageData()
            shape = numpy.shape(numpyarray)
            doubleImg.SetDimensions(shape[0], shape[1], shape[2])
            doubleImg.SetOrigin(0, 0, 0)
            doubleImg.SetSpacing(1, 1, 1)
            doubleImg.SetExtent(0, shape[0] - 1, 0, shape[1] - 1, 0,
                                shape[2] - 1)
            doubleImg.AllocateScalars(vtk.VTK_DOUBLE, 1)

            for i in range(shape[0]):
                for j in range(shape[1]):
                    for k in range(shape[2]):
                        doubleImg.SetScalarComponentFromDouble(
                            i, j, k, 0, numpyarray[i][j][k])

            # rescale to appropriate VTK_UNSIGNED_SHORT
            stats = vtk.vtkImageAccumulate()
            stats.SetInputData(doubleImg)
            stats.Update()
            iMin = stats.GetMin()[0]
            iMax = stats.GetMax()[0]
            scale = vtk.VTK_UNSIGNED_SHORT_MAX / (iMax - iMin)

            shiftScaler = vtk.vtkImageShiftScale()
            shiftScaler.SetInputData(doubleImg)
            shiftScaler.SetScale(scale)
            shiftScaler.SetShift(iMin)
            shiftScaler.SetOutputScalarType(vtk.VTK_UNSIGNED_SHORT)
            shiftScaler.Update()
            self.img3D = shiftScaler.GetOutput()
Пример #24
0
Файл: io.py Проект: piro0321/AI
def shiftscale_uchar(image, ww=300.0, wc=40.0):
    """
    Parameters
    ----------
    image : vtk data
    ww : float
        window width
    wc : float
        window center

    Returns
    -------
    shift_data : vkt uchar data
    """
    shift_scale = vtk.vtkImageShiftScale()
    shift_scale.SetInputData(image.GetOutput())

    shift_scale.SetShift(-(wc - 0.5 * ww))

    shift_scale.SetScale(255.0 / ww)

    shift_scale.SetOutputScalarTypeToUnsignedChar()
    shift_scale.ClampOverflowOn()
    shift_scale.Update()

    return shift_scale
Пример #25
0
 def WriteTIFFImageFile(self):
     if (self.OutputFileName == ''):
         self.PrintError('Error: no OutputFileName.')
     self.PrintLog('Writing TIFF image file.')
     outputImage = self.Image
     if self.Image.GetScalarTypeAsString() != 'unsigned char':
         shiftScale = vtk.vtkImageShiftScale()
         shiftScale.SetInputData(self.Image)
         if self.WindowLevel[0] == 0.0:
             scalarRange = self.Image.GetScalarRange()
             shiftScale.SetShift(-scalarRange[0])
             shiftScale.SetScale(255.0/(scalarRange[1]-scalarRange[0]))
         else: 
             shiftScale.SetShift(-(self.WindowLevel[1]-self.WindowLevel[0]/2.0))
             shiftScale.SetScale(255.0/self.WindowLevel[0])
         shiftScale.SetOutputScalarTypeToUnsignedChar()
         shiftScale.ClampOverflowOn()
         shiftScale.Update()
         outputImage = shiftScale.GetOutput()
     writer = vtk.vtkTIFFWriter()
     writer.SetInputData(outputImage)
     if self.Image.GetDimensions()[2] == 1:
         writer.SetFileName(self.OutputFileName)
     else:
         writer.SetFilePrefix(self.OutputFileName)
         writer.SetFilePattern("%s%04d.tif")
     writer.Write()
    def SetupTextureMapper(self):
        if not self.GetInput():
            return
        
        mapper3D = vtk.vtkVolumeTextureMapper3D.SafeDownCast(self.__VolumeTextureMapper)
        if mapper3D and not self.GetRenderWindow().GetNeverRendered():
            if not mapper3D.IsRenderSupported(self.__VolumeProperty):
#               try the ATI fragment program implementation
                mapper3D.SetPreferredMethodToFragmentProgram()
                if not mapper3D.IsRenderSupported(self.__VolumeProperty):
                    print "Warning: 3D texture volume rendering is not supported by your hardware, switching to 2D texture rendering."
                    newMapper = vtk.vtkVolumeTextureMapper2D()
                    newMapper.CroppingOn()
                    newMapper.SetCroppingRegionFlags (0x7ffdfff)
                    
                    range = self.GetInput().GetScalarRange()
                    shift = 0 - range[0]
                    scale = 65535.0 / (range[1]-range[0])
                    
                    scaler = vtk.vtkImageShiftScale()
                    scaler.SetInput(self.GetInput())
                    scaler.SetShift(shift)
                    scaler.SetScale(scale)
                    scaler.SetOutputScalarTypeToUnsignedShort()
                    scaler.Update()
                    newMapper.SetInput(scaler.GetOutput())
#                    del scaler
                    self.__Callback.SetVolumeMapper(newMapper)
                    self.__VolumeMapper = newMapper
                    self.__VolumeMapper.SetMapper(newMapper)
Пример #27
0
    def highlight_voxels_3D(self, coords):

        self.viewer.ren_iso.RemoveVolume(self.viewer.vol)

        newimage = vtk.vtkImageData()
        newimage.SetSpacing(self.viewer.volumedata.GetSpacing())
        newimage.SetOrigin(self.viewer.volumedata.GetOrigin())
        newimage.SetDimensions(self.viewer.volumedata.GetDimensions())
        newimage.SetExtent(self.viewer.volumedata.GetExtent())
        newimage.SetNumberOfScalarComponents(1)
        newimage.SetScalarTypeToDouble()
        newimage.AllocateScalars()

        for p in coords:
            newimage.SetScalarComponentFromDouble(p[0], p[1], p[2], 0, p[3])

        shift_scale = vtk.vtkImageShiftScale()
        shift_scale.SetInput(newimage)
        shift_scale.SetOutputScalarTypeToUnsignedChar()
        shift_scale.Update()

        flipYFilter = vtk.vtkImageFlip()
        flipYFilter.SetFilteredAxis(1)
        flipYFilter.SetInput(shift_scale.GetOutput())
        flipYFilter.Update()

        self.viewer.volMapper.SetInput(flipYFilter.GetOutput())

        self.viewer.ren_iso.AddVolume(self.viewer.vol)
        self.viewer.refresh_3d()
Пример #28
0
    def execute(self, inputs, update=0, last=0):
        """
		Execute the filter with given inputs and return the output
		"""
        if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
            return None

        image = self.getInput(1)
        self.vtkfilter.SetInput(image)

        self.vtkfilter.SetConsiderAnisotropy(
            self.parameters["ConsiderAnisotropy"])
        self.vtkfilter.SetAlgorithm(self.parameters["Algorithm"])
        data = self.vtkfilter.GetOutput()
        if self.parameters["CastToUnsignedChar"]:
            self.vtkfilter.Update()
            cast = vtk.vtkImageShiftScale()
            x0, x1 = data.GetScalarRange()
            print data
            print "Scalar range=", x0, x1
            cast.SetInput(self.vtkfilter.GetOutput())
            cast.SetOutputScalarTypeToUnsignedChar()
            #cast.SetClampOverflow(1)
            cast.SetScale(255.0 / x1)
            print "Setting scale to ", 255.0 / x1
            data = cast.GetOutput()
        if update:
            self.vtkfilter.Update()
        return data
Пример #29
0
    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No input image.')

        if self.OutputType == 'uchar' and self.ShiftScale:
            shiftScale = vtk.vtkImageShiftScale()
            shiftScale.SetInputData(self.Image)
            if self.WindowLevel[0] == 0.0:
                scalarRange = self.Image.GetScalarRange()
                scale = 255.0
                if (scalarRange[1]-scalarRange[0]) > 0.0:
                    scale = 255.0/(scalarRange[1]-scalarRange[0])
                shiftScale.SetShift(-scalarRange[0])
                shiftScale.SetScale(scale)
            else:
                shiftScale.SetShift(-(self.WindowLevel[1]-self.WindowLevel[0]/2.0))
                shiftScale.SetScale(255.0/self.WindowLevel[0])
            shiftScale.SetOutputScalarTypeToUnsignedChar()
            shiftScale.ClampOverflowOn()
            shiftScale.Update()
            self.Image = shiftScale.GetOutput()
        else:
            cast = vtk.vtkImageCast()
            cast.SetInputData(self.Image)
            if self.OutputType == 'float':
                cast.SetOutputScalarTypeToFloat()
            elif self.OutputType == 'double':
                cast.SetOutputScalarTypeToDouble()
            elif self.OutputType == 'uchar':
                cast.SetOutputScalarTypeToUnsignedChar()
            elif self.OutputType == 'short':
                cast.SetOutputScalarTypeToShort()
            cast.Update()
            self.Image = cast.GetOutput()
Пример #30
0
    def DownsampleImage(self, image, nbits=8):
        """Downsamples an image"""

        image.SetReleaseDataFlag(1)

        # get the min and max values from the image
        (minval, maxval) = image.GetScalarRange()

        # create an 8-bit version of this image
        _filter = vtk.vtkImageShiftScale()
        _filter.SetInput(image.GetRealImage())
        _filter.SetShift(-minval)
        try:
            if nbits == 8:
                _filter.SetScale(255.0 / (maxval - minval))
            elif nbits == 16:
                _filter.SetScale(65535.0 / (maxval - minval))
        except ZeroDivisionError:
            logging.exception("DownsampleImage")
            _filter.SetScale(1.0)
        if nbits == 8:
            _filter.SetOutputScalarTypeToUnsignedChar()
        elif nbits == 16:
            _filter.SetOutputScalarTypeToShort()
        elif nbits == 32:
            _filter.SetOutputScalarTypeToFloat()
        elif nbits == 64:
            _filter.SetOutputScalarTypeToDouble()

        _filter.AddObserver('ProgressEvent', self.HandleVTKProgressEvent)
        _filter.SetProgressText("Downsampling to %d-bit..." % nbits)
        logging.info("Image downsampled to {0}-bit".format(nbits))
        _filter.Update()

        return MVImage.MVImage(_filter.GetOutputPort(), input=image)
Пример #31
0
    def Execute(self):

        if self.Image == None:
            self.PrintError("Error: No input image.")

        if self.OutputType == "uchar" and self.ShiftScale:
            shiftScale = vtk.vtkImageShiftScale()
            shiftScale.SetInput(self.Image)
            if self.WindowLevel[0] == 0.0:
                scalarRange = self.Image.GetScalarRange()
                shiftScale.SetShift(-scalarRange[0])
                shiftScale.SetScale(255.0 / (scalarRange[1] - scalarRange[0]))
            else:
                shiftScale.SetShift(-(self.WindowLevel[1] - self.WindowLevel[0] / 2.0))
                shiftScale.SetScale(255.0 / self.WindowLevel[0])
            shiftScale.SetOutputScalarTypeToUnsignedChar()
            shiftScale.ClampOverflowOn()
            shiftScale.Update()
            self.Image = shiftScale.GetOutput()
        else:
            cast = vtk.vtkImageCast()
            cast.SetInput(self.Image)
            if self.OutputType == "float":
                cast.SetOutputScalarTypeToFloat()
            elif self.OutputType == "double":
                cast.SetOutputScalarTypeToDouble()
            elif self.OutputType == "uchar":
                cast.SetOutputScalarTypeToUnsignedChar()
            elif self.OutputType == "short":
                cast.SetOutputScalarTypeToShort()
            cast.Update()
            self.Image = cast.GetOutput()
Пример #32
0
def createImageData():
    sphere = vtk.vtkSphere()
    sphere.SetRadius(0.1)
    sphere.SetCenter(0.0, 0.0, 0.0)

    sampleFunction = vtk.vtkSampleFunction()
    sampleFunction.SetImplicitFunction(sphere)
    sampleFunction.SetOutputScalarTypeToDouble()
    sampleFunction.SetSampleDimensions(127, 127, 127)
    sampleFunction.SetModelBounds(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)
    sampleFunction.SetCapping(False)
    sampleFunction.SetComputeNormals(False)
    sampleFunction.SetScalarArrayName("values")
    sampleFunction.Update()

    a = sampleFunction.GetOutput().GetPointData().GetScalars("values")
    range = a.GetRange()
    print range
    t = vtk.vtkImageShiftScale()
    t.SetInputConnection(sampleFunction.GetOutputPort())

    t.SetShift(-range[0])
    magnitude = range[1] - range[0]
    if magnitude == 0.0:
        magnitude = 1.0
    t.SetScale(255.0 / magnitude)
    t.SetOutputScalarTypeToUnsignedChar()
    t.Update()
    return t.GetOutput()
Пример #33
0
def diff(im1, im2):

    #Takes the differences of two aim files and adds them together

    shift1 = vtk.vtkImageShiftScale()
    shift1.SetInputConnection(im1.GetOutputPort())
    shift1.SetOutputScalarTypeToChar()

    shift2 = vtk.vtkImageShiftScale()
    shift2.SetInputConnection(im2.GetOutputPort())
    shift2.SetOutputScalarTypeToChar()

    box1 = vtk.vtkImageReslice()
    box1.SetInput(shift1.GetOutput())
    box1.SetResliceAxesOrigin(im2.GetOutput().GetOrigin())
    box1.Update()

    sub1 = vtk.vtkImageMathematics()
    sub1.SetInput1(box1.GetOutput())
    sub1.SetInput2(shift2.GetOutput())
    sub1.SetOperationToSubtract()

    sub2 = vtk.vtkImageMathematics()
    sub2.SetInput1(shift2.GetOutput())
    sub2.SetInput2(shift1.GetOutput())
    sub2.SetOperationToSubtract()

    step1 = vtk.vtkImageMathematics()
    step1.SetInput1(sub1.GetOutput())
    step1.SetConstantC(-127)
    step1.SetConstantK(0)
    step1.SetOperationToReplaceCByK()

    step2 = vtk.vtkImageMathematics()
    step2.SetInput1(sub2.GetOutput())
    step2.SetConstantC(-127)
    step2.SetConstantK(0)
    step2.SetOperationToReplaceCByK()

    add = vtk.vtkImageMathematics()
    add.SetInput1(step2.GetOutput())
    add.SetInput2(step1.GetOutput())
    add.SetOperationToAdd()

    return add
Пример #34
0
    def save_frame_depth(self, path):

        #setup camera
        camera = vtkCamera()
        camera.SetPosition(self.cx, self.cy, self.cz)
        camera.SetFocalPoint(self.fx, self.fy, self.fz)
        camera.SetViewUp(self.ux, self.uy, self.uz)
        camera.SetViewAngle(self.fovy)
        #setup renderer
        renderer = vtkRenderer()
        renderWindow = vtkRenderWindow()
        renderWindow.SetOffScreenRendering(1)
        renderWindow.AddRenderer(renderer)
        renderWindow.SetSize(self.w, self.h)
        for i in xrange(-1, self.expert.nr_obstacles_c()):
            vss, nss, iss = self.save_frame_mesh(i)
            #geometry
            pts = vtkPoints()
            for i in xrange(len(vss)):
                pts.InsertNextPoint(vss[i][0], vss[i][1], vss[i][2])
                tris = vtkCellArray()
            for i in xrange(len(iss)):
                triangle = vtkTriangle()
                triangle.GetPointIds().SetId(0, iss[i][0])
                triangle.GetPointIds().SetId(1, iss[i][1])
                triangle.GetPointIds().SetId(2, iss[i][2])
                tris.InsertNextCell(triangle)
            poly = vtkPolyData()
            poly.SetPoints(pts)
            poly.SetPolys(tris)
            #actor
            mapper = vtkPolyDataMapper()
            mapper.SetInput(poly)
            actor = vtkActor()
            actor.SetMapper(mapper)
            renderer.AddActor(actor)
        renderer.SetBackground(self.bk_r, self.bk_g, self.bk_b)
        renderer.SetActiveCamera(camera)
        renderWindow.Render()
        #output options
        windowToImageFilter = vtkWindowToImageFilter()
        windowToImageFilter.SetInput(renderWindow)
        windowToImageFilter.SetMagnification(1)
        windowToImageFilter.SetInputBufferTypeToZBuffer()
        #Extract z buffer value
        windowToImageFilter.Update()
        #scale and shift
        scale = vtkImageShiftScale()
        scale.SetOutputScalarTypeToUnsignedChar()
        scale.SetInputConnection(windowToImageFilter.GetOutputPort())
        scale.SetShift(0)
        scale.SetScale(-255)
        #output
        writer = vtkBMPWriter()
        writer.SetFileName(path)
        writer.SetInputConnection(scale.GetOutputPort())
        writer.Write()
Пример #35
0
def Rescale(combo, ZeroPoint):
    """Rescale to legal pixel values [-1, 1] --> [0, MaxScaledValue]"""
    scaled = vtk.vtkImageShiftScale()
    scaled.SetInputConnection(combo.GetOutputPort())
    scaled.SetShift(1.)
    scaled.SetScale(ZeroPoint + 1)
    scaled.SetOutputScalarTypeToUnsignedShort()

    return scaled
Пример #36
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(self,
                                       module_manager,
                                       vtk.vtkImageShiftScale(),
                                       'Processing.', ('vtkImageData', ),
                                       ('vtkImageData', ),
                                       replaceDoc=True,
                                       inputFunctions=None,
                                       outputFunctions=None)
Пример #37
0
def Rescale(combo, ZeroPoint):
    """Rescale to legal pixel values [-1, 1] --> [0, MaxScaledValue]"""
    scaled = vtk.vtkImageShiftScale()
    scaled.SetInputConnection(combo.GetOutputPort())
    scaled.SetShift(1.)
    scaled.SetScale(ZeroPoint + 1)
    scaled.SetOutputScalarTypeToUnsignedShort()

    return scaled
Пример #38
0
def ipl_add_aims(image_in1, image_in2):
    ipl_add_aims_settings()

    extent1 = image_in1.GetExtent()

    voi1 = vtk.vtkExtractVOI()
    voi1.SetInput(image_in1)
    voi1.SetVOI(extent1[0], extent1[1], extent1[2], extent1[3], extent1[4],
                extent1[5])

    extent2 = image_in2.GetExtent()

    voi2 = vtk.vtkExtractVOI()
    voi2.SetInput(image_in2)
    voi2.SetVOI(extent2[0], extent2[1], extent2[2], extent2[3], extent2[4],
                extent2[5])

    shift1 = vtk.vtkImageShiftScale()
    shift1.SetInputConnection(voi1.GetOutputPort())
    shift1.SetOutputScalarTypeToChar()
    shift1.Update()

    shift2 = vtk.vtkImageShiftScale()
    shift2.SetInputConnection(voi2.GetOutputPort())
    shift2.SetOutputScalarTypeToChar()
    shift2.Update()

    add = vtk.vtkImageMathematics()
    add.SetInput1(shift1.GetOutput())
    add.SetInput2(shift2.GetOutput())
    add.SetOperationToAdd()
    add.Update()

    temp = vtk.vtkImageMathematics()
    temp.SetInput1(add.GetOutput())
    temp.SetConstantC(-2)
    temp.SetConstantK(127)
    temp.SetOperationToReplaceCByK()
    temp.Update()

    image_out = temp.GetOutput()
    return image_out
	def __init__(self):
		"""
		Initialization
		"""		   
		lib.ProcessingFilter.ProcessingFilter.__init__(self, (1, 1))
		self.vtkfilter = vtk.vtkImageShiftScale()
		self.vtkfilter.AddObserver("ProgressEvent", lib.messenger.send)
		lib.messenger.connect(self.vtkfilter, 'ProgressEvent', self.updateProgress)
		self.eventDesc = "Applying a shift and scale to image intensity"
		self.descs = {"Shift": "Shift:", "Scale": "Scale:", "AutoScale": "Scale to max range of data type", "NoOverflow":"Prevent over/underflow", "Scale8bit": "Scale to 8-bit range (0-255)"}
		self.filterDesc = "Shifts pixel/voxel intensities and then scales them, corresponding roughly to the adjustment of brightness and contrast, respectively\nInput: Grayscale image\nOutput: Grayscale image"
Пример #40
0
 def __cvt2ubyte(self, reader):
     reader.Update()
     self.sliceNum = reader.GetOutput().GetDimensions()[2]
     self.sliceIdx = self.sliceNum / 2
     min, max = reader.GetOutput().GetScalarRange()
     data = vtk.vtkImageShiftScale()
     data.SetInputConnection(reader.GetOutputPort())
     data.SetShift(-1.0 * min)
     data.SetScale(255.0 / (max - min))
     data.SetOutputScalarTypeToUnsignedChar()
     return data
Пример #41
0
    def __init__(self,renWin):
        self.renWin = renWin
        self.zBuffFilter = vtk.vtkWindowToImageFilter()
        self.zBuffFilter.SetInput(self.renWin)
        self.zBuffFilter.SetInputBufferTypeToZBuffer()

        self.scaledZBuff = vtk.vtkImageShiftScale()
        self.scaledZBuff.SetOutputScalarTypeToUnsignedChar()
        self.scaledZBuff.SetInputConnection(self.zBuffFilter.GetOutputPort())
        self.scaledZBuff.SetShift(0)
        self.scaledZBuff.SetScale(255)
Пример #42
0
    def __init__(self, renWin):
        self.renWin = renWin
        self.zBuffFilter = vtk.vtkWindowToImageFilter()
        self.zBuffFilter.SetInput(self.renWin)
        self.zBuffFilter.SetMagnification(1)
        self.zBuffFilter.SetInputBufferTypeToZBuffer()

        self.scaledZBuff = vtk.vtkImageShiftScale()
        self.scaledZBuff.SetOutputScalarTypeToUnsignedChar()
        self.scaledZBuff.SetInputConnection(self.zBuffFilter.GetOutputPort())
        self.scaledZBuff.SetShift(0)
        self.scaledZBuff.SetScale(-255)
	def __init__(self):
		"""
		Initialization
		"""		   
		lib.ProcessingFilter.ProcessingFilter.__init__(self, (1, 1))
		self.vtkfilter = vtk.vtkImageShiftScale()
		self.vtkfilter.AddObserver("ProgressEvent", lib.messenger.send)
		lib.messenger.connect(self.vtkfilter, 'ProgressEvent', self.updateProgress)
		self.eventDesc = "Applying an Automatic background subtraction"
		self.descs = {"SmallestNonZeroValue":"Use smallest non-zero value as background",
		"FirstPeak":"First peak in histogram","MostCommon":"Most common value"}
		self.filterDesc = "Removes background by subtracting a certain value from the intensity of every pixel/voxel\nInput: Grayscale image\nOutput: Grayscale image"
Пример #44
0
 def __cvt2ubyte(self, reader):
     reader.Update()
     x, y, z = reader.GetOutput().GetDimensions()
     self.orientation_dict = {  #sliceNum, sliceIdx
         0: [lambda viewer: viewer.SetSliceOrientationToXY, z, z / 2],
         1: [lambda viewer: viewer.SetSliceOrientationToYZ, x, x / 2],
         2: [lambda viewer: viewer.SetSliceOrientationToXZ, y, y / 2]
     }
     min, max = reader.GetOutput().GetScalarRange()
     data = vtk.vtkImageShiftScale()
     data.SetInputConnection(reader.GetOutputPort())
     data.SetShift(-1.0 * min)
     data.SetScale(255.0 / (max - min + 0.00001))
     data.SetOutputScalarTypeToUnsignedChar()
     return data
        def CreateVolumeSource(self):
            imageReader = vtk.vtkMetaImageReader()
            imageReader.SetFileName(self.ImageFileName)
            imageReader.Update()

            valueMin, valueMax = imageReader.GetOutput().GetPointData(
            ).GetArray('MetaImage').GetValueRange()

            toUnsignedShort = vtk.vtkImageShiftScale()
            toUnsignedShort.ClampOverflowOn()
            toUnsignedShort.SetShift(-valueMin)
            toUnsignedShort.SetScale(512.0 / (valueMax - valueMin))
            toUnsignedShort.SetInputConnection(imageReader.GetOutputPort())
            toUnsignedShort.SetOutputScalarTypeToUnsignedShort()

            return toUnsignedShort
Пример #46
0
def _handleFailedImage(idiff, pngr, img_fname):
    """Writes all the necessary images when an image comparison
    failed."""
    f_base, f_ext = os.path.splitext(img_fname)

    # write out the difference file in full.
    pngw = vtk.vtkPNGWriter()
    pngw.SetFileName(_getTempImagePath(f_base + ".diff.png"))
    pngw.SetInput(idiff.GetOutput())
    pngw.Write()

    # write the difference image scaled and gamma adjusted for the
    # dashboard.
    sz = pngr.GetOutput().GetDimensions()
    if sz[1] <= 250.0:
        mag = 1.0
    else:
        mag = 250.0 / sz[1]

    shrink = vtk.vtkImageResample()
    shrink.SetInput(idiff.GetOutput())
    shrink.InterpolateOn()
    shrink.SetAxisMagnificationFactor(0, mag)
    shrink.SetAxisMagnificationFactor(1, mag)

    gamma = vtk.vtkImageShiftScale()
    gamma.SetInput(shrink.GetOutput())
    gamma.SetShift(0)
    gamma.SetScale(10)

    jpegw = vtk.vtkJPEGWriter()
    jpegw.SetFileName(_getTempImagePath(f_base + ".diff.small.jpg"))
    jpegw.SetInput(gamma.GetOutput())
    jpegw.SetQuality(85)
    jpegw.Write()

    # write out the image that was generated.
    shrink.SetInput(idiff.GetInput())
    jpegw.SetInput(shrink.GetOutput())
    jpegw.SetFileName(_getTempImagePath(f_base + ".test.small.jpg"))
    jpegw.Write()

    # write out the valid image that matched.
    shrink.SetInput(idiff.GetImage())
    jpegw.SetInput(shrink.GetOutput())
    jpegw.SetFileName(_getTempImagePath(f_base + ".small.jpg"))
    jpegw.Write()
Пример #47
0
def _handleFailedImage(idiff, pngr, img_fname):
    """Writes all the necessary images when an image comparison
    failed."""
    f_base, f_ext = os.path.splitext(img_fname)

    # write out the difference file in full.
    pngw = vtk.vtkPNGWriter()
    pngw.SetFileName(_getTempImagePath(f_base + ".diff.png"))
    pngw.SetInput(idiff.GetOutput())
    pngw.Write()
    
    # write the difference image scaled and gamma adjusted for the
    # dashboard.
    sz = pngr.GetOutput().GetDimensions()
    if sz[1] <= 250.0:
        mag = 1.0
    else:
        mag = 250.0/sz[1]

    shrink = vtk.vtkImageResample()
    shrink.SetInput(idiff.GetOutput())
    shrink.InterpolateOn()
    shrink.SetAxisMagnificationFactor(0, mag)
    shrink.SetAxisMagnificationFactor(1, mag)

    gamma = vtk.vtkImageShiftScale()
    gamma.SetInput(shrink.GetOutput())
    gamma.SetShift(0)
    gamma.SetScale(10)

    jpegw = vtk.vtkJPEGWriter()
    jpegw.SetFileName(_getTempImagePath(f_base + ".diff.small.jpg"))
    jpegw.SetInput(gamma.GetOutput())
    jpegw.SetQuality(85)
    jpegw.Write()

    # write out the image that was generated.
    shrink.SetInput(idiff.GetInput())
    jpegw.SetInput(shrink.GetOutput())
    jpegw.SetFileName(_getTempImagePath(f_base + ".test.small.jpg"))
    jpegw.Write()

    # write out the valid image that matched.
    shrink.SetInput(idiff.GetImage())
    jpegw.SetInput(shrink.GetOutput())
    jpegw.SetFileName(_getTempImagePath(f_base + ".small.jpg"))
    jpegw.Write()
Пример #48
0
def dicom_to_png(imagedata, dir):
    logging.debug("In data.dicom_to_png()")
    shiftScale = vtk.vtkImageShiftScale()
    shiftScale.SetOutputScalarTypeToUnsignedShort()
    shiftScale.SetInput(imagedata)
    inp = shiftScale.GetInput()
    minv, maxv = inp.GetScalarRange()
    shiftScale.SetShift(-minv)
    shiftScale.SetScale(65535 / (maxv - minv))
    w = vtk.vtkPNGWriter()
    w.SetFileDimensionality(3)
    w.SetInput(shiftScale.GetOutput())
    w.SetFilePattern("%s%d.png")
    if not os.path.exists(dir):
        os.mkdir(dir)
    w.SetFilePrefix(dir)
    w.Write()
    def Display(self):

        wholeExtent = self.Image.GetWholeExtent()

        self.SliceVOI[0] = wholeExtent[0]
        self.SliceVOI[1] = wholeExtent[1]
        self.SliceVOI[2] = wholeExtent[2]
        self.SliceVOI[3] = wholeExtent[3]
        self.SliceVOI[4] = wholeExtent[4]
        self.SliceVOI[5] = wholeExtent[5]

        self.SliceVOI[self.Axis*2] = wholeExtent[self.Axis*2]
        self.SliceVOI[self.Axis*2+1] = wholeExtent[self.Axis*2]

        range = self.Image.GetScalarRange()

        imageShifter = vtk.vtkImageShiftScale()
        imageShifter.SetInput(self.Image)
        imageShifter.SetShift(-1.0*range[0])
        imageShifter.SetScale(255.0/(range[1]-range[0]))
        imageShifter.SetOutputScalarTypeToUnsignedChar()

        widgetImage = imageShifter.GetOutput()

        self.ImageActor.SetInput(widgetImage)
        self.ImageActor.SetDisplayExtent(self.SliceVOI)
        self.vmtkRenderer.Renderer.AddActor(self.ImageActor)

        self.ImageTracerWidget.SetCaptureRadius(1.5)
        self.ImageTracerWidget.SetViewProp(self.ImageActor)
        self.ImageTracerWidget.SetInput(widgetImage)
        self.ImageTracerWidget.ProjectToPlaneOn()
        self.ImageTracerWidget.SetProjectionNormal(self.Axis)
        self.ImageTracerWidget.PlaceWidget()
        self.ImageTracerWidget.SetAutoClose(self.AutoClose)
        self.ImageTracerWidget.AddObserver("StartInteractionEvent",self.SetWidgetProjectionPosition)
        self.ImageTracerWidget.AddObserver("EndInteractionEvent",self.GetLineFromWidget)

        interactorStyle = vtk.vtkInteractorStyleImage()
        self.vmtkRenderer.RenderWindowInteractor.SetInteractorStyle(interactorStyle)

        self.vmtkRenderer.Render()
Пример #50
0
    def __init__(self, module_manager):

        # call parent constructor
        ModuleBase.__init__(self, module_manager)
        # ctor for this specific mixin
        # FilenameViewModuleMixin.__init__(self)
	
	self._shiftScale = vtk.vtkImageShiftScale()
        self._shiftScale.SetOutputScalarTypeToUnsignedShort()

        module_utils.setup_vtk_object_progress(
            self, self._shiftScale,
            'Converting input to unsigned short.')

        
	
	self._writer = vtk.vtkPNGWriter()
	self._writer.SetFileDimensionality(3)
        self._writer.SetInput(self._shiftScale.GetOutput())
        
	module_utils.setup_vtk_object_progress(
            self, self._writer, 'Writing PNG file(s)')

        
       
        self._config.filePattern = '%d.png'

        configList = [
            ('File pattern:', 'filePattern', 'base:str', 'filebrowser',
             'Filenames will be built with this.  See module help.',
             {'fileMode' : wx.OPEN,
              'fileMask' :
              'PNG files (*.png)|*.png|All files (*.*)|*.*'})]

        ScriptedConfigModuleMixin.__init__(
            self, configList,
            {'Module (self)' : self,
             'vtkPNGWriter' : self._writer})
            
        self.sync_module_logic_with_config()
	def execute(self, inputs, update = 0, last = 0):
		"""
		Execute the filter with given inputs and return the output
		"""
		if not lib.ProcessingFilter.ProcessingFilter.execute(self, inputs):
			return None

		roi = self.parameters["ROI"][1]
		scripting.wantWholeDataset = 1
		imagedata = self.getInput(1)
		imagedata.SetUpdateExtent(imagedata.GetWholeExtent())
		imagedata.Update()

		itkOrig = self.convertVTKtoITK(imagedata)
		itkOrig.DisconnectPipeline()

		mx, my, mz = self.dataUnit.getDimensions()
		n, maskImage = lib.ImageOperations.getMaskFromROIs([roi], mx, my, mz)
		itkLabel = self.convertVTKtoITK(maskImage)
		itkLabel = self.castITKImage(itkLabel, itkOrig)
		#vtkToItk2 = itk.VTKImageToImageFilter.IUC3.New()
		#vtkToItk2.SetInput(maskImage)
		#itkLabel = vtkToItk2.GetOutput()
		#itkLabel.Update()

		labelStats = itk.LabelStatisticsImageFilter[itkOrig, itkLabel].New()
		labelStats.SetInput(0, itkOrig)
		labelStats.SetInput(1, itkLabel)
		labelStats.Update()
		
		avgint = labelStats.GetMean(255)
		print "Subtract from image:",avgint

		shift = vtk.vtkImageShiftScale()
		shift.SetInput(imagedata)
		shift.SetClampOverflow(1)
		shift.SetScale(1)
		shift.SetShift(-avgint)
		
		return shift.GetOutput()
	def getDataSet(self, i, raw = 0):
		"""
		Returns the DataSet at the specified index
		Parameters:	  i		  The index
		"""
		data = self.getTimepoint(i)
		data = self.getResampledData(data, i)
		if not self.shift:
			self.shift = vtk.vtkImageShiftScale()
			self.shift.SetOutputScalarTypeToUnsignedChar()
		self.shift.SetInput(data)

		x0, x1 = data.GetScalarRange()
		print "Scalar range=", x0, x1
		if not x1:
			x1 = 1
		scale = 255.0/x1

		if scale:
			self.shift.SetScale(scale)
		self.shift.Update()
		data = self.shift.GetOutput()
		data.ReleaseDataFlagOff()
		return data
Пример #53
0
    def Get_filter(self):

        x1 = float(self.gui.m_textCtrlOldValue1.GetValue())
        y1 = float(self.gui.m_textCtrlOldValue2.GetValue())
        x2 = float(self.gui.m_textCtrlNewValue1.GetValue())
        y2 = float(self.gui.m_textCtrlNewValue2.GetValue())

        if x1 == x2 and y1 == y2:
            logging.info(
                "Current values will have no effect.")
            return None

        if x1 == y1 or x2 == y2:
            logging.info("Cannot satisfy these shift/scale")
            return None

        shift = x2 - x1
        scale = (y2 - x2) / (y1 - x1)

        _type = [vtk.VTK_CHAR,
                 vtk.VTK_UNSIGNED_CHAR,
                 vtk.VTK_SHORT,
                 vtk.VTK_UNSIGNED_SHORT,
                 vtk.VTK_INT,
                 vtk.VTK_FLOAT,
                 vtk.VTK_DOUBLE][self.gui.m_choiceScalarType.GetSelection()]

        _filter = vtk.vtkImageShiftScale()
        _filter.SetInput(component.getUtility(ICurrentImage).GetRealImage())
        _filter.SetOutputScalarType(_type)
        _filter.SetScale(scale)
        _filter.SetShift(shift)
        _filter.SetClampOverflow(int(
            self.gui.m_checkBoxClampOverflow.GetValue()))

        return _filter
Пример #54
0
    def testAllBlendsFloat(self):

        # This script blends images that consist of float data

        renWin = vtk.vtkRenderWindow()
        renWin.SetSize(512, 256)

        # Image pipeline

        inputImage = vtk.vtkTIFFReader()
        inputImage.SetFileName(VTK_DATA_ROOT + "/Data/beach.tif")

        # "beach.tif" image contains ORIENTATION tag which is
        # ORIENTATION_TOPLEFT (row 0 top, col 0 lhs) type. The TIFF
        # reader parses this tag and sets the internal TIFF image
        # orientation accordingly.  To overwrite this orientation with a vtk
        # convention of ORIENTATION_BOTLEFT (row 0 bottom, col 0 lhs ), invoke
        # SetOrientationType method with parameter value of 4.
        inputImage.SetOrientationType(4)

        inputImage2 = vtk.vtkBMPReader()
        inputImage2.SetFileName(VTK_DATA_ROOT + "/Data/masonry.bmp")

        # shrink the images to a reasonable size

        shrink1 = vtk.vtkImageShrink3D()
        shrink1.SetInputConnection(inputImage.GetOutputPort())
        shrink1.SetShrinkFactors(2, 2, 1)

        shrink2 = vtk.vtkImageShrink3D()
        shrink2.SetInputConnection(inputImage2.GetOutputPort())
        shrink2.SetShrinkFactors(2, 2, 1)

        color = vtk.vtkImageShiftScale()
        color.SetOutputScalarTypeToFloat()
        color.SetShift(0)
        color.SetScale(1.0 / 255)
        color.SetInputConnection(shrink1.GetOutputPort())

        backgroundColor = vtk.vtkImageShiftScale()
        backgroundColor.SetOutputScalarTypeToFloat()
        backgroundColor.SetShift(0)
        backgroundColor.SetScale(1.0 / 255)
        backgroundColor.SetInputConnection(shrink2.GetOutputPort())

        # create a greyscale version

        luminance = vtk.vtkImageLuminance()
        luminance.SetInputConnection(color.GetOutputPort())

        backgroundLuminance = vtk.vtkImageLuminance()
        backgroundLuminance.SetInputConnection(backgroundColor.GetOutputPort())

        # create an alpha mask

        alpha = vtk.vtkImageThreshold()
        alpha.SetInputConnection(luminance.GetOutputPort())
        alpha.ThresholdByLower(0.9)
        alpha.SetInValue(1.0)
        alpha.SetOutValue(0.0)

        # make luminanceAlpha and colorAlpha versions

        luminanceAlpha = vtk.vtkImageAppendComponents()
        luminanceAlpha.AddInputConnection(luminance.GetOutputPort())
        luminanceAlpha.AddInputConnection(alpha.GetOutputPort())

        colorAlpha = vtk.vtkImageAppendComponents()
        colorAlpha.AddInputConnection(color.GetOutputPort())
        colorAlpha.AddInputConnection(alpha.GetOutputPort())

        foregrounds = ["luminance", "luminanceAlpha", "color", "colorAlpha"]
        backgrounds = ["backgroundColor", "backgroundLuminance"]

        deltaX = 1.0 / 4.0
        deltaY = 1.0 / 2.0

        blend = dict()
        mapper = dict()
        actor = dict()
        imager = dict()

        for row, bg in enumerate(backgrounds):
            for column, fg in enumerate(foregrounds):
                blend.update({bg:{fg:vtk.vtkImageBlend()}})
                blend[bg][fg].AddInputConnection(eval(bg + '.GetOutputPort()'))
                if bg == "backgroundColor" or fg == "luminance" or fg == "luminanceAlpha":
                    blend[bg][fg].AddInputConnection(eval(fg + '.GetOutputPort()'))
                    blend[bg][fg].SetOpacity(1, 0.8)

                mapper.update({bg:{fg:vtk.vtkImageMapper()}})
                mapper[bg][fg].SetInputConnection(blend[bg][fg].GetOutputPort())
                mapper[bg][fg].SetColorWindow(1.0)
                mapper[bg][fg].SetColorLevel(0.5)

                actor.update({bg:{fg:vtk.vtkActor2D()}})
                actor[bg][fg].SetMapper(mapper[bg][fg])

                imager.update({bg:{fg:vtk.vtkRenderer()}})
                imager[bg][fg].AddActor2D(actor[bg][fg])
                imager[bg][fg].SetViewport(column * deltaX, row * deltaY, (column + 1) * deltaX, (row + 1) * deltaY)

                renWin.AddRenderer(imager[bg][fg])

        # render and interact with data

        iRen = vtk.vtkRenderWindowInteractor()
        iRen.SetRenderWindow(renWin);
        renWin.Render()

        img_file = "TestAllBlendsFloat.png"
        vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
        vtk.test.Testing.interact()
Пример #55
0
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

# A script to test the vtkLassoStencilSource
reader = vtk.vtkPNGReader()
reader.SetDataSpacing(0.8,0.8,1.5)
reader.SetDataOrigin(0.0,0.0,0.0)
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
reader.Update()
shiftScale = vtk.vtkImageShiftScale()
shiftScale.SetInputConnection(reader.GetOutputPort())
shiftScale.SetScale(0.2)
shiftScale.Update()
points1 = vtk.vtkPoints()
points1.InsertNextPoint(80,50,0)
points1.InsertNextPoint(100,90,0)
points1.InsertNextPoint(200,50,0)
points1.InsertNextPoint(230,100,0)
points1.InsertNextPoint(150,170,0)
points1.InsertNextPoint(110,170,0)
points1.InsertNextPoint(80,50,0)
points2 = vtk.vtkPoints()
points2.InsertNextPoint(80,50,0)
points2.InsertNextPoint(100,90,0)
points2.InsertNextPoint(200,50,0)
points2.InsertNextPoint(230,100,0)
points2.InsertNextPoint(150,170,0)
points2.InsertNextPoint(110,170,0)
Пример #56
0
    def buildPipeline(self):
        """ execute() -> None
        Dispatch the vtkRenderer to the actual rendering widget
        """       
        self.colorInputModule = self.wmod.forceGetInputFromPort( "colors", None )
        
        if self.input() == None: 
            print>>sys.stderr, "Must supply 'volume' port input to VectorCutPlane"
            return
              
        xMin, xMax, yMin, yMax, zMin, zMax = self.input().GetWholeExtent()       
        spacing = self.input().GetSpacing()
        sx, sy, sz = spacing       
        origin = self.input().GetOrigin()
        ox, oy, oz = origin
        
        cellData = self.input().GetCellData()  
        pointData = self.input().GetPointData()     
        vectorsArray = pointData.GetVectors()
        
        if vectorsArray == None: 
            print>>sys.stderr, "Must supply point vector data for 'volume' port input to VectorVolume"
            return

        self.setRangeBounds( list( vectorsArray.GetRange(-1) ) )
        self.nComponents = vectorsArray.GetNumberOfComponents()
        for iC in range(-1,3): print "Value Range %d: %s " % ( iC, str( vectorsArray.GetRange( iC ) ) )
        for iV in range(10): print "Value[%d]: %s " % ( iV, str( vectorsArray.GetTuple3( iV ) ) )
        
        self.initialOrigin = self.input().GetOrigin()
        self.initialExtent = self.input().GetExtent()
        self.initialSpacing = self.input().GetSpacing()
        self.dataBounds = self.getUnscaledWorldExtent( self.initialExtent, self.initialSpacing, self.initialOrigin ) 
        dataExtents = ( (self.dataBounds[1]-self.dataBounds[0])/2.0, (self.dataBounds[3]-self.dataBounds[2])/2.0, (self.dataBounds[5]-self.dataBounds[4])/2.0 )
        centroid = ( (self.dataBounds[0]+self.dataBounds[1])/2.0, (self.dataBounds[2]+self.dataBounds[3])/2.0, (self.dataBounds[4]+self.dataBounds[5])/2.0  )
        self.pos = [ self.initialSpacing[i]*self.initialExtent[2*i] for i in range(3) ]
        if ( (self.initialOrigin[0] + self.pos[0]) < 0.0): self.pos[0] = self.pos[0] + 360.0

        self.resample = vtk.vtkExtractVOI()
        self.resample.SetInput( self.input() ) 
        self.resample.SetVOI( self.initialExtent )
        self.ApplyGlyphDecimationFactor()
        lut = self.getLut()
        
        if self.colorInputModule <> None:
            colorInput = self.colorInputModule.getOutput()
            self.color_resample = vtk.vtkExtractVOI()
            self.color_resample.SetInput( colorInput ) 
            self.color_resample.SetVOI( self.initialExtent )
            self.color_resample.SetSampleRate( sampleRate, sampleRate, 1 )
#            self.probeFilter = vtk.vtkProbeFilter()
#            self.probeFilter.SetSourceConnection( self.resample.GetOutputPort() )           
#            colorInput = self.colorInputModule.getOutput()
#            self.probeFilter.SetInput( colorInput )
            resampledColorInput = self.color_resample.GetOutput()
            shiftScale = vtk.vtkImageShiftScale()
            shiftScale.SetOutputScalarTypeToFloat ()           
            shiftScale.SetInput( resampledColorInput ) 
            valueRange = self.getScalarRange()
            shiftScale.SetShift( valueRange[0] )
            shiftScale.SetScale ( (valueRange[1] - valueRange[0]) / 65535 )
            colorFloatInput = shiftScale.GetOutput() 
            colorFloatInput.Update()
            colorInput_pointData = colorFloatInput.GetPointData()     
            self.colorScalars = colorInput_pointData.GetScalars()
            self.colorScalars.SetName('color')
            lut.SetTableRange( valueRange ) 
        
        self.glyph = vtk.vtkGlyph3DMapper() 
#        if self.colorInputModule <> None:   self.glyph.SetColorModeToColorByScalar()            
#        else:                               self.glyph.SetColorModeToColorByVector()          
        scalarRange = self.getScalarRange()
        self.glyph.SetScaleModeToScaleByMagnitude()
        self.glyph.SetColorModeToMapScalars()     
        self.glyph.SetUseLookupTableScalarRange(1)
        self.glyph.SetOrient( 1 ) 
#        self.glyph.ClampingOn()
        self.glyph.SetRange( scalarRange[0:2] )
        self.glyph.SetInputConnection( self.resample.GetOutputPort()  )
        self.arrow = vtk.vtkArrowSource()
        self.glyph.SetSourceConnection( self.arrow.GetOutputPort() )
        self.glyph.SetLookupTable( lut )
        self.glyphActor = vtk.vtkActor() 
        self.glyphActor.SetMapper( self.glyph )
        self.renderer.AddActor( self.glyphActor )
        self.renderer.SetBackground( VTK_BACKGROUND_COLOR[0], VTK_BACKGROUND_COLOR[1], VTK_BACKGROUND_COLOR[2] ) 
        self.set3DOutput(wmod=self.wmod) 
Пример #57
0
    def Execute(self):    
        if self.Image == None:
            self.PrintError('Error: no Image.')

        cast = vtk.vtkImageCast()
        cast.SetInputData(self.Image)
        cast.SetOutputScalarTypeToFloat()
        cast.Update()
        self.Image = cast.GetOutput()

        if self.NegateImage:
            scalarRange = self.Image.GetScalarRange()
            negate = vtk.vtkImageMathematics()
            negate.SetInputData(self.Image)
            negate.SetOperationToMultiplyByK()
            negate.SetConstantK(-1.0)
            negate.Update()
            shiftScale = vtk.vtkImageShiftScale()
            shiftScale.SetInputConnection(negate.GetOutputPort())
            shiftScale.SetShift(scalarRange[1]+scalarRange[0])
            shiftScale.SetOutputScalarTypeToFloat()
            shiftScale.Update()
            self.Image = shiftScale.GetOutput()

        if self.Interactive:
            if not self.vmtkRenderer:
                self.vmtkRenderer = vmtkscripts.vmtkRenderer()
                self.vmtkRenderer.Initialize()
                self.OwnRenderer = 1

            self.vmtkRenderer.RegisterScript(self) 
 
            if not self.ImageSeeder: 
                self.ImageSeeder = vmtkscripts.vmtkImageSeeder()
                self.ImageSeeder.vmtkRenderer = self.vmtkRenderer
                self.ImageSeeder.Image = self.Image
                self.ImageSeeder.Display = 0
                self.ImageSeeder.Execute()
                ##self.ImageSeeder.Display = 1
                self.ImageSeeder.BuildView()
  
            if not self.SurfaceViewer:
                self.SurfaceViewer = vmtkscripts.vmtkSurfaceViewer()
                self.SurfaceViewer.vmtkRenderer = self.vmtkRenderer
  
            initializationMethods = {
                                '0': self.CollidingFrontsInitialize,
                                '1': self.FastMarchingInitialize,
                                '2': self.ThresholdInitialize,
                                '3': self.IsosurfaceInitialize,
                                '4': self.SeedInitialize
                                }
  
            endInitialization = False
            while not endInitialization:
                queryString = 'Please choose initialization type: \n 0: colliding fronts;\n 1: fast marching;\n 2: threshold;\n 3: isosurface;\n 4: seed\n '
                initializationType = self.InputText(queryString,self.InitializationTypeValidator)
                initializationMethods[initializationType]()
                self.DisplayLevelSetSurface(self.InitialLevelSets)
                queryString = 'Accept initialization? (y/n): '
                inputString = self.InputText(queryString,self.YesNoValidator)
                if inputString == 'y':
                    self.MergeLevelSets()
                    self.DisplayLevelSetSurface(self.MergedInitialLevelSets)
                queryString = 'Initialize another branch? (y/n): '
                inputString = self.InputText(queryString,self.YesNoValidator)
                if inputString == 'y':
                    endInitialization = False
                elif inputString == 'n':
                    endInitialization = True

            self.InitialLevelSets = self.MergedInitialLevelSets
            self.MergedInitialLevelSets = None

        else:
            if self.Method == "collidingfronts":
                self.CollidingFrontsInitialize()
            elif self.Method == "fastmarching":
                self.FastMarchingInitialize()
            elif self.Method == "threshold":
                self.ThresholdInitialize()
            elif self.Method == "isosurface":
                self.IsosurfaceInitialize()
            elif self.Method == "seeds":
                self.SeedInitialize()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()
Пример #58
0
    def CollidingFrontsInitialize(self):

        self.PrintLog('Colliding fronts initialization.')

        seedIds1 = vtk.vtkIdList()
        seedIds2 = vtk.vtkIdList()

        if self.Interactive:
            queryString = "Please input lower threshold (\'n\' for none): "
            self.LowerThreshold = self.ThresholdInput(queryString)

            queryString = "Please input upper threshold (\'n\' for none): "
            self.UpperThreshold = self.ThresholdInput(queryString)

            queryString = 'Please place two seeds'
            seeds = self.SeedInput(queryString,2)

            seedIds1.InsertNextId(self.Image.FindPoint(seeds.GetPoint(0)))
            seedIds2.InsertNextId(self.Image.FindPoint(seeds.GetPoint(1)))

        else:
            seedIds1.InsertNextId(self.Image.ComputePointId([self.SourcePoints[0],self.SourcePoints[1],self.SourcePoints[2]]))
            seedIds2.InsertNextId(self.Image.ComputePointId([self.TargetPoints[0],self.TargetPoints[1],self.TargetPoints[2]]))

        scalarRange = self.Image.GetScalarRange()
	
        thresholdedImage = self.Image

        if (self.LowerThreshold is not None) | (self.UpperThreshold is not None):
            threshold = vtk.vtkImageThreshold()
            threshold.SetInputData(self.Image)
            if (self.LowerThreshold is not None) & (self.UpperThreshold is not None):
                threshold.ThresholdBetween(self.LowerThreshold,self.UpperThreshold)
            elif (self.LowerThreshold is not None):
                threshold.ThresholdByUpper(self.LowerThreshold)
            elif (self.UpperThreshold is not None):
                threshold.ThresholdByLower(self.UpperThreshold)
            threshold.ReplaceInOff()
            threshold.ReplaceOutOn()
            threshold.SetOutValue(scalarRange[0] - scalarRange[1])
            threshold.Update()
        
            scalarRange = threshold.GetOutput().GetScalarRange()

            thresholdedImage = threshold.GetOutput()

        scale = 1.0
        if scalarRange[1]-scalarRange[0] > 0.0:
            scale = 1.0 / (scalarRange[1]-scalarRange[0])

        shiftScale = vtk.vtkImageShiftScale()
        shiftScale.SetInputData(thresholdedImage)
        shiftScale.SetShift(-scalarRange[0])
        shiftScale.SetScale(scale)
        shiftScale.SetOutputScalarTypeToFloat()
        shiftScale.Update()
        
        speedImage = shiftScale.GetOutput()

        collidingFronts = vtkvmtk.vtkvmtkCollidingFrontsImageFilter()
        collidingFronts.SetInputData(speedImage)
        collidingFronts.SetSeeds1(seedIds1)
        collidingFronts.SetSeeds2(seedIds2)
        collidingFronts.ApplyConnectivityOn()
        collidingFronts.StopOnTargetsOn()
        collidingFronts.Update()

        subtract = vtk.vtkImageMathematics()
        subtract.SetInputConnection(collidingFronts.GetOutputPort())
        subtract.SetOperationToAddConstant()
        subtract.SetConstantC(-10.0 * collidingFronts.GetNegativeEpsilon())
        subtract.Update()

        self.InitialLevelSets = vtk.vtkImageData()
        self.InitialLevelSets.DeepCopy(subtract.GetOutput())

        self.IsoSurfaceValue = 0.0 
Пример #59
0
    def FastMarchingInitialize(self):

        self.PrintLog('Fast marching initialization.')

        sourceSeedIds = vtk.vtkIdList()
        targetSeedIds = vtk.vtkIdList()
        if self.Interactive:
            queryString = "Please input lower threshold (\'n\' for none): "
            self.LowerThreshold = self.ThresholdInput(queryString)

            queryString = "Please input upper threshold (\'n\' for none): "
            self.UpperThreshold = self.ThresholdInput(queryString)

            queryString = 'Please place source seeds'
            sourceSeeds = self.SeedInput(queryString,0)
            
            queryString = 'Please place target seeds'
            targetSeeds = self.SeedInput(queryString,0)

            for i in range(sourceSeeds.GetNumberOfPoints()):
                sourceSeedIds.InsertNextId(self.Image.FindPoint(sourceSeeds.GetPoint(i)))

            for i in range(targetSeeds.GetNumberOfPoints()):
                targetSeedIds.InsertNextId(self.Image.FindPoint(targetSeeds.GetPoint(i)))

        else:
            for i in range(len(self.SourcePoints)/3):
                sourceSeedIds.InsertNextId(self.Image.ComputePointId([self.SourcePoints[3*i+0],self.SourcePoints[3*i+1],self.SourcePoints[3*i+2]]))
            for i in range(len(self.TargetPoints)/3):
                targetSeedIds.InsertNextId(self.Image.ComputePointId([self.TargetPoints[3*i+0],self.TargetPoints[3*i+1],self.TargetPoints[3*i+2]]))

        scalarRange = self.Image.GetScalarRange()

        thresholdedImage = self.Image
	
        if (self.LowerThreshold is not None) | (self.UpperThreshold is not None):
            threshold = vtk.vtkImageThreshold()
            threshold.SetInputData(self.Image)
            if (self.LowerThreshold is not None) & (self.UpperThreshold is not None):
                threshold.ThresholdBetween(self.LowerThreshold,self.UpperThreshold)
            elif (self.LowerThreshold is not None):
                threshold.ThresholdByUpper(self.LowerThreshold)
            elif (self.UpperThreshold is not None):
                threshold.ThresholdByLower(self.UpperThreshold)
            threshold.ReplaceInOff()
            threshold.ReplaceOutOn()
            threshold.SetOutValue(scalarRange[0] - scalarRange[1])
            threshold.Update()
        
            scalarRange = threshold.GetOutput().GetScalarRange()

            thresholdedImage = threshold.GetOutput()

        scale = 1.0
        if scalarRange[1]-scalarRange[0] > 0.0:
            scale = 1.0 / (scalarRange[1]-scalarRange[0])

        shiftScale = vtk.vtkImageShiftScale()
        shiftScale.SetInputData(thresholdedImage)
        shiftScale.SetShift(-scalarRange[0])
        shiftScale.SetScale(scale)
        shiftScale.SetOutputScalarTypeToFloat()
        shiftScale.Update()
        
        speedImage = shiftScale.GetOutput()

        fastMarching = vtkvmtk.vtkvmtkFastMarchingUpwindGradientImageFilter()
        fastMarching.SetInputData(speedImage)
        fastMarching.SetSeeds(sourceSeedIds)
        fastMarching.GenerateGradientImageOff()
        fastMarching.SetTargetOffset(100.0)
        fastMarching.SetTargets(targetSeedIds)
        if targetSeedIds.GetNumberOfIds() > 0:
            fastMarching.SetTargetReachedModeToOneTarget()
        else:
            fastMarching.SetTargetReachedModeToNoTargets()
        fastMarching.Update()

        subtract = vtk.vtkImageMathematics()
        subtract.SetInputConnection(fastMarching.GetOutputPort())
        subtract.SetOperationToAddConstant()
        subtract.SetConstantC(-fastMarching.GetTargetValue())
        subtract.Update()

        self.InitialLevelSets = vtk.vtkImageData()
        self.InitialLevelSets.DeepCopy(subtract.GetOutput())

        self.IsoSurfaceValue = 0.0