def get_nb_formants(formant_file):
"""
get the number of formants of an sdif file
"""
try:
ent = eaSDIF.Entity()
ent.OpenRead(formant_file)
frame = eaSDIF.Frame()
#take the length of the fifth matrix, sometimes the first ones don't have the good number of formants =P
ent.ReadNextSelectedFrame(frame)
ent.ReadNextSelectedFrame(frame)
ent.ReadNextSelectedFrame(frame)
ent.ReadNextSelectedFrame(frame)
ent.ReadNextSelectedFrame(frame)
try:
mat = frame.GetMatrixWithSig("1RES")
except IndexError:
pass
par_mat = mat.GetMatrixData()
return len(par_mat)
except EOFError:
pass
return 0
def FSdifLoadFile(f0file, retrieve_nvts=False):
'''
Load sdif file containing a single frame/matrix type combination wit a matrix type containing
a single row into a list with elements of the form ([times], [np.array(data)])
where the numpy array contains the rows of matrix data and the times are the list of related frame times
'''
file = eaSDIF.Entity()
frame = eaSDIF.Frame()
try:
res = file.OpenRead(f0file)
except RuntimeError as err:
res = False
if res == False:
raise IOError("FSdifLoadFile: " + f0file +
" is not an sdif file or does not exist")
if retrieve_nvts:
NVTs = []
for nvt in xrange(file.GetNbNVT()):
NVT = file.GetNVT(nvt)
#NVTs become invalid when file is closed, so we need to copy the content
NVT_deep_copy = eaSDIF.NameValueTable()
NVT_deep_copy.SetStreamID(NVT.GetStreamID())
for kk in NVT:
NVT_deep_copy.AddNameValue(kk, NVT[kk])
NVTs.append(NVT_deep_copy)
dlist = []
tlist = []
vec = eaSDIF.Vector()
for frame in file:
# print frame to stdout
# frame.Print();
if frame.GetNbMatrix() > 0:
mat = frame.GetMatrix(0)
# $nomat= $frame->GetMatrix(1);
msig = mat.GetSignature()
nrow = mat.GetNbRows()
if nrow > 1:
raise RuntimeError(
'FSdifLoadFile:: cannot read more than a signle row from '
+ fi0file)
ncol = mat.GetNbCols()
if nrow > 0 and ncol > 0:
mat.GetRow(vec, 0)
dlist.append(np.array(vec))
tlist.append(frame.GetTime())
# close file
file.Close()
if retrieve_nvts:
return tlist, dlist, NVTs
return tlist, dlist
def get_formants_info(formant_file):
"""
load formant_file from SDIF file
return an array of panadas data frames with the formants in the sdif file
return: Array of pandas data frames with formants
"""
ts = [] # analysis times
cols_names = ("Frequency", "Amplitude", "Bw", "Saliance")
nb_formants = get_nb_formants(formant_file)
try:
formants = []
for i in range(nb_formants):
formant = DataFrame(columns=cols_names)
formants.append(formant)
ent = eaSDIF.Entity()
ent.OpenRead(formant_file)
frame = eaSDIF.Frame()
ent.ReadNextSelectedFrame(frame)
except EOFError:
print "In get_formants_info first exception"
pass
try:
while ent.ReadNextSelectedFrame(frame):
try:
mat = frame.GetMatrixWithSig("1RES")
except IndexError:
print "Index Error dans get_formants_info in parse_sdif"
# matrix is not present so we continue
continue
frame_time = frame.GetTime()
ts.append(frame_time)
par_mat = mat.GetMatrixData()
if par_mat.shape[1] != 4:
raise RuntimeError("partial data number of columns " +
str(cols) + " unequal to 4 !")
if len(par_mat) == nb_formants:
for i in range(nb_formants):
formants[i] = formants[i].append(
DataFrame([par_mat[i].tolist()],
columns=cols_names,
index=[frame_time]))
except EOFError:
pass
return formants
def get_matrix_values(sdif):
"""
load data from ascii or SDIF file
return time-tagged values and matrix data
return tlist, Matrix_data
This can be used to extract data from lpc or true env .sdif files
"""
inent = eaSDIF.Entity()
res = inent.OpenRead(sdif)
if res == False:
raise RuntimeError("get_lpc:: " + sdif +
" is no sdif file or does not exist")
dlist = []
tlist = []
vec = eaSDIF.Vector()
frame = eaSDIF.Frame()
#fft size
#intypes = inent.GetTypeString() # Very practical line fr printing what is inside
for frame in inent:
has_IGBG = frame.MatrixExists("IGBG")
if has_IGBG:
mat = frame.GetMatrixWithSig("IGBG")
mat.GetRow(vec, 0)
sample_rate = vec[1]
fftsize = vec[3]
fftsize = int(fftsize / 2)
#Extract time tag values
for frame in inent:
mat = frame.GetMatrix(1)
nrow = mat.GetNbRows()
ncol = mat.GetNbCols()
if nrow > 1 and ncol > 0:
tlist.append(frame.GetTime())
#Extract Matrix data values
for frame in inent:
for i in range(0, fftsize + 1):
mat = frame.GetMatrix(1)
nrow = mat.GetNbRows()
ncol = mat.GetNbCols()
if nrow > 1 and ncol >= 0:
mat.GetRow(vec, i)
dlist.append(float(np.array((vec)[0])))
#Convert dlist into a matrix
sample_nb = len(
tlist) - 1 # Because the first value in tlist should be ignored
fftsize_range = fftsize + 1
sample_nb_range = sample_nb + 1
matrix_data = np.zeros((sample_nb_range, fftsize_range))
for row in range(0, sample_nb_range):
for col in range(0, fftsize_range):
matrix_data[row][col] = dlist[row * (fftsize_range) + col]
#when using the flag -OS1 in super vp the amplitude values are in linear, here we transform it to db so the amplitudes are in db
from conversions import lin2db
matrix_data = lin2db(matrix_data)
return tlist, matrix_data
#!/usr/bin/env python
import math
import string
import eaSDIF
import sys
if len(sys.argv) < 2 :
sys.stderr.write( "please provide input and output file name!")
sys.exit()
file = eaSDIF.Entity()
fileout = eaSDIF.Entity()
frame = eaSDIF.Frame();
infile = sys.argv[1]
outfile = sys.argv[2]
#with shadow class:
res = file.OpenRead(infile)
sys.stderr.write( " file.OpenReads(\"%s\")... %d\n" % (infile, res))
#with shadow class:
res = fileout.OpenWrite(outfile)
sys.stderr.write( " file.OpenWrite(\"%s\") ... %d\n" % (outfile ,res))
frameout = eaSDIF.Frame();
matrixout = eaSDIF.Matrix();
# write one matrix with mean at time sigma per type found
matrixout.Init("1TRC", 1, 4, eaSDIF.eFloat4)
frameout.SetHeader("1TRC", 0, 0)
def FSdifStoreFile(filename,
times,
data,
frame_type="1FQ0",
matrix_type="1FQ0",
dtype=np.float,
name_value_dict=None,
NVTs=None):
'''
save sdif file containing a single frame/matrix type combination with a matrix type containing
a single row into a list with elements of the form ([times], [np.array(data)])
where the numpy array contains the rows of matrix data and the times are the list of related frame times
In the case when subsequent data entries have the same frame time those
will be distributed over subsequent stream ids.
'''
esfile = eaSDIF.Entity()
frame = eaSDIF.Frame()
frame.SetSignature(frame_type)
frame.SetStreamID(0)
frame.AddMatrix(eaSDIF.Matrix())
mdat = frame.GetMatrix(0)
easdif_type = eaSDIF.eFloat8
if dtype == np.dtype('f4'):
easdif_type = eaSDIF.eFloat4
elif dtype == np.dtype('i8'):
easdif_type = eaSDIF.eInt8
elif dtype == np.dtype('i4'):
easdif_type = eaSDIF.eInt4
elif dtype == np.dtype('i2'):
easdif_type = eaSDIF.eInt2
elif dtype == np.dtype('i1'):
easdif_type = eaSDIF.eText
elif dtype == np.dtype('u8'):
easdif_type = eaSDIF.eUInt8
elif dtype == np.dtype('u4'):
easdif_type = eaSDIF.eUInt4
elif dtype == np.dtype('u2'):
easdif_type = eaSDIF.eUInt2
elif dtype == np.dtype('u1'):
easdif_type = eaSDIF.eText
mdat.Init(matrix_type, 1, 1, easdif_type)
nvt_stream_id = None
if NVTs != None:
for NVT in NVTs:
if nvt_stream_id == None:
nvt_stream_id = NVT.GetStreamID()
esfile.AddNVT(NVT)
if isinstance(name_value_dict, collections.Iterable):
NVT = eaSDIF.NameValueTable()
if nvt_stream_id:
NVT.SetStreamID(nvt_stream_id)
for kk in name_value_dict:
NVT.AddNameValue(kk, str(name_value_dict[kk]))
esfile.AddNVT(NVT)
res = esfile.OpenWrite(filename)
if res == False:
raise IOError("could not open file {0} for writing".format(filename))
old_currtime = None
stream_id = 0
if (not hasattr(data, 'shape')) or (len(data.shape) > 1):
for (curtime, row) in zip(times, data):
# print frame to stdout
# frame.Print();
frame.SetTime(curtime)
if old_currtime == None or old_currtime != curtime:
stream_id = 0
else:
stream_id += 1
old_currtime = curtime
frame.SetStreamID(stream_id)
if mdat.GetNbCols() != len(row):
mdat.Resize(1, len(row))
mdat.SetRowA(row, 0)
esfile.WriteFrame(frame)
else:
mdat.Resize(1, 1)
for (curtime, val) in zip(times, data):
frame.SetTime(curtime)
if old_currtime == None or old_currtime != curtime:
stream_id = 0
else:
stream_id += 1
old_currtime = curtime
frame.SetStreamID(stream_id)
mdat.Set(0, 0, val)
esfile.WriteFrame(frame)
# close file
esfile.Close()
#!/usr/bin/env python
import math
import string
import eaSDIF
file = eaSDIF.Entity()
print "created new SDIFEntity ", file
frame = eaSDIF.Frame()
print "created new SDIFFrame ", frame
#with shadow class:
res = file.OpenRead(
"/u/formes/roebel/src/EASDIF_SDIF/swig/python/../../test/mrk.sdif")
print "open (mode ", eaSDIF.eReadFile, ")...", res
set = eaSDIF.SelectionSetI()
set.insert(eaSDIF.CreateSignature('1', 'T', 'R', 'C'))
file.RestrictMatrixSelection(set)
count = {}
valfsig = {}
valmsig = {}
valcount = {}
valsum = {}
valssum = {}
while not file.eof():
res = file.ReadNextSelectedFrame(frame)
if res:
fsig = frame.GetSignature()