def read(read_string):
ext = os.path.splitext(read_string)[1]
m_string = read_string
if (ext == ".nii" or ext == ".nrrd"):
Inner_volume = sitk.ReadImage(m_string)
else:
Inner_volume = RIM.dicom_series_reader(m_string)
return Inner_volume
# input_matrix[np.where((input_matrix == [255.0]))] = [1.0]
img = (img - min(img)) / (max(img) - min(img))
img = img * 65535
return img
##########################################################################################################################
# read the original volume
ext = os.path.splitext(args.args0)[1]
m_string = args.args0
if (ext == ".nii" or ext == ".nrrd"):
input_volume = sitk.ReadImage(m_string)
else:
input_volume = RIM.dicom_series_reader(m_string)
# spacing=input_volume.GetSpacing()
spacing = [0.12, 0.12, 0.12]
origin = input_volume.GetOrigin()
try:
myvolume = sitk.GetArrayFromImage(input_volume)
except:
myvolume = itk.GetArrayFromImage(input_volume)
w1 = myvolume.shape[2]
h1 = myvolume.shape[1]
d1 = myvolume.shape[0]
# The_Normal,p1,p2,p3=call_normal_computation.main_normal(myvolume,spacing)
# The_Normal=[round(The_Normal[0]),round(The_Normal[1]),round(The_Normal[2])]
# print(The_Normal)
# The_Normal=[0,0,-1]
#
# original_volume=sitk.ReadImage(m_string3)
# original_array=sitk.GetArrayFromImage(original_volume)
# else:
# original_volume=RIM.dicom_series_reader(m_string3)
# original_array=itk.GetArrayFromImage(original_volume)
# # intact_volume=RIM.dicom_series_reader(str(unicode('\\\\samba.cs.ucalgary.ca\\fatemeh.yazdanbakhsh\Documents\Data_Sets\Calgary\TBone-2015\TBoneCBCT-2015-10\L2963L','utf-8')))
########################################################################################
ext = os.path.splitext(str((args.args0)))[1]
m_string3 = str((args.args0))
if (ext == ".nii" or ext == ".nrrd" or ext == ".nhdr"):
intact_volume = sitk.ReadImage(m_string3)
intact_array = sitk.GetArrayFromImage(intact_volume)
else:
intact_volume = RIM.dicom_series_reader(m_string3)
intact_array = itk.GetArrayFromImage(intact_volume)
# intact_volume=RIM.dicom_series_reader(str(unicode('\\\\samba.cs.ucalgary.ca\\fatemeh.yazdanbakhsh\Documents\Data_Sets\Calgary\TBone-2015\TBoneCBCT-2015-10\L2963L','utf-8')))
intact_array_original = intact_array
##########################################################################
data = intact_array
# xmin2,xmax2,ymin2,ymax2,zmin2,zmax2=bbox2_3D(original_array)
xmin, xmax, ymin, ymax, zmin, zmax = bbox2_3D(data)
aa = xmax - xmin
bb = ymax - ymin
cc = zmax - zmin
# aa2=xmax2-xmin2
# bb2=ymax2-ymin2
# cc2=zmax2-zmin2
input('Press Enter to quit: ')
###############################################################################################################################
##########################################################################################################################
# read the original volume
ext=os.path.splitext(args.args0)[1]
m_string=args.args0
if (ext==".nii" or ext==".nrrd"):
input_volume=sitk.ReadImage(m_string)
else:
input_volume=RIM.dicom_series_reader(m_string)
spacing=input_volume.GetSpacing()
origin=input_volume.GetOrigin()
try:
myvolume=sitk.GetArrayFromImage(input_volume)
except:
myvolume=itk.GetArrayFromImage(input_volume)
w1 = myvolume.shape[2]
h1 = myvolume.shape[1]
d1 = myvolume.shape[0]
The_Normal,p1,p2,p3=main_normal(myvolume,spacing,verts2,faces2)
del(myvolume)
#############################################################
def execute(txt_Wedge,txt_Wline,txt_Wterm,txt_alpha,txt_beta,txt_sigma,txt_gamma,txt_start,txt_end,txt_url,txt_start2,txt_end2,flagg,txt_flagDown,txt_Wurl):
m_string=txt_url
# m_string='U:\Documents\medical_imaging\Hip'
input_volume=RIM.dicom_series_reader(m_string)
# input_volume=im
#
PixelType = itk.ctype('signed short')
Dimension = 3
ImageType_threshold = itk.Image[PixelType, Dimension]
# thresholdFilter= itk.BinaryThresholdImageFilter[ImageType_threshold,ImageType_threshold].New()
thresholdFilter= itk.IntensityWindowingImageFilter[ImageType_threshold,ImageType_threshold].New()
# thresholdFilter= itk.InvertIntensityImageFilter[ImageType_threshold,ImageType_threshold].New()
thresholdFilter.SetInput(input_volume)
# thresholdFilter.SetLowerThreshold(-400)
# thresholdFilter.SetUpperThreshold(40)
# thresholdFilter.SetOutsideValue(0)
# thresholdFilter.SetInsideValue(255)
##################################
thresholdFilter.SetInput(input_volume)
thresholdFilter.SetWindowMinimum(-500)
thresholdFilter.SetWindowMaximum(1)
thresholdFilter.SetOutputMinimum(0)
thresholdFilter.SetOutputMaximum(255)
######################################
# thresholdFilter.SetMaximum(10)
#################################
thresholdFilter.Update()
threshold_input=thresholdFilter.GetOutput()
sigma_smooth = float(txt_sigma)
smooth_volume=SFM.smooth_3d(input_volume,sigma_smooth)
w = input_volume.GetLargestPossibleRegion().GetSize()[0]
h = input_volume.GetLargestPossibleRegion().GetSize()[1]
d = input_volume.GetLargestPossibleRegion().GetSize()[2]
input_matrix=np.zeros((w,h,d))
input_matrix_smoothed=np.zeros((w,h,d))
index=np.zeros((3))
input_matrix_smoothed=itk.GetArrayFromImage(smooth_volume)
# input_matrix_smoothed=np.transpose(input_matrix_smoothed,axes=(2,1,0))
# input_matrix = itk.GetArrayFromImage(SFM.smooth_3d(thresholdFilter.GetOutput(),sigma_smooth))
input_matrix = itk.GetArrayFromImage(input_volume)
# input_matrix = itk.GetArrayFromImage(thresholdFilter.GetOutput())
# input_matrix=np.transpose(input_matrix,axes=(2,1,0))
input_matrix2=input_matrix
input_matrix_smoothed2=input_matrix_smoothed
# P=RPM.read_points()
#P,zslice=MIM.mouse_input()
zslice=txt_start
zslice2=txt_start2
d1=txt_end
d2=txt_end2
# zslice=498
# d=829
# X=[]
# Y=[]
# P=[]
if (flagg==0):
P=ICP.main((input_matrix[:][:][zslice]))
P2=ICP.main((input_matrix2[:][:][zslice2]))
npoints=P[0].__len__()
############################
# output_volume = input_matrix
output_volume=np.zeros((d,h,w))
output_volume1=np.zeros((d,h,w))
output_volume2=np.zeros((d,h,w))
##############################
tck,u= interpolate.splprep( [P[0],P[1]] ,s = 0 )
xnew,ynew = interpolate.splev( np.linspace( 0, 1, P[0].__len__() ), tck,der = 0)
P=[xnew[:],ynew[:]]
##################################################
tck2,u2= interpolate.splprep( [P2[0],P2[1]] ,s = 0 )
xnew2,ynew2 = interpolate.splev( np.linspace( 0, 1, P2[0].__len__() ), tck2,der = 0)
P2=[xnew2[:],ynew2[:]]
#############################
output_volume1=func.function_abstract(P,input_matrix,input_matrix_smoothed,zslice,d1,output_volume1,1,txt_Wedge,txt_Wline,txt_Wterm,txt_alpha,txt_beta,txt_gamma,txt_flagDown)
output_volume2=func.function_abstract(P2,input_matrix2,input_matrix_smoothed2,zslice2,d2,output_volume2,1,txt_Wedge,txt_Wline,txt_Wterm,txt_alpha,txt_beta,txt_gamma,txt_flagDown)
output_volume=output_volume1+output_volume2
# output_volume=output_volume1
####################################################################
output_volume=sitk.GetImageFromArray(output_volume)
output_volume=sitk.Cast(output_volume,sitk.sitkFloat64)
# #output_volume = sitk.Cast(output_volume, sitk.sitkInt64)
sitk.WriteImage(output_volume,txt_Wurl)
if(flagg==1):
P=ICP.main((input_matrix[:][:][zslice]))
# P2=ICP.main((input_matrix2[:][:][zslice2]))
npoints=P[0].__len__()
############################
# output_volume = input_matrix
output_volume=np.zeros((d,h,w))
output_volume1=np.zeros((d,h,w))
output_volume2=np.zeros((d,h,w))
##############################
tck,u= interpolate.splprep( [P[0],P[1]] ,s = 0 )
xnew,ynew = interpolate.splev( np.linspace( 0, 1, P[0].__len__() ), tck,der = 0)
P=[xnew[:],ynew[:]]
##################################################
# tck2,u2= interpolate.splprep( [P2[0],P2[1]] ,s = 0 )
#
# xnew2,ynew2 = interpolate.splev( np.linspace( 0, 1, P2[0].__len__() ), tck2,der = 0)
#
# P2=[xnew2[:],ynew2[:]]
#############################
output_volume1=func.function_abstract(P,input_matrix,input_matrix_smoothed,zslice,d1,output_volume1,1,txt_Wedge,txt_Wline,txt_Wterm,txt_alpha,txt_beta,txt_gamma,txt_flagDown)
# output_volume2=func.function_abstract(P2,input_matrix2,input_matrix_smoothed2,zslice2,d2,output_volume2,1)
# output_volume=output_volume1+output_volume2
output_volume=output_volume1
####################################################################
output_volume=sitk.GetImageFromArray(output_volume)
output_volume=sitk.Cast(output_volume,sitk.sitkFloat64)
# #output_volume = sitk.Cast(output_volume, sitk.sitkInt64)
sitk.WriteImage(output_volume,txt_Wurl)
################################################Reading Dissected Volume##########################################################################
########################################################################################################################################
def finish():
print('\n', "bye", '\n')
input('Press Enter to quit: ')
################################################Reading Dissected Volume##########################################################################
# read the original volume
ext=os.path.splitext(args.args2)[1]
m_string=args.args2
if (ext==".nii" or ext==".nrrd"):
input_volume=sitk.ReadImage(m_string)
else:
input_volume=RIM.dicom_series_reader(m_string)
spacing=input_volume.GetSpacing()
origin=input_volume.GetOrigin()
try:
dissected_matrix=sitk.GetArrayFromImage(input_volume)
except:
dissected_matrix=itk.GetArrayFromImage(input_volume)
w1 = dissected_matrix.shape[2]
h1 = dissected_matrix.shape[1]
d1 = dissected_matrix.shape[0]
#############################Reading Intact Volume################################
def main(args0, args1, args2, args3):
parser = argparse.ArgumentParser(
description=
"""This program uses ray casting method to detect overhang problem""")
parser.add_argument(
"-args0",
type=str,
default=
(("\\\\samba.cs.ucalgary.ca\\fatemeh.yazdanbakhsh\Documents\Data_Sets\Kowther\Specimen2501L\Specimen2501L\Segmentations\FacialNerve.nrrd"
)),
help="facial nerve")
# parser.add_argument("-args0", type = str, default = "U:\Documents\Data_Sets\Calgary\TBone-2015\TBoneCBCT-2015-10\L3016_modified_19_nov", help = "dicome image address")
parser.add_argument(
"-args1",
type=str,
default=
("\\\\samba.cs.ucalgary.ca\\fatemeh.yazdanbakhsh\Documents\Data_Sets\Kowther\Specimen2501L\Specimen2501L\Segmentations\SigmoidSinus.nrrd"
),
help="address of sigmoid sinus mask")
parser.add_argument(
"-args2",
type=str,
default=
(('\\\\samba.cs.ucalgary.ca\\fatemeh.yazdanbakhsh\Documents\Data_Sets\Kowther\Specimen2501L\dissected_27_feb_2019'
)),
help="dissected image address")
parser.add_argument(
"-args3",
type=str,
default=
('\\\\samba.cs.ucalgary.ca\\fatemeh.yazdanbakhsh\Documents\Data_Sets\Kowther\Specimen2501L\Specimen2501L\\2501L_reduced'
),
help="intact image address")
parser.add_argument("-args4", type=int, default=1000, help="low")
parser.add_argument("-args5", type=int, default=4000, help="high")
# Get your arguments
args = parser.parse_args()
args.args0 = args0
args.args1 = args1
args.args2 = args2
args.args3 = args3
low = args.args4
high = args.args5
################################################Reading Dissected Volume##########################################################################
# read the original volume
ext = os.path.splitext(args.args2)[1]
m_string = args.args2
if (ext == ".nii" or ext == ".nrrd"):
input_volume = sitk.ReadImage(m_string)
else:
input_volume = RIM.dicom_series_reader(m_string)
spacing = input_volume.GetSpacing()
origin = input_volume.GetOrigin()
try:
dissected_matrix = sitk.GetArrayFromImage(input_volume)
except:
dissected_matrix = itk.GetArrayFromImage(input_volume)
w1 = dissected_matrix.shape[2]
h1 = dissected_matrix.shape[1]
d1 = dissected_matrix.shape[0]
#############################Reading Intact Volume################################
ext = os.path.splitext(str((args.args3)))[1]
m_string3 = str((args.args3))
if (ext == ".nii" or ext == ".nrrd" or ext == ".nhdr"):
intact_volume = sitk.ReadImage(m_string3)
intact_array = sitk.GetArrayFromImage(intact_volume)
else:
intact_volume = RIM.dicom_series_reader(m_string3)
intact_array = itk.GetArrayFromImage(intact_volume)
# intact_volume=RIM.dicom_series_reader(str(unicode('\\\\samba.cs.ucalgary.ca\\fatemeh.yazdanbakhsh\Documents\Data_Sets\Calgary\TBone-2015\TBoneCBCT-2015-10\L2963L','utf-8')))
#######################################################################################################
#
#do binary threshoulding on the original image
PixelType = itk.ctype('signed short')
Dimension = 3
try:
thresholdFilter = sitk.BinaryThresholdImageFilter()
input_volume_thr = thresholdFilter.Execute(input_volume, low, high,
255, 0)
except:
print(0)
try:
ImageType_threshold = itk.Image[PixelType, Dimension]
thresholdFilter = itk.BinaryThresholdImageFilter[
ImageType_threshold, ImageType_threshold].New()
# input_volume=thresholdFilter.Execute(input_volume,low,high,0,255)
thresholdFilter.SetInput((input_volume))
thresholdFilter.SetLowerThreshold(low)
thresholdFilter.SetUpperThreshold(high)
thresholdFilter.SetOutsideValue(0)
thresholdFilter.SetInsideValue(255)
thresholdFilter.Update()
input_volume_thr = thresholdFilter.GetOutput()
except:
print(0)
#####################################################
#do binary threshoulding on the intact image
try:
thresholdFilter = sitk.BinaryThresholdImageFilter()
intact_volume2_thr = thresholdFilter.Execute(intact_volume, low, high,
255, 0)
except:
print(0)
#
try:
PixelType = itk.ctype('signed short')
Dimension = 3
ImageType_threshold = itk.Image[PixelType, Dimension]
thresholdFilter = itk.BinaryThresholdImageFilter[
ImageType_threshold, ImageType_threshold].New()
thresholdFilter.SetInput(intact_volume)
thresholdFilter.SetLowerThreshold(low)
thresholdFilter.SetUpperThreshold(high)
thresholdFilter.SetOutsideValue(0)
thresholdFilter.SetInsideValue(255)
thresholdFilter.Update()
intact_volume2_thr = thresholdFilter.GetOutput()
#
except:
print(0)
#intact_array=itk.GetArrayFromImage(intact_volume2)
try:
intact_array_thr = sitk.GetArrayFromImage(intact_volume2_thr)
except:
print(0)
try:
intact_array_thr = itk.GetArrayFromImage(intact_volume2_thr)
except:
print(0)
#####################################################
try:
dissected_array_thr = sitk.GetArrayFromImage(input_volume_thr)
except:
print(0)
try:
dissected_array_thr = itk.GetArrayFromImage(input_volume_thr)
except:
print(0)
#######################################################################################################
# read nrrd or segmented volume of sigmoid sinus to be used as mask
ext = os.path.splitext(args.args1)[1]
m_string2 = args.args1
if (ext == ".nii" or ext == ".nrrd"):
sigmoid_volume = sitk.ReadImage(m_string2)
else:
sigmoid_volume = RIM.dicom_series_reader(m_string2)
# nrrd_volume=sitk.ReadImage(m_string2)
spacing = sigmoid_volume.GetSpacing()
sigmoid_volume = sitk.GetArrayFromImage(sigmoid_volume)
sigmoid_volume = np.ndarray.transpose(np.ndarray.transpose(sigmoid_volume))
# read facialnerve
ext = os.path.splitext(args.args0)[1]
m_string = args.args0
if (ext == ".nii" or ext == ".nrrd"):
facial_volume = sitk.ReadImage(m_string)
else:
facial_volume = RIM.dicom_series_reader(m_string)
facial_volume = sitk.GetArrayFromImage(facial_volume)
facial_volume = np.ndarray.transpose(np.ndarray.transpose(facial_volume))
##########################chebyshev distance###########################
# allDist = squareform( pdist2( set1, set2 ) );
# [minDist nni] = min( allDist, [], 2 );
###########python version#################
#
# X = sigmoid_volume
# Y = facial_volume
#
# allDist=cdist(X, Y)
# distancee=min(allDist)
mesh = sigmoid_volume
pts = facial_volume
# squared_distances,face_indices,closest_point=pymesh.distance_to_mesh(mesh, pts, engine='auto')
# print(squared_distances)
# print(face_indices)
# print(closest_point)
#######################################################################
# quality=computeQualityMeasures(facial_volume,sigmoid_volume)
# print(quality)
a = np.ones((3, 3, 3))
for i in range(10, 50):
b = morph.binary_dilation(sigmoid_volume, a, i)
c = morph.binary_dilation(facial_volume, a, i)
d = np.logical_and(b, c)
d[np.where((d == [True]))] = [1.0]
if np.sum(d) > 10000:
print(np.sum(d))
print(i)
break
print(np.where((d == [1.0])))
sum_image = b + c
#############visualizing the extended sigmoid sinus and facial nerve
verts, faces, normals, values = marching_cubes_lewiner(
sum_image, 0, spacing)
# mesh=mlab.triangular_mesh([vert[0] for vert in verts],
# [vert[1] for vert in verts],
# [vert[2] for vert in verts],
# faces)
# fig = mlab.figure(1)
# mlab.show()
#################calculate the bounding box of the intersection point
d[np.where((d == [True]))] = [1.0]
rmin3, rmax3, cmin3, cmax3, zmin3, zmax3 = bbox2_3D(d)
original_sum = sigmoid_volume + facial_volume
original_sum[np.where((original_sum == [True]))] = [1.0]
##################extracting region of interest
segmented_area = dissected_array_thr[rmin3:rmax3, cmin3:cmax3, zmin3:zmax3]
print(segmented_area.shape)
verts, faces, normals, values = marching_cubes_lewiner(
segmented_area, 0, spacing)
# mesh=mlab.triangular_mesh([vert[0] for vert in verts],
# [vert[1] for vert in verts],
# [vert[2] for vert in verts],
# faces)
# mlab.title("part of dissected")
# fig = mlab.figure("part of dissected")
segmented_area = intact_array_thr[rmin3:rmax3, cmin3:cmax3, zmin3:zmax3]
print(segmented_area.shape)
verts, faces, normals, values = marching_cubes_lewiner(
segmented_area, 0, spacing)
# mesh=mlab.triangular_mesh([vert[0] for vert in verts],
# [vert[1] for vert in verts],
# [vert[2] for vert in verts],
# faces)
# mlab.title("part of intact")
# fig = mlab.figure("part of intact")
segmented_area = dissected_array_thr[rmin3:rmax3, cmin3:cmax3, zmin3:zmax3]
print(segmented_area.shape)
verts, faces, normals, values = marching_cubes_lewiner(
dissected_array_thr, 0, spacing)
# mesh=mlab.triangular_mesh([vert[0] for vert in verts],
# [vert[1] for vert in verts],
# [vert[2] for vert in verts],
# faces)
# mlab.title('complete image')
# fig=mlab.figure('complete image')
# mlab.show()
##############################results####################################
subtracted_array = intact_array_thr - dissected_array_thr
subtracted_region = subtracted_array[rmin3:rmax3, cmin3:cmax3, zmin3:zmax3]
num1 = np.sum(subtracted_region)
print(num1)
if (num1 > 0):
print("digastric ridge is identified")
else:
print("digastric ridge is not identified")
print("rmin")
print(rmin3)
print("rmax")
print(rmax3)
print("cmin")
print(cmin3)
print("cmax")
print(cmax3)
print("zmin")
print(zmin3)
print("zmax")
print(zmax3)
return rmin3, rmax3, cmin3, cmax3, zmin3, zmax3
def main(read_string):
ext = os.path.splitext(str((read_string)))[1]
m_string3 = str((read_string))
if (ext == ".nii" or ext == ".nrrd" or ext == ".nhdr"):
intact_volume = sitk.ReadImage(m_string3)
intact_array = sitk.GetArrayFromImage(intact_volume)
else:
intact_volume = RIM.dicom_series_reader(m_string3)
intact_array = itk.GetArrayFromImage(intact_volume)
# intact_volume=RIM.dicom_series_reader(str(unicode('\\\\samba.cs.ucalgary.ca\\fatemeh.yazdanbakhsh\Documents\Data_Sets\Calgary\TBone-2015\TBoneCBCT-2015-10\L2963L','utf-8')))
intact_array_original = intact_array
##########################################################################
data = intact_array
# xmin2,xmax2,ymin2,ymax2,zmin2,zmax2=bbox2_3D(original_array)
xmin, xmax, ymin, ymax, zmin, zmax = bbox2_3D(data)
aa = xmax - xmin
bb = ymax - ymin
cc = zmax - zmin
# aa2=xmax2-xmin2
# bb2=ymax2-ymin2
# cc2=zmax2-zmin2
# scale=(aa2*bb2*cc2)/(aa*bb*cc)
scale = int(
(intact_array.shape[0] * intact_array.shape[1] * intact_array.shape[2])
/ (aa * bb * cc))
data[np.where(data == 255)] = 1
data = np.where(data == 1.0)
#
from sklearn.cluster import KMeans
if data[0].__len__() > 20:
# if data[0].__len__()/scale<1:
# nn=np.ceil(data[0].__len__()/scale)*2
# else:
nn = np.ceil(data[0].__len__() / 30)
if nn < 1:
nn = 1
if scale > 400:
nn = np.ceil(data[0].__len__() / 40)
if scale <= 15:
# nn=300
nn = np.ceil(data[0].__len__() / scale)
# nn=np.ceil(data[0].__len__()/30)*2.3
if nn > 300:
nn = 300
# if scale<=10:
# nn=np.ceil(data[0].__len__()/scale)*0.2
# if nn>300:
# nn=300
if scale <= 8:
# nn=500/scale
# nn=np.ceil(data[0].__len__()/30)*3
nn = np.ceil(
math.ceil((data[0].__len__() / math.floor(scale))) / 2)
if nn > 350:
nn = 350
if scale <= 2:
nn = np.ceil(data[0].__len__() / 30) * 4
# nn=500
if nn > 500:
nn = 500
# nn=data[0].__len__()/20
print("number of clusters")
print(nn)
# nn=math.ceil(data[0].__len__())/20
cluster = KMeans(n_clusters=int(nn), algorithm='full',
max_iter=500).fit(np.asarray(data).transpose())
c2 = 0
for i in (np.unique(cluster.labels_)):
jjj.append((np.where(cluster.labels_ == i))[0].size)
print(jjj)
print("number of clusters")
print(nn)
print("max")
print(np.asarray(jjj).max())
for i in range(jjj.__len__()):
k = jjj.pop()
if k > 48:
print(k)
print("overhang has happend in label")
print(i)
c2 = c2 + 1
cluster = KMeans(n_clusters=int(nn), algorithm='full',
max_iter=500).fit(np.asarray(data).transpose())
c1 = 0
for i in (np.unique(cluster.labels_)):
jjj.append((np.where(cluster.labels_ == i))[0].size)
print(jjj)
print("number of clusters")
print(nn)
print("max")
print(np.asarray(jjj).max())
for i in range(jjj.__len__()):
k = jjj.pop()
if k > 48:
print(k)
print("overhang has happend in label")
print(i)
c1 = c1 + 1
if c1 > 0 and c2 > 0:
print("overhang has happend")
res = 0
np.max
percent = 1 - (np.max((c1, c2)) / nn)
else:
print("No Overhang")
res = 1
percent = 0
else:
print("over hang has not happend")
percent = 1
res = 1
print('scale')
print(scale)
print('percent')
print(percent)
return res
# Get your arguments
args = parser.parse_args()
low = args.args4
high = args.args5
################################################Reading Dissected Volume##########################################################################
# read the original volume
ext = os.path.splitext(args.args2)[1]
m_string = args.args2
if (ext == ".nii" or ext == ".nrrd"):
input_volume = sitk.ReadImage(m_string)
else:
input_volume = RIM.dicom_series_reader(m_string)
spacing = input_volume.GetSpacing()
origin = input_volume.GetOrigin()
try:
dissected_matrix = sitk.GetArrayFromImage(input_volume)
except:
dissected_matrix = itk.GetArrayFromImage(input_volume)
w1 = dissected_matrix.shape[2]
h1 = dissected_matrix.shape[1]
d1 = dissected_matrix.shape[0]
#############################Reading Intact Volume################################
ext = os.path.splitext(str((args.args3)))[1]
m_string3 = str((args.args3))
