''' Created on 15/06/2018 @author: rjag008 ''' from opencmiss.zinc._graphics import Graphicslineattributes_SHAPE_TYPE_CIRCLE_EXTRUSION from digitiser.dataset import PaintDatasetItem from opencmiss.zincwidgets.sceneviewerwidget import SceneviewerWidget from opencmiss.zinc.sceneviewerinput import Sceneviewerinput from opencmiss.zinc.glyph import Glyph from opencmiss.zinc.scenecoordinatesystem import SCENECOORDINATESYSTEM_WINDOW_PIXEL_TOP_LEFT, SCENECOORDINATESYSTEM_WORLD import sys from os import path from digitiser.model import PaintModel, signalHandle from collections import OrderedDict from opencmiss.zinc.context import Context from opencmiss.zinc.field import Field, FieldFindMeshLocation dir_path = path.dirname(path.realpath(sys.argv[0])) if not hasattr(sys, 'frozen'): #For py2exe dir_path = path.join(dir_path,"..") uiFile = path.join(dir_path,"./digitiser/PaintUI.ui") try: from PySide import QtCore, QtGui, QtOpenGL from pysideuiutils.uic import loadUi class ZincDigitiserWidgetBase(QtGui.QWidget): def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) loadUi(uiFile, self) except ImportError: #from PyQt4 import QtCore, QtGui, QtOpenGL, uic ''' form,base = uic.loadUiType(uiFile) class ZincDigitiserWidgetBase(base,form): def __init__(self,parent=None): super(base,self).__init__(parent) self.setupUi(self) ''' pass button_map = {QtCore.Qt.RightButton: Sceneviewerinput.BUTTON_TYPE_RIGHT} class SceneViewerWidget(SceneviewerWidget): ''' classdocs ''' try: # PySide doubleClicked = QtCore.Signal() pointSelectionClick = QtCore.Signal(tuple) pointDeletionClick = QtCore.Signal(tuple) except AttributeError: # PyQt doubleClicked = QtCore.pyqtSignal() pointSelectionClick = QtCore.pyqtSignal(tuple) pointDeletionClick = QtCore.pyqtSignal(tuple) def __init__(self, parent=None, shared=None): ''' Constructor ''' SceneviewerWidget.__init__(self, parent, shared) #Code to handle double click self.timer = QtCore.QTimer() self.timer.setSingleShot(True) # had to add a "__doubleClickedFlag" flag self.__doubleClickedFlag = False self.__doubleClickInterval = QtGui.qApp.doubleClickInterval() self._selectionKeyPressed = False self.nodeOfInterest = None #Override mouse events so that they can be broadcast to listerners def mousePressEvent(self, event): #x = event.x() #y = event.y() #self.nodeOfInterest = self.getNearestGraphicsData(x, y) super(SceneViewerWidget,self).mousePressEvent(event) def mouseMoveEvent(self, event): super(SceneViewerWidget,self).mouseMoveEvent(event) def mouseReleaseEvent(self, event): #super(SceneViewerWidget,self).mouseReleaseEvent(event) event.accept() if event.button() in button_map: x = event.x() y = event.y() px,py,_ = self.transformToWorld(x,y) if event.button()==QtCore.Qt.RightButton: if not self._selectionKeyPressed: self.pointSelectionClick.emit([px,py]) else: self.nodeOfInterest = self.getNearestNode(x, y) self.pointDeletionClick.emit([px,py]) else: self.nodeOfInterest = None if not self.__doubleClickedFlag: self.timer.start(self.__doubleClickInterval) else: self.__doubleClickedFlag = False def mouseDoubleClickEvent(self, event): event.accept() self.timer.stop() self.__doubleClickedFlag = True self.doubleClicked.emit() def keyPressEvent(self, event): if (event.key() == QtCore.Qt.Key_Shift) and (event.isAutoRepeat() == False): self._selectionKeyPressed = True event.setAccepted(True) else: event.ignore() def keyReleaseEvent(self, event): if (event.key() == QtCore.Qt.Key_Shift) and event.isAutoRepeat() == False: self._selectionKeyPressed = False event.setAccepted(True) else: event.ignore() def transformToWorld(self,x,y): #Go from screen to world coordinates #First find the depth by projecting known node value in world coordinates on to pixel coordinates _,loc = self._sceneviewer.transformCoordinates (SCENECOORDINATESYSTEM_WORLD,SCENECOORDINATESYSTEM_WINDOW_PIXEL_TOP_LEFT,self._sceneviewer.getScene(), [0.0,0.0,0.0] ) #Due to right handed coordinate system, y should be sent in as -ve _,pos = self._sceneviewer.transformCoordinates (SCENECOORDINATESYSTEM_WINDOW_PIXEL_TOP_LEFT,SCENECOORDINATESYSTEM_WORLD,self._sceneviewer.getScene(), [x,-y,loc[2]] ) return pos class ZincGraphicsEllipseItem(object): def __init__(self, material, key,parent): self.parent = parent self.material = material self._key = key def getItemKey(self): return self._key def setMaterial(self,color): self.material = color class DigitizationView(object): #PenNames = ['red','green','blue','cyan','magenta','yellow'] PenColors = [QtGui.QColor(col) for col in [ QtCore.Qt.red, QtCore.Qt.green, QtCore.Qt.blue,\ QtCore.Qt.cyan, QtCore.Qt.magenta, QtCore.Qt.yellow]] def __init__(self, model, zincContext, graphicsScene, listDatasets): self._model = model self._graphicsScene = graphicsScene self.zincContext = zincContext self.rootRegion = self.zincContext.getDefaultRegion() self._listDatasets = listDatasets #Create a list of materials self.datasetColors = self._model.datasetColors if len(self.datasetColors)==0: self.datasetColors[0] = self.createPenAndMaterial(self.PenColors[0]) #Default item's color #Set the clipping plane self._graphicsScene.setViewParameters([0.0, 0.0, 4.742128877220128], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0], 0.6981317007977312) self.reset() self._model.modelChanged.connect(self.modelChanged) self.modelChanged() self._listDatasets.itemChanged.connect(self.updateDatasetName) self._listDatasets.itemDoubleClicked.connect(self.changeItemColor) self.freeDataNodes = [] self.numberOfTemporaryColors = 0 def changeItemColor(self,item): newColor = item.changeColor() if not newColor is None: ds = item._key #Change the color of related points self.datasetColors[ds] = self.createPenAndMaterial(newColor) mat = self.datasetColors[ds][0] for k in self._pointItems: itm, dataset = self._pointItems[k] if dataset==ds: itm.setMaterial(mat) self.fieldCache.setNode(itm.parent) self.nodeColorField.assignReal(self.fieldCache,mat) def createPenAndMaterial(self,color): rgb = [color.red()/255.0, color.green()/255.0, color.blue()/255.0] return [rgb,color] def reset(self): region = self.rootRegion.findChildByName('digitizer') if region.isValid(): self.rootRegion.removeChild(region) self._listDatasets.clear() self._pointItems = {} self._datasetItems = {} self.freeDataNodes = [] self.usedDataNodes = dict() def loadMesh(self,meshGenerator): region = self.rootRegion.findChildByName('digitizer') if region.isValid(): self.rootRegion.removeChild(region) region = self.rootRegion.createChild('digitizer') meshGenerator.generateMesh(region) self.region = region self.useMesh() def useMesh(self): region = self.rootRegion.findChildByName('digitizer') self.region = region fieldModule = region.getFieldmodule() self.xiCoordinates = fieldModule.findFieldByName('texture') #Create necessary fields nodeAnnotationField = fieldModule.findFieldByName('nodeAnnotation') if not nodeAnnotationField.isValid(): nodeAnnotationField = fieldModule.createFieldStoredString() nodeAnnotationField.setName('nodeAnnotation') self.nodeAnnotationField = nodeAnnotationField nodeVisibilityFlagField = fieldModule.findFieldByName('nodeVisibilityFlag') if not nodeVisibilityFlagField.isValid(): nodeVisibilityFlagField = fieldModule.createFieldFiniteElement(1) nodeVisibilityFlagField.setName('nodeVisibilityFlag') self.nodeVisibilityFlagField = nodeVisibilityFlagField nodeSizeField = fieldModule.findFieldByName('nodeSizeField') if not nodeSizeField.isValid(): nodeSizeField = fieldModule.createFieldFiniteElement(9) nodeSizeField.setName('nodeSizeField') self.nodeSizeField = nodeSizeField nodeColorField = fieldModule.findFieldByName('nodeColor') if not nodeColorField.isValid(): nodeColorField = fieldModule.createFieldFiniteElement(3) nodeColorField.setName('nodeColor') self.nodeColorField = nodeColorField self.datanodeset = fieldModule.findNodesetByFieldDomainType(self.xiCoordinates.DOMAIN_TYPE_DATAPOINTS) self.fieldCache = fieldModule.createFieldcache() self.coordinatesField = fieldModule.findFieldByName('coordinates').castFiniteElement() self.nodetemplate = self.datanodeset.createNodetemplate() self.nodetemplate.defineField(self.coordinatesField) self.nodetemplate.defineField(self.nodeAnnotationField) self.nodetemplate.defineField(self.nodeVisibilityFlagField) self.nodetemplate.defineField(self.nodeSizeField) self.nodetemplate.defineField(self.nodeColorField) #Create the scene filter and set the app's sceneview to use it sceneFilterModule = self.zincContext.getScenefiltermodule() self.sceneFilter = sceneFilterModule.createScenefilterRegion(region) def linkToSceneViewer(self): if hasattr(self, 'sceneFilter') and self.sceneFilter.isValid(): self._graphicsScene.setScenefilter(self.sceneFilter) self._graphicsScene.setScene(self.region.getScene()) #Picking fails without this self._graphicsScene.setTumbleRate(0.0) def setTexture(self,imageFile): fieldModule = self.region.getFieldmodule() image_field = fieldModule.createFieldImage() image_field.setFilterMode(image_field.FILTER_MODE_LINEAR) image_field.setWrapMode(image_field.WRAP_MODE_EDGE_CLAMP) #coordinates = fieldModule.findFieldByName('coordinates') image_field.setDomainField(self.coordinatesField) image_field.setTextureCoordinateSizes([1, 1, 1]) # Create a stream information object that we can use to read the # image file from disk stream_information = image_field.createStreaminformationImage() stream_information.createStreamresourceFile(imageFile) image_field.read(stream_information) scene = self.region.getScene() textureMaterial = scene.getMaterialmodule().createMaterial() textureMaterial.setManaged(True) textureMaterial.setName("regionMap") textureMaterial.setTextureField(1, image_field) #textureMaterial.setAttributeReal(Material.ATTRIBUTE_ALPHA, 0.2) if hasattr(self, 'textureMaterial'): del self.textureMaterial self.textureMaterial = textureMaterial if hasattr(self, 'surfaceGraphics'): self.surfaceGraphics.setMaterial(self.textureMaterial) def setupGraphics(self): scene = self.region.getScene() scene.beginChange() # createSurfaceGraphic graphic start fieldModule = self.region.getFieldmodule() coordinateField = fieldModule.findFieldByName('coordinates') glyphModule = scene.getGlyphmodule() glyphModule.defineStandardGlyphs() glyphModule.beginChange() #axisGlyph = glyphModule.findGlyphByGlyphShapeType(Glyph.SHAPE_TYPE_AXES_SOLID_XYZ) glyphModule.endChange() ''' graphics = scene.findGraphicsByName("axis") if graphics.isValid(): scene.removeGraphics(graphics) graphics = scene.createGraphicsPoints() graphics.setName("axis") graphics.setScenecoordinatesystem(SCENECOORDINATESYSTEM_NORMALISED_WINDOW_FIT_BOTTOM) pointattributes = graphics.getGraphicspointattributes() pointattributes.setGlyph(axisGlyph) pointattributes.setBaseSize([0.1,0.1,0.1]) #pointattributes.setGlyphOffset([-0.9,0.0,0.0]) ''' ''' graphics1 = scene.createGraphicsPoints() graphics1.setFieldDomainType(Field.DOMAIN_TYPE_MESH_HIGHEST_DIMENSION) graphics1.setCoordinateField(coordinateField) gpa1 = graphics1.getGraphicspointattributes() cmiss_number = fieldModule.findFieldByName('cmiss_number') gpa1.setLabelField(cmiss_number) gpa1.setGlyphShapeType(Glyph.SHAPE_TYPE_NONE) ''' materialModule = scene.getMaterialmodule () materialModule.defineStandardMaterials () surfaceMaterial = materialModule.findMaterialByName('gold') lineMaterial = materialModule.findMaterialByName('silver') # Create Surface self.surfaceGraphics = scene.createGraphicsSurfaces() self.surfaceGraphics.setCoordinateField(coordinateField) self.surfaceGraphics.setTextureCoordinateField(self.xiCoordinates) self.surfaceGraphics.setMaterial(surfaceMaterial) #Create lines self.surfaceLines = scene.createGraphicsLines() self.surfaceLines.setCoordinateField(coordinateField) lineattributes = self.surfaceLines.getGraphicslineattributes() lineattributes.setShapeType(Graphicslineattributes_SHAPE_TYPE_CIRCLE_EXTRUSION) lineattributes.setBaseSize([0.01,0.01,0.01]) self.surfaceLines.setMaterial(lineMaterial) #Create spectrum to pick up rgb from nodeColor Field spectrumModule = scene.getSpectrummodule() spectrum = spectrumModule.createSpectrum() spectrum.setMaterialOverwrite(True) #This will ensure that the transparency of the material is used spectrum.setName("RGB") spectrumR = spectrum.createSpectrumcomponent() spectrumR.setColourMappingType(spectrumR.COLOUR_MAPPING_TYPE_RED) spectrumR.setFieldComponent(1) spectrumG = spectrum.createSpectrumcomponent() spectrumG.setColourMappingType(spectrumR.COLOUR_MAPPING_TYPE_GREEN) spectrumG.setFieldComponent(2) spectrumB = spectrum.createSpectrumcomponent() spectrumB.setColourMappingType(spectrumR.COLOUR_MAPPING_TYPE_BLUE) spectrumB.setFieldComponent(3) for spec in [spectrumR,spectrumG,spectrumB]: spec.setRangeMinimum(0.0) spec.setRangeMaximum(1.0) spec.setColourMinimum(0.0) spec.setColourMaximum(1.0) spec.setExtendBelow(True) spec.setExtendAbove(True) self.spectrumR = spectrumR self.spectrumB = spectrumB self.spectrumG = spectrumG self.spectrum = spectrum #Code for rendering datapoints graphics = scene.createGraphicsPoints() graphics.setFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS) graphics.setCoordinateField(coordinateField) graphics.setSubgroupField(self.nodeVisibilityFlagField) graphics.setDataField(self.nodeColorField) gpa = graphics.getGraphicspointattributes() gpa.setGlyphShapeType(Glyph.SHAPE_TYPE_SPHERE) gpa.setOrientationScaleField(self.nodeSizeField) graphics.setSpectrum(spectrum) scene.endChange() def getUsedNodesWithXiAndData(self): fieldModule = self.region.getFieldmodule() fieldCache = fieldModule.createFieldcache() mesh = fieldModule.findMeshByDimension(2) meshLocation = fieldModule.createFieldFindMeshLocation(self.coordinatesField,self.coordinatesField,mesh) meshLocation.setSearchMode(FieldFindMeshLocation.SEARCH_MODE_NEAREST) result = dict() for nd in self.usedDataNodes: fieldCache.setNode(self.datanodeset.findNodeByIdentifier(nd)) element, xi = meshLocation.evaluateMeshLocation(fieldCache, 2) annot = self.nodeAnnotationField.evaluateString(fieldCache) _,vis = self.nodeVisibilityFlagField.evaluateReal(fieldCache,1) _,size = self.nodeSizeField.evaluateReal(fieldCache,9) _,color = self.nodeColorField.evaluateReal(fieldCache,3) result[nd] = [element.getIdentifier(),xi,annot,vis,size,color] return result def modelChanged(self): self.datasetColors = self._model.datasetColors self.updateListDatasets() #Create the list and then the points as list name is used for annotation self.updatePointItems() def updatePointItems(self): model_points = self._model.getPoints() set_model_keys = set(model_points.keys()) set_view_keys = set(self._pointItems.keys()) set_intersect_keys = set_model_keys.intersection(set_view_keys) # Added points added_keys = set_model_keys - set_intersect_keys for key in added_keys: pos, dataset = model_points[key] pos = [pos[0], pos[1]] self.addPointItem(key, pos, dataset) # Removed points removed_keys = set_view_keys - set_intersect_keys for key in removed_keys: self.removePointItem(key) def createDataNode(self,key): if len(self.freeDataNodes)==0: node = self.datanodeset.createNode(-1, self.nodetemplate) else: node = self.freeDataNodes.pop(0) self.usedDataNodes[node.getIdentifier()] = key return node def setPosition(self,node,pos): self.fieldCache.setNode(node) self.coordinatesField.assignReal(self.fieldCache,[pos[0],pos[1],0.0]) def setAnnotation(self,node,annot): self.fieldCache.setNode(node) self.nodeAnnotationField.assignString(self.fieldCache,str(annot)) def addPointItem(self, key, pos, dataset): #Only add if it is within the bounds if pos[0]<=1.0 and pos[0]>=-1.0 and pos[1]<=1.0 and pos[1]>=-1.0: pen = self.datasetColors[dataset][0] item = ZincGraphicsEllipseItem(pen, key,self.createDataNode(key)) self._pointItems[key] = (item, dataset) self.setPosition(item.parent, pos) self.nodeSizeField.assignReal(self.fieldCache,[0.1,0,0,0,0.1,0,0,0,0.1]) self.nodeVisibilityFlagField.assignReal(self.fieldCache,1.0) #Assign color self.nodeColorField.assignReal(self.fieldCache,pen) annot = self._datasetItems[dataset]._name self.nodeAnnotationField.assignString(self.fieldCache,str(annot)) def removePointItem(self, key): item, _ = self._pointItems[key] self.fieldCache.setNode(item.parent) self.nodeVisibilityFlagField.assignReal(self.fieldCache,0.0) self.nodeAnnotationField.assignString(self.fieldCache,"Deleted") self.freeDataNodes.append(item.parent) del self.usedDataNodes[item.parent.getIdentifier()] item.parent = None del self._pointItems[key] def listSelectionChanged(self,dataset): for k in self._pointItems: item,ds = self._pointItems[k] self.fieldCache.setNode(item.parent) if ds==dataset: self.nodeSizeField.assignReal(self.fieldCache,[0.1,0,0,0,0.1,0,0,0,0.1]) else: self.nodeSizeField.assignReal(self.fieldCache,[0.05,0,0,0,0.05,0,0,0,0.05]) def updateDatasetName(self,item): key = item._key if item._name != str(item.text()): annot = str(item.text()) item._name = annot self._model.changeDatasetName(key,annot) for k in self._pointItems: itm,ds = self._pointItems[k] if ds==item._key: self.fieldCache.setNode(itm.parent) self.nodeAnnotationField.assignString(self.fieldCache,annot) else: self.listItemVisibilityToggled(item) def updateListDatasets(self): model_datasets = self._model.getDatasets() set_model_keys = set(model_datasets.keys()) set_view_keys = set(self._datasetItems.keys()) set_intersect_keys = set_model_keys.intersection(set_view_keys) #Set the names to match for common keys def iterAllItems(self): for i in range(self.count()): yield self.item(i) for item in iterAllItems(self._listDatasets): if item._key in set_intersect_keys: name = model_datasets[item._key] item._name = name item.setText(name) # Added datasets added_keys = set_model_keys - set_intersect_keys for key in added_keys: name = model_datasets[key] self.addListItem(key, name) # Removed datasets removed_keys = set_view_keys - set_intersect_keys for key in removed_keys: self.removeListItem(key) #Set current item key = self._model.getCurrentDataset() if not key is None: item = self._datasetItems[key] self._listDatasets.setCurrentItem(item) def addListItem(self, key, name): if key in self.datasetColors: col = self.datasetColors[key][1] else: pen,col = self.createPenAndMaterial(self.PenColors[key % len(self.PenColors)]) self.datasetColors[key] = [pen,col] item = PaintDatasetItem(key, name, col) self._datasetItems[key] = item self._listDatasets.addItem(item) def listItemVisibilityToggled(self,item): state = 0.0 if item.checkState(): state = 1.0 key = item._key for k in self._pointItems: itm,ds = self._pointItems[k] if ds==key: self.fieldCache.setNode(itm.parent) self.nodeVisibilityFlagField.assignReal(self.fieldCache,state) def removeListItem(self, key): # TODO: Iterate through items to find the one with the key def iterAllItems(self): for i in range(self.count()): yield self.item(i) for item in iterAllItems(self._listDatasets): if item._key == key: self._listDatasets.takeItem(self._listDatasets.row(item)) del item break del self._datasetItems[key] class ZincPainterWidget(ZincDigitiserWidgetBase): graphicsInitialized = signalHandle() def __init__(self,zincContext,parent=None,shared=None,project=None): super(ZincPainterWidget,self).__init__(parent) self.sceneLayout = QtGui.QVBoxLayout(self.graphicsViewHolder) self.qgl = QtOpenGL.QGLWidget() self.graphicsView = SceneViewerWidget(self.qgl,shared) self.graphicsView.setContext(zincContext) self.sceneLayout.addWidget(self.graphicsView) self.zincContext = zincContext self.filename = None self.model = PaintModel() self.model.modelChanged.connect(self.updateInterface) self.addNewDataset.setIcon(self.style().standardIcon(getattr(QtGui.QStyle, 'SP_FileDialogNewFolder'))) self.removeCurrentDataset.setIcon(self.style().standardIcon(getattr(QtGui.QStyle, 'SP_MessageBoxCritical'))) self.moveUp.setIcon(self.style().standardIcon(getattr(QtGui.QStyle, 'SP_ArrowUp'))) self.moveDown.setIcon(self.style().standardIcon(getattr(QtGui.QStyle, 'SP_ArrowDown'))) self.saveData.setIcon(self.style().standardIcon(getattr(QtGui.QStyle, 'SP_DialogSaveButton'))) self.loadData.setIcon(self.style().standardIcon(getattr(QtGui.QStyle, 'SP_DialogOpenButton'))) self.addNewDataset.clicked.connect(self.addDataset) self.removeCurrentDataset.clicked.connect(self.removeDataset) #self.loadBackground.clicked.connect(self.newBackground) self.saveData.clicked.connect(self.saveRegions) self.loadData.clicked.connect(self.loadRegions) self.moveUp.clicked.connect(self.moveDatasetItemUp) self.moveDown.clicked.connect(self.moveDatasetItemDown) # Actions self.listDatasets.itemSelectionChanged.connect(self.selectedDatasetChanged) # Mouse move self.graphicsView.graphicsInitialized.connect(self.graphicsInitialized) self.graphicsView.pointSelectionClick.connect(self.pointSelected) self.graphicsView.pointDeletionClick.connect(self.pointDeleted) self.graphicsView.doubleClicked.connect(self.viewAll) self.loadproject(project) def moveDatasetItemUp(self): numItems = self.listDatasets.count() if numItems>1: currentRow = self.listDatasets.currentRow() if currentRow > 0: ci = self.listDatasets.takeItem(currentRow) self.listDatasets.insertItem(currentRow - 1, ci) self.listDatasets.setCurrentRow(currentRow - 1) def moveDatasetItemDown(self): numItems = self.listDatasets.count() if numItems>1: currentRow = self.listDatasets.currentRow() if currentRow < numItems-1: ci = self.listDatasets.takeItem(currentRow) self.listDatasets.insertItem(currentRow + 1, ci) self.listDatasets.setCurrentRow(currentRow + 1) def setupMeshBackground(self,backgroundMesh): ''' Load a mesh and create a background based on the node that lie on xy-plane Assumes the standard Stomach Meshobject is used ''' self.model.newDataSet('Default') self.view = DigitizationView(self.model, self.zincContext, self.graphicsView, self.listDatasets) self.view.loadMesh(backgroundMesh) self.view.linkToSceneViewer() self.view.setupGraphics() self.updateInterface() def useBackgroundMesh(self): ''' Use a mesh created for the background based Assumes the standard Stomach Meshobject is used ''' self.model.newDataSet('Default') self.view = DigitizationView(self.model, self.zincContext, self.graphicsView, self.listDatasets) self.view.useMesh() self.view.linkToSceneViewer() self.view.setupGraphics() self.updateInterface() def setTexture(self,filename): self.view.setTexture(filename) def getMarkersAndColors(self): result = self.model.getDatasetInTransformedCoordinates() #Order the result in the listed order orderedResult = OrderedDict() for row in range(self.listDatasets.count()): item = self.listDatasets.item(row) name = item._name orderedResult[name] = result[name] return orderedResult def viewAll(self): #self.graphicsView.viewAll() self._graphicsScene.setViewParameters([0.0, 0.0, 4.742128877220128], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0], 0.6981317007977312) def saveRegions(self,filename=None): if filename is None: filename = QtGui.QFileDialog.getSaveFileName(self, 'Dataset file', '', "Data Files (*.dat)") if isinstance(filename,tuple): #Handle pyside filename = str(filename[0]) if filename is not None and not str(filename) == "": return self.model.saveDataset(filename) return False def loadRegions(self,filename=None): if filename is None: filename = QtGui.QFileDialog.getOpenFileName(self, 'Dataset file', '', "Data Files (*.dat)") if isinstance(filename,tuple): #Handle pyside filename = str(filename[0]) if filename is not None and not str(filename) == "": #Do not clear the lists, it is automatically taken care by the model self.model.loadDataset(filename) self.view.listSelectionChanged(self.model._currentDataset) def getUsedNodesWithXiAndData(self): return self.view.getUsedNodesWithXiAndData() def newBackground(self,filename): self.model.addImage(str(filename)) self.view.setTexture(filename) self.updateInterface() def defaultProject(self): self.model.newDataSet('Default') self.view = DigitizationView(self.model, self.zincContext, self.graphicsView, self.listDatasets) self.view.linkToSceneViewer() self.view.setupGraphics() self.updateInterface() def loadproject(self,filename): if filename is not None and not str(filename) == "": # Try to load project self.model.loadDataset(filename) self.view = DigitizationView(self.model, self.zincContext, self.graphicsView, self.listDatasets) self.view.linkToSceneViewer() self.view.setupGraphics() #Get the colors and texture file information self.updateInterface() def updateInterface(self): pass def addDataset(self): self.model.addDataset() def removeDataset(self): row = self.listDatasets.currentRow() item = self.listDatasets.takeItem(row) self.model.removeDataset(item._key) def selectedDatasetChanged(self): if not self.listDatasets.currentItem() is None: ds = self.listDatasets.currentItem()._key self.model.changeCurrentDataset(ds) if hasattr(self, 'view'): self.view.listSelectionChanged(ds) else: self.model.changeCurrentDataset(None) def pointSelected(self,pos): if not self.graphicsView.nodeOfInterest is None and self.graphicsView.nodeOfInterest.isValid(): nid = self.graphicsView.nodeOfInterest.getIdentifier() if nid in self.view.usedDataNodes: self.pointItemMoved(self.view.usedDataNodes[nid], [pos[0],pos[1]]) else: self.addPoint([pos[0],pos[1]]) else: self.addPoint([pos[0],pos[1]]) def pointDeleted(self,pos): if not self.graphicsView.nodeOfInterest is None and self.graphicsView.nodeOfInterest.isValid(): nid = self.graphicsView.nodeOfInterest.getIdentifier() if nid in self.view.usedDataNodes: self.model.removePoint(self.view.usedDataNodes[nid]) def addPoint(self, pos): self.model.addPoint(pos) def removePoint(self,key): self.model.removePoint(key) def pointItemMoved(self, key, pos): self.model.movePoint(key, pos) from digitiser.mapping import MeshMapper if __name__ == '__main__': # Entry point application = QtGui.QApplication(sys.argv) ctx = Context('ctx') main_window = ZincPainterWidget(ctx) main_window.show() #main_window.defaultProject() backgroundMesh = MeshMapper() #self.backgroundMesh.setupByFile(r'scaffoldmaker.ex2', 8,11) backgroundMesh.setupByPickle('symmetricstomachsurface.pkl') class MeshGen(object): def __init__(self,mesh): self.meshgen = mesh def generateMesh(self,region): self.meshgen.generateFlatMesh(region, 8,11) main_window.setupMeshBackground(MeshGen(backgroundMesh)) main_window.newBackground(r'../textureprocessing/foot1820.jpg') sys.exit(application.exec_())