def load(self):
"""
Read model and data and define fit fields and data.
Can call again to reset fit, after parameters have changed.
"""
self._region = self._context.createRegion()
self._fieldmodule = self._region.getFieldmodule()
self._rawDataRegion = self._region.createChild("raw_data")
self._loadModel()
self._loadData()
self._defineDataProjectionFields()
# get centre and scale of data coordinates to manage fitting tolerances and steps
datapoints = self._fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
minimums, maximums = evaluateFieldNodesetRange(
self._dataCoordinatesField, datapoints)
self._dataCentre = [
0.5 * (minimums[c] + maximums[c]) for c in range(3)
]
self._dataScale = max((maximums[c] - minimums[c]) for c in range(3))
if self._diagnosticLevel > 0:
print("Load data: data coordinates centre ", self._dataCentre)
print("Load data: data coordinates scale ", self._dataScale)
for step in self._fitterSteps:
step.setHasRun(False)
self._fitterSteps[0].run(
) # initial config step will calculate data projections
def test_cylinder1(self):
"""
Test creation of cylinder scaffold.
"""
scaffold = MeshType_3d_solidcylinder1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default"])
options = scaffold.getDefaultOptions("Default")
self.assertEqual(12, len(options))
self.assertEqual(4, options.get("Number of elements across major"))
self.assertEqual(4, options.get("Number of elements across minor"))
self.assertEqual(0, options.get("Number of elements across shell"))
self.assertEqual(1,
options.get("Number of elements across transition"))
self.assertEqual(1, options.get("Number of elements along"))
self.assertEqual(1.0,
options.get("Shell element thickness proportion"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(0, len(annotationGroups))
fieldmodule = region.getFieldmodule()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(12, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(52, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(73, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(34, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, cylinder volume
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-1.0, -1.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [1.0, 1.0, 3.0], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 9.414866630615249, delta=1.0E-3)
def test_humancolonsegment1(self):
"""
Test creation of human colon segment scaffold.
"""
parameterSetNames = MeshType_3d_colonsegment1.getParameterSetNames()
self.assertEqual(parameterSetNames,
["Default", "Human 1", "Mouse 1", "Pig 1"])
options = MeshType_3d_colonsegment1.getDefaultOptions("Human 1")
self.assertEqual(27, len(options))
self.assertEqual(0.0, options.get("Start phase"))
self.assertEqual(2,
options.get("Number of elements around tenia coli"))
self.assertEqual(4, options.get("Number of elements along segment"))
self.assertEqual(1, options.get("Number of elements through wall"))
self.assertEqual(43.5, options.get("Start inner radius"))
self.assertEqual(0.0, options.get("Start inner radius derivative"))
self.assertEqual(33.0, options.get("End inner radius"))
self.assertEqual(0.0, options.get("End inner radius derivative"))
self.assertEqual(3.0,
options.get("Segment length mid derivative factor"))
self.assertEqual(50.0, options.get("Segment length"))
self.assertEqual(3, options.get("Number of tenia coli"))
self.assertEqual(10.0, options.get("Start tenia coli width"))
self.assertEqual(0.0, options.get("End tenia coli width derivative"))
self.assertEqual(1.6, options.get("Wall thickness"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_colonsegment1.generateBaseMesh(
region, options)
self.assertEqual(3, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(144, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(576, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(747, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(315, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(
self, minimums,
[-2.172286248499807e-15, -58.968781863998764, -55.55863337757897],
1.0E-6)
assertAlmostEqualList(self, maximums,
[50.0, 50.53111767614515, 55.55863271778078],
1.0E-6)
flatCoordinates = fieldmodule.findFieldByName(
"flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(flatCoordinates, nodes)
assertAlmostEqualList(self, minimums, [0.0, 0.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums,
[397.26513766571264, 50.0, 3.2000000000000006],
1.0E-6)
textureCoordinates = fieldmodule.findFieldByName(
"texture coordinates").castFiniteElement()
minimums, maximums = evaluateFieldNodesetRange(textureCoordinates,
nodes)
assertAlmostEqualList(self, minimums, [0.0, 0.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [0.9887754554800083, 1.0, 2.0],
1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(
fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 20849.829586166292, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 35626.9300655261, delta=1.0E-6)
def test_heart1(self):
"""
Test creation of heart scaffold.
"""
scaffold = MeshType_3d_heart1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, [
"Default", "Human 1", "Mouse 1", "Pig 1", "Rat 1", "Unit Human 1",
"Unit Mouse 1", "Unit Pig 1", "Unit Rat 1"
])
options = scaffold.getDefaultOptions("Human 1")
self.assertEqual(123, len(options))
self.assertEqual(0.9, options.get("LV outer height"))
self.assertEqual(80.0, options.get("Unit scale"))
self.assertEqual(7,
options.get("Number of elements around LV free wall"))
self.assertEqual(7,
options.get("Number of elements around RV free wall"))
# simplify atria
self.assertEqual(8, options.get("Number of elements over atria"))
options["Number of elements over atria"] = 6
self.assertEqual(
2, options.get("Number of elements radial pulmonary vein annuli"))
options["Number of elements radial pulmonary vein annuli"] = 1
self.assertFalse(scaffold.checkOptions(options))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(32, len(annotationGroups))
fieldmodule = region.getFieldmodule()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(332, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1287, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1567, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(614, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, epicardium surface area and volume
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums,
[-50.7876375290527, -58.42494589146976, -91.6],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[43.810947610743156, 39.03925080604259, 42.018608492002784],
1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
epicardiumGroup = fieldmodule.findFieldByName(
'epicardium').castGroup()
self.assertTrue(epicardiumGroup.isValid())
epicardiumMeshGroup = epicardiumGroup.getFieldElementGroup(
mesh2d).getMeshGroup()
self.assertTrue(epicardiumMeshGroup.isValid())
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, epicardiumMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 36541.36513577538, delta=1.0E-2)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 218014.81436425756, delta=1.0E-1)
# check some annotationGroups:
expectedSizes3d = {
"left ventricle myocardium": 110,
"right ventricle myocardium": 95,
"interventricular septum": 37,
"left atrium myocardium": 88,
"right atrium myocardium": 80,
"interatrial septum": 23
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
expectedSizes2d = {
"endocardium of left ventricle": 88,
"endocardium of right ventricle": 73,
"endocardium of left atrium": 82,
"endocardium of right atrium": 74,
"epicardium": 229
}
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh2d).getSize()
self.assertEqual(expectedSizes2d[name], size, name)
# test finding a marker in scaffold
markerGroup = fieldmodule.findFieldByName("marker").castGroup()
markerNodes = markerGroup.getFieldNodeGroup(nodes).getNodesetGroup()
self.assertEqual(7, markerNodes.getSize())
markerName = fieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = fieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = fieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "apex of heart")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(1, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 1.0], 1.0E-10)
apexGroup = getAnnotationGroupForTerm(annotationGroups,
get_heart_term("apex of heart"))
self.assertTrue(apexGroup.getNodesetGroup(nodes).containsNode(node))
# refine 2x2x2 and check result
# first remove any face (but not point) annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and (
annotationGroup.hasMeshGroup(mesh2d)
or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(23, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements surface'] = 2
options['Refine number of elements through LV wall'] = 2
options['Refine number of elements through wall'] = 2
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(32, len(annotationGroups))
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(2580, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(8872, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(9983, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(3693, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 8, size, name)
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh2d).getSize()
if name == "epicardium":
# fibrous ring is only refined by 1 through its thickness
fibrousRingReduction = (
options['Refine number of elements surface'] - 1
) * options['Refine number of elements surface'] * (
options['Number of elements around left atrium free wall']
+
options['Number of elements around right atrium free wall']
)
self.assertEqual(
expectedSizes2d[name] * 4 - fibrousRingReduction, size,
name)
else:
self.assertEqual(expectedSizes2d[name] * 4, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(7, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "apex of heart")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(5, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 1.0], 1.0E-10)
apexGroup = getAnnotationGroupForTerm(annotationGroups,
get_heart_term("apex of heart"))
self.assertTrue(apexGroup.getNodesetGroup(nodes).containsNode(node))
def test_stomach1(self):
"""
Test creation of stomach scaffold.
"""
scaffold = MeshType_3d_stomach1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames,
["Default", "Human 1", "Mouse 1", "Rat 1"])
options = scaffold.getDefaultOptions("Rat 1")
self.assertEqual(19, len(options))
self.assertEqual(12,
options.get("Number of elements around esophagus"))
self.assertEqual(14, options.get("Number of elements around duodenum"))
self.assertEqual(
2, options.get("Number of elements between cardia and duodenum"))
self.assertEqual(1, options.get("Number of elements across cardia"))
self.assertEqual(0.5, options.get("Wall thickness"))
self.assertEqual(True, options.get("Limiting ridge"))
ostiumOptions = options['Gastro-esophagal junction']
ostiumSettings = ostiumOptions.getScaffoldSettings()
self.assertEqual(1, ostiumSettings.get("Number of vessels"))
self.assertEqual(
12, ostiumSettings.get("Number of elements around ostium"))
self.assertEqual(4,
ostiumSettings.get("Number of elements through wall"))
self.assertEqual(5.0, ostiumSettings.get("Ostium diameter"))
self.assertEqual(5.0, ostiumSettings.get("Ostium length"))
self.assertEqual(0.5, ostiumSettings.get("Ostium wall thickness"))
self.assertEqual(
[0.65, 0.12, 0.18, 0.05],
ostiumSettings.get("Ostium wall relative thicknesses"))
self.assertEqual(2.0, ostiumSettings.get("Vessel inner diameter"))
self.assertEqual(0.5, ostiumSettings.get("Vessel wall thickness"))
self.assertEqual(
[0.65, 0.12, 0.18, 0.05],
ostiumSettings.get("Vessel wall relative thicknesses"))
self.assertEqual(0.0, ostiumSettings.get("Vessel angle 1 degrees"))
self.assertEqual(
0.55,
options.get("Gastro-esophagal junction position along factor"))
self.assertEqual(0.2, options.get("Cardia derivative factor"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateBaseMesh(region, options)
self.assertEqual(37, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(582, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1965, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(2195, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(830, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(
self, minimums,
[-18.238549598577396, -16.033751319943754, -8.905924748773598],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[18.285156743233415, 15.214807824088728, 8.905433142848109],
1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(
fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 2557.832902256128, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 809.0349219398828, delta=1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"body of stomach": 112,
"cardia of stomach": 36,
"duodenum": 56,
"esophagus": 96,
"fundus of stomach": 114,
"pyloric antrum": 112,
"pyloric canal": 56,
"stomach": 582
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_stomach_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# refine 4x4x4 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and \
(annotationGroup.hasMeshGroup(mesh2d) or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(37, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements surface'] = 4
options['Refine number of elements through wall'] = 4
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(68, len(annotationGroups))
#
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(37248, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(115248, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(118796, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(40814, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_stomach_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 64, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(18, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(
markerNodes, markerName,
"esophagogastric junction along the lesser curvature on serosa")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(5821, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 1.0, 1.0], 1.0E-10)
def test_smallintestine1(self):
"""
Test creation of small intestine scaffold.
"""
parameterSetNames = MeshType_3d_smallintestine1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Cattle 1", "Mouse 1"])
centralPathDefaultScaffoldPackages = {
'Test line': ScaffoldPackage(MeshType_1d_path1, {
'scaffoldSettings': {
'D2 derivatives': True,
'Coordinate dimensions': 3,
'Length': 1.0,
'Number of elements': 3
},
'meshEdits': exnodeStringFromNodeValues(
[Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1, Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D2_DS1DS2], [
[[-2.3, 18.5, -4.4], [-4.2, -0.8, 3.7], [0.0, 5.0, 0.0], [0.0, 0.0, 0.5]],
[[-8.6, 16.3, -0.4], [-7.1, -2.7, 1.6], [0.0, 5.0, 0.0], [0.0, 0.0, 0.5]],
[[-18.3, 12.6, -1.5], [-6.4, -1.7, -3.8], [0.0, 5.0, 0.0], [0.0, 0.0, 0.5]],
[[-15.6, 13.7, -6.1], [7.0, 2.1, -1.8], [0.0, 5.0, 0.0], [0.0, 0.0, 0.5]]])
})
}
centralPathOption = centralPathDefaultScaffoldPackages['Test line']
options = MeshType_3d_smallintestine1.getDefaultOptions("Mouse 1")
options['Central path'] = copy.deepcopy(centralPathOption)
options['Number of segments'] = 4
options['Duodenum length'] = 5.0
options['Jejunum length'] = 15.0
options['Ileum length'] = 5.0
self.assertEqual(19, len(options))
centralPath = options['Central path']
self.assertEqual(4, options.get("Number of segments"))
self.assertEqual(8, options.get("Number of elements around"))
self.assertEqual(4, options.get("Number of elements along segment"))
self.assertEqual(1, options.get("Number of elements through wall"))
self.assertEqual(5.0, options.get("Duodenum length"))
self.assertEqual(5.0, options.get("Ileum length"))
self.assertEqual(0.6, options.get("Duodenum inner radius"))
self.assertEqual(1.0, options.get("Jejunum-ileum inner radius"))
self.assertEqual(0.1, options.get("Wall thickness"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
tmpRegion = region.createRegion()
centralPath.generate(tmpRegion)
cx = extractPathParametersFromRegion(tmpRegion, [Node.VALUE_LABEL_VALUE])[0]
self.assertEqual(4, len(cx))
assertAlmostEqualList(self, cx[0], [-2.3, 18.5, -4.4], 1.0E-6)
assertAlmostEqualList(self, cx[2], [-18.3, 12.6, -1.5], 1.0E-6)
del tmpRegion
annotationGroups = MeshType_3d_smallintestine1.generateBaseMesh(region, options)
self.assertEqual(4, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(128, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(520, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(664, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(272, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-20.06978981419564, 11.406595205949705, -7.1653294859433965], 1.0E-6)
assertAlmostEqualList(self, maximums, [-1.8300388314851923, 19.193885338090105, 0.9772071374844936], 1.0E-6)
flatCoordinates = fieldmodule.findFieldByName("flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(flatCoordinates, nodes)
assertAlmostEqualList(self, minimums, [-1.39038154442654, 0.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [4.891237158967401, 25.293706698841913, 0.1], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
flatSurfaceAreaField = fieldmodule.createFieldMeshIntegral(one, flatCoordinates, faceMeshGroup)
flatSurfaceAreaField.setNumbersOfPoints(4)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 171.27464080337143, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 16.35219225882822, delta=1.0E-6)
result, flatSurfaceArea = flatSurfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(flatSurfaceArea, 171.37026123844635, delta=1.0E-3)
def test_cecum1(self):
"""
Test creation of cecum scaffold.
"""
parameterSetNames = MeshType_3d_cecum1.getParameterSetNames()
self.assertEqual(parameterSetNames, [ "Default", "Pig 1" ])
options = MeshType_3d_cecum1.getDefaultOptions("Pig 1")
self.assertEqual(30, len(options))
self.assertEqual(5, options.get("Number of segments"))
self.assertEqual(2, options.get("Number of elements around tenia coli"))
self.assertEqual(8, options.get("Number of elements along segment"))
self.assertEqual(1, options.get("Number of elements through wall"))
self.assertEqual(35.0, options.get("Start inner radius"))
self.assertEqual(3.0, options.get("Start inner radius derivative"))
self.assertEqual(38.0, options.get("End inner radius"))
self.assertEqual(3.0, options.get("End inner radius derivative"))
self.assertEqual(0.5, options.get("Corner inner radius factor"))
self.assertEqual(0.25, options.get("Haustrum inner radius factor"))
self.assertEqual(4.0, options.get("Segment length mid derivative factor"))
self.assertEqual(3, options.get("Number of tenia coli"))
self.assertEqual(5.0, options.get("Start tenia coli width"))
self.assertEqual(0.0, options.get("End tenia coli width derivative"))
self.assertEqual(2.0, options.get("Wall thickness"))
ostiumOptions = options['Ileocecal junction']
ostiumSettings = ostiumOptions.getScaffoldSettings()
self.assertEqual(1, ostiumSettings.get("Number of vessels"))
self.assertEqual(8, ostiumSettings.get("Number of elements around ostium"))
self.assertEqual(1, ostiumSettings.get("Number of elements through wall"))
self.assertEqual(20.0, ostiumSettings.get("Ostium diameter"))
self.assertEqual(10.0, ostiumSettings.get("Vessel inner diameter"))
self.assertEqual(60, options.get("Ileocecal junction angular position degrees"))
self.assertEqual(0.5, options.get("Ileocecal junction position along factor"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_cecum1.generateBaseMesh(region, options)
self.assertEqual(2, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(1492, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(5617, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(6767, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(2642, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-49.01658984455258, -46.89686037622053, -2.343256155753525], 1.0E-6)
assertAlmostEqualList(self, maximums, [42.18085849205387, 54.89264119402881, 180.0], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 65960.02821062482, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 127893.74708048582, delta=1.0E-6)
def test_bladder1(self):
"""
Test creation of bladder scaffold.
"""
parameterSetNames = MeshType_3d_bladder1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Cat 1", "Rat 1"])
ostiumDefaultScaffoldPackages = {
'Test ostium': ScaffoldPackage(MeshType_3d_ostium1, {
'scaffoldSettings': {
'Number of vessels': 1,
'Number of elements across common': 2,
'Number of elements around ostium': 8,
'Number of elements along': 2,
'Number of elements through wall': 1, # not implemented for > 1
'Unit scale': 1.0,
'Outlet': False,
'Ostium diameter': 0.3,
'Ostium length': 0.2,
'Ostium wall thickness': 0.05,
'Ostium inter-vessel distance': 0.8,
'Ostium inter-vessel height': 0.0,
'Use linear through ostium wall': True,
'Vessel end length factor': 1.0,
'Vessel inner diameter': 0.15,
'Vessel wall thickness': 0.04,
'Vessel angle 1 degrees': 0.0,
'Vessel angle 1 spread degrees': 0.0,
'Vessel angle 2 degrees': 0.0,
'Use linear through vessel wall': True,
# 'Use cross derivatives' : False,
'Refine': False,
'Refine number of elements around': 4,
'Refine number of elements along': 4,
'Refine number of elements through wall': 1
},
})
}
ostiumOption = ostiumDefaultScaffoldPackages['Test ostium']
options = {
'Number of elements up neck': 8,
'Number of elements up body': 16,
'Number of elements around': 8, # should be even
'Number of elements through wall': 1,
'Number of elements around ostium': 8, # implemented for 8
'Number of elements radially on annulus': 1,
'Height': 5.0,
'Major diameter': 6.0,
'Minor diameter': 6.0,
'Bladder wall thickness': 0.05,
'Urethra diameter': 1.0,
'Ureter': copy.deepcopy(ostiumOption),
'Ostium position around': 0.15,
'Ostium position up': 0.25,
'Use cross derivatives': False,
'Refine': False,
'Refine number of elements around': 4,
'Refine number of elements up': 4,
'Refine number of elements through wall': 1
}
self.assertEqual(19, len(options))
ostiumSettings = ostiumOption.getScaffoldSettings()
self.assertEqual(1, ostiumSettings.get("Number of vessels"))
self.assertEqual(8, ostiumSettings.get("Number of elements around ostium"))
self.assertEqual(1, ostiumSettings.get("Number of elements through wall"))
self.assertEqual(0.3, ostiumSettings.get("Ostium diameter"))
self.assertEqual(8, options.get("Number of elements up neck"))
self.assertEqual(16, options.get("Number of elements up body"))
self.assertEqual(8, options.get("Number of elements around"))
self.assertEqual(1.0, options.get("Urethra diameter"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_bladder1.generateBaseMesh(region, options)
self.assertEqual(3, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
if annotationGroups is not None:
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(232, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(936, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1183, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(478, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-2.996386368615517, -2.996386368615517, -6.464466094067262], 1.0E-6)
assertAlmostEqualList(self, maximums, [2.996386368615517, 2.996386368615517, 5.0], 1.0E-6)
def test_lung1(self):
"""
Test creation of heart scaffold.
"""
scaffold = MeshType_3d_lung1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, [ "Default", "Human 1", "Mouse 1", "Pig 1", "Rat 1" ])
options = scaffold.getDefaultOptions(["Human 1"])
self.assertEqual(3, len(options))
self.assertFalse(scaffold.checkOptions(options))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(20, len(annotationGroups))
fieldmodule = region.getFieldmodule()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(88, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(292, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(334, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(141, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, outside surface area and volume
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [ 14.153, 62.444, -353.40564 ], 1.0E-6)
assertAlmostEqualList(self, maximums, [ 297.502, 245.3003, -23.486 ], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
upperRightFissureGroup = fieldmodule.findFieldByName('upper lobe of right lung').castGroup()
self.assertTrue(upperRightFissureGroup.isValid())
upperRightFissureMeshGroup = upperRightFissureGroup.getFieldElementGroup(mesh2d).getMeshGroup()
self.assertTrue(upperRightFissureMeshGroup.isValid())
surfaceAreaField = fieldmodule.createFieldMeshIntegral(one, coordinates, upperRightFissureMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 138894.27893716586, delta=1.0E-2)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 7225489.982550352, delta=1.0E-2)
# check some annotationGroups:
expectedSizes3d = {
"lung": 88,
"left lung": 44,
"right lung": 44,
"upper lobe of left lung": 24,
"lower lobe of left lung": 20,
"upper lobe of right lung": 16,
"middle lobe of right lung": 8,
"lower lobe of right lung": 20,
# "right lung accessory lobe": 0
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, get_lung_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
expectedSizes2d = {
"horizontal fissure of right lung": 4,
"oblique fissure of left lung": 8,
"oblique fissure of right lung": 8
}
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups, get_lung_term(name))
size = group.getMeshGroup(mesh2d).getSize()
self.assertEqual(expectedSizes2d[name], size, name)
# test finding a marker in scaffold
markerGroup = fieldmodule.findFieldByName("marker").castGroup()
markerNodes = markerGroup.getFieldNodeGroup(nodes).getNodesetGroup()
self.assertEqual(9, markerNodes.getSize())
markerName = fieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = fieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = fieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "apex of left lung")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(37, element.getIdentifier())
assertAlmostEqualList(self, xi, [ 0.0, 0.0, 1.0 ], 1.0E-10)
# refine 4 and check result
# first remove any face (but not point) annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and (annotationGroup.hasMeshGroup(mesh2d) or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(17, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine'] = True
options['Refine number of elements'] = 4
refineNumberOfElements = options['Refine number of elements']
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(20, len(annotationGroups))
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(5632, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(17344, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(17848, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(6147, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, get_lung_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name]*(refineNumberOfElements**3), size, name)
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups, get_lung_term(name))
size = group.getMeshGroup(mesh2d).getSize()
self.assertEqual(expectedSizes2d[name]*(refineNumberOfElements**2), size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(refinedNodes).getNodesetGroup()
self.assertEqual(9, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "apex of left lung")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(2353, element.getIdentifier())
assertAlmostEqualList(self, xi, [ 0.0, 0.0, 1.0 ], 1.0E-10)
def test_humancolonsegment1(self):
"""
Test creation of human colon segment scaffold.
"""
parameterSetNames = MeshType_3d_colonsegment1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Cattle 1", "Human 1", "Mouse 1", "Pig 1"])
options = MeshType_3d_colonsegment1.getDefaultOptions("Human 1")
self.assertEqual(31, len(options))
self.assertEqual(0.0, options.get("Start phase"))
self.assertEqual(2, options.get("Number of elements around tenia coli"))
self.assertEqual(4, options.get("Number of elements along segment"))
self.assertEqual(4, options.get("Number of elements through wall"))
self.assertEqual(43.5, options.get("Start inner radius"))
self.assertEqual(0.0, options.get("Start inner radius derivative"))
self.assertEqual(33.0, options.get("End inner radius"))
self.assertEqual(0.0, options.get("End inner radius derivative"))
self.assertEqual(3.0, options.get("Segment length mid derivative factor"))
self.assertEqual(50.0, options.get("Segment length"))
self.assertEqual(3, options.get("Number of tenia coli"))
self.assertEqual(10.0, options.get("Start tenia coli width"))
self.assertEqual(0.0, options.get("End tenia coli width derivative"))
self.assertEqual(1.6, options.get("Wall thickness"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = MeshType_3d_colonsegment1.generateBaseMesh(region, options)
self.assertEqual(8, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(504, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1746, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(2007, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(765, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-2.172286248499807e-15, -58.95670186936737, -55.54662267827035], 1.0E-6)
assertAlmostEqualList(self, maximums, [50.0, 50.52621132610023, 55.54662267827035], 1.0E-6)
flatCoordinates = fieldmodule.findFieldByName("flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(flatCoordinates, nodes)
assertAlmostEqualList(self, minimums, [0.0, 0.0, 0.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [397.2736607240895, 50.0, 2.2], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 21035.8818469729, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 39781.704358310606, delta=1.0E-6)
def test_esophagus1(self):
"""
Test creation of esophagus scaffold.
"""
scaffold = MeshType_3d_esophagus1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Human 1"])
options = scaffold.getDefaultOptions("Human 1")
self.assertEqual(15, len(options))
self.assertEqual(8, options.get("Number of elements around"))
self.assertEqual(12, options.get("Number of elements along"))
self.assertEqual(4, options.get("Number of elements through wall"))
self.assertEqual(5.0, options.get("Wall thickness"))
self.assertEqual(0.35, options.get("Mucosa relative thickness"))
self.assertEqual(0.15, options.get("Submucosa relative thickness"))
self.assertEqual(
0.25, options.get("Circular muscle layer relative thickness"))
self.assertEqual(
0.25, options.get("Longitudinal muscle layer relative thickness"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateBaseMesh(region, options)
self.assertEqual(12, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(384, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1280, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1416, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(524, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(
self, minimums,
[-17.57777917463216, -9.777573632674187, -14.999995678650333],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[40.16077850310996, 291.0400575669104, 14.999999571130854], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(
fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 27931.063402890817, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 116538.12918074048, delta=1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"abdominal part of esophagus": 64,
"cervical part of esophagus": 64,
"esophagus": 384,
"esophagus mucosa": 96,
"esophagus smooth muscle circular layer": 96,
"esophagus smooth muscle longitudinal layer": 96,
"submucosa of esophagus": 96,
"thoracic part of esophagus": 256
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_esophagus_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# refine 4x4x4 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and \
(annotationGroup.hasMeshGroup(mesh2d) or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(12, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements around'] = 4
options['Refine number of elements along'] = 4
options['Refine number of elements through wall'] = 4
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(13, len(annotationGroups))
#
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(24576, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(75776, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(77856, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(26660, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_esophagus_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 64, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(4, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(
markerNodes, markerName,
"distal point of lower esophageal sphincter serosa on the greater curvature of stomach"
)
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(24125, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 1.0, 1.0], 1.0E-10)
def createGraphics(self):
fieldmodule = self.getFieldmodule()
mesh = self._fitter.getHighestDimensionMesh()
meshDimension = mesh.getDimension()
modelCoordinates = self._fitter.getModelCoordinatesField()
componentsCount = modelCoordinates.getNumberOfComponents()
# prepare fields and calculate axis and glyph scaling
with ChangeManager(fieldmodule):
# fields in same order as nodeDerivativeLabels
nodeDerivativeFields = [
fieldmodule.createFieldNodeValue(modelCoordinates, derivative,
1)
for derivative in [
Node.VALUE_LABEL_D_DS1, Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D_DS3, Node.VALUE_LABEL_D2_DS1DS2,
Node.VALUE_LABEL_D2_DS1DS3, Node.VALUE_LABEL_D2_DS2DS3,
Node.VALUE_LABEL_D3_DS1DS2DS3
]
]
elementDerivativesField = fieldmodule.createFieldConcatenate([
fieldmodule.createFieldDerivative(modelCoordinates, d + 1)
for d in range(meshDimension)
])
cmiss_number = fieldmodule.findFieldByName("cmiss_number")
markerNodeGroup, markerLocation, markerCoordinates, markerName = self._fitter.getMarkerModelFields(
)
# get sizing for axes
axesScale = 1.0
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
minX, maxX = evaluateFieldNodesetRange(modelCoordinates, nodes)
if componentsCount == 1:
maxRange = maxX - minX
else:
maxRange = maxX[0] - minX[0]
for c in range(1, componentsCount):
maxRange = max(maxRange, maxX[c] - minX[c])
if maxRange > 0.0:
while axesScale * 10.0 < maxRange:
axesScale *= 10.0
while axesScale * 0.1 > maxRange:
axesScale *= 0.1
# fixed width glyph size is based on average element size in all dimensions
mesh1d = fieldmodule.findMeshByDimension(1)
meanLineLength = 0.0
lineCount = mesh1d.getSize()
if lineCount > 0:
one = fieldmodule.createFieldConstant(1.0)
sumLineLength = fieldmodule.createFieldMeshIntegral(
one, modelCoordinates, mesh1d)
cache = fieldmodule.createFieldcache()
result, totalLineLength = sumLineLength.evaluateReal(cache, 1)
glyphWidth = 0.1 * totalLineLength / lineCount
del cache
del sumLineLength
del one
if (lineCount == 0) or (glyphWidth == 0.0):
# use function of coordinate range if no elements
if componentsCount == 1:
maxScale = maxX - minX
else:
first = True
for c in range(componentsCount):
scale = maxX[c] - minX[c]
if first or (scale > maxScale):
maxScale = scale
first = False
if maxScale == 0.0:
maxScale = 1.0
glyphWidth = 0.01 * maxScale
glyphWidthSmall = 0.25 * glyphWidth
# make graphics
scene = self._fitter.getRegion().getScene()
with ChangeManager(scene):
scene.removeAllGraphics()
axes = scene.createGraphicsPoints()
pointattr = axes.getGraphicspointattributes()
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_AXES_XYZ)
pointattr.setBaseSize([axesScale, axesScale, axesScale])
pointattr.setLabelText(1, " " + str(axesScale))
axes.setMaterial(self._materialmodule.findMaterialByName("grey50"))
axes.setName("displayAxes")
axes.setVisibilityFlag(self.isDisplayAxes())
# marker points, projections
markerGroup = self._fitter.getMarkerGroup()
markerDataGroup, markerDataCoordinates, markerDataName = self._fitter.getMarkerDataFields(
)
markerDataLocation, markerDataLocationCoordinates, markerDataDelta = self._fitter.getMarkerDataLocationFields(
)
markerNodeGroup, markerLocation, markerCoordinates, markerName = self._fitter.getMarkerModelFields(
)
markerDataLocationGroupField = self._fitter.getMarkerDataLocationGroupField(
)
markerDataPoints = scene.createGraphicsPoints()
markerDataPoints.setFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
if markerDataLocationGroupField:
markerDataPoints.setSubgroupField(markerDataLocationGroupField)
elif markerGroup:
markerDataPoints.setSubgroupField(markerGroup)
if markerDataCoordinates:
markerDataPoints.setCoordinateField(markerDataCoordinates)
pointattr = markerDataPoints.getGraphicspointattributes()
pointattr.setBaseSize(
[glyphWidthSmall, glyphWidthSmall, glyphWidthSmall])
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_CROSS)
markerDataPoints.setMaterial(
self._materialmodule.findMaterialByName("yellow"))
markerDataPoints.setName("displayMarkerDataPoints")
markerDataPoints.setVisibilityFlag(
self.isDisplayMarkerDataPoints())
markerDataNames = scene.createGraphicsPoints()
markerDataNames.setFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
if markerDataLocationGroupField:
markerDataNames.setSubgroupField(markerDataLocationGroupField)
elif markerGroup:
markerDataNames.setSubgroupField(markerGroup)
if markerDataCoordinates:
markerDataNames.setCoordinateField(markerDataCoordinates)
pointattr = markerDataNames.getGraphicspointattributes()
pointattr.setBaseSize(
[glyphWidthSmall, glyphWidthSmall, glyphWidthSmall])
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_NONE)
if markerDataName:
pointattr.setLabelField(markerDataName)
markerDataNames.setMaterial(
self._materialmodule.findMaterialByName("yellow"))
markerDataNames.setName("displayMarkerDataNames")
markerDataNames.setVisibilityFlag(self.isDisplayMarkerDataNames())
markerDataProjections = scene.createGraphicsPoints()
markerDataProjections.setFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
if markerDataLocationGroupField:
markerDataProjections.setSubgroupField(
markerDataLocationGroupField)
elif markerGroup:
markerDataProjections.setSubgroupField(markerGroup)
if markerDataCoordinates:
markerDataProjections.setCoordinateField(markerDataCoordinates)
pointAttr = markerDataProjections.getGraphicspointattributes()
pointAttr.setGlyphShapeType(Glyph.SHAPE_TYPE_LINE)
pointAttr.setBaseSize([0.0, 1.0, 1.0])
pointAttr.setScaleFactors([1.0, 0.0, 0.0])
if markerDataDelta:
pointAttr.setOrientationScaleField(markerDataDelta)
markerDataProjections.setMaterial(
self._materialmodule.findMaterialByName("magenta"))
markerDataProjections.setName("displayMarkerDataProjections")
markerDataProjections.setVisibilityFlag(
self.isDisplayMarkerDataProjections())
markerPoints = scene.createGraphicsPoints()
markerPoints.setFieldDomainType(Field.DOMAIN_TYPE_NODES)
if markerGroup:
markerPoints.setSubgroupField(markerGroup)
if markerCoordinates:
markerPoints.setCoordinateField(markerCoordinates)
pointattr = markerPoints.getGraphicspointattributes()
pointattr.setBaseSize(
[glyphWidthSmall, glyphWidthSmall, glyphWidthSmall])
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_CROSS)
markerPoints.setMaterial(
self._materialmodule.findMaterialByName("white"))
markerPoints.setName("displayMarkerPoints")
markerPoints.setVisibilityFlag(self.isDisplayMarkerPoints())
markerNames = scene.createGraphicsPoints()
markerNames.setFieldDomainType(Field.DOMAIN_TYPE_NODES)
if markerGroup:
markerNames.setSubgroupField(markerGroup)
if markerCoordinates:
markerNames.setCoordinateField(markerCoordinates)
pointattr = markerNames.getGraphicspointattributes()
pointattr.setBaseSize(
[glyphWidthSmall, glyphWidthSmall, glyphWidthSmall])
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_NONE)
if markerName:
pointattr.setLabelField(markerName)
markerNames.setMaterial(
self._materialmodule.findMaterialByName("white"))
markerNames.setName("displayMarkerNames")
markerNames.setVisibilityFlag(self.isDisplayMarkerNames())
# data points, projections and projection points
dataCoordinates = self._fitter.getDataCoordinatesField()
dataPoints = scene.createGraphicsPoints()
dataPoints.setFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
if dataCoordinates:
dataPoints.setCoordinateField(dataCoordinates)
pointattr = dataPoints.getGraphicspointattributes()
# pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_DIAMOND)
# pointattr.setBaseSize([glyphWidthSmall, glyphWidthSmall, glyphWidthSmall])
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_POINT)
dataPoints.setRenderPointSize(3.0)
dataPoints.setMaterial(
self._materialmodule.findMaterialByName("grey50"))
dataPoints.setName("displayDataPoints")
dataPoints.setVisibilityFlag(self.isDisplayDataPoints())
for projectionMeshDimension in range(1, 3):
dataProjectionNodeGroup = self._fitter.getDataProjectionNodeGroupField(
projectionMeshDimension)
if dataProjectionNodeGroup.getNodesetGroup().getSize() == 0:
continue
dataProjectionCoordinates = self._fitter.getDataProjectionCoordinatesField(
projectionMeshDimension)
dataProjectionDelta = self._fitter.getDataProjectionDeltaField(
projectionMeshDimension)
dataProjectionError = self._fitter.getDataProjectionErrorField(
projectionMeshDimension)
dataProjections = scene.createGraphicsPoints()
dataProjections.setFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
dataProjections.setSubgroupField(dataProjectionNodeGroup)
if dataCoordinates:
dataProjections.setCoordinateField(dataCoordinates)
pointAttr = dataProjections.getGraphicspointattributes()
pointAttr.setGlyphShapeType(Glyph.SHAPE_TYPE_LINE)
pointAttr.setBaseSize([0.0, 1.0, 1.0])
pointAttr.setScaleFactors([1.0, 0.0, 0.0])
dataProjections.setRenderLineWidth(2.0 if (
projectionMeshDimension == 1) else 1.0)
if dataProjectionDelta:
pointAttr.setOrientationScaleField(dataProjectionDelta)
if dataProjectionError:
dataProjections.setDataField(dataProjectionError)
spectrummodule = scene.getSpectrummodule()
spectrum = spectrummodule.getDefaultSpectrum()
dataProjections.setSpectrum(spectrum)
dataProjections.setName("displayDataProjections")
dataProjections.setVisibilityFlag(
self.isDisplayDataProjections())
dataProjectionPoints = scene.createGraphicsPoints()
dataProjectionPoints.setFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
dataProjectionPoints.setSubgroupField(dataProjectionNodeGroup)
if dataProjectionCoordinates:
dataProjectionPoints.setCoordinateField(
dataProjectionCoordinates)
pointattr = dataProjectionPoints.getGraphicspointattributes()
# pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_DIAMOND)
# pointattr.setBaseSize([glyphWidthSmall, glyphWidthSmall, glyphWidthSmall])
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_POINT)
dataProjectionPoints.setRenderPointSize(3.0)
dataProjectionPoints.setMaterial(
self._materialmodule.findMaterialByName("grey50"))
dataProjectionPoints.setName("displayDataProjectionPoints")
dataProjectionPoints.setVisibilityFlag(
self.isDisplayDataProjectionPoints())
nodePoints = scene.createGraphicsPoints()
nodePoints.setFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodePoints.setCoordinateField(modelCoordinates)
pointattr = nodePoints.getGraphicspointattributes()
pointattr.setBaseSize([glyphWidth, glyphWidth, glyphWidth])
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_SPHERE)
nodePoints.setMaterial(
self._materialmodule.findMaterialByName("white"))
nodePoints.setName("displayNodePoints")
nodePoints.setVisibilityFlag(self.isDisplayNodePoints())
nodeNumbers = scene.createGraphicsPoints()
nodeNumbers.setFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodeNumbers.setCoordinateField(modelCoordinates)
pointattr = nodeNumbers.getGraphicspointattributes()
pointattr.setLabelField(cmiss_number)
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_NONE)
nodeNumbers.setMaterial(
self._materialmodule.findMaterialByName("green"))
nodeNumbers.setName("displayNodeNumbers")
nodeNumbers.setVisibilityFlag(self.isDisplayNodeNumbers())
# names in same order as nodeDerivativeLabels "D1", "D2", "D3", "D12", "D13", "D23", "D123" and nodeDerivativeFields
nodeDerivativeMaterialNames = [
"gold", "silver", "green", "cyan", "magenta", "yellow", "blue"
]
derivativeScales = [1.0, 1.0, 1.0, 0.5, 0.5, 0.5, 0.25]
for i in range(len(nodeDerivativeLabels)):
nodeDerivativeLabel = nodeDerivativeLabels[i]
nodeDerivatives = scene.createGraphicsPoints()
nodeDerivatives.setFieldDomainType(Field.DOMAIN_TYPE_NODES)
nodeDerivatives.setCoordinateField(modelCoordinates)
pointattr = nodeDerivatives.getGraphicspointattributes()
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_ARROW_SOLID)
pointattr.setOrientationScaleField(nodeDerivativeFields[i])
pointattr.setBaseSize([0.0, glyphWidth, glyphWidth])
pointattr.setScaleFactors([derivativeScales[i], 0.0, 0.0])
material = self._materialmodule.findMaterialByName(
nodeDerivativeMaterialNames[i])
nodeDerivatives.setMaterial(material)
nodeDerivatives.setSelectedMaterial(material)
nodeDerivatives.setName("displayNodeDerivatives" +
nodeDerivativeLabel)
nodeDerivatives.setVisibilityFlag(
self.isDisplayNodeDerivatives() and
self.isDisplayNodeDerivativeLabels(nodeDerivativeLabel))
elementNumbers = scene.createGraphicsPoints()
elementNumbers.setFieldDomainType(
Field.DOMAIN_TYPE_MESH_HIGHEST_DIMENSION)
elementNumbers.setCoordinateField(modelCoordinates)
pointattr = elementNumbers.getGraphicspointattributes()
pointattr.setLabelField(cmiss_number)
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_NONE)
elementNumbers.setMaterial(
self._materialmodule.findMaterialByName("cyan"))
elementNumbers.setName("displayElementNumbers")
elementNumbers.setVisibilityFlag(self.isDisplayElementNumbers())
elementAxes = scene.createGraphicsPoints()
elementAxes.setFieldDomainType(
Field.DOMAIN_TYPE_MESH_HIGHEST_DIMENSION)
elementAxes.setCoordinateField(modelCoordinates)
pointattr = elementAxes.getGraphicspointattributes()
pointattr.setGlyphShapeType(Glyph.SHAPE_TYPE_AXES_123)
pointattr.setOrientationScaleField(elementDerivativesField)
if meshDimension == 1:
pointattr.setBaseSize([0.0, 2 * glyphWidth, 2 * glyphWidth])
pointattr.setScaleFactors([0.25, 0.0, 0.0])
elif meshDimension == 2:
pointattr.setBaseSize([0.0, 0.0, 2 * glyphWidth])
pointattr.setScaleFactors([0.25, 0.25, 0.0])
else:
pointattr.setBaseSize([0.0, 0.0, 0.0])
pointattr.setScaleFactors([0.25, 0.25, 0.25])
elementAxes.setMaterial(
self._materialmodule.findMaterialByName("yellow"))
elementAxes.setName("displayElementAxes")
elementAxes.setVisibilityFlag(self.isDisplayElementAxes())
lines = scene.createGraphicsLines()
lines.setCoordinateField(modelCoordinates)
lines.setExterior(self.isDisplayLinesExterior())
lines.setName("displayLines")
lines.setVisibilityFlag(self.isDisplayLines())
surfaces = scene.createGraphicsSurfaces()
surfaces.setCoordinateField(modelCoordinates)
surfaces.setRenderPolygonMode(
Graphics.RENDER_POLYGON_MODE_WIREFRAME if self.
isDisplaySurfacesWireframe(
) else Graphics.RENDER_POLYGON_MODE_SHADED)
surfaces.setExterior(self.isDisplaySurfacesExterior() if (
meshDimension == 3) else False)
surfacesMaterial = self._materialmodule.findMaterialByName(
"trans_blue" if self.isDisplaySurfacesTranslucent(
) else "solid_blue")
surfaces.setMaterial(surfacesMaterial)
surfaces.setName("displaySurfaces")
surfaces.setVisibilityFlag(self.isDisplaySurfaces())
def test_bladderurethra1(self):
"""
Test creation of bladder scaffold.
"""
scaffold = MeshType_3d_bladderurethra1
parameterSetNames = MeshType_3d_bladderurethra1.getParameterSetNames()
self.assertEqual(parameterSetNames,
["Default", "Cat 1", "Rat 1", "Human 1"])
options = scaffold.getDefaultOptions("Cat 1")
self.assertEqual(26, len(options))
self.assertEqual(12, options.get("Number of elements along bladder"))
self.assertEqual(12, options.get("Number of elements around"))
self.assertEqual(1, options.get("Number of elements through wall"))
self.assertEqual(0.5, options.get("Wall thickness"))
self.assertEqual(45, options.get("Neck angle degrees"))
ostiumOptions = options['Ureter']
ostiumSettings = ostiumOptions.getScaffoldSettings()
self.assertEqual(1, ostiumSettings.get("Number of vessels"))
self.assertEqual(
8, ostiumSettings.get("Number of elements around ostium"))
self.assertEqual(1,
ostiumSettings.get("Number of elements through wall"))
self.assertEqual(2.2, ostiumSettings.get("Ostium diameter"))
self.assertEqual(0.5, ostiumSettings.get("Ostium length"))
self.assertEqual(0.5, ostiumSettings.get("Ostium wall thickness"))
self.assertEqual(0.8, ostiumSettings.get("Vessel inner diameter"))
self.assertEqual(0.25, ostiumSettings.get("Vessel wall thickness"))
self.assertEqual(0.0, ostiumSettings.get("Vessel angle 1 degrees"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateBaseMesh(region, options)
self.assertEqual(13, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(240, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(960, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1201, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(487, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums,
[-15.48570141314588, -12.992184072505665, -0.5],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[15.485696373577879, 13.837600783918127, 127.68599990411343],
1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(
fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 5335.535739164492, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 2555.81694845211, delta=1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"dome of the bladder": 108,
"neck of urinary bladder": 36,
"urethra": 96,
"urinary bladder": 144
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_bladder_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# test finding a marker in scaffold
markerGroup = fieldmodule.findFieldByName("marker").castGroup()
markerNodes = markerGroup.getFieldNodeGroup(nodes).getNodesetGroup()
self.assertEqual(5, markerNodes.getSize())
markerName = fieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = fieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = fieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName,
"apex of urinary bladder")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(1, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 0.0], 1.0E-10)
apexGroup = getAnnotationGroupForTerm(
annotationGroups, get_bladder_term("apex of urinary bladder"))
self.assertTrue(apexGroup.getNodesetGroup(nodes).containsNode(node))
# refine 4x4x4 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and (
annotationGroup.hasMeshGroup(mesh2d)
or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(13, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements along'] = 4
options['Refine number of elements around'] = 4
options['Refine number of elements through wall'] = 4
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
del meshrefinement
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(37, len(annotationGroups))
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(15360, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(49920, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(53764, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(19210, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_bladder_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 64, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(5, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
# test apex marker point
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName,
"apex of urinary bladder")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(1, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 0.0], 1.0E-10)
def test_heart1(self):
"""
Test creation of heart scaffold.
"""
scaffold = MeshType_3d_heart1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, [
"Default", "Human 1", "Mouse 1", "Pig 1", "Rat 1", "Unit Human 1",
"Unit Mouse 1", "Unit Pig 1", "Unit Rat 1"
])
options = scaffold.getDefaultOptions("Human 1")
self.assertEqual(117, len(options))
self.assertEqual(0.9, options.get("LV outer height"))
self.assertEqual(80.0, options.get("Unit scale"))
self.assertEqual(7,
options.get("Number of elements around LV free wall"))
self.assertEqual(7,
options.get("Number of elements around RV free wall"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(27, len(annotationGroups))
fieldmodule = region.getFieldmodule()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(289, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1117, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(1356, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(528, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums,
[-50.7876375290527, -57.76590573823474, -91.6],
1.0E-6)
assertAlmostEqualList(
self, maximums,
[43.81084359764995, 39.03925080604259, 40.71693637558552], 1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"left ventricle myocardium": 94,
"right ventricle myocardium": 79,
"interventricular septum": 30,
"left atrium myocardium": 88,
"right atrium myocardium": 62,
"interatrial septum": 17
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
expectedSizes2d = {
"endocardium of left ventricle": 74,
"endocardium of right ventricle": 59,
"endocardium of left atrium": 82,
"endocardium of right atrium": 56,
"epicardium": 197
}
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh2d).getSize()
self.assertEqual(expectedSizes2d[name], size, name)
# refine 2x2x2 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if annotationGroup.getMeshGroup(mesh3d).getSize() == 0:
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(18, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements surface'] = 2
options['Refine number of elements through LV wall'] = 2
options['Refine number of elements through wall'] = 2
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(27, len(annotationGroups))
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(2236, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(7676, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(8623, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(3183, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name] * 8, size, name)
for name in expectedSizes2d:
group = getAnnotationGroupForTerm(annotationGroups,
get_heart_term(name))
size = group.getMeshGroup(mesh2d).getSize()
if name == "epicardium":
# fibrous ring is only refined by 1 through its thickness
fibrousRingReduction = (
options['Refine number of elements surface'] - 1
) * options['Refine number of elements surface'] * (
options['Number of elements around left atrium free wall']
+
options['Number of elements around right atrium free wall']
)
self.assertEqual(
expectedSizes2d[name] * 4 - fibrousRingReduction, size,
name)
else:
self.assertEqual(expectedSizes2d[name] * 4, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(
refinedNodes).getNodesetGroup()
self.assertEqual(5, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "APEX")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(5, element.getIdentifier())
assertAlmostEqualList(self, xi, [0.0, 0.0, 1.0], 1.0E-10)
def test_transformation(self):
"""
Test transformation of a box scaffold with scaffold package.
"""
scaffoldPackage = ScaffoldPackage(MeshType_3d_box1)
tmpScale = scaffoldPackage.getScale()
TOL = 1.0E-7
FINETOL = 1.0E-12
assertAlmostEqualList(self, tmpScale, [ 1.0, 1.0, 1.0 ], delta=FINETOL)
newScale = [ 2.0, 1.5, 0.5 ]
scaffoldPackage.setScale(newScale)
tmpScale = scaffoldPackage.getScale()
assertAlmostEqualList(self, tmpScale, newScale, delta=FINETOL)
tmpRotation = scaffoldPackage.getRotation()
assertAlmostEqualList(self, tmpRotation, [ 0.0, 0.0, 0.0 ], delta=FINETOL)
newRotation = [ 30.0, -10.0, 90.0 ]
scaffoldPackage.setRotation(newRotation)
tmpRotation = scaffoldPackage.getRotation()
assertAlmostEqualList(self, tmpRotation, newRotation, delta=FINETOL)
tmpTranslation = scaffoldPackage.getTranslation()
assertAlmostEqualList(self, tmpTranslation, [ 0.0, 0.0, 0.0 ], delta=FINETOL)
newTranslation = [ 0.5, 1.2, -0.1 ]
scaffoldPackage.setTranslation(newTranslation)
tmpTranslation = scaffoldPackage.getTranslation()
assertAlmostEqualList(self, tmpTranslation, newTranslation, delta=FINETOL)
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
scaffoldPackage.generate(region)
fieldmodule = region.getFieldmodule()
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(8, nodes.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [ 2.744244002293470e-01, 6.367511648575830e-01, -1.000000000000000e-01 ], delta=TOL)
assertAlmostEqualList(self, maximums, [ 2.455737063904887e+00, 2.184807753012208e+00, 1.724507984852172e+00 ], delta=TOL)
node = nodes.findNodeByIdentifier(8)
self.assertTrue(node.isValid())
fieldcache = fieldmodule.createFieldcache()
fieldcache.setNode(node)
result, x = coordinates.getNodeParameters(fieldcache, -1, Node.VALUE_LABEL_VALUE, 1, 3)
self.assertEqual(RESULT_OK, result)
assertAlmostEqualList(self, x , [ 2.230161464134234e+00, 1.621558917869791e+00, 1.724507984852172e+00 ], delta=TOL)
# derivative magnitudes must also equal scale
result, d1 = coordinates.getNodeParameters(fieldcache, -1, Node.VALUE_LABEL_D_DS1, 1, 3)
self.assertEqual(RESULT_OK, result)
assertAlmostEqualList(self, d1, [ 1.705737064039425e+00, 9.848077530127952e-01, 3.472963553408093e-01 ], delta=TOL)
self.assertAlmostEqual(newScale[0], magnitude(d1), delta=TOL)
result, d2 = coordinates.getNodeParameters(fieldcache, -1, Node.VALUE_LABEL_D_DS2, 1, 3)
self.assertEqual(RESULT_OK, result)
assertAlmostEqualList(self, d2, [ -2.255755995328457e-01, -1.302361332111701e-01, 1.477211629352659e+00 ], delta=TOL)
self.assertAlmostEqual(newScale[1], magnitude(d2), delta=TOL)
result, d3 = coordinates.getNodeParameters(fieldcache, -1, Node.VALUE_LABEL_D_DS3, 1, 3)
self.assertEqual(RESULT_OK, result)
assertAlmostEqualList(self, d3, [ 2.499999998128999e-01, -4.330127019169794e-01, 0.000000000000000e+00 ], delta=TOL)
self.assertAlmostEqual(newScale[2], magnitude(d3), delta=TOL)
def test_sphere1(self):
"""
Test creation of Sphere scaffold.
"""
scaffold = MeshType_3d_solidsphere2
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default"])
options = scaffold.getDefaultOptions("Default")
self.assertEqual(16, len(options))
self.assertEqual(4, options.get("Number of elements across axis 1"))
self.assertEqual(4, options.get("Number of elements across axis 2"))
self.assertEqual(4, options.get("Number of elements across axis 3"))
self.assertEqual(0, options.get("Number of elements across shell"))
self.assertEqual(1,
options.get("Number of elements across transition"))
self.assertEqual(1.0, options.get("Radius1"))
self.assertEqual(1.0, options.get("Radius2"))
self.assertEqual(1.0, options.get("Radius3"))
self.assertEqual(1.0,
options.get("Shell element thickness proportion"))
self.assertEqual(
[0, 4], options.get("Range of elements required in direction 1"))
self.assertEqual(
[0, 4], options.get("Range of elements required in direction 2"))
self.assertEqual(
[0, 4], options.get("Range of elements required in direction 3"))
self.assertEqual([1, 2, 3], options.get("Box derivatives"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateMesh(region, options)
self.assertEqual(2, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(32, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(108, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(128, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(53, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, sphere volume
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-1.0, -1.0, -1.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [1.0, 1.0, 1.0], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
surfaceGroup = AnnotationGroup(region, ("sphere surface", ""))
is_exterior = fieldmodule.createFieldIsExterior()
surfaceMeshGroup = surfaceGroup.getMeshGroup(mesh2d)
surfaceMeshGroup.addElementsConditional(is_exterior)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, surfaceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 12.460033954564986, delta=2.0E-1)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 4.132033912594377, delta=1.0E-3)
# check some annotationGroups:
expectedSizes3d = {
"box group": 8,
"transition group": 24,
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, (name, ''))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# refine 8x8x8 and check result
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements'] = 2
meshrefinement = MeshRefinement(region, refineRegion, [])
scaffold.refineMesh(meshrefinement, options)
refineCoordinates = refineFieldmodule.findFieldByName(
"coordinates").castFiniteElement()
refineFieldmodule.defineAllFaces()
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(256, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(816, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(880, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(321, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# obtain surface area and volume again. If they are the same as previous, mesh is conform.
with ChangeManager(refineFieldmodule):
one = refineFieldmodule.createFieldConstant(1.0)
surfaceGroup = AnnotationGroup(refineRegion,
("sphere surface", ""))
is_exterior = refineFieldmodule.createFieldIsExterior()
surfaceMeshGroup = surfaceGroup.getMeshGroup(mesh2d)
surfaceMeshGroup.addElementsConditional(is_exterior)
surfaceAreaField = refineFieldmodule.createFieldMeshIntegral(
one, refineCoordinates, surfaceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = refineFieldmodule.createFieldMeshIntegral(
one, refineCoordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
refineFieldcache = refineFieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(
refineFieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 12.460033954564986, delta=5.0E-1)
result, volume = volumeField.evaluateReal(refineFieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 4.132033912594377, delta=3.0E-1)
# check ellipsoid.
scaffold1 = MeshType_3d_solidsphere2
parameterSetNames = scaffold1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default"])
options = scaffold1.getDefaultOptions("Default")
options['Number of elements across axis 1'] = 4
options['Number of elements across axis 2'] = 6
options['Number of elements across axis 3'] = 8
options['Range of elements required in direction 1'] = [0, 4]
options['Range of elements required in direction 2'] = [0, 6]
options['Range of elements required in direction 3'] = [0, 8]
options['Radius1'] = 0.5
options['Radius2'] = 0.8
options['Radius3'] = 1.0
context2 = Context("Test2")
region = context2.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold1.generateMesh(region, options)
self.assertEqual(2, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(136, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(452, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(510, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_NODES)
self.assertEqual(195, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(
Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check coordinates range, sphere volume
coordinates = fieldmodule.findFieldByName(
"coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-0.5, -0.8, -1.0], 1.0E-6)
assertAlmostEqualList(self, maximums, [0.5, 0.8, 1.0], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
surfaceGroup = AnnotationGroup(region, ("sphere surface", ""))
is_exterior = fieldmodule.createFieldIsExterior()
surfaceMeshGroup = surfaceGroup.getMeshGroup(mesh2d)
surfaceMeshGroup.addElementsConditional(is_exterior)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(
one, coordinates, surfaceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(
one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 7.3015173697377245, delta=2.0E-1)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 1.6741674010981926, delta=1.0E-3)
def test_colon1(self):
"""
Test creation of colon scaffold.
"""
parameterSetNames = MeshType_3d_colon1.getParameterSetNames()
self.assertEqual(parameterSetNames, ["Default", "Human 1", "Human 2", "Mouse 1", "Mouse 2", "Pig 1", "Pig 2"])
centralPathDefaultScaffoldPackages = {
'Test line': ScaffoldPackage(MeshType_1d_path1, {
'scaffoldSettings': {
'Coordinate dimensions': 3,
'Length': 1.0,
'Number of elements': 1
},
'meshEdits': exnodeStringFromNodeValues(
[Node.VALUE_LABEL_VALUE, Node.VALUE_LABEL_D_DS1, Node.VALUE_LABEL_D_DS2,
Node.VALUE_LABEL_D2_DS1DS2], [
[[163.7, -25.2, 12.2], [-21.7, 50.1, -18.1], [0.0, 0.0, 5.0], [0.0, 0.0, 0.5]],
[[117.2, 32.8, -2.6], [-64.3, 34.4, -3.9], [0.0, 0.0, 5.0], [0.0, 0.0, 0.5]]])
})
}
centralPathOption = centralPathDefaultScaffoldPackages['Test line']
segmentProfileOption = ScaffoldPackage(MeshType_3d_colonsegment1, defaultParameterSetName='Human 1')
options = {
'Central path': copy.deepcopy(centralPathOption),
'Segment profile': segmentProfileOption,
'Number of segments': 3,
'Start phase': 0.0,
'Proximal length': 25.0,
'Transverse length': 25.0,
'Distal length': 25.0,
'Proximal inner radius': 20.0,
'Proximal tenia coli width': 8.0,
'Proximal-transverse inner radius': 18.0,
'Proximal-transverse tenia coli width': 6.0,
'Transverse-distal inner radius': 16.0,
'Transverse-distal tenia coli width': 5.0,
'Distal inner radius': 15.0,
'Distal tenia coli width': 5.0,
'Refine': False,
'Refine number of elements around': 1,
'Refine number of elements along': 1,
'Refine number of elements through wall': 1
}
self.assertEqual(19, len(options))
centralPath = options['Central path']
segmentProfile = options.get("Segment profile")
segmentSettings = segmentProfile.getScaffoldSettings()
self.assertEqual(8, segmentSettings.get("Number of elements around haustrum"))
self.assertEqual(0.5, segmentSettings.get("Corner inner radius factor"))
self.assertEqual(0.5, segmentSettings.get("Haustrum inner radius factor"))
self.assertEqual(0.5, segmentSettings.get("Segment length end derivative factor"))
self.assertEqual(3, segmentSettings.get("Number of tenia coli"))
self.assertEqual(1.6, segmentSettings.get("Tenia coli thickness"))
self.assertEqual(3, options.get("Number of segments"))
self.assertEqual(0.0, options.get("Start phase"))
self.assertEqual(25.0, options.get("Transverse length"))
self.assertEqual(20.0, options.get("Proximal inner radius"))
self.assertEqual(6.0, options.get("Proximal-transverse tenia coli width"))
self.assertEqual(16.0, options.get("Transverse-distal inner radius"))
self.assertEqual(5.0, options.get("Distal tenia coli width"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
tmpRegion = region.createRegion()
centralPath.generate(tmpRegion)
cx = extractPathParametersFromRegion(tmpRegion)[0]
self.assertEqual(2, len(cx))
assertAlmostEqualList(self, cx[0], [ 163.7, -25.2, 12.2 ], 1.0E-6)
assertAlmostEqualList(self, cx[1], [ 117.2, 32.8, -2.6 ], 1.0E-6)
del tmpRegion
annotationGroups = MeshType_3d_colon1.generateBaseMesh(region, options)
self.assertEqual(7, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
if annotationGroups is not None:
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(432, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(1656, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(2043, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(819, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [ 108.0250647983898, -36.876103983560014, -25.89741158325083 ], 1.0E-6)
assertAlmostEqualList(self, maximums, [ 185.46457506220003, 48.101157490744, 34.995316052158934 ], 1.0E-6)
flatCoordinates = fieldmodule.findFieldByName("flat coordinates").castFiniteElement()
self.assertTrue(flatCoordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(flatCoordinates, nodes)
assertAlmostEqualList(self, minimums, [ 0.0, 0.0, 0.0 ], 1.0E-6)
assertAlmostEqualList(self, maximums, [ 186.72988844629867, 77.4178187926561, 3.2000000000000006 ], 1.0E-6)
textureCoordinates = fieldmodule.findFieldByName("texture coordinates").castFiniteElement()
minimums, maximums = evaluateFieldNodesetRange(textureCoordinates, nodes)
assertAlmostEqualList(self, minimums, [ 0.0, 0.0, 0.0 ], 1.0E-6)
assertAlmostEqualList(self, maximums, [ 0.9812471574796385, 1.0, 2.0 ], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 14612.416788520026, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 26826.069540921028, delta=1.0E-6)
def test_stomach1(self):
"""
Test creation of stomach scaffold.
"""
scaffold = MeshType_3d_stomach1
parameterSetNames = scaffold.getParameterSetNames()
self.assertEqual(parameterSetNames, [ "Default", "Human 1", "Rat 1" ])
options = scaffold.getDefaultOptions("Rat 1")
self.assertEqual(15, len(options))
self.assertEqual(12, options.get("Number of elements around esophagus"))
self.assertEqual(14, options.get("Number of elements around duodenum"))
self.assertEqual(2, options.get("Number of elements between cardia and duodenum"))
self.assertEqual(1, options.get("Number of elements across cardia"))
self.assertEqual(0.5, options.get("Wall thickness"))
self.assertEqual(True, options.get("Limiting ridge"))
ostiumOptions = options['Gastro-esophagal junction']
ostiumSettings = ostiumOptions.getScaffoldSettings()
self.assertEqual(1, ostiumSettings.get("Number of vessels"))
self.assertEqual(8, ostiumSettings.get("Number of elements around ostium"))
self.assertEqual(1, ostiumSettings.get("Number of elements through wall"))
self.assertEqual(4.0, ostiumSettings.get("Ostium diameter"))
self.assertEqual(3.5, ostiumSettings.get("Ostium length"))
self.assertEqual(0.5, ostiumSettings.get("Ostium wall thickness"))
self.assertEqual(1.25, ostiumSettings.get("Vessel inner diameter"))
self.assertEqual(0.5, ostiumSettings.get("Vessel wall thickness"))
self.assertEqual(0.0, ostiumSettings.get("Vessel angle 1 degrees"))
self.assertEqual(0.55, options.get("Gastro-esophagal junction position along factor"))
self.assertEqual(0.2, options.get("Cardia derivative factor"))
context = Context("Test")
region = context.getDefaultRegion()
self.assertTrue(region.isValid())
annotationGroups = scaffold.generateBaseMesh(region, options)
self.assertEqual(13, len(annotationGroups))
fieldmodule = region.getFieldmodule()
self.assertEqual(RESULT_OK, fieldmodule.defineAllFaces())
mesh3d = fieldmodule.findMeshByDimension(3)
self.assertEqual(158, mesh3d.getSize())
mesh2d = fieldmodule.findMeshByDimension(2)
self.assertEqual(643, mesh2d.getSize())
mesh1d = fieldmodule.findMeshByDimension(1)
self.assertEqual(823, mesh1d.getSize())
nodes = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(342, nodes.getSize())
datapoints = fieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
coordinates = fieldmodule.findFieldByName("coordinates").castFiniteElement()
self.assertTrue(coordinates.isValid())
minimums, maximums = evaluateFieldNodesetRange(coordinates, nodes)
assertAlmostEqualList(self, minimums, [-18.535034704449842, -14.989550140413265, -8.726949180639382], 1.0E-6)
assertAlmostEqualList(self, maximums, [18.39909561216101, 15.187335864125645, 8.727618869278126], 1.0E-6)
with ChangeManager(fieldmodule):
one = fieldmodule.createFieldConstant(1.0)
faceMeshGroup = createFaceMeshGroupExteriorOnFace(fieldmodule, Element.FACE_TYPE_XI3_1)
surfaceAreaField = fieldmodule.createFieldMeshIntegral(one, coordinates, faceMeshGroup)
surfaceAreaField.setNumbersOfPoints(4)
volumeField = fieldmodule.createFieldMeshIntegral(one, coordinates, mesh3d)
volumeField.setNumbersOfPoints(3)
fieldcache = fieldmodule.createFieldcache()
result, surfaceArea = surfaceAreaField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(surfaceArea, 2452.212186914634, delta=1.0E-6)
result, volume = volumeField.evaluateReal(fieldcache, 1)
self.assertEqual(result, RESULT_OK)
self.assertAlmostEqual(volume, 1175.367658574881, delta=1.0E-6)
# check some annotationGroups:
expectedSizes3d = {
"body of stomach" : 28,
"cardia of stomach" : 12,
"duodenum" : 14,
"esophagus" : 24,
"fundus of stomach" : 38,
"pyloric antrum" : 28,
"pylorus": 14,
"stomach": 158
}
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, get_stomach_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name], size, name)
# refine 4x4x4 and check result
# first remove any surface annotation groups as they are re-added by defineFaceAnnotations
removeAnnotationGroups = []
for annotationGroup in annotationGroups:
if (not annotationGroup.hasMeshGroup(mesh3d)) and (annotationGroup.hasMeshGroup(mesh2d) or annotationGroup.hasMeshGroup(mesh1d)):
removeAnnotationGroups.append(annotationGroup)
for annotationGroup in removeAnnotationGroups:
annotationGroups.remove(annotationGroup)
self.assertEqual(13, len(annotationGroups))
refineRegion = region.createRegion()
refineFieldmodule = refineRegion.getFieldmodule()
options['Refine number of elements surface'] = 4
options['Refine number of elements through wall'] = 4
meshrefinement = MeshRefinement(region, refineRegion, annotationGroups)
scaffold.refineMesh(meshrefinement, options)
annotationGroups = meshrefinement.getAnnotationGroups()
refineFieldmodule.defineAllFaces()
oldAnnotationGroups = copy.copy(annotationGroups)
for annotationGroup in annotationGroups:
annotationGroup.addSubelements()
scaffold.defineFaceAnnotations(refineRegion, options, annotationGroups)
for annotation in annotationGroups:
if annotation not in oldAnnotationGroups:
annotationGroup.addSubelements()
self.assertEqual(16, len(annotationGroups))
#
mesh3d = refineFieldmodule.findMeshByDimension(3)
self.assertEqual(10112, mesh3d.getSize())
mesh2d = refineFieldmodule.findMeshByDimension(2)
self.assertEqual(33232, mesh2d.getSize())
mesh1d = refineFieldmodule.findMeshByDimension(1)
self.assertEqual(36028, mesh1d.getSize())
nodes = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
self.assertEqual(12936, nodes.getSize())
datapoints = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_DATAPOINTS)
self.assertEqual(0, datapoints.getSize())
# check some refined annotationGroups:
for name in expectedSizes3d:
group = getAnnotationGroupForTerm(annotationGroups, get_stomach_term(name))
size = group.getMeshGroup(mesh3d).getSize()
self.assertEqual(expectedSizes3d[name]*64, size, name)
# test finding a marker in refined scaffold
markerGroup = refineFieldmodule.findFieldByName("marker").castGroup()
refinedNodes = refineFieldmodule.findNodesetByFieldDomainType(Field.DOMAIN_TYPE_NODES)
markerNodes = markerGroup.getFieldNodeGroup(refinedNodes).getNodesetGroup()
self.assertEqual(4, markerNodes.getSize())
markerName = refineFieldmodule.findFieldByName("marker_name")
self.assertTrue(markerName.isValid())
markerLocation = refineFieldmodule.findFieldByName("marker_location")
self.assertTrue(markerLocation.isValid())
cache = refineFieldmodule.createFieldcache()
node = findNodeWithName(markerNodes, markerName, "gastro-esophagal junction on lesser curvature")
self.assertTrue(node.isValid())
cache.setNode(node)
element, xi = markerLocation.evaluateMeshLocation(cache, 3)
self.assertEqual(1213, element.getIdentifier())
assertAlmostEqualList(self, xi, [ 0.0, 1.0, 1.0 ], 1.0E-10)
