def __init__(self, level=0, textureFile=TEXTURE, shift=0.5): self.transf = vtk.vtkTransform() self.globe = vtk.vtkTexturedSphereSource() self.texture = vtk.vtkTexture() #self.transf.Scale(0.25, 1., 1.) # may need to shift the picture to match the start longitude self.transf.Translate(shift, 0., 0.) self.texture.SetTransform(self.transf) self.texture.SetInterpolate(1) if re.search(r'jpe?g', textureFile.split('.')[-1]): self.reader = vtk.vtkJPEGReader() elif textureFile.split('.')[-1] == 'png': self.reader = vtk.vtkPNGReader() self.mapper = vtk.vtkPolyDataMapper() self.actor = vtk.vtkActor() # connect self.actor.SetMapper(self.mapper) self.actor.SetTexture(self.texture) self.mapper.SetInputConnection(self.globe.GetOutputPort()) self.texture.SetInputConnection(self.reader.GetOutputPort()) self.reader.SetFileName(textureFile) self.globe.SetThetaResolution(256) self.globe.SetPhiResolution(128) self.globe.SetRadius(1. + 0.01 * level)
def add_eye_ball(self, pose, orientation): # Eye ball sphere = vtk.vtkSphereSource() sphere.SetThetaResolution(64) sphere.SetPhiResolution(64) sphere.SetRadius(0.5) reader = vtk.vtkJPEGReader() reader.SetFileName(os.path.join(rospkg.RosPack().get_path('motion_renderer'), 'resource', 'green_eye.jpg')) texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) map_to_sphere = vtk.vtkTextureMapToSphere() map_to_sphere.SetInputConnection(sphere.GetOutputPort()) map_to_sphere.PreventSeamOn() xform = vtk.vtkTransformTextureCoords() xform.SetInputConnection(map_to_sphere.GetOutputPort()) xform.SetScale(1.5, 1.5, 1) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(xform.GetOutputPort()) # Left Eye Actor eye_actor = vtk.vtkActor() eye_actor.SetMapper(mapper) eye_actor.SetTexture(texture) eye_actor.SetPosition(pose[0], pose[1], pose[2]) eye_actor.RotateX(orientation[0]) eye_actor.RotateY(orientation[1]) eye_actor.RotateZ(orientation[2]) self.ren.AddActor(eye_actor) return eye_actor
def setActorTexture(self, actor, image_path): if actor.__class__ == Billboards.TextBillboard: # text billboards have no texture return if image_path[-4:].lower() == '.jpg' or image_path[-4:].lower( ) == '.jpeg': reader = vtk.vtkJPEGReader() reader.SetFileName(image_path) reader.Update() elif image_path[-4:].lower() == '.png': reader = vtk.vtkPNGReader() reader.SetFileName(image_path) reader.Update() texture = vtk.vtkTexture() texture.RepeatOn() texture.SetInputConnection(reader.GetOutputPort()) actor.SetTexture(texture) # polydata = actor.GetMapper().GetInput() # pointdata = polydata.GetPointData() # celldata = polydata.GetCellData() # numtuples = celldata.GetNumberOfTuples() # numpolygons = polydata.GetNumberOfPolys() self.vtk_interactor.Render()
def __init__(self, module_manager): ModuleBase.__init__(self, module_manager) self._state = STATE_INIT self._config.filename = None self._current_measurement = None # pogo line first # outline of larynx second self._actors = [] # list of pointwidgets, first is apex, second is lm, others # are others. :) self._markers = [] self._pogo_line_source = None self._area_polydata = None self._view_frame = None self._viewer = None self._reader = vtk.vtkJPEGReader() self._create_view_frame() self._bind_events() self.view() # all modules should toggle this once they have shown their # stuff. self.view_initialised = True self.config_to_logic() self.logic_to_config() self.config_to_view()
def showTexture(self): self.reader = vtk.vtkJPEGReader() self.reader.SetFileName(os.path.join(os.path.split(__file__)[0], 'earth.jpg')) self.texture = vtk.vtkTexture() self.texture.SetInput(self.reader.GetOutput()) self.sphere._actor.GetProperty().SetColor(1.0, 1.0, 1.0) self.sphere._actor.SetTexture(self.texture)
def Model(model_path, model_image_path=None): if model_path[-4:].lower() == '.obj': reader = vtk.vtkOBJReader() reader.SetFileName(model_path) reader.Update() polyData = reader.GetOutput() mapper = vtk.vtkPolyDataMapper() mapper.SetInput(polyData) objActor = vtk.vtkActor() objActor.SetMapper(mapper) # texture from image if model_image_path is not None: texture = vtk.vtkTexture() if model_image_path[-4:].lower( ) == '.jpg' or model_image_path[-4:].lower() == '.jpeg': jpgReader = vtk.vtkJPEGReader() jpgReader.SetFileName(model_image_path) jpgReader.Update() texture.SetInputConnection(jpgReader.GetOutputPort()) elif model_image_path[-4:].lower() == '.png': pngReader = vtk.vtkPNGReader() pngReader.SetFileName(model_image_path) pngReader.Update() texture.SetInputConnection(pngReader.GetOutputPort()) objActor.SetTexture(texture) return objActor
def insert_plane(): img = 'floor.jpg' cube_source = vtk.vtkCubeSource() cube_source.SetCenter(0.49, 10, 10) cube_source.SetXLength(0.0010) cube_source.SetYLength(20) cube_source.SetZLength(20) cube_source.Update() reader = vtk.vtkJPEGReader() reader.SetFileName(img) # Create texture object texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) # Map texture coordinates map_to_plane = vtk.vtkTextureMapToPlane() map_to_plane.SetInputConnection(cube_source.GetOutputPort()) # Create mapper and set the mapped texture as input mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(map_to_plane.GetOutputPort()) # Create actor and set the mapper and the texture . uncomment if no texture # mapper = vtk.vtkPolyDataMapper() # mapper.SetInputConnection(cube_source.GetOutputPort()) mapper.Update() actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(texture) return actor
def __init__(self, obj=None): vtk.vtkImageActor.__init__(self) ActorBase.__init__(self) if utils.isSequence(obj) and len(obj): iac = vtk.vtkImageAppendComponents() for i in range(3): #arr = np.flip(np.flip(array[:,:,i], 0), 0).ravel() arr = np.flip(obj[:, :, i], 0).ravel() varb = numpy_to_vtk(arr, deep=True, array_type=vtk.VTK_UNSIGNED_CHAR) imgb = vtk.vtkImageData() imgb.SetDimensions(obj.shape[1], obj.shape[0], 1) imgb.GetPointData().SetScalars(varb) iac.AddInputData(0, imgb) iac.Update() self.SetInputData(iac.GetOutput()) #self.mirror() elif isinstance(obj, str): if ".png" in obj: picr = vtk.vtkPNGReader() elif ".jpg" in obj or ".jpeg" in obj: picr = vtk.vtkJPEGReader() elif ".bmp" in obj: picr = vtk.vtkBMPReader() picr.SetFileName(obj) picr.Update() self.SetInputData(picr.GetOutput())
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkJPEGReader(), 'Reading vtkJPEG.', (), ('vtkJPEG',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def addCube(self,pos,tam,img=False): jpegfile = "struct.jpg" # Read the image data from a file reader = vtk.vtkJPEGReader() reader.SetFileName(jpegfile) (x,y,z) = pos (i,j,k) = tam cubito = vtk.vtkCubeSource() cubito.SetXLength(0.2*i) cubito.SetYLength(0.2*j) cubito.SetZLength(0.2*k) cubito.SetCenter((x,y,z)) if img == True: # Create texture object texture = vtk.vtkTexture() if vtk.VTK_MAJOR_VERSION <= 5: texture.SetInput(reader.GetOutput()) else: texture.SetInputConnection(reader.GetOutputPort()) # Map texture coordinates map_to_sphere = vtk.vtkTextureMapToPlane() if vtk.VTK_MAJOR_VERSION <= 5: map_to_sphere.SetInput(cubito.GetOutput()) else: map_to_sphere.SetInputConnection(cubito.GetOutputPort()) #map_to_sphere.PreventSeamOn() # Create mapper and set the mapped texture as input mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(map_to_sphere.GetOutput()) else: mapper.SetInputConnection(map_to_sphere.GetOutputPort()) planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetInputConnection(cubito.GetOutputPort()) planeActor = (vtk.vtkActor()) if (img == True): planeActor.SetMapper(mapper) else: planeActor.SetMapper(planeMapper)# mapper planeMapper planeActor.DragableOn() planeActor.SetDragable(1) if (img== True): planeActor.SetTexture(texture) else: planeActor.GetProperty().SetColor(.0,.3,.6) planeActor.GetProperty().SetOpacity(0.95) #planeActor.GetProperty().SetAmbient(0) #planeActor.GetProperty().SetDiffuse(0.9) #planeActor.GetProperty().SetSpecular(0.1) self.render.AddActor(planeActor) return planeActor
def __init_renderer(self, list_of_planets): for planet in list_of_planets: actor = vtk.vtkActor() #sphere = vtk.vtkSphereSource() sphere = vtk.vtkTexturedSphereSource() mapper = vtk.vtkPolyDataMapper() sphere.SetPhiResolution(20) sphere.SetThetaResolution(20) scaled_radius = planet.get_radius() * self.__scale_planet_radius if(planet.id == 0): scaled_radius = planet.get_radius() * self.__scale_sun_radius sphere.SetRadius(scaled_radius) mapper.SetInput(sphere.GetOutput()) graphic_name = "../textures/"+planet.get_name()+".jpg" graphic_reader = vtk.vtkJPEGReader() graphic_reader.SetFileName(graphic_name) graphic_texture = vtk.vtkTexture() graphic_texture.SetInputConnection(graphic_reader.GetOutputPort()) graphic_texture.InterpolateOn() actor.SetTexture(graphic_texture) actor.SetMapper(mapper) actor.SetScale(1,1,1) actor.SetPosition(int(self.__scale_planet_orbit_inner*planet.get_posVector_x()), int(self.__scale_planet_orbit_inner*planet.get_posVector_y()), int(self.__scale_planet_orbit_inner*planet.get_posVector_z())) self.__renderer.AddActor(actor) self.__list_of_actors.append(actor)
def create_texture_from_jpeg(jpeg_ifp): reader_jpeg = vtk.vtkJPEGReader() reader_jpeg.SetFileName(jpeg_ifp) reader_jpeg.Update() texture = vtk.vtkTexture() texture.SetInputData(reader_jpeg.GetOutput()) texture.InterpolateOn() return texture
def __init__(self, obj=None): vtk.vtkImageActor.__init__(self) Base3DProp.__init__(self) if utils.isSequence(obj) and len(obj): iac = vtk.vtkImageAppendComponents() nchan = obj.shape[ 2] # get number of channels in inputimage (L/LA/RGB/RGBA) for i in range(nchan): #arr = np.flip(np.flip(array[:,:,i], 0), 0).ravel() arr = np.flip(obj[:, :, i], 0).ravel() varb = numpy_to_vtk(arr, deep=True, array_type=vtk.VTK_UNSIGNED_CHAR) imgb = vtk.vtkImageData() imgb.SetDimensions(obj.shape[1], obj.shape[0], 1) imgb.GetPointData().SetScalars(varb) iac.AddInputData(0, imgb) iac.Update() img = iac.GetOutput() self.SetInputData(img) elif isinstance(obj, vtk.vtkImageData): self.SetInputData(obj) img = obj elif isinstance(obj, str): if "https://" in obj: import vedo.io as io obj = io.download(obj, verbose=False) if ".png" in obj: picr = vtk.vtkPNGReader() elif ".jpg" in obj or ".jpeg" in obj: picr = vtk.vtkJPEGReader() elif ".bmp" in obj: picr = vtk.vtkBMPReader() elif ".tif" in obj: picr = vtk.vtkTIFFReader() else: colors.printc("Cannot understand picture format", obj, c='r') return picr.SetFileName(obj) self.filename = obj picr.Update() img = picr.GetOutput() self.SetInputData(img) else: img = vtk.vtkImageData() self.SetInputData(img) self._data = img sx, sy, _ = img.GetDimensions() self.shape = np.array([sx, sy]) self._mapper = self.GetMapper()
def buildPipeline(self): """ execute() -> None Dispatch the vtkRenderer to the actual rendering widget """ module = self.getRegisteredModule() world_map = None # wmod.forceGetInputFromPort( "world_map", None ) if wmod else None opacity = wmod.forceGetInputFromPort( "opacity", 0.4 ) if wmod else 0.4 map_border_size = wmod.forceGetInputFromPort( "map_border_size", 20 ) if wmod else 20 self.y0 = -90.0 dataPosition = None if world_map == None: self.map_file = defaultMapFile self.map_cut = defaultMapCut else: self.map_file = world_map[0].name self.map_cut = world_map[1] self.world_cut = wmod.forceGetInputFromPort( "world_cut", -1 ) if wmod else getFunctionParmStrValues( module, "world_cut", -1 ) roi_size = [ self.roi[1] - self.roi[0], self.roi[3] - self.roi[2] ] map_cut_size = [ roi_size[0] + 2*map_border_size, roi_size[1] + 2*map_border_size ] data_origin = self.input().GetOrigin() if self.input() else [ 0, 0, 0 ] if self.world_cut == -1: if (self.roi <> None): if roi_size[0] > 180: self.ComputeCornerPosition() self.world_cut = NormalizeLon( self.x0 ) else: dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ] else: self.world_cut = self.map_cut self.imageInfo = vtk.vtkImageChangeInformation() image_reader = vtk.vtkJPEGReader() image_reader.SetFileName( self.map_file ) baseImage = image_reader.GetOutput() new_dims = None if dataPosition == None: baseImage = self.RollMap( baseImage ) new_dims = baseImage.GetDimensions() else: baseImage, new_dims = self.getBoundedMap( baseImage, dataPosition, map_cut_size ) scale = [ map_cut_size[0]/new_dims[0], map_cut_size[1]/new_dims[1], 1 ] # printArgs( " baseMap: ", extent=baseImage.GetExtent(), spacing=baseImage.GetSpacing(), origin=baseImage.GetOrigin() ) self.baseMapActor = vtk.vtkImageActor() self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 ) self.baseMapActor.SetScale( scale ) self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 ) self.baseMapActor.SetOpacity( opacity ) # self.baseMapActor.SetDisplayExtent( -1, 0, 0, 0, 0, 0 ) #Positioning map at location %s, size = %s, roi = %s" % ( str( ( self.x0, self.y0) ), str( map_cut_size ), str( ( NormalizeLon( self.roi[0] ), NormalizeLon( self.roi[1] ), self.roi[2], self.roi[3] ) ) ) self.baseMapActor.SetPosition( self.x0, self.y0, 0.1 ) self.baseMapActor.SetInput( baseImage ) self.renderer.AddActor( self.baseMapActor )
def get_texture(): """ Get texture from jpeg image """ reader = vtk.vtkJPEGReader() reader.SetFileName(TEXTURE_IMG) texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) return texture
def __init__(self): # ODE initialization self.world = ode.World() self.world.setGravity(GRAVITY) self.world.setERP(ERP) self.world.setCFM(CFM) self.space = ode.Space() self.floor = ode.GeomPlane(self.space, (0.0,1.0,0.0), 0.0) self.jointGroup = ode.JointGroup() self.time = 0.0 # VTK initialization self.renderer = vtk.vtkRenderer() self.renderer.SetBackground(102.0/255.0,204/255.0,1.0) self.window = vtk.vtkRenderWindow() self.window.SetSize(WINDOW_WIDTH,WINDOW_HEIGHT) self.window.AddRenderer(self.renderer) self.interactor = vtk.vtkRenderWindowInteractor() self.interactor.SetRenderWindow(self.window) self.axes = vtk.vtkAxesActor() self.axes.SetAxisLabels(0) transform = vtk.vtkTransform() transform.Scale(0.1,0.1,0.1) self.axes.SetUserTransform(transform) self.renderer.AddActor(self.axes) # Create ground plane visualization self.floorVisual = vtk.vtkPlaneSource() self.floorVisual.SetNormal((0.0,1.0,0.0)) self.floorVisual.SetResolution(10,10) self.floorReader = vtk.vtkJPEGReader() self.floorReader.SetFileName(FLOOR_IMAGE) self.floorTexture = vtk.vtkTexture() transform = vtk.vtkTransform() transform.Scale(50.0,50.0,50.0) self.floorTexture.SetTransform(transform) self.floorTexture.SetInput(self.floorReader.GetOutput()) self.floorMap = vtk.vtkTextureMapToPlane() self.floorMap.SetInput(self.floorVisual.GetOutput()) self.floorMapper = vtk.vtkPolyDataMapper() self.floorMapper.SetInput(self.floorMap.GetOutput()) self.floorActor = vtk.vtkActor() transform = vtk.vtkTransform() transform.Scale(100.0,100.0,100.0) self.floorActor.SetUserTransform(transform) self.floorActor.SetMapper(self.floorMapper) self.floorActor.SetTexture(self.floorTexture) self.renderer.AddActor(self.floorActor) # VTK camera setup self.camera = vtk.vtkCamera() self.renderer.SetActiveCamera(self.camera) self.cameraFocus = [0.0, 0.0, 0.0] self.cameraPos = [4.0, 2.5, 1.5] self.cameraOffset = [0.0,1.0,3.0] self.cameraRoll = 0.0 # Keep track of the simulated bodies and robots self.bodies = [] self.robots = [] self.controllers = []
def __init__(self, obj=None, channels=(), flip=False): vtk.vtkImageActor.__init__(self) vedo.base.Base3DProp.__init__(self) if utils.isSequence(obj) and len(obj): # passing array img = _get_img(obj, flip) elif isinstance(obj, vtk.vtkImageData): img = obj elif isinstance(obj, str): if "https://" in obj: obj = vedo.io.download(obj, verbose=False) fname = obj.lower() if fname.endswith(".png"): picr = vtk.vtkPNGReader() elif fname.endswith(".jpg") or fname.endswith(".jpeg"): picr = vtk.vtkJPEGReader() elif fname.endswith(".bmp"): picr = vtk.vtkBMPReader() elif fname.endswith(".tif") or fname.endswith(".tiff"): picr = vtk.vtkTIFFReader() picr.SetOrientationType(vedo.settings.tiffOrientationType) else: colors.printc("Cannot understand picture format", obj, c='r') return picr.SetFileName(obj) self.filename = obj picr.Update() img = picr.GetOutput() else: img = vtk.vtkImageData() # select channels nchans = len(channels) if nchans and img.GetPointData().GetScalars().GetNumberOfComponents() > nchans: pec = vtk.vtkImageExtractComponents() pec.SetInputData(img) if nchans == 3: pec.SetComponents(channels[0], channels[1], channels[2]) elif nchans == 2: pec.SetComponents(channels[0], channels[1]) elif nchans == 1: pec.SetComponents(channels[0]) pec.Update() img = pec.GetOutput() self._data = img self.SetInputData(img) sx,sy,_ = img.GetDimensions() self.shape = np.array([sx,sy]) self._mapper = self.GetMapper()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkJPEGReader(), 'Reading vtkJPEG.', (), ('vtkJPEG', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def FileExtensionsDescriptor(cls): # cheap way #return 'JPEG Images|*.jpg;*.jpeg;*.JPG;*.JPEG' # dynamic way descriptor = 'JPEG Images' extensions = vtk.vtkJPEGReader().GetFileExtensions().split(' ') extensions.extend([item.upper() for item in extensions]) extensions = ['*'+item for item in extensions] return '|'.join([descriptor, ';'.join(extensions)])
def build( self, **args ): if self.enableBasemap: # print " @@@ MapManager: build " world_map = None dataPosition = None if world_map == None: self.map_file = defaultMapFile self.map_cut = defaultMapCut else: self.map_file = world_map[0].name self.map_cut = world_map[1] # data_origin = self.input().GetOrigin() if self.input() else [ 0, 0, 0 ] if self.world_cut == -1: if (self.roi <> None): if self.roi_size[0] > 180: self.ComputeCornerPosition() self.world_cut = self.NormalizeMapLon( self.x0 ) else: dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ] else: self.world_cut = self.map_cut self.imageInfo = vtk.vtkImageChangeInformation() self.image_reader = vtk.vtkJPEGReader() self.image_reader.SetFileName( self.map_file ) self.image_reader.Update() world_image = self.image_reader.GetOutput() self.sphericalBaseImage = self.RollMap( world_image ) new_dims, scale = None, None if dataPosition == None: self.baseImage = self.RollMap( world_image ) new_dims = self.baseImage.GetDimensions() scale = [ 360.0/new_dims[0], 180.0/new_dims[1], 1 ] self.width = 360.0 else: self.baseImage, new_dims = self.getBoundedMap( world_image, dataPosition ) scale = [ self.map_cut_size[0]/new_dims[0], self.map_cut_size[1]/new_dims[1], 1 ] self.width = self.map_cut_size[0] self.baseMapActor = vtk.vtkImageActor() self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 ) self.baseMapActor.SetScale( scale ) self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 ) self.baseMapActor.SetOpacity( self.map_opacity ) mapCorner = [ self.x0, self.y0 ] self.baseMapActor.SetPosition( mapCorner[0], mapCorner[1], 0.05 ) extent = self.baseImage.GetExtent() # print " @@@ baseImage.GetExtent: ", str( extent ) # print " @@@ baseImage.Position: ", str( self.x0 ) # print " @@@ baseImage.Size: ", str( self.map_cut_size ) if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(self.baseImage) else: self.baseMapActor.SetInputData(self.baseImage) self.mapCenter = [ self.x0 + self.map_cut_size[0]/2.0, self.y0 + self.map_cut_size[1]/2.0 ]
def build( self, **args ): if self.enableBasemap: # print " @@@ MapManager: build " world_map = None dataPosition = None if world_map == None: self.map_file = defaultMapFile self.map_cut = defaultMapCut else: self.map_file = world_map[0].name self.map_cut = world_map[1] # data_origin = self.input().GetOrigin() if self.input() else [ 0, 0, 0 ] if self.world_cut == -1: if (self.roi <> None): if self.roi_size[0] > 180: self.ComputeCornerPosition() self.world_cut = self.NormalizeMapLon( self.x0 ) else: dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ] else: self.world_cut = self.map_cut self.imageInfo = vtk.vtkImageChangeInformation() self.image_reader = vtk.vtkJPEGReader() self.image_reader.SetFileName( self.map_file ) self.image_reader.Update() world_image = self.image_reader.GetOutput() self.sphericalBaseImage = self.RollMap( world_image ) new_dims, scale = None, None if dataPosition == None: self.baseImage = self.RollMap( world_image ) new_dims = self.baseImage.GetDimensions() scale = [ 360.0/new_dims[0], 180.0/new_dims[1], 1 ] self.width = 360.0 else: self.baseImage, new_dims = self.getBoundedMap( world_image, dataPosition ) scale = [ self.map_cut_size[0]/new_dims[0], self.map_cut_size[1]/new_dims[1], 1 ] self.width = self.map_cut_size[0] self.baseMapActor = vtk.vtkImageActor() self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 ) self.baseMapActor.SetScale( scale ) self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 ) self.baseMapActor.SetOpacity( self.map_opacity ) mapCorner = [ self.x0, self.y0 ] self.baseMapActor.SetPosition( mapCorner[0], mapCorner[1], 0.1 ) extent = self.baseImage.GetExtent() # print " @@@ baseImage.GetExtent: ", str( extent ) # print " @@@ baseImage.Position: ", str( self.x0 ) # print " @@@ baseImage.Size: ", str( self.map_cut_size ) if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(self.baseImage) else: self.baseMapActor.SetInputData(self.baseImage) self.mapCenter = [ self.x0 + self.map_cut_size[0]/2.0, self.y0 + self.map_cut_size[1]/2.0 ]
def GenerateImageReader(self, file_type): if file_type == "png": png_reader = vtk.vtkPNGReader() return png_reader elif file_type == "jpg" or file_type == "jpeg": jpeg_reader = vtk.vtkJPEGReader() return jpeg_reader else: raise TypeError()
def build( self, **args ): if self.enableBasemap: world_map = None dataPosition = None if world_map == None: self.map_file = defaultMapFile self.map_cut = defaultMapCut else: self.map_file = world_map[0].name self.map_cut = world_map[1] roi_size = [ self.roi[1] - self.roi[0], self.roi[3] - self.roi[2] ] map_cut_size = [ roi_size[0] + 2*self.map_border_size, roi_size[1] + 2*self.map_border_size ] if map_cut_size[0] > 360.0: map_cut_size[0] = 360.0 if map_cut_size[1] > 180.0: map_cut_size[1] = 180.0 # data_origin = self.input().GetOrigin() if self.input() else [ 0, 0, 0 ] if self.world_cut == -1: if (self.roi <> None): if roi_size[0] > 180: self.ComputeCornerPosition() self.world_cut = self.NormalizeMapLon( self.x0 ) else: dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ] else: self.world_cut = self.map_cut self.imageInfo = vtk.vtkImageChangeInformation() self.image_reader = vtk.vtkJPEGReader() self.image_reader.SetFileName( self.map_file ) self.image_reader.Update() world_image = self.image_reader.GetOutput() self.sphericalBaseImage = self.RollMap( world_image ) new_dims, scale = None, None if dataPosition == None: self.baseImage = self.RollMap( world_image ) new_dims = self.baseImage.GetDimensions() scale = [ 360.0/new_dims[0], 180.0/new_dims[1], 1 ] else: self.baseImage, new_dims = self.getBoundedMap( world_image, dataPosition, map_cut_size, self.map_border_size ) scale = [ map_cut_size[0]/new_dims[0], map_cut_size[1]/new_dims[1], 1 ] self.baseMapActor = vtk.vtkImageActor() self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 ) self.baseMapActor.SetScale( scale ) self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 ) self.baseMapActor.SetOpacity( self.map_opacity ) mapCorner = [ self.x0, self.y0 ] self.baseMapActor.SetPosition( mapCorner[0], mapCorner[1], 0.1 ) if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(self.baseImage) else: self.baseMapActor.SetInputData(self.baseImage) self.mapCenter = [ self.x0 + map_cut_size[0]/2.0, self.y0 + map_cut_size[1]/2.0 ]
def VtkRead(filepath, t): if not const.VTK_WARNING: log_path = os.path.join(const.USER_LOG_DIR, 'vtkoutput.txt') fow = vtk.vtkFileOutputWindow() fow.SetFileName(log_path.encode(const.FS_ENCODE)) ow = vtk.vtkOutputWindow() ow.SetInstance(fow) global no_error if t == "bmp": reader = vtk.vtkBMPReader() elif t == "tiff" or t == "tif": reader = vtk.vtkTIFFReader() elif t == "png": reader = vtk.vtkPNGReader() elif t == "jpeg" or t == "jpg": reader = vtk.vtkJPEGReader() else: return False print ">>>> bmp reader", type(filepath) reader.AddObserver("ErrorEvent", VtkErrorToPy) reader.SetFileName(filepath.encode(const.FS_ENCODE)) reader.Update() if no_error: image = reader.GetOutput() dim = image.GetDimensions() if reader.GetNumberOfScalarComponents() > 1: luminanceFilter = vtk.vtkImageLuminance() luminanceFilter.SetInputData(image) luminanceFilter.Update() image = vtk.vtkImageData() image.DeepCopy(luminanceFilter.GetOutput()) img_array = numpy_support.vtk_to_numpy( image.GetPointData().GetScalars()) img_array.shape = (dim[1], dim[0]) return img_array else: no_error = True return False
def TexturedQuad(numpy_array, image_path): if np.shape(numpy_array)[0] == 3: numpy_array = np.transpose(numpy_array) if image_path[-4:].lower() == '.jpg' or image_path[-4:].lower() == '.jpeg': reader = vtk.vtkJPEGReader() reader.SetFileName(image_path) reader.Update() elif image_path[-4:].lower() == '.png': reader = vtk.vtkPNGReader() reader.SetFileName(image_path) reader.Update() texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) points = vtk.vtkPoints() points.SetNumberOfPoints(4) points.SetData(nps.numpy_to_vtk(numpy_array, deep=1)) quad = vtk.vtkQuad() quad.GetPointIds().SetId(0, 0) quad.GetPointIds().SetId(1, 1) quad.GetPointIds().SetId(2, 2) quad.GetPointIds().SetId(3, 3) quads = vtk.vtkCellArray() quads.InsertNextCell(quad) polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.SetPolys(quads) texCoords = vtk.vtkFloatArray() texCoords.SetNumberOfComponents(2) texCoords.SetName("TextureCoordinates") texCoords.InsertNextTuple((0.0, 0.0)) texCoords.InsertNextTuple((1.0, 0.0)) texCoords.InsertNextTuple((1.0, 1.0)) texCoords.InsertNextTuple((0.0, 1.0)) polydata.GetPointData().SetTCoords(texCoords) mapper = vtk.vtkDataSetMapper() mapper.SetInput(polydata) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(texture) return actor
def floor(): plane = vtk.vtkPlaneSource() reader = vtk.vtkJPEGReader() reader.SetFileName(pkg_resources.resource_filename("robopy", "media/imgs/floor.jpg")) texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) map_to_plane = vtk.vtkTextureMapToPlane() map_to_plane.SetInputConnection(plane.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(map_to_plane.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(texture) return actor
def VtkRead(filepath, t): if not const.VTK_WARNING: log_path = os.path.join(inv_paths.USER_LOG_DIR, 'vtkoutput.txt') fow = vtk.vtkFileOutputWindow() fow.SetFileName(log_path.encode(const.FS_ENCODE)) ow = vtk.vtkOutputWindow() ow.SetInstance(fow) global no_error if t == "bmp": reader = vtk.vtkBMPReader() elif t == "tiff" or t == "tif": reader = vtk.vtkTIFFReader() elif t == "png": reader = vtk.vtkPNGReader() elif t == "jpeg" or t == "jpg": reader = vtk.vtkJPEGReader() else: return False reader.AddObserver("ErrorEvent", VtkErrorToPy) reader.SetFileName(filepath) reader.Update() if no_error: image = reader.GetOutput() dim = image.GetDimensions() if reader.GetNumberOfScalarComponents() > 1: luminanceFilter = vtk.vtkImageLuminance() luminanceFilter.SetInputData(image) luminanceFilter.Update() image = vtk.vtkImageData() image.DeepCopy(luminanceFilter.GetOutput()) img_array = numpy_support.vtk_to_numpy(image.GetPointData().GetScalars()) img_array.shape = (dim[1], dim[0]) return img_array else: no_error = True return False
def main(): colors = vtk.vtkNamedColors() jpegfile = get_program_parameters() # Create a render window ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(480, 480) renWin.SetWindowName('SphereTexture') iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Generate an sphere polydata sphere = vtk.vtkSphereSource() sphere.SetThetaResolution(12) sphere.SetPhiResolution(12) # Read the image data from a file reader = vtk.vtkJPEGReader() reader.SetFileName(jpegfile) # Create texture object texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) # Map texture coordinates map_to_sphere = vtk.vtkTextureMapToSphere() map_to_sphere.SetInputConnection(sphere.GetOutputPort()) map_to_sphere.PreventSeamOn() # Create mapper and set the mapped texture as input mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(map_to_sphere.GetOutputPort()) # Create actor and set the mapper and the texture actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(texture) ren.AddActor(actor) ren.SetBackground(colors.GetColor3d('RosyBrown')) iren.Initialize() renWin.Render() iren.Start()
def createButtonRepresentation(self, **args): self.buttonRepresentation = vtk.vtkTexturedButtonRepresentation2D() self.buttonRepresentation.SetPlaceFactor( args.get( 'scale', 1 ) ) self.numberOfImages = len( self.names ) if self.numberOfImages: self.buttonRepresentation.SetNumberOfStates(self.numberOfImages) for button_index in range( self.numberOfImages ): buttonFilePath = os.path.join( ButtonDir, '.'.join( [ self.names[ button_index ], 'jpeg' ] ) ) JPEGReader = vtk.vtkJPEGReader() JPEGReader.SetFileName ( buttonFilePath ) JPEGReader.Update() image_data = JPEGReader.GetOutput() if self.image_size == None: self.image_size = image_data.GetDimensions() self.buttonRepresentation.SetButtonTexture( button_index, image_data ) self.button_files.append( buttonFilePath ) self.setToggleProps()
def set_texture(self, filename): """ Sets an image from a file as a texture for the model. :param filename: :return: """ # Read the texture image from a file. # Currently supports png and jpeg formats. if filename is not None: vf.validate_is_file(filename) if filename.endswith('.png'): self.texture_reader = vtk.vtkPNGReader() elif np.logical_or(filename.endswith('.jpeg'), filename.endswith('.jpg')): self.texture_reader = vtk.vtkJPEGReader() else: raise ValueError( 'File type not supported for texture loading: {}'.format( filename)) else: # Unset texture when the function is called with None. self.texture_reader = None self.texture_file = None self.texture_name = None self.texture = None self.actor.SetTexture(None) return self.texture_reader.SetFileName(filename) self.texture_file = filename self.texture_name = os.path.basename(self.texture_file) # Create texture object. self.texture = vtk.vtkTexture() if vtk.VTK_MAJOR_VERSION <= 5: self.texture.SetInput(self.texture_reader.GetOutput()) else: self.texture.SetInputConnection( self.texture_reader.GetOutputPort()) # Set the texture self.actor.SetTexture(self.texture)
def __init__(self, obj=None): vtk.vtkImageActor.__init__(self) ActorBase.__init__(self) if utils.isSequence(obj) and len(obj): iac = vtk.vtkImageAppendComponents() for i in range(3): #arr = np.flip(np.flip(array[:,:,i], 0), 0).ravel() arr = np.flip(obj[:, :, i], 0).ravel() varb = numpy_to_vtk(arr, deep=True, array_type=vtk.VTK_UNSIGNED_CHAR) imgb = vtk.vtkImageData() imgb.SetDimensions(obj.shape[1], obj.shape[0], 1) imgb.GetPointData().SetScalars(varb) iac.AddInputData(0, imgb) iac.Update() img = iac.GetOutput() self.SetInputData(img) elif isinstance(obj, vtk.vtkImageData): self.SetInputData(obj) img = obj elif isinstance(obj, str): if ".png" in obj: picr = vtk.vtkPNGReader() elif ".jpg" in obj or ".jpeg" in obj: picr = vtk.vtkJPEGReader() elif ".bmp" in obj: picr = vtk.vtkBMPReader() elif ".tif" in obj: picr = vtk.vtkTIFFReader() else: colors.printc("Cannot understand picture format", obj, c=1) picr.SetFileName(obj) picr.Update() img = picr.GetOutput() self.SetInputData(img) else: img = vtk.vtkImageData() self.SetInputData(img) self._imagedata = img self._mapper = self.GetMapper()
def load2Dimage(filename, alpha=1): fl = filename.lower() if '.png' in fl: picr = vtk.vtkPNGReader() elif '.jpg' in fl or '.jpeg' in fl: picr = vtk.vtkJPEGReader() else: print('file must end with .png or .jpg') exit(1) picr.SetFileName(filename) picr.Update() vactor = ImageActor() #vtk.vtkImageActor() vactor.SetInputData(picr.GetOutput()) if alpha is None: alpha = 1 vactor.SetOpacity(alpha) return vactor
def floor(): plane = vtk.vtkPlaneSource() reader = vtk.vtkJPEGReader() reader.SetFileName( pkg_resources.resource_filename( __name__, '/'.join(('media', 'imgs', 'floor.jpg')))) texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) map_to_plane = vtk.vtkTextureMapToPlane() map_to_plane.SetInputConnection(plane.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(map_to_plane.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(texture) return actor
def load2Dimage(filename, alpha): fl = filename.lower() if '.png' in fl: picr = vtk.vtkPNGReader() elif '.jpg' in fl or '.jpeg' in fl: picr = vtk.vtkJPEGReader() else: print('file must end with .png or .jpg') exit(1) picr.SetFileName(filename) picr.Update() vactor = vtk.vtkImageActor() vu.setInput(vactor, picr.GetOutput()) vactor.SetOpacity(alpha) vu.assignConvenienceMethods(vactor, False) vu.assignPhysicsMethods(vactor) return vactor
def createButtonRepresentation(self, **args): self.buttonRepresentation = vtk.vtkTexturedButtonRepresentation2D() self.buttonRepresentation.SetPlaceFactor( args.get( 'scale', 1 ) ) if self.names[0] == "Run": print "." self.numberOfImages = len( self.names ) if self.numberOfImages: self.buttonRepresentation.SetNumberOfStates(self.numberOfImages) for button_index in range( self.numberOfImages ): buttonFilePath = os.path.join( ButtonDir, '.'.join( [ self.names[ button_index ], 'jpeg' ] ) ) JPEGReader = vtk.vtkJPEGReader() JPEGReader.SetFileName ( buttonFilePath ) JPEGReader.Update() image_data = JPEGReader.GetOutput() if self.image_size == None: self.image_size = image_data.GetDimensions() self.buttonRepresentation.SetButtonTexture( button_index, image_data ) self.button_files.append( buttonFilePath ) self.setToggleProps()
def assignTexture(actor, name, scale=1, falsecolors=False, mapTo=1): '''Assign a texture to actor from file or name in /textures directory''' if mapTo == 1: tmapper = vtk.vtkTextureMapToCylinder() elif mapTo == 2: tmapper = vtk.vtkTextureMapToSphere() elif mapTo == 3: tmapper = vtk.vtkTextureMapToPlane() setInput(tmapper, polydata(actor)) if mapTo == 1: tmapper.PreventSeamOn() xform = vtk.vtkTransformTextureCoords() xform.SetInputConnection(tmapper.GetOutputPort()) xform.SetScale(scale, scale, scale) if mapTo == 1: xform.FlipSOn() xform.Update() mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(xform.GetOutputPort()) mapper.ScalarVisibilityOff() cdir = os.path.dirname(__file__) if cdir == '': cdir = '.' fn = cdir + '/textures/' + name + ".jpg" if os.path.exists(name): fn = name elif not os.path.exists(fn): colors.printc(('Texture', name, 'not found in', cdir + '/textures'), 'r') colors.printc('Available textures:', c='m', end=' ') for ff in os.listdir(cdir + '/textures'): colors.printc(ff.split('.')[0], end=' ', c='m') print() return jpgReader = vtk.vtkJPEGReader() jpgReader.SetFileName(fn) atext = vtk.vtkTexture() atext.RepeatOn() atext.EdgeClampOff() atext.InterpolateOn() if falsecolors: atext.MapColorScalarsThroughLookupTableOn() atext.SetInputConnection(jpgReader.GetOutputPort()) actor.GetProperty().SetColor(1, 1, 1) actor.SetMapper(mapper) actor.SetTexture(atext)
def __init__(self, imagepath, center=[0, 0, 0], direction=[0, 0, 1], kernel=4): """ Class initialization :@param imagepath: path to the source image to be used as a textures :@param center: coordinates of the center of the plane :@param direction: normal to the plane :@param kernel: number of tiles per row. Will create kernel squared tiles """ self.path = imagepath self.sources = [] self.reader = vtk.vtkJPEGReader() self.reader.SetFileName(self.path) self.reader.Update() self.img = cv2.imread(self.path) self.h, self.w = self.img.shape[:2] self.VOIs = [] self.textures = [] self.textMappers = [] self.mappers = [] self.actors = [] self.center = center self.direction = direction self.T = np.eye(4) R_2vect(self.T, [0, 0, 1], self.direction) self.T[0, 3] = self.center[0] self.T[1, 3] = self.center[1] self.T[2, 3] = self.center[2] self.transform = vtk.vtkTransform() self.transform.SetMatrix(StoreAsMatrix4x4(self.T)) self.createTexture(kernel)
def get_background_render(image_path): # Read the image jpeg_reader = vtk.vtkJPEGReader() assert jpeg_reader.CanReadFile( image_path), "Error reading file %s" % image_path jpeg_reader.SetFileName(image_path) jpeg_reader.Update() image_data = jpeg_reader.GetOutput() # Create an image actor to display the image image_actor = vtk.vtkImageActor() image_actor.SetInputData(image_data) # Create a renderer to display the image in the background background_renderer = vtk.vtkRenderer() background_renderer.AddActor(image_actor) return image_data, background_renderer
def main(): filename = get_program_parameters() # Read the image jpeg_reader = vtk.vtkJPEGReader() jpeg_reader.SetFileName(filename) # Visualize image_viewer = vtk.vtkImageViewer2() image_viewer.SetInputConnection(jpeg_reader.GetOutputPort()) render_window_interactor = vtk.vtkRenderWindowInteractor() image_viewer.SetupInteractor(render_window_interactor) image_viewer.Render() image_viewer.GetRenderer().ResetCamera() image_viewer.Render() render_window_interactor.Start()
def __init__(self): self.sceneSources = list() self.sceneMappers = list() self.sceneActors = list() self.sceneLights = list() self.sceneSources.append(vtk.vtkCubeSource()) self.sceneSources[-1].SetXLength(10000) self.sceneSources[-1].SetYLength(10000) self.sceneSources[-1].SetZLength(5) # self.sceneMappers.append(vtk.vtkPolyDataMapper()) # self.sceneMappers[-1].SetInputConnection(self.sceneSources[-1].GetOutputPort()) reader = vtk.vtkJPEGReader() reader.SetFileName("blackandwhite.jpg") #reader.SetFileName("white.jpg") # Create texture object texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) texture.RepeatOn() #Map texture coordinates map_to_plane = vtk.vtkTextureMapToPlane() map_to_plane.SetInputConnection(self.sceneSources[-1].GetOutputPort()) # Create mapper and set the mapped texture as input mapperplane = vtk.vtkPolyDataMapper() mapperplane.SetInputConnection(map_to_plane.GetOutputPort()) self.sceneActors.append(vtk.vtkActor()) self.sceneActors[-1].RotateX(90) self.sceneActors[-1].SetPosition(0, -800, 0) self.sceneActors[-1].SetMapper(mapperplane) self.sceneActors[-1].SetTexture(texture) # self.sceneActors[-1].GetProperty().SetColor(1,1,1) self.addLight(1.0, 1.0, 1.0, 1000, 1000, -1000, 0.75, 180, 0.75) self.addLight(1.0, 1.0, 1.0, -1000, 500, 1000, 0.5, 180, 0.0) self.addLight(1.0, 1.0, 1.0, -1000, 500, -1000, 0.5, 180, 0.0)
def main(): # Parse input arguments inputFilename = 'Bunny.jpg' #IMREAD_COLOR sets to BGR mode img = cv.imread(inputFilename, cv.IMREAD_COLOR) # Read the image reader = vtk.vtkJPEGReader() reader.SetFileName(inputFilename) reader.Update() otherreader = vtk.vtkImageData() #fromMat2Vtk (input, otherreader) # Create an actor actor = vtk.vtkImageActor() #actor.GetMapper().SetInputConnection(reader.GetOutputPort()) actor.GetMapper().SetInputData(fromMat2Vtk(img)) # Setup renderer colors = vtk.vtkNamedColors() renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.ResetCamera() #renderer.SetBackground(colors.GetColor3d("Burlywood").GetData()) # Setup render window window = vtk.vtkRenderWindow() window.AddRenderer(renderer) # Setup render window interactor interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(window) # Setup interactor style (this is what implements the zooming, panning and brightness adjustment functionality) style = vtk.vtkInteractorStyleImage() interactor.SetInteractorStyle(style) # Render and start interaction interactor.Start()
def make_texture_overly_object(self): input_image = self.session.overlay_image_fname reader = vtk.vtkJPEGReader() reader.SetFileName(input_image) texture = vtk.vtkTexture() texture.SetInput(reader.GetOutput()) texture.SetInputConnection(reader.GetOutputPort()) texture.InterpolateOn() plane = vtk.vtkPlaneSource() plane.SetOrigin((0, 0, 0)) plane.SetPoint1(self.bounds.lat_max_distance) plane.SetPoint2(self.bounds.long_max_distance) planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetInputConnection(plane.GetOutputPort()) self.overlayActor = vtk.vtkActor() self.overlayActor.SetMapper(planeMapper) self.overlayActor.SetTexture(texture) self.actors.append(self.overlayActor)
def addLogo(self): if self.logoRepresentation == None: defaultLogoFile = os.path.join(sys.prefix,"share","vcs","uvcdat.png") reader = vtk.vtkJPEGReader() reader.SetFileName( defaultLogoFile ) reader.Update() logo_input = reader.GetOutput() self.logoRepresentation = vtk.vtkLogoRepresentation() self.logoRepresentation.SetImage(logo_input) self.logoRepresentation.ProportionalResizeOn () # self.logoRepresentation.SetPosition( 0.82, 0.0 ) # self.logoRepresentation.SetPosition2( 0.18, 0.08 ) self.logoRepresentation.SetPosition( 0.82, 1.0 ) self.logoRepresentation.SetPosition2( 0.08, 0.18 ) self.logoRepresentation.GetImageProperty().SetOpacity( 0.9 ) self.logoRepresentation.GetImageProperty().SetDisplayLocationToBackground() self.logoWidget = vtk.vtkLogoWidget() self.logoWidget.SetInteractor( self.renderWindowInteractor ) self.logoWidget.SetRepresentation(self.logoRepresentation) self.logoWidget.On() self.render()
def __init__(self, renderer, parent, screenDistance, width, height, isActiveCamera = False): ''' Initialize the CameraScreen model. If you are going to stream data to it, set isActiveCamera to true in the constructor parameters and pass jpeg data to the update method. ''' # Call the parent constructor super(CameraScreen,self).__init__(renderer, parent) # Create a plane for the camera # Ref: http://www.vtk.org/doc/nightly/html/classvtkPlaneSource.html planeSource = vtk.vtkPlaneSource() # Defaults work for this, so just push it out a bit #planeSource.Push(screenDistance) # Transform scale it to the right size trans = vtk.vtkTransform() trans.Scale(width, height, 1) trans.Translate(0, 0, screenDistance) trans.RotateY(180) # Effectively flipping the UV (texture) mapping so that the video isn't left/right flipped transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(planeSource.GetOutputPort()) transF.SetTransform(trans) # Create a test picture and assign it to the screen for now... # Ref: http://vtk.org/gitweb?p=VTK.git;a=blob;f=Examples/Rendering/Python/TPlane.py if not isActiveCamera: self.__textReader = vtk.vtkPNGReader() self.__textReader.SetFileName("../scene/media/semisortedcameralogo.png") else: self.__textReader = vtk.vtkJPEGReader() self.cameraVtkTexture = vtk.vtkTexture() self.cameraVtkTexture.SetInputConnection(self.__textReader.GetOutputPort()) self.cameraVtkTexture.InterpolateOn() # Finally assign the mapper and the actor planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetInputConnection(transF.GetOutputPort()) self.vtkActor.SetMapper(planeMapper) self.vtkActor.SetTexture(self.cameraVtkTexture)
def __init__(self, sim, pos, dims, density, fixed=False): # ODE initialization x, y, z = pos # initial pos lx, ly, lz = dims # dimensions self.sim = sim # link to the sim object self.body = ode.Body(self.sim.world) # ode body mass = ode.Mass() # mass object mass.setBox(density, lx, ly, lz) # calculate mass self.body.setMass(mass) # link mass to body self.body.setPosition(pos) # set the initial pos self.geom = ode.GeomBox(self.sim.space, lengths=dims) # geometry self.geom.setBody(self.body) # link geometry and body if fixed: self.fixedJoint = ode.FixedJoint(self.sim.world) self.fixedJoint.attach(self.body,self.sim.space.getBody()) self.fixedJoint.setFixed() # VTK initialization self.math = vtk.vtkMath() self.cube = vtk.vtkCubeSource() self.cube.SetXLength(lx) self.cube.SetYLength(ly) self.cube.SetZLength(lz) self.cube.SetCenter((0.0,0.0,0.0)) self.reader = vtk.vtkJPEGReader() self.reader.SetFileName(ROBOT_IMAGE) self.texture = vtk.vtkTexture() transform = vtk.vtkTransform() transform.Scale(1.0,1.0,1.0) self.texture.SetTransform(transform) self.texture.SetInput(self.reader.GetOutput()) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInput(self.cube.GetOutput()) self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) self.actor.SetTexture(self.texture) sim.renderer.AddActor(self.actor) # Self-include in the bodies for visualization sim.bodies.append(self)
def showRender(self): jpegfile = "/home/jose/Documentos/PFC/PFC/sphere.jpg" # Read the image data from a file reader = vtk.vtkJPEGReader() reader.SetFileName(jpegfile) reader.Update() # Create texture object texture = vtk.vtkTexture() if vtk.VTK_MAJOR_VERSION <= 5: texture.SetInput(reader.GetOutput()) else: texture.SetInputConnection(reader.GetOutputPort()) #self.render.SetTexturedBackground(True) #self.render.SetBackgroundTexture(texture) self.render.GradientBackgroundOn() self.render.SetBackground2(0.4,0.5,0.9) self.render.SetBackground(0.3,0.3,0.3) self.pantalla.Initialize() self.pantalla.Start()
def __init__(self, module_manager): ModuleBase.__init__(self, module_manager) self._reader = vtk.vtkJPEGReader() self._reader.SetFileDimensionality(3) module_utils.setup_vtk_object_progress(self, self._reader, 'Reading JPG images.') self._config.filePattern = '%03d.jpg' self._config.firstSlice = 0 self._config.lastSlice = 1 self._config.spacing = (1,1,1) self._config.fileLowerLeft = False configList = [ ('File pattern:', 'filePattern', 'base:str', 'filebrowser', 'Filenames will be built with this. See module help.', {'fileMode' : wx.OPEN, 'fileMask' : 'JPG files (*.jpg)|*.jpg|All files (*.*)|*.*'}), ('First slice:', 'firstSlice', 'base:int', 'text', '%d will iterate starting at this number.'), ('Last slice:', 'lastSlice', 'base:int', 'text', '%d will iterate and stop at this number.'), ('Spacing:', 'spacing', 'tuple:float,3', 'text', 'The 3-D spacing of the resultant dataset.'), ('Lower left:', 'fileLowerLeft', 'base:bool', 'checkbox', 'Image origin at lower left? (vs. upper left)')] ScriptedConfigModuleMixin.__init__( self, configList, {'Module (self)' : self, 'vtkJPEGReader' : self._reader}) self.sync_module_logic_with_config()
def FileExtensions(cls): extensions = vtk.vtkJPEGReader().GetFileExtensions().split(' ') extensions.extend([item.upper() for item in extensions]) return extensions
def createDICOMFileForScene(self): """ Export the scene data: - first to a directory using the utility in the mrmlScene - create a zip file using the application logic - create secondary capture based on the sample dataset - add the zip file as a private creator tag TODO: confirm that resulting file is valid - may need to change the CLI to include more parameters or do a new implementation ctk/DCMTK See: http://sourceforge.net/apps/mediawiki/gdcm/index.php?title=Writing_DICOM """ # set up temp directories and files self.dicomDirectory = tempfile.mkdtemp('', 'dicomExport', slicer.app.temporaryPath) self.sceneDirectory = os.path.join(self.dicomDirectory,'scene') os.mkdir(self.sceneDirectory) # known to be unique self.imageFile = os.path.join(self.dicomDirectory, "scene.jpg") self.zipFile = os.path.join(self.dicomDirectory, "scene.zip") self.dumpFile = os.path.join(self.dicomDirectory, "dicom.dump") self.sdbFile = os.path.join(self.dicomDirectory, "SlicerDataBundle.dcm") # Clean up paths on Windows (some commands and operations are not performed properly with mixed slash and backslash) self.dicomDirectory = self.dicomDirectory.replace('\\','/') self.sceneDirectory = self.sceneDirectory.replace('\\','/') # otherwise invalid zip file is created on Windows (with the same size strangely) self.imageFile = self.imageFile.replace('\\','/') self.zipFile = self.zipFile.replace('\\','/') self.dumpFile = self.dumpFile.replace('\\','/') self.sdbFile = self.sdbFile.replace('\\','/') # get the screen image self.progress('Saving Image...') image = ctk.ctkWidgetsUtils.grabWidget(slicer.util.mainWindow()) image.save(self.imageFile) imageReader = vtk.vtkJPEGReader() imageReader.SetFileName(self.imageFile) imageReader.Update() #add storage node for each storable node in the scene, add file name if file name doesn't exist # TODO: this could be moved to appLogic.SaveSceneToSlicerDataBundleDirectory lnodes = slicer.mrmlScene.GetNodesByClass("vtkMRMLLinearTransformNode") lnodes.UnRegister(slicer.mrmlScene) lnum = lnodes.GetNumberOfItems() for itemNum in range(lnum): print(itemNum) node = lnodes.GetItemAsObject(itemNum) snode = node.GetStorageNode() if snode is None: print("something is none") snode = node.CreateDefaultStorageNode() slicer.mrmlScene.AddNode(snode) node.SetAndObserveStorageNodeID(snode.GetID()) if snode.GetFileName() is None: snode.SetFileName(node.GetID()+".h5") # save the scene to the temp dir self.progress('Saving Scene...') appLogic = slicer.app.applicationLogic() appLogic.SaveSceneToSlicerDataBundleDirectory(self.sceneDirectory, imageReader.GetOutput()) # make the zip file self.progress('Making zip...') appLogic.Zip(self.zipFile, self.sceneDirectory) zipSize = os.path.getsize(self.zipFile) # now create the dicom file # - create the dump (capture stdout) # cmd = "dcmdump --print-all --write-pixel %s %s" % (self.dicomDirectory, self.referenceFile) self.progress('Making dicom reference file...') if not self.referenceFile: # set reference file the first file found in the DICOM database self.getFirstFileInDatabase() # if there is still no reference file, then there are no files in the database, cannot continue if not self.referenceFile: logging.error('No reference file! DICOM database is empty') return False args = ['--print-all', '--write-pixel', self.dicomDirectory, self.referenceFile] dump = DICOMLib.DICOMCommand('dcmdump', args).start() # append this to the dumped output and save the result as self.dicomDirectory/dcm.dump # with %s as self.zipFile and %d being its size in bytes zipSizeString = "%d" % zipSize # hack: encode the file zip file size as part of the creator string # because none of the normal types (UL, DS, LO) seem to survive # the dump2dcm step (possibly due to the Unknown nature of the private tag) creatorString = "3D Slicer %s" % zipSizeString candygram = """(cadb,0010) LO [%s] # %d, 1 PrivateCreator (cadb,1008) LO [%s] # 4, 1 Unknown Tag & Data (cadb,1010) OB =%s # %d, 1 Unknown Tag & Data """ % (creatorString, len(creatorString), zipSizeString, self.zipFile, zipSize) dump = str(dump) + candygram logging.debug('dumping to: %s/dump.dcm' % self.dicomDirectory, 'w') fp = open('%s/dump.dcm' % self.dicomDirectory, 'w') fp.write(dump) fp.close() self.progress('Encapsulating Scene in DICOM Dump...') args = [ '%s/dump.dcm' % self.dicomDirectory, '%s/template.dcm' % self.dicomDirectory, '--generate-new-uids', '--overwrite-uids', '--ignore-errors'] DICOMLib.DICOMCommand('dump2dcm', args).start() # now create the Secondary Capture data set # cmd = "img2dcm -k 'InstanceNumber=1' -k 'SeriesDescription=Slicer Data Bundle' -df %s/template.dcm %s %s" % (self.dicomDirectory, self.imageFile, self.sdbFile) args = [ '-k', 'InstanceNumber=1', '-k', 'StudyDescription=Slicer Scene Export', '-k', 'SeriesDescription=Slicer Data Bundle', '--dataset-from', '%s/template.dcm' % self.dicomDirectory, self.imageFile, self.sdbFile] self.progress('Creating DICOM Binary File...') DICOMLib.DICOMCommand('img2dcm', args).start() self.progress('Done') return True
def img2dcm(self, input_img, output, img_type, img_number): if img_type == "jpg": print "JPG" image = vtk.vtkJPEGReader() image.SetFileName(input_img) image.Update() elif img_type == "tif": print "TIF" image = vtk.vtkTIFFReader() image.SetFileName(input_img) image.Update() elif img_type == "bmp": print "BMP" image = vtk.vtkBMPReader() image.SetFileName(input_img) image.Allow8BitBMPOn() image.Update() elif img_type == "png": print "PNG" image = vtk.vtkPNGReader() image.SetFileName(input_img) image.SetDataSpacing(self.spacing) image.Update() elif img_type == "vti": print "VTI" image = vtk.vtkXMLImageDataReader() image.SetFileName(input_img) image.Update() #if (orientation == 0): image_pos = img_number * self.spacing[2] image_localization = image_pos # print image_pos, img_number, image.GetOutput().GetScalarRange() img_clone = vtk.vtkImageData() img_clone.DeepCopy(image.GetOutput()) img_clone.SetSpacing(self.spacing) img_clone.Update() # v = vtk.vtkImageViewer() # v.SetInput(image.GetOutput()) # v.SetColorLevel(500) # v.SetColorWindow(240) # v.Render() # time.sleep(3) # a = vtk.vtkImageCast() # a.SetOutputScalarTypeToUnsignedChar() # a.SetInput(image.GetOutput()) # a.ClampOverflowOn() # a.Update() #b = vtk.vtkJPEGWriter() #b.SetFileName("C:\\teste.jpg") #b.SetInput(a.GetOutput()) #b.writer() #spacing = image.GetOutput().GetSpacing() #elif (orientation == 1): # image_pos[0] = image_pos[0] + thickness # image_localization = image_localization + thickness # img_number = img_number + 1 #elif (orientation == 2): # image_pos[1] = image_pos[1] + thickness # image_localization = image_localization + thickness # img_number = img_number + 1 pos = 0, 0, image_pos print pos # transform = vtk.vtkTransform() # transform.Translate(pos) # transform_filter = vtk.vtkImageReslice() # transform_filter.SetInput(image.GetOutput()) # transform_filter.SetResliceTransform(transform) # transform_filter.Update() properties = vtk.vtkMedicalImageProperties() properties.SetModality(self.modality) properties.SetInstitutionName(self.institution) properties.SetPatientName(self.patient) properties.SetSliceThickness(str(self.spacing[2])) properties.SetSeriesNumber(str(self.serie)) properties.SetImageNumber(str(img_number)) properties.SetPatientID(self.patient_id) properties.SetStudyID(self.study_id) properties.AddUserDefinedValue("Image Position (Patient)", "%.5f\\%.5f\\%.5f" % (pos[0], pos[1], pos[2])) properties.AddUserDefinedValue("Instance Number", str(img_number)) print str(img_number), properties.GetNumberOfUserDefinedValues() writer = vtkgdcm.vtkGDCMImageWriter() writer.SetInput(img_clone) writer.SetStudyUID(self.study_uid) writer.SetSeriesUID(self.series_uid) writer.SetMedicalImageProperties(properties) writer.SetFileName(output) # writer.SetImageFormat(vtk.VTK_LUMINANCE) writer.SetFileDimensionality(3) writer.Write() reader = gdcm.Reader() reader.SetFileName(output) reader.Read() anon = gdcm.Anonymizer() anon.SetFile(reader.GetFile()) anon.Replace(gdcm.Tag(0x0020, 0x0013), str(img_number)) anon.Replace(gdcm.Tag(0x0028, 0x0030), "%.6f\\%.6f" % (self.spacing[0], self.spacing[1])) writer = gdcm.Writer() writer.SetFile(reader.GetFile()) writer.SetFileName(output) writer.Write() # print spacing, pos, image.GetOutput().GetScalarRange() # writer = ivDicom.DicomWriter() # writer.SetFileName(output) # writer.SaveIsNew(image.GetOutput()) # # writer.SetAcquisitionModality(self.modality) # writer.SetInstitutionName(self.institution) # writer.SetStudyID(self.study_uid) # writer.SetPatientID(self.patient_id) # writer.SetPatientName(self.patient) # writer.SetImageThickness(self.spacing[2]) # writer.SetImageSeriesNumber(self.serie) # writer.SetImageNumber(img_number) # writer.SetImagePosition(pos) # writer.SetImageLocation(image_localization) # writer.SetPixelSpacing(self.spacing[:2]) # writer.Save() print "Written", input_img, "->", output
def main(argv): # Verify input arguments if len(argv) > 1: # Read the image jpeg_reader = vtkJPEGReader() if not jpeg_reader.CanReadFile(argv[1]): print("Error reading file %s" % argv[1]) return jpeg_reader.SetFileName(argv[1]) jpeg_reader.Update() image_data = jpeg_reader.GetOutput() else: canvas_source = vtk.vtkImageCanvasSource2D() canvas_source.SetExtent(0, 100, 0, 100, 0, 0) canvas_source.SetScalarTypeToUnsignedChar() canvas_source.SetNumberOfScalarComponents(3) canvas_source.SetDrawColor(127, 127, 100) canvas_source.FillBox(0, 100, 0, 100) canvas_source.SetDrawColor(100, 255, 255) canvas_source.FillTriangle(10, 10, 25, 10, 25, 25) canvas_source.SetDrawColor(255, 100, 255) canvas_source.FillTube(75, 75, 0, 75, 5.0) canvas_source.Update() image_data = canvas_source.GetOutput() # Create an image actor to display the image image_actor = vtkImageActor() if VTK_MAJOR_VERSION <= 5: image_actor.SetInput(image_data) else: image_actor.SetInputData(image_data) # Create a superquadric superquadric_source = vtkSuperquadricSource() superquadric_source.SetPhiRoundness(1.1) superquadric_source.SetThetaRoundness(.2) # Create a mapper and actor superquadric_mapper = vtkPolyDataMapper() superquadric_mapper.SetInputConnection(superquadric_source.GetOutputPort()) superquadric_actor = vtkActor() superquadric_actor.SetMapper(superquadric_mapper) vtk_renderer = vtkRenderer() vtk_renderer.SetLayer(1) # Set up the render window and renderers such that there is # a background layer and a foreground layer background_renderer = vtkRenderer() background_renderer.SetLayer(0) background_renderer.InteractiveOff() background_renderer.AddActor(image_actor) render_window = vtkRenderWindow() render_window.SetNumberOfLayers(2) render_window.AddRenderer(background_renderer) render_window.AddRenderer(vtk_renderer) render_window_interactor = vtkRenderWindowInteractor() render_window_interactor.SetRenderWindow(render_window) # Add actors to the renderers vtk_renderer.AddActor(superquadric_actor) # Render once to figure out where the background camera will be render_window.Render() # Set up the background camera to fill the renderer with the image origin = image_data.GetOrigin() spacing = image_data.GetSpacing() extent = image_data.GetExtent() camera = background_renderer.GetActiveCamera() camera.ParallelProjectionOn() xc = origin[0] + 0.5*(extent[0] + extent[1]) * spacing[0] yc = origin[1] + 0.5*(extent[2] + extent[3]) * spacing[1] # xd = (extent[1] - extent[0] + 1) * spacing[0] yd = (extent[3] - extent[2] + 1) * spacing[1] d = camera.GetDistance() camera.SetParallelScale(0.5 * yd) camera.SetFocalPoint(xc, yc, 0.0) camera.SetPosition(xc, yc, d) # Render again to set the correct view render_window.Render() # Interact with the window render_window_interactor.Start()
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # ------------------------------------------------------------ # Purpose: Test the paraemtric functions. # ------------------------------------------------------------ # ------------------------------------------------------------ # Call the VTK Tcl packages to make available all VTK commands # ------------------------------------------------------------ # ------------------------------------------------------------ # Get a texture # ------------------------------------------------------------ textureReader = vtk.vtkJPEGReader() textureReader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/beach.jpg") texture = vtk.vtkTexture() texture.SetInputConnection(textureReader.GetOutputPort()) # ------------------------------------------------------------ # For each parametric surface: # 1) Create it # 2) Assign mappers and actors # 3) Position ths object # 5) Add a label # ------------------------------------------------------------ # ------------------------------------------------------------ # Create a torus # ------------------------------------------------------------ torus = vtk.vtkParametricTorus() torusSource = vtk.vtkParametricFunctionSource()
# Do picking with an actor with a texture. # This example draws a cone at the pick point, with the color # of the cone set from the color of the texture at the pick position. # # renderer and interactor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # read the volume reader = vtk.vtkJPEGReader() reader.SetFileName(VTK_DATA_ROOT + "/Data/beach.jpg") #--------------------------------------------------------- # Do the surface rendering sphereSource = vtk.vtkSphereSource() sphereSource.SetRadius(100) textureSphere = vtk.vtkTextureMapToSphere() textureSphere.SetInputConnection(sphereSource.GetOutputPort()) sphereStripper = vtk.vtkStripper() sphereStripper.SetInputConnection(textureSphere.GetOutputPort()) sphereStripper.SetMaximumLength(5) sphereMapper = vtk.vtkPolyDataMapper()
def main(): session = Set_Render_Variables("quake(13).csv") data = Data_Extractor(session) bounds = Model_Bounds_Points_Maker(data, session) events = Timed_Event_List_Maker(data.event_list, session) # sets up the VTK session ren = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() #renderWindow.AddRenderer(ren) i_ren = vtk.vtkRenderWindowInteractor() i_ren.SetRenderWindow(renderWindow) # text / legend object legend = vtk.vtkCornerAnnotation() legend.SetText(0, " Quake Cloud 3d Visualiser\n Depth Markers are 25Km Apart\n" " All other distances are relative \n\n\n Copyright 2013 Jay Gattuso\n\n") legend.SetMaximumFontSize(15) # handles the overlay map image input_image = session.overlay_image_fname reader = vtk.vtkJPEGReader() reader.SetFileName(input_image) texture = vtk.vtkTexture() texture.SetInput(reader.GetOutput()) texture.SetInputConnection(reader.GetOutputPort()) texture.InterpolateOn() ren = vtk.vtkRenderer() renderWindow.AddRenderer(ren) plane = vtk.vtkPlaneSource() plane.SetOrigin((0, 0, 0)) plane.SetPoint1(bounds.lat_max_distance) plane.SetPoint2(bounds.long_max_distance) # Create texture object planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetInputConnection(plane.GetOutputPort()) planeActor = vtk.vtkActor() planeActor.SetMapper(planeMapper) planeActor.SetTexture(texture) pointCloud_bounds = VtkPointCloud(data.event_max_depth) if session.plot_boundary_markers: for bound in bounds.bounds: pointCloud_bounds.addPoint(bound, 10) # the number is what makes the bound markers larger if session.plot_depth_scale: for bound in bounds.bounds_scale: pointCloud_bounds.addPoint(bound, 10) # the number is what makes the bound markers larger # add basic objects (bounds, overlay, background) ren.AddActor(pointCloud_bounds.vtkActor) ren.AddViewProp(legend) ren.AddActor(planeActor) ren.SetBackground(.2, .2, .2) ren.ResetCamera() renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Begin Interaction renderWindow.Render() # Initialize must be called prior to creating timer events. renderWindowInteractor.Initialize() # Sign up to receive TimerEvent cb = vtkTimerCallback(events.timed_event_dict, data.event_max_depth, ren, renderWindow, session) cb.actor = vtk.vtkActor() renderWindowInteractor.AddObserver('TimerEvent', cb.execute) timerId = renderWindowInteractor.CreateRepeatingTimer(session.replay_frame_speed) renderWindowInteractor.Start()
def testParametricFunctions(self): # ------------------------------------------------------------ # Get a texture # ------------------------------------------------------------ textureReader = vtk.vtkJPEGReader() textureReader.SetFileName(VTK_DATA_ROOT + "/Data/beach.jpg") texture = vtk.vtkTexture() texture.SetInputConnection(textureReader.GetOutputPort()) # ------------------------------------------------------------ # For each parametric surface: # 1) Create it # 2) Assign mappers and actors # 3) Position the object # 5) Add a label # ------------------------------------------------------------ # ------------------------------------------------------------ # Create a torus # ------------------------------------------------------------ torus = vtk.vtkParametricTorus() torusSource = vtk.vtkParametricFunctionSource() torusSource.SetParametricFunction(torus) torusSource.SetScalarModeToPhase() torusMapper = vtk.vtkPolyDataMapper() torusMapper.SetInputConnection(torusSource.GetOutputPort()) torusMapper.SetScalarRange(0, 360) torusActor = vtk.vtkActor() torusActor.SetMapper(torusMapper) torusActor.SetPosition(0, 12, 0) torusTextMapper = vtk.vtkTextMapper() torusTextMapper.SetInput("Torus") torusTextMapper.GetTextProperty().SetJustificationToCentered() torusTextMapper.GetTextProperty().SetVerticalJustificationToCentered() torusTextMapper.GetTextProperty().SetColor(1, 0, 0) torusTextMapper.GetTextProperty().SetFontSize(14) torusTextActor = vtk.vtkActor2D() torusTextActor.SetMapper(torusTextMapper) torusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() torusTextActor.GetPositionCoordinate().SetValue(0, 9.5, 0) # ------------------------------------------------------------ # Create a Klein bottle # ------------------------------------------------------------ klein = vtk.vtkParametricKlein() kleinSource = vtk.vtkParametricFunctionSource() kleinSource.SetParametricFunction(klein) kleinSource.SetScalarModeToU0V0() kleinMapper = vtk.vtkPolyDataMapper() kleinMapper.SetInputConnection(kleinSource.GetOutputPort()) kleinMapper.SetScalarRange(0, 3) kleinActor = vtk.vtkActor() kleinActor.SetMapper(kleinMapper) kleinActor.SetPosition(8, 10.5, 0) kleinTextMapper = vtk.vtkTextMapper() kleinTextMapper.SetInput("Klein") kleinTextMapper.GetTextProperty().SetJustificationToCentered() kleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered() kleinTextMapper.GetTextProperty().SetColor(1, 0, 0) kleinTextMapper.GetTextProperty().SetFontSize(14) kleinTextActor = vtk.vtkActor2D() kleinTextActor.SetMapper(kleinTextMapper) kleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() kleinTextActor.GetPositionCoordinate().SetValue(8, 9.5, 0) # ------------------------------------------------------------ # Create a Figure-8 Klein # ------------------------------------------------------------ klein2 = vtk.vtkParametricFigure8Klein() klein2Source = vtk.vtkParametricFunctionSource() klein2Source.SetParametricFunction(klein2) klein2Source.GenerateTextureCoordinatesOn() klein2Mapper = vtk.vtkPolyDataMapper() klein2Mapper.SetInputConnection(klein2Source.GetOutputPort()) klein2Mapper.SetScalarRange(0, 3) klein2Actor = vtk.vtkActor() klein2Actor.SetMapper(klein2Mapper) klein2Actor.SetPosition(16, 12, 0) klein2Actor.SetTexture(texture) fig8KleinTextMapper = vtk.vtkTextMapper() fig8KleinTextMapper.SetInput("Fig-8.Klein") fig8KleinTextMapper.GetTextProperty().SetJustificationToCentered() fig8KleinTextMapper.GetTextProperty().SetVerticalJustificationToCentered() fig8KleinTextMapper.GetTextProperty().SetColor(1, 0, 0) fig8KleinTextMapper.GetTextProperty().SetFontSize(14) fig8KleinTextActor = vtk.vtkActor2D() fig8KleinTextActor.SetMapper(fig8KleinTextMapper) fig8KleinTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() fig8KleinTextActor.GetPositionCoordinate().SetValue(16, 9.5, 0) # ------------------------------------------------------------ # Create a Mobius strip # ------------------------------------------------------------ mobius = vtk.vtkParametricMobius() mobiusSource = vtk.vtkParametricFunctionSource() mobiusSource.SetParametricFunction(mobius) mobiusSource.GenerateTextureCoordinatesOn() mobiusMapper = vtk.vtkPolyDataMapper() mobiusMapper.SetInputConnection(mobiusSource.GetOutputPort()) mobiusActor = vtk.vtkActor() mobiusActor.SetMapper(mobiusMapper) mobiusActor.RotateX(45) mobiusActor.SetPosition(24, 12, 0) mobiusActor.SetTexture(texture) mobiusTextMapper = vtk.vtkTextMapper() mobiusTextMapper.SetInput("Mobius") mobiusTextMapper.GetTextProperty().SetJustificationToCentered() mobiusTextMapper.GetTextProperty().SetVerticalJustificationToCentered() mobiusTextMapper.GetTextProperty().SetColor(1, 0, 0) mobiusTextMapper.GetTextProperty().SetFontSize(14) mobiusTextActor = vtk.vtkActor2D() mobiusTextActor.SetMapper(mobiusTextMapper) mobiusTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() mobiusTextActor.GetPositionCoordinate().SetValue(24, 9.5, 0) # ------------------------------------------------------------ # Create a super toroid # ------------------------------------------------------------ toroid = vtk.vtkParametricSuperToroid() toroid.SetN1(2) toroid.SetN2(3) toroidSource = vtk.vtkParametricFunctionSource() toroidSource.SetParametricFunction(toroid) toroidSource.SetScalarModeToU() toroidMapper = vtk.vtkPolyDataMapper() toroidMapper.SetInputConnection(toroidSource.GetOutputPort()) toroidMapper.SetScalarRange(0, 6.28) toroidActor = vtk.vtkActor() toroidActor.SetMapper(toroidMapper) toroidActor.SetPosition(0, 4, 0) superToroidTextMapper = vtk.vtkTextMapper() superToroidTextMapper.SetInput("Super.Toroid") superToroidTextMapper.GetTextProperty().SetJustificationToCentered() superToroidTextMapper.GetTextProperty().SetVerticalJustificationToCentered() superToroidTextMapper.GetTextProperty().SetColor(1, 0, 0) superToroidTextMapper.GetTextProperty().SetFontSize(14) superToroidTextActor = vtk.vtkActor2D() superToroidTextActor.SetMapper(superToroidTextMapper) superToroidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() superToroidTextActor.GetPositionCoordinate().SetValue(0, 1.5, 0) # ------------------------------------------------------------ # Create a super ellipsoid # ------------------------------------------------------------ superEllipsoid = vtk.vtkParametricSuperEllipsoid() superEllipsoid.SetXRadius(1.25) superEllipsoid.SetYRadius(1.5) superEllipsoid.SetZRadius(1.0) superEllipsoid.SetN1(1.1) superEllipsoid.SetN2(1.75) superEllipsoidSource = vtk.vtkParametricFunctionSource() superEllipsoidSource.SetParametricFunction(superEllipsoid) superEllipsoidSource.SetScalarModeToV() superEllipsoidMapper = vtk.vtkPolyDataMapper() superEllipsoidMapper.SetInputConnection(superEllipsoidSource.GetOutputPort()) superEllipsoidMapper.SetScalarRange(0, 3.14) superEllipsoidActor = vtk.vtkActor() superEllipsoidActor.SetMapper(superEllipsoidMapper) superEllipsoidActor.SetPosition(8, 4, 0) superEllipsoidTextMapper = vtk.vtkTextMapper() superEllipsoidTextMapper.SetInput("Super.Ellipsoid") superEllipsoidTextMapper.GetTextProperty().SetJustificationToCentered() superEllipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered() superEllipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0) superEllipsoidTextMapper.GetTextProperty().SetFontSize(14) superEllipsoidTextActor = vtk.vtkActor2D() superEllipsoidTextActor.SetMapper(superEllipsoidTextMapper) superEllipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() superEllipsoidTextActor.GetPositionCoordinate().SetValue(8, 1.5, 0) # ------------------------------------------------------------ # Create an open 1D spline # ------------------------------------------------------------ splinePoints = [ [0.50380158308139134, -0.60679315105396936, -0.37248976406291578], [-0.4354646054261665, -0.85362339758017258, -0.84844312996065385], [0.2163147512899315, -0.39797507012168643, -0.76700353518454523], [0.97158415334838644, -0.58513467367046257, -0.35846037946569753], [-0.64359767997804918, -0.94620739107309249, -0.90762176546623086], [-0.39901219094126117, -0.1978931497772658, 0.0098316934936828471], [-0.75872745167404765, 0.067719714281950116, 0.165237936733867], [-0.84599731389712418, -0.67685466896596114, 0.10357868909071133], [0.84702754758625654, -0.0080077177882230677, -0.58571286666473044], [-0.076150034124101484, 0.14637647622561856, 0.1494359239700418] ] inputPoints = vtk.vtkPoints() for i in range(0, 10): inputPoints.InsertPoint(i, splinePoints[i]) spline = vtk.vtkParametricSpline() spline.SetPoints(inputPoints) spline.ClosedOff() splineSource = vtk.vtkParametricFunctionSource() splineSource.SetParametricFunction(spline) splineMapper = vtk.vtkPolyDataMapper() splineMapper.SetInputConnection(splineSource.GetOutputPort()) splineActor = vtk.vtkActor() splineActor.SetMapper(splineMapper) splineActor.SetPosition(16, 4, 0) splineActor.GetProperty().SetColor(0, 0, 0) splineTextMapper = vtk.vtkTextMapper() splineTextMapper.SetInput("Open.Spline") splineTextMapper.GetTextProperty().SetJustificationToCentered() splineTextMapper.GetTextProperty().SetVerticalJustificationToCentered() splineTextMapper.GetTextProperty().SetColor(1, 0, 0) splineTextMapper.GetTextProperty().SetFontSize(14) splineTextActor = vtk.vtkActor2D() splineTextActor.SetMapper(splineTextMapper) splineTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() splineTextActor.GetPositionCoordinate().SetValue(16, 1.5, 0) # ------------------------------------------------------------ # Create a closed 1D spline # ------------------------------------------------------------ spline2 = vtk.vtkParametricSpline() spline2.SetPoints(inputPoints) spline2.ClosedOn() spline2Source = vtk.vtkParametricFunctionSource() spline2Source.SetParametricFunction(spline2) spline2Mapper = vtk.vtkPolyDataMapper() spline2Mapper.SetInputConnection(spline2Source.GetOutputPort()) spline2Actor = vtk.vtkActor() spline2Actor.SetMapper(spline2Mapper) spline2Actor.SetPosition(24, 4, 0) spline2Actor.GetProperty().SetColor(0, 0, 0) spline2TextMapper = vtk.vtkTextMapper() spline2TextMapper.SetInput("Closed.Spline") spline2TextMapper.GetTextProperty().SetJustificationToCentered() spline2TextMapper.GetTextProperty().SetVerticalJustificationToCentered() spline2TextMapper.GetTextProperty().SetColor(1, 0, 0) spline2TextMapper.GetTextProperty().SetFontSize(14) spline2TextActor = vtk.vtkActor2D() spline2TextActor.SetMapper(spline2TextMapper) spline2TextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() spline2TextActor.GetPositionCoordinate().SetValue(24, 1.5, 0) # ------------------------------------------------------------ # Create a spiral conic # ------------------------------------------------------------ sconic = vtk.vtkParametricConicSpiral() sconic.SetA(0.8) sconic.SetB(2.5) sconic.SetC(0.4) sconicSource = vtk.vtkParametricFunctionSource() sconicSource.SetParametricFunction(sconic) sconicSource.SetScalarModeToDistance() sconicMapper = vtk.vtkPolyDataMapper() sconicMapper.SetInputConnection(sconicSource.GetOutputPort()) sconicActor = vtk.vtkActor() sconicActor.SetMapper(sconicMapper) sconicMapper.SetScalarRange(0, 9) sconicActor.SetPosition(0, -4, 0) sconicActor.SetScale(1.2, 1.2, 1.2) sconicTextMapper = vtk.vtkTextMapper() sconicTextMapper.SetInput("Spiral.Conic") sconicTextMapper.GetTextProperty().SetJustificationToCentered() sconicTextMapper.GetTextProperty().SetVerticalJustificationToCentered() sconicTextMapper.GetTextProperty().SetColor(1, 0, 0) sconicTextMapper.GetTextProperty().SetFontSize(14) sconicTextActor = vtk.vtkActor2D() sconicTextActor.SetMapper(sconicTextMapper) sconicTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() sconicTextActor.GetPositionCoordinate().SetValue(0, -6.5, 0) # ------------------------------------------------------------ # Create Boy's surface # ------------------------------------------------------------ boy = vtk.vtkParametricBoy() boySource = vtk.vtkParametricFunctionSource() boySource.SetParametricFunction(boy) boySource.SetScalarModeToModulus() boyMapper = vtk.vtkPolyDataMapper() boyMapper.SetInputConnection(boySource.GetOutputPort()) boyMapper.SetScalarRange(0, 2) boyActor = vtk.vtkActor() boyActor.SetMapper(boyMapper) boyActor.SetPosition(8, -4, 0) boyActor.SetScale(1.5, 1.5, 1.5) boyTextMapper = vtk.vtkTextMapper() boyTextMapper.SetInput("Boy") boyTextMapper.GetTextProperty().SetJustificationToCentered() boyTextMapper.GetTextProperty().SetVerticalJustificationToCentered() boyTextMapper.GetTextProperty().SetColor(1, 0, 0) boyTextMapper.GetTextProperty().SetFontSize(14) boyTextActor = vtk.vtkActor2D() boyTextActor.SetMapper(boyTextMapper) boyTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() boyTextActor.GetPositionCoordinate().SetValue(8, -6.5, 0) # ------------------------------------------------------------ # Create a cross cap # ------------------------------------------------------------ crossCap = vtk.vtkParametricCrossCap() crossCapSource = vtk.vtkParametricFunctionSource() crossCapSource.SetParametricFunction(crossCap) crossCapSource.SetScalarModeToY() crossCapMapper = vtk.vtkPolyDataMapper() crossCapMapper.SetInputConnection(crossCapSource.GetOutputPort()) crossCapActor = vtk.vtkActor() crossCapActor.SetMapper(crossCapMapper) crossCapActor.RotateX(65) crossCapActor.SetPosition(16, -4, 0) crossCapActor.SetScale(1.5, 1.5, 1.5) crossCapTextMapper = vtk.vtkTextMapper() crossCapTextMapper.SetInput("Cross.Cap") crossCapTextMapper.GetTextProperty().SetJustificationToCentered() crossCapTextMapper.GetTextProperty().SetVerticalJustificationToCentered() crossCapTextMapper.GetTextProperty().SetColor(1, 0, 0) crossCapTextMapper.GetTextProperty().SetFontSize(14) crossCapTextActor = vtk.vtkActor2D() crossCapTextActor.SetMapper(crossCapTextMapper) crossCapTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() crossCapTextActor.GetPositionCoordinate().SetValue(16, -6.5, 0) # ------------------------------------------------------------ # Create Dini's surface # ------------------------------------------------------------ dini = vtk.vtkParametricDini() diniSource = vtk.vtkParametricFunctionSource() diniSource.SetScalarModeToDistance() diniSource.SetParametricFunction(dini) diniMapper = vtk.vtkPolyDataMapper() diniMapper.SetInputConnection(diniSource.GetOutputPort()) diniActor = vtk.vtkActor() diniActor.SetMapper(diniMapper) diniActor.RotateX(-90) diniActor.SetPosition(24, -3, 0) diniActor.SetScale(1.5, 1.5, 0.5) diniTextMapper = vtk.vtkTextMapper() diniTextMapper.SetInput("Dini") diniTextMapper.GetTextProperty().SetJustificationToCentered() diniTextMapper.GetTextProperty().SetVerticalJustificationToCentered() diniTextMapper.GetTextProperty().SetColor(1, 0, 0) diniTextMapper.GetTextProperty().SetFontSize(14) diniTextActor = vtk.vtkActor2D() diniTextActor.SetMapper(diniTextMapper) diniTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() diniTextActor.GetPositionCoordinate().SetValue(24, -6.5, 0) # ------------------------------------------------------------ # Create Enneper's surface # ------------------------------------------------------------ enneper = vtk.vtkParametricEnneper() enneperSource = vtk.vtkParametricFunctionSource() enneperSource.SetParametricFunction(enneper) enneperSource.SetScalarModeToQuadrant() enneperMapper = vtk.vtkPolyDataMapper() enneperMapper.SetInputConnection(enneperSource.GetOutputPort()) enneperMapper.SetScalarRange(1, 4) enneperActor = vtk.vtkActor() enneperActor.SetMapper(enneperMapper) enneperActor.SetPosition(0, -12, 0) enneperActor.SetScale(0.25, 0.25, 0.25) enneperTextMapper = vtk.vtkTextMapper() enneperTextMapper.SetInput("Enneper") enneperTextMapper.GetTextProperty().SetJustificationToCentered() enneperTextMapper.GetTextProperty().SetVerticalJustificationToCentered() enneperTextMapper.GetTextProperty().SetColor(1, 0, 0) enneperTextMapper.GetTextProperty().SetFontSize(14) enneperTextActor = vtk.vtkActor2D() enneperTextActor.SetMapper(enneperTextMapper) enneperTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() enneperTextActor.GetPositionCoordinate().SetValue(0, -14.5, 0) # ------------------------------------------------------------ # Create an ellipsoidal surface # ------------------------------------------------------------ ellipsoid = vtk.vtkParametricEllipsoid() ellipsoid.SetXRadius(1) ellipsoid.SetYRadius(0.75) ellipsoid.SetZRadius(0.5) ellipsoidSource = vtk.vtkParametricFunctionSource() ellipsoidSource.SetParametricFunction(ellipsoid) ellipsoidSource.SetScalarModeToZ() ellipsoidMapper = vtk.vtkPolyDataMapper() ellipsoidMapper.SetInputConnection(ellipsoidSource.GetOutputPort()) ellipsoidMapper.SetScalarRange(-0.5, 0.5) ellipsoidActor = vtk.vtkActor() ellipsoidActor.SetMapper(ellipsoidMapper) ellipsoidActor.SetPosition(8, -12, 0) ellipsoidActor.SetScale(1.5, 1.5, 1.5) ellipsoidTextMapper = vtk.vtkTextMapper() ellipsoidTextMapper.SetInput("Ellipsoid") ellipsoidTextMapper.GetTextProperty().SetJustificationToCentered() ellipsoidTextMapper.GetTextProperty().SetVerticalJustificationToCentered() ellipsoidTextMapper.GetTextProperty().SetColor(1, 0, 0) ellipsoidTextMapper.GetTextProperty().SetFontSize(14) ellipsoidTextActor = vtk.vtkActor2D() ellipsoidTextActor.SetMapper(ellipsoidTextMapper) ellipsoidTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() ellipsoidTextActor.GetPositionCoordinate().SetValue(8, -14.5, 0) # ------------------------------------------------------------ # Create a surface with random hills on it. # ------------------------------------------------------------ randomHills = vtk.vtkParametricRandomHills() randomHills.AllowRandomGenerationOn() randomHillsSource = vtk.vtkParametricFunctionSource() randomHillsSource.SetParametricFunction(randomHills) randomHillsSource.GenerateTextureCoordinatesOn() randomHillsMapper = vtk.vtkPolyDataMapper() randomHillsMapper.SetInputConnection(randomHillsSource.GetOutputPort()) randomHillsActor = vtk.vtkActor() randomHillsActor.SetMapper(randomHillsMapper) randomHillsActor.SetPosition(16, -14, 0) randomHillsActor.SetScale(0.2, 0.2, 0.2) randomHillsActor.SetTexture(texture) randomHillsTextMapper = vtk.vtkTextMapper() randomHillsTextMapper.SetInput("Random.Hills") randomHillsTextMapper.GetTextProperty().SetJustificationToCentered() randomHillsTextMapper.GetTextProperty().SetVerticalJustificationToCentered() randomHillsTextMapper.GetTextProperty().SetColor(1, 0, 0) randomHillsTextMapper.GetTextProperty().SetFontSize(14) randomHillsTextActor = vtk.vtkActor2D() randomHillsTextActor.SetMapper(randomHillsTextMapper) randomHillsTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() randomHillsTextActor.GetPositionCoordinate().SetValue(16, -14.5, 0) # ------------------------------------------------------------ # Create Steiner's Roman Surface. # ------------------------------------------------------------ roman = vtk.vtkParametricRoman() roman.SetRadius(1.5) romanSource = vtk.vtkParametricFunctionSource() romanSource.SetParametricFunction(roman) romanSource.SetScalarModeToX() romanMapper = vtk.vtkPolyDataMapper() romanMapper.SetInputConnection(romanSource.GetOutputPort()) romanActor = vtk.vtkActor() romanActor.SetMapper(romanMapper) romanActor.SetPosition(24, -12, 0) romanTextMapper = vtk.vtkTextMapper() romanTextMapper.SetInput("Roman") romanTextMapper.GetTextProperty().SetJustificationToCentered() romanTextMapper.GetTextProperty().SetVerticalJustificationToCentered() romanTextMapper.GetTextProperty().SetColor(1, 0, 0) romanTextMapper.GetTextProperty().SetFontSize(14) romanTextActor = vtk.vtkActor2D() romanTextActor.SetMapper(romanTextMapper) romanTextActor.GetPositionCoordinate().SetCoordinateSystemToWorld() romanTextActor.GetPositionCoordinate().SetValue(24, -14.5, 0) # ------------------------------------------------------------ # Create the RenderWindow, Renderer and both Actors # ------------------------------------------------------------ ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # add actors ren.AddViewProp(torusActor) ren.AddViewProp(kleinActor) ren.AddViewProp(klein2Actor) ren.AddViewProp(toroidActor) ren.AddViewProp(superEllipsoidActor) ren.AddViewProp(mobiusActor) ren.AddViewProp(splineActor) ren.AddViewProp(spline2Actor) ren.AddViewProp(sconicActor) ren.AddViewProp(boyActor) ren.AddViewProp(crossCapActor) ren.AddViewProp(diniActor) ren.AddViewProp(enneperActor) ren.AddViewProp(ellipsoidActor) ren.AddViewProp(randomHillsActor) ren.AddViewProp(romanActor) #add text actors ren.AddViewProp(torusTextActor) ren.AddViewProp(kleinTextActor) ren.AddViewProp(fig8KleinTextActor) ren.AddViewProp(mobiusTextActor) ren.AddViewProp(superToroidTextActor) ren.AddViewProp(superEllipsoidTextActor) ren.AddViewProp(splineTextActor) ren.AddViewProp(spline2TextActor) ren.AddViewProp(sconicTextActor) ren.AddViewProp(boyTextActor) ren.AddViewProp(crossCapTextActor) ren.AddViewProp(diniTextActor) ren.AddViewProp(enneperTextActor) ren.AddViewProp(ellipsoidTextActor) ren.AddViewProp(randomHillsTextActor) ren.AddViewProp(romanTextActor) ren.SetBackground(0.7, 0.8, 1) renWin.SetSize(500, 500) ren.ResetCamera() ren.GetActiveCamera().Zoom(1.3) iren.Initialize() renWin.Render() img_file = "TestParametricFunctions.png" # NOTE: this test has a companion .tcl test. The threshold set # here should be the same as the threshold in the .tcl # test. Both tests should produce exactly the same results. vtk.test.Testing.compareImage(iren.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=10) vtk.test.Testing.interact()
import vtk # set up the renderer and render window _renderer = vtk.vtkRenderer() _renderWindow = vtk.vtkRenderWindow() _renderWindow.AddRenderer(_renderer) _renderWindow.SetSize(640,480) _renderer.SetBackground(1,1,1) # load the vtk file _dataReader = vtk.vtkDataSetReader() _dataReader.SetFileName("Flinders_ranges.vtk") # load the jpeg image _jpegReader = vtk.vtkJPEGReader() _jpegReader.SetFileName("Flinders_eval.jpg") # map the image onto a plane _tex = vtk.vtkTexture() _tex.SetInput(_jpegReader.GetOutput()) _plane = vtk.vtkPlaneSource() _planeMapper = vtk.vtkPolyDataMapper() _planeMapper.SetInput(_plane.GetOutput()) _planeActor = vtk.vtkActor() _planeActor.SetMapper(_planeMapper) _planeActor.SetTexture(_tex) # alternatively, just grab the image _jpgImgActor = vtk.vtkImageActor()
def __init__(self, filepaths): VolumeImageReader.__init__(self, filepaths) self.reader = vtk.vtkJPEGReader()
def prepareActorWithShadersAndMapper(self, points, poly, tdir): # Set point normals self.pointNormalsArray = vtk.vtkDoubleArray() pointNormalsArray = self.pointNormalsArray pointNormalsArray.SetNumberOfComponents(3) # 3d normals (ie x,y,z) pointNormalsArray.SetNumberOfTuples(points.GetNumberOfPoints()) # Add the data to the normals array (use for tangent vector...) self.pointNormalsArray.SetTuple3(0, tdir[0], tdir[1], tdir[2]) pointNormalsArray.SetTuple3(1, tdir[0], tdir[1], tdir[2]) pointNormalsArray.SetTuple3(2, tdir[0], tdir[1], tdir[2]) pointNormalsArray.SetTuple3(3, tdir[0], tdir[1], tdir[2]) # Set point tcoords self.pointTCoordsArray = vtk.vtkDoubleArray() pointTCoordsArray = self.pointTCoordsArray pointTCoordsArray.SetNumberOfComponents(3) # 4d TCoords (ie s, t, p) pointTCoordsArray.SetNumberOfTuples(points.GetNumberOfPoints()) pointTCoordsArray.SetName("thickness_falloff") # Add the data to the TCoords array (use for expansion direction...) # Hmm, okay, now i see. if we do all of our calcs in VC # and the offset scale is constant there (which is how it is done now), # then the width of the polygon will never change # when zooming in and out, since the width is constant... th = self.linethickness / 2.0 fall = self.falloff pointTCoordsArray.SetTuple3(0, -1.0, th, fall) # (expansion dir, offset scale, falloff) pointTCoordsArray.SetTuple3(1, 1.0, th, fall) pointTCoordsArray.SetTuple3(2, 1.0, th, fall) pointTCoordsArray.SetTuple3(3, -1.0, th, fall) """ # Set gl_Color for each vertex, and have alpha = (1 - abs(expansion direction))^falloff pointColorArray = vtk.vtkDoubleArray() pointColorArray.SetNumberOfComponents(3) #4d TCoords (ie s, t, p) pointColorArray.SetNumberOfTuples( points.GetNumberOfPoints() ) pointColorArray.SetTuple3(0, 1., 0., 0.) pointColorArray.SetTuple3(1, 1., 0., 0.) pointColorArray.SetTuple3(2, 1., 0., 0.) pointColorArray.SetTuple3(3, 1., 0., 0.) """ polys = vtk.vtkCellArray() polys.InsertNextCell(poly) # appears that we need a texture for tcoords glsl attribute variable to be set # Apply the texture reader = vtk.vtkJPEGReader() reader.SetFileName("../examplesAndSandboxCode/test.jpeg") atext = vtk.vtkTexture() atext.SetInputConnection(reader.GetOutputPort()) atext.InterpolateOn() actor = self.actor actor.SetTexture(atext) quadPolyData = self.polydata quadPolyData.SetPoints(points) quadPolyData.SetPolys(polys) # Add the normals to the points in the polydata, on a vtkDataSetAttributes object quadPolyData.GetPointData().SetNormals(pointNormalsArray) quadPolyData.GetPointData().SetTCoords(pointTCoordsArray) quadPolyData.GetPointData().SetActiveTCoords("thickness_falloff") # actor.GetProperty().SetDiffuseColor(1, 0, 0) # Red # actor.GetProperty().SetSpecularColor(1, 0, 0) # Red # actor.GetProperty().SetEdgeVisibility(False) gl_mapper = self.gl_mapper gl_mapper.SetInputData(quadPolyData) actor.SetMapper(gl_mapper) gl_mapper.SetVertexShaderCode(vertshader) gl_mapper.SetFragmentShaderCode(fragshader) # gl_mapper.SetBlendModeToAdditive() val = actor.HasTranslucentPolygonalGeometry() # actor.ForceTranslucentOn() actor.VisibilityOff() return actor
def buildBaseMap(self): if self.baseMapActor <> None: self.renderer.RemoveActor( self.baseMapActor ) world_map = None map_border_size = 20 self.y0 = -90.0 self.x0 = 0.0 dataPosition = None if world_map == None: self.map_file = defaultMapFile self.map_cut = defaultMapCut else: self.map_file = world_map[0].name self.map_cut = world_map[1] self.world_cut = -1 if (self.roi <> None): roi_size = [ self.roi[1] - self.roi[0], self.roi[3] - self.roi[2] ] scale = (self.roi[1] - self.roi[0])/300.0 border_size = map_border_size * scale map_cut_size = [ roi_size[0] + 2*border_size, roi_size[1] + 2*border_size ] if map_cut_size[0] > 360.0: map_cut_size[0] = 360.0 if map_cut_size[1] > 180.0: map_cut_size[1] = 180.0 else: map_cut_size = [ 360, 180 ] if self.world_cut == -1: if (self.roi <> None): if roi_size[0] > 180: self.ComputeCornerPosition() self.world_cut = self.NormalizeMapLon( self.x0 ) else: dataPosition = [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ] else: dataPosition = [ 180, 0 ] # [ ( self.roi[1] + self.roi[0] ) / 2.0, ( self.roi[3] + self.roi[2] ) / 2.0 ] else: self.world_cut = self.map_cut self.imageInfo = vtk.vtkImageChangeInformation() image_reader = vtk.vtkJPEGReader() image_reader.SetFileName( self.map_file ) image_reader.Update() baseImage = image_reader.GetOutput() new_dims, scale = None, None if dataPosition == None: old_dims = baseImage.GetDimensions() baseImage = self.RollMap( baseImage ) new_dims = baseImage.GetDimensions() scale = [ 360.0/new_dims[0], 180.0/new_dims[1], 1 ] else: baseImage, new_dims = self.getBoundedMap( baseImage, dataPosition, map_cut_size, border_size ) scale = [ map_cut_size[0]/new_dims[0], map_cut_size[1]/new_dims[1], 1 ] self.baseMapActor = vtk.vtkImageActor() self.baseMapActor.SetOrigin( 0.0, 0.0, 0.0 ) self.baseMapActor.SetScale( scale ) self.baseMapActor.SetOrientation( 0.0, 0.0, 0.0 ) self.baseMapActor.SetOpacity( self.map_opacity[0] ) mapCorner = [ self.x0, self.y0 ] # self.xcenter = self.x0 # self.ycenter = self.y0 # self.adjustCamera( baseImage ) self.baseMapActor.SetPosition( mapCorner[0], mapCorner[1], 0.1 ) if vtk.VTK_MAJOR_VERSION <= 5: self.baseMapActor.SetInput(baseImage) else: self.baseMapActor.SetInputData(baseImage) self.mapCenter = [ self.x0 + map_cut_size[0]/2.0, self.y0 + map_cut_size[1]/2.0 ] self.renderer.AddActor( self.baseMapActor )