def load_vtk(file_number,vtk_dir="vtk_files",organs=list_organs):
    """Loads .vtk file into tensor given file number"""
    file_number = str(file_number).zfill(3)
    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(vtk_dir+"/500%s_fat_content.vtk" %(file_number))
    reader.Update()
    
    data_fat = vtk_to_numpy(reader.GetOutput().GetPointData().GetScalars())
    x_range, y_range, z_range = reader.GetOutput().GetDimensions()
    data = np.zeros(6*x_range*y_range*z_range).reshape(6,x_range,y_range,z_range)
    data[0] = data_fat.reshape(x_range,y_range,z_range)

    #reader.SetFileName(vtk_dir+"/500%s_wat_content.vtk" %(file_number))
    #reader.Update()
    #data_wat = vtk_to_numpy(reader.GetOutput().GetPointData().GetScalars())
    #data[1] = data_wat.reshape(x_range,y_range,z_range)
    
    for i,organ in enumerate(organs):
        reader.SetFileName(vtk_dir+"/binary_"+organ+"500%s.vtk" %(file_number))
        reader.Update()
        data_organ = vtk_to_numpy(reader.GetOutput().GetPointData().GetScalars())
        data[i+1] = data_organ.reshape(x_range,y_range,z_range)
    
    grid = torch.from_numpy(data[:,54:214,:,54:214])
    return grid.to(dtype=torch.float32)
コード例 #2
0
def load_surface(filename):
    # Set a VTKReader
    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(filename)
    reader.Update()

    return reader
コード例 #3
0
def read_3D_file(filename):
    """
    Read a mesh from an STL, OBJ, PLY or VTK file.
    """
    def _read(filename, reader, getVtkReader):
        reader.SetFileName(filename)
        reader.Update()
        if getVtkReader:
            return reader
        return reader.GetOutput()
    if not os.path.exists(filename):
        raise IOError('Input file "{0}" was not found'.format(filename))
    filenameLower = filename.lower()
    getVtkReader = False
    extension = get_filename_extension(filenameLower)
    if extension == 'stl':
        reader = vtk.vtkSTLReader()
        sm = _read(filename, reader, getVtkReader)
    elif extension == 'obj':
        reader = vtk.vtkOBJReader()
        sm = _read(filename, reader, getVtkReader)
    elif extension == 'ply':
        reader = vtk.vtkPLYReader()
        sm = _read(filename, reader, getVtkReader)
    elif extension == 'vtk':
        reader = vtk.vtkGenericDataObjectReader()
        reader.SetFileName(filename)
        reader.Update()
        if reader.IsFilePolyData():
            sm = reader.GetPolyDataOutput()
        else:
            raise Exception
    else:
        raise Exception('Unknown file format : {0}'.format(extension))
    return sm
コード例 #4
0
def load_vtk(file_number):
    """Loads .vtk file into tensor given file number"""
    file_number = str(file_number).zfill(3)
    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName("../../Project course/500%s_fat_content.vtk" %
                       (file_number))
    reader.Update()
    data_fat = vtk_to_numpy(reader.GetOutput().GetPointData().GetScalars())
    x_range, y_range, z_range = reader.GetOutput().GetDimensions()
    data_fat = data_fat.reshape(x_range, y_range, z_range)

    reader.SetFileName("../../Project course/500%s_wat_content.vtk" %
                       (file_number))
    reader.Update()
    data_wat = vtk_to_numpy(reader.GetOutput().GetPointData().GetScalars())
    data_wat = data_wat.reshape(x_range, y_range, z_range)

    reader.SetFileName("../../Project course/binary_liver500%s.vtk" %
                       (file_number))
    reader.Update()
    data_liv = vtk_to_numpy(reader.GetOutput().GetPointData().GetScalars())
    data_liv = data_liv.reshape(x_range, y_range, z_range)

    data = np.zeros(3 * x_range * y_range * z_range).reshape(
        3, x_range, y_range, z_range)
    data[0] = data_fat
    data[1] = data_wat
    data[2] = data_liv

    grid = torch.from_numpy(data)
    return grid.to(dtype=torch.float32)
