def jaccard3D_pd(pd1,pd2):
"""
computes the jaccard distance error for two polydata objects
returns (error) float
"""
union = vtk.vtkBooleanOperationPolyDataFilter()
union.SetOperationToUnion()
union.SetInputData(0,pd1)
union.SetInputData(1,pd2)
union.Update()
u = union.GetOutput()
massUnion = vtk.vtkMassProperties()
massUnion.SetInputData(u)
intersection = vtk.vtkBooleanOperationPolyDataFilter()
intersection.SetOperationToIntersection()
intersection.SetInputData(0,pd1)
intersection.SetInputData(1,pd2)
intersection.Update()
i = intersection.GetOutput()
massIntersection = vtk.vtkMassProperties()
massIntersection.SetInputData(i)
return 1 - massIntersection.GetVolume()/massUnion.GetVolume()
def obj(x,sF,devF,R,sv,mv,tv,material,spatial,rc,sc):
nF = np.dot(R,x[0]*sF)+np.dot(R,x[1]*devF)
#Make a copy of material configuration and deform this with nF
nm = vtk.vtkPolyData()
nm.DeepCopy(material)
pcoords = vtk.vtkFloatArray()
pcoords.SetNumberOfComponents(3)
pcoords.SetNumberOfTuples(nm.GetNumberOfPoints())
for i in xrange(nm.GetNumberOfPoints()):
p = [0.,0.,0.]
nm.GetPoint(i,p)
p = np.dot(nF,p-rc)
p.flatten()
pcoords.SetTuple3(i,p[0]+sc[0],p[1]+sc[1],p[2]+sc[2])
points = vtk.vtkPoints()
points.SetData(pcoords)
nm.SetPoints(points)
nm.GetPoints().Modified()
#calculate both the intersection and the union of the two polydata
intersect = vtk.vtkBooleanOperationPolyDataFilter()
intersect.SetOperation(1)
intersect.SetInputData(0,nm)
intersect.SetInputData(1,spatial)
intersect.Update()
union = vtk.vtkBooleanOperationPolyDataFilter()
union.SetOperation(0)
union.SetInputData(0,nm)
union.SetInputData(1,spatial)
union.Update()
unionmass = vtk.vtkMassProperties()
unionmass.SetInputConnection(union.GetOutputPort())
vol_union = unionmass.GetVolume()
if intersect.GetOutput().GetNumberOfPoints() > 0:
intmass = vtk.vtkMassProperties()
intmass.SetInputConnection(intersect.GetOutputPort())
vol_int = intmass.GetVolume()
else:
#penalize with distance between centroids
w = sc.T-np.dot(nF,rc.T)
c = np.linalg.norm(w)
vol_int = c*vol_union
diff = max([abs(sv-vol_int),abs(sv-vol_union)])
return diff
def obj(x, sF, devF, R, sv, mv, tv, material, spatial, rc, sc):
nF = np.dot(R, x[0] * sF) + np.dot(R, x[1] * devF)
#Make a copy of material configuration and deform this with nF
nm = vtk.vtkPolyData()
nm.DeepCopy(material)
pcoords = vtk.vtkFloatArray()
pcoords.SetNumberOfComponents(3)
pcoords.SetNumberOfTuples(nm.GetNumberOfPoints())
for i in xrange(nm.GetNumberOfPoints()):
p = [0., 0., 0.]
nm.GetPoint(i, p)
p = np.dot(nF, p - rc)
p.flatten()
pcoords.SetTuple3(i, p[0] + sc[0], p[1] + sc[1], p[2] + sc[2])
points = vtk.vtkPoints()
points.SetData(pcoords)
nm.SetPoints(points)
nm.GetPoints().Modified()
#calculate both the intersection and the union of the two polydata
intersect = vtk.vtkBooleanOperationPolyDataFilter()
intersect.SetOperation(1)
intersect.SetInputData(0, nm)
intersect.SetInputData(1, spatial)
intersect.Update()
union = vtk.vtkBooleanOperationPolyDataFilter()
union.SetOperation(0)
union.SetInputData(0, nm)
union.SetInputData(1, spatial)
union.Update()
unionmass = vtk.vtkMassProperties()
unionmass.SetInputConnection(union.GetOutputPort())
vol_union = unionmass.GetVolume()
if intersect.GetOutput().GetNumberOfPoints() > 0:
intmass = vtk.vtkMassProperties()
intmass.SetInputConnection(intersect.GetOutputPort())
vol_int = intmass.GetVolume()
else:
#penalize with distance between centroids
w = sc.T - np.dot(nF, rc.T)
c = np.linalg.norm(w)
vol_int = c * vol_union
diff = max([abs(sv - vol_int), abs(sv - vol_union)])
return diff
def computeDiceDistance(mesh1Path, mesh2Path):
if mesh1Path == mesh2Path:
return 1.
#Reading
reader1 = vtkPolyDataReader()
reader1.SetFileName(mesh1Path)
reader1.Update()
reader2 = vtkPolyDataReader()
reader2.SetFileName(mesh2Path)
reader2.Update()
#First volume
mass1 = vtkMassProperties()
mass1.SetInputConnection(reader1.GetOutputPort())
mass1.Update()
volume1 = mass1.GetVolume()
#Second volume
mass2 = vtkMassProperties()
mass2.SetInputConnection(reader2.GetOutputPort())
mass2.Update()
volume2 = mass2.GetVolume()
#Intersection
# intersectionOperation = vtkIntersectionPolyDataFilter()
intersectionOperation = vtkBooleanOperationPolyDataFilter()
intersectionOperation.SetOperationToIntersection()
intersectionOperation.SetInputConnection(0, reader1.GetOutputPort())
intersectionOperation.SetInputConnection(1, reader2.GetOutputPort())
intersectionOperation.Update()
#Volume of the intersection
massInter = vtkMassProperties()
massInter.SetInputConnection(intersectionOperation.GetOutputPort())
massInter.Update()
intersectionVolume = massInter.GetVolume()
dice = 2 * intersectionVolume / (volume1 + volume2)
assert 0 <= dice <= 1, "Warning : suspicious behavior detected in the intersection filter."
return dice
def boolean_vtk_polydata(poly1, poly2, keyword):
"""
Apply VTK boolean operation on two VTK PolyData
Args:
poly1: first VTK PolyData
poly2: second VTK PolyData
keywords: str union, intersection, difference
Returns:
poly: resulted VTK PolyData
"""
boolean = vtk.vtkBooleanOperationPolyDataFilter()
if keyword == "union":
boolean.SetOperationToUnion()
elif keyword == "intersection":
boolean.SetOperationToIntersection()
elif keyword == "difference":
boolean.SetOperationToDifference()
else:
raise ValueError("Keyword option is not supporte.")
boolean.SetInputData(0, poly1)
boolean.SetInputData(1, poly2)
boolean.Update()
return boolean.GetOutput()
def BooleanCut(self, cut, tolerance=1E-5, inplace=False):
"""
Performs a Boolean cut using another mesh.
Parameters
----------
cut : vtkInterface.PolyData
Mesh making the cut
inplace : bool, optional
Updates mesh in-place while returning nothing.
Returns
-------
mesh : vtkInterface.PolyData
The cut mesh when inplace=False
"""
bfilter = vtk.vtkBooleanOperationPolyDataFilter()
bfilter.SetOperationToIntersection()
bfilter.SetInputData(1, cut)
bfilter.SetInputData(0, self)
bfilter.ReorientDifferenceCellsOff()
bfilter.SetTolerance(tolerance)
bfilter.Update()
if inplace:
self.Overwrite(bfilter.GetOutput())
else:
return PolyData(bfilter.GetOutput())
def booleanOperation(actor1, actor2, operation='plus', c=None, alpha=1,
wire=False, bc=None, legend=None, texture=None):
'''Volumetric union, intersection and subtraction of surfaces.
[**Example**](https://github.com/marcomusy/vtkplotter/blob/master/examples/basic/boolean.py)
'''
try:
bf = vtk.vtkBooleanOperationPolyDataFilter()
except AttributeError:
vc.printc('Boolean operation only possible for vtk version >= 8', c='r')
return None
poly1 = actor1.polydata(True)
poly2 = actor2.polydata(True)
if operation.lower() == 'plus':
bf.SetOperationToUnion()
elif operation.lower() == 'intersect':
bf.SetOperationToIntersection()
elif operation.lower() == 'minus':
bf.SetOperationToDifference()
bf.ReorientDifferenceCellsOn()
bf.SetInputData(0, poly1)
bf.SetInputData(1, poly2)
bf.Update()
actor = Actor(bf.GetOutput(), c, alpha, wire, bc, legend, texture)
return actor
def run(self, inputModel1, inputModel2, outputModel, operationIndex):
"""
Run the actual algorithm
"""
if not self.isValidInputOutputData(inputModel1, inputModel2, outputModel):
slicer.util.errorDisplay('Input volume is the same as output volume. Choose a different output volume.')
return False
logging.info('Processing started')
triangleFilter1 = vtk.vtkTriangleFilter()
triangleFilter1.SetInputData(inputModel1.GetPolyData())
triangleFilter1.Update()
triangleFilter2 = vtk.vtkTriangleFilter()
triangleFilter2.SetInputData(inputModel2.GetPolyData())
triangleFilter2.Update()
booleanFilter = vtk.vtkBooleanOperationPolyDataFilter()
if operationIndex == 0:
booleanFilter.SetOperationToIntersection()
elif operationIndex == 1:
booleanFilter.SetOperationToDifference()
elif operationIndex == 2:
booleanFilter.SetOperationToUnion()
booleanFilter.SetInputData(0, triangleFilter1.GetOutput())
booleanFilter.SetInputData(1, triangleFilter2.GetOutput())
booleanFilter.Update()
outputModel.SetAndObservePolyData(booleanFilter.GetOutput())
outputModel.CreateDefaultDisplayNodes()
logging.info('Processing completed')
return True
def BooleanUnion(self, mesh, inplace=False):
"""
Returns the mesh in common between the current mesh and the input mesh.
Parameters
----------
mesh : vtkInterface.PolyData
The mesh to perform a union against.
inplace : bool, optional
Updates mesh in-place while returning nothing.
Returns
-------
union : vtkInterface.PolyData
The union mesh when inplace=False.
"""
bfilter = vtk.vtkBooleanOperationPolyDataFilter()
bfilter.SetOperationToUnion()
bfilter.SetInputData(1, mesh)
bfilter.SetInputData(0, self)
bfilter.ReorientDifferenceCellsOff()
bfilter.Update()
if inplace:
self.Overwrite(vtkappend.GetOutput())
else:
return PolyData(vtkappend.GetOutput())
def booleanOperation(actor1,
actor2,
operation='plus',
c=None,
alpha=1,
wire=False,
bc=None,
edges=False,
legend=None,
texture=None):
'''Volumetric union, intersection and subtraction of surfaces'''
try:
bf = vtk.vtkBooleanOperationPolyDataFilter()
except AttributeError:
vio.printc('Boolean operation only possible for vtk version >= 8', 'r')
return None
poly1 = vu.polydata(actor1, True)
poly2 = vu.polydata(actor2, True)
if operation.lower() == 'plus':
bf.SetOperationToUnion()
elif operation.lower() == 'intersect':
bf.SetOperationToIntersection()
elif operation.lower() == 'minus':
bf.SetOperationToDifference()
bf.ReorientDifferenceCellsOn()
if vu.vtkMV:
bf.SetInputData(0, poly1)
bf.SetInputData(1, poly2)
else:
bf.SetInputConnection(0, poly1.GetProducerPort())
bf.SetInputConnection(1, poly2.GetProducerPort())
bf.Update()
actor = vu.makeActor(bf.GetOutput(), c, alpha, wire, bc, edges, legend,
texture)
return actor
def booldifference(surface1, surface2):
"""Create surface that is the difference between the two input surfaces."""
boolfilter = vtk.vtkBooleanOperationPolyDataFilter()
boolfilter.SetOperationToDifference()
boolfilter.SetInput(0, surface1)
boolfilter.SetInput(1, surface2)
boolfilter.Update()
return boolfilter.GetOutput()
def booldifference(surface1, surface2):
"""Create surface that is the difference between the two input surfaces."""
boolfilter = vtk.vtkBooleanOperationPolyDataFilter()
boolfilter.SetOperationToDifference()
boolfilter.SetInput(0, surface1)
boolfilter.SetInput(1, surface2)
boolfilter.Update()
return boolfilter.GetOutput()
def _calculateVolumeByBoolean(vtkDataSet1,vtkDataSet2,iV):
"""
Function to calculate the volumes of a cell intersecting a mesh.
Uses a boolean polydata filter to calculate the intersection,
a general implementation but slow.
"""
import numpy as np, SimPEG as simpeg, vtk
import vtk.util.numpy_support as npsup
from telluricpy import vtkTools
# Triangulate polygon and calc normals
baseC = vtkTools.dataset.getCell2vtp(vtkDataSet2,iV)
baseVol = vtkTools.polydata.calculateVolume(baseC)
# print iV, baseVol
# Extract cells from the first mesh that intersect the base cell
extractCells = vtkTools.extraction.extractDataSetWithPolygon(vtkDataSet1,baseC,extInside=True,extBoundaryCells=True,extractBounds=True)
extInd = npsup.vtk_to_numpy(extractCells.GetCellData().GetArray('id'))
# print extInd
# Assert if there are no cells cutv
assert extractCells.GetNumberOfCells() > 0, 'No cells in the clip, cell id {:d}'.format(iV)
# Calculate the volumes of the clipped cells and insert to the matrix
volL = []
for nrCC,iR in enumerate(extInd):
tempCell = vtkTools.dataset.thresholdCellId2vtp(extractCells,iR)
# Find the intersection of the 2 cells
boolFilt = vtk.vtkBooleanOperationPolyDataFilter()
boolFilt.SetInputData(0,tempCell)
boolFilt.SetInputData(1,baseC)
boolFilt.SetOperationToIntersection()
# If they intersect, calculate the volumes
if boolFilt.GetOutput().GetNumberOfPoints() > 0:
cleanInt = vtkTools.polydata.cleanPolyData(boolFilt.GetOutputPort())
del3dFilt = vtk.vtkDelaunay3D()
del3dFilt.SetInputData(cleanInt)
del3dFilt.Update()
# Get the output
intC = vtkTools.extraction.vtu2vtp(del3dFilt.GetOutput())
intVol = vtkTools.polydata.calculateVolume(tempCell)
# Calculate the volume
volVal = intVol/baseVol
# print iR, intVol, volVal
# Insert the value
if volVal > 0.0:
volL.append(volVal)
return extInd,np.array(volL)
def boolean_stl(input_file1, input_file2, output_file, transform_file, operation, visualize, overwrite, func):
if os.path.isfile(output_file) and not overwrite:
result = input('File \"{}\" already exists. Overwrite? [y/n]: '.format(output_file))
if result.lower() not in ['y', 'yes']:
print('Not overwriting. Exiting...')
os.sys.exit()
im1 = vtk.vtkSTLReader()
im1.SetFileName(input_file1)
im1.Update()
im1 = cleanPolyData( im1.GetOutput() )
im2 = vtk.vtkSTLReader()
im2.SetFileName(input_file2)
im2.Update()
im2 = cleanPolyData( im2.GetOutput() )
im2 = applyTransform(transform_file, im2)
if (visualize):
mat4x4 = visualize_actors( im2.GetOutputPort(), im1.GetOutputPort() )
else:
mat4x4 = vtk.vtkMatrix4x4()
transform = vtk.vtkTransform()
transform.SetMatrix(mat4x4)
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetInputConnection( im2.GetOutputPort() )
transformFilter.SetTransform( transform )
transformFilter.Update()
booleanOperation = vtk.vtkBooleanOperationPolyDataFilter()
booleanOperation.SetInputData( 0, im1.GetOutput() )
booleanOperation.SetInputData( 1, transformFilter.GetOutput() )
if "union" in operation:
booleanOperation.SetOperationToUnion()
elif "intersection" in operation:
booleanOperation.SetOperationToIntersection()
elif "difference" in operation:
booleanOperation.SetOperationToDifference()
else:
raise ValueError('Invalid boolean operation: ' + operation)
booleanOperation.Update()
write_stl( booleanOperation.GetOutputPort(), output_file, vtk.vtkMatrix4x4() )
def getBooleanOperationOnPolys(poly1, poly2, operation='union'):
if operation == 'union':
opVTK = vtk.VTK_UNION
elif operation == 'intersection':
opVTK = vtk.VTK_INTERSECTION
elif operation == 'difference':
opVTK = vtk.VTK_DIFFERENCE
else:
raise Exception(
"getBooleanOperationOnPolys: unknown boolean operation type (known types are: 'union', 'intersection', and 'difference')"
)
boolFilter = vtk.vtkBooleanOperationPolyDataFilter()
boolFilter.SetOperation(opVTK)
boolFilter.SetInputConnection(0, poly1.GetProducerPort())
boolFilter.SetInputConnection(1, poly2.GetProducerPort())
boolFilter.Update()
return boolFilter.GetOutput()
def apply_boolean_operation(polydata1, polydata2, operation="difference"):
boolean_operator = vtk.vtkBooleanOperationPolyDataFilter()
if operation == "union":
boolean_operator.SetOperationToUnion()
elif operation == "intersection":
boolean_operator.SetOperationToIntersection()
elif operation == "difference":
boolean_operator.SetOperationToDifference()
else:
print("Unknow operation")
sys.exit(0)
boolean_operator.SetInputData(0, polydata1)
boolean_operator.SetInputData(1, polydata2)
boolean_operator.Update()
return boolean_operator.GetOutput()
def _calculateVolumeByBoolean(vtkDataSet1,vtkDataSet2,iV):
"""
Function to calculate the volumes of a cell intersecting a mesh.
Uses a boolean polydata filter to calculate the intersection,
a general implementation but slow.
"""
# Triangulate polygon and calc normals
baseC = vtkTools.dataset.getCell2vtp(vtkDataSet2,iV)
baseVol = vtkTools.polydata.calculateVolume(baseC)
# print iV, baseVol
# Extract cells from the first mesh that intersect the base cell
extractCells = vtkTools.extraction.extractDataSetWithPolygon(vtkDataSet1,baseC,extInside=True,extBoundaryCells=True,extractBounds=True)
extInd = npsup.vtk_to_numpy(extractCells.GetCellData().GetArray('id'))
# print extInd
# Assert if there are no cells cutv
assert extractCells.GetNumberOfCells() > 0, 'No cells in the clip, cell id {:d}'.format(iV)
# Calculate the volumes of the clipped cells and insert to the matrix
volL = []
for nrCC,iR in enumerate(extInd):
tempCell = vtkTools.dataset.thresholdCellId2vtp(extractCells,iR)
# Find the intersection of the 2 cells
boolFilt = vtk.vtkBooleanOperationPolyDataFilter()
boolFilt.SetInputData(0,tempCell)
boolFilt.SetInputData(1,baseC)
boolFilt.SetOperationToIntersection()
# If they intersect, calculate the volumes
if boolFilt.GetOutput().GetNumberOfPoints() > 0:
cleanInt = vtkTools.polydata.cleanPolyData(boolFilt.GetOutputPort())
del3dFilt = vtk.vtkDelaunay3D()
del3dFilt.SetInputData(cleanInt)
del3dFilt.Update()
# Get the output
intC = vtkTools.extraction.vtu2vtp(del3dFilt.GetOutput())
intVol = vtkTools.polydata.calculateVolume(tempCell)
# Calculate the volume
volVal = intVol/baseVol
# print iR, intVol, volVal
# Insert the value
if volVal > 0.0:
volL.append(volVal)
return extInd,np.array(volL)
def polydataBoolean(self, polyData1, polyData2, operation, triangleFilter=True, loop=False, clean=True):
# Subtract/add polyData2 from polyData1
if (not polyData1) or (not polyData2):
return polyData1
booleanFilter = vtk.vtkBooleanOperationPolyDataFilter()
if loop:
booleanFilter = vtk.vtkLoopBooleanPolyDataFilter()
if operation=="difference" or operation=="subtract":
booleanFilter.SetOperationToDifference()
elif operation=="union" or operation=="addition":
booleanFilter.SetOperationToUnion()
else:
return None
if triangleFilter:
triangleFilter1 = vtk.vtkTriangleFilter()
triangleFilter1.SetInputData(polyData1)
triangleFilter1.Update()
triangleFilter2 = vtk.vtkTriangleFilter()
triangleFilter2.SetInputData(polyData2)
triangleFilter2.Update()
booleanFilter.SetInputData(0, triangleFilter1.GetOutput())
booleanFilter.SetInputData(1, triangleFilter2.GetOutput())
else:
booleanFilter.SetInputData(0, polyData1)
booleanFilter.SetInputData(1, polyData2)
booleanFilter.Update()
if clean:
cleanFilter = vtk.vtkCleanPolyData()
cleanFilter.SetInputData(booleanFilter.GetOutput())
cleanFilter.PointMergingOn()
cleanFilter.Update()
return cleanFilter.GetOutput()
else:
return booleanFilter.GetOutput()
def Union(gONE,gTWO):
err0 = ErrorObserver()
bOp = vtk.vtkBooleanOperationPolyDataFilter()
bOp.AddObserver('ErrorEvent', err0)
bOp.SetOperationToUnion()
# bOp.SetOperationToIntersection()
# bOp.SetOperationToDifference()
if vtk.VTK_MAJOR_VERSION <= 5:
bOp.SetInputConnection( 0, gONE.GetProducerPort() )
bOp.SetInputConnection( 1, gTWO.GetProducerPort() )
else:
bOp.SetInputData( 0, gONE.GetOutput() )
bOp.SetInputData( 1, gTWO.GetOutput() )
bOp.Update()
if err0.ErrorOccurred():
return None
return bOp
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No Surface.')
if self.Surface2 == None:
self.PrintError('Error: No Surface2.')
booleanOperationFilter = vtk.vtkBooleanOperationPolyDataFilter()
booleanOperationFilter.SetInputData(0, self.Surface)
booleanOperationFilter.SetInputData(1, self.Surface2)
if self.Operation == 'union':
booleanOperationFilter.SetOperationToUnion()
elif self.Operation == 'intersection':
booleanOperationFilter.SetOperationToIntersection()
elif self.Operation == 'difference':
booleanOperationFilter.SetOperationToDifference()
booleanOperationFilter.SetTolerance(self.Tolerance)
booleanOperationFilter.Update()
self.Surface = booleanOperationFilter.GetOutput()
def Execute(self):
if self.Surface == None:
self.PrintError('Error: No Surface.')
if self.Surface2 == None:
self.PrintError('Error: No Surface2.')
booleanOperationFilter = vtk.vtkBooleanOperationPolyDataFilter()
booleanOperationFilter.SetInputData(0,self.Surface)
booleanOperationFilter.SetInputData(1,self.Surface2)
if self.Operation == 'union':
booleanOperationFilter.SetOperationToUnion()
elif self.Operation == 'intersection':
booleanOperationFilter.SetOperationToIntersection()
elif self.Operation == 'difference':
booleanOperationFilter.SetOperationToDifference()
booleanOperationFilter.SetTolerance(self.Tolerance)
booleanOperationFilter.Update()
self.Surface = booleanOperationFilter.GetOutput()
def BooleanCut(self, cut):
"""
Performs a Boolean cut using another mesh.
Parameters
----------
cut : vtkInterface.PolyData
Mesh making the cut
Returns
-------
mesh : vtkInterface.PolyData
The cut mesh
"""
bfilter = vtk.vtkBooleanOperationPolyDataFilter()
bfilter.SetOperationToIntersection()
bfilter.SetInputData(1, cut)
bfilter.SetInputData(0, self)
bfilter.ReorientDifferenceCellsOff()
bfilter.Update()
return PolyData(bfilter.GetOutput())
def BooleanUnion(self, mesh):
"""
Returns the mesh in common between the current mesh and the input mesh.
Parameters
----------
mesh : vtkInterface.PolyData
The mesh to perform a union against.
Returns
-------
union : vtkInterface.PolyData
The union mesh
"""
bfilter = vtk.vtkBooleanOperationPolyDataFilter()
bfilter.SetOperationToUnion()
bfilter.SetInputData(1, mesh)
bfilter.SetInputData(0, self)
bfilter.ReorientDifferenceCellsOff()
bfilter.Update()
return PolyData(bfilter.GetOutput())
def two_polydata_dice(polydata_0, polydata_1):
"""
Calculates the DICE score for two polydata.
Will probably struggle with complex topologies,
but should be fine for vaguely spherical shape.
This function uses vtk.vtkMassProperties() so does not
convert polydata to image data
:param polydata_0: vtkPolyData representing a 3D mesh
:param polydata_1: vtkPolyData representing a 3D mesh
:return dice: The DICE score
:return volume_0: The enclosed volume of polydata_0
:return volume_1: The enclosed volume of polydata_1
:return volume_01: The enclosed volume of the intersection
"""
measured_polydata = vtkMassProperties()
measured_polydata.SetInputData(polydata_0)
volume_0 = measured_polydata.GetVolume()
measured_polydata.SetInputData(polydata_1)
volume_1 = measured_polydata.GetVolume()
intersector = vtkBooleanOperationPolyDataFilter()
intersector.SetOperationToIntersection()
intersector.SetInputData(0, polydata_0)
intersector.SetInputData(1, polydata_1)
if check_overlapping_bounds(polydata_0, polydata_1):
intersector.Update()
intersection = intersector.GetOutput()
measured_polydata.SetInputData(intersection)
volume_01 = measured_polydata.GetVolume()
else:
volume_01 = 0.0
dice = 0.0
dice = 2 * volume_01 / (volume_0 + volume_1)
return dice, volume_0, volume_1, volume_01
def __init__(self, raysect_csg_primitive):
# need to get the geometry source for each primitive
self.raysect_primitive = raysect_csg_primitive
primitive_a = map_raysect_element_to_vtk(
raysect_csg_primitive.primitive_a)
source_a_tris = vtk.vtkTriangleFilter()
source_a_tris.SetInputData(primitive_a.transform_filter.GetOutput())
self.source_a_tri_filter = source_a_tris
primitive_b = map_raysect_element_to_vtk(
raysect_csg_primitive.primitive_b)
source_b_tris = vtk.vtkTriangleFilter()
source_b_tris.SetInputData(primitive_b.transform_filter.GetOutput())
self.source_b_tri_filter = source_b_tris
boolean_operation = vtk.vtkBooleanOperationPolyDataFilter()
self.boolean_operation = boolean_operation
self._set_boolean_operation()
boolean_operation.SetInputConnection(0, source_a_tris.GetOutputPort())
boolean_operation.SetInputConnection(1, source_b_tris.GetOutputPort())
boolean_operation.Update()
transform_filter = vtk.vtkTransformPolyDataFilter()
transform_filter.SetInputConnection(boolean_operation.GetOutputPort())
transform_filter.SetTransform(
convert_to_vtk_transform(raysect_csg_primitive.transform))
transform_filter.Update()
self.transform_filter = transform_filter
booleanOperationMapper = vtk.vtkPolyDataMapper()
booleanOperationMapper.SetInputConnection(
transform_filter.GetOutputPort())
booleanOperationMapper.ScalarVisibilityOff()
self.mapper = booleanOperationMapper
booleanOperationActor = vtk.vtkActor()
booleanOperationActor.SetMapper(booleanOperationMapper)
self.actor = booleanOperationActor
def vtk_bool_operation(obj_1, obj_2, operation='intersection'):
# Triangles
tri_1 = vtk.vtkTriangleFilter()
tri_1.SetInputConnection(obj_1.GetOutputPort())
tri_2 = vtk.vtkTriangleFilter()
tri_2.SetInputConnection(obj_2.GetOutputPort())
# Create an intersection operation
boolean_operation = vtk.vtkBooleanOperationPolyDataFilter()
if operation is 'union':
boolean_operation.SetOperationToUnion()
elif operation is 'difference':
boolean_operation.SetOperationToDifference()
else:
boolean_operation.SetOperationToIntersection()
boolean_operation.SetInputConnection(0, tri_1.GetOutputPort())
boolean_operation.SetInputConnection(1, tri_2.GetOutputPort())
boolean_operation.Update()
print('[ OK ] %s was already performed' % operation.title())
return boolean_operation
input1Actor.SetMapper(input1Mapper)
input1Actor.GetProperty().SetColor(1, 0, 0)
input1Actor.SetPosition(input1.GetBounds()[1] - input1.GetBounds()[0], 0, 0)
input2Mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
input2Mapper.SetInputConnection(input2.GetProducerPort())
else:
input2Mapper.SetInputData(input2)
input2Mapper.ScalarVisibilityOff()
input2Actor = vtk.vtkActor()
input2Actor.SetMapper(input2Mapper)
input2Actor.GetProperty().SetColor(0, 1, 0)
input2Actor.SetPosition(-(input2.GetBounds()[1] - input2.GetBounds()[0]), 0, 0)
booleanOperation = vtk.vtkBooleanOperationPolyDataFilter()
#booleanOperation.SetOperationToUnion()
booleanOperation.SetOperationToIntersection()
#booleanOperation.SetOperationToDifference()
if vtk.VTK_MAJOR_VERSION <= 5:
booleanOperation.SetInputConnection(0, sphere1Tri.GetOutputPort())
booleanOperation.SetInputConnection(1, sphere2Tri.GetOutputPort())
else:
booleanOperation.SetInputData(0, sphere1Tri)
booleanOperation.SetInputData(1, sphere2Tri)
booleanOperation.Update()
booleanOperationMapper = vtk.vtkPolyDataMapper()
booleanOperationMapper.SetInputConnection(booleanOperation.GetOutputPort())
booleanOperationMapper.ScalarVisibilityOff()
def computeContactPoints(mesh):
print "Computing contact points..."
segments = mesh.segments
components = mesh.components
adjacency_info_2 = collections.defaultdict(dict)
contact_slots_2 = collections.defaultdict(dict)
for seg in components.keys():
contact_slots_2[seg] = collections.defaultdict(list)
adjacency_info_2[seg] = collections.defaultdict(int)
polys = {}
for seg in components.keys():
for c in components[seg]:
if not c.segmentId in polys:
polys[c.segmentId] = []
pts, tris = arrayToPolydata(c.vertices, c.faces)
poly = vtk.vtkPolyData()
poly.SetPoints(pts)
poly.SetPolys(tris)
poly.Update()
polys[c.segmentId].append(poly)
s_keys = polys.keys()
vertices = vtk.vtkCellArray()
points = vtk.vtkPoints()
for x in range(len(s_keys) - 1):
for y in range(x+1, len(s_keys)):
for id_x, c_x in enumerate(polys[s_keys[x]]):
for id_y, c_y in enumerate(polys[s_keys[y]]):
b = vtk.vtkBooleanOperationPolyDataFilter()
b.SetOperationToIntersection()
b.SetTolerance(0.1)
b.SetInput(0, c_x)
b.SetInput(1, c_y)
b.Update()
p = b.GetOutput(1).GetPoints()
if (p.GetNumberOfPoints() > 0):
print "Found %d contact points between segment #%d-%d and segment #%d-%d" % (p.GetNumberOfPoints(), s_keys[x], id_x, s_keys[y], id_y)
for k in range(p.GetNumberOfPoints()):
id = points.InsertNextPoint(p.GetPoint(k))
vertices.InsertNextCell(1)
vertices.InsertCellPoint(id)
res_points = numpy.array(polydataToArray(p))
d_x = dict()
d_x['points'] = res_points
d_x['seg'] = s_keys[y]
d_x['comp'] = id_y
contact_slots_2[s_keys[x]][id_x].append(d_x)
d_y = dict()
d_y['points'] = res_points
d_y['seg'] = s_keys[x]
d_y['comp'] = id_x
contact_slots_2[s_keys[y]][id_y].append(d_y)
adjacency_info_2[s_keys[x]][s_keys[y]] += 1
adjacency_info_2[s_keys[y]][s_keys[x]] += 1
points.Modified()
vertices.Modified()
print "Adjacency info"
for k in s_keys:
s = "\t %d | " % k
for k_2 in s_keys:
s += " %d |" % (adjacency_info_2[k][k_2])
print s
for s_k, s_v in contact_slots_2.items():
print "Segment %d" % s_k
for c_k, c_v in s_v.items():
print "\t Component %d" % c_k
for data in c_v:
print "\t\t Seg: %d Comp: %d Points: %d" % (data['seg'], data['comp'], len(data['points']))
return adjacency_info_2, contact_slots_2
def test_vtk_example_with_my_cylinder(self):
# sphereSource1 = vtk.vtkSphereSource()
# sphereSource1.SetCenter(0.25, 0, 0)
# sphereSource1.Update()
# input1 = sphereSource1.GetOutput()
input1 = teigen.tb_vtk.get_cylinder([0.25, 0, -.5], 0.9, 0.7,
[0.0, .0, .0])
sphere1tri = vtk.vtkTriangleFilter()
sphere1tri.SetInputData(input1)
# sphereSource2 = vtk.vtkSphereSource()
# sphereSource2 = vtk.vtkCylinderSource()
# sphereSource2.Update()
# input2 = sphereSource2.GetOutput()
direction = np.asarray([1., 1., 1.])
direction /= np.linalg.norm(direction)
input2 = teigen.tb_vtk.get_cylinder([0, .1, 0], 0.7, 0.5, direction)
sphere2Tri = vtk.vtkTriangleFilter()
sphere2Tri.SetInputData(input2)
input1mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
input1mapper.SetInputConnection(input1.GetProducerPort())
else:
input1mapper.SetInputData(input1)
input1mapper.ScalarVisibilityOff()
input1Actor = vtk.vtkActor()
input1Actor.SetMapper(input1mapper)
input1Actor.GetProperty().SetColor(1, 0, 0)
input1Actor.SetPosition(input1.GetBounds()[1] - input1.GetBounds()[0],
0, 0)
input2Mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
input2Mapper.SetInputConnection(input2.GetProducerPort())
else:
input2Mapper.SetInputData(input2)
input2Mapper.ScalarVisibilityOff()
input2Actor = vtk.vtkActor()
input2Actor.SetMapper(input2Mapper)
input2Actor.GetProperty().SetColor(0, 1, 0)
input2Actor.SetPosition(
-(input2.GetBounds()[1] - input2.GetBounds()[0]), 0, 0)
booleanOperation = vtk.vtkBooleanOperationPolyDataFilter()
# booleanOperation.SetOperationToUnion()
# booleanOperation.SetOperationToIntersection()
booleanOperation.SetOperationToDifference()
if vtk.VTK_MAJOR_VERSION <= 5:
booleanOperation.SetInputConnection(0, sphere1tri.GetOutputPort())
booleanOperation.SetInputConnection(1, sphere2Tri.GetOutputPort())
else:
sphere1tri.Update()
sphere2Tri.Update()
booleanOperation.SetInputData(0, sphere1tri.GetOutput())
booleanOperation.SetInputData(1, sphere2Tri.GetOutput())
booleanOperation.Update()
boolean_peration_mapper = vtk.vtkPolyDataMapper()
boolean_peration_mapper.SetInputConnection(
booleanOperation.GetOutputPort())
boolean_peration_mapper.ScalarVisibilityOff()
booleanOperationActor = vtk.vtkActor()
booleanOperationActor.SetMapper(boolean_peration_mapper)
renderer = vtk.vtkRenderer()
renderer.AddViewProp(input1Actor)
renderer.AddViewProp(input2Actor)
renderer.AddViewProp(booleanOperationActor)
renderer.SetBackground(.1, .2, .3)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
ren_win_interactor = vtk.vtkRenderWindowInteractor()
ren_win_interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
ren_win_interactor.Start()
def SST_primary_mirror_plane():
sphereSource1 = vtk.vtkSphereSource()
sphereSource1.SetCenter(0.3, 0, 0)
sphereSource1.SetRadius(cam_height)
sphereSource1.SetThetaResolution(30)
sphereSource1.SetPhiResolution(30)
sphereSource1.Update()
input1 = sphereSource1.GetOutput()
sphere1Tri = vtk.vtkTriangleFilter()
sphere1Tri.SetInputData(input1)
sphereSource2 = vtk.vtkSphereSource()
sphereSource2.SetRadius(cam_height)
sphereSource2.SetThetaResolution(30)
sphereSource2.SetPhiResolution(30)
sphereSource2.Update()
input2 = sphereSource2.GetOutput()
sphere2Tri = vtk.vtkTriangleFilter()
sphere2Tri.SetInputData(input2)
booleanOperation = vtk.vtkBooleanOperationPolyDataFilter()
# booleanOperation.SetOperationToUnion()
# booleanOperation.SetOperationToIntersection()
booleanOperation.SetOperationToDifference()
booleanOperation.SetInputConnection(1, sphere1Tri.GetOutputPort())
booleanOperation.SetInputConnection(0, sphere2Tri.GetOutputPort())
booleanOperation.Update()
bool_cylinder = vtk.vtkCylinderSource()
bool_cylinder.SetCenter(0, 0, 0)
bool_cylinder.SetRadius(primary_reflector_diameter / 2)
bool_cylinder.SetHeight(cam_height * 2)
bool_cylinder.SetResolution(40)
# sphereSource3.SetResolution(20)
bool_cylinder.Update()
transform = vtk.vtkTransform()
transform.Translate(-cam_height, 0, 0)
transform.RotateZ(90)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(bool_cylinder.GetOutputPort())
transformFilter.Update()
input3 = transformFilter.GetOutput()
cylinderTri = vtk.vtkTriangleFilter()
cylinderTri.SetInputData(input3)
booleanCylinderIntersect = vtk.vtkBooleanOperationPolyDataFilter()
booleanCylinderIntersect.SetOperationToIntersection()
# booleanCylinderIntersect.SetOperationToUnion()
booleanCylinderIntersect.SetInputConnection(
0, booleanOperation.GetOutputPort())
booleanCylinderIntersect.SetInputConnection(1, cylinderTri.GetOutputPort())
booleanCylinderIntersect.Update()
booleanOperationMapper = vtk.vtkPolyDataMapper()
booleanOperationMapper.SetInputConnection(
booleanCylinderIntersect.GetOutputPort())
booleanOperationMapper.ScalarVisibilityOff()
booleanOperationActor = vtk.vtkActor()
booleanOperationActor.SetMapper(booleanOperationMapper)
booleanOperationActor.SetPosition(cam_height - 0.8, 0, 0)
return booleanOperationActor
tris1 = vtk.vtkTriangleFilter() tris1.SetInputData(transform_filter.GetOutput()) cylinder_source2 = vtk.vtkCylinderSource() cylinder_source2.SetRadius(1) cylinder_source2.SetHeight(4.2) cylinder_source2.SetResolution(50) cylinder_source2.Update() transform_filter = vtk.vtkTransformPolyDataFilter() transform_filter.SetInputConnection(cylinder_source2.GetOutputPort()) transform_filter.SetTransform(convert_to_vtk_transform(rotate_z(90))) transform_filter.Update() tris2 = vtk.vtkTriangleFilter() tris2.SetInputData(transform_filter.GetOutput()) booleanOperation1 = vtk.vtkBooleanOperationPolyDataFilter() booleanOperation1.SetOperationToUnion() booleanOperation1.SetInputConnection(0, tris1.GetOutputPort()) booleanOperation1.SetInputConnection(1, tris2.GetOutputPort()) booleanOperation1.Update() bool_tris = vtk.vtkTriangleFilter() bool_tris.SetInputData(booleanOperation1.GetOutput()) cylinder_source3 = vtk.vtkCylinderSource() cylinder_source3.SetRadius(1) cylinder_source3.SetHeight(4.2) cylinder_source3.SetResolution(50) cylinder_source3.Update() tris3 = vtk.vtkTriangleFilter() tris3.SetInputData(cylinder_source3.GetOutput())
def computeContactPointsWithGUI(mesh):
print "Computing contact points..."
rand = random.Random()
rand.seed(time())
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
segments = mesh.segments
components = mesh.components
adjacency_info = numpy.zeros (( len(components.keys()) , len(components.keys()) ), 'd')
contact_slots = {}
adjacency_info_2 = collections.defaultdict(dict)
contact_slots_2 = collections.defaultdict(dict)
for seg in components.keys():
contact_slots[seg] = [None, ] * len(components[seg])
contact_slots_2[seg] = collections.defaultdict(list)
adjacency_info_2[seg] = collections.defaultdict(int)
polys = {}
for seg in components.keys():
for c in components[seg]:
if not c.segmentId in polys:
polys[c.segmentId] = []
pts, tris = arrayToPolydata(c.vertices, c.faces)
poly = vtk.vtkPolyData()
poly.SetPoints(pts)
poly.SetPolys(tris)
poly.Update()
polys[c.segmentId].append(poly)
legend = vtk.vtkLegendBoxActor()
legend.SetNumberOfEntries( len(segments.keys()) )
legendSphereSource = vtk.vtkSphereSource()
legendSphere = legendSphereSource.GetOutput()
leg = 0
for segIdx in segments.keys():
segColor = [rand.random(),0.2,rand.random()]
for c in polys[segIdx]:
dataMapper = vtk.vtkPolyDataMapper()
dataMapper.SetInput(c)
model = vtk.vtkActor()
model.SetMapper(dataMapper)
model.GetProperty().SetColor(segColor)
ren.AddActor(model)
print "%d: V%d - P%d" % (segIdx, c.GetNumberOfPoints(), c.GetNumberOfPolys() )
legend.SetEntry(leg, legendSphere, "Segment #" + str(segIdx), segColor)
leg += 1
s_keys = polys.keys()
vertices = vtk.vtkCellArray()
points = vtk.vtkPoints()
for x in range(len(s_keys) - 1):
for y in range(x+1, len(s_keys)):
for id_x, c_x in enumerate(polys[s_keys[x]]):
for id_y, c_y in enumerate(polys[s_keys[y]]):
b = vtk.vtkBooleanOperationPolyDataFilter()
b.SetOperationToIntersection()
b.SetTolerance(0.1)
b.SetInput(0, c_x)
b.SetInput(1, c_y)
b.Update()
p = b.GetOutput(1).GetPoints()
if (p.GetNumberOfPoints() > 0):
print "Found %d contact points between segment #%d-%d and segment #%d-%d" % (p.GetNumberOfPoints(), s_keys[x], id_x, s_keys[y], id_y)
for k in range(p.GetNumberOfPoints()):
id = points.InsertNextPoint(p.GetPoint(k))
vertices.InsertNextCell(1)
vertices.InsertCellPoint(id)
res_points = numpy.array(polydataToArray(p))
contact_slots[s_keys[x]][id_x] = res_points
contact_slots[s_keys[y]][id_y] = res_points
d_x = dict()
d_x['points'] = res_points
d_x['seg'] = s_keys[y]
d_x['comp'] = id_y
contact_slots_2[s_keys[x]][id_x].append(d_x)
d_y = dict()
d_y['points'] = res_points
d_y['seg'] = s_keys[x]
d_y['comp'] = id_x
contact_slots_2[s_keys[y]][id_y].append(d_y)
adjacency_info[x,y] += 1
adjacency_info[y,x] += 1
adjacency_info_2[s_keys[x]][s_keys[y]] += 1
adjacency_info_2[s_keys[y]][s_keys[x]] += 1
points.Modified()
vertices.Modified()
print "Adjacency info"
for k in s_keys:
s = "\t %d | " % k
for k_2 in s_keys:
s += " %d |" % (adjacency_info_2[k][k_2])
print s
for s_k, s_v in contact_slots_2.items():
print "Segment %d" % s_k
for c_k, c_v in s_v.items():
print "\t Component %d" % c_k
for data in c_v:
print "\t\t Seg: %d Comp: %d Points: %d" % (data['seg'], data['comp'], len(data['points']))
data = vtk.vtkPolyData()
data.SetPoints(points)
data.SetVerts(vertices)
dataMapper = vtk.vtkPolyDataMapper()
dataMapper.SetInput(data)
model = vtk.vtkActor()
model.SetMapper(dataMapper)
model.GetProperty().SetColor(0.0, 1.0, 0.0)
model.GetProperty().SetPointSize(8.0)
ren.AddActor(model)
ren.AddActor(legend)
ren.SetBackground(0.1,0.2,0.4)
renWin.SetSize(500,500)
iren.Initialize()
iren.Start()
def get_tube_old(radius,
point,
direction,
length,
sphere_resolution,
cylinder_resolution,
cylinder_radius_compensation_factor=1.0,
sphere_radius_compensation_factor=1.0,
tube_shape=True):
""" Create a tube with ending half-spherese in Z axis.
:param radius:
:param point:
:param direction:
:param length:
:param sphere_resolution:
:param cylinder_resolution:
:param cylinder_radius_compensation_factor:
:param sphere_radius_compensation_factor:
:param tube_shape:
:return:
"""
cylinderTri = vtk.vtkTriangleFilter()
sphere1Tri = vtk.vtkTriangleFilter()
sphere2Tri = vtk.vtkTriangleFilter()
boolean_operation1 = vtk.vtkBooleanOperationPolyDataFilter()
boolean_operation2 = vtk.vtkBooleanOperationPolyDataFilter()
boolean_operation1.SetOperationToUnion()
boolean_operation2.SetOperationToUnion()
# print(dbg_msg)
cylinder_radius = radius * cylinder_radius_compensation_factor
sphere_radius = radius * sphere_radius_compensation_factor
retval = None
if tube_shape:
sphere1 = get_sphere(point,
sphere_radius,
resolution=sphere_resolution)
sphere1Tri.SetInputData(sphere1)
sphere1Tri.Update()
if length > 0:
cylinder = get_cylinder(point,
length,
cylinder_radius,
direction,
resolution=cylinder_resolution)
cylinderTri.SetInputData(cylinder)
cylinderTri.Update()
direction /= nm.linalg.norm(direction)
lv = point + direction * length
if tube_shape:
sphere2 = get_sphere(lv,
sphere_radius,
resolution=sphere_resolution)
sphere2Tri.SetInputData(sphere2)
sphere2Tri.Update()
# booleanOperation.SetInputData(0, cyl)
boolean_operation1.SetInputData(0, cylinderTri.GetOutput())
boolean_operation1.SetInputData(1, sphere1Tri.GetOutput())
boolean_operation1.Update()
boolean_operation2.SetInputData(0, boolean_operation1.GetOutput())
boolean_operation2.SetInputData(1, sphere2Tri.GetOutput())
# booleanOperation.SetInputData(2, sph2)
boolean_operation2.Update()
else:
boolean_operation2 = cylinderTri
retval = boolean_operation2.GetOutput()
else:
if tube_shape:
boolean_operation2 = sphere1Tri
retval = boolean_operation2.GetOutput()
else:
# length == 0 but no spheres
# so we are generating just flat shape
# boolean_operation2 = cylinderTri
# return empty space
retval = vtk.vtkTriangleFilter().GetOutput()
# something_to_add = False
return retval
def gen_tree(tree_data,
cylinder_resolution=10,
sphere_resolution=10,
polygon_radius_selection_method="inscribed",
cylinder_radius_compensation_factor=1.0,
sphere_radius_compensation_factor=1.0,
tube_shape=True):
"""
:param polygon_radius_selection_method:
"inscribed":
"compensation factors"
"cylinder volume"
"cylinder surface"
:param tree_data:
:param cylinder_resolution:
:param sphere_resolution:
:param cylinder_radius_compensation_factor: is used to change radius of cylinder and spheres
:return:
"""
import vtk
# appendFilter = vtk.vtkAppendPolyData()
appended_data = None
if vtk.VTK_MAJOR_VERSION <= 5:
logger.error("VTK 6 required")
factors = polygon_radius_compensation_factos(
polygon_radius_selection_method, cylinder_radius_compensation_factor,
sphere_radius_compensation_factor, cylinder_resolution,
sphere_resolution)
cylinder_radius_compensation_factor, sphere_radius_compensation_factor,\
cylinder_radius_compensation_factor_long, sphere_radius_compensation_factor_long = factors
# import ipdb; ipdb.set_trace()
for br in tree_data:
# import ipdb;
# ipdb.set_trace()
something_to_add = True
radius = br['radius']
length = br["length"]
direction = br["direction"]
uv = br['upperVertex']
dbg_msg = "generating edge with length: " + str(br["length"])
logger.debug(dbg_msg)
# tube = get_tube_old(radius, uv, direction, length,
if length == 0:
tube = get_sphere(uv, radius * sphere_radius_compensation_factor,
sphere_resolution)
else:
tube = get_tube(radius,
uv,
direction,
length,
sphere_resolution,
cylinder_resolution,
cylinder_radius_compensation_factor=
cylinder_radius_compensation_factor_long,
sphere_radius_compensation_factor=
sphere_radius_compensation_factor_long,
tube_shape=tube_shape)
# this is simple version
# appendFilter.AddInputData(boolean_operation2.GetOutput())
# print "object connected, starting addind to general space " + str(br["length"])
if something_to_add:
if appended_data is None:
#appended_data = boolean_operation2.GetOutput()
appended_data = tube
else:
boolean_operation3 = vtk.vtkBooleanOperationPolyDataFilter()
boolean_operation3.SetOperationToUnion()
boolean_operation3.SetInputData(0, appended_data)
boolean_operation3.SetInputData(1, tube)
boolean_operation3.Update()
appended_data = boolean_operation3.GetOutput()
# import ipdb; ipdb.set_trace()
# del (cylinderTri)
# del (sphere1Tri)
# del (sphere2Tri)
# del (boolean_operation1)
# del (boolean_operation2)
# del (boolean_operation3)
logger.debug("konec gen_tree()")
# appendFilter.Update()
# appended_data = appendFilter.GetOutput()
return appended_data
def get_tube(radius=1.0,
point=[0.0, 0.0, 0.0],
direction=[0.0, 0.0, 1.0],
length=1.0,
sphere_resolution=10,
cylinder_resolution=10,
cylinder_radius_compensation_factor=1.0,
sphere_radius_compensation_factor=1.0,
tube_shape=True,
axis=1,
make_ladder_even=True):
point1 = [0.0, 0.0, 0.0]
center = [0.0, 0.0, 0.0]
point2 = [0.0, 0.0, 0.0]
center[axis] = length / 2.0
point2[axis] = length
cylinder_radius = radius * cylinder_radius_compensation_factor
sphere_radius = radius * sphere_radius_compensation_factor
direction /= nm.linalg.norm(direction)
lv = point + direction * length
cylinderTri = vtk.vtkTriangleFilter()
sphere1Tri = vtk.vtkTriangleFilter()
sphere2Tri = vtk.vtkTriangleFilter()
cylinder = vtk.vtkCylinderSource()
cylinder.SetCenter(center)
cylinder.SetHeight(length)
cylinder.SetRadius(cylinder_radius)
cylinder.SetResolution(cylinder_resolution)
cylinder.Update()
cylinderTri.SetInputData(cylinder.GetOutput())
cylinderTri.Update()
# make ladder even
if make_ladder_even:
if sphere_resolution % 2 == 0:
phi_resolution = sphere_resolution + 1
else:
phi_resolution = sphere_resolution
if not tube_shape:
tube = move_to_position(cylinderTri, point, direction, 2, 1, 0)
return tube.GetOutput()
sphere1 = get_sphere(
center=point1,
radius=sphere_radius,
resolution=sphere_resolution,
start_phi=0,
#end_phi=90,
end_phi=180,
axis=1,
phi_resolution=phi_resolution)
# sphere1.Update()
sphere1Tri.SetInputData(sphere1)
sphere1Tri.Update()
sphere2 = get_sphere(
center=point2,
# radius= 1. - (cylinder_radius - sphere_radius),
radius=sphere_radius,
resolution=sphere_resolution,
start_phi=0,
end_phi=180,
axis=1,
phi_resolution=phi_resolution)
sphere2Tri.SetInputData(sphere2)
sphere2Tri.Update()
boolean_operation1 = vtk.vtkBooleanOperationPolyDataFilter()
boolean_operation2 = vtk.vtkBooleanOperationPolyDataFilter()
boolean_operation1.SetOperationToUnion()
boolean_operation2.SetOperationToUnion()
# booleanOperation.SetInputData(0, cyl)
boolean_operation1.SetInputData(0, cylinderTri.GetOutput())
boolean_operation1.SetInputData(1, sphere1Tri.GetOutput())
boolean_operation1.Update()
boolean_operation2.SetInputData(0, boolean_operation1.GetOutput())
boolean_operation2.SetInputData(1, sphere2Tri.GetOutput())
# booleanOperation.SetInputData(2, sph2)
boolean_operation2.Update()
# tube_in_base_position = boolean_operation2.GetOutput()
#tube = move_to_position(boolean_operation2, point, direction, 1, 2)
tube = move_to_position(boolean_operation2, point, direction, 2, 1, 0)
return tube.GetOutput()
filteredMeshes.append(clean.GetOutput())
print "%d: %d - %d" % (k, clean.GetOutput().GetNumberOfPoints(), clean.GetOutput().GetNumberOfPolys(), )
dataMapper = vtk.vtkPolyDataMapper()
dataMapper.SetInput(clean.GetOutput())
model = vtk.vtkActor()
model.SetMapper(dataMapper)
model.GetProperty().SetColor(rand.random(),0.2,rand.random())
ren.AddActor(model)
print
print filteredMeshes
b = vtk.vtkBooleanOperationPolyDataFilter()
b.SetOperationToIntersection()
b.SetTolerance(0.1)
b.SetInput(0, filteredMeshes[2])
b.SetInput(1, filteredMeshes[1])
b.Update()
print b.GetOutput(1).GetPoints()
points = b.GetOutput(1).GetPoints()
vertices = vtk.vtkCellArray()
for x in range(points.GetNumberOfPoints()):
vertices.InsertNextCell(1)
vertices.InsertCellPoint(x)
points.Modified()
def write_boolean_operation(self, obj, position, rotation, operation):
return None
self.logger.debug("Writing Boolean Object {}".format(
obj.__class__.__name__))
self.logger.debug("First: {}".format(obj.first))
self.logger.debug("Second: {}".format(obj.second))
self.logger.debug("Rotation: {}".format(obj.rotation))
self.logger.debug("Position: {}".format(obj.position))
booleanFilter = vtk.vtkBooleanOperationPolyDataFilter()
booleanFilter.SetOperation(operation)
input1 = None
input2 = None
if isinstance(obj.first, Box):
input1 = self.write_box(obj.first, [0, 0, 0], [0, 0, 0])
elif isinstance(obj.first, Tube):
input1 = self.write_tube(obj.first, [0, 0, 0], [0, 0, 0])
elif isinstance(obj.first, Sphere):
input1 = self.write_sphere(obj.first, [0, 0, 0], [0, 0, 0])
elif isinstance(obj.first, Union):
input1 = self.write_union(obj.first, [0, 0, 0], [0, 0, 0])
elif isinstance(obj.first, Subtraction):
input1 = self.write_intersection(obj.first, [0, 0, 0], [0, 0, 0])
elif isinstance(obj.first, Intersection):
input1 = self.write_union(obj.first, [0, 0, 0], [0, 0, 0])
else:
cls_name = obj.first.__class__.__name__
self.logger.error("Encountered Unknown Type: " + cls_name)
raise WritingError("Unkown Type Encountered in Boolean First")
if input1 is None:
cls_name = obj.first.__class__.__name__
self.logger.warning("Input1 is Null for " + cls_name)
if isinstance(obj.second, Box):
input2 = self.write_box(obj.second, obj.position, obj.rotation)
elif isinstance(obj.second, Tube):
input2 = self.write_tube(obj.second, obj.position, obj.rotation)
elif isinstance(obj.second, Sphere):
input2 = self.write_sphere(obj.second, obj.position, obj.rotation)
elif isinstance(obj.second, Union):
input2 = self.write_union(obj.second, obj.position, obj.rotation)
elif isinstance(obj.second, Subtraction):
input2 = self.write_intersection(obj.second, obj.position,
obj.rotation)
elif isinstance(obj.second, Intersection):
input2 = self.write_union(obj.second, obj.position, obj.rotation)
else:
self.logger.warning("Encountered Unknown Type: {}".format(
obj.second.__class__.__name__))
raise WritingError("Unknown Type Encoutered in Boolean Second")
if input2 is None:
self.logger.warning("Input2 is Null for " +
obj.second.__class__.__name__)
if (input1 is None or input2 is None):
return None
tmp1 = vtk.vtkTriangleFilter()
tmp1.SetInputConnection(input1.GetOutputPort())
tmp1.Update()
input1 = tmp1
tmp2 = vtk.vtkTriangleFilter()
tmp2.SetInputConnection(input2.GetOutputPort())
tmp2.Update()
input2 = tmp2
self.appendpolydata.AddInputData(
self.apply_transformations(input1.GetOutputPort(), rotation,
position).GetOutput())
self.appendpolydata.Update()
self.appendpolydata.AddInputData(
self.apply_transformations(input2.GetOutputPort(), rotation,
position).GetOutput())
self.appendpolydata.Update()
return None
booleanFilter.SetInputData(
0,
self.apply_transformations(input1.GetOutputPort(), rotation,
position).GetOutput())
booleanFilter.SetInputData(
1,
self.apply_transformations(input2.GetOutputPort(), rotation,
position).GetOutput())
if not self.check_intersection(input1, input2):
self.logger.warning("Could NOT find intersection")
return None
self.logger.debug("Found Intersections")
self.logger.debug("Applying Boolean Filter")
try:
booleanFilter.SetTolerance(1.e-12)
booleanFilter.Update()
self.logger.debug("Finished Creating Boolean Surface")
return booleanFilter
except:
self.logger.warning("Failed")
return None
def ComputeEdgeOfUnion(lnume, A, S, pz):
use_function_callback = True
colors = vtk.vtkNamedColors()
colorsCell = ['AliceBlue', 'Green', 'Blue', 'Yellow', 'Magenta']
# A renderer and render window
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d('Silver'))
# render window
renwin = vtk.vtkRenderWindow()
renwin.SetWindowName("CallBack")
renwin.AddRenderer(renderer)
# An interactor
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renwin)
# Start
if use_function_callback:
CloseWin.int = interactor
interactor.AddObserver('EndInteractionEvent', CloseWin)
# Create actors
# create container Sphere
sphere = vtk.vtkQuadric()
sphere.SetCoefficients(S)
sampleS = vtk.vtkSampleFunction()
sampleS.SetImplicitFunction(sphere)
# mapper
mapperSphere = vtk.vtkPolyDataMapper()
mapperSphere.SetInputConnection(sampleS.GetOutputPort())
mapperSphere.ScalarVisibilityOff()
# actorSphere = vtk.vtkActor()
# actorSphere.SetMapper(mapperSphere)
# actorSphere.GetProperty().EdgeVisibilityOn()
# actorSphere.GetProperty().SetColor(colors.GetColor3d('AliceBlue'))
# actorSphere.GetProperty().SetEdgeColor(colors.GetColor3d('SteelBlue'))
boundsC = np.array(sampleS.GetModelBounds())
for k in range(3):
boundsC[2 * k] = -1.1 * np.sqrt(-S[9])
boundsC[2 * k + 1] = 1.1 * np.sqrt(-S[9])
print(S[9])
print(boundsC)
sampleS.SetModelBounds(boundsC)
# surface.SetValue(0, 0.0)
#
contoursS = vtk.vtkContourFilter()
contoursS.SetInputConnection(sampleS.GetOutputPort())
contoursS.GenerateValues(1, 0.0, 1.2)
contMapper = vtk.vtkPolyDataMapper()
contMapper.SetInputConnection(contoursS.GetOutputPort())
contMapper.SetScalarRange(0.0, 1.2)
contActor = vtk.vtkActor()
contActor.GetProperty().SetOpacity(0.1)
contActor.SetMapper(contMapper)
# create an ellipsoid using a implicit quadric
quadric = [None] * len(lnume)
mapper = [None] * len(lnume)
actor = [None] * len(lnume)
sample = [None] * len(lnume)
contours = [None] * len(lnume)
bounds = np.array(sampleS.GetModelBounds())
booleanOperation = vtk.vtkBooleanOperationPolyDataFilter()
booleanOperation.SetOperationToUnion()
booleanOperationMapper = vtk.vtkPolyDataMapper()
booleanOperationActor = vtk.vtkActor()
for k in lnume:
quadric[k] = vtk.vtkQuadric()
quadric[k].SetCoefficients(A[lnume[k]])
sample[k] = vtk.vtkSampleFunction()
sample[k].SetImplicitFunction(quadric[k])
for l in range(3):
bounds[2 * l] = -1.2 * np.sqrt(-S[9])
bounds[2 * l + 1] = 1.2 * np.sqrt(-S[9])
sample[k].SetModelBounds(bounds)
contours[k] = vtk.vtkContourFilter()
contours[k].SetInputConnection(sample[k].GetOutputPort())
# generation d'une valeur dans l'intervalle spécifié (le min et le max sont inclus)
contours[k].GenerateValues(1, 0.0, 0.1)
# mapper
mapper[k] = vtk.vtkPolyDataMapper()
mapper[k].SetInputConnection(contours[k].GetOutputPort())
mapper[k].ScalarVisibilityOff()
actor[k] = vtk.vtkActor()
actor[k].SetMapper(mapper[k])
#actor[k].GetProperty().EdgeVisibilityOn()
actor[k].GetProperty().SetColor(
colors.GetColor3d(colorsCell[k % len(colorsCell)]))
actor[k].GetProperty().SetEdgeColor(colors.GetColor3d('SteelBlue'))
Ellipsoid2Tri = vtk.vtkTriangleFilter()
input2 = contours[k].GetOutput()
Ellipsoid2Tri.SetInputData(input2)
if k == lnume[0]:
booleanOperationActor.SetMapper(mapper[lnume[0]])
EllipsoidsTri = vtk.vtkTriangleFilter()
input1 = booleanOperation.GetOutputPort().GetOutput() # A revoir
EllipsoidsTri.SetInputData(input1)
else:
booleanOperation.SetInputConnection(0,
EllipsoidsTri.GetOutputPort())
booleanOperation.SetInputConnection(1,
Ellipsoid2Tri.GetOutputPort())
booleanOperation.Update()
booleanOperationMapper.SetInputConnection(
booleanOperation.GetOutputPort())
booleanOperationMapper.ScalarVisibilityOff()
booleanOperationActor.GetProperty().SetDiffuseColor(
colors.GetColor3d("Banana"))
