Exemplo n.º 1
0
 def check_volumepro(self):
     try:
         map = vtk.vtkVolumeProMapper()
     except AttributeError:
         return 0
     else:
         return map.GetNumberOfBoards()
Exemplo n.º 2
0
 def set_map_type(self, map_type):
     if map_type == self.map_type:
         return
     Common.state.busy ()
     if map_type == 0:
         self.map = vtk.vtkVolumeRayCastMapper ()
         self.map.SetVolumeRayCastFunction (self.ray_cast_func)
     elif map_type == 1:
         self.map = vtk.vtkVolumeTextureMapper2D()
     elif map_type == 2:
         self.map = vtk.vtkVolumeProMapper()
         self.renwin.get_active_camera().ParallelProjectionOn()
         tkMessageBox.showwarning("Notice!","Camera's projection type set to parallel projection!")
        
     self.map_type = map_type
     self.map.SetInput (self.mod_m.GetOutput ())
     self.act.SetMapper (self.map)
     if self.root and self.root.winfo_exists():
         self.make_map_gui()
         self.make_rcf_gui()
     self.renwin.Render ()     
     Common.state.idle ()            
Exemplo n.º 3
0
    def __init__(self, parent, visualizer, **kws):
        """
		Initialization
		"""
        self.modes = [
            "Ray casting", "Texture mapping", "3D texture mapping",
            "Maximum intensity projection"
        ]
        self.haveVolpro = 0
        self.mapper = None
        conf = Configuration.getConfiguration()

        self.defaultMode = conf.getConfigItem("DefaultVolumeMode", "Rendering")
        if self.defaultMode != None:
            self.defaultMode = int(self.defaultMode)
        else:
            self.defaultMode = RAYCAST

        try:
            volpro = vtk.vtkVolumeProMapper()
            self.haveVolpro = 0
            if volpro.GetNumberOfBoards():
                self.haveVolpro = 1
        except:
            self.haveVolpro = 0
        if self.haveVolpro:
            self.modes.append("Minimum intensity projection")
        self.colorTransferFunction = None
        self.otf, self.otf2 = vtk.vtkPiecewiseFunction(
        ), vtk.vtkPiecewiseFunction()

        otf2 = self.otf2
        otf = self.otf

        otf2.AddPoint(0, 0.0)
        otf2.AddPoint(255, 1.0)
        otf.AddPoint(0, 0.0)
        otf.AddPoint(255, 0.2)

        self.otfs = [self.otf, self.otf, self.otf, self.otf2, self.otf]

        self.volumeProperty = vtk.vtkVolumeProperty()
        self.volume = vtk.vtkVolume()
        self.actor = self.volume
        self.volume.SetProperty(self.volumeProperty)

        VisualizationModule.__init__(self, parent, visualizer, **kws)
        self.mapper = None
        #self.name = "Volume Rendering"
        self.setParameter("Quality", 10)
        self.parameters["Method"] = RAYCAST

        if self.defaultMode != None:
            self.parameters["Method"] = int(self.defaultMode)

        self.volumeProperty.SetScalarOpacity(
            self.otfs[self.parameters["Method"]])

        self.descs = {"Palette": "", "Method": "", "Interpolation": "Interpolation", \
            "NearestNeighbor": "Nearest Neighbour", "Linear": "Linear", \
            "Quality": "", "QualityValue": "Maximum number of planes:", \
            "UseVolumepro": "Use VolumePro acceleration", \
            "UseShading": "Use shading"   }

        self.eventDesc = "Rendering volume"
        self.qualityRange = 0, 10

        self.volumeAdded = False
        self.mapperUpdated = False
        self.setShading(0)

        self.vtkObjects = ["otf", "otf2"]
        #self.updateRendering()
        lib.messenger.connect(None, "switch_datasets", self.onSwitchDatasets)
        self.filterDesc = "Volume render input data"