コード例 #5
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkGenericDataObjectReader(), 'Reading vtkGenericDataObject.',
         (), ('vtkGenericDataObject',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
コード例 #6
0
    def load(fname, dataset_type=None):
        """
        Load from VTK file.

        Parameters
        ----------
        fname : str or pathlib.Path
            Filename for reading. Valid extensions are .vti, .vtr, .vtu, .vtp, and .vtk.
        dataset_type : {'vtkImageData', ''vtkRectilinearGrid', 'vtkUnstructuredGrid', 'vtkPolyData'}, optional
            Name of the vtk.vtkDataSet subclass when opening a .vtk file.

        Returns
        -------
        loaded : damask.VTK
            VTK-based geometry from file.

        """
        if not os.path.isfile(fname):  # vtk has a strange error handling
            raise FileNotFoundError(f'No such file: {fname}')
        ext = Path(fname).suffix
        if ext == '.vtk' or dataset_type is not None:
            reader = vtk.vtkGenericDataObjectReader()
            reader.SetFileName(str(fname))
            if dataset_type is None:
                raise TypeError('Dataset type for *.vtk file not given.')
            elif dataset_type.lower().endswith(('imagedata', 'image_data')):
                reader.Update()
                vtk_data = reader.GetStructuredPointsOutput()
            elif dataset_type.lower().endswith(
                ('rectilineargrid', 'rectilinear_grid')):
                reader.Update()
                vtk_data = reader.GetRectilinearGridOutput()
            elif dataset_type.lower().endswith(
                ('unstructuredgrid', 'unstructured_grid')):
                reader.Update()
                vtk_data = reader.GetUnstructuredGridOutput()
            elif dataset_type.lower().endswith(('polydata', 'poly_data')):
                reader.Update()
                vtk_data = reader.GetPolyDataOutput()
            else:
                raise TypeError(
                    f'Unknown dataset type {dataset_type} for vtk file')
        else:
            if ext == '.vti':
                reader = vtk.vtkXMLImageDataReader()
            elif ext == '.vtr':
                reader = vtk.vtkXMLRectilinearGridReader()
            elif ext == '.vtu':
                reader = vtk.vtkXMLUnstructuredGridReader()
            elif ext == '.vtp':
                reader = vtk.vtkXMLPolyDataReader()
            else:
                raise TypeError(f'Unknown file extension {ext}')

            reader.SetFileName(str(fname))
            reader.Update()
            vtk_data = reader.GetOutput()

        return VTK(vtk_data)
コード例 #7
0
def LabelToSurface(label_path, surface_path, lcc=False, smoothIterations=15,relaxationFactor=0.1):
	tqdm.write("Converting segmentation label to surface file: {}".format(label_path))

	# binary path
	if platform == "linux" or platform == "linux2":
		bin_path = "/home/jacky/Projects/CFD_intraranial/cxx/label_to_mesh/build_linux/LabelToMesh"
	elif platform == "darwin":
		return
	elif platform == "win32":	
		bin_path = "D:/projects/CFD_intracranial/cxx/label_to_mesh/build/Release/LabelToMesh.exe"

	# convert to binary file
	command = bin_path + " " + label_path + " " + surface_path + " 1 1"
	# print(command)
	os.system(command)

	reader = vtk.vtkGenericDataObjectReader()
	reader.SetFileName(surface_path)
	reader.Update()
	surface = reader.GetOutput()

	transform = vtk.vtkTransform()
	transform.Scale(-1,-1,1)

	transformFilter = vtk.vtkTransformPolyDataFilter()
	transformFilter.SetInputData(surface)
	transformFilter.SetTransform(transform)
	transformFilter.Update()
	surface = transformFilter.GetOutput()

	smoothFilter = vtk.vtkSmoothPolyDataFilter()
	smoothFilter.SetInputData(surface)
	smoothFilter.SetNumberOfIterations(smoothIterations);
	smoothFilter.SetRelaxationFactor(relaxationFactor);
	smoothFilter.FeatureEdgeSmoothingOff();
	smoothFilter.BoundarySmoothingOn();
	smoothFilter.Update();
	surface = smoothFilter.GetOutput()

	if lcc:
		connectedFilter = vtk.vtkConnectivityFilter()
		connectedFilter.SetInputData(surface)
		connectedFilter.Update()
		surface = connectedFilter.GetOutput()

	if pathlib.Path(surface_path).suffix == ".vtk":
		writer = vtk.vtkGenericDataObjectWriter()
	elif pathlib.Path(surface_path).suffix == ".vtp":
		writer = vtk.vtkXMLPolyDataWriter()
	elif pathlib.Path(surface_path).suffix == ".stl":
		writer = vtk.vtkSTLWriter()
	writer.SetFileName(surface_path)
	writer.SetInputData(surface)
	writer.Update()

	tqdm.write("Convert segmentation label to surface file complete: {}".format(label_path))
コード例 #8
0
ファイル: load_data.py プロジェクト: clatlan/cdiutils
def load_vtk(file):
    """Get raw data from .vtk file."""

    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(file)
    reader.ReadAllScalarsOn()
    reader.ReadAllVectorsOn()
    reader.ReadAllTensorsOn()
    reader.Update()

    return reader.GetOutput()
コード例 #9
0
ファイル: Field.py プロジェクト: nitramkaroh/mupif
    def makeFromVTK3(fileName,units, time=0,forceVersion2=False):
        '''
        Create fields from a VTK unstructured grid file (``.vtu``, format version 3, or ``.vtp`` with *forceVersion2*); the mesh is shared between fields.

        ``vtk.vtkXMLGenericDataObjectReader`` is used to open the file (unless *forceVersion2* is set), but it is checked that contained dataset is a ``vtk.vtkUnstructuredGrid`` and an error is raised if not.

        .. note:: Units are not supported when loading from VTK, all fields will have ``None`` unit assigned.

        :param str fileName: VTK (``*.vtu``) file
        :param PhysicalUnit units: units of read values
        :param float time: time value for created fields (time is not saved in VTK3, thus cannot be recovered)
        :param bool forceVersion2: if ``True``, ``vtk.vtkGenericDataObjectReader`` (for VTK version 2) will be used to open the file, isntead of ``vtk.vtkXMLGenericDataObjectReader``; this also supposes *fileName* ends with ``.vtk`` (not checked, but may cause an error).
        :return: list of new :obj:`Field` instances
        :rtype: [Field,Field,...]
        '''
        import vtk
        from . import fieldID
        #rr=vtk.vtkXMLUnstructuredGridReader()
        if forceVersion2 or fileName.endswith('.vtk'): rr=vtk.vtkGenericDataObjectReader()
        else: rr=vtk.vtkXMLGenericDataObjectReader()
        rr.SetFileName(fileName)
        rr.Update()
        ugrid=rr.GetOutput()
        if not isinstance(ugrid,vtk.vtkUnstructuredGrid): raise RuntimeError("vtkDataObject read from '%s' must be a vtkUnstructuredGrid (not a %s)"%(fileName,ugrid.__class__.__name__))
        #import sys
        #sys.stderr.write(str((ugrid,ugrid.__class__,vtk.vtkUnstructuredGrid)))
        # make mesh -- implemented separately
        mesh=Mesh.UnstructuredMesh.makeFromVtkUnstructuredGrid(ugrid)
        # fields which will be returned
        ret=[]
        # get cell and point data
        cd,pd=ugrid.GetCellData(),ugrid.GetPointData()
        for data,fieldType in (pd,FieldType.FT_vertexBased),(cd,FieldType.FT_cellBased):
            for idata in range(data.GetNumberOfArrays()):
                aname,arr=pd.GetArrayName(idata),pd.GetArray(idata)
                nt=arr.GetNumberOfTuples()
                if nt==0: raise RuntimeError("Zero values in field '%s', unable to determine value type."%aname)
                t0=arr.GetTuple(0)
                valueType=ValueType.fromNumberOfComponents(len(arr.GetTuple(0)))
                # this will raise KeyError if fieldID with that name not defined
                fid=fieldID.FieldID[aname]
                # get actual values as tuples
                values=[arr.GetTuple(t) for t in range(nt)]
                ret.append(Field(
                    mesh=mesh,
                    fieldID=fid,
                    units=units, # not stored at all
                    time=time,  # not stored either, set by caller
                    valueType=valueType,
                    values=values,
                    fieldType=fieldType
                ))
        return ret
コード例 #10
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self,
         module_manager,
         vtk.vtkGenericDataObjectReader(),
         "Reading vtkGenericDataObject.",
         (),
         ("vtkGenericDataObject",),
         replaceDoc=True,
         inputFunctions=None,
         outputFunctions=None,
     )
