예제 #1
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkSimplePointsReader(), 'Reading vtkSimplePoints.',
         (), ('vtkSimplePoints',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
예제 #2
0
def main():
    # Get all data from the file
    filename = get_program_parameters()
    colors = vtk.vtkNamedColors()

    # Read the file
    reader = vtk.vtkSimplePointsReader()
    reader.SetFileName(filename)
    reader.Update()

    # Visualize
    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(reader.GetOutputPort())

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().SetPointSize(4)

    renderer = vtk.vtkRenderer()
    renderer.AddActor(actor)

    renderer.SetBackground(colors.GetColor3d("Azure"))

    render_window = vtk.vtkRenderWindow()
    render_window.AddRenderer(renderer)

    render_window_interactor = vtk.vtkRenderWindowInteractor()
    render_window_interactor.SetRenderWindow(render_window)

    render_window_interactor.Start()
def ReadSimplePoint(filename):
    print 'Reading file: ', filename
    #read file
    reader = vtk.vtkSimplePointsReader()
    reader.SetFilename(filename)
    reader.Update()

    #visualize
    PolyVisualize(reader.GetOutputPort())
def ReadSimplePoint(filename):
    print 'Reading file: ', filename
    #read file
    reader = vtk.vtkSimplePointsReader()
    reader.SetFilename(filename)
    reader.Update()

    #visualize
    PolyVisualize(reader.GetOutputPort())
예제 #5
0
    def _readFile(self, filename):
        # Takes filename as string and returns polyData
        extension = os.path.splitext(filename)[1].lower()
        print filename

        # # Read PLY into vtkPoints
        # if extension == ".ply" or extension == ".obj" or extension == ".stl":
        #     if (extension == ".ply"):
        #         reader = vtk.vtkPLYReader()
        #     if (extension == ".obj"):
        #         reader = vtk.vtkOBJReader()
        #     if (extension == ".stl"):
        #         reader = vtk.vtkSTLReader()
        #     reader.SetFileName(filename)
        #     reader.Update()
        #     points = reader.GetOutput().GetPoints()
        #     vertices = vtk.vtkCellArray()
        #     for i in range(0,reader.GetOutput().GetNumberOfPoints()):
        #         vertices.InsertNextCell(1)
        #         vertices.InsertCellPoint(i)
        #     # Add all generated data to polydata
        #     polydata = vtk.vtkPolyData()
        #     polydata.SetPoints(points)
        #     polydata.SetVerts(vertices)

        # Read TXT into vtkPoints
        if extension == ".txt":
            textReader = vtk.vtkSimplePointsReader()
            textReader.SetFileName(filename)
            textReader.Update()
            polydata = textReader.GetOutput()
        else:
            print("input must be a .txt file")
            return None
            # raise InputError("file must be ply, stl, obj or txt")

        print("Bounds: ", polydata.GetBounds())

        return polydata
예제 #6
0
def normal_estimation_visual(filename, ply=None):
    '''
    filename:文件名
    顶点的法线评估
    '''
    reader = vtk.vtkSimplePointsReader()
    reader.SetFileName(filename)
    reader.Update()
    polyData = reader.GetOutput()

    sampleSize = polyData.GetNumberOfPoints() * .00005
    if sampleSize < 10:
        sampleSize = 10

    print('Estimating normals using PCANormalEstimation')
    normals = vtk.vtkPCANormalEstimation()
    normals.SetInputData(polyData)
    normals.SetSampleSize(sampleSize)
    normals.SetNormalOrientationToGraphTraversal()
    normals.FlipNormalsOff()
    normals.Update()

    render(normals.GetOutput(), None, ply)
예제 #7
0
def normal_estimation_write(infile, outfile):
    '''
    infile:string, 输入的文件路径
    outfile:string,输出的文件路径
    '''
    reader = vtk.vtkSimplePointsReader()
    reader.SetFileName(infile)
    reader.Update()
    polyData = reader.GetOutput()

    sampleSize = polyData.GetNumberOfPoints() * .00005
    if sampleSize < 10:
        sampleSize = 10

    print('Estimating normals using PCANormalEstimation')
    normals = vtk.vtkPCANormalEstimation()
    normals.SetInputData(polyData)
    normals.SetSampleSize(sampleSize)
    normals.SetNormalOrientationToGraphTraversal()
    normals.FlipNormalsOn()
    normals.Update()

    output = normals.GetOutput()
    arr_normal = output.GetPointData().GetNormals()
    num = arr_normal.GetNumberOfTuples()

    f = codecs.open(outfile, "w")

    for index in range(num):
        for i in range(3):
            f.write("%.6f " % polyData.GetPoint(index)[i])
        for i in range(2):
            f.write("%.6f " % arr_normal.GetTuple(index)[i])
        f.write("%.6f\n" % arr_normal.GetTuple(index)[2])

    f.close()
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

reader = vtk.vtkSimplePointsReader()
reader.SetFileName(VTK_DATA_ROOT + "/Data/points.txt")

mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())

actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetPointSize(5)

ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)

ren1.AddActor(actor)

renWin.SetSize(300, 300)

iren.Initialize()

renWin.Render()

#iren.Start()