Exemplo n.º 4
0
    def updateMethod(self):
        """
		Set the Rendering method used
		"""
        self.parameters["QualityValue"] = 0
        if not self.initDone:
            return

        method = self.parameters["Method"]
        self.volumeProperty.SetScalarOpacity(self.otfs[method])
        self.updateOpacityTransferFunction()

        tbl = [
            "Ray cast", "Texture Map", "3D texture map", "MIP", "Isosurface"
        ]
        Logging.info("Volume rendering method: ", tbl[method], kw="rendering")

        #Ray Casting, RGBA Ray Casting, Texture Mapping, MIP
        composites = [
            vtk.vtkVolumeRayCastCompositeFunction, None, None,
            vtk.vtkVolumeRayCastMIPFunction,
            vtk.vtkVolumeRayCastIsosurfaceFunction
        ]
        blendModes = [
            "Composite", "Composite", "Composite", "MaximumIntensity",
            "Composite"
        ]
        if method in [RAYCAST, MIP, ISOSURFACE]:
            # Iso surfacing with fixedpoint mapper is not supported
            if method != ISOSURFACE:
                self.mapper = vtk.vtkFixedPointVolumeRayCastMapper()

                #self.mapper.SetAutoAdjustSampleDistances(1)
                self.sampleDistance = self.mapper.GetSampleDistance()
                #self.volumeProperty.IndependentComponentsOff()
                mode = blendModes[method]
                Logging.info("Setting fixed point rendering mode to ",
                             mode,
                             kw="rendering")
                eval("self.mapper.SetBlendModeTo%s()" % mode)
            else:
                self.mapper = vtk.vtkVolumeRayCastMapper()
                self.function = composites[method]()
                Logging.info("Using ray cast function ",
                             self.function,
                             kw="rendering")
                self.mapper.SetVolumeRayCastFunction(self.function)
        elif method == TEXTURE_MAPPING_3D:  # 3d texture mapping
            self.mapper = vtk.vtkVolumeTextureMapper3D()
            self.sampleDistance = self.mapper.GetSampleDistance()
        elif method == TEXTURE_MAPPING:  # texture mapping
            self.mapper = vtk.vtkVolumeTextureMapper2D()
            self.maxPlanes = self.mapper.GetMaximumNumberOfPlanes()


