def test_sampling_rate(self):
# test if error is raise when not giving sample_rate
with self.assertRaises(ValueError):
ImageSequence(self.data, units="V", spatial_scale=1 * pq.um)
with self.assertRaises(TypeError):
ImageSequence(self.data, frame_duration=500, units="V", spatial_scale=1 * pq.um)
# test if error is raise when not giving frequency at sampling rate
with self.assertRaises(TypeError):
ImageSequence(self.data, units="V", sampling_rate=500, spatial_scale=1 * pq.um)
def test_wrong_dimensions(self):
seq = ImageSequence(self.data, sampling_rate=500 * pq.Hz,
units="V", spatial_scale=1 * pq.um)
self.assertEqual(seq.sampling_rate, 500 * pq.Hz)
self.assertEqual(seq.spatial_scale, 1 * pq.um)
# giving wrong dimension test if it give an error
with self.assertRaises(ValueError):
ImageSequence(
[[0, 1, 2, 4, 2], [0, 1, 2, 4, 5]],
sampling_rate=500 * pq.Hz,
units="V",
spatial_scale=1 * pq.um,
)
def test_sampling_rate(self):
# test if error is raise when not giving sample_rate
with self.assertRaises(ValueError):
ImageSequence(self.data, units='V', spatial_scale='m')
with self.assertRaises(TypeError):
ImageSequence(self.data,
sampling_period=500,
units='V',
spatial_scale='m')
# test if error is raise when not giving frequency at sampling rate
with self.assertRaises(TypeError):
ImageSequence(self.data,
units='V',
sampling_rate=500,
spatial_scale='m')
def read_block(self, lazy=False, **kwargs):
# to sort file
def natural_sort(l):
convert = lambda text: int(text) if text.isdigit() else text.lower(
)
alphanum_key = lambda key: [
convert(c) for c in re.split('([0-9]+)', key)
]
return sorted(l, key=alphanum_key)
# find all the images in the given directory
file_name_list = []
# name of extensions to track
types = ["*.tif", "*.tiff"]
for file in types:
file_name_list.append(glob.glob(self.filename + "/" + file))
# flatten list
file_name_list = [
item for sublist in file_name_list for item in sublist
]
# delete path in the name of file
file_name_list = [
file_name[len(self.filename) + 1::] for file_name in file_name_list
]
# sorting file
file_name_list = natural_sort(file_name_list)
list_data_image = []
for file_name in file_name_list:
list_data_image.append(
np.array(Image.open(self.filename + "/" + file_name),
dtype=np.float))
list_data_image = np.array(list_data_image)
if len(list_data_image.shape) == 4:
list_data_image = []
for file_name in file_name_list:
list_data_image.append(
np.array(Image.open(self.filename + "/" +
file_name).convert('L'),
dtype=np.float))
print("read block")
image_sequence = ImageSequence(np.stack(list_data_image),
units=self.units,
sampling_rate=self.sampling_rate,
spatial_scale=self.spatial_scale)
print("creating segment")
segment = Segment(file_origin=self.filename)
segment.annotate(tiff_file_names=file_name_list)
segment.imagesequences = [image_sequence]
block = Block(file_origin=self.filename)
segment.block = block
block.segments.append(segment)
print("returning block")
return block
def test_signal_from_region(self):
self.fake_region_of_interest()
l = ImageSequence(self.data,
units='V',
sampling_rate=500 * pq.Hz,
spatial_scale='m').signal_from_region(self.rect_ROI)
self.assertIsInstance(l, list)
for i in range(len(l)):
self.assertIsInstance(l[i], object)
with self.assertRaises(ValueError): # no pixels in region
ImageSequence(self.data,
units='V',
sampling_rate=500 * pq.Hz,
spatial_scale='m').signal_from_region(
RectangularRegionOfInterest(1, 1, 0, 0))
with self.assertRaises(ValueError):
ImageSequence(self.data,
units='V',
sampling_rate=500 * pq.Hz,
spatial_scale='m').signal_from_region()
def test_t_start(self):
seq = ImageSequence(
self.data,
sampling_rate=500 * pq.Hz,
units="V",
t_start=250 * pq.ms,
spatial_scale=1 * pq.um,
)
self.assertEqual(seq.t_start, 250 * pq.ms)
n_frames = seq.shape[0]
self.assertEqual(seq.duration, n_frames / seq.sampling_rate)
self.assertEqual(seq.t_stop, 290 * pq.ms)
def test_signal_from_region(self):
self.fake_region_of_interest()
seq = ImageSequence(
self.data,
units="V",
sampling_rate=500 * pq.Hz,
t_start=250 * pq.ms,
spatial_scale=1 * pq.um,
)
signals = seq.signal_from_region(self.rect_ROI)
self.assertIsInstance(signals, list)
self.assertEqual(len(signals), 1)
for signal in signals:
self.assertIsInstance(signal, AnalogSignal)
self.assertEqual(signal.t_start, seq.t_start)
self.assertEqual(signal.sampling_period, seq.frame_duration)
with self.assertRaises(ValueError): # no pixels in region
ImageSequence(
self.data, units="V", sampling_rate=500 * pq.Hz, spatial_scale=1 * pq.um
).signal_from_region(RectangularRegionOfInterest(1, 1, 0, 0))
with self.assertRaises(ValueError):
ImageSequence(
self.data, units="V", sampling_rate=500 * pq.Hz, spatial_scale=1 * pq.um
).signal_from_region()
def read_block(self, lazy=False, **kwargs):
file = open(self.filename, 'r')
data = file.read()
print("read block")
liste_value = []
record = []
for i in range(len(data)):
if data[i] == "\n" or data[i] == "\t":
t = "".join(str(e) for e in record)
liste_value.append(t)
record = []
else:
record.append(data[i])
data = []
nb = 0
for i in range(self.nb_frame):
data.append([])
for y in range(self.nb_row):
data[i].append([])
for x in range(self.nb_column):
data[i][y].append(liste_value[nb])
nb += 1
image_sequence = ImageSequence(np.array(data, dtype='float'),
units=self.units,
sampling_rate=self.sampling_rate,
spatial_scale=self.spatial_scale)
file.close()
print("creating segment")
segment = Segment(file_origin=self.filename)
segment.imagesequences = [image_sequence]
block = Block(file_origin=self.filename)
segment.block = block
block.segments.append(segment)
print("returning block")
return block
def read_block(self, lazy=False, **kargs):
def read(name, type, nb, dictionary, file):
if type == 'int32':
# dictionary[name] = int.from_bytes(file.read(4), byteorder=sys.byteorder, signed=True)
dictionary[name] = struct.unpack("i", file.read(4))[0]
if type == 'float32':
dictionary[name] = struct.unpack('f', file.read(4))[0]
if type == 'uint8':
l = []
for i in range(nb):
l.append(chr(struct.unpack('B', file.read(1))[0]))
dictionary[name] = l
if type == 'uint16':
l = []
for i in range(nb):
l.append((struct.unpack('H', file.read(2)))[0])
dictionary[name] = l
if type == 'short':
dictionary[name] = struct.unpack('h', file.read(2))[0]
return dictionary
def read_header(file_name):
file = open(file_name, "rb")
i = [['file_size', 'int32', 1], ['checksum_header', 'int32', 1],
['check_data', 'int32', 1], ['lenheader', 'int32', 1],
['versionid', 'float32', 1], ['filetype', 'int32', 1],
['filesubtype', 'int32', 1], ['datatype', 'int32', 1],
['sizeof', 'int32', 1], ['framewidth', 'int32', 1],
['frameheight', 'int32', 1], ['nframesperstim', 'int32', 1],
['nstimuli', 'int32', 1], ['initialxbinfactor', 'int32', 1],
['initialybinfactor', 'int32', 1], ['xbinfactor', 'int32', 1],
['ybinfactor', 'int32', 1], ['username', 'uint8', 32],
['recordingdate', 'uint8', 16], ['x1roi', 'int32', 1],
['y1roi', 'int32', 1], ['x2roi', 'int32', 1],
['y2roi', 'int32', 1], ['stimoffs', 'int32', 1],
['stimsize', 'int32', 1], ['frameoffs', 'int32', 1],
['framesize', 'int32', 1], ['refoffs', 'int32', 1],
['refsize', 'int32', 1], ['refwidth', 'int32', 1],
['refheight', 'int32', 1], ['whichblocks', 'uint16', 16],
['whichframe', 'uint16', 16], ['loclip', 'int32', 1],
['hiclip', 'int32', 1], ['lopass', 'int32', 1],
['hipass', 'int32', 1], ['operationsperformed', 'uint8', 64],
['magnification', 'float32', 1], ['gain', 'uint16', 1],
['wavelength', 'uint16', 1], ['exposuretime', 'int32', 1],
['nrepetitions', 'int32', 1],
['acquisitiondelay', 'int32', 1],
['interstiminterval', 'int32', 1],
['creationdate', 'uint8', 16], ['datafilename', 'uint8', 64],
['orareserved', 'uint8', 256]]
dic = {}
for x in i:
dic = read(name=x[0],
type=x[1],
nb=x[2],
dictionary=dic,
file=file)
if dic['filesubtype'] == 13:
i = [["includesrefframe", "int32", 1], ["temp", "uint8", 128],
["ntrials", "int32", 1], ["scalefactors", "int32", 1],
["cameragain", "short", 1], ["ampgain", "short", 1],
["samplingrate", "short", 1], ["average", "short", 1],
["exposuretime", "short", 1],
["samplingaverage", "short", 1],
["presentaverage", "short", 1],
["framesperstim", "short", 1],
["trialsperblock", "short", 1],
["sizeofanalogbufferinframes", "short", 1],
["cameratrials", "short", 1], ["filler", "uint8", 106],
["dyedaqreserved", "uint8", 106]]
for x in i:
dic = read(name=x[0],
type=x[1],
nb=x[2],
dictionary=dic,
file=file)
# nottested
# p.listofstimuli=temp(1:max(find(temp~=0)))'; % up to first non-zero stimulus
dic["listofstimuli"] = dic["temp"][0:np.argwhere(
x != 0).max(0)]
else:
i = [["includesrefframe", "int32", 1],
["listofstimuli", "uint8", 256],
["nvideoframesperdataframe", "int32", 1],
["ntrials", "int32", 1], ["scalefactor", "int32", 1],
["meanampgain", "float32",
1], ["meanampdc", "float32", 1],
["vdaqreserved", "uint8", 256]]
for x in i:
dic = read(name=x[0],
type=x[1],
nb=x[2],
dictionary=dic,
file=file)
i = [["user", "uint8", 256], ["comment", "uint8", 256],
["refscalefactor", "int32", 1]]
for x in i:
dic = read(name=x[0],
type=x[1],
nb=x[2],
dictionary=dic,
file=file)
dic["actuallength"] = os.stat(file_name).st_size
file.close()
return dic
# start of the reading process
nblocks = 1
print("reading the header")
header = read_header(self.filename)
nstim = header['nstimuli']
ni = header['framewidth']
nj = header['frameheight']
nfr = header['nframesperstim']
lenh = header['lenheader']
framesize = header['framesize']
filesize = header['file_size']
dtype = header['datatype']
gain = header['meanampgain']
dc = header['meanampdc']
scalefactor = header['scalefactor']
# [["dtype","nbytes","datatype","type_out"],[...]]
l = [[11, 1, "uchar", "uint8", "B"], [12, 2, "ushort", "uint16", "H"],
[13, 4, "ulong", "uint32", "I"], [14, 4, "float", "single", "f"]]
for i in l:
if dtype == i[0]:
nbytes, datatype, type_out, struct_type = i[1], i[2], i[3], i[
4]
if framesize != ni * nj * nbytes:
print(
"BAD HEADER!!! framesize does not match framewidth*frameheight*nbytes!"
)
framesize = ni * nj * nbytes
if (filesize - lenh) > (framesize * nfr * nstim):
nfr2 = nfr + 1
includesrefframe = True
else:
nfr2 = nfr
includesrefframe = False
nbin = nblocks
conds = [i for i in range(1, nstim + 1)]
ncond = len(conds)
data = [[[np.zeros((ni, nj, nfr), type_out)] for x in range(ncond)]
for i in range(nbin)]
for k in range(1, nbin + 1):
print("reading block")
bin = np.arange(math.floor((k - 1 / nbin * nblocks) + 1),
math.floor((k / nbin * nblocks) + 1))
sbin = bin.size
for j in range(1, sbin + 1):
file = open(self.filename, 'rb')
for i in range(1, ncond + 1):
framestart = conds[i - 1] * nfr2 - nfr
offset = framestart * ni * nj * nbytes + lenh
file.seek(offset, 0)
a = [(struct.unpack(struct_type, file.read(nbytes)))[0]
for m in range(ni * nj * nfr)]
a = np.reshape(np.array(a, dtype=type_out, order='F'),
(ni * nj, nfr),
order='F')
a = np.reshape(a, (ni, nj, nfr), order='F')
if includesrefframe:
# not tested
framestart = (conds[i] - 1) * nfr2
offset = framestart * ni * nj * nbytes + lenh
file.seek(offset)
ref = [(struct.unpack(struct_type,
file.read(nbytes)))[0]
for m in range(ni * nj)]
ref = np.array(ref, dtype=type_out)
for y in range(len(ref)):
ref[y] *= scalefactor
ref = np.reshape(ref, (ni, nj))
b = np.tile(ref, [1, 1, nfr])
for y in range(len(a)):
b.append([])
for x in range(len(a[y])):
b[y + 1].append([])
for frame in range(len(a[y][x])):
b[y + 1][x][frame] = (a[y][x][frame] / gain) - \
(scalefactor * dc / gain)
a = b
if sbin == 1:
data[k - 1][i - 1] = a
else:
# not tested
for y in range(len(a)):
for x in range(len(a[y])):
a[y][x] /= sbin
data[k - 1][i - 1] = data[k - 1][i - 1] + a / sbin
file.close()
# data format [block][stim][width][height][frame]]
# data structure should be [block][stim][frame][width][height] in order to be easy to use with neo
# each file is a block
# each stim could be a segment
# then an image sequence [frame][width][height]
# image need to be rotated
# changing order of data for compatibility
# [block][stim][width][height][frame]]
# to
# [block][stim][frame][width][height]
for block in range(len(data)):
for stim in range(len(data[block])):
a = []
for frame in range(header['nframesperstim']):
a.append([])
for width in range(len(data[block][stim])):
a[frame].append([])
for height in range(len(data[block][stim][width])):
a[frame][width].append(
data[block][stim][width][height][frame])
# rotation of data to be the same as thomas deneux screenshot
a[frame] = np.rot90(np.fliplr(a[frame]))
data[block][stim] = a
block = Block(file_origin=self.filename)
for stim in range(len(data[0])):
image_sequence = ImageSequence(data[0][stim],
units=self.units,
sampling_rate=self.sampling_rate,
spatial_scale=self.spatial_scale)
segment = Segment(file_origin=self.filename,
description=("stim nb:" + str(stim)))
segment.imagesequences = [image_sequence]
segment.block = block
for key in header:
block.annotations[key] = header[key]
block.segments.append(segment)
print("returning block")
return block
def test_units(self):
with self.assertRaises(TypeError):
ImageSequence(self.data, sampling_rate=500 * pq.Hz, spatial_scale=1 * pq.um)
def test_error_spatial_scale(self):
# test if error is raise when not giving spatial scale
with self.assertRaises(ValueError):
ImageSequence(self.data, units="V", sampling_rate=500 * pq.Hz)
import quantities as pq
import random
# generate data
l = []
for frame in range(50):
l.append([])
for y in range(100):
l[frame].append([])
for x in range(100):
l[frame][y].append(random.randint(0, 50))
image_seq = ImageSequence(l,
sampling_rate=500 * pq.Hz,
spatial_scale='m',
units='V')
result = image_seq.signal_from_region(
CircularRegionOfInterest(50, 50, 25), CircularRegionOfInterest(10, 10, 5),
PolygonRegionOfInterest((50, 25), (50, 45), (14, 65), (90, 80)))
for i in range(len(result)):
plt.figure()
plt.plot(result[i].times, result[i])
plt.xlabel("seconde")
plt.ylabel("valeur")
plt.show()