def plot_image(fig, ax, imageId, img_key, selected_channels=None):
'''
Plot get_images(imageId)[image_key] on axis/fig
Optional: select which channels of the image are used (used for sixteen_band/ images)
Parameters
----------
img_key : str, {'3', 'P', 'N', 'A'}
See get_images for description.
'''
images = get_images(imageId, img_key)
img = images[img_key]
title_suffix = ''
if selected_channels is not None:
img = img[selected_channels]
title_suffix = ' (' + ','.join([repr(i)
for i in selected_channels]) + ')'
if len(img.shape) == 2:
new_img = np.zeros((3, img.shape[0], img.shape[1]))
new_img[0] = img
new_img[1] = img
new_img[2] = img
img = new_img
tiff.imshow(img, figure=fig, subplot=ax)
ax.set_title(imageId + ' - ' + img_key + title_suffix)
ax.set_xlabel(img.shape[-2])
ax.set_ylabel(img.shape[-1])
ax.set_xticks([])
ax.set_yticks([])
def main(argv=None):
"""Command line usage main function."""
if argv is None:
argv = sys.argv
if len(argv) < 2:
filename = askopenfilename(title='Select a CZI file',
multiple=False,
filetypes=[('CZI files', '*.czi')])
else:
filename = argv[1]
if not filename:
return
timer = Timer()
with CziFile(filename) as czi:
timer.stop()
print(czi)
print()
timer.print('Opening file: ')
timer.start('Reading image:')
data = czi.asarray()
timer.print()
from matplotlib import pyplot # NOQA: delay import
imshow(data, title=os.path.split(filename)[-1])
pyplot.show()
def StackInt(self, start, stop, step=0.2):
no = int((stop - start) / step) + 1
pos = start
xs = self.ccd.image_size[0]
ys = self.ccd.image_size[1]
self.data = N.zeros((no, xs, ys), dtype=N.uint16)
self.ccd.SetShutterMode(1)
for p in range(no):
self.zst.setPositionf(pos)
q = self.ccd.Acquire()
q = self.ccd.WaitForNewData()
q = self.ccd.AbortAcquisition()
self.data[p] = self.ccd.images
pos += step
self.ccd.AbortAcquisition()
self.ccd.SetShutterMode(2)
cur_pos = self.prior.getPosition()
self.stackTags(cur_pos[0],
cur_pos[1],
start,
stop,
step,
function='Z-Stack')
T.imshow(self.data, vmin=self.data.min(), vmax=self.data.max())
return True
def singleSnapExt(self, verbose=True):
pos = self.zst.getPosition()
xs = self.ccd.image_size[0]
ys = self.ccd.image_size[1]
self.data = N.zeros((xs, ys), dtype=N.uint16)
self.ccd.SetShutterMode(1)
self.ccd.Acquire()
time.sleep(0.2) # was 0.05
daq.CCDTrig_run(self.handleA, self.handleB)
self.ccd.WaitForNewData()
self.data[:, :] = self.ccd.images
self.ccd.AbortAcquisition()
self.ccd.SetShutterMode(2)
if verbose:
T.imshow(self.data, vmin=self.data.min(), vmax=self.data.max())
cur_pos = self.prior.getPosition()
xx = cur_pos[0]
yy = cur_pos[1]
self.stackTags(xx,
yy,
z1=pos,
z2=pos,
zs=0.,
function='Single snap',
ps=89)
return True
def main():
parser = argparse.ArgumentParser()
parser.add_argument('in_path', help='input tiff file or directory')
parser.add_argument('min_size',
help='minimum w*h*d',
nargs='?',
default=0,
type=int)
args = parser.parse_args()
files = []
if os.path.isdir(args.in_path):
for r, _, fnames in os.walk(args.in_path):
for fname in fnames:
files.append((r + '/' + fname))
elif os.path.isfile(args.in_path):
files.append(args.in_path)
print('Found {} file{}'.format(len(files), '' if len(files) == 1 else 's'))
for f in files:
img = tifffile.imread(f)
d, h, w = img.shape
if d * h * w >= args.min_size:
print(f, w, h, d)
tifffile.imshow(img, title=f)
# tifffile.imshow(img,title=f,cmap=plt.cm.magma)
plt.show()
def VecZernDecomp(bpp, nx, radius, verbose=False, phase=True):
''' the output is the amplitude of the different Zernike components in radians
where the Zernikes are normalized to an RMS amplitude of 1 '''
# if p==None:
# nx = bpp.shape[0]
# radius = nx/2
# else:
# nx = p.Nx#params['Nx']
# dx = p.dx#params['dx']
# wl = p.wl#params['wl']
# nap = p.na #params['na']
# n2 = p.n2# params['n2']
# dp = 1/(nx*dx)
# radius = (2*nap/wl)/2/dp
# factor = nx/2./radius
#########################
if phase:
phi = bpp
else:
phi = N.angle(bpp)
dx, dy = diff(phi, radius)
if verbose:
T.imshow(dx, vmax=dx.max(), vmin=dx.min())
T.imshow(dy, vmax=dx.max(), vmin=dx.min())
scoeff = [0]
for j in range(1, Nzern):
sx, sy = getS(j)
t = (sx(nx, nx, radius) * dx - sy(nx, nx, radius) * dy).sum() / (
N.pi * (radius)**2) #changed to minus
if verbose: print(j, t)
scoeff.append(t)
return N.array(getZc(scoeff))
def make_film(images):
images = [normalise(i[:, 125:275, 125:275]) for i in images]
print([i.max() for i in images])
print([i.shape for i in images])
film_data1 = np.concatenate(images[0:2], axis=2)
print(film_data1.shape)
film_data2 = np.concatenate(images[2:], axis=2)
print(film_data2.shape)
film_data = np.concatenate([film_data1, film_data2], axis=1)
print(film_data.shape)
film_data[film_data < 0] = 0
print(film_data.shape)
outpath = os.path.join(outdir, 'movie.gif')
imageio.mimsave(outpath, film_data)
quit()
print(outpath)
for frame in range(15, film_data.shape[0]):
still_frame = film_data[frame]
imshow(still_frame)
plt.show()
outpath = os.path.join(outdir, f'movie_still_{frame}.png')
Image.fromarray(still_frame * 255).convert("L").save(outpath)
print(outpath)
quit()
def view(args):
import tifffile as tf
import matplotlib.pyplot as plt
if args.file.endswith(".tif") or args.file.endswith(".tiff"):
print(f"loading {args.file}")
im = tf.imread(args.file)
elif os.path.isdir(args.file):
from glob import glob
im0 = glob(
os.path.join(args.file, "**",
"*{:04d}*Pos0*.tif".format(args.t)))[0]
print("loading timepoint {}, pos {}".format(args.t, args.p))
im = tf.imread(im0, series=args.p)
if args.max:
tf.imshow(
im.max(0),
vmax=im.max() * args.contrast,
cmap="gray",
photometric="minisblack",
)
else:
tf.imshow(im,
vmax=im.max() * args.contrast,
cmap="gray",
photometric="minisblack")
plt.show()
def plot_image(fig, ax, imageId, img_key, selected_channels=None):
'''
Plot get_images(imageId)[image_key] on axis/fig
Optional: select which channels of the image are used (used for sixteen_band/ images)
Parameters
----------
img_key : str, {'3', 'P', 'N', 'A'}
See get_images for description.
'''
images = get_images(imageId, img_key)
img = images[img_key]
title_suffix = ''
if selected_channels is not None:
img = img[selected_channels]
title_suffix = ' (' + ','.join([ repr(i) for i in selected_channels ]) + ')'
if len(img.shape) == 2:
new_img = np.zeros((3, img.shape[0], img.shape[1]))
new_img[0] = img
new_img[1] = img
new_img[2] = img
img = new_img
tiff.imshow(img, figure=fig, subplot=ax)
ax.set_title(imageId + ' - ' + img_key + title_suffix)
ax.set_xlabel(img.shape[-2])
ax.set_ylabel(img.shape[-1])
ax.set_xticks([])
ax.set_yticks([])
def TimeLapseExt(self, no=200, pol=0, verbose=True):
pos = self.zst.getPosition()
xs = self.ccd.image_size[0]
ys = self.ccd.image_size[1]
self.data = N.zeros((no, xs, ys), dtype=N.uint16)
self.ccd.SetShutterMode(1)
q = self.ccd.Acquire()
time.sleep(0.01)
self.zst.setPositionf(pos)
self.pol.MoveAbs(pol)
for p in range(no):
self.zst.setPositionf(pos)
time.sleep(0.01)
daq.CCDTrig_run(self.handleA, self.handleB)
q = self.ccd.WaitForNewData()
print(p, q)
self.data[p] = self.ccd.images
time.sleep(0.01)
self.ccd.AbortAcquisition()
self.ccd.SetShutterMode(2)
if verbose:
T.imshow(self.data, vmin=self.data.min(), vmax=self.data.max())
cur_pos = self.prior.getPosition()
xx = cur_pos[0]
yy = cur_pos[1]
self.stackTags(xx,
yy,
pos,
pos,
zs=0.,
function='Time-Lapse widefield',
ps=89)
return True
def lastimage(n):
hdr = db[-n]
for doc in hdr.documents(fill=True):
data1 = doc[1].get('data')
if data1 != None:
light_img = data1['pe1c_image']
dark_uid = hdr.start.get('sc_dk_field_uid')
dk_hdrs = db(uid=dark_uid)
for dk_hdr in dk_hdrs:
for doc in dk_hdr.documents(fill=True):
dk_data1 = doc[1].get('data')
if dk_data1 != None:
dk_img = dk_data1['pe1c_image']
I = light_img - dk_img
imshow(I, vmax=(I.sum() / (2048 * 2048)), cmap='jet')
imsave(
"/nsls2/xf28id1/xpdacq_data/user_data/tiff_base/" + "dark_sub_image" +
".tiff", light_img - dk_img)
imsave(
"/nsls2/xf28id1/xpdacq_data/user_data/tiff_base/" + "dark_image" +
".tiff", dk_img)
imsave(
"/nsls2/xf28id1/xpdacq_data/user_data/tiff_base/" + "light_image" +
".tiff", light_img)
def show(self):
if self.img is not None:
tiff.imshow(self.img)
plt.show()
if self.RGB_mask is not None:
tiff.imshow(self.RGB_mask)
plt.show()
def noise_movie(frame_filter, width_filter, height_filter, is_plot=False):
"""
creating a numpy array with shape [len(frame_filter), len(height_filter), len(width_filter)]
this array is random noise filtered by these three filters in Fourier domain
each pixel of the movie have the value in [0. - 1.]
"""
raw_mov = np.random.rand(len(frame_filter), len(height_filter), len(width_filter))
raw_mov_fft = np.fft.fftn(raw_mov)
filter_x = np.repeat(np.array([width_filter]), len(height_filter), axis=0)
filter_y = np.repeat(np.transpose(np.array([height_filter])), len(width_filter), axis=1)
filter_xy = filter_x * filter_y
for i in xrange(raw_mov_fft.shape[0]):
raw_mov_fft[i] = frame_filter[i] * (raw_mov_fft[i] * filter_xy)
filtered_mov = np.real(np.fft.ifftn(raw_mov_fft))
movie = bas.array_nor(filtered_mov)
if is_plot:
tf.imshow(movie, vmin=0, vmax=1, cmap='gray')
return movie
def P(image_id):
filename = os.path.join(inDir, 'sixteen_band', '{}_P.tif'.format(image_id))
img = tiff.imread(filename)
img = np.rollaxis(img, 0, 3)
tiff.imshow(stretch_n(pan.reshape(pan.shape[0], pan.shape[1], 1)))
return img
def orthomat(jm):
q = F.zeroArrF((jm, jm))
for m in range(1, jm):
for n in range(1, jm):
q[m, n] = testortho(m, n)
T.imshow(q)
return q
def StackExt(self,start,stop,step=0.2,verbose=True):
init_loc=self.zst.getPosition()
no = int((stop-start)/step)+1
pos = start
xs = self.ccd.image_size[0]
ys = self.ccd.image_size[1]
self.data = N.zeros((no,xs,ys), N.uint16)
self.ccd.SetShutterMode(1)
q = self.ccd.Acquire()
time.sleep(0.2) # was 0.05
for p in range(no):
self.zst.setPositionf(pos)
daq.CCDTrig_run(self.handleA,self.handleB)
q = self.ccd.WaitForNewData()
print(p,q)
self.data[p] = self.ccd.images
pos += step
time.sleep(self.delay)
self.ccd.AbortAcquisition()
self.ccd.SetShutterMode(2)
if verbose:
T.imshow(self.data, vmin=self.data.min(), vmax=self.data.max())
cur_pos = self.prior.getPosition()
self.stackTags(cur_pos[0],cur_pos[1],start,stop,step,function='Z-Stack')
self.zst.setPositionf(init_loc)
return True
def Stack_Sectioning(self,start,stop,step=0.2, verbose=True):
no = int((stop-start)/step)+1
pos = start
xs = self.ccd.image_size[0]
ys = self.ccd.image_size[1]
# psz = qx.getordernum()
psz = 3
self.data = N.zeros((psz*no,xs,ys), dtype=N.uint16)
self.ccd.SetShutterMode(1)
q = self.ccd.Acquire()
self.pol.MoveAbs(0)
time.sleep(0.4)
for p in range(no):
self.zst.setPositionf(pos)
for m in range(psz):
qx.selecteorder(15+m)
qx.activate()
time.sleep(0.02)
daq.CCDTrig_run(self.handleA,self.handleB)
q = self.ccd.WaitForNewData()
print (p,q)
self.data[psz*p + m] = self.ccd.images
qx.deactivate()
time.sleep(0.02)
pos += step
self.ccd.AbortAcquisition()
self.ccd.SetShutterMode(2)
if verbose:
T.imshow(self.data, vmin=self.data.min(), vmax=self.data.max())
cur_pos = self.zst.getPosition()
self.stackTags(cur_pos,start,stop,step,function='Z-Stack patterns')
return True
def show_image(im, ms, number, name=""):
"""
Outputs a plot with multiple subplots showing the original crop in RGB and the masks for all 10 classes.
"""
image = np.zeros((im.shape[0], im.shape[1], 3))
image[:, :, 0] = im[:, :, 0] # red
image[:, :, 1] = im[:, :, 1] # green
image[:, :, 2] = im[:, :, 2] # blue
classes = ["Buildings", "Misc. structures", "Road", "Track", "Trees", "Crops", "Waterway",
"Standing Water", "Vehicle Large", "Vehicle Small"]
f, (axarr) = plt.subplots(3, 4, sharey=True, figsize=(20,15))
counter = 0
for j in range(3):
for k in range(4):
if (j==0) & (k==0):
tiff.imshow(image, figure=f, subplot=axarr[0,0])
plt.grid("off")
plt.title("Raw Image", size=22)
continue
elif (j==2) & (k==3):
pass
else:
msk = ms[:,:,counter]
tiff.imshow(255*np.stack([msk,msk,msk]), figure=f, subplot=axarr[j,k])
plt.grid("off")
# plt.title(name, size=22)
plt.title("{} Mask".format(classes[counter]), size=22)
counter += 1
plt.grid("off")
os.makedirs("../plots", exist_ok=True)
plt.savefig("../plots/Crop_{}_{}.png".format(number, name), bbox_inches="tight", pad_inches=1)
plt.clf()
plt.cla()
plt.close()
def show_raster(raster):
import tifffile as tiff
from matplotlib import pyplot as plt
fig, ax = plt.subplots(figsize=(8, 8))
tiff.imshow(raster, figure=fig, subplot=ax)
plt.show()
def compare_masks(self):
if self.predicted_RGB_mask is not None:
tiff.imshow(self.predicted_RGB_mask)
plt.show()
tiff.imshow(self.RGB_mask)
plt.show()
else:
print('There is not predicted mask!')
def show_grid(self, part='delta'):
import tifffile
if part == 'delta':
tifffile.imshow(self.grid_delta)
elif part == 'beta':
tifffile.imshow(self.grid_beta)
else:
warnings.warn('Wrong part specified for show_grid.')
def averageAll(self,verbose=True):
nz,ny,nx = self.tmp.shape
avg = N.zeros((ny,nx),dtype=N.float64)
for i in range(nz):
avg+=(self.tmp[i]/nz)
if verbose:
T.imshow(avg)
self.avg = avg
def show_image_with_mask(imageId, maskAlpha=0.4, figsize=(10, 10)):
fig, ax = plt.subplots(figsize=figsize)
img = stretch_n(M(imageId))
mask = generate_mask_for_image_and_class(img.shape[:2], imageId)
tifffile.imshow(img, figure=fig, subplot=ax)
ax.imshow(mask, alpha=maskAlpha)
ax.axis("off")
plt.show()
def testortho(j1, j2, verbose=False):
nx = 256
ny = 256
rad = 100
sx1, sy1 = getS(j1)
sx2, sy2 = getS(j2)
dp = (sx1(nx, ny, rad) * sx2(nx, ny, rad) +
sy1(nx, ny, rad) * sy2(nx, ny, rad))
if verbose: T.imshow(dp)
return (dp.sum() / (N.pi * rad**2)) #(nx*ny))
def imshowpair(im1, im2, method=None, mip=False, **kwargs):
# normalize
if not im1.shape == im2.shape:
raise ValueError("images must be same shape")
if not mip:
try:
from tifffile import imshow
except ImportError:
imshow = plt.imshow
mip = True
else:
imshow = plt.imshow
if im1.ndim < 3:
mip = False
if method == "diff":
imshow(imoverlay(im1, im2, "diff"), cmap="gray", vmin=0.2, vmax=0.8)
elif method == "3D":
im3 = imoverlay(im1, im2)
fig, subpl, ax = imshow(im3, subplot=221)
imshow(np.rot90(im3.max(1)), figure=fig, subplot=222)
imshow(im3.max(2), figure=fig, subplot=223)
else: # falsecolor
imshow(imoverlay(im1, im2))
plt.show()
def show_image(imageId, fig=None, ax=None):
do_show = False
if fig is None or ax is None:
fig, ax = plt.subplots(figsize=(10, 10))
do_show = True
img = M(imageId)
img_color_stretched = stretch_n(img)
tifffile.imshow(img_color_stretched, figure=fig, subplot=ax)
ax.axis("off")
if do_show:
plt.show()
def show_image_channel(imageId, channel="M", fig=None, ax=None):
do_show = False
if fig is None or ax is None:
fig, ax = plt.subplots(figsize=(10, 10))
do_show = True
img = M_sixteen_band(imageId, channel=channel)
img_color_stretched = stretch_n(img)
tifffile.imshow(img_color_stretched, figure=fig, subplot=ax)
ax.axis("off")
if do_show:
plt.show()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('in_path',help='input tiff file or directory')
parser.add_argument('min_size',help='minimum w*h*d',nargs='?',default=0,type=int)
args = parser.parse_args()
files = []
if os.path.isdir(args.in_path):
for r,_,fnames in os.walk(args.in_path):
for fname in fnames:
files.append((r+'/'+fname))
elif os.path.isfile(args.in_path):
files.append(args.in_path)
resol,stepsize,C = 256,64,0
print('Found {} file{}'.format(len(files),'' if len(files)==1 else 's'))
for f in files:
img = tf.imread(f)
d,h,w = img.shape
print(f,w,h,d,args.min_size,img.nbytes//1e6)
img = tf.transpose_axes(img, 'YXZ', 'XYZ')
d,h,w = img.shape
aux = 1
cmap = matplotlib.cm.get_cmap('inferno',stepsize)
bounds = list(range(0,resol, resol//stepsize))
bounds.append(resol)
norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N)
if C:
npz = np.arange(resol).astype('uint8')
z11 = np.array([3.17108944e-04, 9.92360110e-01, 1.61116136e+00])
for i in range(len(npz)):
aux = round(z11[0]*npz[i]*npz[i]+z11[1]*npz[i]+z11[2])
if aux < 256 and aux > 0:
npz[i] = int(aux)
elif aux > 255:
npz[i] = 255
else:
npz[i] = 0
with np.nditer(img, flags=['external_loop'], op_flags=['readwrite']) as it:
for x in it:
x[...] = npz[x]
print(f,w,h,d,args.min_size)
if d*h*w>=args.min_size:
tf.imshow(img,cmap = cmap, norm = norm, title=f,origin='lower')
# tf.imshow(img,title=f,cmap=plt.cm.magma)
plt.show()
C = 1
def process_challenge_data(imname, image):
image = normalise(image)
image = np.fliplr(np.flipud(image))
# lateral crop
image = image[:, 250:400, 125:275]
# sum along y
image = image.mean(axis=1)
image = image.astype(np.float32)
imshow(image)
plt.show()
return image
def transform_img(impath, im_type):
img = imread(impath)
img = img / img.max()
img = img[:, :, :]
img = img[40:110, 240, 180:320].transpose()
imshow(img)
plt.title(im_type)
plt.show()
outname = os.path.join(outdir, f"{imname.replace('out.tif' ,'')}{im_type}_yz.png")
Image.fromarray(img * 255).convert("L").save(outname)
print(outname)
def plot_mask(mask_data, figure=None, subplot=111, title=None):
"""Adopted from https://www.kaggle.com/lopuhin/dstl-satellite-imagery-feature-detection/full-pipeline-demo-poly-pixels-ml-poly"""
import matplotlib.pyplot as plt
import tifffile as tiff
mask_plot_data = 255 * np.stack([mask_data, mask_data, mask_data])
tiff.imshow(mask_plot_data, figure=figure, subplot=subplot)
if title is not None:
plt.title(title)
plt.show()
def show_image(self, name):
"""Show image on image view
:param name: image file path
:type name: str
"""
# size = self.imageView.get_allocation()
# pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(name, size.width, size.height)
# self.imageView.set_from_pixbuf(pixbuf)
old_viewport = self.imageScrolled.get_child()
if old_viewport:
old_viewport.destroy()
old_viewport = self.imageBox.get_child()
if old_viewport:
old_viewport.destroy()
with TiffFile(name) as img:
fig = imshow(img.asarray())[0]
canvas = FigureCanvas(fig)
self.imageScrolled.add_with_viewport(canvas)
toolbar = NavigationToolbar(canvas, self.win)
self.imageBox.add_with_viewport(toolbar)
pyplot.close(fig)
self.shape = img.asarray().shape
self.xmax.set_range(self.xmin.get_value_as_int() + 1, self.shape[0])
self.ymax.set_range(self.ymin.get_value_as_int() + 1, self.shape[1])
self.imageScrolled.show_all()
def run(config, show_output = False):
"""
Runs the simulation using the given config.
For more information on the available parameters, see configspecs.ini and the readme
Args:
config: dictionary
the configuration dict outputed by the configobj library
show_output: boolean
if True, shows the output in a new window
"""
gt_params = config['groundtruth']
volume_dim = gt_params['bounds']
voxel_dim = gt_params['voxel_dim']
#Remove voxel dim so that we can pass gt_params to the load_gt function
del gt_params['voxel_dim']
print "Loading data..."
gt_dataset = load_gt(**gt_params)
print "Labeling..."
labeling_params = config['labeling']
labeled_volumes, labeled_cells = label(gt_dataset, volume_dim, voxel_dim, labeling_params)
print "Imaging..."
expansion_params = config['expansion']
optics_params = config['optics']
volumes = resolve(labeled_volumes, volume_dim, voxel_dim, expansion_params, optics_params)
print "Saving..."
#Save to desired output
output_params = config['output']
save(volumes, **output_params)
save_gt(gt_dataset, labeled_cells, volume_dim, volumes[0].shape, voxel_dim,\
expansion_params, optics_params, **output_params)
print "Done!"
if show_output:
imshow(np.moveaxis(np.array(volumes), 0, 3))
plt.show()
import pandas.io.sql as psql import pandas.io.parsers as pp import matplotlib.image as mpimg import tifffile as tiff import scipy.signal as signal from matplotlib.colors import LogNorm inPath = '/Users/mpopovic/Documents/Work/Projects/drosophila_wing_analysis/height_maps/' inFile = 'HeightMa.png' inFile = 'HM_Stitch_Time_196.tif' a = tiff.imread(inPath+inFile) tiff.imshow(a) plt.show() gx, gy = np.gradient(a) gg = np.sqrt(gx**2+gy**2) gx_cut = gx gx.max() bin = np.arange(18) hist, bins = np.histogram(gx, bin) tiff.imshow(smooth_30_gx[500:2000,500:1500], cmap='hot') tiff.imshow(np.exp(smooth_20_gx), cmap='gist_rainbow') tiff.imshow(np.exp(smooth_20_gy), cmap='gist_rainbow') tiff.imshow(a, cmap='gist_rainbow') plt.show()
N_EPOCHS = 100
BATCH_SIZE = 100
# ask Keras to save best weights (in terms of validation loss) into file:
model_checkpoint = ModelCheckpoint(filepath='weights_simple_unet_2.hdf5', monitor='val_loss', save_best_only=True)
# ask Keras to log each epoch loss:
csv_logger = CSVLogger('log_2.csv', append=True, separator=';')
# ask Keras to log info in TensorBoard format:, but right now we dont need to check the TF graph
#tensorboard = TensorBoard(log_dir='tensorboard_simple_unet/', write_graph=True, write_images=True)
# Fit:
np.random.seed(1)
model.fit(x_aug_input, y_aug_input, batch_size=BATCH_SIZE, epochs=N_EPOCHS,
verbose=2, shuffle=True,
callbacks=[model_checkpoint, csv_logger],
validation_data=(x_val_aug_input, y_val_aug_input))
# In[ ]:
test_img_normalized = normalize(test_img)
test_img_t = test_img_normalized.transpose([1,2,0]) # keras uses last dimension for channels by default
predicted_mask = predict(test_img_t, model).transpose([2,0,1]) # channels first to plot
y_pict_2 = picture_from_mask(predicted_mask, threshold = 0.5)
tiff.imshow(y_pict_2)
# In[ ]:
tiff.imsave('predicted_mask.tif', (255*predicted_mask).astype('uint8'))
tiff.imsave('y_pict_2.tif', y_pict_2)
