def nd2arr_list(nd_dh=None, nd_fns=[], nd_fh=None):
arr_list = []
if nd_fh is None:
for nd_fn in nd_fns:
nd = nd2reader.Nd2("%s/%s" % (nd_dh, nd_fn))
for ndi in nd:
arr_list.append(np.array(ndi))
del nd
return arr_list
elif not nd_fh is None:
nd = nd2reader.Nd2("%s" % (nd_fh))
for ndi in nd:
arr_list.append(np.array(ndi))
return arr_list
def run_extraction(self):
start_t = datetime.now()
os.chdir(self.input_path)
# get position name if xml is available
if self.xml_file:
if not self.xml_dir:
self.xml_dir = self.input_path
self.pos_info()
# otherwise get lane info from y_um
else:
self.lane_info()
os.chdir(self.input_path)
# switch to another ND2reader for faster iterations
nd2 = nd2reader.Nd2(self.nd2_file)
main_dir = self.input_path + "/" + self.nd2_file_name
if not os.path.exists(main_dir):
os.makedirs(main_dir)
# parallelize extraction
poses = nd2.fields_of_view
cores = pathos.multiprocessing.cpu_count()
pool = pathos.multiprocessing.Pool(cores)
pool.map(self.tiff_extractor, poses)
time_elapsed = datetime.now() - start_t
print('Time elapsed for extraction (hh:mm:ss.ms) {}'.format(
time_elapsed))
def save_action(self, timestamps_model):
"""
Writes missing timestamp files.
So the first ND2 starts at 2015-11-13 16:53:12.
The second ND2 starts at 2015-11-14 17:01:43.
:type timestamps_model: fylm.model.Timestamps()
"""
# ND2 timestamps are relative to the beginning of acquisition of a single time period. So to get the true timestamp
# we need to look at the datetime that each ND2 began and compare it to the first ND2. This will be zero for the
# first one.
timestamp_offset = self._experiment.exact_start_time(
timestamps_model.time_period) - self._experiment.exact_start_time(
1)
log.debug("Timestamp offset for time period %s: %s" %
(timestamps_model.time_period, timestamp_offset))
log.info(
"Creating timestamps for time_period:%s, Field of View:%s" %
(timestamps_model.time_period, timestamps_model.field_of_view))
nd2_filename = self._experiment.get_nd2_from_time_period(
timestamps_model.time_period)
nd2 = nd2reader.Nd2(nd2_filename)
# subtract 1 from the field of view since nd2reader uses 0-based indexing, but we
# refer to the fields of view with 1-based indexing
for image_set in nd2.image_sets(
field_of_view=timestamps_model.field_of_view,
channels=[""],
z_levels=[0]):
image = [i for i in image_set][0]
timestamp = image.timestamp + timestamp_offset
timestamps_model.add(timestamp)
def nd2_to_tiff(data_path):
basename = splitext(data_path)[0]
nd2 = nd2reader.Nd2(data_path)
frames = nd2.frames
channels = nd2.channels
planes = nd2.z_levels
fovs = nd2.fields_of_view
for f in frames:
for c in channels:
for p in planes:
for fov in fovs:
output_filename = basename + '_frame_' + str(f) + \
'_channel_' + c + '_plane_' + str(p) + '_field_' + \
str(fov) + '.tif'
try:
image = nd2.get_image(frame_number=f,
field_of_view=fov,
channel_name=c,
z_level=p)
except:
import pudb
pudb.set_trace()
image = np.array(image).astype('uint16')
imsave(filename=output_filename, data=image)
def nd2csv(nd_fh):
nd = nd2reader.Nd2(nd_fh)
frame_cnt = 0
for frame in nd:
np.savetxt("%s/%s%02d.csv" % (nd2_dh, basename(nd_fh), frame_cnt),
frame,
delimiter=",")
frame_cnt += 1
nd.close
def load_ZStack(stack_path):
read_obj = nd2reader.Nd2(stack_path)
green_stack = np.zeros((len(read_obj.z_levels), 512, 512))
red_stack = np.zeros((len(read_obj.z_levels), 512, 512))
for i_z, z in enumerate(read_obj.z_levels):
green_stack[i_z] = read_obj.get_image(0, 0, read_obj.channels[0], z)
red_stack[i_z] = read_obj.get_image(0, 0, read_obj.channels[1], z)
return green_stack, red_stack
def __init__(self,
input_file,
crop_edge=0.05,
image_type="nd2",
plate_index=0):
self.pixel_microns = 1
self.channels = None
self.shape = None
self.fl_img = {}
self.ph_img = None
self.ph_filtered = None
self.ph_binary = None
self.shape_indexed = None
#self.shape_idx_binary = None deprecated
self.shape_indexed_smoothed = None
self.microcolony_labels = None
self.microcolony_info = None
self.sobel = None
self.celllike = []
self.cells = []
self.microcolonies = []
self.shape = None
self.global_fl_bg_mean = {}
self.global_fl_bg_std = {}
self.plate_idx = plate_index
if image_type == "nd2":
img = nd2.Nd2(input_file)
self.pixel_microns = img.pixel_microns
self.channels = img.channels
self.shape = (img.width, img.height)
self.date_time = img.date
if 0 <= crop_edge < 0.4:
crop_w = int(crop_edge * img.width)
crop_h = int(crop_edge * img.height)
w1, w2 = crop_w, img.width - crop_w
h1, h2 = crop_h, img.height - crop_h
self.shape = (img.width - 2 * crop_w, img.height - 2 * crop_h)
else:
raise ValueError(
"Fraction of cropped edge should be less than 0.4!")
self.min_length = int(round(conf.min_length / self.pixel_microns))
self.max_length = int(round(conf.max_length / self.pixel_microns))
for channel in self.channels:
if re.search("ph", channel, re.IGNORECASE):
self.ph_img = np.array(
img[img.channels.index(channel)]).astype(
np.uint16)[h1:h2, w1:w2]
else:
self.fl_img[channel] = np.array(
img[img.channels.index(channel)]).astype(
np.uint16)[h1:h2, w1:w2]
def _get_nd2_attributes(self, experiment):
"""
Determine several attributes of the ND2s used in this experiment.
:type experiment: model.experiment.Experiment()
"""
experiment_log = self._load_experiment_log(experiment)
found_an_nd2 = False
for n, nd2_filename in enumerate(experiment.nd2s):
try:
nd2 = nd2reader.Nd2(nd2_filename)
except IOError:
pass
else:
# We need to know the absolute time that an experiment began so we can figure out the gap between
# different files (as that could be any amount of time).
timestamp = self._utc_timestamp(nd2.absolute_start)
time_period = n + 1
experiment.set_time_period_start_time(time_period, timestamp)
experiment_log['start_unix_timestamps'][str(
time_period)] = timestamp
experiment.field_of_view_count = nd2.field_of_view_count
experiment_log['field_of_view_count'] = nd2.field_of_view_count
experiment_log['has_fluorescent_channels'] = False
for channel in nd2.channels:
if channel.name != "":
log.info("Experiment has fluorescent channels.")
experiment.has_fluorescent_channels = True
experiment_log['has_fluorescent_channels'] = True
break
else:
log.info("Experiment does not have fluorescent channels.")
self._save_experiment_log(experiment, experiment_log)
found_an_nd2 = True
if not found_an_nd2:
# There are no ND2s so we load all the information we need from the log.
if 'field_of_view_count' not in experiment_log.keys(
) or 'has_fluorescent_channels' not in experiment_log.keys():
terminal_error(
"No ND2s found and no attributes saved. It seems like you haven't even started this experiment."
)
experiment.field_of_view_count = int(
experiment_log['field_of_view_count'])
experiment.has_fluorescent_channels = experiment_log[
'has_fluorescent_channels']
for time_period, timestamp in experiment_log[
'start_unix_timestamps'].items():
experiment.set_time_period_start_time(time_period, timestamp)
def get_wholefield_fluorescence(stim_table,im_filetype,im_directory,exp_date,mouse_ID,savepath):
if os.path.isfile(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy'):
avg_fluorescence = np.load(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy')
else:
im_path = None
if im_filetype=='nd2':
for f in os.listdir(im_directory):
if f.endswith(im_filetype) and f.lower().find('local') == -1:
im_path = im_directory + f
print im_path
elif im_filetype=='h5':
#find experiment directory:
for f in os.listdir(im_directory):
if f.lower().find('ophys_experiment_')!=-1:
exp_path = im_directory+f+'\\'
session_ID = f[17:]
print session_ID
else:
print 'im_filetype not recognized!'
sys.exit(1)
if im_filetype=='nd2':
print 'Reading nd2...'
read_obj = nd2reader.Nd2(im_path)
num_frames = len(read_obj.frames)
avg_fluorescence = np.zeros((num_frames,))
sweep_starts = stim_table['Start'].values
block_bounds = []
block_bounds.append((np.min(sweep_starts)-30,np.max(sweep_starts[sweep_starts<50000])+100))
block_bounds.append((np.min(sweep_starts[sweep_starts>50000])-30,np.max(sweep_starts)+100))
for block in block_bounds:
frame_start = int(block[0])
frame_end = int(block[1])
for f in np.arange(frame_start,frame_end):
this_frame = read_obj.get_image(f,0,read_obj.channels[0],0)
print 'Loaded frame ' + str(f) + ' of ' + str(num_frames)
avg_fluorescence[f] = np.mean(this_frame)
elif im_filetype=='h5':
f = h5py.File(exp_path+session_ID+'.h5')
data = np.array(f['data'])
avg_fluorescence = np.mean(data,axis=(1,2))
f.close()
np.save(savepath+exp_date+'_'+mouse_ID+'_wholefield.npy',avg_fluorescence)
return avg_fluorescence
def save_action(self, registration_model):
"""
Calculates the rotation offset for a single field of view and time_period.
:type registration_model: fylm.model.registration.Registration()
"""
log.info("Creating registration file %s" % registration_model.filename)
# This is a pretty naive loop - the same file will get opened 8-12 times
# There are obvious ways to optimize this but that can be done later if it matters
# It probably doesn't matter though and I like simple things
base_nd2_filename = self._experiment.get_nd2_from_time_period(1)
nd2_filename = self._experiment.get_nd2_from_time_period(
registration_model.time_period)
base_nd2 = nd2reader.Nd2(base_nd2_filename)
nd2 = nd2reader.Nd2(nd2_filename)
# gets the first out-of-focus image from the first time_period in the stack
base_image = base_nd2.get_image(0, registration_model.field_of_view,
"", 0)
for i in range(nd2.time_index_count):
image = nd2.get_image(i, registration_model.field_of_view, "", 0)
dx, dy = self._determine_registration_offset(
base_image.data, image.data)
registration_model.add(dx, dy)
def process(file):
stack = nd2r.Nd2('Images/' + file)
for i in range(6):
bf = normalize(stack[i*5+4])
gfp = normalize(stack[i*5+2])
find_distance_from_center(gfp, bf, signal)
# with open('pickles/' + file + '.pkl', 'wb') as handle:
# pik.dump(signal, handle)
make_boxplot(signal, file)
def save_action(self, rotation_model):
"""
Calculates the rotation offset for a single field of view and time_period.
:type rotation_model: fylm.model.rotation.Rotation()
"""
log.info("Creating rotation file %s" % rotation_model.filename)
# This is a pretty naive loop - the same file will get opened 8-12 times
# There are obvious ways to optimize this but that can be done later if it matters
# It probably doesn't matter though and I like simple things
nd2_filename = self._experiment.get_nd2_from_time_period(
rotation_model.time_period)
nd2 = nd2reader.Nd2(nd2_filename)
# gets the first in-focus image from the first timpoint in the stack
# TODO: Update nd2reader to figure out which one is in focus or to be able to set it
image = nd2.get_image(0, rotation_model.field_of_view, "", 1)
offset = self._determine_rotation_offset(image.data)
rotation_model.offset = offset
def get_nd2_dict(img_path):
print img_path in os.listdir(IMAGE_DIR)
# print os.listdir(IMAGE_DIR)
im_name = img_path.replace('.nd2', '')
im_name_pickle = im_name + '.pkl'
if im_name_pickle not in os.listdir(IMAGE_DIR):
print '---------------------------------'
print 'CREATING NEW PICKLE FILE'
print '---------------------------------'
img_dict = {
'DAPI': {},
'FITC': {},
'FITClong': {},
'CY3': {},
'BF-Cy3': {}
}
nd2 = nd2reader.Nd2(IMAGE_DIR + '/' + img_path)
# nd2 = nd2reader.Nd2(img_path)
print nd2.fields_of_view
for i in range(len(nd2)):
channel = nd2[i].channel
fov = nd2[i].field_of_view
# img_dict[channel][fov] = nd2[i]
img_dict[channel][fov] = nd2[i].astype(np.uint16)
# / np.amax(nd2[i]).astype(np.uint16)
pickle.dump(img_dict, open(IMAGE_DIR + '/' + im_name_pickle, 'w'))
else:
print '---------------------------------'
print 'LOADING FROM PICKLE FILE'
print '---------------------------------'
img_dict = pickle.load(open(IMAGE_DIR + '/' + im_name_pickle, 'r'))
print '...done'
return img_dict
def tiff_extractor(self, pos):
nd2 = nd2reader.Nd2(self.nd2_f)
if self.pos_dict:
new_dir = self.main_dir + "/Lane_" + str(
self.lane_dict[pos]).im(2) + "/" + self.pos_dict[pos] + "/"
else:
lane_ind = self.lane_dict[pos]
pos_off = self.pos_offset[lane_ind]
new_dir = self.main_dir + "/Lane_" + str(lane_ind).zfill(
2) + "/pos_" + str(pos - pos_off).zfill(3) + "/"
# create a folder for each position
if not os.path.exists(new_dir):
os.makedirs(new_dir)
os.chdir(new_dir)
if self.pos_dict:
meta_name = self.nd2_file_name + "_" + self.pos_dict[pos] + "_t"
else:
meta_name = self.nd2_file_name + "_pos_" + str(
pos - pos_off).zfill(3) + "_t"
for image in nd2.select(fields_of_view=pos):
channel = image._channel
channel = str(channel.encode('ascii', 'ignore'))
time_point = image.frame_number
tiff_name = meta_name + str(time_point).zfill(
4) + "_c_" + channel + ".tiff"
# save file in 16-bit
# thanks to http://shortrecipes.blogspot.com/2009/01/python-python-imaging-library-16-bit.html
image = image.base.astype(np.uint16)
out = PIL.Image.frombytes("I;16", (image.shape[1], image.shape[0]),
image.tobytes())
out.save(tiff_name)
os.chdir(self.file_dir)
mt)**2
if maxBetweenVar < currVarB:
maxBetweenVar = currVarB
t1 = i
t2 = j
return 1.0 * t1 / bins, 1.0 * t2 / bins
def normalize(img):
high = np.amax(img)
low = np.amin(img)
return (img - low) / (high - low)
stack = nd2r.Nd2(
'/Users/student/Projects/PlateImages/Plate000_WellF08_Seq0040.nd2')
test = stack[4].astype(np.float64) / np.amax(stack[4])
cy3 = stack[3].astype(np.float64) / np.amax(stack[3])
dapi = stack[0].astype(np.float64) / np.amax(stack[0])
def find_cells(img):
strong_blur = filters.gaussian(img, 20)
no_back = img - strong_blur
no_back = normalize(no_back)
equalized_no_back = exposure.equalize_hist(no_back)
equalized_no_back = normalize(equalized_no_back)
edges_nb = feature.canny(equalized_no_back, sigma=5)
close_nb = ndi.binary_closing(edges_nb,
structure=np.ones((3, 3)),
iterations=1)
def nd2_to_npy(gene,
raw_data_gene_fname,
tmp_gene_dir,
processing_hyb,
use_ram=True,
max_ram=150000000000):
"""
Function used to convert Nikon ND2 files in numpy arrays.
Important: require the nd2reader (https://github.com/jimrybarski/nd2reader)
pip install "nd2reader==2.1.3". There is a new version based on pims
but need to be tested
The input ND2 file will have only one channel and will be converted in a
binary npy.
Parameters:
-----------
gene: str
Name of the gene to process (ex. Aldoc)
raw_data_gene_fname: str
Path to the ND2 file (ex. '/Users/simone/Desktop/test/ND2conversion/BW_Aldoc.nd2')
tmp_gene_dir: str
path to the folder where to save the npy files
processing_hyb: str
Name of the processing_hyb to process (ex. EXP-17-BP3597_hyb2)
use_ram: bool
If True the images are written first in ram until max_ram is reached
max_ram: int
Size of the RAM that can be used as temporary storage
"""
size_counter = 0
tmp_storage = {}
with nd2.Nd2(raw_data_gene_fname) as nd2file:
for channel in nd2file.channels:
for fov in nd2file.fields_of_view:
img_stack = np.empty(
[len(nd2file.z_levels), nd2file.height, nd2file.width],
dtype='uint16')
images = nd2file.select(channels=channel,
fields_of_view=fov,
z_levels=nd2file.z_levels)
for idx, im in enumerate(images):
img_stack[idx, :, :] = im
converted_fname = tmp_gene_dir + processing_hyb + '_' + gene + '_pos_' + str(
fov) + '.npy'
if use_ram:
# Create a dict that is saved in ram. When full is written on disk
# Done to reduce the number of i/o and increase performance
size_counter += img_stack.nbytes
if size_counter < max_ram:
tmp_storage[fov] = {}
tmp_storage[fov]['img'] = img_stack
tmp_storage[fov]['converted_fname'] = converted_fname
else:
for pos in tmp_storage.keys():
np.save(tmp_storage[pos]['converted_fname'],
tmp_storage[pos]['img'],
allow_pickle=False)
tmp_storage = {}
size_counter = img_stack.nbytes
tmp_storage[fov] = {}
tmp_storage[fov]['img'] = img_stack
tmp_storage[fov]['converted_fname'] = converted_fname
else:
# Directly save the file without saving it in RAM
np.save(converted_fname, img_stack, allow_pickle=False)
# Save the data that remained in the tmp_storage (if RAM is used)
if use_ram:
for pos in tmp_storage.keys():
np.save(tmp_storage[pos]['converted_fname'],
tmp_storage[pos]['img'],
allow_pickle=False)
def process_standalone_experiment():
"""
Script to run conversion, filtering and raw counting on a small set of images.
The analysis run locally
All the parameters are entered with argparse
Parameters:
-----------
path: string
Path to the experiment to process
analysis_name: string
Name of the analysis
stringency: int
Value of the stringency to use in the threshold selection. Default=0
min_distance: int
Min distance betwenn to peaks. Default=5
min_plane: int
Min plane for z-stack cropping. Default=None
max_plane: int:
Max plane for z-stack cropping. Default=None
ncores: int
Number of cores to use for the processing. Deafault=1
"""
# input to the function
parser = argparse.ArgumentParser(
description='Counting and filtering experiment')
parser.add_argument('-path', help='path to experiment to analyze')
parser.add_argument('-analysis_name', help='analysis name')
parser.add_argument('-stringency', help='stringency', default=0, type=int)
parser.add_argument('-min_distance',
help='min distance between peaks',
default=5,
type=int)
parser.add_argument('-min_plane',
help='starting plane to consider',
default=None,
type=int)
parser.add_argument('-max_plane',
help='ending plane to consider',
default=None,
type=int)
parser.add_argument('-ncores',
help='number of cores to use',
default=1,
type=int)
# Parse the input args
args = parser.parse_args()
processing_directory = args.path
analysis_name = args.analysis_name
stringency = args.stringency
min_distance = args.min_distance
min_plane = args.min_plane
max_plane = args.max_plane
ncores = args.ncores
if min_plane != None and max_plane != None:
plane_keep = [min_plane, max_plane]
else:
plane_keep = None
# Determine the os type
os_windows, add_slash = utils.determine_os()
# Starting logger
utils.init_file_logger(processing_directory)
logger = logging.getLogger()
logger.debug('min_plane%s', min_plane)
logger.debug('max_plane %s', max_plane)
logger.debug('keep_planes value %s', plane_keep)
# Start the distributed client
client = Client(n_workers=ncores, threads_per_worker=1)
logger.debug('client %s', client)
logger.debug('check that workers are on the same directory %s',
client.run(os.getcwd))
# Check trail slash
processing_directory = utils.check_trailing_slash(processing_directory,
os_windows)
# Determine the experiment name
exp_name = processing_directory.split(add_slash)[-2]
logger.debug('Experiment name: %s', exp_name)
# Create the directories where to save the output
tmp_dir_path = processing_directory + analysis_name + '_' + exp_name + '_tmp' + add_slash
filtered_dir_path = processing_directory + analysis_name + '_' + exp_name + '_filtered' + add_slash
counting_dir_path = processing_directory + analysis_name + '_' + exp_name + '_counting_pkl' + add_slash
try:
os.stat(tmp_dir_path)
except:
os.mkdir(tmp_dir_path)
os.chmod(tmp_dir_path, 0o777)
try:
os.stat(filtered_dir_path)
except:
os.mkdir(filtered_dir_path)
os.chmod(filtered_dir_path, 0o777)
try:
os.stat(counting_dir_path)
except:
os.mkdir(counting_dir_path)
os.chmod(counting_dir_path, 0o777)
# Get the list of the nd2 files to process inside the directory
files_list = glob.glob(processing_directory + '*.nd2')
logger.debug('files to process %s', files_list)
# Convert the .nd2 data
for raw_data_gene_fname in files_list:
fname = raw_data_gene_fname.split(add_slash)[-1][:-4]
logger.debug('fname %s', fname)
with nd2.Nd2(raw_data_gene_fname) as nd2file:
for channel in nd2file.channels:
for fov in nd2file.fields_of_view:
img_stack = np.empty(
[len(nd2file.z_levels), nd2file.height, nd2file.width],
dtype='uint16')
images = nd2file.select(channels=channel,
fields_of_view=fov,
z_levels=nd2file.z_levels)
for idx, im in enumerate(images):
img_stack[idx, :, :] = im
converted_fname = tmp_dir_path + exp_name + '_' + fname + '_' + channel + '_fov_' + str(
fov) + '.npy'
np.save(converted_fname, img_stack, allow_pickle=False)
logger.debug('Finished .nd2 file conversion')
# Filtering all the data
# Get list of the files to process
flist_img_to_filter = glob.glob(tmp_dir_path + '*.npy')
# logger.debug('files to filter %s',flist_img_to_filter)
# Parallel process all the data
futures_processes=client.map(filtering_and_counting_experiment,flist_img_to_filter, \
filtered_dir_path=filtered_dir_path, \
counting_dir_path=counting_dir_path, \
exp_name=exp_name,plane_keep=plane_keep,add_slash=add_slash, \
min_distance=min_distance, stringency=stringency)
client.gather(futures_processes)
client.close()
logger.debug('Finished filtering and counting')
# delete the tmp folders
shutil.rmtree(tmp_dir_path)
# a=fig.add_subplot(1,3,2)
# imgplot = plt.imshow(dapi_colors)
# a.set_title('dapi')
# a=fig.add_subplot(1,3,3)
# imgplot = plt.imshow(cy3_colors)
# a.set_title('cy3')
# plt.show()
nd2_files = []
for filename in os.listdir(os.getcwd()):
if filename.endswith(".nd2"):
nd2_files.append(filename)
for filename in nd2_files:
well_id = filename.split('_')[1]
compound_img = nd2reader.Nd2(filename)
dapi_to_gfp_distance = []
cy3_to_gfp_distance = []
cy3_to_dapi_distance = []
dapi_to_gfp_pixel_coor = []
cy3_to_gfp_pixel_coor = []
cy3_to_dapi_pixel_coor = []
well_data = {}
well_segmentation = []
for i in range(0, 6, 1):
for img in compound_img.select(fields_of_view=i):
if img.channel == 'FITClong':
gfp = nd2tofloat(img)
elif img.channel == 'DAPI':
dapi = nd2tofloat(img)
elif img.channel == 'CY3':
import nd2reader
import numpy as np
import matplotlib.pyplot as plt
import channel_utils as cu
x=[]
FOV=0
Original_filename ="/Volumes/Samsung_T3/20160630_SJ102_persister_002.nd2"
nd2 = nd2reader.Nd2(Original_filename)
for image in nd2.select(channels='488nm_jt', fields_of_view=(FOV)):
x.append(image)
final=np.sum(x,axis=0)
number_channels,pixels=cu.number_of_channels(final)
print("number of channel sections",number_channels/2)
print(pixels)
print("First located at ",pixels[0],"ending at",pixels[1])
def main(argv):
imagefile = argv[1]
print(imagefile)
nd2 = nd2reader.Nd2(imagefile)
print(nd2)
print(nd2[1])
#!/usr/bin/env python2
import nd2reader
from sys import argv
script, nd2 = argv
nd2 = nd2reader.Nd2(str(nd2))
dapi = []
fitc = []
fitclong = []
cy3 = []
bfcy3 = []
for image in nd2.select(channels='DAPI'):
dapi.append(image)
for image in nd2.select(channels='FITC'):
fitc.append(image)
for image in nd2.select(channels='FITClong'):
fitclong.append(image)
for image in nd2.select(channels='CY3'):
cy3.append(image)
for image in nd2.select(channels='BF-Cy3'):
bfcy3.append(image)
test = cy3[0]
print type(test)
# plt.ylabel("Frequency")
#plt.imshow(matrix2,cmap='jet')
#plt.imshow(test_image3,alpha=0.5)
# print 'cell mean', np.mean(intensity1)
# print 'cell var', np.var(intensity1)
# print 'nuc mean', np.mean(intensity_nuc)
# print 'nuc var', np.var(intensity_nuc)
# print 'nuc/cell', np.mean(intensity_nuc)/np.mean(intensity1)
# plt.show()
#plt.savefig(name.png)
for filename in listdir('PlateImages1/'):
if filename == '.DS_Store':
continue
img1 = nd2reader.Nd2('PlateImages1/' + filename)
test_image1 = img1[4].astype(np.float64) / np.amax(img1[4])
test_image2 = img1[0].astype(np.float64) / np.amax(img1[0])
test_image3 = img1[2].astype(np.float64) / np.amax(img1[2])
matrix = find_cells(test_image1)
matrix2 = segment_image(test_image2, 0.5, 0.5)
intensity = find_intensity_cell(matrix, test_image3)
intensity_nuc = find_intensity_in_nuc(matrix2, test_image3)
sns.distplot(intensity, len(np.unique(intensity)))
sns.distplot(intensity_nuc, len(np.unique(intensity_nuc)))
plt.xlabel("Value")
plt.ylabel("Frequency")
plt.savefig('PlateImages2/' + filename + '.png')
plt.close()
import nd2reader
import Persister_utils as pu
import h5py
import numpy as np
from scipy import signal
#nd2 = nd2reader.Nd2("/Users/Ashley/Desktop/20160728_SDB1_LABPENAB001.nd2")
nd2 = nd2reader.Nd2("/Volumes/Samsung_T3/20160630_SJ102_persister_002.nd2")
print(nd2.channels)
holdall = np.zeros((nd2.height, nd2.width), 'double')
FOV = 1
for image in nd2.select(channels="488nm_jt", fields_of_view=(FOV)):
holdall = holdall + image
line_profile = np.sum(holdall, axis=1)
window = np.diff(signal.gaussian(nd2.height, std=15))
cor_line = np.convolve(line_profile, window, mode='same')
cor_line_fit = cor_line[40:-40]
mean_val = np.mean(cor_line_fit**2)
out = signal.find_peaks_cwt(cor_line_fit**2, np.arange(1, 50))
myarray_out = np.asarray(out)
selected_points = np.where(cor_line_fit[out]**2 > mean_val)
myarray_selected_points = (selected_points)
new_points = (myarray_out[myarray_selected_points])
new_image = nd2[0]
