void ERPTier_rejectArtefacts (ERPTier me, double threshold) {
long numberOfEvents = my events -> size;
if (numberOfEvents < 1)
return; // nothing to do
ERPPoint firstEvent = my event (1);
long numberOfChannels = firstEvent -> erp -> ny;
long numberOfSamples = firstEvent -> erp -> nx;
if (numberOfSamples < 1)
return; // nothing to do
for (long ievent = numberOfEvents; ievent >= 1; ievent --) { // cycle down because of removal
ERPPoint event = my event (ievent);
double minimum = event -> erp -> z [1] [1];
double maximum = minimum;
for (long ichannel = 1; ichannel <= (numberOfChannels & ~ 15); ichannel ++) {
double *channel = event -> erp -> z [ichannel];
for (long isample = 1; isample <= numberOfSamples; isample ++) {
double value = channel [isample];
if (value < minimum) minimum = value;
if (value > maximum) maximum = value;
}
}
if (minimum < - threshold || maximum > threshold) {
Collection_removeItem (my events, ievent);
}
}
}
static void IntervalTier_cutInterval (IntervalTier me, long index, int extend_option) {
long size_pre = my intervals -> size;
/* There always must be at least one interval */
if (size_pre == 1 || index > size_pre || index < 1) {
return;
}
TextInterval ti = (TextInterval) my intervals -> item[index];
double xmin = ti -> xmin;
double xmax = ti -> xmax;
Collection_removeItem (my intervals, index);
if (index == 1) { // Change xmin of the new first interval.
ti = (TextInterval) my intervals -> item[index];
ti -> xmin = xmin;
} else if (index == size_pre) { // Change xmax of the new last interval.
ti = (TextInterval) my intervals -> item[my intervals -> size];
ti -> xmax = xmax;
} else {
if (extend_option == 0) { // extend earlier interval to the right
ti = (TextInterval) my intervals -> item[index - 1];
ti -> xmax = xmax;
} else { // extend next interval to the left
ti = (TextInterval) my intervals -> item[index];
ti -> xmin = xmin;
}
}
}
static void IntervalTier_removeEmptyIntervals (IntervalTier me, IntervalTier boss) {
IntervalTier_removeBoundariesBetweenIdenticallyLabeledIntervals (me, L"");
if (my intervals -> size < 2) return;
TextInterval firstInterval = my interval (1);
if (Melder_wcsequ (firstInterval -> text, L"")) {
IntervalTier_removeLeftBoundary (me, 2);
}
if (my numberOfIntervals () < 2) return;
TextInterval lastInterval = my interval (my numberOfIntervals ());
if (Melder_wcsequ (lastInterval -> text, L"")) {
IntervalTier_removeLeftBoundary (me, my numberOfIntervals ());
}
if (my numberOfIntervals () < 3) return;
for (long iinterval = my numberOfIntervals () - 1; iinterval >= 2; iinterval --) {
TextInterval interval = my interval (iinterval);
if (Melder_wcsequ (interval -> text, L"")) {
/*
* Distribute the empty interval between its neigbours.
*/
double newBoundaryTime =
boss ?
IntervalTier_boundaryTimeClosestTo (boss, interval -> xmin, interval -> xmax) :
0.5 * (interval -> xmin + interval -> xmax);
TextInterval previous = my interval (iinterval - 1);
TextInterval next = my interval (iinterval + 1);
previous -> xmax = newBoundaryTime;
next -> xmin = newBoundaryTime;
Collection_removeItem (my intervals, iinterval);
}
}
}
static int CategoriesEditorInsert_undo (CategoriesEditorInsert me) {
CategoriesEditor editor = static_cast<CategoriesEditor> (my boss);
Categories categories = static_cast<Categories> (editor -> data);
Collection_removeItem (categories, my selection[1]);
update (editor, my selection[1], 0, my selection, 1);
return 1;
}
void PairDistribution_removeZeroWeights (PairDistribution me) {
for (long ipair = my pairs -> size; ipair > 0; ipair --) {
PairProbability prob = static_cast <PairProbability> (my pairs -> item [ipair]);
if (prob -> weight <= 0.0) {
Collection_removeItem (my pairs.get(), ipair);
}
}
}
void AnyTier_removePointsBetween (I, double tmin, double tmax) {
iam (AnyTier);
if (my points -> size == 0) return;
long ileft = AnyTier_timeToHighIndex (me, tmin);
long iright = AnyTier_timeToLowIndex (me, tmax);
for (long i = iright; i >= ileft; i --)
Collection_removeItem (my points, i);
}
static void IntervalTier_insertIntervalDestructively (IntervalTier me, double tmin, double tmax) {
Melder_assert (tmin < tmax);
Melder_assert (tmin >= my xmin);
Melder_assert (tmax <= my xmax);
/*
* Make sure that the tier has boundaries at the edges of the interval.
*/
long firstIntervalNumber = IntervalTier_hasTime (me, tmin);
if (! firstIntervalNumber) {
long intervalNumber = IntervalTier_timeToIndex (me, tmin);
if (intervalNumber == 0)
Melder_throw ("Cannot add a boundary at ", Melder_fixed (tmin, 6), " seconds, because this is outside the time domain of the intervals.");
TextInterval interval = my interval (intervalNumber);
/*
* Move the text to the left of the boundary.
*/
autoTextInterval newInterval = TextInterval_create (tmin, interval -> xmax, L"");
interval -> xmax = tmin;
Collection_addItem (my intervals, newInterval.transfer());
firstIntervalNumber = IntervalTier_hasTime (me, interval -> xmin);
}
Melder_assert (firstIntervalNumber >= 1 && firstIntervalNumber <= my intervals -> size);
long lastIntervalNumber = IntervalTier_hasTime (me, tmax);
if (! lastIntervalNumber) {
long intervalNumber = IntervalTier_timeToIndex (me, tmax);
if (intervalNumber == 0)
Melder_throw ("Cannot add a boundary at ", Melder_fixed (tmin, 6), " seconds, because this is outside the time domain of the intervals.");
TextInterval interval = my interval (intervalNumber);
/*
* Move the text to the right of the boundary.
*/
autoTextInterval newInterval = TextInterval_create (interval -> xmin, tmax, L"");
interval -> xmin = tmax;
Collection_addItem (my intervals, newInterval.transfer());
lastIntervalNumber = IntervalTier_hasTime (me, interval -> xmax);
}
Melder_assert (lastIntervalNumber >= 1 && lastIntervalNumber <= my intervals -> size);
/*
* Empty the interval in the word tier.
*/
trace ("Empty interval %ld down to %ld.", lastIntervalNumber, firstIntervalNumber);
for (long iinterval = lastIntervalNumber; iinterval >= firstIntervalNumber; iinterval --) {
TextInterval interval = my interval (iinterval);
if (interval -> xmin > tmin && interval -> xmin < tmax) {
Melder_assert (iinterval > 1);
TextInterval previous = (TextInterval) my intervals -> item [iinterval - 1];
previous -> xmax = tmax; // collapse left and right intervals into left interval
TextInterval_setText (previous, L"");
Collection_removeItem (my intervals, iinterval); // remove right interval
}
if (interval -> xmax == tmax) {
TextInterval_setText (interval, L"");
}
}
}
static int CategoriesEditorRemove_execute (CategoriesEditorRemove me) {
CategoriesEditor editor = static_cast<CategoriesEditor> (my boss);
Categories categories = static_cast<Categories> (editor -> data);
for (long i = my nSelected; i >= 1; i--) {
autoSimpleString item = Data_copy ((SimpleString) categories -> item[my selection[i]]);
Ordered_addItemAtPosition_move (my categories.peek(), item.move(), 1);
Collection_removeItem (categories, my selection[i]);
}
update (editor, my selection[1], 0, nullptr, 0);
return 1;
}
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);
}
}
}
void OrderedOfString_removeOccurrences (I, const wchar_t *search, int use_regexp) {
iam (OrderedOfString);
if (search == NULL) {
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 && wcsstr (ss -> string, search))) {
Collection_removeItem (me, i);
}
}
}
void CommandHistory_insertItem (I, Any data) {
iam (CommandHistory);
Melder_assert (data && (Thing_member ( (Thing) data, my itemClass) || my itemClass == NULL));
if (my current < my size) {
for (long i = my current + 1; i <= my size; i++) {
forget ( ( (Command *) my item) [i]);
}
my size = my current;
}
if (my size >= my _capacity) {
Collection_removeItem (me, 1);
}
my item[++my size] = data;
my current = my size;
}
void PitchTier_stylize (PitchTier me, double frequencyResolution, int useSemitones) {
double dfmin;
for (;;) {
long i, imin = 0;
dfmin = 1e300;
for (i = 2; i <= my points -> size - 1; i ++) {
RealPoint pm = (RealPoint) my points -> item [i];
RealPoint pl = (RealPoint) my points -> item [i - 1];
RealPoint pr = (RealPoint) my points -> item [i + 1];
double expectedFrequency = pl -> value + (pr -> value - pl -> value) /
(pr -> number - pl -> number) * (pm -> number - pl -> number);
double df = useSemitones ?
12 * fabs (log (pm -> value / expectedFrequency)) / NUMln2:
fabs (pm -> value - expectedFrequency);
if (df < dfmin) {
imin = i;
dfmin = df;
}
}
if (imin == 0 || dfmin > frequencyResolution) break;
Collection_removeItem (my points, imin);
}
}
TextGrid TextGrid_readFromTIMITLabelFile (MelderFile file, int phnFile) {
try {
double dt = 1.0 / 16000; /* 1 / (TIMIT samplingFrequency) */
double xmax = dt;
autofile f = Melder_fopen (file, "r");
// Ending time will only be known after all labels have been read.
// We start with a sufficiently long duration (one hour) and correct this later.
autoTextGrid me = TextGrid_create (0, 3600, U"wrd", 0);
IntervalTier timit = (IntervalTier) my tiers -> item[1];
long linesRead = 0;
char line[200], label[200];
while (fgets (line, 199, f)) {
long it1, it2;
linesRead++;
if (sscanf (line, "%ld%ld%s", &it1, &it2, label) != 3) {
Melder_throw (U"Incorrect number of items.");
}
if (it1 < 0 || it2 <= it1) {
Melder_throw (U"Incorrect time at line ", linesRead);
}
xmax = it2 * dt;
double xmin = it1 * dt;
long ni = timit -> intervals -> size - 1;
if (ni < 1) {
ni = 1;
// Some files do not start with a first line "0 <number2> h#".
// Instead they start with "<number1> <number2> h#", where number1 > 0.
// We override number1 with 0. */
if (xmin > 0 && phnFile) {
xmin = 0;
}
}
TextInterval interval = (TextInterval) timit -> intervals -> item[ni];
if (xmin < interval -> xmax && linesRead > 1) {
xmin = interval -> xmax;
Melder_warning (U"File \"", MelderFile_messageName (file), U"\": Start time set to previous end "
U"time for label at line ", linesRead, U".");
}
// standard: new TextInterval
const char *labelstring = (strncmp (label, "h#", 2) ? label : TIMIT_DELIMITER);
IntervalTier_add (timit, xmin, xmax, Melder_peek8to32 (labelstring));
}
// Now correct the end times, based on last read interval.
// (end time was set to large value!)
if (timit -> intervals -> size < 2) {
Melder_throw (U"Empty TextGrid");
}
Collection_removeItem (timit -> intervals, timit -> intervals -> size);
TextInterval interval = (TextInterval) timit -> intervals -> item[timit -> intervals -> size];
timit -> xmax = interval -> xmax;
my xmax = xmax;
if (phnFile) { // Create tier 2 with IPA symbols
autoIntervalTier ipa = Data_copy (timit);
Thing_setName (ipa.peek(), U"ipa");
// First change the data in ipa
for (long i = 1; i <= ipa -> intervals -> size; i++) {
interval = (TextInterval) timit -> intervals -> item[i];
TextInterval_setText ( (TextInterval) ipa -> intervals -> item[i],
Melder_peek8to32 (timitLabelToIpaLabel (Melder_peek32to8 (interval -> text))));
}
Collection_addItem (my tiers, ipa.transfer()); // Then: add to collection
Thing_setName (timit, U"phn"); // rename wrd
}
f.close (file);
return me.transfer();
} catch (MelderError) {
Melder_throw (U"TextGrid not read from file ", file, U".");
}
}
void AnyTier_removePointNear (I, double time) {
iam (AnyTier);
long ipoint = AnyTier_timeToNearestIndex (me, time);
if (ipoint) Collection_removeItem (my points, ipoint);
}
void AnyTier_removePoint (I, long i) {
iam (AnyTier);
if (i >= 1 && i <= my points -> size) Collection_removeItem (my points, i);
}
