Beispiel #1
0
 def mouseMoveEvent(self, event):
     if self._lastMousePos is not None:
         pos = [ event.x(), event.y() ]
         delta = [ pos[0] - self._lastMousePos[0], pos[1] - self._lastMousePos[1] ]
         result, eye = self._sceneviewer.getEyePosition()
         result, lookat = self._sceneviewer.getLookatPosition()
         result, up = self._sceneviewer.getUpVector()
         lookatToEye = vectorops.sub(eye, lookat)
         eyeDistance = vectorops.magnitude(lookatToEye)
         front = vectorops.div(lookatToEye, eyeDistance)
         right = vectorops.cross(up, front)
         if self._active_button == QtCore.Qt.LeftButton:
             mag = vectorops.magnitude(delta)
             prop = vectorops.div(delta, mag)
             axis = vectorops.add(vectorops.mult(up, prop[0]), vectorops.mult(right, prop[1]))
             angle = mag*0.002
             self._model.rotateModel(axis, angle)
         elif self._active_button == QtCore.Qt.MiddleButton:
             result, l, r, b, t, near, far = self._sceneviewer.getViewingVolume()
             viewportWidth = self.width()
             viewportHeight = self.height()
             if viewportWidth > viewportHeight:
                 eyeScale = (t - b) / viewportHeight
             else:
                 eyeScale = (r - l) / viewportWidth
             offset = vectorops.add(vectorops.mult(right, eyeScale*delta[0]), vectorops.mult(up, -eyeScale*delta[1]))
             self._model.translateModel(offset)
         elif self._active_button == QtCore.Qt.RightButton:
             factor = 1.0 + delta[1]*0.0005
             if factor < 0.9:
                 factor = 0.9
             self._model.scaleModel(factor)
         self._lastMousePos = pos
     else:
         super(AlignmentSceneviewerWidget, self).mouseMoveEvent(event)
 def mouseMoveEvent(self, event):
     if self._lastMousePos is not None:
         pos = [ event.x(), event.y() ]
         delta = [ pos[0] - self._lastMousePos[0], pos[1] - self._lastMousePos[1] ]
         result, eye = self._sceneviewer.getEyePosition()
         result, lookat = self._sceneviewer.getLookatPosition()
         result, up = self._sceneviewer.getUpVector()
         lookatToEye = vectorops.sub(eye, lookat)
         eyeDistance = vectorops.magnitude(lookatToEye)
         front = vectorops.div(lookatToEye, eyeDistance)
         right = vectorops.cross(up, front)
         if self._active_button == QtCore.Qt.LeftButton:
             mag = vectorops.magnitude(delta)
             prop = vectorops.div(delta, mag)
             axis = vectorops.add(vectorops.mult(up, prop[0]), vectorops.mult(right, prop[1]))
             angle = mag*0.002
             self._model.rotateModel(axis, angle)
         elif self._active_button == QtCore.Qt.MiddleButton:
             result, l, r, b, t, near, far = self._sceneviewer.getViewingVolume()
             viewportWidth = self.width()
             viewportHeight = self.height()
             if viewportWidth > viewportHeight:
                 eyeScale = (t - b) / viewportHeight
             else:
                 eyeScale = (r - l) / viewportWidth
             offset = vectorops.add(vectorops.mult(right, eyeScale*delta[0]), vectorops.mult(up, -eyeScale*delta[1]))
             self._model.offsetModel(offset)
         elif self._active_button == QtCore.Qt.RightButton:
             factor = 1.0 + delta[1]*0.0005
             if factor < 0.9:
                 factor = 0.9
             self._model.scaleModel(factor)
         self._lastMousePos = pos
     else:
         super(AlignmentSceneviewerWidget, self).mouseMoveEvent(event)
 def rotateModel(self, axis, angle):
     quat = vectorops.axisAngleToQuaternion(axis, angle)
     mat1 = vectorops.rotmx(quat)
     mat2 = vectorops.eulerToRotationMatrix3(self._alignSettings['euler_angles'])
     if self.isAlignMirror():
         mat2[0] = vectorops.mult(mat2[0], -1.0)
     newmat = vectorops.matrixmult(mat1, mat2)
     if self.isAlignMirror():
         newmat[0] = vectorops.mult(newmat[0], -1.0)
     self._alignSettings['euler_angles'] = vectorops.rotationMatrix3ToEuler(newmat)
     self._applyAlignSettings()
 def rotateModel(self, axis, angle):
     quat = vectorops.axisAngleToQuaternion(axis, angle)
     mat1 = vectorops.rotmx(quat)
     mat2 = vectorops.eulerToRotationMatrix3(
         self._alignSettings['euler_angles'])
     if self.isAlignMirror():
         mat2[0] = vectorops.mult(mat2[0], -1.0)
     newmat = vectorops.matrixmult(mat1, mat2)
     if self.isAlignMirror():
         newmat[0] = vectorops.mult(newmat[0], -1.0)
     self._alignSettings['euler_angles'] = vectorops.rotationMatrix3ToEuler(
         newmat)
     self._applyAlignSettings()
 def setStatePostAlign(self):
     if not self._isStateAlign:
         return
     self._isStateAlign = False
     rotationScale = vectorops.matrixconstantmult(vectorops.eulerToRotationMatrix3(self._alignSettings['euler_angles']), self._alignSettings['scale'])
     if self.isAlignMirror():
         rotationScale[0] = vectorops.mult(rotationScale[0], -1.0)
     zincutils.transformCoordinates(self._modelCoordinateField, rotationScale, self._alignSettings['offset'])
     zincutils.copyNodalParameters(self._modelCoordinateField, self._modelReferenceCoordinateField)
     self._setModelGraphicsCoordinateField(self._modelCoordinateField)
    def load(self):
        if self._modelReferenceCoordinateField is None:
            # read and rename coordinates to reference_coordinates, for calculating strains
            result = self._region.readFile(self._zincModelFile)
            if result != ZINC_OK:
                raise ValueError('Failed to read reference model')
            self._modelReferenceCoordinateField = self._getModelCoordinateField(
            )
            name = self._modelReferenceCoordinateField.getName()
            number = 0
            numberString = ''
            while True:
                result = self._modelReferenceCoordinateField.setName(
                    'reference_' + name + numberString)
                if result == ZINC_OK:
                    #print('Renamed field', name, ' to', 'reference_' + name + numberString)
                    break
                number = number + 1
                numberString = str(number)
            # read data cloud
            if self._zincPointCloudFile:
                sir = self._region.createStreaminformationRegion()
                pointCloudResource = sir.createStreamresourceFile(
                    self._zincPointCloudFile)
                sir.setResourceDomainTypes(pointCloudResource,
                                           Field.DOMAIN_TYPE_DATAPOINTS)
                result = self._region.read(sir)
                if result != ZINC_OK:
                    raise ValueError('Failed to read point cloud')
                self._dataCoordinateField = self._getDataCoordinateField()
            elif self._pointCloudData:
                self._dataCoordinateField = createFiniteElementField(
                    self._region, field_name='data_coordinates')
                self._createDataPoints(self._pointCloudData)

        result = self._region.readFile(self._zincModelFile)
        if result != ZINC_OK:
            raise ValueError('Failed to read model')
        self._mesh = self._getMesh()
        self._modelCoordinateField = self._getModelCoordinateField()
        minimums, maximums = self._getModelRange()
        self._modelCentre = vectorops.mult(vectorops.add(minimums, maximums),
                                           0.5)
        self._projectSurfaceGroup, self._projectSurfaceElementGroup = self._getProjectSurfaceGroup(
        )
        fm = self._region.getFieldmodule()
        datapoints = fm.findNodesetByFieldDomainType(
            Field.DOMAIN_TYPE_DATAPOINTS)
        self._activeDataPointGroupField = fm.createFieldNodeGroup(datapoints)
        tmpTrue = fm.createFieldConstant([1])
        activeDatapointsGroup = self._activeDataPointGroupField.getNodesetGroup(
        )
        activeDatapointsGroup.addNodesConditional(tmpTrue)
        self._applyAlignSettings()
        self._showModelGraphics()
 def setStatePostAlign(self):
     if not self._isStateAlign:
         return
     self._isStateAlign = False
     rotationScale = vectorops.matrixconstantmult(
         vectorops.eulerToRotationMatrix3(
             self._alignSettings['euler_angles']),
         self._alignSettings['scale'])
     if self.isAlignMirror():
         rotationScale[0] = vectorops.mult(rotationScale[0], -1.0)
     zincutils.transformCoordinates(self._modelCoordinateField,
                                    rotationScale,
                                    self._alignSettings['offset'])
     zincutils.copyNodalParameters(self._modelCoordinateField,
                                   self._modelReferenceCoordinateField)
     self._setModelGraphicsCoordinateField(self._modelCoordinateField)
    def _load(self):
        if self._modelReferenceCoordinateField is None:
            # read and rename coordinates to reference_coordinates, for calculating strains
            result = self._region.readFile(self._zincModelFile)
            if result != ZINC_OK:
                raise ValueError('Failed to read reference model')
            self._modelReferenceCoordinateField = self._getModelCoordinateField()
            name = self._modelReferenceCoordinateField.getName()
            number = 0
            numberString = ''
            while True:
                result = self._modelReferenceCoordinateField.setName('reference_' + name + numberString)
                if result == ZINC_OK:
                    #print('Renamed field', name, ' to', 'reference_' + name + numberString)
                    break
                number = number + 1
                numberString = str(number)
            # read data cloud
            if self._zincPointCloudFile:
                sir = self._region.createStreaminformationRegion()
                pointCloudResource = sir.createStreamresourceFile(self._zincPointCloudFile)
                sir.setResourceDomainTypes(pointCloudResource, Field.DOMAIN_TYPE_DATAPOINTS)
                result = self._region.read(sir)
                if result != ZINC_OK:
                    raise ValueError('Failed to read point cloud')
                self._dataCoordinateField = self._getDataCoordinateField()
            elif self._pointCloudData:
                self._dataCoordinateField = createFiniteElementField(self._region, field_name='data_coordinates')
                self._createDataPoints(self._pointCloudData)

        result = self._region.readFile(self._zincModelFile)
        if result != ZINC_OK:
            raise ValueError('Failed to read model')
        self._mesh = self._getMesh()
        self._modelCoordinateField = self._getModelCoordinateField()
        minimums, maximums = self._getModelRange()
        self._modelCentre = vectorops.mult(vectorops.add(minimums, maximums), 0.5)
        self._projectSurfaceGroup, self._projectSurfaceElementGroup = self._getProjectSurfaceGroup()
        fm = self._region.getFieldmodule()
        datapoints = fm.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
        self._activeDataPointGroupField = fm.createFieldNodeGroup(datapoints)
        tmpTrue = fm.createFieldConstant([1])
        activeDatapointsGroup = self._activeDataPointGroupField.getNodesetGroup()
        activeDatapointsGroup.addNodesConditional(tmpTrue)
        self._applyAlignSettings()
        self._showModelGraphics()
 def autoCentreModelOnData(self):
     minimums, maximums = self._getDataRange()
     dataCentre = vectorops.mult(vectorops.add(minimums, maximums), 0.5)
     self.setAlignOffset(vectorops.sub(dataCentre, self._modelCentre))
 def autoCentreModelOnData(self):
     minimums, maximums = self._getDataRange()
     dataCentre = vectorops.mult(vectorops.add(minimums, maximums), 0.5)
     self.setAlignOffset(vectorops.sub(dataCentre, self._modelCentre))