コード例 #1
0
ファイル: organiseData.py プロジェクト: beauof/FSIViewer
def assignElements2Dlin(mesh, elements):
    
    numRows, numCols = elements.shape
    
    # TODO can we do this faster?
    for i in range(numRows):
        v0, v1, v2, v3, v4, v5 = elements[i, :]
        tri1 = vtk.vtkTriangle()
        tri1.GetPointIds().SetId(0, v0)
        tri1.GetPointIds().SetId(1, v3)
        tri1.GetPointIds().SetId(2, v4)
        tri2 = vtk.vtkTriangle()
        tri2.GetPointIds().SetId(0, v3)
        tri2.GetPointIds().SetId(1, v1)
        tri2.GetPointIds().SetId(2, v5)
        tri3 = vtk.vtkTriangle()
        tri3.GetPointIds().SetId(0, v3)
        tri3.GetPointIds().SetId(1, v5)
        tri3.GetPointIds().SetId(2, v4)
        tri4 = vtk.vtkTriangle()
        tri4.GetPointIds().SetId(0, v4)
        tri4.GetPointIds().SetId(1, v5)
        tri4.GetPointIds().SetId(2, v2)
        mesh.InsertNextCell(tri1.GetCellType(), tri1.GetPointIds())
        mesh.InsertNextCell(tri1.GetCellType(), tri2.GetPointIds())
        mesh.InsertNextCell(tri1.GetCellType(), tri3.GetPointIds())
        mesh.InsertNextCell(tri1.GetCellType(), tri4.GetPointIds())
    return mesh
コード例 #2
0
def setup_topography(x, y, topography, xmax=None, ymax=None, decimation=1):
    # Define points, triangles and colors
    x = x[::decimation]
    y = y[::decimation]
    lonsize = len(x)-1 if not xmax else xmax
    latsize = len(y)-1 if not ymax else ymax
    colors = vtk.vtkUnsignedCharArray()
    # colors.SetNumberOfComponents(3)
    colors.SetNumberOfComponents(1)
    points = vtk.vtkPoints()
    triangles = vtk.vtkCellArray()
    zmax = topography.max()
    zmin = topography.min()
    zrange = zmax - zmin
    xmesh, ymesh = scaled_mesh(x, y)
    count = 0
    t1 = time.time()
    topography = topography.T
    topo_new = num.zeros((len(y), len(x)))
    for iy in xrange(len(y)):
        topo_new[iy, :] = topography[iy*decimation, ::decimation]
    topography = topo_new
    for i in xrange(latsize):
        print '%i / %i' % (i+1, latsize)
        for j in xrange(lonsize-3):

            d = (ymesh[i][j], xmesh[i][j], topography[i][j])
            c = (ymesh[i][j+1], xmesh[i][j+1], topography[i][j+1])
            b = (ymesh[i+1][j+1], xmesh[i+1][j+1], topography[i+1][j+1])
            a = (ymesh[i+1][j], xmesh[i+1][j], topography[i+1][j])
            points.InsertNextPoint(*a)
            points.InsertNextPoint(*b)
            points.InsertNextPoint(*c)

            triangle = vtk.vtkTriangle()
            triangle.GetPointIds().SetId(0, count)
            triangle.GetPointIds().SetId(1, count + 1)
            triangle.GetPointIds().SetId(2, count + 2)

            triangles.InsertNextCell(triangle)

            points.InsertNextPoint(*a)
            points.InsertNextPoint(*d)
            points.InsertNextPoint(*c)

            triangle = vtk.vtkTriangle()
            triangle.GetPointIds().SetId(0, count + 3)
            triangle.GetPointIds().SetId(1, count + 4)
            triangle.GetPointIds().SetId(2, count + 5)

            count += 6

            triangles.InsertNextCell(triangle)

            # rs = [[int((zmax-topography[j][i])/zrange*255)]]*6
            rs = [[int((zmax-topography[i][j])/zrange*255)]]*6
            map(colors.InsertNextTupleValue, rs)
    print 'total time needed ', time.time()-t1
    return points, triangles, colors
コード例 #3
0
ファイル: v0.4.py プロジェクト: maxrosan/MAC5742_EP1
    def vtkTile(tile, min_temp, max_temp):
        # calcula a intensidade da cor para representar a temperatura.
        # vermelho, com pastilha. azul, estourou
        intensity = 255 - int(((tile.last_temp - min_temp) / (max_temp - min_temp)) * 256)
        if tile.bursted:
            color = (intensity, intensity, 255)
        else:
            color = (255, intensity, intensity)

        Points = vtk.vtkPoints()
        Triangles = vtk.vtkCellArray()

        Points.InsertNextPoint(*tile.edges[0])
        Points.InsertNextPoint(*tile.edges[1])
        Points.InsertNextPoint(*tile.edges[2])
        Points.InsertNextPoint(*tile.edges[3])

        Triangle1 = vtk.vtkTriangle();
        Triangle1.GetPointIds().SetId(0, 0);
        Triangle1.GetPointIds().SetId(1, 1);
        Triangle1.GetPointIds().SetId(2, 2);
        Triangles.InsertNextCell(Triangle1);

        Triangle2 = vtk.vtkTriangle();
        Triangle2.GetPointIds().SetId(0, 1);
        Triangle2.GetPointIds().SetId(1, 3);
        Triangle2.GetPointIds().SetId(2, 2);
        Triangles.InsertNextCell(Triangle2);

        Colors = vtk.vtkUnsignedCharArray();
        Colors.SetNumberOfComponents(3);
        Colors.SetName("Colors");
        Colors.InsertNextTuple3(*color);
        Colors.InsertNextTuple3(*color);

        polydata = vtk.vtkPolyData()
        polydata.SetPoints(Points)
        polydata.SetPolys(Triangles)
 
        polydata.GetCellData().SetScalars(Colors);
        polydata.Modified()
        polydata.Update()

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInput(polydata)
        
        actor = vtk.vtkActor()
        actor.SetMapper(mapper)
        actor.GetProperty().SetAmbient(1.0)
        actor.GetProperty().SetDiffuse(0.0)

        return actor
コード例 #4
0
ファイル: Clustering.py プロジェクト: myousefi2016/PyACVD
def Gen_uGrid(new_pt, new_fc):
    """ Generates a vtk unstructured grid given points and triangular faces"""
    ints = np.ones(len(new_fc), 'int') * 3
    cells = np.hstack((ints.reshape(-1, 1), np.vstack(new_fc)))

    # Generate vtk mesh

    # Convert points to vtkfloat object
    points = np.vstack(new_pt)
    vtkArray = VN.numpy_to_vtk(np.ascontiguousarray(points),
                               deep=True)  #, deep=True)
    points = vtk.vtkPoints()
    points.SetData(vtkArray)

    # Convert to vtk arrays
    tritype = vtk.vtkTriangle().GetCellType() * np.ones(len(new_fc), 'int')
    cell_type = np.ascontiguousarray(tritype).astype('uint8')
    cell_type = VN.numpy_to_vtk(cell_type, deep=True)

    offset = np.cumsum(np.hstack(ints + 1))
    offset = np.ascontiguousarray(np.delete(np.insert(offset, 0, 0),
                                            -1)).astype('int64')  # shift
    offset = VN.numpy_to_vtkIdTypeArray(offset, deep=True)

    cells = np.ascontiguousarray(np.hstack(cells).astype('int64'))
    vtkcells = vtk.vtkCellArray()
    vtkcells.SetCells(cells.shape[0],
                      VN.numpy_to_vtkIdTypeArray(cells, deep=True))

    # Create unstructured grid
    uGrid = vtk.vtkUnstructuredGrid()
    uGrid.SetPoints(points)
    uGrid.SetCells(cell_type, offset, vtkcells)

    return uGrid
コード例 #5
0
ファイル: mmio.py プロジェクト: MRE-Code-Hub/meshmagick
def _build_vtkPolyData(vertices, faces):
    """Builds a vtkPolyData object from vertices and faces"""

    import vtk

    # Create a vtkPoints object and store the points in it
    points = vtk.vtkPoints()
    for point in vertices:
        points.InsertNextPoint(point)

    # Create a vtkCellArray to store faces
    cell_array = vtk.vtkCellArray()
    for face_ids in faces:
        if face_ids[0] == face_ids[-1]:
            # Triangle
            curface = face_ids[:3]
            vtk_face = vtk.vtkTriangle()
        else:
            # Quadrangle
            curface = face_ids[:4]
            vtk_face = vtk.vtkQuad()

        for idx, id in enumerate(curface):
            vtk_face.GetPointIds().SetId(idx, id)

        cell_array.InsertNextCell(vtk_face)

    polydata_mesh = vtk.vtkPolyData()
    polydata_mesh.SetPoints(points)
    polydata_mesh.SetPolys(cell_array)

    return polydata_mesh
コード例 #6
0
ファイル: vtkService.py プロジェクト: gmarupilla/vcell-1
def getMembraneVtkGrid(visMesh):
    assert isinstance(visMesh, VisMesh)
    vtkpoints = vtk.vtkPoints()
    for visPoint in visMesh.surfacePoints:
        vtkpoints.InsertNextPoint(visPoint.x, visPoint.y, visPoint.z)

    vtkgrid = vtk.vtkUnstructuredGrid()
    vtkgrid.Allocate(len(visMesh.surfacePoints), len(visMesh.surfacePoints))
    vtkgrid.SetPoints(vtkpoints)

    if visMesh.dimension == 2:
        vtkline = vtk.vtkLine()
        lineType = vtkline.GetCellType()

        for line in visMesh.visLines:
            pts = vtk.vtkIdList()
            pts.InsertNextId(line.p1)
            pts.InsertNextId(line.p2)
            vtkgrid.InsertNextCell(lineType, pts)
    else:
        vtktriangle = vtk.vtkTriangle()
        triangleType = vtktriangle.GetCellType()
        for surfaceTriangle in visMesh.surfaceTriangles:
            pts = vtk.vtkIdList()
            for pi in surfaceTriangle.pointIndices:
                pts.InsertNextId(pi)
            # each triangle is a cell
            vtkgrid.InsertNextCell(triangleType, pts)

    vtkgrid.BuildLinks()
    return vtkgrid