コード例 #11
0
ファイル: Field.py プロジェクト: mmp-project/mupif
    def makeFromVTK3(fileName,time=0,forceVersion2=False):
        '''
        Create fields from a VTK unstructured grid file (``.vtu``, format version 3, or ``.vtp`` with *forceVersion2*); the mesh is shared between fields.

        ``vtk.vtkXMLGenericDataObjectReader`` is used to open the file (unless *forceVersion2* is set), but it is checked that contained dataset is a ``vtk.vtkUnstructuredGrid`` and an error is raised if not.

        .. note:: Units are not supported when loading from VTK, all fields will have ``None`` unit assigned.

        :param str fileName: VTK (``*.vtu``) file
        :param float time: time value for created fields (time is not saved in VTK3, thus cannot be recovered)
        :param bool forceVersion2: if ``True``, ``vtk.vtkGenericDataObjectReader`` (for VTK version 2) will be used to open the file, isntead of ``vtk.vtkXMLGenericDataObjectReader``; this also supposes *fileName* ends with ``.vtk`` (not checked, but may cause an error).
        :return: list of new :obj:`Field` instances
        :rtype: [Field,Field,...]
        '''
        import vtk
        from . import fieldID
        #rr=vtk.vtkXMLUnstructuredGridReader()
        if forceVersion2 or fileName.endswith('.vtk'): rr=vtk.vtkGenericDataObjectReader()
        else: rr=vtk.vtkXMLGenericDataObjectReader()
        rr.SetFileName(fileName)
        rr.Update()
        ugrid=rr.GetOutput()
        if not isinstance(ugrid,vtk.vtkUnstructuredGrid): raise RuntimeError("vtkDataObject read from '%s' must be a vtkUnstructuredGrid (not a %s)"%(fileName,ugrid.__class__.__name__))
        #import sys
        #sys.stderr.write(str((ugrid,ugrid.__class__,vtk.vtkUnstructuredGrid)))
        # make mesh -- implemented separately
        mesh=mupif.Mesh.UnstructuredMesh.makeFromVtkUnstructuredGrid(ugrid)
        # fields which will be returned
        ret=[]
        # get cell and point data
        cd,pd=ugrid.GetCellData(),ugrid.GetPointData()
        for data,fieldType in (pd,FieldType.FT_vertexBased),(cd,FieldType.FT_cellBased):
            for idata in range(data.GetNumberOfArrays()):
                aname,arr=pd.GetArrayName(idata),pd.GetArray(idata)
                nt=arr.GetNumberOfTuples()
                if nt==0: raise RuntimeError("Zero values in field '%s', unable to determine value type."%aname)
                t0=arr.GetTuple(0)
                valueType=ValueType.fromNumberOfComponents(len(arr.GetTuple(0)))
                # this will raise KeyError if fieldID with that name not defined
                fid=fieldID.FieldID[aname]
                # get actual values as tuples
                values=[arr.GetTuple(t) for t in range(nt)]
                ret.append(Field(
                    mesh=mesh,
                    fieldID=fid,
                    units=None, # not stored at all
                    time=time,  # not stored either, set by caller
                    valueType=valueType,
                    values=values,
                    fieldType=fieldType
                ))
        return ret
コード例 #12
0
def main():
    filename = get_program_parameters()

    # Get all data from the file
    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(filename)
    reader.Update()

    # All of the standard data types can be checked and obtained like this:
    if reader.IsFilePolyData():
        print("output is a polydata")
        output = reader.GetPolyDataOutput()
        print("output has", output.GetNumberOfPoints(), "points.")
コード例 #13
0
def readVTK(inputFileName):
    """ IO :: read a file.txt """
    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(inputFileName)
    reader.Update()  # Needed because of GetScalarRange

    append = vtk.vtkAppendPolyData()
    append.AddInputData(reader.GetOutput())
    append.Update()

    pdata = append.GetOutput()

    return pdata
コード例 #14
0
def convertFile(filepath, outdir):
    if not os.path.isdir(outdir):
        os.makedirs(outdir)
    if os.path.isfile(filepath):
        basename = os.path.basename(filepath)
        print("Copying file:", basename)
        basename = os.path.splitext(basename)[0]
        outfile = os.path.join(outdir, basename + ".ply")
        reader = vtk.vtkGenericDataObjectReader()
        reader.SetFileName(filepath)
        reader.Update()
        writer = vtk.vtkPLYWriter()
        writer.SetInputConnection(reader.GetOutputPort())
        writer.SetFileName(outfile)
        return writer.Write() == 1
    return False
コード例 #15
0
ファイル: LiverView.py プロジェクト: xeon-ye/TrialVTK
    def initVessels(self):
        qDebug('initVessels()')
        if os.name == 'nt':
            filename = os.path.join(filedir,
                                    '../../data/Abdomen/Connected.vtp')
            if IOUSFAN:
                #filename = 'e:/analogic/TrialVTK/data/VesselMeshData.vtk'
                filename = 'e:/analogic/TrialVTK/data/LiverVesselMeshData.vtk'
        else:
            filename = '/home/jmh/bkmedical/data/CT/Connected.vtp'

        # read data
        if IOUSFAN:
            reader = vtk.vtkGenericDataObjectReader()
        else:
            reader = vtk.vtkXMLPolyDataReader()
        reader.SetFileName(filename)
        reader.Update()

        connectFilter = vtk.vtkPolyDataConnectivityFilter()
        connectFilter.SetInputConnection(reader.GetOutputPort())
        connectFilter.SetExtractionModeToLargestRegion()
        connectFilter.Update()

        self.vesselPolyData = self.scale(connectFilter.GetOutput())

        # compute normals
        self.vesselNormals = vtk.vtkPolyDataNormals()
        self.vesselNormals.SetInputData(self.vesselPolyData)

        # mapper
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(self.vesselNormals.GetOutputPort())

        # actor for vessels
        self.vessels = vtk.vtkActor()
        self.vessels.SetMapper(mapper)
        prop = self.vessels.GetProperty()

        if self.brighter25:
            prop.SetColor(vtk.vtkColor3d(hexCol("#517487")))  # 25% lighter
        else:
            prop.SetColor(vtk.vtkColor3d(hexCol("#415d6c")))
        # assign actor to the renderer
        self.renderer.AddActor(self.vessels)
コード例 #16
0
    def load(fname,dataset_type=None):
        """
        Create VTK from file.

        Parameters
        ----------
        fname : str or pathlib.Path
            Filename for reading. Valid extensions are .vtr, .vtu, .vtp, and .vtk.
        dataset_type : str, optional
            Name of the vtk.vtkDataSet subclass when opening a .vtk file. Valid types are vtkRectilinearGrid,
            vtkUnstructuredGrid, and vtkPolyData.

        """
        ext = Path(fname).suffix
        if ext == '.vtk' or dataset_type is not None:
            reader = vtk.vtkGenericDataObjectReader()
            reader.SetFileName(str(fname))
            if dataset_type is None:
                raise TypeError('Dataset type for *.vtk file not given.')
            elif dataset_type.lower().endswith('rectilineargrid'):
                reader.Update()
                vtk_data = reader.GetRectilinearGridOutput()
            elif dataset_type.lower().endswith('unstructuredgrid'):
                reader.Update()
                vtk_data = reader.GetUnstructuredGridOutput()
            elif dataset_type.lower().endswith('polydata'):
                reader.Update()
                vtk_data = reader.GetPolyDataOutput()
            else:
                raise TypeError(f'Unknown dataset type {dataset_type} for vtk file')
        else:
            if   ext == '.vtr':
                reader = vtk.vtkXMLRectilinearGridReader()
            elif ext == '.vtu':
                reader = vtk.vtkXMLUnstructuredGridReader()
            elif ext == '.vtp':
                reader = vtk.vtkXMLPolyDataReader()
            else:
                raise TypeError(f'Unknown file extension {ext}')

            reader.SetFileName(str(fname))
            reader.Update()
            vtk_data = reader.GetOutput()

        return VTK(vtk_data)
