Exemplo n.º 1
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkGenericDataObjectWriter(), 'Writing vtkGenericDataObject.',
         ('vtkGenericDataObject',), (),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
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))
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()
Exemplo n.º 4
0
def write_vtk_to_file(filename, vtkdata):
    """
    Write VTK file.

    Parameters
    ----------
    filename : str
        Name of the VTK file.

    vtkdata : VTK object
        Mesh, scalar, vector and tensor data.
    """
    writer = vtk.vtkGenericDataObjectWriter()
    writer.SetFileName(filename)
    if vtk_version < 6:
        writer.SetInput(vtkdata)

    else:
        writer.SetInputData(vtkdata)

    writer.Update()
Exemplo n.º 5
0
def write_vtk_to_file(filename, vtkdata):
    """
    Write VTK file.

    Parameters
    ----------
    filename : str
        Name of the VTK file.

    vtkdata : VTK object
        Mesh, scalar, vector and tensor data.
    """
    writer = vtk.vtkGenericDataObjectWriter()
    writer.SetFileName(filename)
    if vtk_version < 6:
        writer.SetInput(vtkdata)

    else:
        writer.SetInputData(vtkdata)

    writer.Update()
Exemplo n.º 6
0
	u = bgridreader.GetOutput() 
	GeomFilt2 = vtk.vtkGeometryFilter()
	GeomFilt2.SetInput(u)
	GeomFilt2.Update()
	y = GeomFilt2.GetOutput()

	append = vtk.vtkAppendPolyData()
	append.AddInput(x)
	append.AddInput(y)
	data = append.GetOutput()
	
	d = vtk.vtkDelaunay3D()
	d.SetInput(data)
	d.Update
	d.BoundingTriangulationOff()  
	d.SetTolerance(0.01)
	d.SetAlpha(0)
	d.Update()
	z = d.GetOutput()
	return z

if __name__ == '__main__':
	z = Create_topo()
	writer = vtk.vtkGenericDataObjectWriter()
	writer.SetFileName("test31.vtu")
	writer.SetInput(z)
	writer.Update()
	writer.Write()


Exemplo n.º 7
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()
Exemplo n.º 8
0
def apply_filters(fname, df, sf, surf_type):
    """Apply the decimation and smoothing filters using the VTK library
    and the user specified refinement factors. Decimation uses the
    vtkDecimatePro method. Smoothing uses the vtkWindowSincPolyDataFilter
    method. Both refinement processes maintain boundary vertices and
    topology. If both filters are applied, smoothing will be applied first.

    Input:
    ------
        fname: string, name of the surface vtk file that will be refined
        df: float or None, factor for target reduction in the decimation
            process. Must be between 0 and 1. If set to None, no
            decimation will be applied. A higher value indicates a
            greater reduction in the number of surface triangles.
        sf: float or None, smoothing factor for the smoothing process.
            Must be between 0 and 1. If set to None, no smoothing will
            be applied. A higher value indicates more smoothing.
        surf_type: str, 'interior' or 'exterior', used to indicate if
            the surface being refined is an interior or exterior surface.
            Only interior surfaces will have smoothing applied if
            smoothing is requested.

    Return:
    -------
        outfile: string, name of the output file from VTK after refinement
    """
    # read in surface w/ vtk as an unstructured grid
    usg = vtk.vtkUnstructuredGridReader()
    usg.SetFileName(fname)
    usg.Update()
    usgport = usg.GetOutputPort()

    # convert USG to polydata
    gf = vtk.vtkGeometryFilter()
    gf.SetInputConnection(usgport)
    gf.Update()
    pdport = gf.GetOutputPort()

    # only apply smoothing filter to interior surfaces to avoid smoothing
    # the corners of the geometry
    if sf is not None and surf_type == 'interior':
        smoothfilter = vtk.vtkWindowedSincPolyDataFilter()
        smoothfilter.SetInputConnection(pdport)
        smoothfilter.SetNumberOfIterations(20)
        smoothfilter.BoundarySmoothingOff  # don't apply to boundaries
        smoothfilter.NonManifoldSmoothingOff()  # don't collapse topology/vols
        smoothfilter.Update()
        pdport = smoothfilter.GetOutputPort()

    if df is not None:
        # setup decimate operator
        decifilter = vtk.vtkDecimatePro()
        decifilter.SetInputConnection(pdport)
        # set decimate options
        decifilter.SetTargetReduction(df)  # target reduction
        # preserve topology (splitting or hole elimination not allowed)
        decifilter.SetPreserveTopology(True)
        decifilter.SetSplitting(False)  # no mesh splitting allowed
        # no boundary vertex (edge/curve) deletion allowed
        decifilter.SetBoundaryVertexDeletion(False)
        decifilter.Update()
        pdport = decifilter.GetOutputPort()

    # convert polydata back to USG
    appendfilter = vtk.vtkAppendFilter()
    appendfilter.SetInputConnection(pdport)
    appendfilter.Update()
    usg_new = vtk.vtkUnstructuredGrid()
    usg_new.ShallowCopy(appendfilter.GetOutput())

    outfile = fname.split('.')[0] + '_refined.vtk'
    writer1 = vtk.vtkGenericDataObjectWriter()
    writer1.SetFileName(outfile)
    writer1.SetInputData(usg_new)
    writer1.Update()
    writer1.Write()

    return outfile
