diff --git a/SimPEG/visulize/__init__.py b/SimPEG/visulize/__init__.py deleted file mode 100644 index 485f9782..00000000 --- a/SimPEG/visulize/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -import vtk -#import mpl diff --git a/SimPEG/visulize/vtk/__init__.py b/SimPEG/visulize/vtk/__init__.py deleted file mode 100644 index 6d60ed5c..00000000 --- a/SimPEG/visulize/vtk/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from vtkTools import vtkTools -from vtkView import vtkView \ No newline at end of file diff --git a/SimPEG/visulize/vtk/vtkTools.py b/SimPEG/visulize/vtk/vtkTools.py deleted file mode 100644 index 50387a14..00000000 --- a/SimPEG/visulize/vtk/vtkTools.py +++ /dev/null @@ -1,361 +0,0 @@ -import numpy as np, vtk, vtk.util.numpy_support as npsup, pdb -from SimPEG.utils import mkvc - - -class vtkTools(object): - """ - Class that interacts with VTK visulization toolkit. - - """ - - def __init__(self): - """ Initializes the VTK vtkTools. - - """ - - pass - - @staticmethod - def makeCellVTKObject(mesh,model): - """ - Make and return a cell based VTK object for a simpeg mesh and model. - - Input: - :param mesh, SimPEG TensorMesh object - mesh to be transfer to VTK - :param model, dictionary of numpy.array - Name('s) and array('s). Match number of cells - - Output: - :rtype: vtkRecilinearGrid object - :return: vtkObj - """ - - # Deal with dimensionalities - if mesh.dim >= 1: - vX = mesh.vectorNx - xD = mesh.nNx - yD,zD = 1,1 - vY, vZ = np.array([0,0]) - if mesh.dim >= 2: - vY = mesh.vectorNy - yD = mesh.nNy - if mesh.dim == 3: - vZ = mesh.vectorNz - zD = mesh.nNz - # Use rectilinear VTK grid. - # Asaign the spatial information. - vtkObj = vtk.vtkRectilinearGrid() - vtkObj.SetDimensions(xD,yD,zD) - vtkObj.SetXCoordinates(npsup.numpy_to_vtk(vX,deep=1)) - vtkObj.SetYCoordinates(npsup.numpy_to_vtk(vY,deep=1)) - vtkObj.SetZCoordinates(npsup.numpy_to_vtk(vZ,deep=1)) - - # Assign the model('s) to the object - for item in model.iteritems(): - # Convert numpy array - vtkDoubleArr = npsup.numpy_to_vtk(item[1],deep=1) - vtkDoubleArr.SetName(item[0]) - vtkObj.GetCellData().AddArray(vtkDoubleArr) - - vtkObj.GetCellData().SetActiveScalars(model.keys()[0]) - return vtkObj - - @staticmethod - def makeFaceVTKObject(mesh,model): - """ - Make and return a face based VTK object for a simpeg mesh and model. - - Input: - :param mesh, SimPEG TensorMesh object - mesh to be transfer to VTK - :param model, dictionary of numpy.array - Name('s) and array('s). - Property array must be order hstack(Fx,Fy,Fz) - - Output: - :rtype: vtkUnstructuredGrid object - :return: vtkObj - """ - - ## Convert simpeg mesh to VTK properties - # Convert mesh nodes to vtkPoints - vtkPts = vtk.vtkPoints() - vtkPts.SetData(npsup.numpy_to_vtk(mesh.gridN,deep=1)) - - # Define the face "cells" - # Using VTK_QUAD cell for faces (see VTK file format) - nodeMat = mesh.r(np.arange(mesh.nN,dtype='int64'),'N','N','M') - def faceR(mat,length): - return mat.T.reshape((length,1)) - # First direction - nTFx = np.prod(mesh.nFx) - FxCellBlock = np.hstack([ 4*np.ones((nTFx,1),dtype='int64'),faceR(nodeMat[:,:-1,:-1],nTFx),faceR(nodeMat[:,1: ,:-1],nTFx),faceR(nodeMat[:,1: ,1: ],nTFx),faceR(nodeMat[:,:-1,1: ],nTFx)] ) - FyCellBlock = np.array([],dtype='int64') - FzCellBlock = np.array([],dtype='int64') - # Second direction - if mesh.dim >= 2: - nTFy = np.prod(mesh.nFy) - FyCellBlock = np.hstack([ 4*np.ones((nTFy,1),dtype='int64'),faceR(nodeMat[:-1,:,:-1],nTFy),faceR(nodeMat[1: ,:,:-1],nTFy),faceR(nodeMat[1: ,:,1: ],nTFy),faceR(nodeMat[:-1,:,1: ],nTFy)] ) - # Third direction - if mesh.dim == 3: - nTFz = np.prod(mesh.nFz) - FzCellBlock = np.hstack([ 4*np.ones((nTFz,1),dtype='int64'),faceR(nodeMat[:-1,:-1,:],nTFz),faceR(nodeMat[1: ,:-1,:],nTFz),faceR(nodeMat[1: ,1: ,:],nTFz),faceR(nodeMat[:-1,1: ,:],nTFz)] ) - # Cells -cell array - FCellArr = vtk.vtkCellArray() - FCellArr.SetNumberOfCells(np.sum(mesh.nF)) - FCellArr.SetCells(np.sum(mesh.nF)*5,npsup.numpy_to_vtkIdTypeArray(np.vstack([FxCellBlock,FyCellBlock,FzCellBlock]),deep=1)) - # Cell type - FCellType = npsup.numpy_to_vtk(vtk.VTK_QUAD*np.ones(np.sum(mesh.nF),dtype='uint8'),deep=1) - # Cell location - FCellLoc = npsup.numpy_to_vtkIdTypeArray(np.arange(0,np.sum(mesh.nF)*5,5,dtype='int64'),deep=1) - - ## Make the object - vtkObj = vtk.vtkUnstructuredGrid() - # Set the objects properties - vtkObj.SetPoints(vtkPts) - vtkObj.SetCells(FCellType,FCellLoc,FCellArr) - - # Assign the model('s) to the object - for item in model.iteritems(): - # Convert numpy array - vtkDoubleArr = npsup.numpy_to_vtk(item[1],deep=1) - vtkDoubleArr.SetName(item[0]) - vtkObj.GetCellData().AddArray(vtkDoubleArr) - - vtkObj.GetCellData().SetActiveScalars(model.keys()[0]) - vtkObj.Update() - return vtkObj - - @staticmethod - def makeEdgeVTKObject(mesh,model): - """ - Make and return a edge based VTK object for a simpeg mesh and model. - - Input: - :param mesh, SimPEG TensorMesh object - mesh to be transfer to VTK - :param model, dictionary of numpy.array - Name('s) and array('s). - Property array must be order hstack(Ex,Ey,Ez) - - Output: - :rtype: vtkUnstructuredGrid object - :return: vtkObj - """ - - ## Convert simpeg mesh to VTK properties - # Convert mesh nodes to vtkPoints - vtkPts = vtk.vtkPoints() - vtkPts.SetData(npsup.numpy_to_vtk(mesh.gridN,deep=1)) - - # Define the face "cells" - # Using VTK_QUAD cell for faces (see VTK file format) - nodeMat = mesh.r(np.arange(mesh.nN,dtype='int64'),'N','N','M') - def edgeR(mat,length): - return mat.T.reshape((length,1)) - # First direction - nTEx = np.prod(mesh.nEx) - ExCellBlock = np.hstack([ 2*np.ones((nTEx,1),dtype='int64'),edgeR(nodeMat[:-1,:,:],nTEx),edgeR(nodeMat[1:,:,:],nTEx)]) - # Second direction - if mesh.dim >= 2: - nTEy = np.prod(mesh.nEy) - EyCellBlock = np.hstack([ 2*np.ones((nTEy,1),dtype='int64'),edgeR(nodeMat[:,:-1,:],nTEy),edgeR(nodeMat[:,1:,:],nTEy)]) - # Third direction - if mesh.dim == 3: - nTEz = np.prod(mesh.nEz) - EzCellBlock = np.hstack([ 2*np.ones((nTEz,1),dtype='int64'),edgeR(nodeMat[:,:,:-1],nTEz),edgeR(nodeMat[:,:,1:],nTEz)]) - # Cells -cell array - ECellArr = vtk.vtkCellArray() - ECellArr.SetNumberOfCells(np.sum(mesh.nE)) - ECellArr.SetCells(np.sum(mesh.nE)*3,npsup.numpy_to_vtkIdTypeArray(np.vstack([ExCellBlock,EyCellBlock,EzCellBlock]),deep=1)) - # Cell type - ECellType = npsup.numpy_to_vtk(vtk.VTK_LINE*np.ones(np.sum(mesh.nE),dtype='uint8'),deep=1) - # Cell location - ECellLoc = npsup.numpy_to_vtkIdTypeArray(np.arange(0,np.sum(mesh.nE)*3,3,dtype='int64'),deep=1) - - ## Make the object - vtkObj = vtk.vtkUnstructuredGrid() - # Set the objects properties - vtkObj.SetPoints(vtkPts) - vtkObj.SetCells(ECellType,ECellLoc,ECellArr) - - # Assign the model('s) to the object - for item in model.iteritems(): - # Convert numpy array - vtkDoubleArr = npsup.numpy_to_vtk(item[1],deep=1) - vtkDoubleArr.SetName(item[0]) - vtkObj.GetCellData().AddArray(vtkDoubleArr) - - vtkObj.GetCellData().SetActiveScalars(model.keys()[0]) - return vtkObj - - @staticmethod - def makeRenderWindow(ren): - renwin = vtk.vtkRenderWindow() - renwin.AddRenderer(ren) - iren = vtk.vtkRenderWindowInteractor() - iren.SetRenderWindow(renwin) - - return iren, renwin - - - @staticmethod - def closeRenderWindow(iren): - renwin = iren.GetRenderWindow() - renwin.Finalize() - iren.TerminateApp() - - del iren, renwin - - @staticmethod - def makeVTKActor(vtkObj): - """ Makes a vtk mapper and Actor""" - mapper = vtk.vtkDataSetMapper() - mapper.SetInput(vtkObj) - actor = vtk.vtkActor() - actor.SetMapper(mapper) - actor.GetProperty().SetColor(0,0,0) - actor.GetProperty().SetRepresentationToWireframe() - return actor - - @staticmethod - def makeVTKLODActor(vtkObj,clipper): - """Make LOD vtk Actor""" - selectMapper = vtk.vtkDataSetMapper() - selectMapper.SetInputConnection(clipper.GetOutputPort()) - selectMapper.SetScalarVisibility(1) - selectMapper.SetColorModeToMapScalars() - selectMapper.SetScalarModeToUseCellData() - selectMapper.SetScalarRange(clipper.GetInputDataObject(0,0).GetCellData().GetArray(0).GetRange()) - - selectActor = vtk.vtkLODActor() - selectActor.SetMapper(selectMapper) - selectActor.GetProperty().SetEdgeColor(1,0.5,0) - selectActor.GetProperty().SetEdgeVisibility(0) - selectActor.VisibilityOn() - selectActor.SetScale(1.01, 1.01, 1.01) - return selectActor - - @staticmethod - def setScalar2View(vtkObj,scalarName): - """ Sets the sclar to view """ - useArr = vtkObj.GetCellData().GetArray(scalarName) - if useArr == None: - raise IOError('Nerty array {:s} in the vtkObject'.format(scalarName)) - vtkObj.GetCellData().SetActiveScalars(scalarName) - - @staticmethod - def makeRectiVTKVOIThres(vtkObj): - """Make volume of interest and threshold for rectilinear grid.""" - cellCore = vtk.vtkExtractRectilinearGrid() - cellCore.SetInput(vtkObj) - cellCore.SetVOI(vtkObj.GetExtent()) - cellThres = vtk.vtkThreshold() - cellThres.AllScalarsOn() - cellThres.SetInputConnection(cellCore.GetOutputPort()) - cellThres.ThresholdByUpper(-1) - cellThres.Update() - return cellThres.GetOutput(), cellCore.GetOutput() - - @staticmethod - def makePlaneClipper(vtkObj): - """Makes a plane and clipper """ - plane = vtk.vtkPlane() - clipper = vtk.vtkClipDataSet() - clipper.SetInputConnection(vtkObj.GetProducerPort()) - clipper.SetClipFunction(plane) - clipper.InsideOutOff() - return clipper, plane - - @staticmethod - def makePlaneWidget(vtkObj,iren,plane,actor): - """Make an interactive planeWidget""" - - # Callback function - def movePlane(obj, events): - obj.GetPlane(intPlane) - intActor.VisibilityOn() - - # Associate the line widget with the interactor - planeWidget = vtk.vtkImplicitPlaneWidget() - planeWidget.SetInteractor(iren) - planeWidget.SetPlaceFactor(1.25) - planeWidget.SetInput(vtkObj) - planeWidget.PlaceWidget() - #planeWidget.AddObserver("InteractionEvent", movePlane) - planeWidget.SetScaleEnabled(0) - planeWidget.SetEnabled(1) - planeWidget.SetOutlineTranslation(0) - planeWidget.GetPlaneProperty().SetOpacity(0.1) - return planeWidget - - - @staticmethod - def startRenderWindow(iren): - """ Start a vtk rendering window""" - iren.Initialize() - renwin = iren.GetRenderWindow() - renwin.Render() - iren.Start() - - - # Simple write/read VTK xml model functions. - @staticmethod - def writeVTPFile(fileName,vtkPolyObject): - '''Function to write vtk polydata file (vtp).''' - polyWriter = vtk.vtkXMLPolyDataWriter() - polyWriter.SetInput(vtkPolyObject) - polyWriter.SetFileName(fileName) - polyWriter.Update() - - @staticmethod - def writeVTUFile(fileName,vtkUnstructuredGrid): - '''Function to write vtk unstructured grid (vtu).''' - Writer = vtk.vtkXMLUnstructuredGridWriter() - Writer.SetInput(vtkUnstructuredGrid) - Writer.SetFileName(fileName) - Writer.Update() - - @staticmethod - def writeVTRFile(fileName,vtkRectilinearGrid): - '''Function to write vtk rectilinear grid (vtr).''' - Writer = vtk.vtkXMLRectilinearGridWriter() - Writer.SetInput(vtkRectilinearGrid) - Writer.SetFileName(fileName) - Writer.Update() - - @staticmethod - def writeVTSFile(fileName,vtkStructuredGrid): - '''Function to write vtk structured grid (vts).''' - Writer = vtk.vtkXMLStructuredGridWriter() - Writer.SetInput(vtkStructuredGrid) - Writer.SetFileName(fileName) - Writer.Update() - - @staticmethod - def readVTSFile(fileName): - '''Function to read vtk structured grid (vts) and return a grid object.''' - Reader = vtk.vtkXMLStructuredGridReader() - Reader.SetFileName(fileName) - Reader.Update() - return Reader.GetOutput() - - @staticmethod - def readVTUFile(fileName): - '''Function to read vtk structured grid (vtu) and return a grid object.''' - Reader = vtk.vtkXMLUnstructuredGridReader() - Reader.SetFileName(fileName) - Reader.Update() - return Reader.GetOutput() - - @staticmethod - def readVTRFile(fileName): - '''Function to read vtk structured grid (vtr) and return a grid object.''' - Reader = vtk.vtkXMLRectilinearGridReader() - Reader.SetFileName(fileName) - Reader.Update() - return Reader.GetOutput() - - @staticmethod - def readVTPFile(fileName): - '''Function to read vtk structured grid (vtp) and return a grid object.''' - Reader = vtk.vtkXMLPolyDataReader() - Reader.SetFileName(fileName) - Reader.Update() - return Reader.GetOutput() - diff --git a/SimPEG/visulize/vtk/vtkView.py b/SimPEG/visulize/vtk/vtkView.py deleted file mode 100644 index 334561ba..00000000 --- a/SimPEG/visulize/vtk/vtkView.py +++ /dev/null @@ -1,137 +0,0 @@ -import numpy as np, vtk -import SimPEG as simpeg -#import SimPEG.visulize.vtk.vtkTools as vtkSP # Always get an error for this import - -class vtkView(object): - """ - Class for storing and view of SimPEG models in VTK (visulization toolkit). - - Inputs: - :param mesh, SimPEG mesh. - :param propdict, dictionary of property models. - Can have these dictionary names: - 'cell' - cell model; 'face' - face model; 'edge' - edge model - The dictionary properties are given as dictionaries with: - {'NameOfThePropertyModel': np.array of the properties}. - The property array has to be ordered in compliance with SimPEG standards. - - :: - Example of usages. - - ToDo - - """ - - def __init__(self,mesh,propdict): - """ - """ - - self.name = 'VTK figure of SimPEG model' - self.extent = [0,mesh.nCx-1,0,mesh.nCy-1,0,mesh.nCz-1] - self.limits = [0, 10000] - self._mesh = mesh - - # Set vtk object containers - self._cell = None - self._faces = None - self._edges = None - - self._readPropertyDictionary(propdict) - - # Setup hidden properties - self._ren = None - self._iren = None - self._renwin = None - self._core = None - self._viewobj = None - self._plane = None - self._clipper = None - self._widget = None - self._actor = None - self._lut = None - - def _readPropertyDictionary(self,propdict): - """ - Reads the property and assigns to the object - """ - import SimPEG.visulize.vtk.vtkTools as vtkSP - - # Test the property dictionary - if len(propdict) > 3: - raise(Exception,'Too many input items in the property dictionary') - for propitem in propdict.iteritems(): - if propitem[0] in ['cell','face','edge']: - if propitem[0] == 'cell': - self._cell = vtkSP.makeCellVTKObject(self._mesh,propitem[1]) - if propitem[0] == 'face': - self._face = vtkSP.makeFaceVTKObject(self._mesh,propitem[1]) - if propitem[0] == 'edge': - self._edge = vtkSP.makeEdgeVTKObject(self._mesh,propitem[1]) - else: - raise(Exception,'{:s} is not allowed as a dictonary key. Can be \'cell\',\'face\',\'edge\'.'.format(propitem[0])) - - def Show(self,imageType='cell'): - """ - Open the VTK figure window and show the mesh. - - Inputs: - param: str imageType: type of image {'cell','face','edge'} - - """ - #vtkSP = simpeg.visulize.vtk.vtkTools - import SimPEG.visulize.vtk.vtkTools as vtkSP - - # Make a renderer - self._ren = vtk.vtkRenderer() - # Make renderwindow. Returns the interactor. - self._iren, self._renwin = vtkSP.makeRenderWindow(self._ren) - - - # Sort out the actor - if imageType == 'cell': - self._vtkobj, self._core = vtkSP.makeRectiVTKVOIThres(self._cell) - elif imageType == 'face': - self._vtkobj, self._core = vtkSP.makeRectiVTKVOIThres(self._face) - elif imageType == 'edge': - self._vtkobj, self._core = vtkSP.makeRectiVTKVOIThres(self._edge) - else: - raise Exception("{:s} is not a vailid imageType. Has to be 'cell':'face':'edge'".format(imageType)) - - - global intPlane, intActor - self._clipper, intPlane = vtkSP.makePlaneClipper(self._vtkobj) - intActor = vtkSP.makeVTKLODActor(self._vtkobj,self._clipper) - self._widget = vtkSP.makePlaneWidget(self._vtkobj,self._iren,self._clipper.GetClipFunction(),self._actor) - # Callback function - self._plane = intPlane - self._actor = intActor - def movePlane(obj, events): - global intPlane, intActor - obj.GetPlane(intPlane) - intActor.VisibilityOn() - - self._widget.AddObserver("InteractionEvent",movePlane) - lut = vtk.vtkLookupTable() - lut.SetNumberOfColors(256) - lut.SetHueRange(0,0.66667) - lut.Build() - self._lut = lut - self._actor.GetMapper().SetLookupTable(lut) - - # Set renderer options - self._ren.SetBackground(.5,.5,.5) - self._ren.AddActor(self._actor) - - # Start the render Window - vtkSP.startRenderWindow(self._iren) - # Close the window when exited - vtkSP.closeRenderWindow(self._iren) - del self._iren, self._renwin - - - - - - - - diff --git a/notebooks/3DRenderingWithvtkTools.ipynb.orig b/notebooks/3DRenderingWithvtkTools.ipynb.orig new file mode 100644 index 00000000..8d2c833d --- /dev/null +++ b/notebooks/3DRenderingWithvtkTools.ipynb.orig @@ -0,0 +1,115 @@ +{ + "metadata": { +<<<<<<< HEAD + "name": "3D rendering with vtkTools" +======= + "name": "" +>>>>>>> develop + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, +<<<<<<< HEAD + "input": "import numpy as np, vtk\nimport SimPEG as simpeg", + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 +======= + "input": [ + "import numpy as np, vtk\n", + "import SimPEG as simpeg" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 5 +>>>>>>> develop + }, + { + "cell_type": "code", + "collapsed": false, +<<<<<<< HEAD + "input": "#Make a mesh and model\nx0 = np.zeros(3)\nh1 = np.ones(20)*5\nh2 = np.ones(10)*10\nh3 = np.ones(5)*20\n\nmesh = simpeg.mesh.TensorMesh([h1,h2,h3],x0)\n", + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 +======= + "input": [ + "#Make a mesh and model\n", + "x0 = np.zeros(3)\n", + "h1 = np.ones(20)*50\n", + "h2 = np.ones(10)*100\n", + "h3 = np.ones(5)*200\n", + "\n", + "mesh = simpeg.mesh.TensorMesh([h1,h2,h3],x0)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 6 +>>>>>>> develop + }, + { + "cell_type": "code", + "collapsed": false, +<<<<<<< HEAD + "input": "# Make a models that correspond to the cells, faces and edges.\nmodels = {'cell':{'Test':np.arange(0,mesh.nC),'AllOnce':np.ones(mesh.nC)},'face':{'Test':np.arange(0,np.sum(mesh.nF)),'AllOnce':np.ones(np.sum(mesh.nF))},'edge':{'Test':np.arange(0,np.sum(mesh.nE)),'AllOnce':np.ones(np.sum(mesh.nE))}}\n# Make the vtk viewer object.\nvtkViewer = simpeg.visulize.vtk.vtkView(mesh,models) \n ", + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 3 +======= + "input": [ + "# Make a models that correspond to the cells, faces and edges.\n", + "models = {'cell':{'Test':np.arange(0,mesh.nC),'AllOnce':np.ones(mesh.nC)},'face':{'Test':np.arange(0,np.sum(mesh.nF)),'AllOnce':np.ones(np.sum(mesh.nF))},'edge':{'Test':np.arange(0,np.sum(mesh.nE)),'AllOnce':np.ones(np.sum(mesh.nE))}}\n", + "# Make the vtk viewer object.\n", + "vtkViewer = simpeg.visualize.vtk.vtkView(mesh,models) \n", + " " + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 7 +>>>>>>> develop + }, + { + "cell_type": "code", + "collapsed": false, +<<<<<<< HEAD + "input": "# Show the image \nvtkViewer.Show(imageType='cell')\n", + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 + }, + { + "cell_type": "code", + "collapsed": false, + "input": "", + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 4 +======= + "input": [ + "# Show the image \n", + "vtkViewer.Show()\n" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": "*" +>>>>>>> develop + } + ], + "metadata": {} + } + ] +}