コード例 #7
0
ファイル: ImportAtlas.py プロジェクト: netstim/SlicerNetstim
    def getPolyData(self, faces, vertices):
        points = vtk.vtkPoints()
        for v in vertices:
            points.InsertNextPoint(*v)
        triangles = vtk.vtkCellArray()

        for f in faces:
            triangle = vtk.vtkTriangle()
            for j in range(3):
                triangle.GetPointIds().SetId(j,
                                             int(f[j]) -
                                             1)  # fix 1based matlab index
            triangles.InsertNextCell(triangle)

        pd = vtk.vtkPolyData()
        pd.SetPoints(points)
        pd.SetPolys(triangles)

        # Compute surface normals for better appearance
        normals = vtk.vtkPolyDataNormals()
        normals.SetInputData(pd)
        normals.ConsistencyOn()
        normals.AutoOrientNormalsOn()
        normals.Update()

        return normals.GetOutput()
コード例 #8
0
def make_poly_data(points, faces, color):
    vtk_points = vtk.vtkPoints()
    vtk_faces = vtk.vtkCellArray()
    colors = vtk.vtkUnsignedCharArray()
    colors.SetNumberOfComponents(3)
    colors.SetName('colors')

    for i, p in enumerate(points):
        vtk_points.InsertNextPoint(p)
        colors.InsertNextTypedTuple(color)

    for i, f in enumerate(faces):
        triangle = vtk.vtkTriangle()
        triangle.GetPointIds().SetId(0, f[0])
        triangle.GetPointIds().SetId(1, f[1])
        triangle.GetPointIds().SetId(2, f[2])

        vtk_faces.InsertNextCell(triangle)

    poly_data = vtk.vtkPolyData()
    poly_data.SetPoints(vtk_points)
    poly_data.SetPolys(vtk_faces)

    poly_data.GetPointData().SetScalars(colors)
    poly_data.Modified()

    return poly_data
コード例 #9
0
ファイル: mytools.py プロジェクト: cbutakoff/tools
def CreatePolyData( pts, faces ):
    """
    Creates vtkPolyData from vertices and faces
    
    pts numpy.array: Nx3 array of vertices
    faces numpy.array: Mx3 array of faces

    Return vtkPolyData
    """
    (nv,mv) = pts.shape
    (nf,mf) = faces.shape
    cells = vtk.vtkCellArray()
    for j in range(nf):
        cell = vtk.vtkTriangle()
        cell.GetPointIds().SetNumberOfIds(3)
        cell.GetPointIds().SetId( 0, faces[j,0] )
        cell.GetPointIds().SetId( 1, faces[j,1] )
        cell.GetPointIds().SetId( 2, faces[j,2] )
        cells.InsertNextCell( cell )
    
    
    points = vtk.vtkPoints()
    points.SetNumberOfPoints(nv)
    for j in range(nv):
        points.SetPoint( j, pts[j,0], pts[j,1], pts[j,2] )
        
    new_mesh = vtk.vtkPolyData()
    new_mesh.SetPoints( points )
    new_mesh.SetPolys( cells )
    new_mesh.BuildCells()	
    
    return new_mesh
コード例 #10
0
ファイル: Clustering.py プロジェクト: akaszynski/PyACVD
def Gen_uGrid(new_pt, new_fc):
    """ Generates a vtk unstructured grid given points and triangular faces"""    
    ints = np.ones(len(new_fc), 'int')*3
    cells = np.hstack((ints.reshape(-1, 1), np.vstack(new_fc)))
              
    # Generate vtk mesh
    
    # Convert points to vtkfloat object
    points = np.vstack(new_pt)
    vtkArray = VN.numpy_to_vtk(np.ascontiguousarray(points), deep=True)#, deep=True) 
    points = vtk.vtkPoints()
    points.SetData(vtkArray) 
                
    # Convert to vtk arrays
    tritype = vtk.vtkTriangle().GetCellType()*np.ones(len(new_fc), 'int')
    cell_type = np.ascontiguousarray(tritype).astype('uint8')
    cell_type = VN.numpy_to_vtk(cell_type, deep=True)
    
    offset = np.cumsum(np.hstack(ints + 1))
    offset = np.ascontiguousarray(np.delete(np.insert(offset, 0, 0), -1)).astype('int64')  # shift
    offset = VN.numpy_to_vtkIdTypeArray(offset, deep=True)
    
    cells = np.ascontiguousarray(np.hstack(cells).astype('int64'))
    vtkcells = vtk.vtkCellArray()
    vtkcells.SetCells(cells.shape[0], VN.numpy_to_vtkIdTypeArray(cells, deep=True))
    
    
    # Create unstructured grid
    uGrid = vtk.vtkUnstructuredGrid()
    uGrid.SetPoints(points)
    uGrid.SetCells(cell_type, offset, vtkcells)
    
    return uGrid
コード例 #11
0
ファイル: tecplot_io.py プロジェクト: dsegroup22/pyNastran
 def _create_tecplot_shells(self, is_quads, quads, is_tris, tris):
     if is_quads:
         elements = quads
         for iface, face in enumerate(quads):
             elem = vtkQuad()
             epoints = elem.GetPointIds()
             epoints.SetId(0, face[0])
             epoints.SetId(1, face[1])
             epoints.SetId(2, face[2])
             epoints.SetId(3, face[3])
             self.grid.InsertNextCell(
                 elem.GetCellType(),
                 elem.GetPointIds())  #elem.GetCellType() = 5  # vtkTriangle
             #break
     if is_tris:
         elements = tris
         for iface, face in enumerate(tris):
             elem = vtkTriangle()
             epoints = elem.GetPointIds()
             epoints.SetId(0, face[0])
             epoints.SetId(1, face[1])
             epoints.SetId(2, face[2])
             self.grid.InsertNextCell(
                 5,
                 elem.GetPointIds())  #elem.GetCellType() = 5  # vtkTriangle
コード例 #12
0
ファイル: myvtk.py プロジェクト: aewallin/libcutsim
    def __init__(self, filename=None, triangleList=[], color=(1,1,1) ):
        self.src=[]

        points = vtk.vtkPoints()
        triangles = vtk.vtkCellArray()
        n=0
        for t in triangleList:
            triangle = vtk.vtkTriangle()
            for p in t:
                points.InsertNextPoint(p.x, p.y, p.z)
            triangle.GetPointIds().SetId(0,n)
            n=n+1
            triangle.GetPointIds().SetId(1,n)
            n=n+1
            triangle.GetPointIds().SetId(2,n)
            n=n+1
            triangles.InsertNextCell(triangle)
        polydata= vtk.vtkPolyData()
        polydata.SetPoints(points)
        polydata.SetPolys(triangles)
        polydata.Modified()
        polydata.Update()
        self.src=polydata
        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInput(self.src)
        self.SetMapper(self.mapper)
            


        self.SetColor(color)
コード例 #13
0
def createPolyData(faces, vtList, verts, tcoords):

    points = vtk.vtkPoints()
    points.SetDataTypeToDouble()
    points.SetNumberOfPoints(len(vtList))

    tcoordArray = vtk.vtkDoubleArray()
    tcoordArray.SetName('tcoords')
    tcoordArray.SetNumberOfComponents(2)
    tcoordArray.SetNumberOfTuples(len(vtList))

    for i, vt in enumerate(vtList):
        vi, ti = vt
        xyz = verts[vi]
        uv = tcoords[ti]

        points.SetPoint(i, xyz)
        tcoordArray.SetTuple2(i, uv[0], uv[1])

    cells = vtk.vtkCellArray()

    for i, face in enumerate(faces):
        tri = vtk.vtkTriangle()
        tri.GetPointIds().SetId(0, face[0])
        tri.GetPointIds().SetId(1, face[1])
        tri.GetPointIds().SetId(2, face[2])
        cells.InsertNextCell(tri)

    polyData = vtk.vtkPolyData()
    polyData.SetPoints(points)
    polyData.SetPolys(cells)
    polyData.GetPointData().SetTCoords(tcoordArray)
    return polyData
コード例 #14
0
ファイル: vtk_output.py プロジェクト: tbetcke/PyPWDG
 def create_cell(elem):
     triangle = vtk.vtkTriangle()
     ids = triangle.GetPointIds()
     ids.SetId(0, elem[0])
     ids.SetId(1, elem[1])
     ids.SetId(2, elem[2])
     return triangle
コード例 #15
0
ファイル: converters.py プロジェクト: mmolero/pcloudpy
def get_polydata_from(points, tr_re):

    numberPoints = len(points)
    Points = vtkPoints()
    ntype = get_numpy_array_type(Points.GetDataType())
    points_vtk = numpy_to_vtk(np.asarray(points, order='C',dtype=ntype), deep=1)
    Points.SetNumberOfPoints(numberPoints)
    Points.SetData(points_vtk)

    Triangles = vtkCellArray()
    for item in tr_re:
        Triangle = vtkTriangle()
        Triangle.GetPointIds().SetId(0,item[0])
        Triangle.GetPointIds().SetId(1,item[1])
        Triangle.GetPointIds().SetId(2,item[2])
        Triangles.InsertNextCell(Triangle)

    polydata = vtkPolyData()
    polydata.SetPoints(Points)
    polydata.SetPolys(Triangles)

    polydata.Modified()
    polydata.Update()

    return polydata
