static void shiftX (I, double xfrom, double xto) {
iam (Sampled);
inherited (Sampled) shiftX (me, xfrom, xto);
NUMshift (& my x1, xfrom, xto);
}
static void print (void *void_me, Graphics printer) {
iam (Picture);
Graphics_play (my graphics, printer);
}
static void info (I) {
iam (Sound);
const double rho_c = 400; /* rho = 1.14 kg m-3; c = 353 m s-1; [rho c] = kg m-2 s-1 */
long numberOfSamples = my nx;
double minimum = my z [1] [1], maximum = minimum;
classData -> info (me);
MelderInfo_writeLine3 (L"Number of channels: ", Melder_integer (my ny),
my ny == 1 ? L" (mono)" : my ny == 2 ? L" (stereo)" : L"");
MelderInfo_writeLine1 (L"Time domain:");
MelderInfo_writeLine3 (L" Start time: ", Melder_double (my xmin), L" seconds");
MelderInfo_writeLine3 (L" End time: ", Melder_double (my xmax), L" seconds");
MelderInfo_writeLine3 (L" Total duration: ", Melder_double (my xmax - my xmin), L" seconds");
MelderInfo_writeLine1 (L"Time sampling:");
MelderInfo_writeLine2 (L" Number of samples: ", Melder_integer (my nx));
MelderInfo_writeLine3 (L" Sampling period: ", Melder_double (my dx), L" seconds");
MelderInfo_writeLine3 (L" Sampling frequency: ", Melder_single (1.0 / my dx), L" Hz");
MelderInfo_writeLine3 (L" First sample centred at: ", Melder_double (my x1), L" seconds");
double sum = 0.0, sumOfSquares = 0.0;
for (long channel = 1; channel <= my ny; channel ++) {
double *amplitude = my z [channel];
for (long i = 1; i <= numberOfSamples; i ++) {
double value = amplitude [i];
sum += value;
sumOfSquares += value * value;
if (value < minimum) minimum = value;
if (value > maximum) maximum = value;
}
}
MelderInfo_writeLine1 (L"Amplitude:");
MelderInfo_writeLine3 (L" Minimum: ", Melder_single (minimum), L" Pascal");
MelderInfo_writeLine3 (L" Maximum: ", Melder_single (maximum), L" Pascal");
double mean = sum / (my nx * my ny);
MelderInfo_writeLine3 (L" Mean: ", Melder_single (mean), L" Pascal");
MelderInfo_writeLine3 (L" Root-mean-square: ", Melder_single (sqrt (sumOfSquares / (my nx * my ny))), L" Pascal");
double penergy = sumOfSquares * my dx / my ny; /* Pa2 s = kg2 m-2 s-3 */
MelderInfo_write3 (L"Total energy: ", Melder_single (penergy), L" Pascal\u00B2 sec");
double energy = penergy / rho_c; /* kg s-2 = Joule m-2 */
MelderInfo_writeLine3 (L" (energy in air: ", Melder_single (energy), L" Joule/m\u00B2)");
double power = energy / (my dx * my nx); /* kg s-3 = Watt/m2 */
MelderInfo_write3 (L"Mean power (intensity) in air: ", Melder_single (power), L" Watt/m\u00B2");
if (power != 0.0) {
MelderInfo_writeLine3 (L" = ", Melder_half (10 * log10 (power / 1e-12)), L" dB");
} else {
MelderInfo_writeLine1 (L"");
}
if (my nx > 1) {
for (long channel = 1; channel <= my ny; channel ++) {
double *amplitude = my z [channel];
double sum = 0.0;
for (long i = 1; i <= numberOfSamples; i ++) {
double value = amplitude [i];
sum += value;
}
double mean = sum / my nx, stdev = 0.0;
for (long i = 1; i <= numberOfSamples; i ++) {
double value = amplitude [i] - mean;
stdev += value * value;
}
stdev = sqrt (stdev / (my nx - 1));
MelderInfo_writeLine5 (L"Standard deviation in channel ", Melder_integer (channel), L": ", Melder_single (stdev), L" Pascal");
}
}
}
void CommandHistory_back (I) {
iam (CommandHistory);
my current--;
}
int CommandHistory_empty (I) {
iam (CommandHistory);
return my size == 0;
}
char32 *CommandHistory_commandName (I, long offsetFromCurrent) {
iam (CommandHistory);
long pos = my current + offsetFromCurrent;
return pos >= 1 && pos <= my size ? Thing_getName ( (Thing) my item[pos]) : NULL;
}
int Command_undo (I) {
iam (Command);
return my undo (me);
}
int structFilesInMemory :: s_compare_name (I, thou) {
iam (FileInMemory); thouart (FileInMemory);
return Melder_wcscmp (my d_path, thy d_path);
}
int structFilesInMemory :: s_compare_id (I, thou) {
iam (FileInMemory); thouart (FileInMemory);
return Melder_wcscmp (my d_id, thy d_id);
}
double Sampled_indexToX (I, long i) {
iam (Sampled);
return my x1 + (i - 1) * my dx;
}
static void _guiMotifForm_destroyCallback (GuiObject widget, XtPointer void_me, XtPointer call) {
(void) widget; (void) call;
iam (GuiForm);
forget (me);
}
static void scaleX (I, double xminfrom, double xmaxfrom, double xminto, double xmaxto) {
iam (Sampled);
inherited (Sampled) scaleX (me, xminfrom, xmaxfrom, xminto, xmaxto);
NUMscale (& my x1, xminfrom, xmaxfrom, xminto, xmaxto);
my dx *= (xmaxto - xminto) / (xmaxfrom - xminfrom);
}
double Sampled_getXOfMaximum (I, double xmin, double xmax, long ilevel, int unit, int interpolate) {
iam (Sampled);
double time;
Sampled_getMaximumAndX (me, xmin, xmax, ilevel, unit, interpolate, NULL, & time);
return time;
}
double Sampled_getMaximum (I, double xmin, double xmax, long ilevel, int unit, int interpolate) {
iam (Sampled);
double maximum;
Sampled_getMaximumAndX (me, xmin, xmax, ilevel, unit, interpolate, & maximum, NULL);
return maximum;
}
static gboolean _GuiWindow_destroyCallback (GuiObject widget, GdkEvent *event, gpointer void_me) {
(void) widget;
iam (GuiWindow);
forget (me);
return TRUE;
}
static void _GuiGtkDrawingArea_destroyCallback (GuiObject widget, gpointer void_me) {
(void) widget;
iam (GuiDrawingArea);
forget (me);
}
int CommandHistory_offright (I) {
iam (CommandHistory);
return my size == 0 || my current == my size + 1;
}
static void _GuiGtkScrollBar_destroyCallback (GuiObject widget, gpointer void_me) {
(void) widget;
iam (GuiScrollBar);
forget (me);
}
int Command_do (I) {
iam (Command);
return my execute (me);
}
static void _GuiGtkButton_destroyCallback (GuiObject widget, gpointer void_me) {
(void) widget;
iam (GuiButton);
trace (U"destroying GuiButton ", Melder_pointer (me));
forget (me);
}
void CommandHistory_forth (I) {
iam (CommandHistory);
my current++;
}
static void _GuiGtkList_destroyCallback (gpointer void_me) {
iam (GuiList);
forget (me);
}
Any CommandHistory_getItem (I) {
iam (CommandHistory);
Melder_assert (my current > 0 && my current <= my size);
return my item[my current];
}
static double getVector (I, long irow, long icol) {
iam (FormantGrid);
RealTier tier = (structRealTier *)my formants -> item [irow];
return RealTier_getValueAtIndex (tier, icol);
}
int CommandHistory_offleft (I) {
iam (CommandHistory);
return my current == 0;
}
static double getFunction1 (I, long irow, double x) {
iam (FormantGrid);
RealTier tier = (structRealTier *)my formants -> item [irow];
return RealTier_getValueAtTime (tier, x);
}
static double getFunction2 (I, double x, double y) {
iam (Sound);
long channel = (long) floor (y);
if (channel < 0 || channel > my ny || y != (double) channel) return 0.0;
return our getFunction1 (me, channel, x);
}
static void _GuiGtkCheckButton_destroyCallback (GuiObject widget, gpointer void_me) {
(void) widget;
iam (GuiCheckButton);
Melder_free (me);
}
static void _guiGtkMenuItem_destroyCallback (GuiObject widget, gpointer void_me) {
(void) widget;
iam (GuiMenuItem);
trace (U"destroying GuiMenuItem ", Melder_pointer (me));
forget (me);
}
void Sampled_getMaximumAndX (I, double xmin, double xmax, long ilevel, int unit, int interpolate,
double *return_maximum, double *return_xOfMaximum)
{
iam (Sampled);
long imin, imax, i;
double maximum = -1e301, xOfMaximum = 0.0;
if (xmin == NUMundefined || xmax == NUMundefined) {
maximum = xOfMaximum = NUMundefined;
goto end;
}
Function_unidirectionalAutowindow (me, & xmin, & xmax);
if (! Function_intersectRangeWithDomain (me, & xmin, & xmax)) {
maximum = xOfMaximum = NUMundefined; /* Requested range and logical domain do not intersect. */
goto end;
}
if (! Sampled_getWindowSamples (me, xmin, xmax, & imin, & imax)) {
/*
* No sample centres between tmin and tmax.
* Try to return the greater of the values at these two points.
*/
double fleft = Sampled_getValueAtX (me, xmin, ilevel, unit, interpolate);
double fright = Sampled_getValueAtX (me, xmax, ilevel, unit, interpolate);
if (NUMdefined (fleft) && fleft > maximum) maximum = fleft, xOfMaximum = xmin;
if (NUMdefined (fright) && fright > maximum) maximum = fright, xOfMaximum = xmax;
} else {
for (i = imin; i <= imax; i ++) {
double fmid = our getValueAtSample (me, i, ilevel, unit);
if (fmid == NUMundefined) continue;
if (interpolate == FALSE) {
if (fmid > maximum) maximum = fmid, xOfMaximum = i;
} else {
/*
* Try an interpolation, possibly even taking into account a sample just outside the selection.
*/
double fleft = i <= 1 ? NUMundefined : our getValueAtSample (me, i - 1, ilevel, unit);
double fright = i >= my nx ? NUMundefined : our getValueAtSample (me, i + 1, ilevel, unit);
if (fleft == NUMundefined || fright == NUMundefined) {
if (fmid > maximum) maximum = fmid, xOfMaximum = i;
} else if (fmid > fleft && fmid >= fright) {
double y [4], i_real, localMaximum;
y [1] = fleft, y [2] = fmid, y [3] = fright;
localMaximum = NUMimproveMaximum (y, 3, 2, NUM_PEAK_INTERPOLATE_PARABOLIC, & i_real);
if (localMaximum > maximum)
maximum = localMaximum, xOfMaximum = i_real + i - 2;
}
}
}
xOfMaximum = my x1 + (xOfMaximum - 1) * my dx; /* From index plus phase to time. */
/* Check boundary values. */
if (interpolate) {
double fleft = Sampled_getValueAtX (me, xmin, ilevel, unit, TRUE);
double fright = Sampled_getValueAtX (me, xmax, ilevel, unit, TRUE);
if (NUMdefined (fleft) && fleft > maximum) maximum = fleft, xOfMaximum = xmin;
if (NUMdefined (fright) && fright > maximum) maximum = fright, xOfMaximum = xmax;
}
if (xOfMaximum < xmin) xOfMaximum = xmin;
if (xOfMaximum > xmax) xOfMaximum = xmax;
}
if (maximum == -1e301) maximum = xOfMaximum = NUMundefined;
end:
if (return_maximum) *return_maximum = maximum;
if (return_xOfMaximum) *return_xOfMaximum = xOfMaximum;
}
