void AnyTier_removePointsBetween (AnyTier me, double tmin, double tmax) {
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 --)
my points. removeItem (i);
}
double RealTier_getArea (I, double tmin, double tmax) {
iam (RealTier);
long n = my points -> size, imin, imax;
RealPoint *points = (RealPoint *) my points -> item;
if (n == 0) return NUMundefined;
if (n == 1) return (tmax - tmin) * points [1] -> value;
imin = AnyTier_timeToLowIndex (me, tmin);
if (imin == n) return (tmax - tmin) * points [n] -> value;
imax = AnyTier_timeToHighIndex (me, tmax);
if (imax == 1) return (tmax - tmin) * points [1] -> value;
Melder_assert (imin < n);
Melder_assert (imax > 1);
/*
* Sum the areas between the points.
* This works even if imin is 0 (offleft) and/or imax is n + 1 (offright).
*/
double area = 0.0;
for (long i = imin; i < imax; i ++) {
double tleft, fleft, tright, fright;
if (i == imin) tleft = tmin, fleft = RealTier_getValueAtTime (me, tmin);
else tleft = points [i] -> time, fleft = points [i] -> value;
if (i + 1 == imax) tright = tmax, fright = RealTier_getValueAtTime (me, tmax);
else tright = points [i + 1] -> time, fright = points [i + 1] -> value;
area += 0.5 * (fleft + fright) * (tright - tleft);
}
return area;
}
long AnyTier_getWindowPoints (AnyTier me, double tmin, double tmax, long *imin, long *imax) {
if (my points.size == 0) return 0;
*imin = AnyTier_timeToHighIndex (me, tmin);
*imax = AnyTier_timeToLowIndex (me, tmax);
if (*imax < *imin) return 0;
return *imax - *imin + 1;
}
double FormantTier_getValueAtTime (FormantTier me, int iformant, double t) {
long n = my points -> size;
if (n == 0 || iformant < 1) return NUMundefined;
FormantPoint pointRight = (FormantPoint) my points -> item [1];
if (t <= pointRight -> time) {
if (iformant > pointRight -> numberOfFormants) return NUMundefined;
return pointRight -> formant [iformant-1]; /* Constant extrapolation. */
}
FormantPoint pointLeft = (FormantPoint) my points -> item [n];
if (t >= pointLeft -> time) {
if (iformant > pointLeft -> numberOfFormants) return NUMundefined;
return pointLeft -> formant [iformant-1]; /* Constant extrapolation. */
}
Melder_assert (n >= 2);
long ileft = AnyTier_timeToLowIndex (me, t), iright = ileft + 1;
Melder_assert (ileft >= 1 && iright <= n);
pointLeft = (FormantPoint) my points -> item [ileft];
pointRight = (FormantPoint) my points -> item [iright];
double tleft = pointLeft -> time;
double fleft = iformant > pointLeft -> numberOfFormants ? NUMundefined : pointLeft -> formant [iformant-1];
double tright = pointRight -> time;
double fright = iformant > pointRight -> numberOfFormants ? NUMundefined : pointRight -> formant [iformant-1];
return fleft == NUMundefined ? fright == NUMundefined ? NUMundefined : fright
: fright == NUMundefined ? fleft
: t == tright ? fright /* Be very accurate. */
: tleft == tright ? 0.5 * (fleft + fright) /* Unusual, but possible; no preference. */
: fleft + (t - tleft) * (fright - fleft) / (tright - tleft); /* Linear interpolation. */
}
double FormantTier_getValueAtTime (FormantTier me, int iformant, double t) {
long n = my points.size;
if (n == 0 || iformant < 1) return NUMundefined;
FormantPoint pointRight = my points.at [1];
if (t <= pointRight -> number) {
if (iformant > pointRight -> numberOfFormants) return NUMundefined;
return pointRight -> formant [iformant-1]; // constant extrapolation
}
FormantPoint pointLeft = my points.at [n];
if (t >= pointLeft -> number) {
if (iformant > pointLeft -> numberOfFormants) return NUMundefined;
return pointLeft -> formant [iformant-1]; // constant extrapolation
}
Melder_assert (n >= 2);
long ileft = AnyTier_timeToLowIndex (me->asAnyTier(), t), iright = ileft + 1;
Melder_assert (ileft >= 1 && iright <= n);
pointLeft = my points.at [ileft];
pointRight = my points.at [iright];
double tleft = pointLeft -> number;
double fleft = iformant > pointLeft -> numberOfFormants ? NUMundefined : pointLeft -> formant [iformant-1];
double tright = pointRight -> number;
double fright = iformant > pointRight -> numberOfFormants ? NUMundefined : pointRight -> formant [iformant-1];
return fleft == NUMundefined ? fright == NUMundefined ? NUMundefined : fright
: fright == NUMundefined ? fleft
: t == tright ? fright // be very accurate
: tleft == tright ? 0.5 * (fleft + fright) // unusual, but possible; no preference
: fleft + (t - tleft) * (fright - fleft) / (tright - tleft); // linear interpolation
}
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);
}
double RealTier_getStandardDeviation_curve (RealTier me, double tmin, double tmax) {
long n = my points.size, imin, imax;
double mean, integral = 0.0;
if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; } // autowindow
if (n == 0) return NUMundefined;
if (n == 1) return 0.0;
imin = AnyTier_timeToLowIndex (me->asAnyTier(), tmin);
if (imin == n) return 0.0;
imax = AnyTier_timeToHighIndex (me->asAnyTier(), tmax);
if (imax == 1) return 0.0;
Melder_assert (imin < n);
Melder_assert (imax > 1);
/*
* Add the areas between the points.
* This works even if imin is 0 (offleft) and/or imax is n + 1 (offright).
*/
mean = RealTier_getMean_curve (me, tmin, tmax);
for (long i = imin; i < imax; i ++) {
double tleft, fleft, tright, fright, sum, diff;
if (i == imin) {
tleft = tmin;
fleft = RealTier_getValueAtTime (me, tmin);
} else {
tleft = my points.at [i] -> number;
fleft = my points.at [i] -> value - mean;
}
if (i + 1 == imax) {
tright = tmax;
fright = RealTier_getValueAtTime (me, tmax);
} else {
tright = my points.at [i + 1] -> number;
fright = my points.at [i + 1] -> value - mean;
}
/*
* The area is integral dt f^2
* = integral dt [f1 + (f2-f1)/(t2-t1) (t-t1)]^2
* = int dt f1^2 + int dt 2 f1 (f2-f1)/(t2-t1) (t-t1) + int dt [(f2-f1)/(t2-t1)]^2 (t-t1)^2
* = f1^2 (t2-t1) + f1 (f2-f1)/(t2-t1) (t2-t1)^2 + 1/3 [(f2-f1)/(t2-t1)]^2 (t2-t1)^3
* = (t2-t1) [f1 f2 + 1/3 (f2-f1)^2]
* = (t2-t1) (f1^2 + f2^2 + 1/3 f1 f2)
* = (t2-t1) [1/4 (f1+f2)^2 + 1/12 (f1-f2)^2]
* In the last expression, we have a sum of squares, which is computationally best.
*/
sum = fleft + fright;
diff = fleft - fright;
integral += (sum * sum + (1.0/3.0) * diff * diff) * (tright - tleft);
}
return sqrt (0.25 * integral / (tmax - tmin));
}
double RealTier_getValueAtTime (RealTier me, double t) {
long n = my points.size;
if (n == 0) return NUMundefined;
RealPoint pointRight = my points.at [1];
if (t <= pointRight -> number) return pointRight -> value; // constant extrapolation
RealPoint pointLeft = my points.at [n];
if (t >= pointLeft -> number) return pointLeft -> value; // constant extrapolation
Melder_assert (n >= 2);
long ileft = AnyTier_timeToLowIndex (me->asAnyTier(), t), iright = ileft + 1;
Melder_assert (ileft >= 1 && iright <= n);
pointLeft = my points.at [ileft];
pointRight = my points.at [iright];
double tleft = pointLeft -> number, fleft = pointLeft -> value;
double tright = pointRight -> number, fright = pointRight -> value;
return t == tright ? fright // be very accurate
: tleft == tright ? 0.5 * (fleft + fright) // unusual, but possible; no preference
: fleft + (t - tleft) * (fright - fleft) / (tright - tleft); // linear interpolation
}
void PitchTier_Pitch_draw (PitchTier me, Pitch uv, Graphics g,
double tmin, double tmax, double fmin, double fmax, int nonPeriodicLineType, int garnish, const char32 *method)
{
long n = my points.size, imin, imax, i;
if (nonPeriodicLineType == 0) {
PitchTier_draw (me, g, tmin, tmax, fmin, fmax, garnish, method);
return;
}
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);
Pitch_line (uv, g, tmin, fleft, tmax, fright, nonPeriodicLineType);
} else for (i = imin; i <= imax; i ++) {
RealPoint point = my points.at [i];
double t = point -> number, f = point -> value;
Graphics_speckle (g, t, f);
if (i == 1)
Pitch_line (uv, g, tmin, f, t, f, nonPeriodicLineType);
else if (i == imin)
Pitch_line (uv, g, t, f, tmin, RealTier_getValueAtTime (me, tmin), nonPeriodicLineType);
if (i == n)
Pitch_line (uv, g, t, f, tmax, f, nonPeriodicLineType);
else if (i == imax)
Pitch_line (uv, g, t, f, tmax, RealTier_getValueAtTime (me, tmax), nonPeriodicLineType);
else {
RealPoint pointRight = my points.at [i + 1];
Pitch_line (uv, g, t, f, pointRight -> number, pointRight -> value, nonPeriodicLineType);
}
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, true, U"Time (s)");
Graphics_marksBottom (g, 2, true, true, false);
Graphics_marksLeft (g, 2, true, true, false);
Graphics_textLeft (g, true, U"Frequency (Hz)");
}
}
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);
}
}
double RealTier_getValueAtTime (I, double t) {
iam (RealTier);
long n = my points -> size, ileft, iright;
double tleft, tright, fleft, fright;
RealPoint pointLeft, pointRight;
if (n == 0) return NUMundefined;
pointRight = (structRealPoint *)my points -> item [1];
if (t <= pointRight -> time) return pointRight -> value; /* Constant extrapolation. */
pointLeft = (structRealPoint *)my points -> item [n];
if (t >= pointLeft -> time) return pointLeft -> value; /* Constant extrapolation. */
Melder_assert (n >= 2);
ileft = AnyTier_timeToLowIndex (me, t), iright = ileft + 1;
Melder_assert (ileft >= 1 && iright <= n);
pointLeft = (structRealPoint *)my points -> item [ileft];
pointRight = (structRealPoint *)my points -> item [iright];
tleft = pointLeft -> time, fleft = pointLeft -> value;
tright = pointRight -> time, fright = pointRight -> value;
return t == tright ? fright /* Be very accurate. */
: tleft == tright ? 0.5 * (fleft + fright) /* Unusual, but possible; no preference. */
: fleft + (t - tleft) * (fright - fleft) / (tright - tleft); /* Linear interpolation. */
}
void FormantTier_speckle (FormantTier me, Graphics g, double tmin, double tmax, double fmax, int garnish) {
if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; }
Graphics_setWindow (g, tmin, tmax, 0.0, fmax);
Graphics_setInner (g);
long imin = AnyTier_timeToHighIndex (me, tmin);
long imax = AnyTier_timeToLowIndex (me, tmax);
if (imin > 0) for (long i = imin; i <= imax; i ++) {
FormantPoint point = (FormantPoint) my points -> item [i];
double t = point -> time;
for (long j = 1; j <= point -> numberOfFormants; j ++) {
double f = point -> formant [j-1];
if (f <= fmax) Graphics_speckle (g, t, f);
}
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, true, U"Time (s)");
Graphics_marksBottom (g, 2, true, true, false);
Graphics_marksLeft (g, 2, true, true, false);
Graphics_textLeft (g, true, U"Frequency (Hz)");
}
}
double RealTier_getArea (RealTier me, double tmin, double tmax) {
long n = my points.size, imin, imax;
//RealPoint *points = & my points [0];
if (n == 0) return NUMundefined;
if (n == 1) return (tmax - tmin) * my points.at [1] -> value;
imin = AnyTier_timeToLowIndex (me->asAnyTier(), tmin);
if (imin == n) return (tmax - tmin) * my points.at [n] -> value;
imax = AnyTier_timeToHighIndex (me->asAnyTier(), tmax);
if (imax == 1) return (tmax - tmin) * my points.at [1] -> value;
Melder_assert (imin < n);
Melder_assert (imax > 1);
/*
* Sum the areas between the points.
* This works even if imin is 0 (offleft) and/or imax is n + 1 (offright).
*/
double area = 0.0;
for (long i = imin; i < imax; i ++) {
double tleft, fleft, tright, fright;
if (i == imin) {
tleft = tmin;
fleft = RealTier_getValueAtTime (me, tmin);
} else {
tleft = my points.at [i] -> number;
fleft = my points.at [i] -> value;
}
if (i + 1 == imax) {
tright = tmax;
fright = RealTier_getValueAtTime (me, tmax);
} else {
tright = my points.at [i + 1] -> number;
fright = my points.at [i + 1] -> value;
}
area += 0.5 * (fleft + fright) * (tright - tleft);
}
return area;
}
bool structFormantGridEditor :: v_click (double xWC, double yWC, bool shiftKeyPressed) {
FormantGrid grid = (FormantGrid) our data;
Ordered tiers = editingBandwidths ? grid -> bandwidths : grid -> formants;
RealTier tier = (RealTier) tiers -> item [selectedFormant];
double ymin = our editingBandwidths ? our p_bandwidthFloor : our p_formantFloor;
double ymax = our editingBandwidths ? our p_bandwidthCeiling : our p_formantCeiling;
long inearestPoint, ifirstSelected, ilastSelected;
RealPoint nearestPoint;
double dt = 0, df = 0;
bool draggingSelection;
/*
* Perform the default action: move cursor.
*/
//d_startSelection = d_endSelection = xWC;
our ycursor = (1.0 - yWC) * ymin + yWC * ymax;
Graphics_setWindow (our d_graphics, our d_startWindow, our d_endWindow, ymin, ymax);
yWC = our ycursor;
/*
* Clicked on a point?
*/
inearestPoint = AnyTier_timeToNearestIndex (tier, xWC);
if (inearestPoint == 0) {
return FormantGridEditor_Parent :: v_click (xWC, yWC, shiftKeyPressed);
}
nearestPoint = (RealPoint) tier -> points -> item [inearestPoint];
if (Graphics_distanceWCtoMM (our d_graphics, xWC, yWC, nearestPoint -> number, nearestPoint -> value) > 1.5) {
return our FormantGridEditor_Parent :: v_click (xWC, yWC, shiftKeyPressed);
}
/*
* Clicked on a selected point?
*/
draggingSelection = shiftKeyPressed &&
nearestPoint -> number > our d_startSelection && nearestPoint -> number < our d_endSelection;
if (draggingSelection) {
ifirstSelected = AnyTier_timeToHighIndex (tier, our d_startSelection);
ilastSelected = AnyTier_timeToLowIndex (tier, our d_endSelection);
Editor_save (this, U"Drag points");
} else {
ifirstSelected = ilastSelected = inearestPoint;
Editor_save (this, U"Drag point");
}
/*
* Drag.
*/
Graphics_xorOn (our d_graphics, Graphics_MAROON);
drawWhileDragging (this, xWC, yWC, ifirstSelected, ilastSelected, dt, df);
while (Graphics_mouseStillDown (our d_graphics)) {
double xWC_new, yWC_new;
Graphics_getMouseLocation (our d_graphics, & xWC_new, & yWC_new);
if (xWC_new != xWC || yWC_new != yWC) {
drawWhileDragging (this, xWC, yWC, ifirstSelected, ilastSelected, dt, df);
dt += xWC_new - xWC, df += yWC_new - yWC;
xWC = xWC_new, yWC = yWC_new;
drawWhileDragging (this, xWC, yWC, ifirstSelected, ilastSelected, dt, df);
}
}
Graphics_xorOff (our d_graphics);
/*
* Dragged inside window?
*/
if (xWC < d_startWindow || xWC > d_endWindow) return 1;
/*
* Points not dragged past neighbours?
*/
RealPoint *points = (RealPoint *) tier -> points -> item;
double newTime = points [ifirstSelected] -> number + dt;
if (newTime < our tmin) return 1; // outside domain
if (ifirstSelected > 1 && newTime <= points [ifirstSelected - 1] -> number)
return 1; // past left neighbour
newTime = points [ilastSelected] -> number + dt;
if (newTime > our tmax) return 1; // outside domain
if (ilastSelected < tier -> points -> size && newTime >= points [ilastSelected + 1] -> number)
return FunctionEditor_UPDATE_NEEDED; // past right neighbour
/*
* Drop.
*/
for (long i = ifirstSelected; i <= ilastSelected; i ++) {
RealPoint point = (RealPoint) tier -> points -> item [i];
point -> number += dt;
point -> value += df;
}
/*
* Make sure that the same points are still selected (a problem with Undo...).
*/
if (draggingSelection) our d_startSelection += dt, our d_endSelection += dt;
if (ifirstSelected == ilastSelected) {
/*
* Move crosshair to only selected formant point.
*/
RealPoint point = (RealPoint) tier -> points -> item [ifirstSelected];
our d_startSelection = our d_endSelection = point -> number;
our ycursor = point -> value;
} else {
/*
* Move crosshair to mouse location.
*/
/*our cursor += dt;*/
our ycursor += df;
}
Editor_broadcastDataChanged (this);
return FunctionEditor_UPDATE_NEEDED;
}
void structFormantGridEditor :: v_draw () {
FormantGrid grid = (FormantGrid) our data;
Ordered tiers = our editingBandwidths ? grid -> bandwidths : grid -> formants;
RealTier selectedTier = (RealTier) tiers -> item [selectedFormant];
double ymin = our editingBandwidths ? our p_bandwidthFloor : our p_formantFloor;
double ymax = our editingBandwidths ? our p_bandwidthCeiling : our p_formantCeiling;
Graphics_setColour (our d_graphics, Graphics_WHITE);
Graphics_setWindow (our d_graphics, 0, 1, 0, 1);
Graphics_fillRectangle (our d_graphics, 0, 1, 0, 1);
Graphics_setWindow (our d_graphics, our d_startWindow, our d_endWindow, ymin, ymax);
Graphics_setColour (our d_graphics, Graphics_RED);
Graphics_line (our d_graphics, our d_startWindow, our ycursor, our d_endWindow, our ycursor);
Graphics_setTextAlignment (our d_graphics, Graphics_RIGHT, Graphics_HALF);
Graphics_text (our d_graphics, our d_startWindow, our ycursor, Melder_float (Melder_half (our ycursor)));
Graphics_setColour (our d_graphics, Graphics_BLUE);
Graphics_setTextAlignment (our d_graphics, Graphics_LEFT, Graphics_TOP);
Graphics_text (our d_graphics, our d_endWindow, ymax, Melder_float (Melder_half (ymax)), U" Hz");
Graphics_setTextAlignment (our d_graphics, Graphics_LEFT, Graphics_HALF);
Graphics_text (our d_graphics, our d_endWindow, ymin, Melder_float (Melder_half (ymin)), U" Hz");
Graphics_setLineWidth (our d_graphics, 1);
Graphics_setColour (our d_graphics, Graphics_GREY);
for (long iformant = 1; iformant <= grid -> formants -> size; iformant ++) if (iformant != our selectedFormant) {
RealTier tier = (RealTier) tiers -> item [iformant];
long imin = AnyTier_timeToHighIndex (tier, our d_startWindow);
long imax = AnyTier_timeToLowIndex (tier, our d_endWindow);
long n = tier -> points -> size;
if (n == 0) {
} else if (imax < imin) {
double yleft = RealTier_getValueAtTime (tier, our d_startWindow);
double yright = RealTier_getValueAtTime (tier, our d_endWindow);
Graphics_line (our d_graphics, our d_startWindow, yleft, our d_endWindow, yright);
} else for (long i = imin; i <= imax; i ++) {
RealPoint point = (RealPoint) tier -> points -> item [i];
double t = point -> number, y = point -> value;
Graphics_fillCircle_mm (our d_graphics, t, y, 2);
if (i == 1)
Graphics_line (our d_graphics, our d_startWindow, y, t, y);
else if (i == imin)
Graphics_line (our d_graphics, t, y, our d_startWindow, RealTier_getValueAtTime (tier, our d_startWindow));
if (i == n)
Graphics_line (our d_graphics, t, y, our d_endWindow, y);
else if (i == imax)
Graphics_line (our d_graphics, t, y, our d_endWindow, RealTier_getValueAtTime (tier, our d_endWindow));
else {
RealPoint pointRight = (RealPoint) tier -> points -> item [i + 1];
Graphics_line (our d_graphics, t, y, pointRight -> number, pointRight -> value);
}
}
}
Graphics_setColour (our d_graphics, Graphics_BLUE);
long ifirstSelected = AnyTier_timeToHighIndex (selectedTier, our d_startSelection);
long ilastSelected = AnyTier_timeToLowIndex (selectedTier, our d_endSelection);
long n = selectedTier -> points -> size;
long imin = AnyTier_timeToHighIndex (selectedTier, our d_startWindow);
long imax = AnyTier_timeToLowIndex (selectedTier, our d_endWindow);
Graphics_setLineWidth (our d_graphics, 2);
if (n == 0) {
Graphics_setTextAlignment (our d_graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_text (our d_graphics, 0.5 * (our d_startWindow + our d_endWindow),
0.5 * (ymin + ymax), U"(no points in selected formant tier)");
} else if (imax < imin) {
double yleft = RealTier_getValueAtTime (selectedTier, our d_startWindow);
double yright = RealTier_getValueAtTime (selectedTier, our d_endWindow);
Graphics_line (our d_graphics, our d_startWindow, yleft, our d_endWindow, yright);
} else for (long i = imin; i <= imax; i ++) {
RealPoint point = (RealPoint) selectedTier -> points -> item [i];
double t = point -> number, y = point -> value;
if (i >= ifirstSelected && i <= ilastSelected)
Graphics_setColour (our d_graphics, Graphics_RED);
Graphics_fillCircle_mm (our d_graphics, t, y, 3);
Graphics_setColour (our d_graphics, Graphics_BLUE);
if (i == 1)
Graphics_line (our d_graphics, our d_startWindow, y, t, y);
else if (i == imin)
Graphics_line (our d_graphics, t, y, our d_startWindow, RealTier_getValueAtTime (selectedTier, our d_startWindow));
if (i == n)
Graphics_line (our d_graphics, t, y, our d_endWindow, y);
else if (i == imax)
Graphics_line (our d_graphics, t, y, our d_endWindow, RealTier_getValueAtTime (selectedTier, our d_endWindow));
else {
RealPoint pointRight = (RealPoint) selectedTier -> points -> item [i + 1];
Graphics_line (our d_graphics, t, y, pointRight -> number, pointRight -> value);
}
}
Graphics_setLineWidth (our d_graphics, 1);
Graphics_setColour (our d_graphics, Graphics_BLACK);
}
// MARK: TIMETIER
// MARK: Query
DIRECT (INTEGER_TimeTier_getNumberOfPoints) {
NUMBER_ONE (AnyTier)
long result = my points.size;
NUMBER_ONE_END (U" points")
}
FORM (INTEGER_TimeTier_getLowIndexFromTime, U"Get low index", U"AnyTier: Get low index from time...") {
REALVAR (time, U"Time (s)", U"0.5")
OK
DO
FIND_ONE (AnyTier)
Melder_information (my points.size == 0 ? U"--undefined--" : Melder_integer (AnyTier_timeToLowIndex (me, time)));
END
}
FORM (INTEGER_TimeTier_getHighIndexFromTime, U"Get high index", U"AnyTier: Get high index from time...") {
REALVAR (time, U"Time (s)", U"0.5")
OK
DO
FIND_ONE (AnyTier)
Melder_information (my points.size == 0 ? U"--undefined--" : Melder_integer (AnyTier_timeToHighIndex (me, GET_REAL (U"Time"))));
END
}
FORM (INTEGER_TimeTier_getNearestIndexFromTime, U"Get nearest index", U"AnyTier: Get nearest index from time...") {
REALVAR (time, U"Time (s)", U"0.5")
OK