コード例 #16
0
ファイル: groups.py プロジェクト: ClaesFredo/pyNastran
    def _create_cart3d_group(self, name, model, element_id):
        points = vtk.vtkPoints()
        points.SetNumberOfPoints(self.nNodes)
        nelements = len(element_id)
        self.grid.Allocate(nelements, 1000)

        nodes = self.model.get_nodes_associated_with_elements(element_id)
        nodes.sort()

        nid = 0
        all_nodes = self.nodes
        for i in all_nodes:
            #if nid in nodes:
            points.InsertPoint(nid, all_nodes[i, :])
            nid += 1

        from vtk import vtkTriangle
        for eid in element_id:
            elem = vtkTriangle()
            node_ids = elements[eid, :]
            elem_nodes = searchsorted(nodes, node_ids)
            elem.GetPointIds().SetId(0, elem_nodes[0])
            elem.GetPointIds().SetId(1, elem_nodes[1])
            elem.GetPointIds().SetId(2, elem_nodes[2])
            self.grid.InsertNextCell(5, elem.GetPointIds())

        self.grid[name].SetPoints(points)
        self.grid[name].Modified()
        self.grid[name].Update()
コード例 #17
0
def createPolyData(faces, vtList, verts, tcoords):

    points = vtk.vtkPoints()
    points.SetDataTypeToDouble()
    points.SetNumberOfPoints(len(vtList))

    tcoordArray = vtk.vtkDoubleArray()
    tcoordArray.SetName('tcoords')
    tcoordArray.SetNumberOfComponents(2)
    tcoordArray.SetNumberOfTuples(len(vtList))

    for i, vt in enumerate(vtList):
        vi, ti = vt
        xyz = verts[vi]
        uv = tcoords[ti]

        points.SetPoint(i, xyz)
        tcoordArray.SetTuple2(i, uv[0], uv[1])

    cells = vtk.vtkCellArray()

    for i, face in enumerate(faces):
        tri = vtk.vtkTriangle()
        tri.GetPointIds().SetId(0, face[0])
        tri.GetPointIds().SetId(1, face[1])
        tri.GetPointIds().SetId(2, face[2])
        cells.InsertNextCell(tri)

    polyData = vtk.vtkPolyData()
    polyData.SetPoints(points)
    polyData.SetPolys(cells)
    polyData.GetPointData().SetTCoords(tcoordArray)
    return polyData