Exemplo n.º 9
0
    def write_data_to_vtk(self, filename, datasets, volume_normalization=True):
        """Map data to the unstructured mesh element centroids
           to create a VTK point-cloud dataset.

        Parameters
        ----------
        filename : str
            Name of the VTK file to write.
        datasets : dict
            Dictionary whose keys are the data labels
            and values are the data sets.
        volume_normalization : bool
            Whether or not to normalize the data by the
            volume of the mesh elements
        """

        import vtk
        from vtk.util import numpy_support as vtk_npsup

        if self.centroids is None:
            raise RuntimeError("No centroid information is present on this "
                               "unstructured mesh. Please load this "
                               "information from a relevant statepoint file.")

        if self.volumes is None and volume_normalization:
            raise RuntimeError("No volume data is present on this "
                               "unstructured mesh. Please load the "
                               " mesh information from a statepoint file.")

        # check that the data sets are appropriately sized
        for label, dataset in datasets.items():
            if isinstance(dataset, np.ndarray):
                assert dataset.size == self.n_elements
            else:
                assert len(dataset) == self.n_elements
            cv.check_type('label', label, str)

        # create data arrays for the cells/points
        cell_dim = 1
        vertices = vtk.vtkCellArray()
        points = vtk.vtkPoints()

        for centroid in self.centroids:
            # create a point for each centroid
            point_id = points.InsertNextPoint(centroid)
            # create a cell of type "Vertex" for each point
            cell_id = vertices.InsertNextCell(cell_dim, (point_id, ))

        # create a VTK data object
        poly_data = vtk.vtkPolyData()
        poly_data.SetPoints(points)
        poly_data.SetVerts(vertices)

        # strange VTK nuance:
        # data must be held in some container
        # until the vtk file is written
        data_holder = []

        # create VTK arrays for each of
        # the data sets
        for label, dataset in datasets.items():
            dataset = np.asarray(dataset).flatten()

            if volume_normalization:
                dataset /= self.volumes.flatten()

            array = vtk.vtkDoubleArray()
            array.SetName(label)
            array.SetNumberOfComponents(1)
            array.SetArray(vtk_npsup.numpy_to_vtk(dataset), dataset.size, True)

            data_holder.append(dataset)
            poly_data.GetPointData().AddArray(array)

        # set filename
        if not filename.endswith(".vtk"):
            filename += ".vtk"

        writer = vtk.vtkGenericDataObjectWriter()
        writer.SetFileName(filename)
        writer.SetInputData(poly_data)
        writer.Write()