コード例 #17
0
def LabelToSurface(label_path, surface_path, lcc=False):
    print("Converting segmentation label to surface file:", label_path)

    # binary path
    bin_path = "D:/Dr_Simon_Yu/CFD_intracranial/code/cxx/label_to_mesh/build/Release/LabelToMesh.exe"

    # convert to binary file
    command = bin_path + " " + label_path + " " + surface_path + " 1 1"
    # print(command)
    os.system(command)

    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(surface_path)
    reader.Update()
    surface = reader.GetOutput()

    transform = vtk.vtkTransform()
    transform.Scale(-1, -1, 1)

    transformFilter = vtk.vtkTransformPolyDataFilter()
    transformFilter.SetInputData(surface)
    transformFilter.SetTransform(transform)
    transformFilter.Update()
    surface = transformFilter.GetOutput()

    smoothFilter = vtk.vtkSmoothPolyDataFilter()
    smoothFilter.SetInputData(surface)
    smoothFilter.SetNumberOfIterations(15)
    smoothFilter.SetRelaxationFactor(0.1)
    smoothFilter.FeatureEdgeSmoothingOff()
    smoothFilter.BoundarySmoothingOn()
    smoothFilter.Update()
    surface = smoothFilter.GetOutput()

    if lcc:
        connectedFilter = vtk.vtkConnectivityFilter()
        connectedFilter.SetInputData(surface)
        connectedFilter.Update()
        surface = connectedFilter.GetOutput()

    writer = vtk.vtkGenericDataObjectWriter()
    writer.SetFileName(surface_path)
    writer.SetInputData(surface)
    writer.Update()
コード例 #18
0
ファイル: _vtk.py プロジェクト: hrh741/DAMASK
    def from_file(fname, dataset_type=None):
        """
        Create VTK from file.

        Parameters
        ----------
        fname : str
            Filename for reading. Valid extensions are .vtr, .vtu, .vtp, and .vtk.
        dataset_type : str, optional
            Name of the vtk.vtkDataSet subclass when opening an .vtk file. Valid types are vtkRectilinearGrid,
            vtkUnstructuredGrid, and vtkPolyData.

        """
        ext = os.path.splitext(fname)[1]
        if ext == '.vtk':
            reader = vtk.vtkGenericDataObjectReader()
            reader.SetFileName(fname)
            reader.Update()
            if dataset_type is None:
                raise TypeError('Dataset type for *.vtk file not given.')
            elif dataset_type.lower().endswith('rectilineargrid'):
                geom = reader.GetRectilinearGridOutput()
            elif dataset_type.lower().endswith('unstructuredgrid'):
                geom = reader.GetUnstructuredGridOutput()
            elif dataset_type.lower().endswith('polydata'):
                geom = reader.GetPolyDataOutput()
            else:
                raise TypeError('Unknown dataset type for vtk file {}'.format(
                    dataset_type))
        else:
            if ext == '.vtr':
                reader = vtk.vtkXMLRectilinearGridReader()
            elif ext == '.vtu':
                reader = vtk.vtkXMLUnstructuredGridReader()
            elif ext == '.vtp':
                reader = vtk.vtkXMLPolyDataReader()
            else:
                raise TypeError('Unknown file extension {}'.format(ext))

            reader.SetFileName(fname)
            reader.Update()
            geom = reader.GetOutput()

        return VTK(geom)
コード例 #19
0
ファイル: vtk_modeler.py プロジェクト: bch0w/pyatoa
def get_coordinates(fid):
    """
    I couldn't, for the life of me, figure out how to get the mesh dimensions
    out of the mayavi objects, so instead just get it from using the VTK lib

    :type fid: str
    :param fid: file id of the .vtk file
    :rtype: numpy array
    :return: Nx3 numpy array with columns corresponding to x, y, z
    """
    import vtk
    from vtk.util.numpy_support import vtk_to_numpy

    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(fid)
    reader.Update()
    coords = vtk_to_numpy(reader.GetOutput().GetPoints().GetData())

    return coords
コード例 #20
0
def vtp2csv(fileIn, fileOut):
    reader = vtk.vtkGenericDataObjectReader()
    reader = vtk.vtkXMLPPolyDataReader()
    reader.SetFileName(fileIn)
    reader.Update()

    point_obj = reader.GetOutput()
    points = point_obj.GetPoints()

    table = vtk.vtkDataObjectToTable()
    table.SetInputData(point_obj)
    table.Update()
    table.GetOutput().AddColumn(points.GetData())
    table.Update()

    writer = vtk.vtkDelimitedTextWriter()
    writer.SetInputConnection(table.GetOutputPort())
    writer.SetFileName(fileOut)
    writer.Update()
    writer.Write()
コード例 #21
0
def read_vtk_format(filename, type='point'):
    '''
    file: .vtk file or .stl
    type: 'point', 'poly'
    return: vtkPoints or vtkPolyData
    '''
    print 'Reading ', filename
    sufx = filename.split('.')[-1]
    if sufx == 'vtk':
        reader = vtk.vtkGenericDataObjectReader()
        reader.SetFileName(filename)
        reader.Update()
        geo = vtk.vtkGeometryFilter(
        )  # convert unstructed grid to a poly data, cannot write to stl now
        geo.SetInputData(reader.GetOutput())
        geo.Update()
        poly = geo.GetOutput()

        # important: convert point to triangle
        triangle = vtk.vtkTriangleFilter()
        triangle.SetInputData(poly)
        triangle.Update()
        poly = triangle.GetOutput()
        return poly

    elif sufx == 'stl':
        reader = vtk.vtkSTLReader()
        reader.SetFileName(filename)
        reader.Update()
        points = reader.GetOutput().GetPoints()
        poly = reader.GetOutput()
    else:
        raise ValueError('Support stl file only...')

    if type == 'point':
        return points
    elif type == 'poly':
        return poly
    else:
        raise ValueError('Invalid output type')
コード例 #22
0
ファイル: pluto_vtk.py プロジェクト: sddyates/plutopy
def setup_vtk(filename):
    """
    Set vtk reader and get vector dimansions.
    """
    from vtk import vtkStructuredGridReader
    from vtk import vtkGenericDataObjectReader
    from vtk import vtkRectilinearGridReader
    from vtk import vtkStructuredPointsReader

    reader = vtkGenericDataObjectReader()
    reader.SetFileName(filename)
    reader.ReadAllVectorsOn()
    reader.ReadAllScalarsOn()
    reader.Update()
    data = reader.GetOutput()
    dim = data.GetDimensions()
    sca = list(dim)
    sca = [i - 1 for i in dim]
    vec = list(dim)
    vec = [i - 1 for i in dim]
    vec.append(3)
    return data, vec, sca, dim
