def __init__(self, parent=None, dataset=None):
QtGui.QMainWindow.__init__(self, parent)
# Create Dataset
self.dataset = create_3gauss() if dataset is None else dataset
# Compute Reeb graph
#self.rg = pyrg.computeCT_Grid3D(self.dataset)
# Create UI
self.frame = QtGui.QFrame()
self.hl = QtGui.QHBoxLayout()
self.vtkWidget_vr = QVTKRenderWindowInteractor(self.frame)
self.vtkWidget_rg = QVTKRenderWindowInteractor(self.frame)
self.hl.addWidget(self.vtkWidget_vr)
self.hl.addWidget(self.vtkWidget_rg)
self.frame.setLayout(self.hl)
self.setCentralWidget(self.frame)
self.show()
# Create Volume Render pipeline
self.volumeRenderPipeline = VolumeRenderPipeine(
self.dataset, self.vtkWidget_vr.GetRenderWindow())
# Create Reebgraph Render pipeline
self.reebgraphRenderPipeline = ReebgraphRenderPipeline(
self.dataset, self.vtkWidget_rg.GetRenderWindow())
def setupUi(self, Form):
Form.setObjectName(_fromUtf8("Form"))
Form.resize(800, 600)
self.gridLayout = QtGui.QGridLayout(Form)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.verticalLayout_3 = QtGui.QVBoxLayout()
self.verticalLayout_3.setSizeConstraint(
QtGui.QLayout.SetDefaultConstraint)
self.verticalLayout_3.setObjectName(_fromUtf8("verticalLayout_3"))
self.horizontalLayout = QtGui.QHBoxLayout()
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.verticalLayout = QtGui.QVBoxLayout()
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.label = QtGui.QLabel(Form)
self.label.setObjectName(_fromUtf8("label"))
self.verticalLayout.addWidget(self.label)
self.leftVtk = QVTKRenderWindowInteractor(Form)
self.leftVtk.setObjectName(_fromUtf8("leftVtk"))
self.verticalLayout.addWidget(self.leftVtk)
self.verticalLayout.setStretch(1, 1)
self.horizontalLayout.addLayout(self.verticalLayout)
self.verticalLayout_2 = QtGui.QVBoxLayout()
self.verticalLayout_2.setObjectName(_fromUtf8("verticalLayout_2"))
self.label_2 = QtGui.QLabel(Form)
self.label_2.setObjectName(_fromUtf8("label_2"))
self.verticalLayout_2.addWidget(self.label_2)
self.rightVtk = QVTKRenderWindowInteractor(Form)
self.rightVtk.setObjectName(_fromUtf8("rightVtk"))
self.verticalLayout_2.addWidget(self.rightVtk)
self.verticalLayout_2.setStretch(1, 1)
self.horizontalLayout.addLayout(self.verticalLayout_2)
self.verticalLayout_3.addLayout(self.horizontalLayout)
self.tabWidget = QtGui.QTabWidget(Form)
self.tabWidget.setTabShape(QtGui.QTabWidget.Triangular)
self.tabWidget.setTabsClosable(False)
self.tabWidget.setMovable(False)
self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
self.okienkowanieTab = QtGui.QWidget()
self.okienkowanieTab.setObjectName(_fromUtf8("okienkowanieTab"))
self.tabWidget.addTab(self.okienkowanieTab, _fromUtf8(""))
self.cannyTab = QtGui.QWidget()
self.cannyTab.setObjectName(_fromUtf8("cannyTab"))
self.tabWidget.addTab(self.cannyTab, _fromUtf8(""))
self.verticalLayout_3.addWidget(self.tabWidget)
self.loadImage = QtGui.QPushButton(Form)
self.loadImage.setObjectName(_fromUtf8("loadImage"))
self.verticalLayout_3.addWidget(self.loadImage)
self.verticalLayout_3.setStretch(0, 2)
self.verticalLayout_3.setStretch(1, 1)
self.gridLayout.addLayout(self.verticalLayout_3, 0, 0, 1, 1)
self.retranslateUi(Form)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(Form)
def __init__(self, parent=None):
super(VtkWindow, self).__init__(parent)
self.parent = parent
self.outline = False
self.vl = QtGui.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.vl.addWidget(self.vtkWidget)
self.setLayout(self.vl)
self.renderer = vtk.vtkRenderer()
self.vtkwindow = self.vtkWidget.GetRenderWindow()
self.vtkwindow.AddRenderer(self.renderer)
self.interactor = self.vtkWidget.GetRenderWindow().GetInteractor()
self.renderer.GradientBackgroundOn()
self.renderer.SetBackground(1, 1, 1)
self.renderer.SetBackground2(0, 0, 1)
self.interactor.Initialize()
self.vtkWidget.AddObserver('KeyPressEvent', self.onKeyPress)
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vl = QtGui.QVBoxLayout(self)
self.vl.setContentsMargins(0, 0, 0, 0)
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.vl.addWidget(self.vtkWidget)
self._renderer = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self._renderer)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
#Create an style
self._interactorStyle = MouseInteractorActor()
self._interactorStyle.SetDefaultRenderer(self._renderer)
self.vtkWidget.SetInteractorStyle(self._interactorStyle)
self._actor1 = self.createActor1()
self._actor2 = self.createActor2()
self._renderer.AddActor(self._actor1)
self._renderer.AddActor(self._actor2)
self._renderer.ResetCamera()
self._renderer.SetBackground(.1, .2, .3)
self._initialized = False
def __init__(self):
super(MyWindow, self).__init__()
os.chdir(functionPath)
uic.loadUi("registration_gui.ui", self)
os.chdir(startPath)
# Connect buttons to functions
# import moving data
self.ptcldMovingButton.clicked.connect(self.import_data)
# import fixed data
self.ptcldFixedButton.clicked.connect(self.import_data)
# execute qr_register function
self.registrationButton.clicked.connect(self.qf_register)
self.vl = QtGui.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self.vtkFrame)
self.vl.addWidget(self.vtkWidget)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
self.actor_moving = vtk.vtkActor()
self.moving_color = (0, 0.2)
self.actor_fixed = vtk.vtkActor()
self.fixed_color = (.8, 1)
self.ren.AddActor(self.actor_moving)
self.ren.AddActor(self.actor_fixed)
self.ren.ResetCamera()
self.vtkFrame.setLayout(self.vl)
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
self.show()
self.iren.Initialize()
def SetRenderWindow(self,w):
""" SetRenderWindow(w: vtkRenderWindow)
Set a new render window to QVTKWidget and initialize the
interactor as well
"""
if w == self.mRenWin:
return
if self.mRenWin:
if system.systemType!='Linux':
self.mRenWin.SetInteractor(None)
if self.mRenWin.GetMapped():
self.mRenWin.Finalize()
self.mRenWin = w
if self.mRenWin:
self.mRenWin.Register(None)
if self.mRenWin.GetMapped():
self.mRenWin.Finalize()
if system.systemType=='Linux':
display = None
try:
display = int(QtGui.QX11Info.display())
except TypeError:
# This was changed for PyQt4.2
if isinstance(QtGui.QX11Info.display(), QtGui.Display):
display = sip.unwrapinstance(QtGui.QX11Info.display())
if display is not None:
v = vtk.vtkVersion()
version = [v.GetVTKMajorVersion(),
v.GetVTKMinorVersion(),
v.GetVTKBuildVersion()]
display = hex(display)[2:]
if version < [5, 7, 0]:
vp = ('_%s_void_p\0x00' % display)
elif version < [6, 2, 0]:
vp = ('_%s_void_p' % display)
else:
vp = ('_%s_p_void' % display)
self.mRenWin.SetDisplayId(vp)
self.resizeWindow(1,1)
self.mRenWin.SetWindowInfo(str(int(self.winId())))
if self.isVisible():
self.mRenWin.Start()
if not self.mRenWin.GetInteractor():
#iren = vtk.vtkRenderWindowInteractor()
iren = QVTKRenderWindowInteractor()
# if system.systemType=='Darwin':
# iren.InstallMessageProcOff()
iren.SetRenderWindow(self.mRenWin)
iren.Initialize()
# if system.systemType=='Linux':
# system.XDestroyWindow(self.mRenWin.GetGenericDisplayId(),
# self.mRenWin.GetGenericWindowId())
self.mRenWin.SetWindowInfo(str(int(self.winId())))
self.resizeWindow(self.width(), self.height())
self.mRenWin.SetPosition(self.x(), self.y())
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
# Create five points.
origin = [0.0, 0.0, 0.0]
p0 = [1.0, 0.0, 0.0]
p1 = [0.0, 1.0, 0.0]
p2 = [0.0, 1.0, 2.0]
p3 = [1.0, 2.0, 3.0]
p4 = [1.0, 2.0, 8.0]
# Create a vtkPoints object and store the points in it
points = vtk.vtkPoints()
points.InsertNextPoint(origin)
points.InsertNextPoint(p0)
points.InsertNextPoint(p1)
points.InsertNextPoint(p2)
points.InsertNextPoint(p3)
points.InsertNextPoint(p4)
# Create a cell array to store the lines in and add the lines to it
lines = vtk.vtkCellArray()
for i in range(4):
line = vtk.vtkLine()
line.GetPointIds().SetId(0, i)
line.GetPointIds().SetId(1, i + 1)
lines.InsertNextCell(line)
# Create a polydata to store everything in
linesPolyData = vtk.vtkPolyData()
# Add the points to the dataset
linesPolyData.SetPoints(points)
# Add the lines to the dataset
linesPolyData.SetLines(lines)
# Setup actor and mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(linesPolyData)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def __init__(self, x, y, xrange_=10.):
super(VTKPlot, self).__init__()
self.setGeometry(50, 50, 700, 350)
self.setWindowOpacity(1.)
self.view = vtk.vtkContextView()
chartMatrix = vtk.vtkChartMatrix()
chartMatrix.SetSize(vtk.vtkVector2i(1, 1))
chartMatrix.SetGutter(vtk.vtkVector2f(50, 50))
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.view.SetRenderWindow(self.vtkWidget.GetRenderWindow())
self.view.GetRenderer().SetBackground(1.0, 1.0, 1.0)
self.view.GetScene().AddItem(chartMatrix)
self.chart = chartMatrix.GetChart(vtk.vtkVector2i(0, 0))
self.arrY = vtk.vtkFloatArray()
self.arrX = vtk.vtkFloatArray()
self.table = vtk.vtkTable()
self.add_plot(x, y, xrange_=xrange_)
self.chart.GetAxis(vtk.vtkAxis.BOTTOM).SetTitle("Time")
self.chart.GetAxis(vtk.vtkAxis.LEFT).SetTitle("Signal")
self.view.GetRenderWindow().SetMultiSamples(0)
self.view.GetRenderWindow().Render()
layout = QGridLayout()
layout.addWidget(self.vtkWidget, 0, 0)
self.setLayout(layout)
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.frame = QtGui.QFrame()
self.vl = QtGui.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.vl.addWidget(self.vtkWidget)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
source = vtk.vtkDICOMImageReader()
source.SetFileName("D:\Anaconda\workspace\pytest\patient\\1.dcm")
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(source.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self.frame.setLayout(self.vl)
self.setCentralWidget(self.frame)
self.show()
self.iren.Initialize()
def __init__(self, parent = None, filename=""):
QtGui.QMainWindow.__init__(self, parent)
# Create UI
self.splitter = QtGui.QSplitter(self)
self.splitter.setOrientation(Qt.Horizontal)
self.vtkWidget_vr = QVTKRenderWindowInteractor(self.splitter)
self.webview = WebViewWindow(self.splitter)
self.layout = QtGui.QHBoxLayout()
self.layout.setMargin(0)
self.layout.addWidget(self.splitter)
self.splitter.addWidget(self.vtkWidget_vr)
self.splitter.addWidget(self.webview)
self.setCentralWidget(self.splitter)
self.show()
if filename.endswith(".vti") or filename.endswith(".vtk"):
self.dsinfo.filepath = filename
self.dsinfo.filename = os.path.basename(filename)
self.load(filename if filename.endswith(".rgbin") else None)
def QVTKRenderWidgetConeExample():
"""A simple example that uses the QVTKRenderWindowInteractor class."""
# every QT app needs an app
app = QtGui.QApplication(['QVTKRenderWindowInteractor'])
# create the widget
widget = QVTKRenderWindowInteractor()
widget.Initialize()
widget.Start()
# if you dont want the 'q' key to exit comment this.
widget.AddObserver("ExitEvent", lambda o, e, a=app: a.quit())
ren = vtk.vtkRenderer()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtk.vtkConeSource()
cone.SetResolution(8)
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the widget
widget.show()
# start event processing
app.exec_()
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(800, 600)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.pushButton = QtGui.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(10, 230, 121, 41))
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8(":/rc/Resource/Science.png")),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton.setIcon(icon)
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.vtkWidget = QVTKRenderWindowInteractor(self.centralwidget)
self.vtkWidget.setGeometry(QtCore.QRect(200, 100, 521, 391))
self.vtkWidget.setObjectName(_fromUtf8("widget"))
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 23))
self.menubar.setObjectName(_fromUtf8("menubar"))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def __init__(self, parent, Qt4GUI):
super(VTKCanvas, self).__init__(parent)
# dictionary to keep track of tree widget items that correspond to actors/icons - used to handle vtk->Qt4 scene changes
self.actors_to_tree_widget_items = {}
# Qt4 GUI that this canvas is associated with
self.Qt4GUI = Qt4GUI
# camera perspective type check
self.camera_perspective = False
# setup the vtk renderers - one for objects, one for overlay icons/text (which always renders on top)
self.vtk_renderer = vtk.vtkRenderer()
# setup the vtk interactor
self.vtk_interactor = QVTKRenderWindowInteractor(self)
# setup the vtk render window
self.vtk_render_window = self.vtk_interactor.GetRenderWindow()
self.vtk_render_window.AddRenderer(self.vtk_renderer)
self.vtk_render_window.SetInteractor(self.vtk_interactor)
#setup the layout of the vtk interactor in Qt
self.layout = QtGui.QHBoxLayout()
self.layout.addWidget(self.vtk_interactor)
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
superquadricSource = vtk.vtkSuperquadricSource()
superquadricSource.SetPhiRoundness(3.1)
superquadricSource.SetThetaRoundness(2.2)
clipPlane = vtk.vtkPlane()
clipPlane.SetNormal(1.0, -1.0, -1.0)
clipPlane.SetOrigin(0, 0, 0)
clipper = vtk.vtkClipPolyData()
clipper.SetInputConnection(superquadricSource.GetOutputPort())
clipper.SetClipFunction(clipPlane)
superquadricMapper = vtk.vtkPolyDataMapper()
superquadricMapper.SetInputConnection(clipper.GetOutputPort())
superquadricActor = vtk.vtkActor()
superquadricActor.SetMapper(superquadricMapper)
#create renderers and add actors of plane and cube
self.ren.AddActor(superquadricActor)
self.ren.ResetCamera()
self._initialized = False
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.frame = QtGui.QFrame()
self.vl = QtGui.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.vl.addWidget(self.vtkWidget)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
source = vtk.vtkSphereSource()
source.SetCenter(0, 0, 0)
source.SetRadius(5.0)
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(source.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self.frame.setLayout(self.vl)
self.setCentralWidget(self.frame)
self.show()
self.iren.Initialize()
def iniCentralWidget(self):
self.centralWidget = gui.QWidget()
self.centralLayout = gui.QHBoxLayout()
self.vtk_widget = QVTKRenderWindowInteractor(self.centralWidget)
self.setCentralWidget(self.centralWidget)
self.centralWidget.setLayout(self.centralLayout)
self.centralLayout.addWidget(self.vtk_widget)
def initVTKWidget(self, frame):
"""Sets up vtkWidget inside frame.
Also sets up corresponding renderer and interactor.
Args:
frame (QtGui.QFrame): Parenting frame.
Returns:
tuple: Tuple containing:
* vtkWidget (vtk.qt4.QVTKRenderWindowInteractor.QVTKRenderWindowInteractor): Qt vtk window interactor.
* ren (vtk.vtkRenderer)
* iren (vtk.vtkRenderWindowInteractor)
"""
vtkWidget = QVTKRenderWindowInteractor(frame)
ren = vtk.vtkRenderer()
vtkWidget.GetRenderWindow().AddRenderer(ren)
iren = vtkWidget.GetRenderWindow().GetInteractor()
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
ren.ResetCamera()
return vtkWidget, ren, iren
def initRenderWindow(self):
pix_diag = 5.0
self.nVolumes = 0
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(1.0, 1.0, 1.0)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.window = self.vtkWidget.GetRenderWindow()
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
drange = [0,400]
self.vtkWidget.opacity_tf = vtk.vtkPiecewiseFunction()
self.vtkWidget.opacity_tf.AddPoint(drange[0],0.0)
self.vtkWidget.opacity_tf.AddPoint(drange[1],0.0)
self.vtkWidget.color_tf = vtk.vtkColorTransferFunction()
self.vtkWidget.color_tf.AddRGBPoint(drange[0], 0.0, 0.0, 0.0)
self.vtkWidget.color_tf.AddRGBPoint(drange[1], 1.0, 1.0, 1.0)
self.vtkWidget.volProperty = vtk.vtkVolumeProperty()
self.vtkWidget.volProperty.SetColor(self.vtkWidget.color_tf);
self.vtkWidget.volProperty.SetScalarOpacity(self.vtkWidget.opacity_tf)
self.vtkWidget.volProperty.ShadeOn()
self.vtkWidget.volProperty.SetInterpolationTypeToLinear()
self.vtkWidget.volProperty.SetScalarOpacityUnitDistance(pix_diag)
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
#Instance Variables
self.point_array = []
self.vl = QtGui.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.vl.addWidget(self.vtkWidget)
self.frame.setLayout(self.vl)
print(self.frame.height, self.frame.width)
self.renderer = vtk.vtkRenderer()
self.pointCloud = v.VtkPointCloud()
self.renderWindowInteractor = vtk.vtkRenderWindowInteractor()
self.setup_vtk
self.ser = 0
#Signal slots of buttons
self.startButton.clicked.connect(lambda: self.start_scanning(self.ser))
self.stopButton.clicked.connect(lambda: self.stop_scanning(self.ser))
#Actions for menu bar
self.actionSave_CSV.triggered.connect(
lambda: write_CSV(self.point_array))
self.actionSave_STL.triggered.connect(
lambda: write_STL(self.pointCloud))
self.actionClear.triggered.connect(lambda: self.clear_pointcloud())
#Scan thread
self.scan_thread = ScanThread(self)
self.write.connect(self.write_to_browser)
self.pointcloud_changed.connect(self.update_pointcloud)
self.need_pointcloud_setup.connect(self.setup_vtk)
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
source = vtk.vtkConeSource()
source.SetHeight(3.0)
source.SetRadius(1.0)
source.SetResolution(20)
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(source.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.frame = QtGui.QFrame()
layout = QtGui.QVBoxLayout()
self.vtkWidget = \
QVTKRenderWindowInteractor(self.frame)
layout.addWidget(self.vtkWidget)
self.renderer = vtk.vtkRenderer()
rw = self.vtkWidget.GetRenderWindow()
rw.AddRenderer(self.renderer)
self.interactor = rw.GetInteractor()
cylinder = vtk.vtkCylinderSource()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection( \
cylinder.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.renderer.AddActor(actor)
self.renderer.ResetCamera()
self.frame.setLayout(layout)
self.setCentralWidget(self.frame)
self.show()
self.interactor.Initialize()
def __init__(self, parent=None):
QCellWidget.__init__(self, parent)
centralLayout = QtGui.QVBoxLayout()
self.setLayout(centralLayout)
centralLayout.setMargin(0)
centralLayout.setSpacing(0)
self.view = vtk.vtkContextView()
self.widget = QVTKRenderWindowInteractor(
self,
rw=self.view.GetRenderWindow(),
iren=self.view.GetInteractor())
self.chart = vtk.vtkChartParallelCoordinates()
self.view.GetScene().AddItem(self.chart)
self.layout().addWidget(self.widget)
# Create a annotation link to access selection in parallel coordinates view
self.annotationLink = 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.annotationLink.GetCurrentSelection().GetNode(0).SetFieldType(
1) # Point
self.annotationLink.GetCurrentSelection().GetNode(0).SetContentType(
4) # Indices
# Connect the annotation link to the parallel coordinates representation
self.chart.SetAnnotationLink(self.annotationLink)
self.annotationLink.AddObserver("AnnotationChangedEvent",
self.selectionCallback)
def set_up_view(self, main_window):
self.main_window = main_window
self.interactor = QVTKRenderWindowInteractor(self.main_window.ui.frame)
self.renderer.SetLayer(0)
self.renderer.SetInteractive(1)
#self.renderer.BackingStoreOn()
self.renderer_picked.SetLayer(1)
self.renderer_picked.SetInteractive(1)
#self.renderer_picked.BackingStoreOn()
self.renderer_hovered.SetLayer(2)
self.renderer_hovered.SetInteractive(1)
self.interactor.GetRenderWindow().SetNumberOfLayers(3)
self.interactor.GetRenderWindow().AddRenderer(self.renderer_hovered)
self.interactor.GetRenderWindow().AddRenderer(self.renderer_picked)
self.interactor.GetRenderWindow().AddRenderer(self.renderer)
self.interactor.GetRenderWindow().SetAlphaBitPlanes(1)
self.main_window.ui.vl.addWidget(self.interactor)
self.iren = self.interactor.GetRenderWindow().GetInteractor()
self.bg_color_1_default = (0, 0, 1)
self.bg_color_2_default = (0.8, 0.8, 1)
self.bg_color_1 = self.bg_color_1_default
self.bg_color_2 = self.bg_color_2_default
self.axes = CoordinateAxes(self.interactor)
self.renderer.SetBackground(self.bg_color_1)
self.renderer.SetBackground2(self.bg_color_2)
self.renderer.GradientBackgroundOn()
self.perspective = 0
self.camera = vtk.vtkCamera()
self.renderer.SetActiveCamera(self.camera)
self.renderer.ResetCamera()
self.renderer_picked.SetActiveCamera(self.camera)
self.renderer_hovered.SetActiveCamera(self.camera)
self.interactor_style = DefaultInteractorStyle(self)
self.interactor_style.set_default_renderer(self.renderer)
#self.interactor_style.SetDefaultRenderer(self.renderer)
self.interactor.SetInteractorStyle(self.interactor_style)
self.interactor.Start()
# http://www.paraview.org/Wiki/VTK/Examples/Python/Widgets/EmbedPyQt
# http://www.vtk.org/pipermail/vtk-developers/2013-July/014005.html
# see above why self.main_window.show() is done here
self.main_window.show()
self.iren.Initialize()
def __init__(self, data, parent):
super(SliceViewer, self).__init__()
self._data = data
self._lut = None
self._actors = {}
self._camera = None
#self._slice_generator = SliceGenerator(self._data.get_image_side(), self._data.get_curvature())
#self._workspace = QtGui.QWorkspace()
self._widget = QtGui.QWidget(parent)
self._vtk_widget = QVTKRenderWindowInteractor(self._widget)
self._vtk_widget.SetInteractorStyle(
vtk.vtkInteractorStyleRubberBandPick())
#self._vtk_widget = QtGui.QPushButton("Foo", parent=self._widget)
layout = QtGui.QVBoxLayout()
#layout.addWidget(self._workspace)
layout.addWidget(self._vtk_widget)
#self._workspace.addWindow(self._vtk_widget)
self._widget.setLayout(layout)
# self._vtk_widget.Initialize()
# self._vtk_widget.Start()
self._renderer = vtk.vtkRenderer()
self._renderer.SetDraw(0)
self._vtk_render_window = self._vtk_widget.GetRenderWindow()
self._vtk_render_window.AddRenderer(self._renderer)
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Provide some geometry
resolution = 8
aPlane = vtk.vtkPlaneSource()
aPlane.SetXResolution(resolution)
aPlane.SetYResolution(resolution)
# Create cell data
cellData = vtk.vtkFloatArray()
for i in range(resolution * resolution):
cellData.InsertNextValue(i + 1)
# Create a lookup table to map cell data to colors
lut = vtk.vtkLookupTable()
tableSize = max(resolution * resolution + 1, 10)
lut.SetNumberOfTableValues(tableSize)
lut.Build()
# Fill in a few known colors, the rest will be generated if needed
lut.SetTableValue(0, 0, 0, 0, 1) # Black
lut.SetTableValue(1, 0.8900, 0.8100, 0.3400, 1) # Banana
lut.SetTableValue(2, 1.0000, 0.3882, 0.2784, 1) # Tomato
lut.SetTableValue(3, 0.9608, 0.8706, 0.7020, 1) # Wheat
lut.SetTableValue(4, 0.9020, 0.9020, 0.9804, 1) # Lavender
lut.SetTableValue(5, 1.0000, 0.4900, 0.2500, 1) # Flesh
lut.SetTableValue(6, 0.5300, 0.1500, 0.3400, 1) # Raspberry
lut.SetTableValue(7, 0.9804, 0.5020, 0.4471, 1) # Salmon
lut.SetTableValue(8, 0.7400, 0.9900, 0.7900, 1) # Mint
lut.SetTableValue(9, 0.2000, 0.6300, 0.7900, 1) # Peacock
aPlane.Update() #Force an update so we can set cell data
aPlane.GetOutput().GetCellData().SetScalars(cellData)
# Create a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(aPlane.GetOutputPort())
mapper.SetScalarRange(0, tableSize - 1)
mapper.SetLookupTable(lut)
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(603, 553)
self.centralWidget = QtGui.QWidget(MainWindow)
self.gridlayout = QtGui.QGridLayout(self.centralWidget)
self.vtkWidget = QVTKRenderWindowInteractor(self.centralWidget)
self.gridlayout.addWidget(self.vtkWidget, 0, 0, 1, 1)
MainWindow.setCentralWidget(self.centralWidget)
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
loadUi('vtk.ui', self)
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
# self.vl.addWidget(self.vtkWidget)
# self.vl.addWidget(self.button)
new(self.vtkWidget.GetRenderWindow().GetInteractor())
self.show()
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.2, 0.4)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
source = vtk.vtkSphereSource()
source.Update()
triangleFilter = vtk.vtkTriangleFilter()
triangleFilter.SetInputConnection(source.GetOutputPort())
triangleFilter.Update()
# Create a mapper and actor
sphereMapper = vtk.vtkDataSetMapper()
sphereMapper.SetInputConnection(triangleFilter.GetOutputPort())
sphereActor = vtk.vtkActor()
sphereActor.SetMapper(sphereMapper)
mesh = triangleFilter.GetOutput()
qualityFilter = vtk.vtkMeshQuality()
qualityFilter.SetInput(mesh)
qualityFilter.SetTriangleQualityMeasureToArea()
qualityFilter.Update()
qualityMesh = qualityFilter.GetOutput()
#qualityArray = vtk.vtkDoubleArray.SafeDownCase(qualityMesh.GetCellData().GetArray("Quality"))
selectCells = vtk.vtkThreshold()
selectCells.ThresholdByLower(0.02)
selectCells.SetInputArrayToProcess(
0, 0, 0, vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS,
vtk.vtkDataSetAttributes.SCALARS)
selectCells.SetInput(qualityMesh)
selectCells.Update()
ug = selectCells.GetOutput()
# Create a mapper and actor
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(ug)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetColor(1, 0, 0)
actor.GetProperty().SetRepresentationToWireframe()
actor.GetProperty().SetLineWidth(5)
self.ren.AddActor(sphereActor)
self.ren.AddActor(actor)
self.ren.ResetCamera()
self._initialized = False
def initVTK(self):
self.vtkWidget = QVTKRenderWindowInteractor(self.frame)
self.vl.addWidget(self.vtkWidget)
self.ren = vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
self.iren.SetInteractorStyle(MouseInteractorStylePP(self))
def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(1.0, 1.0, 1.0)
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
# Create source
# x = array of 8 3-tuples of float representing the vertices of a cube:
x = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (1.0, 1.0, 0.0),
(0.0, 1.0, 0.0), (0.0, 0.0, 1.0), (1.0, 0.0, 1.0),
(1.0, 1.0, 1.0), (0.0, 1.0, 1.0)]
# pts = array of 6 4-tuples of vtkIdType (int) representing the faces
# of the cube in terms of the above vertices
pts = [(0, 1, 2, 3), (4, 5, 6, 7), (0, 1, 5, 4), (1, 2, 6, 5),
(2, 3, 7, 6), (3, 0, 4, 7)]
# We'll create the building blocks of polydata including data attributes.
points = vtk.vtkPoints()
polys = vtk.vtkCellArray()
scalars = vtk.vtkFloatArray()
# Load the point, cell, and data attributes.
for i in range(8):
points.InsertPoint(i, x[i])
for i in range(6):
idList = vtk.vtkIdList()
for it in pts[i]:
idList.InsertNextId(int(it))
polys.InsertNextCell(idList)
for i in range(8):
scalars.InsertTuple1(i, i)
# We now assign the pieces to the vtkPolyData.
cube = vtk.vtkPolyData()
cube.SetPoints(points)
cube.SetPolys(polys)
cube.GetPointData().SetScalars(scalars)
# Now we'll look at it.
cubeMapper = vtk.vtkPolyDataMapper()
cubeMapper.SetInput(cube)
cubeMapper.SetScalarRange(0, 7)
cubeActor = vtk.vtkActor()
cubeActor.SetMapper(cubeMapper)
self.ren.AddActor(cubeActor)
self.ren.ResetCamera()
self._initialized = False
