Daata Data_readFromTextFile (MelderFile file) { try { autoMelderReadText text = MelderReadText_createFromFile (file); char32 *line = MelderReadText_readLine (text.peek()); if (! line) Melder_throw (U"No lines."); char32 *end = str32str (line, U"ooTextFile"); // oo format? autoDaata me; int formatVersion; if (end) { autostring32 klas = texgetw2 (text.peek()); me.reset (static_cast <Daata> (Thing_newFromClassName (klas.peek(), & formatVersion))); } else { end = str32str (line, U"TextFile"); if (! end) Melder_throw (U"Not an old-type text file; should not occur."); *end = U'\0'; me.reset (static_cast <Daata> (Thing_newFromClassName (line, nullptr))); formatVersion = -1; // old version } MelderFile_getParentDir (file, & Data_directoryBeingRead); Data_readText (me.peek(), text.peek(), formatVersion); file -> format = structMelderFile :: Format :: text; return me.transfer(); } catch (MelderError) { Melder_throw (U"Data not read from text file ", file, U"."); } }
int Data_Description_evaluateInteger (void *structAddress, Data_Description structDescription, const char32 *formula, long *result) { if (! formula) { // this was a VECTOR_FROM array *result = 1; return 1; } if (formula [0] >= U'a' && formula [0] <= U'z') { char32 buffer [100], *minus1, *psize; Data_Description sizeDescription; str32cpy (buffer, formula); if ((minus1 = str32str (buffer, U" - 1")) != nullptr) *minus1 = U'\0'; // strip trailing " - 1", but remember if ((psize = str32str (buffer, U" -> size")) != nullptr) *psize = U'\0'; // strip trailing " -> size" if (! (sizeDescription = Data_Description_findMatch (structDescription, buffer))) { *result = 0; return 0 /*Melder_error ("Cannot find member \"%ls\".", buffer)*/; } *result = Data_Description_integer (structAddress, sizeDescription); if (minus1) *result -= 1; } else { *result = Melder_atoi (formula); } return 1; }
static void do_find (TextEditor me) { if (! theFindString) return; // e.g. when the user does "Find again" before having done any "Find" long left, right; autostring32 text = GuiText_getStringAndSelectionPosition (my textWidget, & left, & right); char32 *location = str32str (& text [right], theFindString); if (location) { long index = location - text.peek(); GuiText_setSelection (my textWidget, index, index + str32len (theFindString)); GuiText_scrollToSelection (my textWidget); #ifdef _WIN32 GuiThing_show (my d_windowForm); #endif } else { /* Try from the start of the document. */ location = str32str (text.peek(), theFindString); if (location) { long index = location - text.peek(); GuiText_setSelection (my textWidget, index, index + str32len (theFindString)); GuiText_scrollToSelection (my textWidget); #ifdef _WIN32 GuiThing_show (my d_windowForm); #endif } else { Melder_beep (); } } }
bool Melder_stringMatchesCriterion (const char32 *value, int which_kMelder_string, const char32 *criterion) { if (! value) { value = U""; // regard null strings as empty strings, as is usual in Praat } if (! criterion) { criterion = U""; // regard null strings as empty strings, as is usual in Praat } if (which_kMelder_string <= kMelder_string_NOT_EQUAL_TO) { bool matchPositiveCriterion = str32equ (value, criterion); return ( which_kMelder_string == kMelder_string_EQUAL_TO ) == matchPositiveCriterion; } if (which_kMelder_string <= kMelder_string_DOES_NOT_CONTAIN) { bool matchPositiveCriterion = !! str32str (value, criterion); return ( which_kMelder_string == kMelder_string_CONTAINS ) == matchPositiveCriterion; } if (which_kMelder_string <= kMelder_string_DOES_NOT_START_WITH) { bool matchPositiveCriterion = str32nequ (value, criterion, str32len (criterion)); return ( which_kMelder_string == kMelder_string_STARTS_WITH ) == matchPositiveCriterion; } if (which_kMelder_string <= kMelder_string_DOES_NOT_END_WITH) { int criterionLength = str32len (criterion), valueLength = str32len (value); bool matchPositiveCriterion = ( criterionLength <= valueLength && str32equ (value + valueLength - criterionLength, criterion) ); return (which_kMelder_string == kMelder_string_ENDS_WITH) == matchPositiveCriterion; } if (which_kMelder_string == kMelder_string_MATCH_REGEXP) { char32 *place = nullptr; regexp *compiled_regexp = CompileRE_throwable (criterion, 0); if (ExecRE (compiled_regexp, nullptr, value, nullptr, 0, '\0', '\0', nullptr, nullptr, nullptr)) place = compiled_regexp -> startp [0]; free (compiled_regexp); return !! place; } return false; // should not occur }
void RealTier_draw (RealTier me, Graphics g, double tmin, double tmax, double fmin, double fmax, int garnish, const char32 *method, const char32 *quantity) { bool drawLines = str32str (method, U"lines") || str32str (method, U"Lines"); bool drawSpeckles = str32str (method, U"speckles") || str32str (method, U"Speckles"); long n = my points.size, imin, imax, i; if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; } Graphics_setWindow (g, tmin, tmax, fmin, fmax); Graphics_setInner (g); imin = AnyTier_timeToHighIndex (me->asAnyTier(), tmin); imax = AnyTier_timeToLowIndex (me->asAnyTier(), tmax); if (n == 0) { } else if (imax < imin) { double fleft = RealTier_getValueAtTime (me, tmin); double fright = RealTier_getValueAtTime (me, tmax); if (drawLines) Graphics_line (g, tmin, fleft, tmax, fright); } else for (i = imin; i <= imax; i ++) { RealPoint point = my points.at [i]; double t = point -> number, f = point -> value; if (drawSpeckles) Graphics_speckle (g, t, f); if (drawLines) { if (i == 1) Graphics_line (g, tmin, f, t, f); else if (i == imin) Graphics_line (g, t, f, tmin, RealTier_getValueAtTime (me, tmin)); if (i == n) Graphics_line (g, t, f, tmax, f); else if (i == imax) Graphics_line (g, t, f, tmax, RealTier_getValueAtTime (me, tmax)); else { RealPoint pointRight = my points.at [i + 1]; Graphics_line (g, t, f, pointRight -> number, pointRight -> value); } } } Graphics_unsetInner (g); if (garnish) { Graphics_drawInnerBox (g); Graphics_textBottom (g, true, my v_getUnitText (0, 0, 0)); Graphics_marksBottom (g, 2, true, true, false); Graphics_marksLeft (g, 2, true, true, false); if (quantity) Graphics_textLeft (g, true, quantity); } }
void OrderedOfString_removeOccurrences (OrderedOfString me, const char32 *search, int use_regexp) { if (! search) { return; } for (long i = my size; i >= 1; i--) { SimpleString ss = (SimpleString) my item[i]; if ( (use_regexp && strstr_regexp (ss -> string, search)) || (!use_regexp && str32str (ss -> string, search))) { Collection_removeItem (me, i); } } }
static double searchToken (ManPages me, long ipage, char32 *token) { double goodness = 0.0; ManPage page = my pages.at [ipage]; struct structManPage_Paragraph *par = & page -> paragraphs [0]; if (! token [0]) return 1.0; /* * Try to find a match in the title, case insensitively. */ static MelderString buffer { 0 }; MelderString_copy (& buffer, page -> title); for (char32 *p = & buffer.string [0]; *p != U'\0'; p ++) *p = towlower ((int) *p); if (str32str (buffer.string, token)) { goodness += 300.0; // lots of points for a match in the title! if (str32equ (buffer.string, token)) goodness += 10000.0; // even more points for an exact match! } /* * Try to find a match in the paragraphs, case-insensitively. */ while (par -> type) { if (par -> text) { char32 *ptoken; MelderString_copy (& buffer, par -> text); for (char32 *p = & buffer.string [0]; *p != '\0'; p ++) *p = towlower ((int) *p); ptoken = str32str (buffer.string, token); if (ptoken) { goodness += 10.0; // ten points for every paragraph with a match! if (str32str (ptoken + str32len (token), token)) { goodness += 1.0; // one point for every second occurrence in a paragraph! } } } par ++; } return goodness; }
bool SpellingChecker_isWordAllowed (SpellingChecker me, const char32 *word) { int wordLength = str32len (word); if (my allowAllWordsContaining && my allowAllWordsContaining [0]) { char32 *p = & my allowAllWordsContaining [0]; while (*p) { /* * Find next token in list of allowed string parts. */ char32 token [100], *q = & token [0]; /* * Skip spaces in list. */ while (*p == U' ') p ++; /* * Collect one token string from list. */ while (*p != U'\0' && *p != U' ') { *q ++ = *p ++; } *q = U'\0'; // trailing null character /* * Allow word if it contains this token. */ if (str32str (word, token)) return true; } } if (my allowAllNames) { /* * Allow word if it starts with a capital. */ if (startsWithCapital (word)) { return true; } if (my namePrefixes && my namePrefixes [0]) { char32 *p = & my namePrefixes [0]; while (*p) { char32 token [100], *q = & token [0]; while (*p == U' ') p ++; while (*p != U'\0' && *p != U' ') *q ++ = *p ++; *q = U'\0'; // trailing null character /* * Allow word if starts with this prefix * and this prefix is followed by a capital. */ if (str32str (word, token) == word && startsWithCapital (word + str32len (token))) { return true; } } } } else if (my allowAllAbbreviations && startsWithCapital (word)) { const char32 *p = & word [0]; for (;;) { if (*p == '\0') return true; if (iswlower ((int) *p)) break; p ++; } } if (my allowAllWordsStartingWith && my allowAllWordsStartingWith [0]) { char32 *p = & my allowAllWordsStartingWith [0]; while (*p) { char32 token [100], *q = & token [0]; int tokenLength; while (*p == U' ') p ++; while (*p != U'\0' && *p != U' ') *q ++ = *p ++; *q = U'\0'; // trailing null character tokenLength = str32len (token); if (wordLength >= tokenLength && str32nequ (token, word, tokenLength)) { return true; } } } if (my allowAllWordsEndingIn && my allowAllWordsEndingIn [0]) { char32 *p = & my allowAllWordsEndingIn [0]; while (*p) { char32 token [100], *q = & token [0]; int tokenLength; while (*p == U' ') p ++; while (*p != U'\0' && *p != U' ') *q ++ = *p ++; *q = U'\0'; // trailing null character tokenLength = str32len (token); if (wordLength >= tokenLength && str32nequ (token, word + wordLength - tokenLength, tokenLength)) { return true; } } } if (WordList_hasWord (my wordList, word)) return true; if (my userDictionary != NULL) { if (str32len (word) > 3333) return false; // superfluous, because WordList_hasWord already checked; but safe static char32 buffer [3*3333+1]; Longchar_genericize32 (word, buffer); if (SortedSetOfString_lookUp (my userDictionary, buffer) != 0) return true; } return false; }
void Vector_draw (Vector me, Graphics g, double *pxmin, double *pxmax, double *pymin, double *pymax, double defaultDy, const char32 *method) { bool xreversed = *pxmin > *pxmax, yreversed = *pymin > *pymax; if (xreversed) { double temp = *pxmin; *pxmin = *pxmax; *pxmax = temp; } if (yreversed) { double temp = *pymin; *pymin = *pymax; *pymax = temp; } long ixmin, ixmax, ix; /* * Automatic domain. */ if (*pxmin == *pxmax) { *pxmin = my xmin; *pxmax = my xmax; } /* * Domain expressed in sample numbers. */ Matrix_getWindowSamplesX (me, *pxmin, *pxmax, & ixmin, & ixmax); /* * Automatic vertical range. */ if (*pymin == *pymax) { Matrix_getWindowExtrema (me, ixmin, ixmax, 1, 1, pymin, pymax); if (*pymin == *pymax) { *pymin -= defaultDy; *pymax += defaultDy; } } /* * Set coordinates for drawing. */ Graphics_setInner (g); Graphics_setWindow (g, xreversed ? *pxmax : *pxmin, xreversed ? *pxmin : *pxmax, yreversed ? *pymax : *pymin, yreversed ? *pymin : *pymax); if (str32str (method, U"bars") || str32str (method, U"Bars")) { for (ix = ixmin; ix <= ixmax; ix ++) { double x = Sampled_indexToX (me, ix); double y = my z [1] [ix]; double left = x - 0.5 * my dx, right = x + 0.5 * my dx; if (y > *pymax) y = *pymax; if (left < *pxmin) left = *pxmin; if (right > *pxmax) right = *pxmax; if (y > *pymin) { Graphics_line (g, left, y, right, y); Graphics_line (g, left, y, left, *pymin); Graphics_line (g, right, y, right, *pymin); } } } else if (str32str (method, U"poles") || str32str (method, U"Poles")) { for (ix = ixmin; ix <= ixmax; ix ++) { double x = Sampled_indexToX (me, ix); Graphics_line (g, x, 0, x, my z [1] [ix]); } } else if (str32str (method, U"speckles") || str32str (method, U"Speckles")) { for (ix = ixmin; ix <= ixmax; ix ++) { double x = Sampled_indexToX (me, ix); Graphics_speckle (g, x, my z [1] [ix]); } } else { /* * The default: draw as a curve. */ Graphics_function (g, my z [1], ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax)); } Graphics_unsetInner (g); }
char32 *str_replace_literal (const char32 *string, const char32 *search, const char32 *replace, long maximumNumberOfReplaces, long *nmatches) { if (string == 0 || search == 0 || replace == 0) { return NULL; } int len_string = str32len (string); if (len_string == 0) { maximumNumberOfReplaces = 1; } int len_search = str32len (search); if (len_search == 0) { maximumNumberOfReplaces = 1; } /* To allocate memory for 'result' only once, we have to know how many matches will occur. */ const char32 *pos = string; //current position / start of current match *nmatches = 0; if (maximumNumberOfReplaces <= 0) { maximumNumberOfReplaces = LONG_MAX; } if (len_search == 0) { /* Search is empty string... */ if (len_string == 0) { *nmatches = 1; /* ...only matches empty string */ } } else { if (len_string != 0) { /* Because empty string always matches */ while ( (pos = str32str (pos, search)) && *nmatches < maximumNumberOfReplaces) { pos += len_search; (*nmatches) ++; } } } int64 len_replace = str32len (replace); int64 len_result = len_string + *nmatches * (len_replace - len_search); char32 *result = Melder_malloc (char32, (len_result + 1) * (int64) sizeof (char32)); result[len_result] = '\0'; const char32 *posp = pos = string; int nchar = 0, result_nchar = 0; for (long i = 1; i <= *nmatches; i++) { pos = str32str (pos, search); /* Copy gap between end of previous match and start of current. */ nchar = (pos - posp); if (nchar > 0) { str32ncpy (result + result_nchar, posp, nchar); result_nchar += nchar; } /* Insert the replace string in result. */ str32ncpy (result + result_nchar, replace, len_replace); result_nchar += len_replace; /* Next search starts after the match. */ pos += len_search; posp = pos; } /* Copy gap between end of match and end of string. */ pos = string + len_string; nchar = pos - posp; if (nchar > 0) { str32ncpy (result + result_nchar, posp, nchar); } return result; }
void TimeSoundEditor_drawSound (TimeSoundEditor me, double globalMinimum, double globalMaximum) { Sound sound = my d_sound.data; LongSound longSound = my d_longSound.data; Melder_assert (!! sound != !! longSound); int nchan = sound ? sound -> ny : longSound -> numberOfChannels; bool cursorVisible = my d_startSelection == my d_endSelection && my d_startSelection >= my d_startWindow && my d_startSelection <= my d_endWindow; Graphics_setColour (my d_graphics, Graphics_BLACK); bool fits; try { fits = sound ? true : LongSound_haveWindow (longSound, my d_startWindow, my d_endWindow); } catch (MelderError) { bool outOfMemory = !! str32str (Melder_getError (), U"memory"); if (Melder_debug == 9) Melder_flushError (); else Melder_clearError (); Graphics_setWindow (my d_graphics, 0.0, 1.0, 0.0, 1.0); Graphics_setTextAlignment (my d_graphics, Graphics_CENTRE, Graphics_HALF); Graphics_text (my d_graphics, 0.5, 0.5, outOfMemory ? U"(out of memory)" : U"(cannot read sound file)"); return; } if (! fits) { Graphics_setWindow (my d_graphics, 0.0, 1.0, 0.0, 1.0); Graphics_setTextAlignment (my d_graphics, Graphics_CENTRE, Graphics_HALF); Graphics_text (my d_graphics, 0.5, 0.5, U"(window too large; zoom in to see the data)"); return; } long first, last; if (Sampled_getWindowSamples (sound ? (Sampled) sound : (Sampled) longSound, my d_startWindow, my d_endWindow, & first, & last) <= 1) { Graphics_setWindow (my d_graphics, 0.0, 1.0, 0.0, 1.0); Graphics_setTextAlignment (my d_graphics, Graphics_CENTRE, Graphics_HALF); Graphics_text (my d_graphics, 0.5, 0.5, U"(zoom out to see the data)"); return; } const int numberOfVisibleChannels = nchan > 8 ? 8 : nchan; const int firstVisibleChannel = my d_sound.channelOffset + 1; int lastVisibleChannel = my d_sound.channelOffset + numberOfVisibleChannels; if (lastVisibleChannel > nchan) lastVisibleChannel = nchan; double maximumExtent = 0.0, visibleMinimum = 0.0, visibleMaximum = 0.0; if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW) { if (longSound) LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, firstVisibleChannel, & visibleMinimum, & visibleMaximum); else Matrix_getWindowExtrema (sound, first, last, firstVisibleChannel, firstVisibleChannel, & visibleMinimum, & visibleMaximum); for (int ichan = firstVisibleChannel + 1; ichan <= lastVisibleChannel; ichan ++) { double visibleChannelMinimum, visibleChannelMaximum; if (longSound) LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, ichan, & visibleChannelMinimum, & visibleChannelMaximum); else Matrix_getWindowExtrema (sound, first, last, ichan, ichan, & visibleChannelMinimum, & visibleChannelMaximum); if (visibleChannelMinimum < visibleMinimum) visibleMinimum = visibleChannelMinimum; if (visibleChannelMaximum > visibleMaximum) visibleMaximum = visibleChannelMaximum; } maximumExtent = visibleMaximum - visibleMinimum; } for (int ichan = firstVisibleChannel; ichan <= lastVisibleChannel; ichan ++) { double cursorFunctionValue = longSound ? 0.0 : Vector_getValueAtX (sound, 0.5 * (my d_startSelection + my d_endSelection), ichan, 70); /* * BUG: this will only work for mono or stereo, until Graphics_function16 handles quadro. */ double ymin = (double) (numberOfVisibleChannels - ichan + my d_sound.channelOffset) / numberOfVisibleChannels; double ymax = (double) (numberOfVisibleChannels + 1 - ichan + my d_sound.channelOffset) / numberOfVisibleChannels; Graphics_Viewport vp = Graphics_insetViewport (my d_graphics, 0, 1, ymin, ymax); bool horizontal = false; double minimum = sound ? globalMinimum : -1.0, maximum = sound ? globalMaximum : 1.0; if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW) { if (nchan > 2) { if (longSound) { LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, ichan, & minimum, & maximum); } else { Matrix_getWindowExtrema (sound, first, last, ichan, ichan, & minimum, & maximum); } if (maximumExtent > 0.0) { double middle = 0.5 * (minimum + maximum); minimum = middle - 0.5 * maximumExtent; maximum = middle + 0.5 * maximumExtent; } } else { minimum = visibleMinimum; maximum = visibleMaximum; } } else if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW_AND_CHANNEL) { if (longSound) { LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, ichan, & minimum, & maximum); } else { Matrix_getWindowExtrema (sound, first, last, ichan, ichan, & minimum, & maximum); } } else if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_FIXED_HEIGHT) { if (longSound) { LongSound_getWindowExtrema (longSound, my d_startWindow, my d_endWindow, ichan, & minimum, & maximum); } else { Matrix_getWindowExtrema (sound, first, last, ichan, ichan, & minimum, & maximum); } double channelExtent = my p_sound_scaling_height; double middle = 0.5 * (minimum + maximum); minimum = middle - 0.5 * channelExtent; maximum = middle + 0.5 * channelExtent; } else if (my p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_FIXED_RANGE) { minimum = my p_sound_scaling_minimum; maximum = my p_sound_scaling_maximum; } if (minimum == maximum) { horizontal = true; minimum -= 1.0; maximum += 1.0;} Graphics_setWindow (my d_graphics, my d_startWindow, my d_endWindow, minimum, maximum); if (horizontal) { Graphics_setTextAlignment (my d_graphics, Graphics_RIGHT, Graphics_HALF); double mid = 0.5 * (minimum + maximum); Graphics_text (my d_graphics, my d_startWindow, mid, Melder_float (Melder_half (mid))); } else { if (! cursorVisible || ! NUMdefined (cursorFunctionValue) || Graphics_dyWCtoMM (my d_graphics, cursorFunctionValue - minimum) > 5.0) { Graphics_setTextAlignment (my d_graphics, Graphics_RIGHT, Graphics_BOTTOM); Graphics_text (my d_graphics, my d_startWindow, minimum, Melder_float (Melder_half (minimum))); } if (! cursorVisible || ! NUMdefined (cursorFunctionValue) || Graphics_dyWCtoMM (my d_graphics, maximum - cursorFunctionValue) > 5.0) { Graphics_setTextAlignment (my d_graphics, Graphics_RIGHT, Graphics_TOP); Graphics_text (my d_graphics, my d_startWindow, maximum, Melder_float (Melder_half (maximum))); } } if (minimum < 0 && maximum > 0 && ! horizontal) { Graphics_setWindow (my d_graphics, 0, 1, minimum, maximum); if (! cursorVisible || ! NUMdefined (cursorFunctionValue) || fabs (Graphics_dyWCtoMM (my d_graphics, cursorFunctionValue - 0.0)) > 3.0) { Graphics_setTextAlignment (my d_graphics, Graphics_RIGHT, Graphics_HALF); Graphics_text (my d_graphics, 0, 0, U"0"); } Graphics_setColour (my d_graphics, Graphics_CYAN); Graphics_setLineType (my d_graphics, Graphics_DOTTED); Graphics_line (my d_graphics, 0, 0, 1, 0); Graphics_setLineType (my d_graphics, Graphics_DRAWN); } /* * Garnish the drawing area of each channel. */ Graphics_setWindow (my d_graphics, 0, 1, 0, 1); Graphics_setColour (my d_graphics, Graphics_CYAN); Graphics_innerRectangle (my d_graphics, 0, 1, 0, 1); Graphics_setColour (my d_graphics, Graphics_BLACK); if (nchan > 1) { Graphics_setTextAlignment (my d_graphics, Graphics_LEFT, Graphics_HALF); const char32 *channelName = my v_getChannelName (ichan); static MelderString channelLabel; MelderString_copy (& channelLabel, ( channelName ? U"ch" : U"Channel " ), ichan); if (channelName) MelderString_append (& channelLabel, U": ", channelName); if (ichan > 8 && ichan - my d_sound.channelOffset == 1) { MelderString_append (& channelLabel, U" " UNITEXT_UPWARDS_ARROW); } else if (ichan >= 8 && ichan - my d_sound.channelOffset == 8 && ichan < nchan) { MelderString_append (& channelLabel, U" " UNITEXT_DOWNWARDS_ARROW); } Graphics_text (my d_graphics, 1, 0.5, channelLabel.string); } /* * Draw a very thin separator line underneath. */ if (ichan < nchan) { /*Graphics_setColour (d_graphics, Graphics_BLACK);*/ Graphics_line (my d_graphics, 0, 0, 1, 0); } /* * Draw the samples. */ /*if (ichan == 1) FunctionEditor_SoundAnalysis_drawPulses (this);*/ if (sound) { Graphics_setWindow (my d_graphics, my d_startWindow, my d_endWindow, minimum, maximum); if (cursorVisible && NUMdefined (cursorFunctionValue)) FunctionEditor_drawCursorFunctionValue (me, cursorFunctionValue, Melder_float (Melder_half (cursorFunctionValue)), U""); Graphics_setColour (my d_graphics, Graphics_BLACK); Graphics_function (my d_graphics, sound -> z [ichan], first, last, Sampled_indexToX (sound, first), Sampled_indexToX (sound, last)); } else { Graphics_setWindow (my d_graphics, my d_startWindow, my d_endWindow, minimum * 32768, maximum * 32768); Graphics_function16 (my d_graphics, longSound -> buffer - longSound -> imin * nchan + (ichan - 1), nchan - 1, first, last, Sampled_indexToX (longSound, first), Sampled_indexToX (longSound, last)); } Graphics_resetViewport (my d_graphics, vp); } Graphics_setWindow (my d_graphics, 0.0, 1.0, 0.0, 1.0); Graphics_rectangle (my d_graphics, 0.0, 1.0, 0.0, 1.0); }
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."); } }
void Sound_draw (Sound me, Graphics g, double tmin, double tmax, double minimum, double maximum, bool garnish, const char32 *method) { long ixmin, ixmax; bool treversed = tmin > tmax; if (treversed) { double temp = tmin; tmin = tmax; tmax = temp; } /* * Automatic domain. */ if (tmin == tmax) { tmin = my xmin; tmax = my xmax; } /* * Domain expressed in sample numbers. */ Matrix_getWindowSamplesX (me, tmin, tmax, & ixmin, & ixmax); /* * Automatic vertical range. */ if (minimum == maximum) { Matrix_getWindowExtrema (me, ixmin, ixmax, 1, my ny, & minimum, & maximum); if (minimum == maximum) { minimum -= 1.0; maximum += 1.0; } } /* * Set coordinates for drawing. */ Graphics_setInner (g); for (long channel = 1; channel <= my ny; channel ++) { Graphics_setWindow (g, treversed ? tmax : tmin, treversed ? tmin : tmax, minimum - (my ny - channel) * (maximum - minimum), maximum + (channel - 1) * (maximum - minimum)); if (str32str (method, U"bars") || str32str (method, U"Bars")) { for (long ix = ixmin; ix <= ixmax; ix ++) { double x = Sampled_indexToX (me, ix); double y = my z [channel] [ix]; double left = x - 0.5 * my dx, right = x + 0.5 * my dx; if (y > maximum) y = maximum; if (left < tmin) left = tmin; if (right > tmax) right = tmax; Graphics_line (g, left, y, right, y); Graphics_line (g, left, y, left, minimum); Graphics_line (g, right, y, right, minimum); } } else if (str32str (method, U"poles") || str32str (method, U"Poles")) { for (long ix = ixmin; ix <= ixmax; ix ++) { double x = Sampled_indexToX (me, ix); Graphics_line (g, x, 0, x, my z [channel] [ix]); } } else if (str32str (method, U"speckles") || str32str (method, U"Speckles")) { for (long ix = ixmin; ix <= ixmax; ix ++) { double x = Sampled_indexToX (me, ix); Graphics_speckle (g, x, my z [channel] [ix]); } } else { /* * The default: draw as a curve. */ Graphics_function (g, my z [channel], ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax)); } } Graphics_setWindow (g, treversed ? tmax : tmin, treversed ? tmin : tmax, minimum, maximum); if (garnish && my ny == 2) Graphics_line (g, tmin, 0.5 * (minimum + maximum), tmax, 0.5 * (minimum + maximum)); Graphics_unsetInner (g); if (garnish) { Graphics_drawInnerBox (g); Graphics_textBottom (g, 1, U"Time (s)"); Graphics_marksBottom (g, 2, 1, 1, 0); Graphics_setWindow (g, tmin, tmax, minimum - (my ny - 1) * (maximum - minimum), maximum); Graphics_markLeft (g, minimum, 1, 1, 0, NULL); Graphics_markLeft (g, maximum, 1, 1, 0, NULL); if (minimum != 0.0 && maximum != 0.0 && (minimum > 0.0) != (maximum > 0.0)) { Graphics_markLeft (g, 0.0, 1, 1, 1, NULL); } if (my ny == 2) { Graphics_setWindow (g, treversed ? tmax : tmin, treversed ? tmin : tmax, minimum, maximum + (my ny - 1) * (maximum - minimum)); Graphics_markRight (g, minimum, 1, 1, 0, NULL); Graphics_markRight (g, maximum, 1, 1, 0, NULL); if (minimum != 0.0 && maximum != 0.0 && (minimum > 0.0) != (maximum > 0.0)) { Graphics_markRight (g, 0.0, 1, 1, 1, NULL); } } } }
bool Melder_hasError (const char32 *partialError) { return !! str32str (errors, partialError); }
static void defaultError (const char32 *message) { Melder_writeToConsole (str32str (message, U"You interrupted ") ? U"User interrupt: " : U"Error: ", true); Melder_writeToConsole (message, true); Melder_writeToConsole (U"\n", true); }