def test_pointset():
n_points = 5
dimension = 3
PointSetType = itk.PointSet[itk.F, dimension]
pointset = PointSetType.New()
points = np.random.random((n_points, dimension)).astype(np.float32)
pointset.SetPoints(itk.vector_container_from_array(points.ravel()))
point_data = np.random.random((n_points, )).astype(np.float32)
pointset.SetPointData(itk.vector_container_from_array(point_data.ravel()))
itk_pointset_dict = itk.dict_from_pointset(pointset)
# Bug, to be fixed by 5.3.0
itk_pointset_dict.pop('dimension', None)
itkwasm_pointset = PointSet(**itk_pointset_dict)
itkwasm_pointset_dict = asdict(itkwasm_pointset)
itk_pointset_roundtrip = itk.pointset_from_dict(itkwasm_pointset_dict)
itk_pointset_roundtrip_dict = itk.dict_from_pointset(
itk_pointset_roundtrip)
pointSetType = itk_pointset_dict["pointSetType"]
pointSetType_roundtrip = itk_pointset_roundtrip_dict["pointSetType"]
assert pointSetType["dimension"] == pointSetType_roundtrip["dimension"]
assert pointSetType["pointComponentType"] == pointSetType_roundtrip[
"pointComponentType"]
assert pointSetType["pointPixelComponentType"] == pointSetType_roundtrip[
"pointPixelComponentType"]
assert pointSetType["pointPixelType"] == pointSetType_roundtrip[
"pointPixelType"]
assert pointSetType["pointPixelComponents"] == pointSetType_roundtrip[
"pointPixelComponents"]
assert itk_pointset_dict["name"] == itk_pointset_roundtrip_dict["name"]
assert itk_pointset_dict["numberOfPoints"] == itk_pointset_roundtrip_dict[
"numberOfPoints"]
assert np.array_equal(itk_pointset_dict["points"],
itk_pointset_roundtrip_dict["points"])
assert itk_pointset_dict[
"numberOfPointPixels"] == itk_pointset_roundtrip_dict[
"numberOfPointPixels"]
assert np.array_equal(itk_pointset_dict["pointData"],
itk_pointset_roundtrip_dict["pointData"])
PointType = itk.Point[itk.F, 3]
if os.name == 'nt':
v_point = itk.VectorContainer[itk.ULL, PointType].New()
else:
v_point = itk.VectorContainer[itk.UL, PointType].New()
v_point.Reserve(NumberOfPoints)
point = PointType()
for i in range(NumberOfPoints):
point[0] = i + 1.0
point[1] = i + 2.0
point[2] = i + 3.0
v_point.SetElement(i, point)
arr = itk.array_view_from_vector_container(v_point)
points_vc = itk.vector_container_from_array(arr.flatten())
mesh.SetPoints(points_vc)
# Set Cells in the Mesh as Triangle Cell
cells_array = np.zeros([NumberOfCells, Dimension], np.uint64)
# Insert point ids in that cell
for i in range(NumberOfCells):
cells_array[i, :] = [i * 1, (i + 1) * 2, (i + 2) * 3]
# Insert the cells in mesh by converting to 1D array
cells_vector = itk.vector_container_from_array(cells_array.flatten())
# Test the API for same type of cells
mesh.SetCellsArray(cells_vector, itk.CommonEnums.CellGeometry_TRIANGLE_CELL)
PointType = itk.Point[itk.F, 3]
if os.name == 'nt':
v_point = itk.VectorContainer[itk.ULL, PointType].New()
else:
v_point = itk.VectorContainer[itk.UL, PointType].New()
v_point.Reserve(NumberOfPoints)
point = PointType()
for i in range(NumberOfPoints):
point[0] = i + 1.0
point[1] = i + 2.0
point[2] = i + 3.0
v_point.SetElement(i, point)
arr = itk.array_view_from_vector_container(v_point)
points_vc = itk.vector_container_from_array(arr.flatten())
point_set.SetPoints(points_vc)
# Check the serialization of mesh
serialize_deserialize = pickle.loads(pickle.dumps(point_set))
assert serialize_deserialize.GetNumberOfPoints(
) == point_set.GetNumberOfPoints()
assert serialize_deserialize.GetObjectName() == point_set.GetObjectName()
# Check if points are same
p1 = itk.array_from_vector_container(serialize_deserialize.GetPoints())
p2 = itk.array_from_vector_container(point_set.GetPoints())
assert np.array_equal(p1, p2)
def test_NumPyBridge_VectorContainer(self):
"Try to convert a itk.VectorContainer into a Numpy array and back."
if not (hasattr(itk.VectorContainer, "ULLF") and hasattr(
itk.PyVectorContainer, "F") and hasattr(itk.Point, "F3")
and hasattr(itk.VectorContainer, "ULLPF3")
and hasattr(itk.Point, "F2")
and hasattr(itk.VectorContainer, "ULLPF2")):
# There is insufficient wrapping to perform this test; skip it.
print('Insufficient wrapping to perform itkPyVectorContainerTest')
return
v1 = itk.VectorContainer[itk.ULL, itk.F].New()
v1.Reserve(4)
v1.SetElement(0, 1.2)
v1.SetElement(1, 2)
v1.SetElement(2, 4)
v1.SetElement(3, 5)
arr = itk.array_view_from_vector_container(v1)
v2 = itk.vector_container_from_array(arr)
self.assertEqual(v1.Size(), arr.shape[0])
self.assertEqual(v1.Size(), v2.Size())
# Compute difference between the original vector and numpy array view
diff = 0.0
for ii in range(0, v1.Size()):
diff += abs(v1.GetElement(ii) - arr[ii])
self.assertEqual(0, diff)
# Compute difference between the two vectors
diff = 0.0
for ii in range(0, v1.Size()):
diff += abs(v1.GetElement(ii) - v2.GetElement(ii))
self.assertEqual(0, diff)
# Test view
v1.SetElement(0, 1)
self.assertEqual(v1.GetElement(0), arr[0])
# Test deep copy
arr_cp = itk.array_from_vector_container(v1)
self.assertEqual(v1.GetElement(0), arr_cp[0])
v1.SetElement(0, 0)
self.assertNotEqual(v1.GetElement(0), arr_cp[0])
v2_cp = itk.vector_container_from_array(arr_cp)
arr_cp[0] = 2
self.assertNotEqual(v2_cp.GetElement(0), arr_cp[0])
PointType = itk.Point[itk.F, 3]
v_point = itk.VectorContainer[itk.ULL, PointType].New()
v_point.Reserve(2)
point = PointType()
point[0] = 1.0
point[1] = 2.0
point[2] = 4.0
v_point.SetElement(0, point)
point[0] = 6.0
point[1] = 8.0
point[2] = 9.0
v_point.SetElement(1, point)
arr = itk.array_view_from_vector_container(v_point)
self.assertTrue(
np.array_equal(arr, np.array([[1.0, 2.0, 4.0], [6.0, 8.0, 9.0]])))
PointType = itk.Point[itk.F, 2]
v_point = itk.VectorContainer[itk.ULL, PointType].New()
v_point.Reserve(2)
point = PointType()
point[0] = 1.0
point[1] = 2.0
v_point.SetElement(0, point)
point[0] = 6.0
point[1] = 8.0
v_point.SetElement(1, point)
arr = itk.array_view_from_vector_container(v_point)
self.assertTrue(np.array_equal(arr, np.array([[1.0, 2.0], [6.0,
8.0]])))