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."); } }