TextGrid TextGrids_merge (TextGrid me, TextGrid thee) {
try {
int at_end = 0, at_start = 1;
autoTextGrid g1 = Data_copy (me);
autoTextGrid g2 = Data_copy (thee);
// The new TextGrid will have the domain
// [min(g1->xmin, g2->xmin), max(g1->xmax, g2->xmax)]
double extra_time_end = fabs (g2 -> xmax - g1 -> xmax);
double extra_time_start = fabs (g2 -> xmin - g1 -> xmin);
if (g1 -> xmin > g2 -> xmin) {
TextGrid_extendTime (g1.peek(), extra_time_start, at_start);
}
if (g1 -> xmax < g2 -> xmax) {
TextGrid_extendTime (g1.peek(), extra_time_end, at_end);
}
if (g2 -> xmin > g1 -> xmin) {
TextGrid_extendTime (g2.peek(), extra_time_start, at_start);
}
if (g2 -> xmax < g1 -> xmax) {
TextGrid_extendTime (g2.peek(), extra_time_end, at_end);
}
for (long i = 1; i <= g2 -> tiers -> size; i++) {
autoFunction tier = Data_copy ( (Function) g2 -> tiers -> item [i]);
Collection_addItem (g1 -> tiers, tier.transfer());
}
return g1.transfer();
} catch (MelderError) {
Melder_throw (me, " & ", thee, ": not merged.");
}
}
Categories FFNet_Activation_to_Categories (FFNet me, Activation activation, int labeling)
{
Categories thee = NULL, categories = my outputCategories;
long i, (*labelingFunction) (I, const double act[]);
if (! my outputCategories)
{
(void) Melder_error1 (L"FFNet & Activation: To Categories\n");
return Melder_errorp1 (L"The neural net has no Categories (has the FFNet been trained yet?).");
}
if (my nOutputs != activation->nx)
{
(void) Melder_error1 (L"FFNet & Activation: To Categories\n");
return Melder_errorp1 (L"The number of columns in the Activation must equal the number of outputs of FFNet.");
}
thee = Categories_create ();
if (thee == NULL) return NULL;
labelingFunction = labeling == 2 ? stochastic : winnerTakesAll;
for (i = 1; i <= activation->ny; i++)
{
long index = labelingFunction (me, activation->z[i]);
Data item = Data_copy (categories->item[index]);
if (item == NULL || ! Collection_addItem (thee, item))
{
forget (thee);
return Melder_errorp3 (L"FFNet & Activation: To Categories\n\nError creating label ",
Melder_integer (i), L".");
}
}
return thee;
}
void AnyTier_addPoint (I, Daata point) {
iam (AnyTier);
try {
Collection_addItem (my points, point);
} catch (MelderError) {
Melder_throw (me, U": point not added.");
}
}
void RealTier_addPoint (RealTier me, double t, double value) {
try {
autoRealPoint point = RealPoint_create (t, value);
Collection_addItem (my points, point.transfer());
} catch (MelderError) {
Melder_throw (me, U": point not added.");
}
}
int RealTier_addPoint (I, double t, double value) {
iam (RealTier);
RealPoint point = RealPoint_create (t, value); cherror
Collection_addItem (my points, point); cherror
end:
iferror return 0;
return 1;
}
void OrderedOfString_sequentialNumbers (OrderedOfString me, long n) {
Collection_removeAllItems (me);
for (long i = 1; i <= n; i++) {
char32 s[40];
Melder_sprint (s,40, i);
autoSimpleString str = SimpleString_create (s);
Collection_addItem (me, str.transfer());
}
}
void OrderedOfString_sequentialNumbers (I, long n) {
iam (OrderedOfString);
Collection_removeAllItems (me);
for (long i = 1; i <= n; i++) {
wchar_t s[20];
swprintf (s, 20, L"%ld", i);
autoSimpleString str = SimpleString_create (s);
Collection_addItem (me, str.transfer());
}
}
void structGuiOptionMenu:: f_addOption (const wchar_t *text) {
#if gtk
gtk_combo_box_append_text (GTK_COMBO_BOX (d_widget), Melder_peekWcsToUtf8 (text));
#elif motif
GuiMenuItem menuItem = Thing_new (GuiMenuItem);
menuItem -> d_widget = XtVaCreateManagedWidget (Melder_peekWcsToUtf8 (text), xmToggleButtonWidgetClass, d_widget, NULL);
XtAddCallback (menuItem -> d_widget, XmNvalueChangedCallback, cb_optionChanged, (XtPointer) this);
Collection_addItem (d_options, menuItem);
#endif
}
Categories ResultsMFC_to_Categories_responses (ResultsMFC me) {
try {
autoCategories thee = Categories_create ();
for (long trial = 1; trial <= my numberOfTrials; trial ++) {
autoSimpleString category = SimpleString_create (my result [trial]. response);
Collection_addItem (thee.peek(), category.transfer());
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, U": responses not converted to Categories.");
}
}
void TextTier_setLaterEndTime (TextTier me, double xmax, const char32 *mark) {
try {
if (xmax <= my xmax) return; // nothing to be done
if (mark != NULL) {
autoTextPoint textpoint = TextPoint_create (my xmax, mark);
Collection_addItem (my points, textpoint.transfer());
}
my xmax = xmax;
} catch (MelderError) {
Melder_throw (U"Larger end time of TextTier not set.");
}
}
int OrderedOfString_append (OrderedOfString me, char32 *append) {
try {
if (append == nullptr) {
return 1; // BUG: lege string appenden??
}
autoSimpleString item = SimpleString_create (append);
Collection_addItem (me, item.transfer());
return 1;
} catch (MelderError) {
Melder_throw (me, U": text not appended.");
}
}
void Regression_addParameter (Regression me, const char32 *label, double minimum, double maximum, double value) {
try {
autoRegressionParameter thee = Thing_new (RegressionParameter);
thy label = Melder_dup (label);
thy minimum = minimum;
thy maximum = maximum;
thy value = value;
Collection_addItem (my parameters, thee.transfer());
} catch (MelderError) {
Melder_throw (me, U": parameter not added.");
}
}
// Precondition: if (preserveTimes) { my xmax <= thy xmin }
// Postcondition: my xmin preserved
void IntervalTiers_append_inline (IntervalTier me, IntervalTier thee, bool preserveTimes) {
try {
double xmax_previous = my xmax, time_shift = my xmax - thy xmin;
if (preserveTimes && my xmax < thy xmin) {
autoTextInterval connection = TextInterval_create (my xmax, thy xmin, L"");
xmax_previous = thy xmin;
Collection_addItem (my intervals, connection.transfer());
}
for (long iint = 1; iint <= thy intervals -> size; iint++) {
autoTextInterval ti = (TextInterval) Data_copy ((Data) thy intervals -> item[iint]);
if (not preserveTimes) {
ti -> xmin = xmax_previous;
xmax_previous = ti -> xmax += time_shift;
}
Collection_addItem (my intervals, ti.transfer());
}
my xmax = preserveTimes ? thy xmax : xmax_previous;
} catch (MelderError) {
Melder_throw ("IntervalTiers not appended.");
}
}
void TextTier_setEarlierStartTime (TextTier me, double xmin, const char32 *mark) {
try {
if (xmin >= my xmin) return; // nothing to be done
if (mark != NULL) {
autoTextPoint textpoint = TextPoint_create (my xmin, mark);
Collection_addItem (my points, textpoint.transfer());
}
my xmin = xmin;
} catch (MelderError) {
Melder_throw (U"Earlier start time of TextTier not set.");
}
}
CrossCorrelationTables CrossCorrelationTables_and_Diagonalizer_diagonalize (CrossCorrelationTables me, Diagonalizer thee) {
try {
autoCrossCorrelationTables him = CrossCorrelationTables_create ();
for (long i = 1; i <= my size; i++) {
CrossCorrelationTable item = (CrossCorrelationTable) my item[i];
autoCrossCorrelationTable ct = CrossCorrelationTable_and_Diagonalizer_diagonalize (item, thee);
Collection_addItem (him.peek(), ct.transfer());
}
return him.transfer();
} catch (MelderError) {
Melder_throw (U"CrossCorrelationTables not diagonalized.");
}
}
void structScriptEditor :: init (Editor environment, const wchar_t *initialText) {
if (environment != NULL) {
environmentName = Melder_wcsdup (environment -> name);
editorClass = environment -> classInfo;
}
structTextEditor::init (initialText);
interpreter = Interpreter_createFromEnvironment (environment);
if (theScriptEditors == NULL) {
theScriptEditors = Collection_create (NULL, 10);
Collection_dontOwnItems (theScriptEditors);
}
Collection_addItem (theScriptEditors, this);
}
void ScriptEditor_init (ScriptEditor me, Editor environment, const char32 *initialText) {
if (environment != NULL) {
my environmentName = Melder_dup (environment -> name);
my editorClass = environment -> classInfo;
}
TextEditor_init (me, initialText);
my interpreter = Interpreter_createFromEnvironment (environment);
if (theScriptEditors == NULL) {
theScriptEditors = Collection_create (NULL, 10);
Collection_dontOwnItems (theScriptEditors);
}
Collection_addItem (theScriptEditors, me);
}
Collection FFNet_createIrisExample (long numberOfHidden1, long numberOfHidden2)
{
TableOfReal iris = NULL;
Collection c = NULL;
FFNet me = NULL;
Pattern thee = NULL;
Categories him = NULL, uniq = NULL;
long i, j;
MelderString ffnetname = { 0 };
if (! (c = Collection_create (classData, 3)) ||
! (uniq = Categories_sequentialNumbers (3)) ||
! (me = FFNet_create (4, numberOfHidden1, numberOfHidden2, 3, 0)) ||
! FFNet_setOutputCategories (me, uniq) ||
! Collection_addItem (c, me) ||
! (iris = TableOfReal_createIrisDataset ()) ||
! TableOfReal_to_Pattern_and_Categories (iris, 0, 0, 0, 0, &thee, &him) ||
! Collection_addItem (c, thee) ||
! Collection_addItem (c, him)) goto end;
/*
Scale data to interval [0-1]
*/
for (i = 1; i <= 150; i++)
{
for (j = 1; j <= 4; j++) thy z[i][j] /= 10.0;
}
FFNet_createNameFromTopology (me, &ffnetname);
Thing_setName (me, ffnetname.string);
Thing_setName (thee, L"iris");
Thing_setName (him, L"iris");
MelderString_free (&ffnetname);
end:
forget (uniq); forget (iris);
if (! Melder_hasError()) return c;
forget (c);
return NULL;
}
// Precondition: if (preserveTimes) { my xmax <= thy xmin }
void TextTiers_append_inline (TextTier me, TextTier thee, bool preserveTimes) {
try {
for (long iint = 1; iint <= thy points -> size; iint++) {
autoTextPoint tp = (TextPoint) Data_copy ((Daata) thy points -> item[iint]);
if (not preserveTimes) {
tp -> number += my xmax - thy xmin;
}
Collection_addItem (my points, tp.transfer());
}
my xmax = preserveTimes ? thy xmax : my xmax + (thy xmax - thy xmin);
} catch (MelderError) {
Melder_throw (U"TextTiers not appended.");
}
}
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.");
}
}
// Precondition: if (preserveTimes) { my xmax <= thy xmin }
// Postcondition: my xmin preserved
void IntervalTiers_append_inline (IntervalTier me, IntervalTier thee, bool preserveTimes) {
try {
IntervalTier_checkStartAndEndTime (me); // start/end time of first/last interval should match with tier
IntervalTier_checkStartAndEndTime (thee);
double xmax_previous = my xmax, time_shift = my xmax - thy xmin;
if (preserveTimes && my xmax < thy xmin) {
autoTextInterval connection = TextInterval_create (my xmax, thy xmin, U"");
xmax_previous = thy xmin;
Collection_addItem (my intervals, connection.transfer());
}
for (long iint = 1; iint <= thy intervals -> size; iint++) {
autoTextInterval ti = (TextInterval) Data_copy ((Daata) thy intervals -> item[iint]);
if (preserveTimes) {
Collection_addItem (my intervals, ti.transfer());
} else {
/* the interval could be so short that if we test ti -> xmin < ti->xmax it might be true
* but after assigning ti->xmin = xmax_previous and ti->xmax += time_shift the test
* ti -> xmin < ti->xmax might be false!
* We want to make sure xmin and xmax are not register variables and therefore force double64
* by using volatile variables.
*/
volatile double xmin = xmax_previous;
volatile double xmax = ti -> xmax + time_shift;
if (xmin < xmax) {
ti -> xmin = xmin; ti -> xmax = xmax;
Collection_addItem (my intervals, ti.transfer());
xmax_previous = xmax;
}
// else don't include interval
}
}
my xmax = preserveTimes ? thy xmax : xmax_previous;
} catch (MelderError) {
Melder_throw (U"IntervalTiers not appended.");
}
}
void IntervalTier_setEarlierStartTime (IntervalTier me, double xmin, const char32 *mark) {
try {
if (xmin >= my xmin) return; // nothing to be done
TextInterval ti = (TextInterval) my intervals -> item[1];
Melder_assert (xmin < ti -> xmin);
if (mark != NULL) {
autoTextInterval interval = TextInterval_create (xmin, ti -> xmin, mark);
Collection_addItem (my intervals, interval.transfer());
} else {
// extend first interval
ti -> xmin = xmin;
}
my xmin = xmin;
} catch (MelderError) {
Melder_throw (U"Earlier start time of IntervalTier not set.");
}
}
void IntervalTier_setLaterEndTime (IntervalTier me, double xmax, const char32 *mark) {
try {
if (xmax <= my xmax) return; // nothing to be done
TextInterval ti = (TextInterval) my intervals -> item[my intervals -> size];
Melder_assert (xmax > ti -> xmax);
if (mark != NULL) {
autoTextInterval interval = TextInterval_create (ti -> xmax, xmax, mark);
Collection_addItem (my intervals, interval.transfer());
} else {
// extend last interval
ti -> xmax = xmax;
}
my xmax = xmax;
} catch (MelderError) {
Melder_throw (U"Larger end time of IntervalTier not set.");
}
}
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.");
}
}
/*
* Generate n different cct's that have a common diagonalizer.
*/
CrossCorrelationTables CrossCorrelationTables_createTestSet (long dimension, long n, int firstPositiveDefinite, double sigma) {
try {
// Start with a square matrix with random gaussian elements and make its singular value decomposition UDV'
// The V matrix will be the common diagonalizer matrix that we use.
autoNUMmatrix<double> d (1, dimension, 1, dimension);
for (long i = 1; i <= dimension; i++) { // Generate the rotation matrix
for (long j = 1; j <= dimension; j++) {
d[i][j] = NUMrandomGauss (0, 1);
}
}
autoNUMmatrix<double> v (1, dimension, 1, dimension);
autoSVD svd = SVD_create_d (d.peek(), dimension, dimension);
autoCrossCorrelationTables me = CrossCorrelationTables_create ();
for (long i = 1; i <= dimension; i++) {
for (long j = 1; j <= dimension; j++) {
d[i][j] = 0;
}
}
// Start with a diagonal matrix D and calculate V'DV
for (long k = 1; k <= n; k++) {
autoCrossCorrelationTable ct = CrossCorrelationTable_create (dimension);
double low = k == 1 && firstPositiveDefinite ? 0.1 : -1;
for (long i = 1; i <= dimension; i++) {
d[i][i] = NUMrandomUniform (low, 1);
}
for (long i = 1; i <= dimension; i++) {
for (long j = 1; j <= dimension; j++) {
v[i][j] = NUMrandomGauss (svd -> v[i][j], sigma);
}
}
// we need V'DV, however our V has eigenvectors row-wise -> VDV'
NUMdmatrices_multiply_VCVp (ct -> data, v.peek(), dimension, dimension, d.peek(), 1);
Collection_addItem (me.peek(), ct.transfer());
}
return me.transfer();
} catch (MelderError) {
Melder_throw (U"CrossCorrelationTables test set not created.");
}
}
void TextGrid_extendTime (TextGrid me, double extra_time, int position) {
autoTextGrid thee = 0;
try {
double xmax = my xmax, xmin = my xmin;
int at_end = position == 0;
if (extra_time == 0) {
return;
}
extra_time = fabs (extra_time); // Just in case...
thee.reset (Data_copy (me));
if (at_end) {
xmax += extra_time;
} else {
xmin -= extra_time;
}
for (long i = 1; i <= my tiers -> size; i++) {
Function anyTier = (Function) my tiers -> item [i];
double tmin = anyTier -> xmin, tmax = anyTier -> xmax;
if (at_end) {
anyTier -> xmax = xmax;
tmin = tmax;
tmax = xmax;
} else {
anyTier -> xmin = xmin;
tmax = tmin;
tmin = xmin;
}
if (anyTier -> classInfo == classIntervalTier) {
IntervalTier tier = (IntervalTier) anyTier;
autoTextInterval interval = TextInterval_create (tmin, tmax, U"");
Collection_addItem (tier -> intervals, interval.transfer());
}
}
my xmin = xmin;
my xmax = xmax;
} catch (MelderError) {
Melder_throw (me, U": time not extended.");
}
}
FormantTier Formant_downto_FormantTier (Formant me) {
try {
autoFormantTier thee = FormantTier_create (my xmin, my xmax);
for (long i = 1; i <= my nx; i ++) {
Formant_Frame frame = & my d_frames [i];
autoFormantPoint point = FormantPoint_create (Sampled_indexToX (me, i));
point -> numberOfFormants = frame -> nFormants > 10 ? 10 : frame -> nFormants;
for (long j = 1; j <= point -> numberOfFormants; j ++) {
Formant_Formant pair = & frame -> formant [j];
point -> formant [j-1] = pair -> frequency;
point -> bandwidth [j-1] = pair -> bandwidth;
}
Collection_addItem (thy points, point.transfer());
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, ": not converted to FormantTier.");
}
}
static ERPTier EEG_PointProcess_to_ERPTier (EEG me, PointProcess events, double fromTime, double toTime) {
try {
autoERPTier thee = Thing_new (ERPTier);
Function_init (thee.peek(), fromTime, toTime);
thy numberOfChannels = my numberOfChannels - EEG_getNumberOfExtraSensors (me);
Melder_assert (thy numberOfChannels > 0);
thy channelNames = NUMvector <wchar_t *> (1, thy numberOfChannels);
for (long ichan = 1; ichan <= thy numberOfChannels; ichan ++) {
thy channelNames [ichan] = Melder_wcsdup (my channelNames [ichan]);
}
long numberOfEvents = events -> nt;
thy events = SortedSetOfDouble_create ();
double soundDuration = toTime - fromTime;
double samplingPeriod = my sound -> dx;
long numberOfSamples = floor (soundDuration / samplingPeriod) + 1;
if (numberOfSamples < 1)
Melder_throw (L"Time window too short.");
double midTime = 0.5 * (fromTime + toTime);
double soundPhysicalDuration = numberOfSamples * samplingPeriod;
double firstTime = midTime - 0.5 * soundPhysicalDuration + 0.5 * samplingPeriod; // distribute the samples evenly over the time domain
for (long ievent = 1; ievent <= numberOfEvents; ievent ++) {
double eegEventTime = events -> t [ievent];
autoERPPoint event = Thing_new (ERPPoint);
event -> number = eegEventTime;
event -> erp = Sound_create (thy numberOfChannels, fromTime, toTime, numberOfSamples, samplingPeriod, firstTime);
double erpEventTime = 0.0;
double eegSample = 1 + (eegEventTime - my sound -> x1) / samplingPeriod;
double erpSample = 1 + (erpEventTime - firstTime) / samplingPeriod;
long sampleDifference = round (eegSample - erpSample);
for (long ichannel = 1; ichannel <= thy numberOfChannels; ichannel ++) {
for (long isample = 1; isample <= numberOfSamples; isample ++) {
long jsample = isample + sampleDifference;
event -> erp -> z [ichannel] [isample] = jsample < 1 || jsample > my sound -> nx ? 0.0 : my sound -> z [ichannel] [jsample];
}
}
Collection_addItem (thy events, event.transfer());
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, ": ERP analysis not performed.");
}
}
FilesInMemory FilesInMemory_createFromDirectoryContents (const char32 *dirpath, const char32 *fileGlobber) {
try {
structMelderDir parent = { { 0 } };
Melder_pathToDir (dirpath, &parent);
autoStrings thee = Strings_createAsFileList (Melder_cat (dirpath, U"/", fileGlobber));
if (thy numberOfStrings < 1) {
Melder_throw (U"No files found.");
}
autoFilesInMemory me = FilesInMemory_create ();
for (long i = 1; i <= thy numberOfStrings; i++) {
structMelderFile file = { 0 };
MelderDir_getFile (&parent, thy strings[i], &file);
autoFileInMemory fim = FileInMemory_create (&file);
Collection_addItem (me.peek(), fim.transfer());
}
return me.transfer();
} catch (MelderError) {
Melder_throw (U"FilesInMemory not created from directory \"", dirpath, U"\" for files that match \"",
fileGlobber, U"\".");
}
}
StringsIndex Strings_to_StringsIndex (Strings me) {
try {
autoStringsIndex thee = StringsIndex_create (my numberOfStrings);
autoPermutation sorted = Strings_to_Permutation (me, 1);
long numberOfClasses = 0;
char32 *strings = nullptr;
for (long i = 1; i <= sorted -> numberOfElements; i++) {
long index = sorted -> p[i];
char32 *stringsi = my strings[index];
if (i == 1 || Melder_cmp (strings, stringsi) != 0) {
numberOfClasses++;
autoSimpleString him = SimpleString_create (stringsi);
Collection_addItem (thy classes, him.transfer());
strings = stringsi;
}
thy classIndex[index] = numberOfClasses;
}
return thee.transfer();
} catch (MelderError) {
Melder_throw (me, U": no StringsIndex created.");
}
}