コード例 #23
0
def centerlineCalculation(working_dir, relaxation=0, post=False):
    if post:
        # compute centerline
        command = binary_path + " " + \
         os.path.join(working_dir,"surface_capped.stl") + " " + \
         os.path.join(working_dir,"surface_capped.stl") + " " + \
         os.path.join(working_dir,"centerline_clipped.vtp")
    else:
        if not os.path.exists(os.path.join(working_dir, "surface.vtk")):
            return

        # convert vtk to stl
        reader = vtk.vtkGenericDataObjectReader()
        reader.SetFileName(os.path.join(working_dir, "surface.vtk"))
        reader.Update()
        surface = reader.GetOutput()

        if relaxation > 0:
            smoothFilter = vtk.vtkSmoothPolyDataFilter()
            smoothFilter.SetInputData(surface)
            smoothFilter.SetNumberOfIterations(100)
            smoothFilter.SetRelaxationFactor(relaxation)
            smoothFilter.FeatureEdgeSmoothingOff()
            smoothFilter.BoundarySmoothingOn()
            smoothFilter.Update()
            surface.DeepCopy(smoothFilter.GetOutput())

        writer = vtk.vtkSTLWriter()
        writer.SetFileName(os.path.join(working_dir, "surface.stl"))
        writer.SetInputData(surface)
        writer.Update()

        # compute centerline
        command = binary_path + " " + \
         os.path.join(working_dir,"surface.stl") + " " + \
         os.path.join(working_dir,"surface_capped.stl") + " " + \
         os.path.join(working_dir,"centerline.vtp")

    os.system(command)
コード例 #24
0
ファイル: LiverView.py プロジェクト: xeon-ye/TrialVTK
    def initLiver(self):
        qDebug('initLiver()')
        if os.name == 'nt':
            filename = os.path.join(
                filedir, '../../data/Abdomen/Liver_3D-interpolation.vtp')
            if IOUSFAN:
                filename = 'e:/analogic/TrialVTK/data/segmented_liver_ITK_snap.vtk'
        else:
            filename = '/home/jmh/bkmedical/data/CT/Liver_3D-interpolation.vtp'
        if IOUSFAN:
            reader = vtk.vtkGenericDataObjectReader()
        else:
            reader = vtk.vtkXMLPolyDataReader()

        reader.SetFileName(filename)
        reader.Update()

        connectFilter = vtk.vtkPolyDataConnectivityFilter()
        connectFilter.SetInputConnection(reader.GetOutputPort())
        connectFilter.SetExtractionModeToLargestRegion()
        connectFilter.Update()

        surfNormals = vtk.vtkPolyDataNormals()
        surfNormals.SetInputData(self.scale(connectFilter.GetOutput()))

        #Create a mapper and actor
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(surfNormals.GetOutputPort())  # was reader
        self.liver = vtk.vtkActor()
        self.liver.SetMapper(mapper)
        prop = self.liver.GetProperty()

        if self.brighter25:
            prop.SetColor(vtk.vtkColor3d(hexCol("#873927")))
        else:
            prop.SetColor(vtk.vtkColor3d(hexCol("#6c2e1f")))
        prop.SetOpacity(self.opacity)
        self.renderer.AddActor(self.liver)
コード例 #25
0
def gmsh1D(listPoints, h):  # use gmsh in 1D
    # print (listPoints)
    if isinstance(listPoints,
                  (np.ndarray, list,
                   tuple)):  # test if listPoints is a np.array, list or tuple
        listPoints = np.asarray(listPoints)  # convert in np.array
    else:
        raise ValueError(
            'List of points must be a numpy array, list or tuple.')
        exit()

    nPoints = listPoints.shape[0]  # store number of points

    if not isinstance(
            h,
        (float, int, np.ndarray, list, tuple)):  # test if h is an other struc
        raise ValueError('h must be a scalar, numpy array, list or tuple.')
        exit()
    if isinstance(
            h,
        (np.ndarray, list, tuple)):  # test if h is a np.array, list or tuple
        h = np.asarray(h)  # convert h in np.array
        if h.shape[0] != nPoints:  # /!\ size are different
            raise ValueError('h must have the same size of number of points.')
    else:
        h = np.full(
            (nPoints),
            h)  # h is a number, convert in np.array : value h, size nPoints

    # print (h)

    if nPoints < 2:  # create a line is not possible without 2 points
        raise ValueError('You have to precise 2 points minimum.')
        exit()

    listPoints_ = np.ndarray((nPoints, 3))  # store 'point' structure of GMSH

    for i in np.arange(nPoints):  # loop over points
        if isinstance(
                listPoints[i],
            (np.ndarray, list, tuple)):  # convert point [i] in np.array
            listPoints[i] = np.asarray(listPoints[i])
        else:
            raise ValueError(
                '{}ieme point must be a numpy array, list or tuple.'.format(i))
            exit()

        if listPoints[i].shape[0] == 1:  # point [i] is [x]
            listPoints_[i] = np.array([listPoints[i, 0], 0., 0.])
        elif listPoints[i].shape[0] == 2:  # point [i] is [x, y]
            listPoints_[i] = np.array([listPoints[i, 0], listPoints[i, 1], 0.])
        else:  # point [i] is [x, y, z]
            listPoints_[i] = listPoints[i]

    listPoints = listPoints_  # erase point with correct number of coordinates

    geom = pygmsh.built_in.Geometry()  # create module of GMSH

    listPoints_ = []  # array of points GMSH structure
    for i in np.arange(nPoints):
        listPoints_.append(
            geom.add_point(  # create a GMSH point
                listPoints[i],  # point [i] = [x, y, z]
                lcar=h[i]  # h [i] is the size at the point [i]
            ))

    listPoints = listPoints_  # erase listPoints with GMSH structure

    for i in np.arange(1, nPoints):  # loop over points
        p = listPoints[i - 1]  # p1 : beginning of line
        p_ = listPoints[i]  # p2 : end of the line
        geom.add_line(p, p_)  # create GMSH line between p1 and p2

    mesh = pygmsh.generate_mesh(geom)  # generate mesh (see pyGMSH)
    file = tempfile.mkstemp(
        suffix='.vtk')  # create a temporary file to write the temporary vtk

    meshio.write(file[1], mesh)  # write output of pyGMSH in the temporary file
    reader = vtk.vtkGenericDataObjectReader()  # Generic reader of VTK
    reader.SetFileName(file[1])  # set the fileName with temporary fileName
    reader.Update()  # Update generic reader

    pdata = vtk.vtkPolyData()  # create an empty vtkPolyData
    geoFilter = vtk.vtkGeometryFilter()  # transform any entry in vtkPolyData
    geoFilter.SetInputData(reader.GetOutput())  #
    geoFilter.Update()  #
    pdata.DeepCopy(geoFilter.GetOutput())  # deep copy of output of geoFilter

    return pdata
コード例 #26
0
ファイル: VTKReader.py プロジェクト: sssilvar/funny_coding
import vtk
import os

# Set filename
filename = os.path.join(os.getcwd(), 'files', 'lh.vtk')

# Set a VTKReader
reader = vtk.vtkGenericDataObjectReader()
reader.SetFileName(filename)
reader.Update()

# Set a mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(reader.GetOutputPort())

# Set an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)

# Renderer
ren = vtk.vtkRenderer()
ren.AddActor(actor)

# RenderWindow
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(ren)

# WindowInteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
コード例 #27
0
                    inplace = False,
                    render = False,
)

(options, filenames) = parser.parse_args()

if not options.vtk:                 parser.error('No VTK file specified.')
if not os.path.exists(options.vtk): parser.error('VTK file does not exist.')

