void Matrix_drawSliceY (Matrix me, Graphics g, double x, double ymin, double ymax, double min, double max) {
if (x < my xmin || x > my xmax) {
return;
}
long ix = Matrix_xToNearestColumn (me, x);
if (ymax <= ymin) {
ymin = my ymin;
ymax = my ymax;
}
long iymin, iymax;
long ny = Matrix_getWindowSamplesY (me, ymin, ymax, &iymin, &iymax);
if (ny < 1) {
return;
}
if (max <= min) {
Matrix_getWindowExtrema (me, ix, ix, iymin, iymax, &min, &max);
}
if (max <= min) {
min -= 0.5; max += 0.5;
}
autoNUMvector<double> y (iymin, iymax);
Graphics_setWindow (g, ymin, ymax, min, max);
Graphics_setInner (g);
for (long i = iymin; i <= iymax; i++) {
y[i] = my z[i][ix];
}
Graphics_function (g, y.peek(), iymin, iymax, Matrix_rowToY (me, iymin), Matrix_rowToY (me, iymax));
Graphics_unsetInner (g);
}
void Matrix_scatterPlot (Matrix me, Graphics g, long icx, long icy, double xmin, double xmax, double ymin, double ymax, double size_mm, const char32 *mark, int garnish) {
long ix = labs (icx), iy = labs (icy);
if (ix < 1 || ix > my nx || iy < 1 || iy > my nx) {
return;
}
if (xmax <= xmin) {
(void) Matrix_getWindowExtrema (me, ix, ix, 1, my ny, & xmin, & xmax);
if (xmax <= xmin) {
xmin -= 0.5; xmax += 0.5;
}
}
if (ymax <= ymin) {
(void) Matrix_getWindowExtrema (me, iy, iy, 1, my ny, & ymin, & ymax);
if (ymax <= ymin) {
ymin -= 0.5; ymax += 0.5;
}
}
Graphics_setInner (g);
if (icx < 0) {
double t = xmin;
xmin = xmax;
xmax = t;
}
if (icy < 0) {
double t = ymin;
ymin = ymax;
ymax = t;
}
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
for (long i = 1; i <= my ny; i++) {
if (my z[i][ix] >= xmin && my z[i][ix] <= xmax && my z[i][iy] >= ymin && my z[i][iy] <= ymax) {
Graphics_mark (g, my z[i][ix], my z[i][iy], size_mm, mark);
}
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksLeft (g, 2, true, true, false);
if (ymin * ymax < 0.0) {
Graphics_markLeft (g, 0.0, true, true, true, nullptr);
}
Graphics_marksBottom (g, 2, true, true, false);
if (xmin * xmax < 0.0) {
Graphics_markBottom (g, 0.0, true, true, true, nullptr);
}
}
}
void FFNet_Pattern_Categories_learnSM (FFNet me, Pattern p, Categories c, long maxNumOfEpochs, double tolerance, int costFunctionType) {
_FFNet_Pattern_Categories_checkDimensions (me, p, c);
autoActivation activation = FFNet_Categories_to_Activation (me, c);
double min, max;
Matrix_getWindowExtrema (p, 0, 0, 0, 0, &min, &max);
FFNet_Pattern_Activation_learnSM (me, p, activation.peek(), maxNumOfEpochs, tolerance, costFunctionType);
}
void FilterBank_paint (FilterBank me, Graphics g, double xmin, double xmax, double ymin, double ymax, double minimum, double maximum, int garnish) {
if (xmax <= xmin) {
xmin = my xmin; xmax = my xmax;
}
if (ymax <= ymin) {
ymin = my ymin; ymax = my ymax;
}
long ixmin, ixmax, iymin, iymax;
(void) Matrix_getWindowSamplesX (me, xmin - 0.49999 * my dx, xmax + 0.49999 * my dx, &ixmin, &ixmax);
(void) Matrix_getWindowSamplesY (me, ymin - 0.49999 * my dy, ymax + 0.49999 * my dy, &iymin, &iymax);
if (maximum <= minimum) {
(void) Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, &minimum, &maximum);
}
if (maximum <= minimum) {
minimum -= 1.0; maximum += 1.0;
}
if (xmin >= xmax || ymin >= ymax) {
return;
}
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
Graphics_image (g, my z,
ixmin, ixmax, Sampled_indexToX (me, ixmin - 0.5), Sampled_indexToX (me, ixmax + 0.5),
iymin, iymax, SampledXY_indexToY (me, iymin - 0.5), SampledXY_indexToY (me, iymax + 0.5),
minimum, maximum);
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksLeft (g, 2, 1, 1, 0);
Graphics_textLeft (g, 1, GetFreqScaleText (my v_getFrequencyScale ()));
Graphics_marksBottom (g, 2, 1, 1, 0);
Graphics_textBottom (g, 1, U"Time (s)");
}
}
static void cellArrayOrImage (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax,
double minimum, double maximum, bool interpolate)
{
if (xmax <= xmin) { xmin = my xmin; xmax = my xmax; }
if (ymax <= ymin) { ymin = my ymin; ymax = my ymax; }
long ixmin, ixmax, iymin, iymax;
(void) Matrix_getWindowSamplesX (me, xmin - 0.49999 * my dx, xmax + 0.49999 * my dx,
& ixmin, & ixmax);
(void) Matrix_getWindowSamplesY (me, ymin - 0.49999 * my dy, ymax + 0.49999 * my dy,
& iymin, & iymax);
if (maximum <= minimum)
(void) Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, & minimum, & maximum);
if (maximum <= minimum) { minimum -= 1.0; maximum += 1.0; }
if (xmin >= xmax || ymin >= ymax) return;
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
if (interpolate)
Graphics_image (g, my z,
ixmin, ixmax, Sampled_indexToX (me, ixmin - 0.5), Sampled_indexToX (me, ixmax + 0.5),
iymin, iymax, SampledXY_indexToY (me, iymin - 0.5), SampledXY_indexToY (me, iymax + 0.5),
minimum, maximum);
else
Graphics_cellArray (g, my z,
ixmin, ixmax, Sampled_indexToX (me, ixmin - 0.5), Sampled_indexToX (me, ixmax + 0.5),
iymin, iymax, SampledXY_indexToY (me, iymin - 0.5), SampledXY_indexToY (me, iymax + 0.5),
minimum, maximum);
Graphics_rectangle (g, xmin, xmax, ymin, ymax);
Graphics_unsetInner (g);
}
void SoundEditor::dataChanged () {
Sound sound = (Sound) _data;
Melder_assert (sound != NULL); /* LongSound objects should not get dataChanged messages. */
Matrix_getWindowExtrema (sound, 1, sound -> nx, 1, sound -> ny, & _sound.minimum, & _sound.maximum);
destroy_analysis ();
TimeSoundAnalysisEditor::dataChanged ();
}
void structSoundEditor :: v_dataChanged () {
Sound sound = (Sound) data;
Melder_assert (sound); // LongSound objects should not get v_dataChanged messages
Matrix_getWindowExtrema (sound, 1, sound -> nx, 1, sound -> ny, & d_sound.minimum, & d_sound.maximum); // BUG unreadable
v_reset_analysis ();
SoundEditor_Parent :: v_dataChanged ();
}
void Pattern_normalize (Pattern me, int choice, double pmin, double pmax) {
if (pmin == pmax) {
(void) Matrix_getWindowExtrema (me, 1, my nx, 1, my ny, & pmin, & pmax);
}
if (pmin == pmax) {
return;
}
if (choice == 1) {
for (long i = 1; i <= my ny; i++) {
for (long j = 1; j <= my nx; j++) {
my z[i][j] = (my z[i][j] - pmin) / (pmax - pmin);
}
}
} else { /* default choice */
for (long i = 1; i <= my ny; i++) {
double sum = 0;
for (long j = 1; j <= my nx; j++) {
sum += (my z[i][j] -= pmin);
}
for (long j = 1; j <= my nx; j++) {
my z[i][j] *= 1.0 / sum;
}
}
}
}
static void _FFNet_Pattern_Categories_learn (FFNet me, Pattern p, Categories c, long maxNumOfEpochs, double tolerance, Any parameters, int costFunctionType, void (*learn) (FFNet, Pattern, Activation, long, double, Any, int)) {
_FFNet_Pattern_Categories_checkDimensions (me, p, c);
autoActivation activation = FFNet_Categories_to_Activation (me, c);
double min, max;
Matrix_getWindowExtrema (p, 0, 0, 0, 0, &min, &max);
learn (me, p, activation.peek(), maxNumOfEpochs, tolerance, parameters, costFunctionType);
}
void structPointEditor :: v_draw () {
PointProcess point = (PointProcess) data;
Sound sound = d_sound.data;
Graphics_setColour (d_graphics, Graphics_WHITE);
Graphics_setWindow (d_graphics, 0, 1, 0, 1);
Graphics_fillRectangle (d_graphics, 0, 1, 0, 1);
double minimum = -1.0, maximum = +1.0;
if (sound != NULL && (d_sound.scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW || d_sound.scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW_AND_CHANNEL)) {
long first, last;
if (Sampled_getWindowSamples (sound, d_startWindow, d_endWindow, & first, & last) >= 1) {
Matrix_getWindowExtrema (sound, first, last, 1, 1, & minimum, & maximum);
}
}
Graphics_setWindow (d_graphics, d_startWindow, d_endWindow, minimum, maximum);
Graphics_setColour (d_graphics, Graphics_BLACK);
if (sound != NULL) {
long first, last;
if (Sampled_getWindowSamples (sound, d_startWindow, d_endWindow, & first, & last) > 1) {
Graphics_setLineType (d_graphics, Graphics_DOTTED);
Graphics_line (d_graphics, d_startWindow, 0.0, d_endWindow, 0.0);
Graphics_setLineType (d_graphics, Graphics_DRAWN);
Graphics_function (d_graphics, sound -> z [1], first, last,
Sampled_indexToX (sound, first), Sampled_indexToX (sound, last));
}
}
Graphics_setColour (d_graphics, Graphics_BLUE);
Graphics_setWindow (d_graphics, d_startWindow, d_endWindow, -1.0, +1.0);
for (long i = 1; i <= point -> nt; i ++) {
double t = point -> t [i];
if (t >= d_startWindow && t <= d_endWindow)
Graphics_line (d_graphics, t, -0.9, t, +0.9);
}
Graphics_setColour (d_graphics, Graphics_BLACK);
v_updateMenuItems_file ();
}
int SoundEditor::menu_cb_Paste (EDITOR_ARGS) {
SoundEditor *editor = (SoundEditor *)editor_me;
Sound sound = (Sound) editor->_data;
long leftSample = Sampled_xToLowIndex (sound, editor->_endSelection);
long oldNumberOfSamples = sound -> nx, newNumberOfSamples;
double **newData, **oldData = sound -> z;
if (! Sound_clipboard) {
Melder_warning1 (L"(SoundEditor_paste:) Clipboard is empty; nothing pasted.");
return 1;
}
if (Sound_clipboard -> ny != sound -> ny)
return Melder_error1 (L"(SoundEditor_paste:) Cannot paste because\n"
"the number of channels of the clipboard is not equal to\n"
"the number of channels of the edited sound.");
if (Sound_clipboard -> dx != sound -> dx)
return Melder_error1 (L"(SoundEditor_paste:) Cannot paste because\n"
"the sampling frequency of the clipboard is not equal to\n"
"the sampling frequency of the edited sound.");
if (leftSample < 0) leftSample = 0;
if (leftSample > oldNumberOfSamples) leftSample = oldNumberOfSamples;
newNumberOfSamples = oldNumberOfSamples + Sound_clipboard -> nx;
if (! (newData = NUMdmatrix (1, sound -> ny, 1, newNumberOfSamples))) return 0;
for (long channel = 1; channel <= sound -> ny; channel ++) {
long j = 0;
for (long i = 1; i <= leftSample; i ++) {
newData [channel] [++ j] = oldData [channel] [i];
}
for (long i = 1; i <= Sound_clipboard -> nx; i ++) {
newData [channel] [++ j] = Sound_clipboard -> z [channel] [i];
}
for (long i = leftSample + 1; i <= oldNumberOfSamples; i ++) {
newData [channel] [++ j] = oldData [channel] [i];
}
}
editor->save (L"Paste");
NUMdmatrix_free (oldData, 1, 1);
sound -> xmin = 0.0;
sound -> xmax = newNumberOfSamples * sound -> dx;
sound -> nx = newNumberOfSamples;
sound -> x1 = 0.5 * sound -> dx;
sound -> z = newData;
/* Start updating the markers of the FunctionEditor, respecting the invariants. */
editor->_tmin = sound -> xmin;
editor->_tmax = sound -> xmax;
editor->_startSelection = leftSample * sound -> dx;
editor->_endSelection = (leftSample + Sound_clipboard -> nx) * sound -> dx;
/* Force FunctionEditor to show changes. */
Matrix_getWindowExtrema (sound, 1, sound -> nx, 1, sound -> ny, & editor->_sound.minimum, & editor->_sound.maximum);
editor->destroy_analysis ();
editor->ungroup ();
editor->marksChanged ();
editor->broadcastChange ();
return 1;
}
void Matrix_scale (Matrix me, int choice) {
double min, max, extremum;
long nZero = 0;
if (choice == 2) { /* by row */
for (long i = 1; i <= my ny; i++) {
Matrix_getWindowExtrema (me, 1, my nx, i, i, &min, &max);
extremum = fabs (max) > fabs (min) ? fabs (max) : fabs (min);
if (extremum == 0.0) {
nZero++;
} else for (long j = 1; j <= my nx; j++) {
my z[i][j] /= extremum;
}
}
} else if (choice == 3) { /* by col */
for (long j = 1; j <= my nx; j++) {
Matrix_getWindowExtrema (me, j, j, 1, my ny, &min, &max);
extremum = fabs (max) > fabs (min) ? fabs (max) : fabs (min);
if (extremum == 0.0) {
nZero++;
} else for (long i = 1; i <= my ny; i++) {
my z[i][j] /= extremum;
}
}
} else if (choice == 1) { /* overall */
Matrix_getWindowExtrema (me, 1, my nx, 1, my ny, &min, &max);
extremum = fabs (max) > fabs (min) ? fabs (max) : fabs (min);
if (extremum == 0.0) {
nZero++;
} else {
for (long i = 1; i <= my ny; i++) {
for (long j = 1; j <= my nx; j++) {
my z[i][j] /= extremum;
}
}
}
} else {
Melder_flushError (U"Matrix_scale: choice must be > 0 && <= 3.");
return;
}
if (nZero) {
Melder_warning (U"Matrix_scale: extremum == 0, (part of) matrix unscaled.");
}
}
void TimeSoundEditor_init (TimeSoundEditor me, const char32 *title, Function data, Sampled sound, bool ownSound) {
my d_ownSound = ownSound;
if (sound) {
if (ownSound) {
Melder_assert (Thing_isa (sound, classSound));
my d_sound.data = Data_copy ((Sound) sound).releaseToAmbiguousOwner(); // deep copy; ownership transferred
Matrix_getWindowExtrema (my d_sound.data, 1, my d_sound.data -> nx, 1, my d_sound.data -> ny, & my d_sound.minimum, & my d_sound.maximum);
} else if (Thing_isa (sound, classSound)) {
my d_sound.data = (Sound) sound; // reference copy; ownership not transferred
Matrix_getWindowExtrema (my d_sound.data, 1, my d_sound.data -> nx, 1, my d_sound.data -> ny, & my d_sound.minimum, & my d_sound.maximum);
} else if (Thing_isa (sound, classLongSound)) {
my d_longSound.data = (LongSound) sound;
my d_sound.minimum = -1.0, my d_sound.maximum = 1.0;
} else {
Melder_fatal (U"Invalid sound class in TimeSoundEditor::init.");
}
}
FunctionEditor_init (me, title, data);
}
void Intensity_drawInside (Intensity me, Graphics g, double tmin, double tmax, double minimum, double maximum) {
if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; } // autowindow
long itmin, itmax;
Matrix_getWindowSamplesX (me, tmin, tmax, & itmin, & itmax);
if (maximum <= minimum)
Matrix_getWindowExtrema (me, itmin, itmax, 1, 1, & minimum, & maximum); // autoscale
if (maximum <= minimum) { minimum -= 10; maximum += 10; }
Graphics_setWindow (g, tmin, tmax, minimum, maximum);
Graphics_function (g, my z [1], itmin, itmax, Matrix_columnToX (me, itmin), Matrix_columnToX (me, itmax));
}
void ParamCurve_draw (ParamCurve me, Graphics g, double t1, double t2, double dt,
double x1, double x2, double y1, double y2, int garnish)
{
if (t2 <= t1) {
double tx1 = my x -> x1;
double ty1 = my y -> x1;
double tx2 = my x -> x1 + (my x -> nx - 1) * my x -> dx;
double ty2 = my y -> x1 + (my y -> nx - 1) * my y -> dx;
t1 = tx1 > ty1 ? tx1 : ty1;
t2 = tx2 < ty2 ? tx2 : ty2;
}
if (x2 <= x1) Matrix_getWindowExtrema (my x, 0, 0, 1, 1, & x1, & x2);
if (x1 == x2) { x1 -= 1.0; x2 += 1.0; }
if (y2 <= y1) Matrix_getWindowExtrema (my y, 0, 0, 1, 1, & y1, & y2);
if (y1 == y2) { y1 -= 1.0; y2 += 1.0; }
if (dt <= 0.0)
dt = my x -> dx < my y -> dx ? my x -> dx : my y -> dx;
long numberOfPoints = (long) ceil ((t2 - t1) / dt) + 1;
if (numberOfPoints > 0) {
autoNUMvector <double> x (1, numberOfPoints);
autoNUMvector <double> y (1, numberOfPoints);
for (long i = 1; i <= numberOfPoints; i ++) {
double t = i == numberOfPoints ? t2 : t1 + (i - 1) * dt;
double index = my x -> f_xToIndex (t);
x [i] = NUM_interpolate_sinc (my x -> z [1], my x -> nx, index, 50);
index = my y -> f_xToIndex (t);
y [i] = NUM_interpolate_sinc (my y -> z [1], my y -> nx, index, 50);
}
Graphics_setWindow (g, x1, x2, y1, y2);
Graphics_setInner (g);
Graphics_polyline (g, numberOfPoints, & x [1], & y [1]);
Graphics_unsetInner (g);
}
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksBottom (g, 2, 1, 1, 0);
Graphics_marksLeft (g, 2, 1, 1, 0);
}
}
void Matrix_drawAsSquares (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax, int garnish) {
Graphics_Colour colour = Graphics_inqColour (g);
long ixmin, ixmax, iymin, iymax;
if (xmax <= xmin) {
xmin = my xmin;
xmax = my xmax;
}
long nx = Matrix_getWindowSamplesX (me, xmin, xmax, &ixmin, &ixmax);
if (ymax <= ymin) {
ymin = my ymin;
ymax = my ymax;
}
long ny = Matrix_getWindowSamplesY (me, ymin, ymax, &iymin, &iymax);
double min, max = nx > ny ? nx : ny;
double dx = (xmax - xmin) / max, dy = (ymax - ymin) / max;
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, & min, & max);
double wAbsMax = fabs (max) > fabs (min) ? fabs (max) : fabs (min);
for (long i = iymin; i <= iymax; i++) {
double y = Matrix_rowToY (me, i);
for (long j = ixmin; j <= ixmax; j++) {
double x = Matrix_columnToX (me, j);
double d = 0.95 * sqrt (fabs (my z[i][j]) / wAbsMax);
if (d > 0) {
double x1WC = x - d * dx / 2, x2WC = x + d * dx / 2;
double y1WC = y - d * dy / 2, y2WC = y + d * dy / 2;
if (my z[i][j] > 0) {
Graphics_setColour (g, Graphics_WHITE);
}
Graphics_fillRectangle (g, x1WC, x2WC, y1WC, y2WC);
Graphics_setColour (g, colour);
Graphics_rectangle (g, x1WC, x2WC , y1WC, y2WC);
}
}
}
Graphics_setGrey (g, 0.0);
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksLeft (g, 2, true, true, false);
if (ymin * ymax < 0.0) {
Graphics_markLeft (g, 0.0, true, true, true, nullptr);
}
Graphics_marksBottom (g, 2, true, true, false);
if (xmin * xmax < 0.0) {
Graphics_markBottom (g, 0.0, true, true, true, nullptr);
}
}
}
void Matrix_movie (Matrix me, Graphics g) {
autoNUMvector <double> column (1, my ny);
double minimum = 0.0, maximum = 1.0;
Matrix_getWindowExtrema (me, 1, my nx, 1, my ny, & minimum, & maximum);
for (long icol = 1; icol <= my nx; icol ++) {
for (long irow = 1; irow <= my ny; irow ++) {
column [irow] = my z [irow] [icol];
}
Graphics_beginMovieFrame (g, & Graphics_WHITE);
Graphics_setWindow (g, my ymin, my ymax, minimum, maximum);
Graphics_function (g, column.peek(), 1, my ny, my ymin, my ymax);
Graphics_endMovieFrame (g, 0.03);
}
}
void ERP_drawChannel_number (ERP me, Graphics graphics, long channelNumber, double tmin, double tmax, double vmin, double vmax, bool garnish) {
if (channelNumber < 1 || channelNumber > my ny) return;
/*
* Automatic domain.
*/
if (tmin == tmax) {
tmin = my xmin;
tmax = my xmax;
}
/*
* Domain expressed in sample numbers.
*/
long ixmin, ixmax;
Matrix_getWindowSamplesX (me, tmin, tmax, & ixmin, & ixmax);
/*
* Automatic vertical range.
*/
if (vmin == vmax) {
Matrix_getWindowExtrema (me, ixmin, ixmax, channelNumber, channelNumber, & vmin, & vmax);
if (vmin == vmax) {
vmin -= 1.0;
vmax += 1.0;
}
}
/*
* Set coordinates for drawing.
*/
Graphics_setInner (graphics);
Graphics_setWindow (graphics, tmin, tmax, vmin, vmax);
Graphics_function (graphics, my z [channelNumber], ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax));
Graphics_unsetInner (graphics);
if (garnish) {
Graphics_drawInnerBox (graphics);
Graphics_textTop (graphics, true, Melder_wcscat (L"Channel ", my channelNames [channelNumber]));
Graphics_textBottom (graphics, true, L"Time (s)");
Graphics_marksBottom (graphics, 2, true, true, false);
if (0.0 > tmin && 0.0 < tmax)
Graphics_markBottom (graphics, 0.0, true, true, true, NULL);
Graphics_markLeft (graphics, vmin, true, true, false, NULL);
Graphics_markLeft (graphics, vmax, true, true, false, NULL);
Graphics_markBottom (graphics, 0.0, true, true, true, NULL);
if (vmin != 0.0 && vmax != 0.0 && (vmin > 0.0) != (vmax > 0.0)) {
Graphics_markLeft (graphics, 0.0, true, true, true, NULL);
}
}
}
void structMatrix :: v_info () {
structDaata :: v_info ();
double minimum = 0.0, maximum = 0.0;
Matrix_getWindowExtrema (this, 1, our nx, 1, our ny, & minimum, & maximum);
MelderInfo_writeLine (U"xmin: ", our xmin);
MelderInfo_writeLine (U"xmax: ", our xmax);
MelderInfo_writeLine (U"Number of columns: ", our nx);
MelderInfo_writeLine (U"dx: ", our dx, U" (-> sampling rate ", 1.0 / our dx, U" )");
MelderInfo_writeLine (U"x1: ", our x1);
MelderInfo_writeLine (U"ymin: ", our ymin);
MelderInfo_writeLine (U"ymax: ", our ymax);
MelderInfo_writeLine (U"Number of rows: ", our ny);
MelderInfo_writeLine (U"dy: ", our dy, U" (-> sampling rate ", 1.0 / our dy, U" )");
MelderInfo_writeLine (U"y1: ", our y1);
MelderInfo_writeLine (U"Minimum value: ", minimum);
MelderInfo_writeLine (U"Maximum value: ", maximum);
}
void Matrix_paintSurface (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax,
double minimum, double maximum, double elevation, double azimuth)
{
if (xmax <= xmin) { xmin = my xmin; xmax = my xmax; }
if (ymax <= ymin) { ymin = my ymin; ymax = my ymax; }
long ixmin, ixmax, iymin, iymax;
(void) Matrix_getWindowSamplesX (me, xmin, xmax, & ixmin, & ixmax);
(void) Matrix_getWindowSamplesY (me, ymin, ymax, & iymin, & iymax);
if (maximum <= minimum)
(void) Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, & minimum, & maximum);
if (maximum <= minimum) { minimum -= 1.0; maximum += 1.0; }
Graphics_setInner (g);
Graphics_setWindow (g, -1.0, 1.0, minimum, maximum);
Graphics_surface (g, my z,
ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax),
iymin, iymax, Matrix_rowToY (me, iymin), Matrix_rowToY (me, iymax),
minimum, maximum, elevation, azimuth);
Graphics_unsetInner (g);
}
void Pattern_normalize (I, int choice, double pmin, double pmax)
{
iam (Pattern); long i, j;
if (pmin == pmax) (void) Matrix_getWindowExtrema (me, 1, my nx, 1, my ny, & pmin, & pmax);
if (pmin == pmax) return;
if (choice == 1)
{
for (i=1; i <= my ny; i++) for (j=1; j <= my nx; j++)
my z[i][j] = ( my z[i][j] - pmin) / ( pmax - pmin);
}
else /* default choice */
{
for (i=1; i <= my ny; i++)
{
double sum = 0;
for (j=1; j <= my nx; j++) sum += ( my z[i][j] -= pmin);
for (j=1; j <= my nx; j++) my z[i][j] *= 1.0 / sum;
}
}
}
void Pitch_Intensity_draw (Pitch pitch, Intensity intensity, Graphics g,
double f1, double f2, double s1, double s2, int garnish, int connect)
{
if (f2 <= f1) Pitch_getExtrema (pitch, & f1, & f2);
if (f1 == 0.0) return; /* All voiceless. */
if (f1 == f2) { f1 -= 1.0; f2 += 1.0; }
if (s2 <= s1) Matrix_getWindowExtrema (intensity, 0, 0, 1, 1, & s1, & s2);
if (s1 == s2) { s1 -= 1.0; s2 += 1.0; }
Graphics_setWindow (g, f1, f2, s1, s2);
Graphics_setInner (g);
long previousI = 0;
double previousX = NUMundefined, previousY = NUMundefined;
for (long i = 1; i <= pitch -> nx; i ++) {
double t = Sampled_indexToX (pitch, i);
double x = pitch -> frame [i]. candidate [1]. frequency;
double y = Sampled_getValueAtX (intensity, t, Pitch_LEVEL_FREQUENCY, kPitch_unit_HERTZ, TRUE);
if (x == 0) {
continue; /* Voiceless. */
}
if (connect & 1) Graphics_speckle (g, x, y);
if ((connect & 2) && NUMdefined (previousX)) {
if (previousI >= 1 && previousI < i - 1) {
Graphics_setLineType (g, Graphics_DOTTED);
}
Graphics_line (g, previousX, previousY, x, y);
Graphics_setLineType (g, Graphics_DRAWN);
}
previousX = x;
previousY = y;
previousI = i;
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, 1, L"Fundamental frequency (Hz)");
Graphics_marksBottom (g, 2, 1, 1, 0);
Graphics_textLeft (g, 1, L"Intensity (dB)");
Graphics_marksLeft (g, 2, 1, 1, 0);
}
}
void Excitation_draw (Excitation me, Graphics g,
double fmin, double fmax, double minimum, double maximum, int garnish)
{
if (fmax <= fmin) { fmin = my xmin; fmax = my xmax; }
long ifmin, ifmax;
Matrix_getWindowSamplesX (me, fmin, fmax, & ifmin, & ifmax);
if (maximum <= minimum)
Matrix_getWindowExtrema (me, ifmin, ifmax, 1, 1, & minimum, & maximum);
if (maximum <= minimum) { minimum -= 20; maximum += 20; }
Graphics_setInner (g);
Graphics_setWindow (g, fmin, fmax, minimum, maximum);
Graphics_function (g, my z [1], ifmin, ifmax,
Matrix_columnToX (me, ifmin), Matrix_columnToX (me, ifmax));
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, 1, L"Frequency (Bark)");
Graphics_textLeft (g, 1, L"Excitation (phon)");
Graphics_marksBottomEvery (g, 1, 5, 1, 1, 0);
Graphics_marksLeftEvery (g, 1, 20, 1, 1, 0);
}
}
void BandFilterSpectrogram_paintImage (BandFilterSpectrogram me, Graphics g, double xmin, double xmax, double ymin, double ymax, double minimum, double maximum, int garnish) {
if (xmax <= xmin) {
xmin = my xmin; xmax = my xmax;
}
if (ymax <= ymin) {
ymin = my ymin; ymax = my ymax;
}
long ixmin, ixmax, iymin, iymax;
(void) Matrix_getWindowSamplesX (me, xmin - 0.49999 * my dx, xmax + 0.49999 * my dx, &ixmin, &ixmax);
(void) Matrix_getWindowSamplesY (me, ymin - 0.49999 * my dy, ymax + 0.49999 * my dy, &iymin, &iymax);
autoMatrix thee = Spectrogram_to_Matrix_dB ((Spectrogram) me, 4e-10, 10, -100);
if (maximum <= minimum) {
(void) Matrix_getWindowExtrema (thee.peek(), ixmin, ixmax, iymin, iymax, &minimum, &maximum);
}
if (maximum <= minimum) {
minimum -= 1.0; maximum += 1.0;
}
if (xmin >= xmax || ymin >= ymax) {
return;
}
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
Graphics_image (g, thy z,
ixmin, ixmax, Sampled_indexToX (thee.peek(), ixmin - 0.5), Sampled_indexToX (thee.peek(), ixmax + 0.5),
iymin, iymax, SampledXY_indexToY (thee.peek(), iymin - 0.5), SampledXY_indexToY (thee.peek(), iymax + 0.5),
minimum, maximum);
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksLeft (g, 2, 1, 1, 0);
Graphics_textLeft (g, 1, Melder_cat (U"Frequency (", my v_getFrequencyUnit (), U")"));
Graphics_marksBottom (g, 2, 1, 1, 0);
Graphics_textBottom (g, 1, U"Time (s)");
}
}
void Matrix_drawRows (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax,
double minimum, double maximum)
{
if (xmax <= xmin) { xmin = my xmin; xmax = my xmax; }
if (ymax <= ymin) { ymin = my ymin; ymax = my ymax; }
long ixmin, ixmax, iymin, iymax;
(void) Matrix_getWindowSamplesX (me, xmin, xmax, & ixmin, & ixmax);
(void) Matrix_getWindowSamplesY (me, ymin, ymax, & iymin, & iymax);
if (maximum <= minimum)
(void) Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, & minimum, & maximum);
if (maximum <= minimum) { minimum -= 1.0; maximum += 1.0; }
if (xmin >= xmax) return;
Graphics_setInner (g);
for (long iy = iymin; iy <= iymax; iy ++) {
Graphics_setWindow (g, xmin, xmax,
minimum - (iy - iymin) * (maximum - minimum),
maximum + (iymax - iy) * (maximum - minimum));
Graphics_function (g, my z [iy], ixmin, ixmax,
Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax));
}
Graphics_unsetInner (g);
if (iymin < iymax)
Graphics_setWindow (g, xmin, xmax, my y1 + (iymin - 1.5) * my dy, my y1 + (iymax - 0.5) * my dy);
}
void Matrix_paintContours (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax,
double minimum, double maximum)
{
double border [1 + 30];
if (xmax <= xmin) { xmin = my xmin; xmax = my xmax; }
if (ymax <= ymin) { ymin = my ymin; ymax = my ymax; }
long ixmin, ixmax, iymin, iymax, iborder;
(void) Matrix_getWindowSamplesX (me, xmin, xmax, & ixmin, & ixmax);
(void) Matrix_getWindowSamplesY (me, ymin, ymax, & iymin, & iymax);
if (maximum <= minimum)
(void) Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, & minimum, & maximum);
if (maximum <= minimum) { minimum -= 1.0; maximum += 1.0; }
for (iborder = 1; iborder <= 30; iborder ++)
border [iborder] = minimum + iborder * (maximum - minimum) / (30 + 1);
if (xmin >= xmax || ymin >= ymax) return;
Graphics_setInner (g);
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
Graphics_grey (g, my z,
ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax),
iymin, iymax, Matrix_rowToY (me, iymin), Matrix_rowToY (me, iymax),
30, border);
Graphics_rectangle (g, xmin, xmax, ymin, ymax);
Graphics_unsetInner (g);
}
void structPointEditor :: v_draw () {
PointProcess point = static_cast <PointProcess> (our data);
Sound sound = d_sound.data;
Graphics_setColour (our graphics.get(), Graphics_WHITE);
Graphics_setWindow (our graphics.get(), 0.0, 1.0, 0.0, 1.0);
Graphics_fillRectangle (our graphics.get(), 0.0, 1.0, 0.0, 1.0);
double minimum = -1.0, maximum = +1.0;
if (sound && (p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW || p_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_BY_WINDOW_AND_CHANNEL)) {
long first, last;
if (Sampled_getWindowSamples (sound, our startWindow, our endWindow, & first, & last) >= 1) {
Matrix_getWindowExtrema (sound, first, last, 1, 1, & minimum, & maximum);
if (minimum == maximum) minimum -= 1.0, maximum += 1.0;
}
}
Graphics_setWindow (our graphics.get(), our startWindow, our endWindow, minimum, maximum);
Graphics_setColour (our graphics.get(), Graphics_BLACK);
if (sound) {
long first, last;
if (Sampled_getWindowSamples (sound, our startWindow, our endWindow, & first, & last) > 1) {
Graphics_setLineType (our graphics.get(), Graphics_DOTTED);
Graphics_line (our graphics.get(), our startWindow, 0.0, our endWindow, 0.0);
Graphics_setLineType (our graphics.get(), Graphics_DRAWN);
Graphics_function (our graphics.get(), sound -> z [1], first, last,
Sampled_indexToX (sound, first), Sampled_indexToX (sound, last));
}
}
Graphics_setColour (our graphics.get(), Graphics_BLUE);
Graphics_setWindow (our graphics.get(), our startWindow, our endWindow, -1.0, +1.0);
for (long i = 1; i <= point -> nt; i ++) {
double t = point -> t [i];
if (t >= our startWindow && t <= our endWindow)
Graphics_line (our graphics.get(), t, -0.9, t, +0.9);
}
Graphics_setColour (our graphics.get(), Graphics_BLACK);
v_updateMenuItems_file ();
}
void Confusion_Matrix_draw (Confusion me, Matrix thee, Graphics g, long index, double lowerPercentage, double xmin, double xmax, double ymin, double ymax, int garnish) {
long ib = 1, ie = my numberOfRows;
if (index > 0 && index <= my numberOfColumns) {
ib = ie = index;
}
if (thy ny != my numberOfRows) {
Melder_throw (U"Wrong number of positions.");
}
if (xmax <= xmin) {
(void) Matrix_getWindowExtrema (thee, 1, 1, 1, thy ny, &xmin, &xmax);
}
if (xmax <= xmin) {
return;
}
if (ymax <= ymin) {
(void) Matrix_getWindowExtrema (thee, 2, 2, 1, thy ny, &ymin, &ymax);
}
if (ymax <= ymin) {
return;
}
double rmax = fabs (xmax - xmin) / 10.0;
double rmin = rmax / 10;
Graphics_setInner (g);
Graphics_setWindow (g, xmin - rmax, xmax + rmax, ymin - rmax, ymax + rmax);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
for (long i = 1; i <= my numberOfRows; i++) {
Graphics_text (g, thy z[i][1], thy z[i][2], my rowLabels[i]);
}
for (long i = ib; i <= ie; i++) {
double xSum = 0.0;
for (long j = 1; j <= my numberOfColumns; j++) {
xSum += my data[i][j];
}
if (xSum <= 0.0) {
continue; /* no confusions */
}
double x1 = thy z[i][1];
double y1 = thy z[i][2];
double r = rmax * my data[i][i] / xSum;
Graphics_circle (g, x1, y1, r > rmin ? r : rmin);
for (long j = 1; j <= my numberOfColumns; j++) {
double x2 = thy z[j][1], y2 = thy z[j][2];
double perc = 100.0 * my data[i][j] / xSum;
double dx = x2 - x1, dy = y2 - y1;
double alpha = atan2 (dy, dx);
if (perc == 0.0 || perc < lowerPercentage || j == i) {
continue;
}
xmin = x1; xmax = x2;
if (x2 < x1) {
xmin = x2; xmax = x1;
}
ymin = y1; xmax = y2;
if (y2 < y1) {
ymin = y2; ymax = y1;
}
autoPolygon p = Polygon_createPointer();
double xs = sqrt (dx * dx + dy * dy) - 2.2 * r;
if (xs < 0.0) {
xs = 0.0;
}
double ys = perc * rmax / 100.0;
Polygon_scale (p.get(), xs, ys);
Polygon_translate (p.get(), x1, y1 - ys / 2);
Polygon_rotate (p.get(), alpha, x1, y1);
Polygon_translate (p.get(), 1.1 * r * cos (alpha), 1.1 * r * sin (alpha));
Polygon_drawInside (p.get(), g);
}
}
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksBottom (g, 2, true, true, false);
if (ymin * ymax < 0.0) {
Graphics_markLeft (g, 0.0, true, true, true, nullptr);
}
Graphics_marksLeft (g, 2, true, true, false);
if (xmin * xmax < 0.0) {
Graphics_markBottom (g, 0.0, true, true, true, nullptr);
}
}
}
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);
}
static void menu_cb_Cut (SoundEditor me, EDITOR_ARGS_DIRECT) {
try {
Sound sound = (Sound) my data;
long first, last, selectionNumberOfSamples = Sampled_getWindowSamples (sound,
my d_startSelection, my d_endSelection, & first, & last);
long oldNumberOfSamples = sound -> nx;
long newNumberOfSamples = oldNumberOfSamples - selectionNumberOfSamples;
if (newNumberOfSamples < 1)
Melder_throw (U"You cannot cut all of the signal away,\n"
U"because you cannot create a Sound with 0 samples.\n"
U"You could consider using Copy instead.");
if (selectionNumberOfSamples) {
double **oldData = sound -> z;
/*
* Create without change.
*/
autoSound publish = Sound_create (sound -> ny, 0.0, selectionNumberOfSamples * sound -> dx,
selectionNumberOfSamples, sound -> dx, 0.5 * sound -> dx);
for (long channel = 1; channel <= sound -> ny; channel ++) {
long j = 0;
for (long i = first; i <= last; i ++) {
publish -> z [channel] [++ j] = oldData [channel] [i];
}
}
autoNUMmatrix <double> newData (1, sound -> ny, 1, newNumberOfSamples);
for (long channel = 1; channel <= sound -> ny; channel ++) {
long j = 0;
for (long i = 1; i < first; i ++) {
newData [channel] [++ j] = oldData [channel] [i];
}
for (long i = last + 1; i <= oldNumberOfSamples; i ++) {
newData [channel] [++ j] = oldData [channel] [i];
}
}
Editor_save (me, U"Cut");
/*
* Change without error.
*/
NUMmatrix_free <double> (oldData, 1, 1);
sound -> xmin = 0.0;
sound -> xmax = newNumberOfSamples * sound -> dx;
sound -> nx = newNumberOfSamples;
sound -> x1 = 0.5 * sound -> dx;
sound -> z = newData.transfer();
Sound_clipboard = publish.move();
/* Start updating the markers of the FunctionEditor, respecting the invariants. */
my tmin = sound -> xmin;
my tmax = sound -> xmax;
/* Collapse the selection, */
/* so that the Cut operation can immediately be undone by a Paste. */
/* The exact position will be half-way in between two samples. */
my d_startSelection = my d_endSelection = sound -> xmin + (first - 1) * sound -> dx;
/* Update the window. */
{
double t1 = (first - 1) * sound -> dx;
double t2 = last * sound -> dx;
double windowLength = my d_endWindow - my d_startWindow; // > 0
if (t1 > my d_startWindow)
if (t2 < my d_endWindow)
my d_startWindow -= 0.5 * (t2 - t1);
else
(void) 0;
else if (t2 < my d_endWindow)
my d_startWindow -= t2 - t1;
else /* Cut overlaps entire window: centre. */
my d_startWindow = my d_startSelection - 0.5 * windowLength;
my d_endWindow = my d_startWindow + windowLength; // first try
if (my d_endWindow > my tmax) {
my d_startWindow -= my d_endWindow - my tmax; // second try
if (my d_startWindow < my tmin)
my d_startWindow = my tmin; // third try
my d_endWindow = my tmax; // second try
} else if (my d_startWindow < my tmin) {
my d_endWindow -= my d_startWindow - my tmin; // second try
if (my d_endWindow > my tmax)
my d_endWindow = my tmax; // third try
my d_startWindow = my tmin; // second try
}
}
/* Force FunctionEditor to show changes. */
Matrix_getWindowExtrema (sound, 1, sound -> nx, 1, sound -> ny, & my d_sound.minimum, & my d_sound.maximum);
my v_reset_analysis ();
FunctionEditor_ungroup (me);
FunctionEditor_marksChanged (me, false);
Editor_broadcastDataChanged (me);
} else {
Melder_warning (U"No samples selected.");
}
} catch (MelderError) {
Melder_throw (U"Sound selection not cut to clipboard.");
}
}