コード例 #18
0
def main():
    filenames = list()
    uGrids = list()

    uGrids.append(MakeUnstructuredGrid(vtk.vtkVertex()))
    filenames.append('Vertex.vtu')

    uGrids.append(MakePolyVertex())
    filenames.append('PolyVertex.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkLine()))
    filenames.append('Line.vtu')

    uGrids.append(MakePolyLine())
    filenames.append('PolyLine.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkTriangle()))
    filenames.append('Triangle.vtu')

    uGrids.append(MakeTriangleStrip())
    filenames.append('TriangleStrip.vtu')

    uGrids.append(MakePolygon())
    filenames.append('Polygon.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkPixel()))
    filenames.append('Pixel.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkQuad()))
    filenames.append('Quad.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkTetra()))
    filenames.append('Tetra.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkVoxel()))
    filenames.append('Voxel.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkHexahedron()))
    filenames.append('Hexahedron.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkWedge()))
    filenames.append('Wedge.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkPyramid()))
    filenames.append('Pyramid.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkPentagonalPrism()))
    filenames.append('PentagonalPrism.vtu')

    uGrids.append(MakeUnstructuredGrid(vtk.vtkHexagonalPrism()))
    filenames.append('HexagonalPrism.vtu')

    # Write each grid into  a file
    for i in range(0, len(uGrids)):
        print('Writing: ', filenames[i])
        writer = vtk.vtkXMLDataSetWriter()
        writer.SetFileName(filenames[i])
        writer.SetInputData(uGrids[i])
        writer.Write()
コード例 #19
0
ファイル: tool_actions.py プロジェクト: als0052/pyNastran
def add_user_geometry(alt_grid: vtk.vtkUnstructuredGrid,
                      geom_grid: vtk.vtkUnstructuredGrid, xyz: np.ndarray,
                      nid_map: Dict[int, int], nnodes: int, bars: np.ndarray,
                      tris: np.ndarray, quads: np.ndarray, nelements: int,
                      nbars: int, ntris: int, nquads: int) -> vtk.vtkPoints:
    """helper method for ``_add_user_geometry``"""
    # set points
    points = numpy_to_vtk_points(xyz, dtype='<f')

    if nelements > 0:
        for i in range(nnodes):
            elem = vtk.vtkVertex()
            elem.GetPointIds().SetId(0, i)
            alt_grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds())
            geom_grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds())
    else:
        for i in range(nnodes):
            elem = vtk.vtkVertex()
            elem.GetPointIds().SetId(0, i)
            alt_grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds())

    if nbars:
        for i, bar in enumerate(bars[:, 1:]):
            g1 = nid_map[bar[0]]
            g2 = nid_map[bar[1]]
            elem = vtk.vtkLine()
            elem.GetPointIds().SetId(0, g1)
            elem.GetPointIds().SetId(1, g2)
            geom_grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds())

    if ntris:
        for i, tri in enumerate(tris[:, 1:]):
            g1 = nid_map[tri[0]]
            g2 = nid_map[tri[1]]
            g3 = nid_map[tri[2]]
            elem = vtk.vtkTriangle()
            elem.GetPointIds().SetId(0, g1)
            elem.GetPointIds().SetId(1, g2)
            elem.GetPointIds().SetId(2, g3)
            geom_grid.InsertNextCell(5, elem.GetPointIds())

    if nquads:
        for i, quad in enumerate(quads[:, 1:]):
            g1 = nid_map[quad[0]]
            g2 = nid_map[quad[1]]
            g3 = nid_map[quad[2]]
            g4 = nid_map[quad[3]]
            elem = vtk.vtkQuad()
            point_ids = elem.GetPointIds()
            point_ids.SetId(0, g1)
            point_ids.SetId(1, g2)
            point_ids.SetId(2, g3)
            point_ids.SetId(3, g4)
            geom_grid.InsertNextCell(9, elem.GetPointIds())

    alt_grid.SetPoints(points)
    if nelements > 0:
        geom_grid.SetPoints(points)
    return points
コード例 #20
0
def main():
    filenames = list()
    uGrids = list()

    uGrids.append(MakeUnstructuredGrid(vtk.vtkVertex()))
    filenames.append("Vertex.vtk")

    uGrids.append(MakePolyVertex())
    filenames.append("PolyVertex.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkLine()))
    filenames.append("Line.vtk")

    uGrids.append(MakePolyLine())
    filenames.append("PolyLine.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkTriangle()))
    filenames.append("Triangle.vtk")

    uGrids.append(MakeTriangleStrip())
    filenames.append("TriangleStrip.vtk")

    uGrids.append(MakePolygon())
    filenames.append("Polygon.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkPixel()))
    filenames.append("Pixel.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkQuad()))
    filenames.append("Quad.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkTetra()))
    filenames.append("Tetra.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkVoxel()))
    filenames.append("Voxel.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkHexahedron()))
    filenames.append("Hexahedron.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkWedge()))
    filenames.append("Wedge.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkPyramid()))
    filenames.append("Pyramid.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkPentagonalPrism()))
    filenames.append("PentagonalPrism.vtk")

    uGrids.append(MakeUnstructuredGrid(vtk.vtkHexagonalPrism()))
    filenames.append("HexagonalPrism.vtk")

    # Write each grid into  a file
    for i in range(0, len(uGrids)):
        print("Writing: ", filenames[i])
        writer = vtk.vtkUnstructuredGridWriter()
        writer.SetFileName(filenames[i])
        writer.SetInputData(uGrids[i])
        writer.Write()
コード例 #21
0
    def save_frame_depth(self, path):

        #setup camera
        camera = vtkCamera()
        camera.SetPosition(self.cx, self.cy, self.cz)
        camera.SetFocalPoint(self.fx, self.fy, self.fz)
        camera.SetViewUp(self.ux, self.uy, self.uz)
        camera.SetViewAngle(self.fovy)
        #setup renderer
        renderer = vtkRenderer()
        renderWindow = vtkRenderWindow()
        renderWindow.SetOffScreenRendering(1)
        renderWindow.AddRenderer(renderer)
        renderWindow.SetSize(self.w, self.h)
        for i in xrange(-1, self.expert.nr_obstacles_c()):
            vss, nss, iss = self.save_frame_mesh(i)
            #geometry
            pts = vtkPoints()
            for i in xrange(len(vss)):
                pts.InsertNextPoint(vss[i][0], vss[i][1], vss[i][2])
                tris = vtkCellArray()
            for i in xrange(len(iss)):
                triangle = vtkTriangle()
                triangle.GetPointIds().SetId(0, iss[i][0])
                triangle.GetPointIds().SetId(1, iss[i][1])
                triangle.GetPointIds().SetId(2, iss[i][2])
                tris.InsertNextCell(triangle)
            poly = vtkPolyData()
            poly.SetPoints(pts)
            poly.SetPolys(tris)
            #actor
            mapper = vtkPolyDataMapper()
            mapper.SetInput(poly)
            actor = vtkActor()
            actor.SetMapper(mapper)
            renderer.AddActor(actor)
        renderer.SetBackground(self.bk_r, self.bk_g, self.bk_b)
        renderer.SetActiveCamera(camera)
        renderWindow.Render()
        #output options
        windowToImageFilter = vtkWindowToImageFilter()
        windowToImageFilter.SetInput(renderWindow)
        windowToImageFilter.SetMagnification(1)
        windowToImageFilter.SetInputBufferTypeToZBuffer()
        #Extract z buffer value
        windowToImageFilter.Update()
        #scale and shift
        scale = vtkImageShiftScale()
        scale.SetOutputScalarTypeToUnsignedChar()
        scale.SetInputConnection(windowToImageFilter.GetOutputPort())
        scale.SetShift(0)
        scale.SetScale(-255)
        #output
        writer = vtkBMPWriter()
        writer.SetFileName(path)
        writer.SetInputConnection(scale.GetOutputPort())
        writer.Write()
コード例 #22
0
ファイル: to_vtk.py プロジェクト: selaux/master-of-bones
def create_single_legend_actor(color, line_style):
    points = vtk.vtkPoints()
    raw_points = [
         [0, 0],
         [1, 0],
         [0, 0.25],
         [1, 0.25],
         [0, 0.5],
         [1, 0.5],
         [0, 0.75],
         [1, 0.75],
         [0, 1],
         [1, 1],
         [0.5, 1],
         [0.5, 0]
    ]
    for point in raw_points:
        points.InsertNextPoint([ point[1], point[0], 1.0 ])

    p1 = [
        [0, 2, 3],
        [0, 3, 1]
    ]
    p2 = [
        [2, 4, 5],
        [2, 5, 3]
    ]
    p3 = [
        [4, 6, 7],
        [4, 7, 5]
    ]
    p4 = [
        [6, 8, 9],
        [6, 9, 7]
    ]
    triangles_raw = [
        [0, 10, 11],
        [0, 9, 10]
    ]
    triangles_raw += p1 + p2 + p3 + p4
    if line_style == 0xF0F0:
        triangles_raw = p1 + p3
    elif line_style == 0xFF00:
        triangles_raw = p1 + p2
    elif line_style == 0x000F:
        triangles_raw = p4
    triangles = vtk.vtkCellArray()
    for t in triangles_raw:
        triangle = vtk.vtkTriangle()
        triangle.GetPointIds().SetId(0, t[0])
        triangle.GetPointIds().SetId(1, t[1])
        triangle.GetPointIds().SetId(2, t[2])
        triangles.InsertNextCell(triangle)
    polydata = vtk.vtkPolyData()
    polydata.SetPoints(points)
    polydata.SetPolys(triangles)
    return polydata
コード例 #23
0
ファイル: structure_vtk.py プロジェクト: wxrui2013/pymatgen
    def add_triangle(self, neighbors, color, center=None, opacity=0.4,
                     draw_edges=False, edges_color=[0.0, 0.0, 0.0],
                     edges_linewidth=2):
        """
        Adds a triangular surface between three atoms.

        Args:
            atoms: Atoms between which a triangle will be drawn.
            color: Color for triangle as RGB.
            center: The "central atom" of the triangle
            opacity: opacity of the triangle
            draw_edges: If set to True, the a line will be  drawn at each edge
            edges_color: Color of the line for the edges
            edges_linewidth: Width of the line drawn for the edges
        """
        points = vtk.vtkPoints()
        triangle = vtk.vtkTriangle()
        for ii in range(3):
            points.InsertNextPoint(neighbors[ii].x, neighbors[ii].y,
                                   neighbors[ii].z)
            triangle.GetPointIds().SetId(ii, ii)
        triangles = vtk.vtkCellArray()
        triangles.InsertNextCell(triangle)

        # polydata object
        trianglePolyData = vtk.vtkPolyData()
        trianglePolyData.SetPoints(points)
        trianglePolyData.SetPolys(triangles)

        # mapper
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInput(trianglePolyData)

        ac = vtk.vtkActor()
        ac.SetMapper(mapper)
        ac.GetProperty().SetOpacity(opacity)
        if color == 'element':
            if center is None:
                raise ValueError(
                    'Color should be chosen according to the central atom, '
                    'and central atom is not provided')
            # If partial occupations are involved, the color of the specie with
            # the highest occupation is used
            myoccu = 0.0
            for specie, occu in center.species.items():
                if occu > myoccu:
                    myspecie = specie
                    myoccu = occu
            color = [i / 255 for i in self.el_color_mapping[myspecie.symbol]]
            ac.GetProperty().SetColor(color)
        else:
            ac.GetProperty().SetColor(color)
        if draw_edges:
            ac.GetProperty().SetEdgeColor(edges_color)
            ac.GetProperty().SetLineWidth(edges_linewidth)
            ac.GetProperty().EdgeVisibilityOn()
        self.ren.AddActor(ac)
コード例 #24
0
ファイル: structure_vtk.py プロジェクト: AtlasL/pymatgen
    def add_triangle(self, neighbors, color, center=None, opacity=0.4,
                     draw_edges=False, edges_color=[0.0, 0.0, 0.0],
                     edges_linewidth=2):
        """
        Adds a triangular surface between three atoms.

        Args:
            atoms: Atoms between which a triangle will be drawn.
            color: Color for triangle as RGB.
            center: The "central atom" of the triangle
            opacity: opacity of the triangle
            draw_edges: If set to True, the a line will be  drawn at each edge
            edges_color: Color of the line for the edges
            edges_linewidth: Width of the line drawn for the edges
        """
        points = vtk.vtkPoints()
        triangle = vtk.vtkTriangle()
        for ii in range(3):
            points.InsertNextPoint(neighbors[ii].x, neighbors[ii].y,
                                   neighbors[ii].z)
            triangle.GetPointIds().SetId(ii, ii)
        triangles = vtk.vtkCellArray()
        triangles.InsertNextCell(triangle)

        # polydata object
        trianglePolyData = vtk.vtkPolyData()
        trianglePolyData.SetPoints( points )
        trianglePolyData.SetPolys( triangles )

        # mapper
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInput(trianglePolyData)

        ac = vtk.vtkActor()
        ac.SetMapper(mapper)
        ac.GetProperty().SetOpacity(opacity)
        if color == 'element':
            if center is None:
                raise ValueError(
                    'Color should be chosen according to the central atom, '
                    'and central atom is not provided')
            # If partial occupations are involved, the color of the specie with
            # the highest occupation is used
            myoccu = 0.0
            for specie, occu in center.species_and_occu.items():
                if occu > myoccu:
                    myspecie = specie
                    myoccu = occu
            color = [i / 255 for i in self.el_color_mapping[myspecie.symbol]]
            ac.GetProperty().SetColor(color)
        else:
            ac.GetProperty().SetColor(color)
        if draw_edges:
            ac.GetProperty().SetEdgeColor(edges_color)
            ac.GetProperty().SetLineWidth(edges_linewidth)
            ac.GetProperty().EdgeVisibilityOn()
        self.ren.AddActor(ac)
コード例 #25
0
def meshToUnstructeredGrid(mesh):
	
	"""Converts a FiPy mesh structure to a vtkUnstructuredGrid.
	
	Works for 2D and 3D meshes.
	
	Args:
		mesh (fipy.GmshImporter3D): Some Fipy mesh object.
		
	Returns:
		vtk.vtkUnstructuredGrid	
	"""
	
	
	# Get vertex coordinates
	coords=mesh.vertexCoords
	
	if len(coords)==2:
		x,y=coords
		dim=2
	else:
		x,y,z=coords
		dim=3
		
	# Insert them as points
	points = vtk.vtkPoints()
	for i in range(len(x)):
		if dim==2:
			points.InsertNextPoint(x[i], y[i],0)
		else:	
			points.InsertNextPoint(x[i], y[i],z[i])

	# Insert tetrahedrons
	verts=mesh._getOrderedCellVertexIDs().T
		
	cellArray = vtk.vtkCellArray()
	for j,vert in enumerate(verts):
		
		if dim==3:
			tetra = vtk.vtkTetra()
		else:
			tetra = vtk.vtkTriangle()
			
		for i,v in enumerate(vert):
			tetra.GetPointIds().SetId(i, v)
		cellArray.InsertNextCell(tetra)

	# Grid
	grid = vtk.vtkUnstructuredGrid()
	grid.SetPoints(points)
	
	if dim==3:
		grid.SetCells(vtk.VTK_TETRA, cellArray)
	else:
		grid.SetCells(vtk.VTK_TRIANGLE, cellArray)
	
	return grid
コード例 #26
0
    def __init__(self):
        super(Tria3, self).__init__()

        self.vtk_cell = vtk.vtkTriangle()
        self.point_ids = self.vtk_cell.GetPointIds()
        self.nodes = None
        self.center = None
        self.order = None
        self.id = None
コード例 #27
0
ファイル: utils.py プロジェクト: luisqcosta/spycer
def createPlaneActor2():
    xsize = params.PlaneXSize
    ysize = params.PlaneYSize
    center = params.PlaneCenter

    points = vtk.vtkPoints()
    points.InsertNextPoint(
        (center[0] - xsize / 2, center[1] - ysize / 2, center[2] - 0.1))
    points.InsertNextPoint(
        (center[0] + xsize / 2, center[1] - ysize / 2, center[2] - 0.1))
    points.InsertNextPoint(
        (center[0] + xsize / 2, center[1] + ysize / 2, center[2] - 0.1))
    points.InsertNextPoint(
        (center[0] - xsize / 2, center[1] + ysize / 2, center[2] - 0.1))

    triangle = vtk.vtkTriangle()
    triangle.GetPointIds().SetId(0, 0)
    triangle.GetPointIds().SetId(1, 1)
    triangle.GetPointIds().SetId(2, 2)

    triangle2 = vtk.vtkTriangle()
    triangle2.GetPointIds().SetId(0, 2)
    triangle2.GetPointIds().SetId(1, 3)
    triangle2.GetPointIds().SetId(2, 0)

    triangles = vtk.vtkCellArray()
    triangles.InsertNextCell(triangle)
    triangles.InsertNextCell(triangle2)

    colors = vtk.vtkUnsignedCharArray()
    colors.SetNumberOfComponents(3)
    colors.SetName("Colors")
    colors.InsertNextTuple3(255, 0, 0)
    colors.InsertNextTuple3(0, 255, 0)
    colors.InsertNextTuple3(0, 0, 255)
    colors.InsertNextTuple3(0, 255, 0)

    trianglePolyData = vtk.vtkPolyData()
    trianglePolyData.SetPoints(points)
    trianglePolyData.SetPolys(triangles)
    trianglePolyData.GetPointData().SetScalars(colors)

    return build_actor(trianglePolyData, True)
コード例 #28
0
ファイル: VtkAdapter.py プロジェクト: Refreezer/vis2
 def AddTriangle(p1, p2, p3):
     Draw.vtkpoints.InsertNextPoint(*p1)
     Draw.vtkpoints.InsertNextPoint(*p2)
     Draw.vtkpoints.InsertNextPoint(*p3)
     Draw.top += 3
     triangle = vtk.vtkTriangle()
     triangle.GetPointIds().SetId(0, Draw.top - 1)
     triangle.GetPointIds().SetId(1, Draw.top - 2)
     triangle.GetPointIds().SetId(2, Draw.top - 3)
     Draw.vtktriangles.InsertNextCell(triangle)
コード例 #29
0
def meshToUnstructeredGrid(mesh):
    """Converts a FiPy mesh structure to a vtkUnstructuredGrid.
	
	Works for 2D and 3D meshes.
	
	Args:
		mesh (fipy.GmshImporter3D): Some Fipy mesh object.
		
	Returns:
		vtk.vtkUnstructuredGrid	
	"""

    # Get vertex coordinates
    coords = mesh.vertexCoords

    if len(coords) == 2:
        x, y = coords
        dim = 2
    else:
        x, y, z = coords
        dim = 3

    # Insert them as points
    points = vtk.vtkPoints()
    for i in range(len(x)):
        if dim == 2:
            points.InsertNextPoint(x[i], y[i], 0)
        else:
            points.InsertNextPoint(x[i], y[i], z[i])

    # Insert tetrahedrons
    verts = mesh._getOrderedCellVertexIDs().T

    cellArray = vtk.vtkCellArray()
    for j, vert in enumerate(verts):

        if dim == 3:
            tetra = vtk.vtkTetra()
        else:
            tetra = vtk.vtkTriangle()

        for i, v in enumerate(vert):
            tetra.GetPointIds().SetId(i, v)
        cellArray.InsertNextCell(tetra)

    # Grid
    grid = vtk.vtkUnstructuredGrid()
    grid.SetPoints(points)

    if dim == 3:
        grid.SetCells(vtk.VTK_TETRA, cellArray)
    else:
        grid.SetCells(vtk.VTK_TRIANGLE, cellArray)

    return grid
コード例 #30
0
ファイル: mesh.py プロジェクト: joshalbrecht/shinyshell
def trim_mesh_with_cone(mesh, cone_point, cone_normal, cone_radius):
    """
    returns a mesh that contains only the triangles that where inside of the cone
    """
    cone_end = cone_point + cone_normal*100.0
    sq_radius = cone_radius*cone_radius
    w = cone_point
    v = cone_end
    n = w - v
    v_w_sq_len = dist2(v, w)
   
    points = mesh.GetPoints().GetData()
    cell_array = mesh.GetPolys()
    polygons = cell_array.GetData()
    triangles = vtk.vtkCellArray()
    for i in xrange(0,  cell_array.GetNumberOfCells()):
        triangle = [polygons.GetValue(j) for j in xrange(i*4+1, i*4+4)]
        
        p = points.GetTuple(triangle[0])
        delta = p - (v + (((p - v).dot(n)) / v_w_sq_len) * n)
        if delta.dot(delta) > sq_radius:
            continue
        
        p = points.GetTuple(triangle[1])
        delta = p - (v + (((p - v).dot(n)) / v_w_sq_len) * n)
        if delta.dot(delta) > sq_radius:
            continue
        
        p = points.GetTuple(triangle[2])
        delta = p - (v + (((p - v).dot(n)) / v_w_sq_len) * n)
        if delta.dot(delta) > sq_radius:
            continue
        
        cell = vtk.vtkTriangle()
        pointIds = cell.GetPointIds()
        pointIds.SetId(0, triangle[0])
        pointIds.SetId(1, triangle[1])
        pointIds.SetId(2, triangle[2])
        triangles.InsertNextCell(cell)
            
    # Create a polydata object
    trianglePolyData = vtk.vtkPolyData()

    # Add the geometry and topology to the polydata
    trianglePolyData.SetPoints(mesh.GetPoints())
    trianglePolyData.SetPolys(triangles)
    trianglePolyData.Update()
    
    #run the clean function here to remove the points that are not used
    cleanPolyData = vtk.vtkCleanPolyData()
    cleanPolyData.SetInput(trianglePolyData)
    cleanPolyData.Update()
    trimmed_mesh = cleanPolyData.GetOutput()

    return trimmed_mesh
コード例 #31
0
ファイル: vtk_tools.py プロジェクト: will214/fermi
def Vtk_cell_types():
    vtk_types = [
    ]  #(vtk_type, vtk_id, vtkCell) <= linear cell types found in VTK
    vtk_types.append(("VTK_TRIANGLE", 5, vtk.vtkTriangle()))
    vtk_types.append(("VTK_QUAD", 9, vtk.vtkQuad()))
    vtk_types.append(("VTK_TETRA", 10, vtk.vtkTetra()))
    vtk_types.append(("VTK_PYRAMID", 14, vtk.vtkPyramid()))
    vtk_types.append(("VTK_WEDGE", 13, vtk.vtkWedge()))
    vtk_types.append(("VTK_HEXAHEDRON", 12, vtk.vtkHexahedron()))

    return vtk_types
コード例 #32
0
 def defineMesh(self,nodes,elements):
     self._points    = vtk.vtkPoints()
     self._triangles = vtk.vtkCellArray()
     for i in range(len(nodes)):
         self._points.InsertNextPoint(nodes[i].x(),nodes[i].y(),0.)
     for el in elements:
         tri = vtk.vtkTriangle()
         conn = el.connectivite()
         for ii,n in enumerate(conn):
             tri.GetPointIds().SetId(ii,n)
         self._triangles.InsertNextCell(tri)
コード例 #33
0
ファイル: raybender.py プロジェクト: annaleida/raybender
def RenderTriangleAsPolygon(points, triangleNumber):
	print '* * * RenderTriangle: ', triangleNumber
	print 'Triangle points: ', tri
	p_triangles.InsertNextPoint(points[0])
	p_triangles.InsertNextPoint(points[1])
	p_triangles.InsertNextPoint(points[2])
	triangle = vtk.vtkTriangle();
	triangle.GetPointIds().SetId(0, 0+(triangleNumber-1)*3);
	triangle.GetPointIds().SetId(1, 1+(triangleNumber-1)*3);
	triangle.GetPointIds().SetId(2, 2+(triangleNumber-1)*3);
	triangles.InsertNextCell(triangle);
コード例 #34
0
 def defineMesh(self, nodes, elements):
     self._points = vtk.vtkPoints()
     self._triangles = vtk.vtkCellArray()
     for i in range(len(nodes)):
         self._points.InsertNextPoint(nodes[i].x(), nodes[i].y(), 0.)
     for el in elements:
         tri = vtk.vtkTriangle()
         conn = el.connectivite()
         for ii, n in enumerate(conn):
             tri.GetPointIds().SetId(ii, n)
         self._triangles.InsertNextCell(tri)
コード例 #35
0
    def create_surface_triangles(self, simpleces):

        Triangles = vtk.vtkCellArray()
        Triangle = vtk.vtkTriangle()

        for s in simpleces:
            Triangle.GetPointIds().SetId(0, s[0])
            Triangle.GetPointIds().SetId(1, s[1])
            Triangle.GetPointIds().SetId(2, s[2])

            Triangles.InsertNextCell(Triangle)
        return Triangles
コード例 #36
0
ファイル: mesh.py プロジェクト: joshalbrecht/shinyshell
def mesh_from_arcs(arcs):
    #create all of the points so they have sensible, shared indices
    points = vtk.vtkPoints()
    num_points_in_arc = len(arcs[0])
    for i in range(0, len(arcs)):
        arc = arcs[i]
        assert len(arc) == num_points_in_arc, "All arcs must be the same length"
        for j in range(0, len(arc)):
            point = arc[j]
            points.InsertNextPoint(point[0], point[1], point[2])
    
    # Build the meshgrid manually
    triangles = vtk.vtkCellArray()
    for i in range(1, len(arcs)):
        for j in range(0, len(arc)-1):
            
            triangle = vtk.vtkTriangle()
            pointIds = triangle.GetPointIds()
            pointIds.SetId(0, i * num_points_in_arc + j)
            pointIds.SetId(1, i * num_points_in_arc + j + 1)
            pointIds.SetId(2, (i-1) * num_points_in_arc + j + 1)
            triangles.InsertNextCell(triangle)

            triangle = vtk.vtkTriangle()
            pointIds = triangle.GetPointIds()
            pointIds.SetId(0, i * num_points_in_arc + j)
            pointIds.SetId(1, (i-1) * num_points_in_arc + j + 1)
            pointIds.SetId(2, (i-1) * num_points_in_arc + j)
            triangles.InsertNextCell(triangle)

    # Create a polydata object
    trianglePolyData = vtk.vtkPolyData()

    # Add the geometry and topology to the polydata
    trianglePolyData.SetPoints(points)
    trianglePolyData.SetPolys(triangles)
    trianglePolyData.Update()

    return trianglePolyData
コード例 #37
0
ファイル: mesh_reduction.py プロジェクト: funveen/MSc_theses
def to_vtk(vertices, simplices=None):
    '''
    Creates a VTK mesh (vtkPolyData object) from a given point set utilizing Delaunay triangulation in the first place.
    
    Arguments:
        vertices: pandas DataFrame of xyz coordinates
        simplices: pandas DataFrame of simplices from Delaunay triangulation, if None basic triangulation will be performed

    Returns:
        polydata: vtkPolyData object which serves as input for subsequent vtk simplification / decimation operations   
    '''

    if simplices is None:
        ## Delaunay
        # triangulation = Delaunay(vertices.iloc[:,:2].values)
        # simplices = triangulation.simplices
        simplices = triangulate(vertices)
    else:
        simplices = simplices

    ## VTK polygons

    # initiate points and read vertices
    points = vtkPoints()

    for p in vertices.values:
        points.InsertNextPoint(p)

    # initiate triangles and read simplices
    # Unfortunately in this simple example the following lines are ambiguous.
    # The first 0 is the index of the triangle vertex which is ALWAYS 0-2.
    # The second 0 is the index into the point (geometry) array, so this can range from 0-(NumPoints-1)
    # i.e. a more general statement is triangle->GetPointIds()->SetId(0, PointId);
    triangle = vtkTriangle()
    triangles = vtkCellArray()

    for i in simplices.values:
        triangle.GetPointIds().SetId(0, i[0])
        triangle.GetPointIds().SetId(1, i[1])
        triangle.GetPointIds().SetId(2, i[2])
        triangles.InsertNextCell(triangle)

    # combine in PolyData object
    polydata = vtkPolyData()
    polydata.SetPoints(points)
    polydata.SetPolys(triangles)

    # check
    polydata.Modified()

    return polydata
コード例 #38
0
ファイル: vtk_tools.py プロジェクト: mvdcvp/CPlantBox
def vtk_cells(t):
    """ Creates vtkCells from an numpy array """
    cellArray = vtk.vtkCellArray()
    for vert in t:
        if t.shape[1] == 2:
            tetra = vtk.vtkLine()
        if t.shape[1] == 3:
            tetra = vtk.vtkTriangle()
        elif t.shape[1] == 4:
            tetra = vtk.vtkTetra()
        for i, v in enumerate(vert):
            tetra.GetPointIds().SetId(i, int(v))
        cellArray.InsertNextCell(tetra)
    return cellArray
コード例 #39
0
ファイル: main.py プロジェクト: EJShim/Manifold
def CalculateManifold(polydata, resolution=1000):

    #Get Vertex and Face Array
    nPoints = polydata.GetNumberOfPoints()
    nFaces = polydata.GetNumberOfCells()

    v = []
    f = []

    for i in range(nPoints):
        v.append(polydata.GetPoint(i))

    for i in range(nFaces):
        cell = polydata.GetCell(i)

        cell.GetPointId(0)

        f.append([cell.GetPointId(0), cell.GetPointId(1), cell.GetPointId(2)])

    v = np.array(v)
    f = np.array(f)

    #Calculate
    calculated = lib.Calculate(v.ctypes.data_as(POINTER(c_double)), v.size,
                               f.ctypes.data_as(POINTER(c_int)), f.size,
                               c_int(resolution))

    vertices = np.array(calculated['vertices'])
    vertices = vertices.reshape(int(vertices.size / 3), 3)
    faces = np.array(calculated['faces'])
    faces = faces.reshape(int(faces.size / 3), 3)

    result = vtk.vtkPolyData()

    points = vtk.vtkPoints()
    points.SetNumberOfPoints(vertices.shape[0])
    for i in range(vertices.shape[0]):
        points.SetPoint(i, vertices[i])
    result.SetPoints(points)

    cells = vtk.vtkCellArray()
    for i in range(faces.shape[0]):
        cell = vtk.vtkTriangle()
        cell.GetPointIds().SetId(0, faces[i][0])
        cell.GetPointIds().SetId(1, faces[i][1])
        cell.GetPointIds().SetId(2, faces[i][2])
        cells.InsertNextCell(cell)
    result.SetPolys(cells)

    return result
コード例 #40
0
    def interpolate(self, x, y, z):
        aCell = vtk.vtkTriangle()
        pcoords = [0, 0, 0]
        weights = [0, 0, 0]

        cid = self.loc.FindCell((x, y, z))
        if cid > -1:
            aCell = self.pd2.GetCell(cid)
            pts = [(aCell.GetPoints().GetPoint(k)[0],
                    aCell.GetPoints().GetPoint(k)[1]) for k in range(3)]
            res = aCell.BarycentricCoords((x, y), pts[0], pts[1], pts[2],
                                          pcoords)
            v = [self.values[aCell.GetPointId(k)] for k in range(3)]
            return sum([pcoords[kk] * v[kk] for kk in range(3)])
コード例 #41
0
ファイル: reader.py プロジェクト: rcherbonnier/caps-clindmri
    def _polydata(self, inflated=False):
        """ Compute a vtk polydata of the TriSurface.
        This code uses vtk.

        Parameters
        ----------
        inflated: bool (optional, default False)
            If True use the inflated vertices.            

        Returns
        -------
        polydata: vtkPolyData
            the TriSurface vtk polydata.
        """
        import vtk

        # Select the vertices to use
        labels = copy.deepcopy(self.labels)
        if inflated:
            vertices = self.inflated_vertices
        else:
            vertices = self.vertices

        # First setup points, triangles and colors.
        vtk_points = vtk.vtkPoints()
        vtk_triangles = vtk.vtkCellArray()
        vtk_colors = vtk.vtkUnsignedCharArray()
        vtk_colors.SetNumberOfComponents(1)
        nb_of_labels = len(set(self.labels))
        labels[numpy.where(labels < 0)] = 0
        for index in range(len(vertices)):
            vtk_points.InsertNextPoint(vertices[index])
            vtk_colors.InsertNextTuple1(labels[index])
        for triangle in self.triangles:
            vtk_triangle = vtk.vtkTriangle()
            vtk_triangle.GetPointIds().SetId(0, triangle[0])
            vtk_triangle.GetPointIds().SetId(1, triangle[1])
            vtk_triangle.GetPointIds().SetId(2, triangle[2])
            vtk_triangles.InsertNextCell(vtk_triangle)

        # Create (geometry and topology) the associated polydata
        polydata = vtk.vtkPolyData()
        polydata.SetPoints(vtk_points)
        polydata.GetPointData().SetScalars(vtk_colors)
        polydata.SetPolys(vtk_triangles)

        return polydata

            
コード例 #42
0
    def GetVtkPoly(self, fid, fdata, n, bytesMirrored, type):

        geo = []
        pid = []

        fill, out, trans, multi = ReadFlags(fid, fdata)

        for i in range(0, n):
            geo.append(ReadFloats(fid, fdata, np.float32, 3, bytesMirrored))

        color, tr = ReadColorAndTrans(fid, fdata, fill, out, multi, trans, n,
                                      bytesMirrored)

        for i in range(0, n):
            pid.append(self.points.InsertNextPoint(geo[i]))
            if multi:
                t = [color[i][0]]
                self.temps.InsertNextTypedTuple(t)
                col = tuple(color[i])
                self.colors.InsertNextTypedTuple(col)

            else:
                t = [color[0][0]]
                self.temps.InsertNextTypedTuple(t)
                col = tuple(color[0])
                self.colors.InsertNextTypedTuple(col)

        if type == 'P':
            return pid[0]
        elif type == 'L':
            line = vtk.vtkLine()
            line.GetPointIds().SetId(0, pid[0])
            line.GetPointIds().SetId(1, pid[1])
            return line

        elif type == 'T':
            tri = vtk.vtkTriangle()
            tri.GetPointIds().SetId(0, pid[0])
            tri.GetPointIds().SetId(1, pid[1])
            tri.GetPointIds().SetId(2, pid[2])
            return tri

        elif type == 'Q':
            quad = vtk.vtkQuad()
            quad.GetPointIds().SetId(0, pid[0])
            quad.GetPointIds().SetId(1, pid[1])
            quad.GetPointIds().SetId(2, pid[2])
            quad.GetPointIds().SetId(3, pid[3])
            return quad
コード例 #43
0
def buildPolyData(vertices, faces=None, indexOffset=0):
    '''
    Build a ``vtkPolyData`` object from a list of vertices
    where faces represents the connectivity of the polygonal mesh.

    E.g. :
        - ``vertices=[[x1,y1,z1],[x2,y2,z2], ...]``
        - ``faces=[[0,1,2], [1,2,3], ...]``

    Use ``indexOffset=1`` if face numbering starts from 1 instead of 0.
    
    .. hint:: Example: `buildpolydata.py <https://github.com/marcomusy/vtkplotter/blob/master/examples/basic/buildpolydata.py>`_
    
        .. image:: https://user-images.githubusercontent.com/32848391/51032546-bf4dac00-15a0-11e9-9e1e-035fff9c05eb.png
    '''
    sourcePoints = vtk.vtkPoints()
    sourceVertices = vtk.vtkCellArray()
    sourcePolygons = vtk.vtkCellArray()
    for pt in vertices:
        if len(pt) > 2:
            aid = sourcePoints.InsertNextPoint(pt[0], pt[1], pt[2])
        else:
            aid = sourcePoints.InsertNextPoint(pt[0], pt[1], 0)
        sourceVertices.InsertNextCell(1)
        sourceVertices.InsertCellPoint(aid)
    if faces:
        for f in faces:
            n = len(f)
            if n == 4:
                plg = vtk.vtkTetra()
            elif n == 3:
                plg = vtk.vtkTriangle()
            else:
                plg = vtk.vtkPolygon()
                plg.GetPointIds().SetNumberOfIds(n)
            for i in range(n):
                plg.GetPointIds().SetId(i, f[i] - indexOffset)
            sourcePolygons.InsertNextCell(plg)

    poly = vtk.vtkPolyData()
    poly.SetPoints(sourcePoints)
    poly.SetVerts(sourceVertices)
    if faces:
        poly.SetPolys(sourcePolygons)
    clp = vtk.vtkCleanPolyData()
    clp.SetInputData(poly)
    clp.PointMergingOn()
    clp.Update()
    return clp.GetOutput()
コード例 #44
0
ファイル: mesh.py プロジェクト: groupeLIAMG/JHVIT
 def getVtkUnstructuredGrid(self):
     tPts = vtk.vtkPoints()
     ugrid = vtk.vtkUnstructuredGrid()
     tPts.SetNumberOfPoints(self.nodes.shape[0])
     for n in np.arange(self.nodes.shape[0]):
         tPts.InsertPoint(n, self.nodes[n, 0], self.nodes[n, 1],
                          self.nodes[n, 2])
     ugrid.SetPoints(tPts)
     tri = vtk.vtkTriangle()
     for n in np.arange(self.cells.shape[0]):
         tri.GetPointIds().SetId(0, self.cells[n, 0])
         tri.GetPointIds().SetId(1, self.cells[n, 1])
         tri.GetPointIds().SetId(2, self.cells[n, 2])
         ugrid.InsertNextCell(tri.GetCellType(), tri.GetPointIds())
     return ugrid
コード例 #45
0
ファイル: pyfrp_gui_vtk.py プロジェクト: mehdah/PyFRAP
    def initTriangles(self):
        """Sets up triangles describing mesh."""

        verts = self.embryo.simulation.mesh.mesh._getOrderedCellVertexIDs().T

        cellArray = vtk.vtkCellArray()
        for j, vert in enumerate(verts):

            tetra = vtk.vtkTriangle()

            for i, v in enumerate(vert):
                tetra.GetPointIds().SetId(i, v)
            cellArray.InsertNextCell(tetra)

        self.grid.SetCells(vtk.VTK_TRIANGLE, cellArray)
コード例 #46
0
    def buildFullVTKGrid(self):
        # Create the points for VTK
        points = vtk.vtkPoints()
        for i in range(0, len(self.mesh.coords) / 3):
            p = self.mesh.coords[(i * 3):(i * 3 + 3)]
            points.InsertNextPoint(p)

        #add the points and cells to unstructured grid
        vtkgrid = vtk.vtkUnstructuredGrid()
        vtkgrid.SetPoints(points)

        #add the VTK elements to the mesh
        for element in self.mesh.elements:
            type = element.getType()
            nodes = element.nodes
            cell = vtk.vtkTriangle()
            if type == eTypes.TRI:
                cell = vtk.vtkTriangle()
            elif type == eTypes.QUAD:
                cell = vtk.vtkQuad()
            elif type == eTypes.TET:
                cell = vtk.vtkTetra()
            elif type == eTypes.PYRAMID:
                cell = vtk.vtkPyramid()
            elif type == eTypes.PRISM:
                cell = vtk.vtkWedge()  #prism
            elif type == eTypes.HEX:
                cell = vtk.vtkHexahedron()
            else:
                raise  # throw an exception
            j = 0
            for n in nodes:
                cell.GetPointIds().SetId(j, n)
                j = j + 1
            vtkgrid.InsertNextCell(cell.GetCellType(), cell.GetPointIds())
        return vtkgrid
コード例 #47
0
def vtk_cells(t):
    """ creates vtkCells from an numpy array @param t, 
    currently vtkLine, vtkTriangle, andn vtkTetra are implemented"""
    cellArray = vtk.vtkCellArray()
    for vert in t:
        if t.shape[1] == 2:
            tetra = vtk.vtkLine()
        if t.shape[1] == 3:
            tetra = vtk.vtkTriangle()
        elif t.shape[1] == 4:
            tetra = vtk.vtkTetra()
        for i, v in enumerate(vert):
            tetra.GetPointIds().SetId(i, int(v))
        cellArray.InsertNextCell(tetra)
    return cellArray
コード例 #48
0
ファイル: guiData.py プロジェクト: zwghit/ProteusCFD
    def buildFullVTKGrid(self):
        # Create the points for VTK
        points = vtk.vtkPoints()
        for i in range(0, len(self.mesh.coords)/3):
            p = self.mesh.coords[(i*3):(i*3+3)]
            points.InsertNextPoint(p)

        #add the points and cells to unstructured grid
        vtkgrid = vtk.vtkUnstructuredGrid()
        vtkgrid.SetPoints(points)

        #add the VTK elements to the mesh
        for element in self.mesh.elements:
            type = element.getType()
            nodes = element.nodes
            cell = vtk.vtkTriangle()
            if type == eTypes.TRI:
                cell = vtk.vtkTriangle()
            elif type == eTypes.QUAD:
                cell = vtk.vtkQuad()
            elif type == eTypes.TET:
                cell = vtk.vtkTetra()
            elif type == eTypes.PYRAMID:
                cell = vtk.vtkPyramid()
            elif type == eTypes.PRISM:
                cell = vtk.vtkWedge()  #prism
            elif type == eTypes.HEX:
                cell = vtk.vtkHexahedron()
            else:
                raise # throw an exception
            j = 0
            for n in nodes:
                cell.GetPointIds().SetId(j,n)
                j = j+1
            vtkgrid.InsertNextCell(cell.GetCellType(), cell.GetPointIds())
        return vtkgrid
コード例 #49
0
ファイル: mesh.py プロジェクト: bernard-giroux/ttcr
    def getVtkUnstructuredGrid(self):
        tPts = vtk.vtkPoints()
        ugrid = vtk.vtkUnstructuredGrid()
        tPts.SetNumberOfPoints(self.nodes.shape[0])
        for n in np.arange(self.nodes.shape[0]):
            tPts.InsertPoint(n, self.nodes[n,0], self.nodes[n,1], self.nodes[n,2])
        ugrid.SetPoints(tPts)
        tri = vtk.vtkTriangle()
        for n in np.arange(self.cells.shape[0]):
            tri.GetPointIds().SetId(0, self.cells[n,0])
            tri.GetPointIds().SetId(1, self.cells[n,1])
            tri.GetPointIds().SetId(2, self.cells[n,2])
            ugrid.InsertNextCell( tri.GetCellType(), tri.GetPointIds() )

        return ugrid
コード例 #50
0
ファイル: surftools.py プロジェクト: dgoyard/pyfreesurfer
    def _polydata(self, inflated=False):
        """ Compute a vtk polydata of the TriSurface.

        This code uses vtk.

        Parameters
        ----------
        inflated: bool (optional, default False)
            If True use the inflated vertices.

        Returns
        -------
        polydata: vtkPolyData
            the TriSurface vtk polydata.
        """
        # Import here since vtk is not required by the package
        import vtk

        # Select the vertices to use
        labels = copy.deepcopy(self.labels)
        if inflated:
            vertices = self.inflated_vertices
        else:
            vertices = self.vertices

        # First setup points, triangles and colors.
        vtk_points = vtk.vtkPoints()
        vtk_triangles = vtk.vtkCellArray()
        vtk_colors = vtk.vtkUnsignedCharArray()
        vtk_colors.SetNumberOfComponents(1)
        labels[numpy.where(labels < 0)] = 0
        for index in range(len(vertices)):
            vtk_points.InsertNextPoint(vertices[index])
            vtk_colors.InsertNextTuple1(labels[index])
        for triangle in self.triangles:
            vtk_triangle = vtk.vtkTriangle()
            vtk_triangle.GetPointIds().SetId(0, triangle[0])
            vtk_triangle.GetPointIds().SetId(1, triangle[1])
            vtk_triangle.GetPointIds().SetId(2, triangle[2])
            vtk_triangles.InsertNextCell(vtk_triangle)

        # Create (geometry and topology) the associated polydata
        polydata = vtk.vtkPolyData()
        polydata.SetPoints(vtk_points)
        polydata.GetPointData().SetScalars(vtk_colors)
        polydata.SetPolys(vtk_triangles)

        return polydata
コード例 #51
0
ファイル: plot.py プロジェクト: SinghN/nutils
  def unstructuredgrid( self, points, npars=None ):
    """add unstructured grid"""

    points = _nansplit( points )
    #assert isinstance( points, (list,tuple,numpy.ndarray) ), 'Expected list of point arrays'

    import vtk

    vtkPoints = vtk.vtkPoints()
    vtkPoints.SetNumberOfPoints( sum(pts.shape[0] for pts in points) )

    cnt = 0
    for pts in points:

      np, ndims = pts.shape
      if not npars:
        npars = ndims

      vtkelem   = None

      if np == 2:
        vtkelem = vtk.vtkLine()
      elif np == 3:
        vtkelem = vtk.vtkTriangle()
      elif np == 4:  
        if npars == 2:
          vtkelem = vtk.vtkQuad()
        elif npars == 3:
          vtkelem = vtk.vtkTetra()
      elif np == 8:
        vtkelem = vtk.vtkVoxel() # TODO hexahedron for not rectilinear NOTE ordering changes!

      if not vtkelem:
        raise Exception( 'not sure what to do with cells with ndims=%d and npoints=%d' % (ndims,np) )

      if ndims < 3:
        pts = numpy.concatenate([pts,numpy.zeros(shape=(pts.shape[0],3-ndims))],axis=1)

      cellpoints = vtkelem.GetPointIds()

      for i,point in enumerate(pts):
        vtkPoints .SetPoint( cnt, point )
        cellpoints.SetId( i, cnt )
        cnt +=1
    
      self.vtkMesh.InsertNextCell( vtkelem.GetCellType(), cellpoints )

    self.vtkMesh.SetPoints( vtkPoints )
コード例 #52
0
ファイル: pyfrp_gui_vtk.py プロジェクト: alexblaessle/PyFRAP
	def initTriangles(self):
		
		"""Sets up triangles describing mesh."""
		
		verts=self.embryo.simulation.mesh.mesh._getOrderedCellVertexIDs().T
		
		cellArray = vtk.vtkCellArray()
		for j,vert in enumerate(verts):

			tetra = vtk.vtkTriangle()
			
			for i,v in enumerate(vert):
				tetra.GetPointIds().SetId(i, v)
			cellArray.InsertNextCell(tetra)
			
		self.grid.SetCells(vtk.VTK_TRIANGLE, cellArray)
コード例 #53
0
ファイル: vtk_helpers.py プロジェクト: orbingol/NURBS-Python
def create_actor_tri(pts, tris, color, **kwargs):
    """ Creates a VTK actor for rendering triangulated surface plots.

    :param pts: points
    :type pts: vtkFloatArray
    :param tris: list of triangle indices
    :type tris: ndarray
    :param color: actor color
    :type color: list
    :return: a VTK actor
    :rtype: vtkActor
    """
    # Keyword arguments
    array_name = kwargs.get('name', "")
    array_index = kwargs.get('index', 0)

    # Create points
    points = vtk.vtkPoints()
    points.SetData(pts)

    # Create triangles
    triangles = vtk.vtkCellArray()
    for tri in tris:
        tmp = vtk.vtkTriangle()
        for i, v in enumerate(tri):
            tmp.GetPointIds().SetId(i, v)
        triangles.InsertNextCell(tmp)

    # Create a PolyData object and add points & triangles
    polydata = vtk.vtkPolyData()
    polydata.SetPoints(points)
    polydata.SetPolys(triangles)

    # Map poly data to the graphics primitives
    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputDataObject(polydata)
    mapper.SetArrayName(array_name)
    mapper.SetArrayId(array_index)

    # Create an actor and set its properties
    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().SetColor(*color)

    # Return the actor
    return actor
コード例 #54
0
ファイル: guiData.py プロジェクト: zwghit/ProteusCFD
    def buildPartialVTKGrid(self, factag):
        #get points required for factag
        pointsList = self.getPointsWithFactag(factag)

        #create a lookup table so we can map the
        #cells from the global list to a local list
        points = vtk.vtkPoints()
        localIdx = 0
        ptMap = {}
        for pt in pointsList:
            ptMap[int(pt)] = localIdx
            localIdx = localIdx + 1
            p = self.mesh.coords[(pt*3):(pt*3+3)]
            points.InsertNextPoint(p)
        
        vtkgrid = vtk.vtkUnstructuredGrid()
        vtkgrid.SetPoints(points)

        #get elements that have desired factag
        felements = self.getElementsWithFactag(factag)

        #build the vtk elements
        for element in felements:
            type = element.getType()
            nodes = element.nodes
            if type == eTypes.TRI:
                cell = vtk.vtkTriangle()
            elif type == eTypes.QUAD:
                cell = vtk.vtkQuad()
            elif type == eTypes.TET:
                cell = vtk.vtkTetra()
            elif type == eTypes.PYRAMID:
                cell = vtk.vtkPyramid()
            elif type == eTypes.PRISM:
                cell = vtk.vtkWedge()  #prism
            elif type == eTypes.HEX:
                cell = vtk.vtkHexahedron()
            else:
                raise # throw an exception
            j = 0
            for n in nodes:
                localId = ptMap[int(n)]
                cell.GetPointIds().SetId(j,localId)
                j = j+1
            vtkgrid.InsertNextCell(cell.GetCellType(), cell.GetPointIds())
        return vtkgrid
コード例 #55
0
def as_triangles(indices, cellarray, level, data):
  if len(indices) >= 3:
    stride = len(indices)//4
    indices.append(indices[-1] + 1)

    triangle = vtk.vtkTriangle()
    triangle.GetPointIds().SetId(0, indices[ stride])
    triangle.GetPointIds().SetId(1, indices[2*stride])
    triangle.GetPointIds().SetId(2, indices[3*stride])

    cellarray.InsertNextCell(triangle)
    data.InsertNextValue(level)

    as_triangles(indices[       0:   stride], cellarray, level + 1, data)
    as_triangles(indices[  stride: 2*stride], cellarray, level + 1, data)
    as_triangles(indices[2*stride: 3*stride], cellarray, level + 1, data)
    as_triangles(indices[3*stride:       -1], cellarray, level + 1, data)
コード例 #56
0
ファイル: IO.py プロジェクト: jrper/ParticleModule
def get_linear_cell(cell):
    """ Get equivalent linear cell to vtkCell cell"""
    if cell.GetCellType() in (vtk.VTK_POLY_LINE,):
        linear_cell = vtk.vtkLine()
        linear_cell.GetPoints().SetPoint(0, cell.GetPoints().GetPoint(0))
        linear_cell.GetPoints().SetPoint(1, cell.GetPoints().GetPoint(1))
    elif cell.GetCellType() in (vtk.VTK_QUADRATIC_TRIANGLE,):
        linear_cell = vtk.vtkTriangle()
        linear_cell.GetPoints().SetPoint(0, cell.GetPoints().GetPoint(0))
        linear_cell.GetPoints().SetPoint(1, cell.GetPoints().GetPoint(1))
        linear_cell.GetPoints().SetPoint(2, cell.GetPoints().GetPoint(2))
    elif cell.GetCellType() in (vtk.VTK_QUADRATIC_TETRA,):
        linear_cell = vtk.vtkTetra()
        linear_cell.GetPoints().SetPoint(0, cell.GetPoints().GetPoint(0))
        linear_cell.GetPoints().SetPoint(1, cell.GetPoints().GetPoint(1))
        linear_cell.GetPoints().SetPoint(2, cell.GetPoints().GetPoint(2))
        linear_cell.GetPoints().SetPoint(3, cell.GetPoints().GetPoint(3))
    else:
        linear_cell = cell

    return linear_cell
コード例 #57
0
ファイル: tecplot_io.py プロジェクト: HibernantBear/pyNastran
 def _create_tecplot_shells(self, is_quads, quads, is_tris, tris):
     if is_quads:
         elements = quads
         for iface, face in enumerate(quads):
             elem = vtkQuad()
             epoints = elem.GetPointIds()
             epoints.SetId(0, face[0])
             epoints.SetId(1, face[1])
             epoints.SetId(2, face[2])
             epoints.SetId(3, face[3])
             self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds())  #elem.GetCellType() = 5  # vtkTriangle
             #break
     if is_tris:
         elements = tris
         for iface, face in enumerate(tris):
             elem = vtkTriangle()
             epoints = elem.GetPointIds()
             epoints.SetId(0, face[0])
             epoints.SetId(1, face[1])
             epoints.SetId(2, face[2])
             self.grid.InsertNextCell(5, elem.GetPointIds())  #elem.GetCellType() = 5  # vtkTriangle
コード例 #58
0
def get3Dpolyactor(final_tripoints):
    polys = []
    for i in xrange(len(final_tripoints)/3):
        poly = []
        poly.append(final_tripoints[3*i])
        poly.append(final_tripoints[3*i+1])
        poly.append(final_tripoints[3*i+2])
        polys.append(poly)
    # print 'polys: ', polys

    points = vtk.vtkPoints()
    print 'len(tris): ', len(polys)
    for p in polys:
        points.InsertNextPoint(p[0])
        points.InsertNextPoint(p[1])
        points.InsertNextPoint(p[2])

    tris = vtk.vtkCellArray()
    for i in range(len(polys)):
        tri = vtk.vtkTriangle()
        tri.GetPointIds().SetId(0, 3*i)
        tri.GetPointIds().SetId(1, 3*i+1)
        tri.GetPointIds().SetId(2, 3*i+2)
        tris.InsertNextCell(tri)

    trisPolyData = vtk.vtkPolyData()
    trisPolyData.SetPoints(points)
    trisPolyData.SetPolys(tris)

    mapper = vtk.vtkPolyDataMapper()
    if vtk.VTK_MAJOR_VERSION <= 5:
        mapper.SetInput(trisPolyData)
    else:
        mapper.SetInputData(trisPolyData)

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)

    return actor
コード例 #59
0
def CreateCrossSectionPolyDataFromFile(file):
  
  with open(file, 'r') as f:
    read_data = f.read()

  tokens = string.split(read_data)

  numPts = int(tokens[0])
  numCells = int(tokens[1])

  print numPts, numCells

  newPoints = vtk.vtkPoints()
  newPoints.SetNumberOfPoints(numPts)

  offset = 2
  for ptId in xrange(numPts):
    x = float(tokens[ptId*3 + 0 + offset])
    y = float(tokens[ptId*3 + 1 + offset])
    z = float(tokens[ptId*3 + 2 + offset])
    newPoints.SetPoint(ptId, x, y, z)

  output = vtk.vtkPolyData()
  output.SetPoints(newPoints)
  output.Allocate(3*numCells)

  offset = 2 + 3*numPts
  triangle = vtk.vtkTriangle()
  pointIds = triangle.GetPointIds()
  pointIds.SetNumberOfIds(3)
  for cellId in xrange(numCells):
    for i in xrange(3):
      pointIds.SetId(i, int(tokens[cellId*3 + i + offset]))
    
    output.InsertNextCell(triangle.GetCellType(), pointIds)
    
  return output
コード例 #60
0
ファイル: clusterRenderer.py プロジェクト: brunoduran/Atoman
 def renderClusterFacets(self, clusterSize, clusterPos, lattice, neighbourRadius, appendPolyData):
     """
     Render facets of a cluster.
     
     """
     # get facets
     facets = clusters.findConvexHullFacets(clusterSize, clusterPos)
     
     # now render
     if facets is not None:
         # TODO: make sure not facets more than neighbour rad from cell
         facets = clusters.checkFacetsPBCs(facets, clusterPos, 2.0 * neighbourRadius, lattice.PBC, lattice.cellDims)
         
         # create vtk points from cluster positions
         points = vtk.vtkPoints()
         for i in xrange(clusterSize):
             points.InsertNextPoint(clusterPos[3 * i], clusterPos[3 * i + 1], clusterPos[3 * i + 2])
         
         # create triangles
         triangles = vtk.vtkCellArray()
         for facet in facets:
             triangle = vtk.vtkTriangle()
             for j in xrange(3):
                 triangle.GetPointIds().SetId(j, facet[j])
             triangles.InsertNextCell(triangle)
         
         # polydata object
         trianglePolyData = vtk.vtkPolyData()
         trianglePolyData.SetPoints(points)
         trianglePolyData.SetPolys(triangles)
         
         # add polydata
         if vtk.vtkVersion.GetVTKMajorVersion() <= 5:
             appendPolyData.AddInputConnection(trianglePolyData.GetProducerPort())
         else:
             appendPolyData.AddInputData(trianglePolyData)