static autoTextGrid SpeechSynthesizer_and_Sound_and_IntervalTier_align2 (SpeechSynthesizer me, Sound thee, IntervalTier him, long istart, long iend, double silenceThreshold, double minSilenceDuration, double minSoundingDuration, double trimDuration) {
try {
if (istart < 1 || iend < istart || iend > his intervals.size) {
Melder_throw (U"Not avalid interval range.");
}
OrderedOf<structTextGrid> textgrids;
TextInterval tb = his intervals.at [istart];
TextInterval te = his intervals.at [iend];
autoTextGrid result = TextGrid_create (tb -> xmin, te -> xmax, U"sentence clause word phoneme", U"");
for (long iint = istart; iint <= iend; iint ++) {
TextInterval ti = his intervals.at [iint];
if (ti -> text && str32len (ti -> text) > 0) {
autoSound sound = Sound_extractPart (thee, ti -> xmin, ti -> xmax, kSound_windowShape_RECTANGULAR, 1, true);
autoTextGrid grid = SpeechSynthesizer_and_Sound_and_TextInterval_align2 (me, sound.peek(), ti, silenceThreshold, minSilenceDuration, minSoundingDuration, trimDuration);
textgrids. addItem_move (grid.move());
}
}
if (textgrids.size == 0) {
Melder_throw (U"Nothing could be aligned. Was your IntervalTier empty?");
}
autoTextGrid aligned = TextGrids_to_TextGrid_appendContinuous (& textgrids, true);
return aligned;
} catch (MelderError) {
Melder_throw (U"No aligned TextGrid created.");
}
}
static void menu_cb_DrawSelectedSound (TimeSoundEditor me, EDITOR_ARGS_FORM) {
EDITOR_FORM (U"Draw selected sound", nullptr)
my v_form_pictureWindow (cmd);
LABEL (U"", U"Sound:")
BOOLEAN (U"Preserve times", my default_picture_preserveTimes ());
REAL (U"left Vertical range", my default_picture_bottom ());
REAL (U"right Vertical range", my default_picture_top ());
my v_form_pictureMargins (cmd);
BOOLEAN (U"Garnish", my default_picture_garnish ());
EDITOR_OK
my v_ok_pictureWindow (cmd);
SET_INTEGER (U"Preserve times", my pref_picture_preserveTimes ());
SET_REAL (U"left Vertical range", my pref_picture_bottom ());
SET_REAL (U"right Vertical range", my pref_picture_top ());
my v_ok_pictureMargins (cmd);
SET_INTEGER (U"Garnish", my pref_picture_garnish ());
EDITOR_DO
my v_do_pictureWindow (cmd);
my pref_picture_preserveTimes () = GET_INTEGER (U"Preserve times");
my pref_picture_bottom () = GET_REAL (U"left Vertical range");
my pref_picture_top () = GET_REAL (U"right Vertical range");
my v_do_pictureMargins (cmd);
my pref_picture_garnish () = GET_INTEGER (U"Garnish");
if (! my d_longSound.data && ! my d_sound.data)
Melder_throw (U"There is no sound to draw.");
autoSound publish = my d_longSound.data ?
LongSound_extractPart (my d_longSound.data, my d_startSelection, my d_endSelection, my pref_picture_preserveTimes ()) :
Sound_extractPart (my d_sound.data, my d_startSelection, my d_endSelection, kSound_windowShape_RECTANGULAR, 1.0, my pref_picture_preserveTimes ());
Editor_openPraatPicture (me);
Sound_draw (publish.peek(), my pictureGraphics, 0.0, 0.0, my pref_picture_bottom (), my pref_picture_top (),
my pref_picture_garnish (), U"Curve");
Editor_closePraatPicture (me);
EDITOR_END
}
static void menu_cb_Copy (SoundEditor me, EDITOR_ARGS_DIRECT) {
try {
Sound_clipboard = my d_longSound.data ? LongSound_extractPart ((LongSound) my data, my d_startSelection, my d_endSelection, false) :
Sound_extractPart ((Sound) my data, my d_startSelection, my d_endSelection, kSound_windowShape_RECTANGULAR, 1.0, false);
} catch (MelderError) {
Melder_throw (U"Sound selection not copied to clipboard.");
}
}
int SoundEditor::menu_cb_Copy (EDITOR_ARGS) {
SoundEditor *editor = (SoundEditor *)editor_me;
Sound publish = editor->_longSound.data ? LongSound_extractPart ((LongSound) editor->_data, editor->_startSelection, editor->_endSelection, FALSE) :
Sound_extractPart ((Sound) editor->_data, editor->_startSelection, editor->_endSelection, kSound_windowShape_RECTANGULAR, 1.0, FALSE);
iferror return 0;
forget (Sound_clipboard);
Sound_clipboard = publish;
return 1;
}
Ltas PointProcess_Sound_to_Ltas_harmonics (PointProcess pulses, Sound sound,
long maximumHarmonic,
double shortestPeriod, double longestPeriod, double maximumPeriodFactor)
{
try {
long numberOfPeriods = pulses -> nt - 2;
autoLtas ltas = Ltas_create (maximumHarmonic, 1.0);
ltas -> xmax = maximumHarmonic;
if (numberOfPeriods < 1)
Melder_throw ("There are no periods in the point process.");
autoMelderProgress progress (L"LTAS (harmonics) analysis...");
for (long ipulse = 2; ipulse < pulses -> nt; ipulse ++) {
double leftInterval = pulses -> t [ipulse] - pulses -> t [ipulse - 1];
double rightInterval = pulses -> t [ipulse + 1] - pulses -> t [ipulse];
double intervalFactor = leftInterval > rightInterval ? leftInterval / rightInterval : rightInterval / leftInterval;
Melder_progress ((double) ipulse / pulses -> nt, L"Sound & PointProcess: To Ltas: pulse ", Melder_integer (ipulse), L" out of ", Melder_integer (pulses -> nt));
if (leftInterval >= shortestPeriod && leftInterval <= longestPeriod &&
rightInterval >= shortestPeriod && rightInterval <= longestPeriod &&
intervalFactor <= maximumPeriodFactor)
{
/*
* We have a period! Compute the spectrum.
*/
long localMaximumHarmonic;
autoSound period = Sound_extractPart (sound,
pulses -> t [ipulse] - 0.5 * leftInterval, pulses -> t [ipulse] + 0.5 * rightInterval,
kSound_windowShape_RECTANGULAR, 1.0, FALSE);
autoSpectrum spectrum = Sound_to_Spectrum (period.peek(), FALSE);
localMaximumHarmonic = maximumHarmonic < spectrum -> nx ? maximumHarmonic : spectrum -> nx;
for (long iharm = 1; iharm <= localMaximumHarmonic; iharm ++) {
double realPart = spectrum -> z [1] [iharm];
double imaginaryPart = spectrum -> z [2] [iharm];
double energy = (realPart * realPart + imaginaryPart * imaginaryPart) * 2.0 * spectrum -> dx;
ltas -> z [1] [iharm] += energy;
}
} else {
numberOfPeriods -= 1;
}
}
if (numberOfPeriods < 1)
Melder_throw (L"There are no periods in the point process.");
for (long iharm = 1; iharm <= ltas -> nx; iharm ++) {
if (ltas -> z [1] [iharm] == 0.0) {
ltas -> z [1] [iharm] = -300.0;
} else {
double energyInThisBand = ltas -> z [1] [iharm];
double powerInThisBand = energyInThisBand / (sound -> xmax - sound -> xmin);
ltas -> z [1] [iharm] = 10.0 * log10 (powerInThisBand / 4.0e-10);
}
}
return ltas.transfer();
} catch (MelderError) {
Melder_throw (sound, " & ", pulses, ": LTAS analysis (harmonics) not performed.");
}
}
static void do_ExtractSelectedSound (TimeSoundEditor me, bool preserveTimes) {
autoSound extract;
if (my d_endSelection <= my d_startSelection)
Melder_throw (U"No selection.");
if (my d_longSound.data) {
extract = LongSound_extractPart (my d_longSound.data, my d_startSelection, my d_endSelection, preserveTimes);
} else if (my d_sound.data) {
extract = Sound_extractPart (my d_sound.data, my d_startSelection, my d_endSelection, kSound_windowShape_RECTANGULAR, 1.0, preserveTimes);
}
Editor_broadcastPublication (me, extract.transfer());
}
Collection TextGrid_Sound_extractAllIntervals (TextGrid me, Sound sound, long tierNumber, int preserveTimes) {
try {
IntervalTier tier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
autoCollection collection = Collection_create (NULL, tier -> intervals -> size);
for (long iseg = 1; iseg <= tier -> intervals -> size; iseg ++) {
TextInterval segment = (TextInterval) tier -> intervals -> item [iseg];
autoSound interval = Sound_extractPart (sound, segment -> xmin, segment -> xmax, kSound_windowShape_RECTANGULAR, 1.0, preserveTimes);
Thing_setName (interval.peek(), segment -> text ? segment -> text : L"untitled");
Collection_addItem (collection.peek(), interval.transfer());
}
return collection.transfer();
} catch (MelderError) {
Melder_throw (me, " & ", sound, ": intervals not extracted.");
}
}
autoSoundList TextGrid_Sound_extractAllIntervals (TextGrid me, Sound sound, long tierNumber, bool preserveTimes) {
try {
IntervalTier tier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
autoSoundList list = SoundList_create ();
for (long iseg = 1; iseg <= tier -> intervals.size; iseg ++) {
TextInterval segment = tier -> intervals.at [iseg];
autoSound interval = Sound_extractPart (sound, segment -> xmin, segment -> xmax, kSound_windowShape_RECTANGULAR, 1.0, preserveTimes);
Thing_setName (interval.get(), segment -> text ? segment -> text : U"untitled");
list -> addItem_move (interval.move());
}
return list;
} catch (MelderError) {
Melder_throw (me, U" & ", sound, U": intervals not extracted.");
}
}
autoCollection TextGrid_Sound_extractAllIntervals (TextGrid me, Sound sound, long tierNumber, int preserveTimes) {
try {
IntervalTier tier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
autoCollection collection = Collection_create (nullptr, tier -> numberOfIntervals ());
for (long iseg = 1; iseg <= tier -> numberOfIntervals (); iseg ++) {
TextInterval segment = tier -> interval (iseg);
autoSound interval = Sound_extractPart (sound, segment -> xmin, segment -> xmax, kSound_windowShape_RECTANGULAR, 1.0, preserveTimes);
Thing_setName (interval.peek(), segment -> text ? segment -> text : U"untitled");
Collection_addItem_move (collection.peek(), interval.move());
}
return collection;
} catch (MelderError) {
Melder_throw (me, U" & ", sound, U": intervals not extracted.");
}
}
static void menu_cb_Copy (EDITOR_ARGS) {
EDITOR_IAM (SoundEditor);
try {
/*
* Create without change.
*/
autoSound publish = my d_longSound.data ? LongSound_extractPart ((LongSound) my data, my d_startSelection, my d_endSelection, FALSE) :
Sound_extractPart ((Sound) my data, my d_startSelection, my d_endSelection, kSound_windowShape_RECTANGULAR, 1.0, FALSE);
/*
* Change without error.
*/
forget (Sound_clipboard);
Sound_clipboard = publish.transfer();
} catch (MelderError) {
Melder_throw ("Sound selection not copied to clipboard.");
}
}
Collection TextGrid_Sound_extractNonemptyIntervals (TextGrid me, Sound sound, long tierNumber, int preserveTimes) {
try {
IntervalTier tier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
autoCollection collection = Collection_create (NULL, tier -> numberOfIntervals ());
for (long iseg = 1; iseg <= tier -> numberOfIntervals (); iseg ++) {
TextInterval segment = tier -> interval (iseg);
if (segment -> text != NULL && segment -> text [0] != '\0') {
autoSound interval = Sound_extractPart (sound, segment -> xmin, segment -> xmax, kSound_windowShape_RECTANGULAR, 1.0, preserveTimes);
Thing_setName (interval.peek(), segment -> text ? segment -> text : L"untitled");
Collection_addItem (collection.peek(), interval.transfer());
}
}
if (collection -> size == 0) Melder_warning (L"No non-empty intervals were found.");
return collection.transfer();
} catch (MelderError) {
Melder_throw (me, " & ", sound, ": non-empty intervals not extracted.");
}
}
Ltas PointProcess_Sound_to_Ltas (PointProcess pulses, Sound sound,
double maximumFrequency, double bandWidth,
double shortestPeriod, double longestPeriod, double maximumPeriodFactor)
{
Ltas ltas = NULL, numbers = NULL;
Sound period = NULL;
Spectrum spectrum = NULL;
long numberOfPeriods = pulses -> nt - 2, ipulse, ifreq, iband, totalNumberOfEnergies = 0;
ltas = Ltas_create (maximumFrequency / bandWidth, bandWidth); cherror
ltas -> xmax = maximumFrequency;
numbers = (structLtas *)Data_copy (ltas);
if (numberOfPeriods < 1) error1 (L"Cannot compute an Ltas if there are no periods in the point process.")
for (ipulse = 2; ipulse < pulses -> nt; ipulse ++) {
double leftInterval = pulses -> t [ipulse] - pulses -> t [ipulse - 1];
double rightInterval = pulses -> t [ipulse + 1] - pulses -> t [ipulse];
double intervalFactor = leftInterval > rightInterval ? leftInterval / rightInterval : rightInterval / leftInterval;
Melder_progress4 ((double) ipulse / pulses -> nt, L"Sound & PointProcess: To Ltas: pulse ", Melder_integer (ipulse), L" out of ", Melder_integer (pulses -> nt));
if (leftInterval >= shortestPeriod && leftInterval <= longestPeriod &&
rightInterval >= shortestPeriod && rightInterval <= longestPeriod &&
intervalFactor <= maximumPeriodFactor)
{
/*
* We have a period! Compute the spectrum.
*/
period = Sound_extractPart (sound,
pulses -> t [ipulse] - 0.5 * leftInterval, pulses -> t [ipulse] + 0.5 * rightInterval,
kSound_windowShape_RECTANGULAR, 1.0, FALSE); cherror
spectrum = Sound_to_Spectrum (period, FALSE); cherror
for (ifreq = 1; ifreq <= spectrum -> nx; ifreq ++) {
double frequency = spectrum -> xmin + (ifreq - 1) * spectrum -> dx;
double realPart = spectrum -> z [1] [ifreq];
double imaginaryPart = spectrum -> z [2] [ifreq];
double energy = (realPart * realPart + imaginaryPart * imaginaryPart) * 2.0 * spectrum -> dx /* OLD: * sound -> nx */;
iband = ceil (frequency / bandWidth);
if (iband >= 1 && iband <= ltas -> nx) {
ltas -> z [1] [iband] += energy;
numbers -> z [1] [iband] += 1;
totalNumberOfEnergies += 1;
}
}
forget (spectrum);
forget (period);
} else {
autoSoundList TextGrid_Sound_extractIntervalsWhere (TextGrid me, Sound sound, long tierNumber,
int comparison_Melder_STRING, const char32 *text, bool preserveTimes)
{
try {
IntervalTier tier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
autoSoundList list = SoundList_create ();
long count = 0;
for (long iseg = 1; iseg <= tier -> intervals.size; iseg ++) {
TextInterval segment = tier -> intervals.at [iseg];
if (Melder_stringMatchesCriterion (segment -> text, comparison_Melder_STRING, text)) {
autoSound interval = Sound_extractPart (sound, segment -> xmin, segment -> xmax, kSound_windowShape_RECTANGULAR, 1.0, preserveTimes);
Thing_setName (interval.get(), Melder_cat (sound -> name ? sound -> name : U"", U"_", text, U"_", ++ count));
list -> addItem_move (interval.move());
}
}
if (list->size == 0)
Melder_warning (U"No label that ", kMelder_string_getText (comparison_Melder_STRING), U" the text \"", text, U"\" was found.");
return list;
} catch (MelderError) {
Melder_throw (me, U" & ", sound, U": intervals not extracted.");
}
}
static void menu_cb_ExtractSelectedSound_windowed (TimeSoundEditor me, EDITOR_ARGS_FORM) {
EDITOR_FORM (U"Extract selected sound (windowed)", nullptr)
WORD (U"Name", U"slice")
OPTIONMENU_ENUM (U"Window shape", kSound_windowShape, my default_extract_windowShape ())
POSITIVE (U"Relative width", my default_extract_relativeWidth ())
BOOLEAN (U"Preserve times", my default_extract_preserveTimes ())
EDITOR_OK
SET_ENUM (U"Window shape", kSound_windowShape, my pref_extract_windowShape ())
SET_REAL (U"Relative width", my pref_extract_relativeWidth ())
SET_INTEGER (U"Preserve times", my pref_extract_preserveTimes ())
EDITOR_DO
Sound sound = my d_sound.data;
Melder_assert (sound);
my pref_extract_windowShape () = GET_ENUM (kSound_windowShape, U"Window shape");
my pref_extract_relativeWidth () = GET_REAL (U"Relative width");
my pref_extract_preserveTimes () = GET_INTEGER (U"Preserve times");
autoSound extract = Sound_extractPart (sound, my d_startSelection, my d_endSelection, my pref_extract_windowShape (),
my pref_extract_relativeWidth (), my pref_extract_preserveTimes ());
Thing_setName (extract.peek(), GET_STRING (U"Name"));
Editor_broadcastPublication (me, extract.transfer());
EDITOR_END
}
Collection TextGrid_Sound_extractIntervalsWhere (TextGrid me, Sound sound, long tierNumber,
int comparison_Melder_STRING, const wchar_t *text, int preserveTimes)
{
try {
IntervalTier tier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
autoCollection collection = Collection_create (NULL, tier -> intervals -> size);
long count = 0;
for (long iseg = 1; iseg <= tier -> intervals -> size; iseg ++) {
TextInterval segment = (TextInterval) tier -> intervals -> item [iseg];
if (Melder_stringMatchesCriterion (segment -> text, comparison_Melder_STRING, text)) {
autoSound interval = Sound_extractPart (sound, segment -> xmin, segment -> xmax, kSound_windowShape_RECTANGULAR, 1.0, preserveTimes);
wchar_t name [1000];
swprintf (name, 1000, L"%ls_%ls_%ld", sound -> name ? sound -> name : L"", text, ++ count);
Thing_setName (interval.peek(), name);
Collection_addItem (collection.peek(), interval.transfer());
}
}
if (collection -> size == 0)
Melder_warning ("No label that ", kMelder_string_getText (comparison_Melder_STRING), " the text \"", text, "\" was found.");
return collection.transfer();
} catch (MelderError) {
Melder_throw (me, " & ", sound, ": intervals not extracted.");
}
}
void TextGrid_anySound_alignInterval (TextGrid me, Function anySound, long tierNumber, long intervalNumber, const char32 *languageName, bool includeWords, bool includePhonemes) {
try {
IntervalTier headTier = TextGrid_checkSpecifiedTierIsIntervalTier (me, tierNumber);
if (intervalNumber < 1 || intervalNumber > headTier -> intervals.size)
Melder_throw (U"Interval ", intervalNumber, U" does not exist.");
TextInterval interval = headTier -> intervals.at [intervalNumber];
if (! includeWords && ! includePhonemes)
Melder_throw (U"Nothing to be done, because you asked neither for word alignment nor for phoneme alignment.");
if (str32str (headTier -> name, U"/") )
Melder_throw (U"The current tier already has a slash (\"/\") in its name. Cannot create a word or phoneme tier from it.");
autoSound part =
anySound -> classInfo == classLongSound ?
LongSound_extractPart (static_cast <LongSound> (anySound), interval -> xmin, interval -> xmax, true) :
Sound_extractPart (static_cast <Sound> (anySound), interval -> xmin, interval -> xmax, kSound_windowShape_RECTANGULAR, 1.0, true);
autoSpeechSynthesizer synthesizer = SpeechSynthesizer_create (languageName, U"default");
double silenceThreshold = -35, minSilenceDuration = 0.1, minSoundingDuration = 0.1;
autoTextGrid analysis;
if (! Melder_equ (interval -> text, U"")) {
try {
analysis = SpeechSynthesizer_and_Sound_and_TextInterval_align
(synthesizer.get(), part.get(), interval, silenceThreshold, minSilenceDuration, minSoundingDuration);
} catch (MelderError) {
Melder_clearError (); // ignore all error messages from DTW and the like
}
}
if (analysis) {
/*
* Clean up the analysis.
*/
Melder_assert (analysis -> xmin == interval -> xmin);
Melder_assert (analysis -> xmax == interval -> xmax);
Melder_assert (analysis -> tiers->size == 4);
Thing_cast (IntervalTier, analysisWordTier, analysis -> tiers->at [3]);
if (! IntervalTier_check (analysisWordTier))
Melder_throw (U"Analysis word tier out of order.");
IntervalTier_removeEmptyIntervals (analysisWordTier, nullptr);
Melder_assert (analysisWordTier -> xmax == analysis -> xmax);
Melder_assert (analysisWordTier -> intervals.size >= 1);
TextInterval firstInterval = analysisWordTier -> intervals.at [1];
TextInterval lastInterval = analysisWordTier -> intervals.at [analysisWordTier -> intervals.size];
firstInterval -> xmin = analysis -> xmin;
lastInterval -> xmax = analysis -> xmax;
if (lastInterval -> xmax != analysis -> xmax)
Melder_fatal (U"analysis ends at ", analysis -> xmax, U", but last interval at ", lastInterval -> xmax, U" seconds");
if (! IntervalTier_check (analysisWordTier))
Melder_throw (U"Analysis word tier out of order (2).");
Thing_cast (IntervalTier, analysisPhonemeTier, analysis -> tiers->at [4]);
if (! IntervalTier_check (analysisPhonemeTier))
Melder_throw (U"Analysis phoneme tier out of order.");
IntervalTier_removeEmptyIntervals (analysisPhonemeTier, analysisWordTier);
Melder_assert (analysisPhonemeTier -> xmax == analysis -> xmax);
Melder_assert (analysisPhonemeTier -> intervals.size >= 1);
firstInterval = analysisPhonemeTier -> intervals.at [1];
lastInterval = analysisPhonemeTier -> intervals.at [analysisPhonemeTier -> intervals.size];
firstInterval -> xmin = analysis -> xmin;
lastInterval -> xmax = analysis -> xmax;
Melder_assert (lastInterval -> xmax == analysis -> xmax);
if (! IntervalTier_check (analysisPhonemeTier))
Melder_throw (U"Analysis phoneme tier out of order (2).");
}
long wordTierNumber = 0, phonemeTierNumber = 0;
IntervalTier wordTier = nullptr, phonemeTier = nullptr;
/*
* Include a word tier.
*/
if (includeWords) {
/*
* Make sure that the word tier exists.
*/
autoMelderString newWordTierName;
MelderString_copy (& newWordTierName, headTier -> name, U"/word");
for (long itier = 1; itier <= my tiers->size; itier ++) {
IntervalTier tier = static_cast <IntervalTier> (my tiers->at [itier]);
if (Melder_equ (newWordTierName.string, tier -> name)) {
if (tier -> classInfo != classIntervalTier)
Melder_throw (U"A tier with the prospective word tier name (", tier -> name, U") already exists, but it is not an interval tier."
U"\nPlease change its name or remove it.");
wordTierNumber = itier;
break;
}
}
if (! wordTierNumber) {
autoIntervalTier newWordTier = IntervalTier_create (my xmin, my xmax);
Thing_setName (newWordTier.get(), newWordTierName.string);
my tiers -> addItemAtPosition_move (newWordTier.move(), wordTierNumber = tierNumber + 1);
}
Melder_assert (wordTierNumber >= 1 && wordTierNumber <= my tiers->size);
wordTier = static_cast <IntervalTier> (my tiers->at [wordTierNumber]);
/*
* Make sure that the word tier has boundaries at the edges of the interval.
*/
IntervalTier_insertIntervalDestructively (wordTier, interval -> xmin, interval -> xmax);
/*
* Copy the contents of the word analysis into the interval in the word tier.
*/
long wordIntervalNumber = IntervalTier_hasTime (wordTier, interval -> xmin);
Melder_assert (wordIntervalNumber != 0);
if (analysis) {
Thing_cast (IntervalTier, analysisWordTier, analysis -> tiers->at [3]);
if (! IntervalTier_check (analysisWordTier))
Melder_throw (U"Analysis word tier out of order (3).");
if (! IntervalTier_check (wordTier))
Melder_throw (U"Word tier out of order (3).");
for (long ianalysisInterval = 1; ianalysisInterval <= analysisWordTier -> intervals.size; ianalysisInterval ++) {
TextInterval analysisInterval = analysisWordTier -> intervals.at [ianalysisInterval];
TextInterval wordInterval = nullptr;
double tmin = analysisInterval -> xmin, tmax = analysisInterval -> xmax;
if (tmax == analysis -> xmax) {
wordInterval = wordTier -> intervals.at [wordIntervalNumber];
TextInterval_setText (wordInterval, analysisInterval -> text);
} else {
wordInterval = wordTier -> intervals.at [wordIntervalNumber];
autoTextInterval newInterval = TextInterval_create (tmin, tmax, analysisInterval -> text);
wordInterval -> xmin = tmax;
wordTier -> intervals. addItem_move (newInterval.move());
wordIntervalNumber ++;
}
}
if (! IntervalTier_check (analysisWordTier))
Melder_throw (U"Analysis word tier out of order (4).");
if (! IntervalTier_check (wordTier))
Melder_throw (U"Word tier out of order (4).");
}
}
/*
* Include a phoneme tier.
*/
if (includePhonemes) {
/*
* Make sure that the phoneme tier exists.
*/
autoMelderString newPhonemeTierName;
MelderString_copy (& newPhonemeTierName, headTier -> name, U"/phon");
for (long itier = 1; itier <= my tiers->size; itier ++) {
IntervalTier tier = (IntervalTier) my tiers->at [itier];
if (Melder_equ (newPhonemeTierName.string, tier -> name)) {
if (tier -> classInfo != classIntervalTier)
Melder_throw (U"A tier with the prospective phoneme tier name (", tier -> name, U") already exists, but it is not an interval tier."
U"\nPlease change its name or remove it.");
phonemeTierNumber = itier;
break;
}
}
if (! phonemeTierNumber) {
autoIntervalTier newPhonemeTier = IntervalTier_create (my xmin, my xmax);
Thing_setName (newPhonemeTier.get(), newPhonemeTierName.string);
my tiers -> addItemAtPosition_move (newPhonemeTier.move(),
phonemeTierNumber = wordTierNumber ? wordTierNumber + 1 : tierNumber + 1);
}
Melder_assert (phonemeTierNumber >= 1 && phonemeTierNumber <= my tiers->size);
phonemeTier = static_cast <IntervalTier> (my tiers->at [phonemeTierNumber]);
/*
* Make sure that the phoneme tier has boundaries at the edges of the interval.
*/
IntervalTier_insertIntervalDestructively (phonemeTier, interval -> xmin, interval -> xmax);
/*
* Copy the contents of the phoneme analysis into the interval in the phoneme tier.
*/
long phonemeIntervalNumber = IntervalTier_hasTime (phonemeTier, interval -> xmin);
Melder_assert (phonemeIntervalNumber != 0);
if (analysis.get()) {
Thing_cast (IntervalTier, analysisPhonemeTier, analysis -> tiers->at [4]);
for (long ianalysisInterval = 1; ianalysisInterval <= analysisPhonemeTier -> intervals.size; ianalysisInterval ++) {
TextInterval analysisInterval = analysisPhonemeTier -> intervals.at [ianalysisInterval];
TextInterval phonemeInterval = nullptr;
double tmin = analysisInterval -> xmin, tmax = analysisInterval -> xmax;
if (tmax == analysis -> xmax) {
phonemeInterval = phonemeTier -> intervals.at [phonemeIntervalNumber];
TextInterval_setText (phonemeInterval, analysisInterval -> text);
} else {
phonemeInterval = phonemeTier -> intervals.at [phonemeIntervalNumber];
autoTextInterval newInterval = TextInterval_create (tmin, tmax, analysisInterval -> text);
phonemeInterval -> xmin = tmax;
phonemeTier -> intervals. addItem_move (newInterval.move());
phonemeIntervalNumber ++;
}
}
}
if (includeWords) {
/*
* Synchronize the boundaries between the word tier and the phoneme tier.
*/
//for (long iinterval = 1; iinterval <=
}
}
} catch (MelderError) {
Melder_throw (me, U" & ", anySound, U": interval not aligned.");
}
}
Ltas PointProcess_Sound_to_Ltas (PointProcess pulses, Sound sound,
double maximumFrequency, double bandWidth,
double shortestPeriod, double longestPeriod, double maximumPeriodFactor)
{
try {
long numberOfPeriods = pulses -> nt - 2, totalNumberOfEnergies = 0;
autoLtas ltas = Ltas_create (maximumFrequency / bandWidth, bandWidth);
ltas -> xmax = maximumFrequency;
autoLtas numbers = Data_copy (ltas.peek());
if (numberOfPeriods < 1)
Melder_throw ("Cannot compute an Ltas if there are no periods in the point process.");
autoMelderProgress progress (L"Ltas analysis...");
for (long ipulse = 2; ipulse < pulses -> nt; ipulse ++) {
double leftInterval = pulses -> t [ipulse] - pulses -> t [ipulse - 1];
double rightInterval = pulses -> t [ipulse + 1] - pulses -> t [ipulse];
double intervalFactor = leftInterval > rightInterval ? leftInterval / rightInterval : rightInterval / leftInterval;
Melder_progress ((double) ipulse / pulses -> nt, L"Sound & PointProcess: To Ltas: pulse ", Melder_integer (ipulse), L" out of ", Melder_integer (pulses -> nt));
if (leftInterval >= shortestPeriod && leftInterval <= longestPeriod &&
rightInterval >= shortestPeriod && rightInterval <= longestPeriod &&
intervalFactor <= maximumPeriodFactor)
{
/*
* We have a period! Compute the spectrum.
*/
autoSound period = Sound_extractPart (sound,
pulses -> t [ipulse] - 0.5 * leftInterval, pulses -> t [ipulse] + 0.5 * rightInterval,
kSound_windowShape_RECTANGULAR, 1.0, FALSE);
autoSpectrum spectrum = Sound_to_Spectrum (period.peek(), FALSE);
for (long ifreq = 1; ifreq <= spectrum -> nx; ifreq ++) {
double frequency = spectrum -> xmin + (ifreq - 1) * spectrum -> dx;
double realPart = spectrum -> z [1] [ifreq];
double imaginaryPart = spectrum -> z [2] [ifreq];
double energy = (realPart * realPart + imaginaryPart * imaginaryPart) * 2.0 * spectrum -> dx /* OLD: * sound -> nx */;
long iband = ceil (frequency / bandWidth);
if (iband >= 1 && iband <= ltas -> nx) {
ltas -> z [1] [iband] += energy;
numbers -> z [1] [iband] += 1;
totalNumberOfEnergies += 1;
}
}
} else {
numberOfPeriods -= 1;
}
}
if (numberOfPeriods < 1)
Melder_throw ("There are no periods in the point process.");
for (long iband = 1; iband <= ltas -> nx; iband ++) {
if (numbers -> z [1] [iband] == 0.0) {
ltas -> z [1] [iband] = NUMundefined;
} else {
/*
* Each bin now contains a total energy in Pa2 sec.
* To convert this to power density, we
*/
double totalEnergyInThisBand = ltas -> z [1] [iband];
if (0 /* i.e. if you just want to have a spectrum of the voiced parts... */) {
double energyDensityInThisBand = totalEnergyInThisBand / ltas -> dx;
double powerDensityInThisBand = energyDensityInThisBand / (sound -> xmax - sound -> xmin);
ltas -> z [1] [iband] = 10.0 * log10 (powerDensityInThisBand / 4.0e-10);
} else {
/*
* And this is what we really want. The total energy has to be redistributed.
*/
double meanEnergyInThisBand = totalEnergyInThisBand / numbers -> z [1] [iband];
double meanNumberOfEnergiesPerBand = (double) totalNumberOfEnergies / ltas -> nx;
double redistributedEnergyInThisBand = meanEnergyInThisBand * meanNumberOfEnergiesPerBand;
double redistributedEnergyDensityInThisBand = redistributedEnergyInThisBand / ltas -> dx;
double redistributedPowerDensityInThisBand = redistributedEnergyDensityInThisBand / (sound -> xmax - sound -> xmin);
ltas -> z [1] [iband] = 10.0 * log10 (redistributedPowerDensityInThisBand / 4.0e-10);
/* OLD: ltas -> z [1] [iband] = 10.0 * log10 (ltas -> z [1] [iband] / numbers -> z [1] [iband] * sound -> nx);*/
}
}
}
for (long iband = 1; iband <= ltas -> nx; iband ++) {
if (ltas -> z [1] [iband] == NUMundefined) {
long ibandleft = iband - 1, ibandright = iband + 1;
while (ibandleft >= 1 && ltas -> z [1] [ibandleft] == NUMundefined) ibandleft --;
while (ibandright <= ltas -> nx && ltas -> z [1] [ibandright] == NUMundefined) ibandright ++;
if (ibandleft < 1 && ibandright > ltas -> nx)
Melder_throw ("Cannot create an Ltas without energy in any bins.");
if (ibandleft < 1) {
ltas -> z [1] [iband] = ltas -> z [1] [ibandright];
} else if (ibandright > ltas -> nx) {
ltas -> z [1] [iband] = ltas -> z [1] [ibandleft];
} else {
double frequency = ltas -> x1 + (iband - 1) * ltas -> dx;
double fleft = ltas -> x1 + (ibandleft - 1) * ltas -> dx;
double fright = ltas -> x1 + (ibandright - 1) * ltas -> dx;
ltas -> z [1] [iband] = ((fright - frequency) * ltas -> z [1] [ibandleft]
+ (frequency - fleft) * ltas -> z [1] [ibandright]) / (fright - fleft);
}
}
}
return ltas.transfer();
} catch (MelderError) {
Melder_throw (sound, " & ", pulses, ": LTAS analysis not performed.");
}
}
