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 )
