def generateWarpedMesh(
mesh_folder,
mesh_basename,
images,
structure,
deformation,
evolution,
verbose=0):
myVTK.myPrint(verbose, "*** generateWarpedMesh ***")
mesh = myVTK.readUGrid(
filename=mesh_folder+"/"+mesh_basename+".vtk",
verbose=verbose-1)
n_points = mesh.GetNumberOfPoints()
n_cells = mesh.GetNumberOfCells()
if os.path.exists(mesh_folder+"/"+mesh_basename+"-WithLocalBasis.vtk"):
ref_mesh = myVTK.readUGrid(
filename=mesh_folder+"/"+mesh_basename+"-WithLocalBasis.vtk",
verbose=verbose-1)
else:
ref_mesh = None
farray_disp = myVTK.createFloatArray(
name="displacement",
n_components=3,
n_tuples=n_points,
verbose=verbose-1)
mesh.GetPointData().AddArray(farray_disp)
mapping = Mapping(images, structure, deformation, evolution)
X = numpy.empty(3)
x = numpy.empty(3)
U = numpy.empty(3)
if ("zfill" not in images.keys()):
images["zfill"] = len(str(images["n_frames"]))
for k_frame in xrange(images["n_frames"]):
t = images["T"]*float(k_frame)/(images["n_frames"]-1) if (images["n_frames"]>1) else 0.
mapping.init_t(t)
for k_point in xrange(n_points):
mesh.GetPoint(k_point, X)
mapping.x(X, x)
U = x - X
farray_disp.SetTuple(k_point, U)
myVTK.computeStrainsFromDisplacements(
mesh=mesh,
disp_array_name="displacement",
ref_mesh=ref_mesh,
verbose=verbose-1)
myVTK.writeUGrid(
ugrid=mesh,
filename=mesh_folder+"/"+mesh_basename+"_"+str(k_frame).zfill(images["zfill"])+".vtk",
verbose=verbose-1)
def generateWarpedMesh(mesh_folder,
mesh_basename,
images,
structure,
deformation,
evolution,
verbose=0):
myVTK.myPrint(verbose, "*** generateWarpedMesh ***")
mesh = myVTK.readUGrid(filename=mesh_folder + "/" + mesh_basename + ".vtk",
verbose=verbose - 1)
n_points = mesh.GetNumberOfPoints()
n_cells = mesh.GetNumberOfCells()
if os.path.exists(mesh_folder + "/" + mesh_basename +
"-WithLocalBasis.vtk"):
ref_mesh = myVTK.readUGrid(filename=mesh_folder + "/" + mesh_basename +
"-WithLocalBasis.vtk",
verbose=verbose - 1)
else:
ref_mesh = None
farray_disp = myVTK.createFloatArray(name="displacement",
n_components=3,
n_tuples=n_points,
verbose=verbose - 1)
mesh.GetPointData().AddArray(farray_disp)
mapping = Mapping(images, structure, deformation, evolution)
X = numpy.empty(3)
x = numpy.empty(3)
U = numpy.empty(3)
if ("zfill" not in images.keys()):
images["zfill"] = len(str(images["n_frames"]))
for k_frame in xrange(images["n_frames"]):
t = images["T"] * float(k_frame) / (images["n_frames"] - 1) if (
images["n_frames"] > 1) else 0.
mapping.init_t(t)
for k_point in xrange(n_points):
mesh.GetPoint(k_point, X)
mapping.x(X, x)
U = x - X
farray_disp.SetTuple(k_point, U)
myVTK.computeStrainsFromDisplacements(mesh=mesh,
disp_array_name="displacement",
ref_mesh=ref_mesh,
verbose=verbose - 1)
myVTK.writeUGrid(ugrid=mesh,
filename=mesh_folder + "/" + mesh_basename + "_" +
str(k_frame).zfill(images["zfill"]) + ".vtk",
verbose=verbose - 1)
def readDataSet(filename, verbose=0):
mypy.my_print(verbose, "*** readDataSet: " + filename + " ***")
assert (os.path.isfile(filename)
), "Wrong filename (\"" + filename + "\"). Aborting."
file_ext = filename[-3:]
if (file_ext == "vtk"):
for line in open(filename):
if (line.split()[0] == "DATASET"):
dataset_type = line.split()[-1]
break
assert ("dataset_type" in locals()), "Wrong file format. Aborting."
if (dataset_type == "STRUCTURED_POINTS"):
return myvtk.readSPoints(filename=filename, verbose=verbose - 1)
elif (dataset_type == "STRUCTURED_GRID"):
return myvtk.readSGrid(filename=filename, verbose=verbose - 1)
elif (dataset_type == "UNSTRUCTURED_GRID"):
return myvtk.readUGrid(filename=filename, verbose=verbose - 1)
elif (dataset_type == "POLYDATA"):
return myvtk.readPData(filename=filename, verbose=verbose - 1)
elif (dataset_type == "RECTILINEAR_GRID") or (dataset_type == "FIELD"):
assert 0, "Not implemented. Aborting."
else:
assert 0, "Wrong dataset type (" + dataset_type + "). Aborting."
elif (file_ext == "vti"):
return myvtk.readImage(filename=filename, verbose=verbose - 1)
elif (file_ext == "vtp") or (file_ext == "stl"):
return myvtk.readPData(filename=filename, verbose=verbose - 1)
elif (file_ext == "vts"):
return myvtk.readSGrid(filename=filename, verbose=verbose - 1)
elif (file_ext == "vtu"):
return myvtk.readUGrid(filename=filename, verbose=verbose - 1)
else:
assert 0, "Wrong extention (" + file_ext + "). Extention must be vtk, vti, vtp, stl, vts, vtu. Aborting."
#coding=utf8
########################################################################
### ###
### Created by Martin Genet, 2012-2017 ###
### ###
### University of California at San Francisco (UCSF), USA ###
### Swiss Federal Institute of Technology (ETH), Zurich, Switzerland ###
### École Polytechnique, Palaiseau, France ###
### ###
########################################################################
import argparse
import myPythonLibrary as mypy
import myVTKPythonLibrary as myvtk
########################################################################
if (__name__ == "__main__"):
parser = argparse.ArgumentParser()
parser.add_argument('vtu_filename', type=str)
args = parser.parse_args()
assert (args.vtu_filename.endswith(".vtu"))
mesh = myvtk.readUGrid(
filename=args.vtu_filename)
myvtk.writeUGrid(
ugrid=mesh,
filename=args.vtu_filename.replace(".vtu", ".vtk"))
#coding=utf8
########################################################################
### ###
### Created by Martin Genet, 2012-2016 ###
### ###
### University of California at San Francisco (UCSF), USA ###
### Swiss Federal Institute of Technology (ETH), Zurich, Switzerland ###
### École Polytechnique, Palaiseau, France ###
### ###
########################################################################
import argparse
import myPythonLibrary as mypy
import myVTKPythonLibrary as myvtk
########################################################################
if (__name__ == "__main__"):
parser = argparse.ArgumentParser()
parser.add_argument('vtk_filename', type=str)
args = parser.parse_args()
assert (args.vtk_filename.endswith(".vtk"))
mesh = myvtk.readUGrid(
filename=args.vtk_filename)
myvtk.writeUGrid(
ugrid=mesh,
filename=args.vtk_filename.replace(".vtk", ".vtu"))
filter_geometry.SetInput(ugrid)
filter_geometry.Update()
pdata = filter_geometry.GetOutput()
if (only_trianlges):
filter_triangle = vtk.vtkTriangleFilter()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
filter_triangle.SetInputData(pdata)
else:
filter_triangle.SetInput(pdata)
filter_triangle.Update()
pdata = filter_triangle.GetOutput()
return pdata
########################################################################
if (__name__ == "__main__"):
parser = argparse.ArgumentParser()
parser.add_argument('ugrid_filename', type=str)
args = parser.parse_args()
assert (args.ugrid_filename.endswith(".vtu"))
ugrid = myvtk.readUGrid(
filename=args.ugrid_filename)
pdata = myvtk.ugrid2pdata(
ugrid=ugrid)
myvtk.writePData(
pdata=pdata,
filename=args.ugrid_filename.replace(".vtu", ".vtp"))
filter_geometry.SetInputData(ugrid)
else:
filter_geometry.SetInput(ugrid)
filter_geometry.Update()
pdata = filter_geometry.GetOutput()
if (only_trianlges):
filter_triangle = vtk.vtkTriangleFilter()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
filter_triangle.SetInputData(pdata)
else:
filter_triangle.SetInput(pdata)
filter_triangle.Update()
pdata = filter_triangle.GetOutput()
return pdata
########################################################################
if (__name__ == "__main__"):
parser = argparse.ArgumentParser()
parser.add_argument("ugrid_filename", type=str)
args = parser.parse_args()
assert (args.ugrid_filename.endswith(".vtu"))
ugrid = myvtk.readUGrid(filename=args.ugrid_filename)
pdata = myvtk.ugrid2pdata(ugrid=ugrid)
myvtk.writePData(pdata=pdata,
filename=args.ugrid_filename.replace(".vtu", ".vtp"))
def generateUnwarpedImages(
images_folder,
images_basename,
sol_folder,
sol_basename,
sol_ext="vtu",
verbose=0):
myVTK.myPrint(verbose, "*** generateUnwarpedImages ***")
ref_image_zfill = len(glob.glob(images_folder+"/"+images_basename+"_*.vti")[0].rsplit("_")[-1].split(".")[0])
ref_image_filename = images_folder+"/"+images_basename+"_"+str(0).zfill(ref_image_zfill)+".vti"
ref_image = myVTK.readImage(
filename=ref_image_filename)
image = vtk.vtkImageData()
image.SetOrigin(ref_image.GetOrigin())
image.SetSpacing(ref_image.GetSpacing())
image.SetExtent(ref_image.GetExtent())
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image.AllocateScalars(vtk.VTK_FLOAT, 1)
else:
image.SetScalarTypeToFloat()
image.SetNumberOfScalarComponents(1)
image.AllocateScalars()
scalars = image.GetPointData().GetScalars()
sol_zfill = len(glob.glob(sol_folder+"/"+sol_basename+"_*."+sol_ext)[0].rsplit("_")[-1].split(".")[0])
n_frames = len(glob.glob(sol_folder+"/"+sol_basename+"_"+"[0-9]"*sol_zfill+"."+sol_ext))
#n_frames = 1
X = numpy.empty(3)
U = numpy.empty(3)
x = numpy.empty(3)
I = numpy.empty(1)
m = numpy.empty(1)
for k_frame in xrange(n_frames):
myVTK.myPrint(verbose, "k_frame = "+str(k_frame))
def_image = myVTK.readImage(
filename=images_folder+"/"+images_basename+"_"+str(k_frame).zfill(ref_image_zfill)+".vti")
interpolator = myVTK.createImageInterpolator(
image=def_image)
mesh = myVTK.readUGrid(
filename=sol_folder+"/"+sol_basename+"_"+str(k_frame).zfill(sol_zfill)+"."+sol_ext)
probe = vtk.vtkProbeFilter()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
probe.SetInputData(image)
probe.SetSourceData(mesh)
else:
probe.SetInput(image)
probe.SetSource(mesh)
probe.Update()
probed_image = probe.GetOutput()
scalars_mask = probed_image.GetPointData().GetArray("vtkValidPointMask")
scalars_U = probed_image.GetPointData().GetArray("displacement")
for k_point in xrange(image.GetNumberOfPoints()):
scalars_mask.GetTuple(k_point, m)
if (m[0] == 0):
I[0] = 0.
else:
image.GetPoint(k_point, X)
scalars_U.GetTuple(k_point, U)
x = X + U
interpolator.Interpolate(x, I)
scalars.SetTuple(k_point, I)
myVTK.writeImage(
image=image,
filename=sol_folder+"/"+sol_basename+"-unwarped_"+str(k_frame).zfill(sol_zfill)+".vti")
def generateUnwarpedImages(images_folder,
images_basename,
sol_folder,
sol_basename,
sol_ext="vtu",
verbose=0):
myVTK.myPrint(verbose, "*** generateUnwarpedImages ***")
ref_image_zfill = len(
glob.glob(images_folder + "/" + images_basename +
"_*.vti")[0].rsplit("_")[-1].split(".")[0])
ref_image_filename = images_folder + "/" + images_basename + "_" + str(
0).zfill(ref_image_zfill) + ".vti"
ref_image = myVTK.readImage(filename=ref_image_filename)
image = vtk.vtkImageData()
image.SetOrigin(ref_image.GetOrigin())
image.SetSpacing(ref_image.GetSpacing())
image.SetExtent(ref_image.GetExtent())
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
image.AllocateScalars(vtk.VTK_FLOAT, 1)
else:
image.SetScalarTypeToFloat()
image.SetNumberOfScalarComponents(1)
image.AllocateScalars()
scalars = image.GetPointData().GetScalars()
sol_zfill = len(
glob.glob(sol_folder + "/" + sol_basename + "_*." +
sol_ext)[0].rsplit("_")[-1].split(".")[0])
n_frames = len(
glob.glob(sol_folder + "/" + sol_basename + "_" + "[0-9]" * sol_zfill +
"." + sol_ext))
#n_frames = 1
X = numpy.empty(3)
U = numpy.empty(3)
x = numpy.empty(3)
I = numpy.empty(1)
m = numpy.empty(1)
for k_frame in xrange(n_frames):
myVTK.myPrint(verbose, "k_frame = " + str(k_frame))
def_image = myVTK.readImage(
filename=images_folder + "/" + images_basename + "_" +
str(k_frame).zfill(ref_image_zfill) + ".vti")
interpolator = myVTK.createImageInterpolator(image=def_image)
mesh = myVTK.readUGrid(filename=sol_folder + "/" + sol_basename + "_" +
str(k_frame).zfill(sol_zfill) + "." + sol_ext)
probe = vtk.vtkProbeFilter()
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
probe.SetInputData(image)
probe.SetSourceData(mesh)
else:
probe.SetInput(image)
probe.SetSource(mesh)
probe.Update()
probed_image = probe.GetOutput()
scalars_mask = probed_image.GetPointData().GetArray(
"vtkValidPointMask")
scalars_U = probed_image.GetPointData().GetArray("displacement")
for k_point in xrange(image.GetNumberOfPoints()):
scalars_mask.GetTuple(k_point, m)
if (m[0] == 0):
I[0] = 0.
else:
image.GetPoint(k_point, X)
scalars_U.GetTuple(k_point, U)
x = X + U
interpolator.Interpolate(x, I)
scalars.SetTuple(k_point, I)
myVTK.writeImage(image=image,
filename=sol_folder + "/" + sol_basename +
"-unwarped_" + str(k_frame).zfill(sol_zfill) + ".vti")
I2W_in = numpy.dot(W_in, numpy.linalg.inv(S_in))
else:
I2W_in = numpy.eye(4)
if (args.image_out is not None):
S_out = numpy.diag(list(numpy.loadtxt("Image_"+args.image_out+"_Scaling.dat"))+[1])
W_out = numpy.loadtxt("Image_"+args.image_out+"_WorldMatrix.dat")
I2W_out = numpy.dot(W_out, numpy.linalg.inv(S_out))
else:
I2W_out = numpy.eye(4)
I2I = numpy.dot(numpy.linalg.inv(I2W_out), I2W_in)
if (args.mesh_in_filename.endswith(".vtk") or args.mesh_in_filename.endswith(".vtu")):
mesh = myvtk.readUGrid(
filename=args.mesh_in_filename,
verbose=args.verbose)
elif (args.mesh_in_filename.endswith(".vtp") or args.mesh_in_filename.endswith(".stl")):
mesh = myvtk.readPData(
filename=args.mesh_in_filename,
verbose=args.verbose)
else:
assert (0), "Input file must be .vtk, .vtu, or .stl. Aborting."
myvtk.moveMeshWithWorldMatrix(
mesh=mesh,
M=I2I,
verbose=args.verbose)
if (args.mesh_out_filename == None):
args.mesh_out_filename = args.mesh_in_filename.replace(args.image_in, args.image_out)
import numpy
import vtk
import myPythonLibrary as mypy
import myVTKPythonLibrary as myvtk
import dolfin_dic as ddic
import os
#read the original data - in World Coordinates
x = os.listdir("../DispInWorldCoords")
mesh2 = myvtk.readUGrid("../MeVisLab/Mesh_CspammCoords_ED_LV.vtk", 10)
farray_name = 'displacement'
S_in = numpy.diag(
list(numpy.loadtxt("../MeVisLab/Image_Cspamm_Scaling.dat")) + [1])
W_in = numpy.loadtxt("../MeVisLab/Image_Cspamm_WorldMatrix.dat")
W_in_new = W_in[0:3, 0:3]
M = numpy.dot(S_in, numpy.linalg.inv(W_in))
images_basename = "projected_p0_31012017_PHASE"
mesh_folder = "."
working_folder = "."
working_basename = images_basename
mesh_basename = "Mesh_CspammCoords_ED_LV"
for files in x:
print("Converting file: " + files)
data = myvtk.readSGrid("../DispInWorldCoords/" + files, 10)
dataset = data.GetPointData()
n_points = data.GetNumberOfPoints()
print("number of points: " + str(n_points))
I2W_in = numpy.dot(W_in, numpy.linalg.inv(S_in))
else:
I2W_in = numpy.eye(4)
if (args.image_out is not None):
S_out = numpy.diag(list(numpy.loadtxt("Image_"+args.image_out+"_Scaling.dat"))+[1])
W_out = numpy.loadtxt("Image_"+args.image_out+"_WorldMatrix.dat")
I2W_out = numpy.dot(W_out, numpy.linalg.inv(S_out))
else:
I2W_out = numpy.eye(4)
I2I = numpy.dot(numpy.linalg.inv(I2W_out), I2W_in)
if (args.mesh_in_filename.endswith(".vtk") or args.mesh_in_filename.endswith(".vtu")):
mesh = myvtk.readUGrid(
filename=args.mesh_in_filename,
verbose=args.verbose)
elif (args.mesh_in_filename.endswith(".vtp") or args.mesh_in_filename.endswith(".stl")):
mesh = myvtk.readPData(
filename=args.mesh_in_filename,
verbose=args.verbose)
else:
assert (0), "Input file must be .vtk, .vtu, or .stl. Aborting."
myvtk.moveMeshWithWorldMatrix(
mesh=mesh,
M=I2I,
verbose=args.verbose)
if (args.mesh_out_filename == None):
args.mesh_out_filename = args.mesh_in_filename.replace(args.image_in+"Coords", args.image_out+"Coords")
