def compare_png_images(self, image1_filename, image2_filename,
threshold=16, allow_shift=False):
"""Compare two PNG images on disc. No two pixels may differ with more
than the default threshold.
"""
import vtk
r1 = vtk.vtkPNGReader()
r1.SetFileName(image1_filename)
r1.Update()
r2 = vtk.vtkPNGReader()
r2.SetFileName(image2_filename)
r2.Update()
# there's a bug in VTK 5.0.1 where input images of unequal size
# (depending on which input is larger) will cause a segfault
# see http://www.vtk.org/Bug/bug.php?op=show&bugid=3586
# se we check for that situation and bail if it's the case
if r1.GetOutput().GetDimensions() != r2.GetOutput().GetDimensions():
em = 'Input images %s and %s are not of equal size.' % \
(image1_filename, image2_filename)
raise RuntimeError, em
# sometimes PNG files have an ALPHA component we have to chuck away
# do this for both images
ec1 = vtk.vtkImageExtractComponents()
ec1.SetComponents(0,1,2)
ec1.SetInput(r1.GetOutput())
ec2 = vtk.vtkImageExtractComponents()
ec2.SetComponents(0,1,2)
ec2.SetInput(r2.GetOutput())
idiff = vtk.vtkImageDifference()
idiff.SetThreshold(threshold)
if allow_shift:
idiff.AllowShiftOn()
else:
idiff.AllowShiftOff()
idiff.SetImage(ec1.GetOutput())
idiff.SetInputConnection(ec2.GetOutputPort())
idiff.Update()
return idiff.GetThresholdedError()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkPNGReader(), 'Reading vtkPNG.',
(), ('vtkPNG',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def do_test(self):
vw = vtk.vtkButtonWidget()
vr = vtk.vtkTexturedButtonRepresentation2D()
vr.SetNumberOfStates(1)
r = vtk.vtkPNGReader()
r.SetFileName("Pepper.png")
r.Update()
image = r.GetOutput()
vr.SetButtonTexture(0, image)
vw.SetRepresentation(vr)
w = vcs.vtk_ui.widget.Widget(self.inter, vw)
w.show()
width, height, _ = image.GetDimensions()
bounds = (0, 0 + width, 0, height, 0, 0)
vr.SetPlaceFactor(1)
vr.PlaceWidget(bounds)
w.detach()
assert vr.GetRenderer() is None and vw.GetCurrentRenderer() is None, "Renderer is set after detach"
assert vw.GetInteractor() is None, "Interactor set after detach"
assert w.showing() == False, "Widget is flagged as Enabled"
assert w not in vcs.vtk_ui.manager.get_manager(self.inter).widgets, "Widget still being managed"
assert w.interactor is None, "Widget has a reference to interactor"
self.passed = 0
def testImportExport(self):
"Testing if images can be imported to and from numeric arrays."
imp = vtkImageImportFromArray()
exp = vtkImageExportToArray()
idiff = vtk.vtkImageDifference()
img_dir = Testing.getAbsImagePath("")
for i in glob.glob(os.path.join(img_dir, "*.png")):
# Putting the reader outside the loop causes bad problems.
reader = vtk.vtkPNGReader()
reader.SetFileName(i)
reader.Update()
# convert the image to a Numeric Array and convert it back
# to an image data.
exp.SetInputConnection(reader.GetOutputPort())
imp.SetArray(exp.GetArray())
# ensure there is no difference between orig image and the
# one we converted and un-converted.
idiff.SetInputConnection(imp.GetOutputPort())
idiff.SetImage(reader.GetOutput())
idiff.Update()
err = idiff.GetThresholdedError()
msg = "Test failed on image %s, with threshold "\
"error: %d"%(i, err)
self.assertEqual(err, 0.0, msg)
def testRenderMesh(self):
# Create a "render mesh" operator
renderMesh = self.operationManager.createOperation(
'smtk.extension.matplotlib.render_mesh.RenderMesh')
if not renderMesh:
raise RuntimeError('Could not find operator \'render mesh\'')
# Set the operator's parameters
print renderMesh.parameters()
renderMesh.parameters().find(
'mesh').setValue(self.meshResource.meshes())
self.outFile = os.path.join(
smtk.testing.TEMP_DIR, str(smtk.common.UUID.random()) + '.png')
renderMesh.parameters().find('filename').setValue(self.outFile)
# Execute the operator
result = renderMesh.operate()
if self.interactive() and self.haveVTK() and self.haveVTKExtension():
import vtk
self.startRenderTest()
reader = vtk.vtkPNGReader()
reader.SetFileName(self.outFile)
reader.Update()
self.addImageToScene(reader)
cam = self.renderer.GetActiveCamera()
self.renderer.ResetCamera()
self.renderWindow.Render()
self.interact()
def removeAlpha(file):
freader = vtk.vtkPNGReader()
freader.SetFileName(file)
removealpha = vtk.vtkImageExtractComponents()
removealpha.SetComponents(0,1,2)
removealpha.SetInputConnection(freader.GetOutputPort())
removealpha.Update()
return removealpha.GetOutput()
def setupReader(img):
rd = vtk.vtkPNGReader()
rd.SetFileName(img1)
rd.Update()
imp = vtkImageImportFromArray()
exp = vtkImageExportToArray()
exp.SetInputConnection(rd.GetOutputPort())
imp.SetArray(exp.GetArray())
return imp
def do_test(self):
self.win.SetSize((100, 100))
vw = vtk.vtkButtonWidget()
vr = vtk.vtkTexturedButtonRepresentation2D()
vr.SetNumberOfStates(1)
r = vtk.vtkPNGReader()
r.SetFileName("Pepper.png")
r.Update()
image = r.GetOutput()
vr.SetButtonTexture(0, image)
vw.SetRepresentation(vr)
w = vcs.vtk_ui.widget.Widget(self.inter, vw)
w.show()
def dummy(*args, **kwargs):
pass
w.subscribe("StartInteractionEvent", dummy)
# Make sure event was properly subscribed to
assert "StartInteractionEvent" in w.subscriptions, "Event not in subscriptions"
# Check observers of w for the tag in w.subscriptions
tag = w.subscriptions["StartInteractionEvent"]
c = vw.GetCommand(tag)
assert c is not None, "Listener not attached to widget"
try:
w.subscribe("StartInteractionEvent", dummy)
print "Failed to notice double event subscription on widget"
return
except KeyError:
pass
w.unsubscribe("StartInteractionEvent")
assert "StartInteractionEvent" not in w.subscriptions, "Did not remove event from subscriptions on unsubscribe"
# Test multiple unsubscriptions
w.subscribe("EndInteractionEvent", dummy)
w.subscribe("StartInteractionEvent", dummy)
w.unsubscribe("StartInteractionEvent", "EndInteractionEvent")
assert (
"EndInteractionEvent" not in w.subscriptions and "StartInteractionEvent" not in w.subscriptions
), "Did not remove both events from widget subscriptions"
try:
w.unsubscribe("StartInteractionEvent")
print "Failed to notice double unsubscribe on widget"
return
except KeyError:
pass
self.passed = 0
def image_from_file(fname):
try:
rd = vtk.vtkPNGReader()
rd.SetFileName(fname)
rd.Update()
exp = vtkImageExportToArray()
exp.SetInputConnection(rd.GetOutputPort())
areader = exp.GetArray()
except Exception,err:
print "Problem opening file",err
return None
def image_from_file(fname):
try:
rd = vtk.vtkPNGReader()
rd.SetFileName(fname)
removeAlpha = vtk.vtkImageExtractComponents()
removeAlpha.SetComponents(0, 1, 2)
removeAlpha.SetInputConnection(rd.GetOutputPort())
removeAlpha.Update()
return removeAlpha.GetOutput()
except Exception, err:
print "Problem opening file '%s': %s" % (fname, err)
return None
def getFromCache(self, datafilename, chName, purpose): """ Retrieve a MIP image from cache """ key = self.getCacheKey(datafilename, chName, purpose) directory = scripting.get_preview_dir() filename = "%s.png" % key filepath = os.path.join(directory, filename) if not os.path.exists(filepath): return None reader = vtk.vtkPNGReader() reader.SetFileName(filepath) reader.Update() return reader.GetOutput()
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 do_test(self):
self.win.SetSize((100, 100))
vw = vtk.vtkButtonWidget()
vr = vtk.vtkTexturedButtonRepresentation2D()
vr.SetNumberOfStates(1)
r = vtk.vtkPNGReader()
r.SetFileName("Pepper.png")
r.Update()
image = r.GetOutput()
vr.SetButtonTexture(0, image)
vw.SetRepresentation(vr)
w = vcs.vtk_ui.widget.Widget(self.inter, vw)
w.show()
width, height, _ = image.GetDimensions()
bounds = (0, 0 + width, 0, height, 0, 0)
vr.SetPlaceFactor(1)
vr.PlaceWidget(bounds)
self.test_file = "test_vtk_ui_widget_show.png"
if self.args:
self.passed = self.check_image(self.args[0])
if self.passed == 1:
print "Failed to show correctly"
return
else:
generate_png(self.win, self.test_file)
assert w.showing(), "showing() thinks hidden while showing"
w.hide()
assert w.showing() == False, "showing() thinks showing while hidden"
self.test_file = "test_vtk_ui_widget_hide.png"
if len(self.args) > 1:
self.passed = self.check_image(self.args[1])
if self.passed == 1:
print "Failed to hide correctly"
return
else:
generate_png(self.win, self.test_file)
self.test_file = None
self.passed = 0
def ReadPNGImageFile(self):
if (self.InputFileName == '') & (self.InputFilePrefix == ''):
self.PrintError('Error: no InputFileName or InputFilePrefix.')
self.PrintLog('Reading PNG image file.')
reader = vtk.vtkPNGReader()
if self.InputFileName != '':
reader.SetFileName(self.InputFileName)
else:
reader.SetFilePrefix(self.InputFilePrefix)
if self.InputFilePattern != '':
reader.SetFilePattern(self.InputFilePattern)
else:
reader.SetFilePattern("%s%04d.png")
reader.SetDataExtent(self.DataExtent)
reader.SetDataSpacing(self.DataSpacing)
reader.SetDataOrigin(self.DataOrigin)
reader.Update()
self.Image = reader.GetOutput()
def updateContents(self, inputPorts):
if self.view == None:
self.view = pvsp.CreateRenderView()
renWin = self.view.GetRenderWindow()
self.SetRenderWindow(renWin)
iren = renWin.GetInteractor()
iren.SetNonInteractiveRenderDelay(0)
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
# Load the uvcdat logo and use it for overlay
logoPath = system.vistrails_root_directory() + "/gui/uvcdat/resources/images/uvcdat_logo_transparent.png"
reader = vtk.vtkPNGReader()
reader.SetFileName(logoPath)
reader.Update()
imageActor = vtk.vtkImageActor()
imageActor.SetInput(reader.GetOutput())
self.overlayRenderer = vtk.vtkRenderer()
self.overlayRenderer.AddActor(imageActor)
renWin.SetNumberOfLayers(renWin.GetNumberOfLayers() + 1)
self.overlayRenderer.SetLayer(renWin.GetNumberOfLayers() - 1)
renWin.AddRenderer(self.overlayRenderer)
self.overlayRenderer.SetViewport(0.7, 0, 1.0, 0.3)
del self.view.Representations[:]
# Fetch variables from the input port
(location, representations) = inputPorts
for rep in representations:
rep.set_view(self.view)
rep.execute()
# Set view specific properties
self.view.CenterAxesVisibility = 0
self.view.Background = [0.6, 0.6, 0.6]
self.view.ResetCamera()
self.view.StillRender()
QCellWidget.updateContents(self, inputPorts)
def createLogo(self):
if self.canvas.drawLogo:
if self.logoRepresentation == None:
defaultLogoFile = os.path.join(sys.prefix,"share","vcs","uvcdat.png")
reader = vtk.vtkPNGReader()
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.882, 0.0 )
self.logoRepresentation.SetPosition2( 0.10, 0.05 )
self.logoRepresentation.GetImageProperty().SetOpacity( .8 )
self.logoRepresentation.GetImageProperty().SetDisplayLocationToBackground()
if (self.logoRenderer == None):
self.logoRenderer = vtk.vtkRenderer()
self.logoRenderer.AddViewProp(self.logoRepresentation)
self.logoRepresentation.SetRenderer(self.logoRenderer)
def create_textured_plane(**kwargs):
"""
create a plane with correct size and texture it with a map
"""
image_reader = vtk.vtkPNGReader()
image_reader.SetFileName(kwargs['map'])
plane = vtk.vtkPlaneSource()
size = kwargs['size']
z_level = 0.0
plane.SetOrigin(-0.5*size[0], -0.5*size[1], z_level)
plane.SetPoint1(+0.5*size[0], -0.5*size[1], z_level)
plane.SetPoint2(-0.5*size[0], +0.5*size[1], z_level)
texture = vtk.vtkTexture()
texture.SetInputConnection(image_reader.GetOutputPort())
texture_plane = vtk.vtkTextureMapToPlane()
texture_plane.SetInputConnection(plane.GetOutputPort())
return texture_plane, texture
def vtkRegressionTestImage( renWin ):
"""vtkRegressionTestImage(renWin) -- produce regression image for window
This function writes out a regression .png file for a vtkWindow.
Does anyone involved in testing care to elaborate?
"""
imageIndex=-1;
for i in range(0, len(sys.argv)):
if sys.argv[i] == '-V' and i < len(sys.argv)-1:
imageIndex = i+1
if imageIndex != -1:
fname = os.path.join(vtkGetDataRoot(), sys.argv[imageIndex])
rt_w2if = vtk.vtkWindowToImageFilter()
rt_w2if.SetInput(renWin)
if os.path.isfile(fname):
pass
else:
rt_pngw = vtk.vtkPNGWriter()
rt_pngw.SetFileName(fname)
rt_pngw.SetInputConnection(rt_w2if.GetOutputPort())
rt_pngw.Write()
rt_pngw = None
rt_png = vtk.vtkPNGReader()
rt_png.SetFileName(fname)
rt_id = vtk.vtkImageDifference()
rt_id.SetInputConnection(rt_w2if.GetOutputPort())
rt_id.SetImageConnection(rt_png.GetOutputPort())
rt_id.Update()
if rt_id.GetThresholdedError() <= 10:
return 1
else:
sys.stderr.write('Failed image test: %f\n'
% rt_id.GetThresholdedError())
return 0
return 2
def createLogo(self):
if self.canvas.drawLogo is False:
## Ok we do not want a logo here
return
# Pth to logo
logoFile = os.path.join(sys.prefix,"share","vcs","uvcdat.png")
# VTK reader for logo
logoRdr=vtk.vtkPNGReader()
logoRdr.SetFileName(logoFile)
logoRdr.Update()
x0,x1,y0,y1,z0,z1 = logoRdr.GetDataExtent()
ia = vtk.vtkImageActor()
ia.GetMapper().SetInputConnection(logoRdr.GetOutputPort())
ren = self.createRenderer()
self.renWin.AddRenderer(ren)
r,g,b = self.canvas.backgroundcolor
ren.SetBackground(r/255.,g/255.,b/255.)
#ren.SetLayer(self.renWin.GetNumberOfLayers()-1)
ren.AddActor(ia)
self.logo = ren
self.logoExtent = [x1,y1]
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 testRasterEPS(self):
"""Test EPS output when Write3DPropsAsRasterImage is on."""
# Get a temporary file name. Set the extension to empty since
# the exporter appends a suitable extension.
tmp_eps = tempfile.mktemp('')
# Write an EPS file.
exp = vtk.vtkGL2PSExporter()
exp.SetRenderWindow(self.renWin)
exp.SetFilePrefix(tmp_eps)
# Turn off compression so PIL can read file.
exp.CompressOff()
exp.SetSortToOff()
exp.DrawBackgroundOn()
exp.Write3DPropsAsRasterImageOn()
exp.Write()
# Now read the EPS file using PIL.
tmp_eps += '.eps'
im = Image.open(tmp_eps)
# Get a temporary name for the PNG file.
tmp_png = tempfile.mktemp('.png')
im.save(tmp_png)
# Now read the saved image and compare it for the test.
png_r = vtk.vtkPNGReader()
png_r.SetFileName(tmp_png)
png_r.Update()
img = png_r.GetOutput()
# Cleanup. Do this first because if the test fails, an
# exception is raised and the temporary files won't be
# removed.
self._cleanup([tmp_eps, tmp_png])
img_file = "TestGL2PSExporter.png"
Testing.compareImageWithSavedImage(img,
Testing.getAbsImagePath(img_file))
# Interact if necessary.
Testing.interact()
def __init__(self, module_manager):
ModuleBase.__init__(self, module_manager)
self._reader = vtk.vtkPNGReader()
self._reader.SetFileDimensionality(3)
module_utils.setup_vtk_object_progress(self, self._reader,
'Reading PNG images.')
self._config.filePattern = '%03d.png'
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' :
'PNG files (*.png)|*.png|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,
'vtkPNGReader' : self._reader})
self.sync_module_logic_with_config()
def testDeciFranFace(self):
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
ren2 = vtk.vtkRenderer()
ren3 = vtk.vtkRenderer()
ren4 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.AddRenderer(ren2)
renWin.AddRenderer(ren3)
renWin.AddRenderer(ren4)
pnm1 = vtk.vtkPNGReader()
pnm1.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.png")
atext = vtk.vtkTexture()
atext.SetInputConnection(pnm1.GetOutputPort())
atext.InterpolateOn()
# create a cyberware source
#
fran = vtk.vtkPolyDataReader()
fran.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.vtk")
# Create a table of decimation conditions
#
boundaryVertexDeletion = ["On", "Off"]
accumulates = ["On", "Off"]
deci = dict()
mapper = dict()
actor = dict()
for topology in boundaryVertexDeletion:
for accumulate in accumulates:
idx = topology + accumulate
deci.update({idx: vtk.vtkDecimatePro()})
deci[idx].SetInputConnection(fran.GetOutputPort())
deci[idx].SetTargetReduction(.95)
if topology == "On":
deci[idx].PreserveTopologyOn()
elif topology == "Off":
deci[idx].PreserveTopologyOff()
if accumulate == "On":
deci[idx].AccumulateErrorOn()
elif accumulate == "Off":
deci[idx].AccumulateErrorOff()
mapper.update({idx: vtk.vtkPolyDataMapper()})
mapper[idx].SetInputConnection(deci[idx].GetOutputPort())
actor.update({idx: vtk.vtkActor()})
actor[idx].SetMapper(mapper[idx])
actor[idx].SetTexture(atext)
# Add the actors to the renderer, set the background and size
#
ren1.SetViewport(0, .5, .5, 1)
ren2.SetViewport(.5, .5, 1, 1)
ren3.SetViewport(0, 0, .5, .5)
ren4.SetViewport(.5, 0, 1, .5)
ren1.AddActor(actor["OnOn"])
ren2.AddActor(actor["OnOff"])
ren3.AddActor(actor["OffOn"])
ren4.AddActor(actor["OffOff"])
camera = vtk.vtkCamera()
ren1.SetActiveCamera(camera)
ren2.SetActiveCamera(camera)
ren3.SetActiveCamera(camera)
ren4.SetActiveCamera(camera)
ren1.GetActiveCamera().SetPosition(0.314753, -0.0699988, -0.264225)
ren1.GetActiveCamera().SetFocalPoint(0.00188636, -0.136847, -5.84226e-09)
ren1.GetActiveCamera().SetViewAngle(30)
ren1.GetActiveCamera().SetViewUp(0, 1, 0)
ren1.ResetCameraClippingRange()
ren2.ResetCameraClippingRange()
ren3.ResetCameraClippingRange()
ren4.ResetCameraClippingRange()
ren1.SetBackground(1, 1, 1)
ren2.SetBackground(1, 1, 1)
ren3.SetBackground(1, 1, 1)
ren4.SetBackground(1, 1, 1)
renWin.SetSize(500, 500)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "deciFranFace.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def rhombicuboctahedron():
import vtk
# First, you need to store the vertex locations.
import numpy as np
fu = 1 # full unit
hu = .5 # half unit
d = np.sqrt((fu**2) / 2) # diag
hh = hu + d # half height
# left view faces us
import utool as ut
import six
import itertools
counter = ut.partial(six.next, itertools.count(0))
vertex_locations = vtk.vtkPoints()
vertex_locations.SetNumberOfPoints(24)
p1, p2, p3 = np.array([
(-hu, -hu, hh),
(hu, -hu, hh),
(hu, hu, hh),
(-hu, hu, hh),
]).T
plist = [p1, p2, p3]
# three of the six main faces
#perms = list(itertools.permutations((0, 1, 2), 3))
perms = [(0, 1, 2), (0, 2, 1), (2, 0, 1)]
vertex_array = []
# VERTEXES
# left, up, back
vplist = ['L', 'U', 'B', 'R', 'D', 'F']
vpdict = {}
print('perms = %r' % (perms, ))
for x in range(3):
vp = vplist[x]
p = np.vstack(ut.take(plist, perms[x])).T
counts = [counter() for z in range(4)]
vpdict[vp] = counts
vertex_array.extend(p.tolist())
vertex_locations.SetPoint(counts[0], p[0])
vertex_locations.SetPoint(counts[1], p[1])
vertex_locations.SetPoint(counts[2], p[2])
vertex_locations.SetPoint(counts[3], p[3])
# three more of the six main faces
perms = [(0, 1, 2), (0, 2, 1), (2, 0, 1)]
plist[-1] = -plist[-1]
# right, down, front
print('perms = %r' % (perms, ))
for x in range(3):
p = np.vstack(ut.take(plist, perms[x])).T
counts = [counter() for z in range(4)]
vp = vplist[x + 3]
vpdict[vp] = counts
vertex_array.extend(p.tolist())
vertex_locations.SetPoint(counts[0], p[0])
vertex_locations.SetPoint(counts[1], p[1])
vertex_locations.SetPoint(counts[2], p[2])
vertex_locations.SetPoint(counts[3], p[3])
pd = vtk.vtkPolyData()
pd.SetPoints(vertex_locations)
polygon_faces = vtk.vtkCellArray()
face_dict = {
'L': [vpdict['L'][0], vpdict['L'][1], vpdict['L'][2], vpdict['L'][3]],
'D': [vpdict['D'][0], vpdict['D'][1], vpdict['D'][2], vpdict['D'][3]],
'U': [vpdict['U'][0], vpdict['U'][1], vpdict['U'][2], vpdict['U'][3]],
'F': [vpdict['F'][0], vpdict['F'][1], vpdict['F'][2], vpdict['F'][3]],
'R': [vpdict['R'][0], vpdict['R'][1], vpdict['R'][2], vpdict['R'][3]],
'B': [vpdict['B'][0], vpdict['B'][1], vpdict['B'][2], vpdict['B'][3]],
'FL': [
vpdict['L'][0],
vpdict['L'][3],
vpdict['F'][2],
vpdict['F'][3],
],
'BL': [
vpdict['L'][1],
vpdict['L'][2],
vpdict['B'][2],
vpdict['B'][3],
],
'UL': [
vpdict['L'][2],
vpdict['L'][3],
vpdict['U'][3],
vpdict['U'][2],
],
'DL': [
vpdict['L'][0],
vpdict['L'][1],
vpdict['D'][2],
vpdict['D'][3],
],
'UFL': [
vpdict['L'][3],
vpdict['F'][2],
vpdict['U'][3],
],
'DFL': [
vpdict['L'][0],
vpdict['F'][3],
vpdict['D'][3],
],
'UBL': [
vpdict['L'][2],
vpdict['B'][2],
vpdict['U'][2],
],
'DBL': [
vpdict['L'][1],
vpdict['B'][3],
vpdict['D'][2],
],
'UFR': [
vpdict['R'][3],
vpdict['F'][1],
vpdict['U'][0],
],
'DFR': [
vpdict['R'][0],
vpdict['F'][0],
vpdict['D'][0],
],
'UBR': [
vpdict['R'][2],
vpdict['B'][1],
vpdict['U'][1],
],
'DBR': [
vpdict['R'][1],
vpdict['B'][0],
vpdict['D'][1],
],
'FR': [
vpdict['R'][3],
vpdict['R'][0],
vpdict['F'][0],
vpdict['F'][1],
],
'BR': [
vpdict['R'][2],
vpdict['R'][1],
vpdict['B'][0],
vpdict['B'][1],
],
'UR': [
vpdict['R'][3],
vpdict['R'][2],
vpdict['U'][1],
vpdict['U'][0],
],
'DR': [
vpdict['R'][1],
vpdict['R'][0],
vpdict['D'][0],
vpdict['D'][1],
],
'DF': [
vpdict['F'][0],
vpdict['F'][3],
vpdict['D'][3],
vpdict['D'][0],
],
'DB': [
vpdict['B'][3],
vpdict['B'][0],
vpdict['D'][1],
vpdict['D'][2],
],
'UF': [
vpdict['F'][1],
vpdict['F'][2],
vpdict['U'][3],
vpdict['U'][0],
],
'UB': [
vpdict['B'][2],
vpdict['B'][1],
vpdict['U'][1],
vpdict['U'][2],
],
}
for key, vert_ids in face_dict.items():
#if key != 'L':
# continue
if len(vert_ids) == 4:
q = vtk.vtkQuad()
else:
q = vtk.vtkTriangle()
for count, idx in enumerate(vert_ids):
q.GetPointIds().SetId(count, idx)
polygon_faces.InsertNextCell(q)
# Next you create a vtkPolyData to store your face and vertex information
#that
# represents your polyhedron.
pd = vtk.vtkPolyData()
pd.SetPoints(vertex_locations)
pd.SetPolys(polygon_faces)
face_stream = vtk.vtkIdList()
face_stream.InsertNextId(polygon_faces.GetNumberOfCells())
vertex_list = vtk.vtkIdList()
polygon_faces.InitTraversal()
while polygon_faces.GetNextCell(vertex_list) == 1:
face_stream.InsertNextId(vertex_list.GetNumberOfIds())
for j in range(vertex_list.GetNumberOfIds()):
face_stream.InsertNextId(vertex_list.GetId(j))
ug = vtk.vtkUnstructuredGrid()
ug.SetPoints(vertex_locations)
ug.InsertNextCell(vtk.VTK_POLYHEDRON, face_stream)
#writer = vtk.vtkUnstructuredGridWriter()
#writer.SetFileName("rhombicuboctahedron.vtk")
##writer.SetInputData(ug)
#writer.SetInput(ug)
#writer.Write()
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(ug)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
if 1:
# Read the image data from a file
import utool as ut
textureCoords = vtk.vtkFloatArray()
textureCoords.SetNumberOfComponents(3)
#coords = ut.take(vertex_array, face_dict['L'])
#for coord in coords:
# textureCoords.InsertNextTuple(tuple(coord))
textureCoords.InsertNextTuple((0, 0, 0))
textureCoords.InsertNextTuple((1, 0, 0))
textureCoords.InsertNextTuple((1, 1, 0))
textureCoords.InsertNextTuple((0, 1, 0))
# Create texture object
fpath = ut.grab_test_imgpath('zebra.png')
reader = vtk.vtkPNGReader()
reader.SetFileName(fpath)
texture = vtk.vtkTexture()
texture.SetInput(reader.GetOutput())
texture.RepeatOff()
texture.InterpolateOff()
ptdat = pd.GetPointData()
ptdat.SetTCoords(textureCoords)
actor.SetTexture(texture)
ren = vtk.vtkRenderer()
ren.AddActor(actor)
renw = vtk.vtkRenderWindow()
renw.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renw)
ren.ResetCamera()
renw.Render()
iren.Start()
def compareImageWithSavedImage(src_img, img_fname, threshold=10):
"""Compares a source image (src_img, which is a vtkImageData) with
the saved image file whose name is given in the second argument.
If the image file does not exist the image is generated and
stored. If not the source image is compared to that of the
figure. This function also handles multiple images and finds the
best matching image.
"""
global _NO_IMAGE
if _NO_IMAGE:
return
f_base, f_ext = os.path.splitext(img_fname)
if not os.path.isfile(img_fname):
# generate the image
pngw = vtk.vtkPNGWriter()
pngw.SetFileName(_getTempImagePath(img_fname))
pngw.SetInput(src_img)
pngw.Write()
return
pngr = vtk.vtkPNGReader()
pngr.SetFileName(img_fname)
idiff = vtk.vtkImageDifference()
idiff.SetInput(src_img)
idiff.SetImage(pngr.GetOutput())
idiff.Update()
min_err = idiff.GetThresholdedError()
img_err = min_err
best_img = img_fname
err_index = 0
count = 0
if min_err > threshold:
count = 1
test_failed = 1
err_index = -1
while 1: # keep trying images till we get the best match.
new_fname = f_base + "_%d.png"%count
if not os.path.exists(new_fname):
# no other image exists.
break
# since file exists check if it matches.
pngr.SetFileName(new_fname)
pngr.Update()
idiff.Update()
alt_err = idiff.GetThresholdedError()
if alt_err < threshold:
# matched,
err_index = count
test_failed = 0
min_err = alt_err
img_err = alt_err
best_img = new_fname
break
else:
if alt_err < min_err:
# image is a better match.
err_index = count
min_err = alt_err
img_err = alt_err
best_img = new_fname
count = count + 1
# closes while loop.
if test_failed:
_handleFailedImage(idiff, pngr, best_img)
# Print for Dart.
_printDartImageError(img_err, err_index, f_base)
msg = "Failed image test: %f\n"%idiff.GetThresholdedError()
raise AssertionError, msg
# output the image error even if a test passed
_printDartImageSuccess(img_err, err_index)
def _load_file(filename, c, alpha, threshold, spacing, unpack):
fl = filename.lower()
################################################################# other formats:
if fl.endswith(".xml") or fl.endswith(".xml.gz") or fl.endswith(".xdmf"):
# Fenics tetrahedral file
actor = loadDolfin(filename)
elif fl.endswith(".neutral") or fl.endswith(
".neu"): # neutral tetrahedral file
actor = loadNeutral(filename)
elif fl.endswith(".gmsh"): # gmesh file
actor = loadGmesh(filename)
elif fl.endswith(".pcd"): # PCL point-cloud format
actor = loadPCD(filename)
actor.GetProperty().SetPointSize(2)
elif fl.endswith(".off"):
actor = loadOFF(filename)
elif fl.endswith(".3ds"): # 3ds format
actor = load3DS(filename)
elif fl.endswith(".wrl"):
importer = vtk.vtkVRMLImporter()
importer.SetFileName(filename)
importer.Read()
importer.Update()
actors = importer.GetRenderer().GetActors() #vtkActorCollection
actors.InitTraversal()
wacts = []
for i in range(actors.GetNumberOfItems()):
act = actors.GetNextActor()
wacts.append(act)
actor = Assembly(wacts)
################################################################# volumetric:
elif fl.endswith(".tif") or fl.endswith(".slc") or fl.endswith(".vti") \
or fl.endswith(".mhd") or fl.endswith(".nrrd") or fl.endswith(".nii") \
or fl.endswith(".dem"):
img = loadImageData(filename, spacing)
if threshold is False:
if c is None and alpha == 1:
c = ['b', 'lb', 'lg', 'y',
'r'] # good for blackboard background
alpha = (0.0, 0.0, 0.2, 0.4, 0.8, 1)
actor = Volume(img, c, alpha)
else:
actor = Volume(img).isosurface(threshold=threshold)
actor.color(c).alpha(alpha)
################################################################# 2D images:
elif fl.endswith(".png") or fl.endswith(".jpg") or fl.endswith(
".bmp") or fl.endswith(".jpeg"):
if ".png" in fl:
picr = vtk.vtkPNGReader()
elif ".jpg" in fl or ".jpeg" in fl:
picr = vtk.vtkJPEGReader()
elif ".bmp" in fl:
picr = vtk.vtkBMPReader()
picr.SetFileName(filename)
picr.Update()
actor = Picture() # object derived from vtk.vtkImageActor()
actor.SetInputData(picr.GetOutput())
if alpha is None:
alpha = 1
actor.SetOpacity(alpha)
################################################################# multiblock:
elif fl.endswith(".vtm") or fl.endswith(".vtmb"):
read = vtk.vtkXMLMultiBlockDataReader()
read.SetFileName(filename)
read.Update()
mb = read.GetOutput()
if unpack:
acts = []
for i in range(mb.GetNumberOfBlocks()):
b = mb.GetBlock(i)
if isinstance(b,
(vtk.vtkPolyData, vtk.vtkImageData,
vtk.vtkUnstructuredGrid, vtk.vtkStructuredGrid,
vtk.vtkRectilinearGrid)):
acts.append(b)
return acts
else:
return mb
################################################################# numpy:
elif fl.endswith(".npy"):
acts = loadNumpy(filename)
if unpack == False:
return Assembly(acts)
return acts
elif fl.endswith(".geojson") or fl.endswith(".geojson.gz"):
return loadGeoJSON(fl)
################################################################# polygonal mesh:
else:
if fl.endswith(".vtk"): # read all legacy vtk types
#output can be:
# PolyData, StructuredGrid, StructuredPoints, UnstructuredGrid, RectilinearGrid
reader = vtk.vtkDataSetReader()
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
reader.ReadAllTensorsOn()
reader.ReadAllFieldsOn()
reader.ReadAllNormalsOn()
reader.ReadAllColorScalarsOn()
elif fl.endswith(".ply"):
reader = vtk.vtkPLYReader()
elif fl.endswith(".obj"):
reader = vtk.vtkOBJReader()
elif fl.endswith(".stl"):
reader = vtk.vtkSTLReader()
elif fl.endswith(".byu") or fl.endswith(".g"):
reader = vtk.vtkBYUReader()
elif fl.endswith(".foam"): # OpenFoam
reader = vtk.vtkOpenFOAMReader()
elif fl.endswith(".pvd"):
reader = vtk.vtkXMLGenericDataObjectReader()
elif fl.endswith(".vtp"):
reader = vtk.vtkXMLPolyDataReader()
elif fl.endswith(".vts"):
reader = vtk.vtkXMLStructuredGridReader()
elif fl.endswith(".vtu"):
reader = vtk.vtkXMLUnstructuredGridReader()
elif fl.endswith(".vtr"):
reader = vtk.vtkXMLRectilinearGridReader()
elif fl.endswith(".pvtk"):
reader = vtk.vtkPDataSetReader()
elif fl.endswith(".pvtr"):
reader = vtk.vtkXMLPRectilinearGridReader()
elif fl.endswith("pvtu"):
reader = vtk.vtkXMLPUnstructuredGridReader()
elif fl.endswith(".txt") or fl.endswith(".xyz"):
reader = vtk.vtkParticleReader() # (format is x, y, z, scalar)
elif fl.endswith(".facet"):
reader = vtk.vtkFacetReader()
else:
return None
reader.SetFileName(filename)
reader.Update()
routput = reader.GetOutput()
if not routput:
colors.printc("~noentry Unable to load", filename, c=1)
return None
actor = Actor(routput, c, alpha)
if fl.endswith(".txt") or fl.endswith(".xyz"):
actor.GetProperty().SetPointSize(4)
actor.filename = filename
return actor
def __init__(self, data_source, input_link):
"""Parallel coordinates view constructor needs a valid DataSource plus
and external annotation link (from the icicle view).
"""
self.ds = data_source
self.input_link = input_link
# Set up callback to listen for changes in IcicleView selections
self.input_link.AddObserver("AnnotationChangedEvent", self.InputSelectionCallback)
# Set up an annotation link for other views to monitor selected image
self.output_link = vtk.vtkAnnotationLink()
# If you don't set the FieldType explicitly it ends up as UNKNOWN (as of 21 Feb 2010)
# See vtkSelectionNode doc for field and content type enum values
self.output_link.GetCurrentSelection().GetNode(0).SetFieldType(1) # Point
# The chart seems to force INDEX selection, so I'm using vtkConvertSelection below to get
# out PedigreeIds...
self.output_link.GetCurrentSelection().GetNode(0).SetContentType(2) # 2 = PedigreeIds, 4 = Indices
# Going to manually create output_link selection list, so not setting up callback for it...
if os.path.isfile(os.path.abspath('BlankImage.png')):
blank_file = 'BlankImage.png'
else:
# For use in app bundles
blank_file = os.path.join(sys.path[0],'BlankImage.png')
self.blankImageReader = vtk.vtkPNGReader()
self.blankImageReader.SetFileName(blank_file)
self.blankImageReader.Update()
tmp = self.blankImageReader.GetOutput().GetBounds()
self.flowSpacing = float(tmp[1]-tmp[0])*1.1
# Create a greyscale lookup table
self.lut = self.ds.GetGrayscaleLUT('gray')
self.lut.SetRange(self.blankImageReader.GetOutput().GetPointData().GetArray('PNGImage').GetRange()) # image intensity range
# Map the image through the lookup table
self.color = vtk.vtkImageMapToColors()
self.color.SetLookupTable(self.lut)
self.color.SetInput(self.blankImageReader.GetOutput())
self.resliceList = []
self.actorList = []
self.numImages = 1
# Map between indices of images and their Pedigree ID
self.pedigree_id_dict = {}
blankImageActor = vtk.vtkImageActor()
blankImageActor.SetInput(self.color.GetOutput())
blankImageActor.SetPickable(False)
blankImageActor.SetOpacity(0.1)
self.actorList.append(blankImageActor)
self.expSpread = 0.5
self.maxAngle = 80.0
self.renderer = vtk.vtkRenderer()
self.cam = self.renderer.GetActiveCamera()
# renderer.SetBackground(0.15, 0.12, 0.1)
# cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [68,57,53]]
# self.renderer.SetBackground(cc0,cc1,cc2)
# cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [60,60,60]]
cc0,cc1,cc2 = [float(ccVal)/255.0 for ccVal in [160, 160, 160]]
self.renderer.SetBackground(cc0,cc1,cc2)
self.renderer.AddActor(self.actorList[0])
self.highlightRect = vtk.vtkOutlineSource()
self.highlightRect.SetBounds(self.actorList[0].GetBounds())
self.highlightMapper = vtk.vtkPolyDataMapper()
self.highlightMapper.SetInputConnection(self.highlightRect.GetOutputPort(0))
self.highlightActor = vtk.vtkActor()
self.highlightActor.SetMapper(self.highlightMapper)
self.highlightActor.GetProperty().SetColor(0,0.5,1.0)
self.highlightActor.GetProperty().SetLineWidth(6.0)
self.highlightActor.GetProperty().SetOpacity(0.5)
self.highlightActor.SetOrientation(self.actorList[0].GetOrientation())
tmpPos = self.actorList[0].GetPosition()
usePos = (tmpPos[0],tmpPos[1],tmpPos[2]+0.01)
self.highlightActor.SetPosition(usePos)
# Setting as if nothing picked even though initialized position & orientation to actor0
self.highlightIndex = -1
self.highlightActor.SetPickable(False)
self.highlightActor.SetVisibility(False)
self.renderer.AddActor(self.highlightActor)
# Create the slider which will control the image positions
self.sliderRep = vtk.vtkSliderRepresentation2D()
self.sliderRep.SetMinimumValue(0)
self.sliderRep.SetMaximumValue(self.numImages-1)
self.sliderRep.SetValue(0)
self.window = vtk.vtkRenderWindow()
self.window.SetSize(600,300)
self.window.AddRenderer(self.renderer)
# Set up the interaction
self.interactorStyle = vtk.vtkInteractorStyleImage()
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor.SetInteractorStyle(self.interactorStyle)
self.window.SetInteractor(self.interactor)
self.sliderWidget = vtk.vtkSliderWidget()
self.sliderWidget.SetInteractor(self.interactor)
self.sliderWidget.SetRepresentation(self.sliderRep)
self.sliderWidget.SetAnimationModeToAnimate()
self.sliderWidget.EnabledOn()
self.sliderWidget.AddObserver("InteractionEvent", self.sliderCallback)
self.sliderWidget.AddObserver("EndInteractionEvent", self.endSliderCallback)
# Default flow direction Horizontal
self.FlowDirection = Direction.Horizontal
self.SetFlowDirection(self.FlowDirection)
# Set up callback to toggle between inspect modes (manip axes & select data)
# self.interactorStyle.AddObserver("SelectionChangedEvent", self.selectImage)
# Create callbacks for mouse events
self.mouseActions = {}
self.mouseActions["LeftButtonDown"] = 0
self.mouseActions["Picking"] = 0
self.interactorStyle.AddObserver("MouseMoveEvent", self.MouseMoveCallback)
self.interactorStyle.AddObserver("LeftButtonPressEvent", self.LeftButtonPressCallback)
self.interactorStyle.AddObserver("LeftButtonReleaseEvent", self.LeftButtonReleaseCallback)
self.cam.ParallelProjectionOn()
self.renderer.ResetCamera(self.actorList[0].GetBounds())
self.cam.Elevation(10)
self.renderer.ResetCameraClippingRange()
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# A script to test the vtkLassoStencilSource
reader = vtk.vtkPNGReader()
reader.SetDataSpacing(0.8,0.8,1.5)
reader.SetDataOrigin(0.0,0.0,0.0)
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
reader.Update()
shiftScale = vtk.vtkImageShiftScale()
shiftScale.SetInputConnection(reader.GetOutputPort())
shiftScale.SetScale(0.2)
shiftScale.Update()
points1 = vtk.vtkPoints()
points1.InsertNextPoint(80,50,0)
points1.InsertNextPoint(100,90,0)
points1.InsertNextPoint(200,50,0)
points1.InsertNextPoint(230,100,0)
points1.InsertNextPoint(150,170,0)
points1.InsertNextPoint(110,170,0)
points1.InsertNextPoint(80,50,0)
points2 = vtk.vtkPoints()
points2.InsertNextPoint(80,50,0)
points2.InsertNextPoint(100,90,0)
points2.InsertNextPoint(200,50,0)
points2.InsertNextPoint(230,100,0)
points2.InsertNextPoint(150,170,0)
points2.InsertNextPoint(110,170,0)
def Latex(
formula,
pos=(0, 0, 0),
normal=(0, 0, 1),
c='k',
s=1,
bg=None,
alpha=1,
res=30,
usetex=False,
fromweb=False,
):
"""
Render Latex formulas.
:param str formula: latex text string
:param list pos: position coordinates in space
:param list normal: normal to the plane of the image
:param c: face color
:param bg: background color box
:param int res: dpi resolution
:param bool usetex: use latex compiler of matplotlib
:param fromweb: retrieve the latex image from online server (codecogs)
You can access the latex formula from the `Actor` object with `actor.info['formula']`.
|latex| |latex.py|_
"""
vactor = None
try:
def build_img_web(formula, tfile):
import requests
if c == 'k':
ct = 'Black'
else:
ct = 'White'
wsite = 'http://latex.codecogs.com/png.latex'
try:
r = requests.get(wsite+'?\dpi{100} \huge \color{'+ct+'} ' + formula)
f = open(tfile, 'wb')
f.write(r.content)
f.close()
except requests.exceptions.ConnectionError:
colors.printc('Latex error. Web site unavailable?', wsite, c=1)
return None
def build_img_plt(formula, tfile):
import matplotlib.pyplot as plt
plt.rc('text', usetex=usetex)
formula1 = '$'+formula+'$'
plt.axis('off')
col = colors.getColor(c)
if bg:
bx = dict(boxstyle="square", ec=col, fc=colors.getColor(bg))
else:
bx = None
plt.text(0.5, 0.5, formula1,
size=res,
color=col,
alpha=alpha,
ha="center",
va="center",
bbox=bx)
plt.savefig('_lateximg.png', format='png',
transparent=True, bbox_inches='tight', pad_inches=0)
plt.close()
if fromweb:
build_img_web(formula, '_lateximg.png')
else:
build_img_plt(formula, '_lateximg.png')
from vtkplotter.actors import Image
picr = vtk.vtkPNGReader()
picr.SetFileName('_lateximg.png')
picr.Update()
vactor = Image()
vactor.SetInputData(picr.GetOutput())
vactor.info['formula'] = formula
vactor.alpha(alpha)
b = vactor.GetBounds()
xm, ym = (b[1]+b[0])/200*s, (b[3]+b[2])/200*s
vactor.SetOrigin(-xm, -ym, 0)
nax = np.linalg.norm(normal)
if nax:
normal = np.array(normal) / nax
theta = np.arccos(normal[2])
phi = np.arctan2(normal[1], normal[0])
vactor.SetScale(0.25/res*s, 0.25/res*s, 0.25/res*s)
vactor.RotateZ(np.rad2deg(phi))
vactor.RotateY(np.rad2deg(theta))
vactor.SetPosition(pos)
try:
import os
os.unlink('_lateximg.png')
except:
pass
except:
colors.printc('Error in Latex()\n', formula, c=1)
colors.printc(' latex or dvipng not installed?', c=1)
colors.printc(' Try: usetex=False' , c=1)
colors.printc(' Try: sudo apt install dvipng' , c=1)
return vactor
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# A script to test the stencil filter with a polydata stencil.
# Image pipeline
reader = vtk.vtkPNGReader()
reader.SetDataSpacing(0.8,0.8,1.5)
reader.SetDataOrigin(0.0,0.0,0.0)
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(12)
sphere.SetThetaResolution(12)
sphere.SetCenter(102,102,0)
sphere.SetRadius(60)
triangle = vtk.vtkTriangleFilter()
triangle.SetInputConnection(sphere.GetOutputPort())
stripper = vtk.vtkStripper()
stripper.SetInputConnection(triangle.GetOutputPort())
dataToStencil = vtk.vtkPolyDataToImageStencil()
dataToStencil.SetInputConnection(stripper.GetOutputPort())
dataToStencil.SetOutputSpacing(0.8,0.8,1.5)
dataToStencil.SetOutputOrigin(0.0,0.0,0.0)
stencil = vtk.vtkImageStencil()
stencil.SetInputConnection(reader.GetOutputPort())
stencil.SetStencilConnection(dataToStencil.GetOutputPort())
stencil.ReverseStencilOn()
stencil.SetBackgroundValue(500)
# test again with a contour
def testDeciFranFace(self):
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
ren2 = vtk.vtkRenderer()
ren3 = vtk.vtkRenderer()
ren4 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
renWin.AddRenderer(ren2)
renWin.AddRenderer(ren3)
renWin.AddRenderer(ren4)
pnm1 = vtk.vtkPNGReader()
pnm1.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.png")
atext = vtk.vtkTexture()
atext.SetInputConnection(pnm1.GetOutputPort())
atext.InterpolateOn()
# create a cyberware source
#
fran = vtk.vtkPolyDataReader()
fran.SetFileName(VTK_DATA_ROOT + "/Data/fran_cut.vtk")
# Create a table of decimation conditions
#
boundaryVertexDeletion = ["On", "Off"]
accumulates = ["On", "Off"]
deci = dict()
mapper = dict()
actor = dict()
for topology in boundaryVertexDeletion:
for accumulate in accumulates:
idx = topology + accumulate
deci.update({idx: vtk.vtkDecimatePro()})
deci[idx].SetInputConnection(fran.GetOutputPort())
deci[idx].SetTargetReduction(.95)
if topology == "On":
deci[idx].PreserveTopologyOn()
elif topology == "Off":
deci[idx].PreserveTopologyOff()
if accumulate == "On":
deci[idx].AccumulateErrorOn()
elif accumulate == "Off":
deci[idx].AccumulateErrorOff()
mapper.update({idx: vtk.vtkPolyDataMapper()})
mapper[idx].SetInputConnection(deci[idx].GetOutputPort())
actor.update({idx: vtk.vtkActor()})
actor[idx].SetMapper(mapper[idx])
actor[idx].SetTexture(atext)
# Add the actors to the renderer, set the background and size
#
ren1.SetViewport(0, .5, .5, 1)
ren2.SetViewport(.5, .5, 1, 1)
ren3.SetViewport(0, 0, .5, .5)
ren4.SetViewport(.5, 0, 1, .5)
ren1.AddActor(actor["OnOn"])
ren2.AddActor(actor["OnOff"])
ren3.AddActor(actor["OffOn"])
ren4.AddActor(actor["OffOff"])
camera = vtk.vtkCamera()
ren1.SetActiveCamera(camera)
ren2.SetActiveCamera(camera)
ren3.SetActiveCamera(camera)
ren4.SetActiveCamera(camera)
ren1.GetActiveCamera().SetPosition(0.314753, -0.0699988, -0.264225)
ren1.GetActiveCamera().SetFocalPoint(0.00188636, -0.136847,
-5.84226e-09)
ren1.GetActiveCamera().SetViewAngle(30)
ren1.GetActiveCamera().SetViewUp(0, 1, 0)
ren1.ResetCameraClippingRange()
ren2.ResetCameraClippingRange()
ren3.ResetCameraClippingRange()
ren4.ResetCameraClippingRange()
ren1.SetBackground(1, 1, 1)
ren2.SetBackground(1, 1, 1)
ren3.SetBackground(1, 1, 1)
ren4.SetBackground(1, 1, 1)
renWin.SetSize(500, 500)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "deciFranFace.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def main():
fn = get_program_parameters()
# A script to test the stencil filter with a polydata stencil.
# Image pipeline
reader = vtk.vtkPNGReader()
reader.SetDataSpacing(0.8, 0.8, 1.5)
reader.SetDataOrigin(0.0, 0.0, 0.0)
reader.SetFileName(fn)
sphere = vtk.vtkSphereSource()
sphere.SetPhiResolution(12)
sphere.SetThetaResolution(12)
sphere.SetCenter(102, 102, 0)
sphere.SetRadius(60)
triangle = vtk.vtkTriangleFilter()
triangle.SetInputConnection(sphere.GetOutputPort())
stripper = vtk.vtkStripper()
stripper.SetInputConnection(triangle.GetOutputPort())
dataToStencil = vtk.vtkPolyDataToImageStencil()
dataToStencil.SetInputConnection(stripper.GetOutputPort())
dataToStencil.SetOutputSpacing(0.8, 0.8, 1.5)
dataToStencil.SetOutputOrigin(0.0, 0.0, 0.0)
stencil = vtk.vtkImageStencil()
stencil.SetInputConnection(reader.GetOutputPort())
stencil.SetStencilConnection(dataToStencil.GetOutputPort())
stencil.ReverseStencilOn()
stencil.SetBackgroundValue(500)
# test again with a contour
reader2 = vtk.vtkPNGReader()
reader2.SetDataSpacing(0.8, 0.8, 1.5)
reader2.SetDataOrigin(0.0, 0.0, 0.0)
reader2.SetFileName(fn)
plane = vtk.vtkPlane()
plane.SetOrigin(0, 0, 0)
plane.SetNormal(0, 0, 1)
cutter = vtk.vtkCutter()
cutter.SetInputConnection(sphere.GetOutputPort())
cutter.SetCutFunction(plane)
stripper2 = vtk.vtkStripper()
stripper2.SetInputConnection(cutter.GetOutputPort())
dataToStencil2 = vtk.vtkPolyDataToImageStencil()
dataToStencil2.SetInputConnection(stripper2.GetOutputPort())
dataToStencil2.SetOutputSpacing(0.8, 0.8, 1.5)
dataToStencil2.SetOutputOrigin(0.0, 0.0, 0.0)
stencil2 = vtk.vtkImageStencil()
stencil2.SetInputConnection(reader2.GetOutputPort())
stencil2.SetStencilConnection(dataToStencil2.GetOutputPort())
stencil2.SetBackgroundValue(500)
imageAppend = vtk.vtkImageAppend()
imageAppend.SetInputConnection(stencil.GetOutputPort())
imageAppend.AddInputConnection(stencil2.GetOutputPort())
viewer = vtk.vtkImageViewer()
interator = vtk.vtkRenderWindowInteractor()
viewer.SetInputConnection(imageAppend.GetOutputPort())
viewer.SetupInteractor(interator)
viewer.SetZSlice(0)
viewer.SetColorWindow(2000)
viewer.SetColorLevel(1000)
viewer.Render()
interator.Start()
def ShowSlice(self, index=0):
try:
dicom = self.dicom_list[index]
except IndexError:
dicom = self.dicom_list[0]
if self.actor is None:
self.__init_vtk()
# UPDATE GUI
## Text related to size
value = STR_SIZE % (dicom.image.size[0], dicom.image.size[1])
self.text_image_size.SetValue(value)
## Text related to slice position
if not (dicom.image.spacing):
value1 = ''
else:
value1 = STR_SPC % (dicom.image.spacing[2])
if dicom.image.orientation_label == 'AXIAL':
value2 = STR_LOCAL % (dicom.image.position[2])
elif dicom.image.orientation_label == 'CORONAL':
value2 = STR_LOCAL % (dicom.image.position[1])
elif dicom.image.orientation_label == 'SAGITTAL':
value2 = STR_LOCAL % (dicom.image.position[0])
else:
value2 = ''
value = "%s\n%s" % (value1, value2)
self.text_image_location.SetValue(value)
## Text related to patient/ acquisiiton data
value = STR_PATIENT %(dicom.patient.id,\
dicom.acquisition.protocol_name)
self.text_patient.SetValue(value)
## Text related to acquisition date and time
value = STR_ACQ % (dicom.acquisition.date, dicom.acquisition.time)
self.text_acquisition.SetValue(value)
if isinstance(dicom.image.thumbnail_path, list):
reader = vtk.vtkPNGReader()
if _has_win32api:
reader.SetFileName(
win32api.GetShortPathName(
dicom.image.thumbnail_path[index]).encode(
const.FS_ENCODE))
else:
reader.SetFileName(dicom.image.thumbnail_path[index])
reader.Update()
image = reader.GetOutput()
else:
filename = dicom.image.file
if _has_win32api:
filename = win32api.GetShortPathName(filename).encode(
const.FS_ENCODE)
np_image = imagedata_utils.read_dcm_slice_as_np2(filename)
print(">>> spacing", dicom.image.spacing)
vtk_image = converters.to_vtk(np_image, dicom.image.spacing, 0,
'AXIAL')
# ADJUST CONTRAST
window_level = dicom.image.level
window_width = dicom.image.window
colorer = vtk.vtkImageMapToWindowLevelColors()
colorer.SetInputData(vtk_image)
colorer.SetWindow(float(window_width))
colorer.SetLevel(float(window_level))
colorer.Update()
image = colorer.GetOutput()
flip = vtk.vtkImageFlip()
flip.SetInputData(image)
flip.SetFilteredAxis(1)
flip.FlipAboutOriginOn()
flip.ReleaseDataFlagOn()
flip.Update()
if self.actor is None:
self.actor = vtk.vtkImageActor()
self.renderer.AddActor(self.actor)
# PLOT IMAGE INTO VIEWER
self.actor.SetInputData(flip.GetOutput())
self.renderer.ResetCamera()
self.interactor.Render()
# Setting slider position
self.slider.SetValue(index)
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 compareImageWithSavedImage(src_img, img_fname, threshold=10):
"""Compares a source image (src_img, which is a vtkImageData) with
the saved image file whose name is given in the second argument.
If the image file does not exist the image is generated and
stored. If not the source image is compared to that of the
figure. This function also handles multiple images and finds the
best matching image.
"""
global _NO_IMAGE
if _NO_IMAGE:
return
f_base, f_ext = os.path.splitext(img_fname)
if not os.path.isfile(img_fname):
# generate the image
pngw = vtk.vtkPNGWriter()
pngw.SetFileName(_getTempImagePath(img_fname))
pngw.SetInputConnection(src_img.GetOutputPort())
pngw.Write()
_printCDashImageNotFoundError(img_fname)
msg = "Missing baseline image: " + img_fname + "\nTest image created: " + _getTempImagePath(
img_fname)
sys.tracebacklimit = 0
raise RuntimeError, msg
pngr = vtk.vtkPNGReader()
pngr.SetFileName(img_fname)
pngr.Update()
idiff = vtk.vtkImageDifference()
idiff.SetInputConnection(src_img.GetOutputPort())
idiff.SetImageConnection(pngr.GetOutputPort())
idiff.Update()
min_err = idiff.GetThresholdedError()
img_err = min_err
err_index = 0
count = 0
if min_err > threshold:
count = 1
test_failed = 1
err_index = -1
while 1: # keep trying images till we get the best match.
new_fname = f_base + "_%d.png" % count
if not os.path.exists(new_fname):
# no other image exists.
break
# since file exists check if it matches.
pngr.SetFileName(new_fname)
pngr.Update()
idiff.Update()
alt_err = idiff.GetThresholdedError()
if alt_err < threshold:
# matched,
err_index = count
test_failed = 0
min_err = alt_err
img_err = alt_err
break
else:
if alt_err < min_err:
# image is a better match.
err_index = count
min_err = alt_err
img_err = alt_err
count = count + 1
# closes while loop.
if test_failed:
_handleFailedImage(idiff, pngr, img_fname)
# Print for CDash.
_printCDashImageError(img_err, err_index, f_base)
msg = "Failed image test: %f\n" % idiff.GetThresholdedError()
sys.tracebacklimit = 0
raise RuntimeError, msg
# output the image error even if a test passed
_printCDashImageSuccess(img_err, err_index)
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# This script shows how to use vtkImageEuclideanDistance
# Image pipeline
reader = vtk.vtkPNGReader()
reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png")
cast = vtk.vtkImageCast()
cast.SetOutputScalarTypeToShort()
cast.SetInputConnection(reader.GetOutputPort())
thresh = vtk.vtkImageThreshold()
thresh.SetInputConnection(cast.GetOutputPort())
thresh.ThresholdByUpper(2000.0)
thresh.SetInValue(0)
thresh.SetOutValue(200)
thresh.ReleaseDataFlagOff()
dist = vtk.vtkImageEuclideanDistance()
dist.SetInputConnection(thresh.GetOutputPort())
dist.SetAlgorithmToSaito()
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(dist.GetOutputPort())
viewer.SetColorWindow(117)
viewer.SetColorLevel(43)
viewer.Render()
#skipping source
# --- end of script --
def ShowSlice(self, index = 0):
try:
dicom = self.dicom_list[index]
except IndexError:
dicom = self.dicom_list[0]
# UPDATE GUI
## Text related to size
value = STR_SIZE %(dicom.image.size[0], dicom.image.size[1])
self.text_image_size.SetValue(value)
## Text related to slice position
if not(dicom.image.spacing):
value1 = ''
else:
value1 = STR_SPC %(dicom.image.spacing[2])
if dicom.image.orientation_label == 'AXIAL':
value2 = STR_LOCAL %(dicom.image.position[2])
elif dicom.image.orientation_label == 'CORONAL':
value2 = STR_LOCAL %(dicom.image.position[1])
elif dicom.image.orientation_label == 'SAGITTAL':
value2 = STR_LOCAL %(dicom.image.position[0])
else:
value2 = ''
value = "%s\n%s" %(value1, value2)
self.text_image_location.SetValue(value)
## Text related to patient/ acquisiiton data
value = STR_PATIENT %(dicom.patient.id,\
dicom.acquisition.protocol_name)
self.text_patient.SetValue(value)
## Text related to acquisition date and time
value = STR_ACQ % (dicom.acquisition.date,
dicom.acquisition.time)
self.text_acquisition.SetValue(value)
if isinstance(dicom.image.thumbnail_path, list):
reader = vtk.vtkPNGReader()
if _has_win32api:
reader.SetFileName(win32api.GetShortPathName(dicom.image.thumbnail_path[index]).encode(const.FS_ENCODE))
else:
reader.SetFileName(dicom.image.thumbnail_path[index])
reader.Update()
image = reader.GetOutput()
else:
rdicom = vtkgdcm.vtkGDCMImageReader()
if _has_win32api:
rdicom.SetFileName(win32api.GetShortPathName(dicom.image.file).encode(const.FS_ENCODE))
else:
rdicom.SetFileName(dicom.image.file)
rdicom.Update()
# ADJUST CONTRAST
window_level = dicom.image.level
window_width = dicom.image.window
colorer = vtk.vtkImageMapToWindowLevelColors()
colorer.SetInputConnection(rdicom.GetOutputPort())
colorer.SetWindow(float(window_width))
colorer.SetLevel(float(window_level))
colorer.Update()
image = colorer.GetOutput()
if self.actor is None:
self.actor = vtk.vtkImageActor()
self.renderer.AddActor(self.actor)
# PLOT IMAGE INTO VIEWER
self.actor.SetInputData(image)
self.renderer.ResetCamera()
self.interactor.Render()
# Setting slider position
self.slider.SetValue(index)
#!/usr/bin/env python import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() ren1.SetBackground(1,1,1) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Read the data. Note this creates a 3-component scalar. red = vtk.vtkPNGReader() red.SetFileName(VTK_DATA_ROOT + "/Data/RedCircle.png") red.Update() # Next filter can only handle RGB *(&&*@ extract = vtk.vtkImageExtractComponents() extract.SetInputConnection(red.GetOutputPort()) extract.SetComponents(0,1,2) # Quantize the image into an index quantize = vtk.vtkImageQuantizeRGBToIndex() quantize.SetInputConnection(extract.GetOutputPort()) quantize.SetNumberOfColors(3) # Create the pipeline discrete = vtk.vtkDiscreteFlyingEdges2D()
def analyze_snapshot(im, bg_color=(0, 0, 0), colors=None,
find_objects=True,
strel=None):
""" Analyze snapshot from memory or file
Parameters
----------
im: str or array
If string then the image is read from a file otherwise the image is
read from a numpy array. The array is expected to be of shape (X, Y, 3)
or (X, Y, 4) where the last dimensions are the RGB or RGBA values.
colors: tuple (3,) or list of tuples (3,)
List of colors to search in the image
find_objects: bool
If True it will calculate the number of objects that are different
from the background and return their position in a new image.
strel: 2d array
Structure element to use for finding the objects.
Returns
-------
report : ReportSnapshot
This is an object with attibutes like ``colors_found`` that give
information about what was found in the current snapshot array ``im``.
"""
if isinstance(im, basestring):
reader = vtk.vtkPNGReader()
reader.SetFileName(im)
reader.Update()
vtk_im = reader.GetOutput()
vtk_ext = vtk_im.GetExtent()
vtk_pd = vtk_im.GetPointData()
vtk_comp = vtk_pd.GetNumberOfComponents()
shape = (vtk_ext[1] - vtk_ext[0] + 1,
vtk_ext[3] - vtk_ext[2] + 1, vtk_comp)
im = numpy_support.vtk_to_numpy(vtk_pd.GetArray(0))
im = im.reshape(shape)
class ReportSnapshot(object):
objects = None
labels = None
colors_found = False
report = ReportSnapshot()
if colors is not None:
if isinstance(colors, tuple):
colors = [colors]
flags = [False] * len(colors)
for (i, col) in enumerate(colors):
# find if the current color exist in the array
flags[i] = np.any(np.all(im == col, axis=-1))
report.colors_found = flags
if find_objects is True:
weights = [0.299, 0.587, 0.144]
gray = np.dot(im[..., :3], weights)
bg_color = im[0, 0]
background = np.dot(bg_color, weights)
if strel is None:
strel = np.array([[1, 1, 1],
[1, 1, 1],
[1, 1, 1]])
labels, objects = ndimage.label(gray != background, strel)
report.labels = labels
report.objects = objects
return report