if os.path.splitext(options.vtk)[1] == '.vtr':
  reader = vtk.vtkXMLRectilinearGridReader()
  reader.SetFileName(options.vtk)
  reader.Update()
  rGrid = reader.GetOutput()
elif os.path.splitext(options.vtk)[1] == '.vtk':
  reader = vtk.vtkGenericDataObjectReader()
  reader.SetFileName(options.vtk)
  reader.Update()
  rGrid = reader.GetRectilinearGridOutput()
else:
  parser.error('Unsupported VTK file type extension.')

Npoints = rGrid.GetNumberOfPoints()
Ncells  = rGrid.GetNumberOfCells()

damask.util.croak('{}: {} points and {} cells...'.format(options.vtk,Npoints,Ncells))

# --- loop over input files -------------------------------------------------------------------------

if filenames == []: filenames = [None]
コード例 #28
0
def gmsh2D (listPoints, h, trSur = "no"):                                               # see D1.py for more details
    # print (listPoints)
    if isinstance (listPoints, (np.ndarray, list, tuple)):
        listPoints = np.asarray (listPoints)
    else:
        raise ValueError('List of points must be a numpy array, list or tuple.')
        exit ()

    nPoints = listPoints.shape [0]

    if not isinstance (h, (float, int, np.ndarray, list, tuple)):
        raise ValueError('h must be a scalar, numpy array, list or tuple.')
        exit ()
    if isinstance (h, (np.ndarray, list, tuple)):
        h = np.asarray (h)
        if h.shape [0] != nPoints:
            raise ValueError('h must have the same size of number of points.')
    else:
        h = np.full ((nPoints), h)

    # print (h)

    if nPoints < 3:
        raise ValueError('You have to precise 3 points minimum.')
        exit ()

    listPoints_ = np.ndarray ((nPoints, 3))

    for i in np.arange (nPoints):
        if isinstance (listPoints [i], (np.ndarray, list, tuple)):
            listPoints [i] = np.asarray (listPoints [i])
        else:
            raise ValueError('{}ieme point must be a numpy array, list or tuple.'.format (i))
            exit ()

        if listPoints [i].shape [0] == 1:
            listPoints_ [i] = np.array ([listPoints [i, 0], 0., 0.])
        elif listPoints [i].shape [0] == 2:
            print (listPoints [i])
            listPoints_ [i] = np.array ([listPoints [i, 0], listPoints [i, 1], 0.])
        else:
            listPoints_ [i] = listPoints [i]

    listPoints = listPoints_

    if nPoints > 3:
        for i, subset in zip ( np.arange (nPoints), itertools.combinations (listPoints, 4)):
            if not coplanar (subset [0], subset [1], subset [2], subset [3]):
                raise ValueError('You must choose coplanar points.')
                exit ()

    geom = pygmsh.built_in.Geometry ()

    listPoints_ = []
    for i in np.arange (nPoints):
        listPoints_.append (geom.add_point (
            listPoints [i],
            lcar= h [i]
        ))

    listPoints = listPoints_

    listLines = []
    for i in np.arange (nPoints):
        p = listPoints [i]
        if i + 1 == nPoints:
            p_ = listPoints [0]
        else:
            p_ = listPoints [i + 1]
        listLines.append (geom.add_line (p, p_))

    ll = geom.add_line_loop(listLines)
    surface = geom.add_plane_surface(ll)

    if trSur == "yes":                                                                      # transfinite surface : surface reguliere
        geom.set_transfinite_surface(surface)


    mesh = pygmsh.generate_mesh(geom)
    file = tempfile.mkstemp (suffix = '.vtk')
    meshio.write(file [1], mesh)

    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(file [1])
    reader.Update()

    pdata = vtk.vtkPolyData()
    geoFilter = vtk.vtkGeometryFilter () # transform any entry in vtkPolyData
    geoFilter.SetInputData (reader.GetOutput ())
    geoFilter.Update()
    pdata.DeepCopy (geoFilter.GetOutput ())

    return pdata
コード例 #29
0
ファイル: mix.py プロジェクト: chielk/beautiful_data
def read_data():
    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName("data/SMRX.vtk")
    reader.Update()
    return reader
コード例 #30
0
def Extrude(Slope,Extrusion,Plane,Model,Sediment,Start_time,End_time,Time_step,Mesh):
	ugrid1 = vtk.vtkUnstructuredGrid()         #1.import sloped sediment and change to polydata
	gridreader1=vtk.vtkUnstructuredGridReader()
	gridreader1.SetFileName(Slope) #.pvd
	gridreader1.Update()
	ugrid1 = gridreader1.GetOutput()
	GeomFilt1 = vtk.vtkGeometryFilter()
	GeomFilt1.SetInput(ugrid1)
	GeomFilt1.Update()
	y1 = GeomFilt1.GetOutput()

	
	Extrude = vtk.vtkLinearExtrusionFilter()         #2. extrude the polydata and save it again as polydata
	Extrude.SetInput(y1)
	Extrude.SetExtrusionTypeToVectorExtrusion()	
	Extrude.SetVector(0,0,-1)
	PreliminaryExtrusion = Extrude.GetOutput()

	PE = vtk.vtkPolyData()
	PE = PreliminaryExtrusion
	PE.Update()

	ugrid2 = vtk.vtkUnstructuredGrid()                      #3. import in the top surface of the sediment below
	gridreader2=vtk.vtkXMLUnstructuredGridReader()
	gridreader2.SetFileName(Plane) # 000000.vtu
	gridreader2.Update()
	ugrid2 = gridreader2.GetOutput()

	ExtrudedPoints = PE.GetPoints()               #4. take points from the extruded polydata
	PlanePoints = ugrid2.GetPoints()                        #5. get points from surface below
	nPoints = PE.GetNumberOfPoints()              #6. for first half of points determine if above or below last surface
	Begin  = nPoints/2                                 #7. if below set as the same as bottom surface (slightly above?)
	                                              #8. set second half 
	counter = 0
	uPoints = ugrid2.GetPoints()

	for p in range(Begin,nPoints):
		y = uPoints.GetPoint(counter)[2:]
		x = ExtrudedPoints.GetPoint(p)[:2] + y
		ExtrudedPoints.SetPoint(p,x)
		counter += 1

	PE.Update()

	writer = vtk.vtkGenericDataObjectWriter()
	writer.SetFileName(Model)
	writer.SetInput(PE)
	writer.Update()
	writer.Write()