# changed following because seems like a mistake, 19.7.2007 SS
#		if self.haveVolpro and self.method in [RAYCAST, ISOSURFACE, MIP] and self.parameters["UseVolumepro"]:
        if self.haveVolpro and method in [
                RAYCAST, ISOSURFACE, MIP
        ] and self.parameters["UseVolumepro"]:
            # use volumepro accelerated rendering
            self.mapper = vtk.vtkVolumeProMapper()

            modes = [
                "Composite", None, None, "MaximumIntensity", "MinimumIntensity"
            ]
            acc = modes[method]
            cmd = "self.mapper.SetBlendModeTo%s()" % acc
            Logging.info("Setting blending mode to ", acc, kw="rendering")
            eval(cmd)
            Logging.info("Setting parallel projetion", kw="rendering")
            self.renderer.GetActiveCamera().ParallelProjectionOn()
            #self.settingEdit.Enable(0)
            #self.qualitySlider.Enable(0)
        else:
            self.renderer.GetActiveCamera().ParallelProjectionOff()

        self.mapperUpdated = True
	def __init__(self, parent, visualizer, **kws):
		"""
		Initialization
		"""		
		self.modes = ["Ray casting", "Texture mapping", "3D texture mapping", "Maximum intensity projection"]
		self.haveVolpro = 0
		self.mapper = None
		conf = Configuration.getConfiguration()

		self.defaultMode = conf.getConfigItem("DefaultVolumeMode", "Rendering")
		if self.defaultMode != None:
			self.defaultMode = int(self.defaultMode)
		else:
			self.defaultMode = RAYCAST
		
		try:
			volpro = vtk.vtkVolumeProMapper()
			self.haveVolpro = 0
			if volpro.GetNumberOfBoards():
				self.haveVolpro = 1
		except:
			self.haveVolpro = 0
		if self.haveVolpro:
			self.modes.append("Minimum intensity projection")
		self.colorTransferFunction = None
		self.otf, self.otf2 = vtk.vtkPiecewiseFunction(), vtk.vtkPiecewiseFunction()
	   
		otf2 = self.otf2
		otf = self.otf

		otf2.AddPoint(0, 0.0)
		otf2.AddPoint(255, 1.0)
		otf.AddPoint(0, 0.0)
		otf.AddPoint(255, 0.2)
		
		self.otfs = [self.otf, self.otf, self.otf, self.otf2, self.otf]
		
		self.volumeProperty =  vtk.vtkVolumeProperty()
		self.volume = vtk.vtkVolume()
		self.actor = self.volume
		self.volume.SetProperty(self.volumeProperty)

		VisualizationModule.__init__(self, parent, visualizer, **kws)
		self.mapper = None
		#self.name = "Volume Rendering"
		self.setParameter("Quality", 10)
		self.parameters["Method"] = RAYCAST

		if self.defaultMode != None:
			self.parameters["Method"] = int(self.defaultMode)
 
				   
		self.volumeProperty.SetScalarOpacity(self.otfs[self.parameters["Method"]])
		
		self.descs = {"Palette": "", "Method": "", "Interpolation": "Interpolation", \
						"NearestNeighbor": "Nearest Neighbour", "Linear": "Linear", \
						"Quality": "", "QualityValue": "Maximum number of planes:", \
						"UseVolumepro": "Use VolumePro acceleration", \
						"UseShading": "Use shading"	  }
		
		
		self.eventDesc = "Rendering volume"
		self.qualityRange = 0, 10
			   
		self.volumeAdded = False
		self.mapperUpdated = False
		self.setShading(0)

		self.vtkObjects = ["otf", "otf2"]
		#self.updateRendering()
		lib.messenger.connect(None, "switch_datasets", self.onSwitchDatasets)
		self.filterDesc = "Volume render input data"
	def updateMethod(self):
		"""
		Set the Rendering method used
		"""				
		self.parameters["QualityValue"] = 0
		if not self.initDone:
			return

		method = self.parameters["Method"]
		self.volumeProperty.SetScalarOpacity(self.otfs[method])
		self.updateOpacityTransferFunction()
		
		tbl = ["Ray cast", "Texture Map", "3D texture map", "MIP", "Isosurface"]
		Logging.info("Volume rendering method: ", tbl[method], kw = "rendering")
		
		#Ray Casting, RGBA Ray Casting, Texture Mapping, MIP
		composites = [vtk.vtkVolumeRayCastCompositeFunction,
					  None,
					  None,
					  vtk.vtkVolumeRayCastMIPFunction,
					  vtk.vtkVolumeRayCastIsosurfaceFunction
					  ]
		blendModes = ["Composite", "Composite", "Composite", "MaximumIntensity", "Composite"]
		if method in [RAYCAST, MIP, ISOSURFACE]:
			# Iso surfacing with fixedpoint mapper is not supported
			if method != ISOSURFACE:
				self.mapper = vtk.vtkFixedPointVolumeRayCastMapper()
				
				#self.mapper.SetAutoAdjustSampleDistances(1)
				self.sampleDistance = self.mapper.GetSampleDistance()
				#self.volumeProperty.IndependentComponentsOff()
				mode = blendModes[method]
				Logging.info("Setting fixed point rendering mode to ", mode, kw = "rendering")
				eval("self.mapper.SetBlendModeTo%s()" % mode)
			else:
				self.mapper = vtk.vtkVolumeRayCastMapper()
				self.function = composites[method]()
				Logging.info("Using ray cast function ", self.function, kw = "rendering")
				self.mapper.SetVolumeRayCastFunction(self.function)
		elif method == TEXTURE_MAPPING_3D: # 3d texture mapping
			self.mapper = vtk.vtkVolumeTextureMapper3D()
			self.sampleDistance = self.mapper.GetSampleDistance()
		elif method == TEXTURE_MAPPING: # texture mapping
			self.mapper = vtk.vtkVolumeTextureMapper2D()
			self.maxPlanes = self.mapper.GetMaximumNumberOfPlanes()

# changed following because seems like a mistake, 19.7.2007 SS
#		if self.haveVolpro and self.method in [RAYCAST, ISOSURFACE, MIP] and self.parameters["UseVolumepro"]:
		if self.haveVolpro and method in [RAYCAST, ISOSURFACE, MIP] and self.parameters["UseVolumepro"]:
			# use volumepro accelerated rendering
			self.mapper = vtk.vtkVolumeProMapper()

			modes = ["Composite", None, None, "MaximumIntensity", "MinimumIntensity"]
			acc = modes[method]
			cmd = "self.mapper.SetBlendModeTo%s()" % acc
			Logging.info("Setting blending mode to ", acc, kw = "rendering")
			eval(cmd)
			Logging.info("Setting parallel projetion", kw = "rendering")
			self.renderer.GetActiveCamera().ParallelProjectionOn()			  
			#self.settingEdit.Enable(0)
			#self.qualitySlider.Enable(0)
		else:
			self.renderer.GetActiveCamera().ParallelProjectionOff()		
			
		self.mapperUpdated = True