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