#################################################################################################################
		


	t = Start_time
	dt = Time_step
	ET = End_time
	et = ET-1
	Save = Sediment + str(t) +'000000.vtu'
	Import = Sediment + str(t)+ '_sed_slope.pvd'
	NewSave = Sediment + str(t)+ 'extruded_sed_slope.pvd'

	SedimentGrid1 = vtk.vtkUnstructuredGrid()         #1.import sloped sediment and change to polydata
	SedimentGridreader1=vtk.vtkUnstructuredGridReader()
	SedimentGridreader1.SetFileName(Import) #.pvd
	SedimentGridreader1.Update()
	SedimentGrid1 = SedimentGridreader1.GetOutput()
	GeomFilt2 = vtk.vtkGeometryFilter()
	GeomFilt2.SetInput(SedimentGrid1)
	GeomFilt2.Update()
	ExtrudeInput1 = GeomFilt2.GetOutput()

	ExtrudeSed1 = vtk.vtkLinearExtrusionFilter()         #2. extrude the polydata and save it again as polydata
	ExtrudeSed1.SetInput(ExtrudeInput1)
	ExtrudeSed1.SetExtrusionTypeToVectorExtrusion()	
	ExtrudeSed1.SetVector(0,0,-1)
	PreliminarySedExtrusion1 = ExtrudeSed1.GetOutput()

	PSE1 = vtk.vtkPolyData()
	PSE1 = PreliminarySedExtrusion1
	PSE1.Update()
		
	PreSurface1 = vtk.vtkUnstructuredGrid()                      #3. import in the top surface of the sediment below
	PSreader1=vtk.vtkGenericDataObjectReader()
	PSreader1.SetFileName(Slope) # 000000.vtu
	PSreader1.Update()
	PreSurface1 = PSreader1.GetOutput()
	ExtrudedSedPoints1 = PSE1.GetPoints()               #4. take points from the extruded polydata
	PSPoints1 = PreSurface1.GetPoints()                        #5. get points from surface below
	SedPoints1 = PSE1.GetNumberOfPoints()          #6. for first half of points determine if above or below last surface
	BeginSed1  = nPoints/2 
	EndSed1 = BeginSed1 - 1                             #7. if below set as the same as bottom surface (slightly above?
	sedcounter1 = 0					 #8. set second half 
	sedcounter2 = BeginSed1
			
	for p in range(BeginSed1,SedPoints1):
		y = PSPoints1.GetPoint(sedcounter1)[2:]
		x = ExtrudedSedPoints1.GetPoint(p)[:2] + y
		ExtrudedSedPoints1.SetPoint(p,x)
		sedcounter1 += 1
			
	writer = vtk.vtkGenericDataObjectWriter()
	writer.SetFileName(NewSave)
	writer.SetInput(PSE1)
	writer.Update()
	writer.Write()

#####################################################################################################################


	while t <= et:
		t += dt
		pre = t -1
		Previous = Sediment +str(pre) + '_sed_slope.pvd'  
		PreviousSave = Sediment + str(pre)+ 'extruded_sed_slope.pvd'
		Import = Sediment + str(t)+ '_sed_slope.pvd'
		NewSave = Sediment + str(t)+ 'extruded_sed_slope.pvd'
		
		SedimentGrid2 = vtk.vtkUnstructuredGrid()         
		SedimentGridreader2=vtk.vtkUnstructuredGridReader()
		SedimentGridreader2.SetFileName(Import) #.pvd
		SedimentGridreader2.Update()
		SedimentGrid2 = SedimentGridreader2.GetOutput()
		GeomFilt3 = vtk.vtkGeometryFilter()
		GeomFilt3.SetInput(SedimentGrid2)
		GeomFilt3.Update()
		ExtrudeInput = GeomFilt3.GetOutput()		


		ExtrudeInput2 = GeomFilt3.GetOutput()
		ExtrudeSed2 = vtk.vtkLinearExtrusionFilter()         
		ExtrudeSed2.SetInput(ExtrudeInput2)
		ExtrudeSed2.SetExtrusionTypeToVectorExtrusion()	
		ExtrudeSed2.SetVector(0,0,-1)
		PreliminarySedExtrusion2 = ExtrudeSed2.GetOutput()
		
		PSE2 = vtk.vtkPolyData()
		PSE2 = PreliminarySedExtrusion2
		PSE2.Update()

		PreSurface2 = vtk.vtkUnstructuredGrid()                     
		PSreader2=vtk.vtkGenericDataObjectReader()
		PSreader2.SetFileName(PreviousSave) # 000000.vtu
		PSreader2.Update()
		PreSurface2 = PSreader2.GetOutput()

		Append = vtk.vtkAppendPolyData()

		Append.AddInput(PreSurface2)
		Append.AddInput(PSE2)

		DD = Append.GetOutput()
		DD.Update()

		ExtrudedSedPoints = PSE2.GetPoints()               
		PSPoints = PreSurface2.GetPoints()                       
		SedPoints = PSE2.GetNumberOfPoints()         
		BeginSed  = nPoints/2 
		EndSed = BeginSed - 1                             
		sedcounter3 = 0					
		sedcounter4 = BeginSed
		Data = DD.GetPoints()
		
		mesh = Mesh
		m = (mesh+1)**2
		c = t
		while c != 0:
			c = (c -1)
			e = int((c*m)*2)
			ee = int(e + m)
			for p in range(e,ee):
				A = Data.GetPoint(p+(2*m))[2:]             #New sediment height
				B = Data.GetPoint(p)[2:]			# old sediment height
				C = Data.GetPoint(p+m)[2:]          # old sediment bottom
				if A < B:                                        #If new sediment height is less than old sediment height
					y = (Data.GetPoint(p)[:2] + Data.GetPoint(p+(2*m))[2:])
            				Data.SetPoint(p,y)
	
				if A < C:
					x = Data.GetPoint(p+m)[:2] + Data.GetPoint(p)[2:]
					Data.SetPoint((p+m),x)
		f = int((t*m)*2+m)
		ff = int(f + m)
		for p in range(f,ff):
			y = Data.GetPoint((p-3*m))[2:]
			x = Data.GetPoint(p)[:2] + y
			Data.SetPoint(p,x)

				

		writer = vtk.vtkGenericDataObjectWriter()
		writer.SetFileName(NewSave)
		writer.SetInput(DD)
		writer.Update()
		writer.Write()