Exemplo n.º 10
0
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName("fMag.0001.vtk")
reader.Update()
vtk_data = reader.GetOutput()
scalar_data = numpy_support.vtk_to_numpy(vtk_data.GetPointData().GetScalars())
mesh_shape = vtk_data.GetDimensions()
origin = vtk_data.GetOrigin()
spacing = vtk_data.GetSpacing()
scalar_data_vtk = numpy_support.numpy_to_vtk(scalar_data)
scalar_data_vtk.SetName('fMag')
vtk_obj = vtk.vtkStructuredPoints()
vtk_obj.SetDimensions(mesh_shape)
vtk_obj.SetOrigin(origin)
vtk_obj.SetSpacing(spacing)
vtk_obj.GetPointData().SetScalars(scalar_data_vtk)
writer = vtk.vtkGenericDataObjectWriter()
writer.SetFileName("test_out.vtk")
writer.SetInputDataObject(vtk_obj)
writer.Update()
writer.Write()  # returns 1 on success, 0 on failure

### STRUCTURED_POINTS - VECTORS ###
reader = vtk.vtkStructuredPointsReader()
reader.SetFileName("u.0001.vtk")
reader.Update()
vtk_data = reader.GetOutput()
# return an n x 3 array of vectors
vector_data = numpy_support.vtk_to_numpy(vtk_data.GetPointData().GetVectors())
mesh_shape = vtk_data.GetDimensions()
origin = vtk_data.GetOrigin()
spacing = vtk_data.GetSpacing()
Exemplo n.º 11
0
def main():
    # input file (vtk isosurface geom)
    fname = sys.argv[1]  # unstructured grid vtk file

    # read unstructured grid
    usg = vtk.vtkUnstructuredGridReader()
    usg.SetFileName(fname)
    usg.Update()
    usgport = usg.GetOutputPort()

    # convert USG to polydata
    gf = vtk.vtkGeometryFilter()
    gf.SetInputConnection(usgport)
    gf.Update()
    pdport = gf.GetOutputPort()

    # setup decimate operator
    deci = vtk.vtkDecimatePro()
    deci.SetInputConnection(pdport)

    # set decimate options
    target = 0.9
    deci.SetTargetReduction(target)  # target reduction
    deci.SetPreserveTopology(
        True)  # preserve topology (splitting or hole elimination not allowed)
    deci.SetSplitting(False)  # no mesh splitting allowed
    deci.SetBoundaryVertexDeletion(
        False)  # no boundary vertex (eddge/curve) deletion allowed
    deci.Update()
    deciport = deci.GetOutputPort()

    # convert polydata back to USG
    appendfilter = vtk.vtkAppendFilter()
    appendfilter.SetInputConnection(deciport)
    appendfilter.Update()
    usg_new = vtk.vtkUnstructuredGrid()
    usg_new.ShallowCopy(appendfilter.GetOutput())

    # write file (USG) - needed for pymoab
    outfile = fname.split('.')[0] + '-decimate-out-usg.vtk'
    writer1 = vtk.vtkGenericDataObjectWriter()
    writer1.SetFileName(outfile)
    writer1.SetInputData(usg_new)
    writer1.Update()
    writer1.Write()

    # write out polydata too
    outpoly = fname.split('.')[0] + '-decimate-out-poly.vtk'
    writer2 = vtk.vtkGenericDataObjectWriter()
    writer2.SetFileName(outpoly)
    writer2.SetInputConnection(deciport)
    writer2.Update()
    writer2.Write()

    # try reading file in w/ pymoab again
    mb = core.Core()
    mb.load_file(outfile)
    rs = mb.get_root_set()
    # get entities w/ dim=2 (should be facets)
    all_facets = mb.get_entities_by_dimension(rs, 2)
    print(all_facets)
    print(len(all_facets))
    # confirm facet type (should by tris, not polygons)
    facet_type = mb.type_from_handle(all_facets[0])
    print(facet_type)
    tris1 = mb.get_entities_by_type(rs, facet_type)
    tris2 = mb.get_entities_by_type(rs, types.MBTRI)
    polys = mb.get_entities_by_type(rs, types.MBPOLYGON)
    print(tris1, len(tris1))
    print(tris2, len(tris2))
    print(polys, len(polys))