def ReadWlzTr(): #{
try: #{
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_FILE_OPEN)
if args.input== '-': #{
f = libc.stdin
else: #}{
f = libc.fopen(args.input, 'rb')
#}
if not bool(f): #{
raise IOError()
#}
obj = w.WlzAssignObject( \
w.WlzReadObj(f, c.byref(errNum)), None)
if not args.input == '-': #{
libc.fclose(f)
#}
if not bool(obj): #{
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_OBJECT_NULL)
raise WlzError()
#}
if ((not int(obj.contents.type) == int(w.WLZ_AFFINE_TRANS)) or \
(not int(obj.contents.domain.core.contents.type) == \
int(w.WLZ_TRANSFORM_3D_AFFINE))): #{
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_OBJECT_TYPE)
raise WlzError()
#}
except IOError: #}{
ErrorMsg('Failed to open ' + args.input)
except WlzError: #}{
ErrorMsg('Failed to read affine transform from ' + args.input +
'(' + w.WlzStringFromErrorNum(errNum, None) + ')')
#}
mat = WlzTrToMat(obj.contents.domain.t)
return(mat)
def WriteWoolzObject(filename, obj):
errNum = Wlz.enum__WlzErrorNum(Wlz.WLZ_ERR_FILE_OPEN)
fp = libc.fopen(filename, 'wb')
if(bool(fp)):
errNum = Wlz.WlzWriteObj(fp, obj)
libc.fclose(fp)
return(errNum)
def WriteWoolzObject(filename, obj):
errNum = Wlz.enum__WlzErrorNum(Wlz.WLZ_ERR_FILE_OPEN)
fp = libc.fopen(filename, 'wb')
if (bool(fp)):
errNum = Wlz.WlzWriteObj(fp, obj)
libc.fclose(fp)
return (errNum)
def ReadWoolzFile(filename):
obj = None
errNum = Wlz.enum__WlzErrorNum(Wlz.WLZ_ERR_FILE_OPEN)
fp = libc.fopen(filename, 'rb')
if(bool(fp)):
obj = Wlz.WlzReadObj(fp, ctypes.byref(errNum))
libc.fclose(fp)
return(obj)
def ReadWoolzFile(filename):
obj = None
errNum = Wlz.enum__WlzErrorNum(Wlz.WLZ_ERR_FILE_OPEN)
fp = libc.fopen(filename, 'rb')
if (bool(fp)):
obj = Wlz.WlzReadObj(fp, ctypes.byref(errNum))
libc.fclose(fp)
return (obj)
def ReadLmkTr(): #{
sv = []
tv = []
try: #{
if args.input == '-': #{
f = sys.stdin
else: #}{
f = open(args.input, 'r')
#}
doc = et.parse(f)
idx = 0
for lm in doc.findall('Landmark'): #{
s = lm.find('Source')
t = lm.find('Target')
sv.append(GetLmkVertex(s))
tv.append(GetLmkVertex(t))
VerbMsg('{:d} {:g} {:g} {:g} {:g} {:g} {:g}'. \
format( \
idx, \
sv[idx].vtX, sv[idx].vtY, sv[idx].vtZ, \
tv[idx].vtX, tv[idx].vtY, tv[idx].vtZ))
idx = idx + 1
#}
if not args.input == '-': #{
f.close()
#}
if ((not len(sv) == len(tv)) or (len(sv) < 3)): #{
raise IOError()
#}
except IOError: #}{
ErrorMsg('Failed to read ITK affine transform from file ' + args.input)
#}
try: #{
n = len(sv)
svtx = (w.WlzDVertex3 * n)()
tvtx = (w.WlzDVertex3 * n)()
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_NONE)
for i in range(0, n): #{
svtx[i] = sv[i]
tvtx[i] = tv[i]
#}
tr = w.WlzAffineTransformLSq3D(n, tvtx, n, svtx, 0, None, \
w.enum__WlzTransformType(w.WLZ_TRANSFORM_3D_AFFINE), \
c.byref(errNum))
if bool(errNum) or \
(not int(tr.contents.type) == int(w.WLZ_TRANSFORM_3D_AFFINE)): #{
raise WlzError()
#}
except WlzError: #}{
ErrorMsg('Failed to compute LSq affine transform from landmarks (' +
w.WlzStringFromErrorNum(errNum, None) + ')')
#}
mat = WlzTrToMat(tr)
return(mat)
#!/usr/bin/python
# Reads a Woolz 2D or 3D domain object and generates a histogram.
from __future__ import print_function
import sys
import ctypes
import Wlz
import matplotlib.pyplot as pt
import numpy as np
libc = ctypes.CDLL("libc.so.6")
fopen = libc.fopen
fclose = libc.fclose
errNum = Wlz.enum__WlzErrorNum(Wlz.WLZ_ERR_NONE)
fopen.restype = ctypes.POINTER(Wlz.FILE)
f = 'test.wlz'
print('Read test object from the file ' + f);
fp = fopen(f, 'rb')
obj = Wlz.WlzAssignObject(Wlz.WlzReadObj(fp, ctypes.byref(errNum)), None)
fclose(fp)
if(bool(errNum)):
print('Failed to read object from ' + f + \
' (' + Wlz.WlzStringFromErrorNum(errNum, None) + ').')
exit(1)
if((not bool(obj.contents)) or
def ExportDomainsToIndexObj(): #{
# Get domain indices and names from the label description file
# adding the domain at each step.
cpd_obj = None
idx_obj = None
max_idx = 0
obj_type = w.WLZ_NULL
dom_objs = []
dom_idxs = []
with open(args.ldf) as ldf: #{
for rec in ldf: #{
VerbMsg('rec = ' + rec)
if not re.match(r'^[ \t]*#', rec): #{
rec = rec.lstrip()
dom_idx = int(re.split('\s+', rec)[0])
dom_name = re.split('"', rec)[1]
VerbMsg('idx = ' + str(dom_idx) + ' dom = ' + dom_name)
if (dom_idx > 0): #{
try: #{
if dom_idx > max_idx: #{
max_idx = dom_idx
#}
dom_idxs.append(dom_idx)
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_FILE_OPEN)
dom_file = args.domaindir + '/' + dom_name + '.wlz'
fp = libc.fopen(dom_file, 'rb')
if not bool(fp): #{
raise IOError()
#}
obj = w.WlzAssignObject( \
w.WlzReadObj(fp, c.byref(errNum)), None)
if (bool(errNum)): #{
raise WlzError()
#}
p_lst = w.WlzMakePropertyList(None)
p_nam = w.WlzMakeNameProperty(dom_name,
c.byref(errNum))
if (bool(errNum)): #{
raise WlzError()
#}
ft = c.CFUNCTYPE(c.c_void_p, c.c_void_p)\
(w.WlzFreePropertyListEntry)
alcerr = w.AlcDLPListEntryAppend(p_lst.contents.list, None, \
p_nam, ft)
if (bool(alcerr)): #{
raise WlzError()
#}
obj.contents.plist = w.WlzAssignPropertyList(
p_lst, None)
dom_objs.append(obj)
libc.fclose(fp)
if (bool(errNum)): #{
raise WlzError()
#}
VerbMsg('domain object type (idx == ' + str(dom_idx) + ') ' + \
str(w.WlzStringFromObjTypeValue( \
obj.contents.type, None)))
if (obj_type == w.WLZ_NULL): #{
if((obj.contents.type == w.WLZ_2D_DOMAINOBJ) or \
(obj.contents.type == w.WLZ_3D_DOMAINOBJ)): #{
obj_type = obj.contents.type
#}
#}
except IOError: #}{
ErrorMsg('Failed to read domain from file ' + dom_file + \
' (' + w.WlzStringFromErrorNum(errNum, None) + ')')
except WlzError: #}{
ErrorMsg('Failed to process domain from file ' + dom_file + \
' (' + w.WlzStringFromErrorNum(errNum, None) + ')')
#}
#}
#}
#}
#}
VerbMsg('Object type ' + str(w.WlzStringFromObjTypeValue(obj_type, None)))
if ((max_idx < 1) or ((not obj_type == w.WLZ_2D_DOMAINOBJ) and
(not obj_type == w.WLZ_3D_DOMAINOBJ))): #{
ErrorMsg('Require at least one 2 or 3D domain with a positive index.')
#}
try: #{
VerbMsg('Creating compound array object of domains.')
cpd_obj = w.WlzMakeCompoundArray( \
w.enum__WlzObjectType(w.WLZ_COMPOUND_ARR_2), \
1, max_idx + 1, None, obj_type, c.byref(errNum))
if (bool(errNum)): #{
raise WlzError()
#}
for i in range(0, len(dom_objs)): #{
obj = dom_objs[i]
idx = dom_idxs[i]
cpd_obj.contents.o[idx] = obj
#}
except: #}{
ErrorMsg('Failed to create compound object from domains (' + \
w.WlzStringFromErrorNum(errNum, None) + ')')
#}
if not args.compound: #{
try: #{
VerbMsg('Creating index object from compound of domains.')
idx_obj = w.WlzAssignObject( \
w.WlzIndexObjFromCompound(cpd_obj, c.byref(errNum)), None)
if (bool(errNum)): #{
raise WlzError()
#}
except: #}{
ErrorMsg('Failed to create index object from compound of domains (' + \
w.WlzStringFromErrorNum(errNum, None) + ')')
#}
#}
if bool(args.reference) and (not args.compound): #{
try: #{
VerbMsg('Cutting index object to the same bounding box as the\n' + \
'reference object (read from ' + args.reference + ').')
fp = None
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_FILE_OPEN)
if args.reference == '-': #{
fp = libc.stdin
else: #}{
fp = libc.fopen(args.reference, 'rb')
#}
if not bool(fp): #{
raise IOError()
#}
obj = w.WlzAssignObject( \
w.WlzReadObj(fp, c.byref(errNum)), None)
if not args.reference == '-': #{
libc.fclose(fp)
#}
if (bool(errNum)): #{
raise WlzError()
#}
box = w.WlzBoundingBox3I(obj, c.byref(errNum))
if (not bool(errNum)): #{
gtype = w.WlzGreyTypeFromObj(idx_obj, c.byref(errNum))
#}
w.WlzFreeObj(obj)
if (bool(errNum)): #{
raise WlzError()
#}
VerbMsg('Using bounding box ' + \
'(' + str(box.xMin) + ',' + str(box.xMax) + '),' + \
'(' + str(box.yMin) + ',' + str(box.yMax) + '),' + \
'(' + str(box.zMin) + ',' + str(box.zMax) + ')')
VerbMsg('Preserving grey type ' + \
w.WlzStringFromGreyType(gtype, None) + \
'.')
obj = w.WlzCutObjToBox3D(idx_obj, box, gtype, 0, 0.0, 0.0, \
c.byref(errNum))
if (bool(errNum)): #{
raise WlzError()
#}
w.WlzFreeObj(idx_obj)
idx_obj = obj
except IOError: #}{
ErrorMsg('Failed to read the reference object read from ' + \
args.reference + '.')
except WlzError: #}{
ErrorMsg('Failed to cut index object to the bounding box of the\n' + \
'reference object read from (' + args.reference + ') (' + \
w.WlzStringFromErrorNum(errNum, None) + ')')
#}
#}
try: #{
ft = 'index'
if args.compound: #{
ft = 'compound'
#}
VerbMsg('Writing ' + ft + ' object to output file (' + args.output +
').')
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_FILE_OPEN)
if args.output == '-': #{
fp = libc.stdout
else: #}{
fp = libc.fopen(args.output, 'wb')
#}
if not bool(fp): #{
raise IOError()
#}
if args.compound: #{
errNum = w.WlzWriteObj(fp, cpd_obj)
else: #}{
errNum = w.WlzWriteObj(fp, idx_obj)
#}
if not args.output == '-': #{
libc.fclose(fp)
#}
if (bool(errNum)): #{
raise WlzError()
#}
except: #}{
ErrorMsg('Failed to write ' + ft + ' object to file (' + \
w.WlzStringFromErrorNum(errNum, None) + ')')
#}
if args.compound: #{
errNum = w.WlzWriteObj(fp, cpd_obj)
else: #}{
errNum = w.WlzWriteObj(fp, idx_obj)
#}
if not args.output == '-': #{
libc.fclose(fp)
#}
if (bool(errNum)): #{
raise WlzError()
#}
except: #}{
ErrorMsg('Failed to write ' + ft + ' object to file (' + \
w.WlzStringFromErrorNum(errNum, None) + ')')
#}
#}
if __name__ == '__main__': #{
# Process the command line
args = ParseArgs()
prog = sys.argv[0]
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_NONE)
if (args.verbose): #{
print(prog + ': args = ' + str(args))
#}
ExportDomainsToIndexObj()
#}
def WriteMeshLabFilter(filename, flt):
with open(filename, "w") as ff:
for fr in flt:
print(fr, file=ff)
ff.close()
def CleanExit(stat):
for f in glob.glob(workfile + '[0-1].*'):
os.remove(f)
exit(stat)
if __name__ == '__main__':
args = ParseArgs()
prog = sys.argv[0];
errNum = Wlz.enum__WlzErrorNum(Wlz.WLZ_ERR_NONE)
if(args.verbose):
print('Args = ' + str(args))
workfile = tempfile.mktemp(dir=args.tmpdir, prefix='wd2vs')
# Use MAVTKDomainToSurf to create an stl file corresponding to the
# given Woolz domain.
cmdline = [MAVTKDomainToSurf, '-o' + workfile + '0.stl']
if(args.voxelscaling):
cmdline.append('-z')
cmdline.append(args.infile)
if(args.verbose):
print(cmdline)
rtn = subprocess.call(cmdline)
a_node = False
#}
#}
if(not bool(a_node)): #{
MsgWarn('failed to merge color for EMAPA:' + str(t_EMAPA) + ' ' +
row.name)
#}
#}
#}
if __name__ == '__main__': #{
#
# Process the command line
args = ParseArgs()
prog = sys.argv[0];
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_NONE)
if(args.stage): #{
match = re.match(r'^TS\d\d?$', args.stage.upper())
if(match): #{
single_stage = match.group(0)
else: #}{
MsgError('Bad stage, specify using TS[0-9][0-9]? (eg TS07\n' +
'or TS17).', 1)
#}
#}
MsgVerbose('args = ' + str(args))
#
# Fetch the EMAP service description file
MsgVerbose('Fetching service description file (using url =\n' +
emap_srv_desc_url + ').')
try: #{
def makeWlzImageObj(slices, rescale):
vrbMsg('creating Woolz object')
obj = None
gvw = None
errNum = w.enum__WlzErrorNum(w.WLZ_ERR_NONE)
s0 = slices[0]
nx = s0.Columns
ny = s0.Rows
nz = len(slices)
sx = float(s0.PixelSpacing[0])
sy = float(s0.PixelSpacing[1])
r_intercept = 0.0
r_slope = 1.0
bgd_v = 0
if rescale:
if ('RescaleIntercept' in s0) and ('RescaleSlope' in s0):
r_intercept = float(s0.RescaleIntercept)
r_slope = float(s0.RescaleSlope)
bgd_v = int(r_intercept)
else:
wrnMsg(
'Unable to rescale image grey values to Hounsfield units as ' +
'rescale parameters not in DICOM metadata.')
sz = m.fabs(slices[1].ImagePositionPatient[2] - s0.ImagePositionPatient[2])
if (sz < sys.float_info.epsilon) and ('SpacingBetweenSlices' in s0):
sz = m.fabs(s0.SpacingBetweenSlices)
if sz < sys.float_info.epsilon:
if nz > 1:
wrnMsg(
'Multiple slices at same position, slice thickness set to 1.0.'
)
sz = 1.0
x1 = int(np.floor(s0.ImagePositionPatient[0] / sx))
y1 = int(np.floor(s0.ImagePositionPatient[1] / sy))
z1 = int(np.floor(s0.ImagePositionPatient[2] / sz))
g_type = w.WlzGreyType(w.WLZ_GREY_ERROR)
if s0.BitsAllocated == 8:
g_type = int(w.WLZ_GREY_UBYTE)
elif s0.BitsAllocated == 16:
g_type = int(w.WLZ_GREY_SHORT)
else:
raise Exception('Unsupported voxel grey type.')
err_num = w.enum__WlzErrorNum(w.WLZ_ERR_NONE)
obj = w.WlzMakeCuboidI(z1, z1 + nz - 1, y1, y1 + ny - 1, x1, x1 + nx - 1,
g_type, bgd_v, None, None, c.byref(err_num))
if not bool(err_num):
err_num = w.enum__WlzErrorNum(w.WlzSetVoxelSize(obj, sx, sy, sz))
if not bool(err_num):
vvp = obj.contents.values.vox.contents.values
for iz in range(0, nz):
si = slices[iz]
vp = vvp[iz].r.contents.values
for iy in range(0, ny):
offset = nx * iy
for ix in range(0, nx):
if g_type == int(w.WLZ_GREY_UBYTE):
ubp = vp.ubp[offset + ix]
ubp.contents = c.c_char(si.pixel_array[iy, ix])
elif g_type == int(w.WLZ_GREY_SHORT):
vp.shp[offset + ix] = c.c_short(
int((si.pixel_array[iy, ix] * r_slope) +
r_intercept))
else:
raise Exception('Unsupported voxel grey type.')
return obj