コード例 #31
0
def execute(working_dir):
    # convert vtk to stl
    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(os.path.join(working_dir, "surface.vtk"))
    reader.Update()
    surface = reader.GetOutput()

    writer = vtk.vtkSTLWriter()
    writer.SetFileName(os.path.join(working_dir, "surface.stl"))
    writer.SetInputData(surface)
    writer.Update()

    # compute centerline
    command = binary_path + " " + \
     os.path.join(working_dir,"surface.stl") + " " + \
     os.path.join(working_dir,"surface_capped.stl") + " " + \
     os.path.join(working_dir,"centerline.vtp")
    # os.system(command)

    # crop equal distance from the defected zone
    # load defected zone coordinate
    defected_point = open(os.path.join(working_dir, "defected_point.fcsv"),
                          "r").readlines()[3]
    defected_point = defected_point.split(",")[1:4]
    defected_point = [float(i) for i in defected_point]

    # load the centerline file
    reader = vtk.vtkXMLPolyDataReader()
    reader.SetFileName(os.path.join(working_dir, "centerline.vtp"))
    reader.Update()
    centerline = reader.GetOutput()

    kdTree = vtk.vtkKdTreePointLocator()
    kdTree.SetDataSet(centerline)
    iD = kdTree.FindClosestPoint(defected_point)

    end_id = centerline.GetNumberOfPoints() - 1

    defected_point_absc = centerline.GetPointData().GetArray(
        "Abscissas").GetComponent(iD, 0)

    # find the start point
    start_id = 0
    start_point_absc = 0
    start_point = [0, 0, 0]
    start_point_tangent = [1, 0, 0]
    start_point_normal = [0, 1, 0]
    start_point_binormal = [0, 0, 1]

    for i in range(centerline.GetNumberOfPoints() - 1):
        if defected_point_absc - centerline.GetPointData().GetArray(
                "Abscissas").GetComponent(i, 0) < dist_from_defect:
            break
        else:
            start_id = i
            start_point_absc = centerline.GetPointData().GetArray(
                "Abscissas").GetComponent(i, 0)
            start_point = list(centerline.GetPoints().GetPoint(i))
            start_point_tangent = list(centerline.GetPointData().GetArray(
                "FrenetTangent").GetTuple(i))
            start_point_normal = list(
                centerline.GetPointData().GetArray("FrenetNormal").GetTuple(i))
            start_point_binormal = list(centerline.GetPointData().GetArray(
                "FrenetBinormal").GetTuple(i))

    print(start_id, start_point, start_point_tangent, start_point_normal,
          start_point_binormal)

    clipBoxes = []
    clipPlanes = []
    surface, clipBox, clipPlane = clip_polydata_by_box(surface, start_point,
                                                       start_point_tangent,
                                                       start_point_normal,
                                                       start_point_binormal)
    centerline, _, _ = clip_polydata_by_box(centerline, start_point,
                                            start_point_tangent,
                                            start_point_normal,
                                            start_point_binormal)
    clipBoxes.append(clipBox)
    clipPlanes.append(clipPlane)

    # find end points
    # split the polydata by centerline id
    splitter = vtk.vtkThreshold()
    splitter.SetInputData(centerline)

    splitted_centerlines = []
    for i in range(
            int(centerline.GetCellData().GetArray("CenterlineIds").GetRange()
                [1]) + 1):
        splitter.ThresholdBetween(i, i)
        splitter.SetInputArrayToProcess(
            0, 0, 0, vtk.vtkDataObject.FIELD_ASSOCIATION_CELLS,
            "CenterlineIds")
        splitter.Update()

        splitted_centerline = vtk.vtkPolyData()
        splitted_centerline.DeepCopy(splitter.GetOutput())
        splitted_centerlines.append(splitted_centerline)

    end_ids = []
    end_points = []
    end_points_tangent = []
    end_points_normal = []
    end_points_binormal = []

    for splitted_centerline in splitted_centerlines:
        end_id = splitted_centerline.GetNumberOfPoints() - 1
        end_point_absc = splitted_centerline.GetPointData().GetArray(
            "Abscissas").GetComponent(
                splitted_centerline.GetNumberOfPoints() - 1, 0)
        end_point = list(splitted_centerline.GetPoints().GetPoint(
            splitted_centerline.GetNumberOfPoints() - 1))
        end_point_tangent = list(splitted_centerline.GetPointData().GetArray(
            "FrenetTangent").GetTuple(splitted_centerline.GetNumberOfPoints() -
                                      1))
        end_point_normal = list(splitted_centerline.GetPointData().GetArray(
            "FrenetNormal").GetTuple(splitted_centerline.GetNumberOfPoints() -
                                     1))
        end_point_binormal = list(
            splitted_centerline.GetPointData().GetArray("FrenetBinormal").
            GetTuple(splitted_centerline.GetNumberOfPoints() - 1))

        for i in range(splitted_centerline.GetNumberOfPoints()):
            if splitted_centerline.GetPointData().GetArray(
                    "Abscissas").GetComponent(
                        i, 0) - start_point_absc > 2 * dist_from_defect:
                end_ids.append(end_id)
                end_points.append(end_point)
                end_points_tangent.append(end_point_tangent)
                end_points_normal.append(end_point_normal)
                end_points_binormal.append(end_point_binormal)
                break
            else:
                end_id = i
                end_point_absc = splitted_centerline.GetPointData().GetArray(
                    "Abscissas").GetComponent(i, 0)
                end_point = list(splitted_centerline.GetPoints().GetPoint(i))
                end_point_tangent = list(
                    splitted_centerline.GetPointData().GetArray(
                        "FrenetTangent").GetTuple(i))
                end_point_normal = list(
                    splitted_centerline.GetPointData().GetArray(
                        "FrenetNormal").GetTuple(i))
                end_point_binormal = list(
                    splitted_centerline.GetPointData().GetArray(
                        "FrenetBinormal").GetTuple(i))

            if i == splitted_centerline.GetNumberOfPoints() - 1:
                end_ids.append(end_id)
                end_points.append(end_point)
                end_points_tangent.append(end_point_tangent)
                end_points_normal.append(end_point_normal)
                end_points_binormal.append(end_point_binormal)

    for i in range(len(end_ids)):
        print(end_ids[i], end_points[i], end_points_tangent[i],
              end_points_normal[i], end_points_binormal[i])
        surface, clipBox, clipPlane = clip_polydata_by_box(
            surface, end_points[i], end_points_tangent[i],
            end_points_normal[i], end_points_binormal[i])
        centerline, _, _ = clip_polydata_by_box(centerline, end_points[i],
                                                end_points_tangent[i],
                                                end_points_normal[i],
                                                end_points_binormal[i])

        clipBoxes.append(clipBox)
        clipPlanes.append(clipPlane)

    # connected component calculation on surface and centerline
    connectedFilter = vtk.vtkConnectivityFilter()
    # connectedFilter.SetExtractionModeToAllRegions()
    # connectedFilter.ColorRegionsOn()
    connectedFilter.SetExtractionModeToClosestPointRegion()
    connectedFilter.SetClosestPoint(defected_point)
    connectedFilter.SetInputData(surface)
    connectedFilter.Update()
    surface.DeepCopy(connectedFilter.GetOutput())

    # output
    vtpWriter = vtk.vtkXMLPolyDataWriter()
    vtpWriter.SetFileName(os.path.join(working_dir, "surface_clipped.vtp"))
    vtpWriter.SetInputData(surface)
    vtpWriter.Update()

    connectedFilter.SetInputData(centerline)
    connectedFilter.Update()
    centerline.DeepCopy(connectedFilter.GetOutput())

    vtpWriter.SetFileName(os.path.join(working_dir, "centerline_clipped.vtp"))
    vtpWriter.SetInputData(centerline)
    vtpWriter.Update()

    for i in range(len(clipBoxes)):
        writer.SetFileName(
            os.path.join(working_dir, "clip_box_" + str(i) + ".stl"))
        writer.SetInputData(clipBoxes[i])
        writer.Update()

        writer.SetFileName(
            os.path.join(working_dir, "clip_plane_" + str(i) + ".stl"))
        writer.SetInputData(clipPlanes[i])
        writer.Update()