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 ();
}
static void drawControlButton (RunnerMFC me, double left, double right, double bottom, double top, const wchar_t *visibleText) {
Graphics_setColour (my graphics, Graphics_MAROON);
Graphics_setLineWidth (my graphics, 3.0);
Graphics_fillRectangle (my graphics, left, right, bottom, top);
Graphics_setColour (my graphics, Graphics_YELLOW);
Graphics_rectangle (my graphics, left, right, bottom, top);
Graphics_text (my graphics, 0.5 * (left + right), 0.5 * (bottom + top), visibleText);
}
static void drawMarkers (Picture me)
/*
* The drawing area is a square measuring 12x12 inches.
*/
#define SIDE 12
/*
* The selection grid has a resolution of 1/2 inch.
*/
#define SQUARES 24
/*
* Vertical and horizontal lines every 3 inches.
*/
#define YELLOW_GRID 3
{
/* Fill the entire canvas with GC's background. */
Graphics_setColour (my selectionGraphics.get(), Graphics_WHITE);
Graphics_fillRectangle (my selectionGraphics.get(), 0, SIDE, 0, SIDE);
/* Draw yellow grid lines for coarse navigation. */
Graphics_setColour (my selectionGraphics.get(), Graphics_YELLOW);
for (int i = YELLOW_GRID; i < SIDE; i += YELLOW_GRID) {
Graphics_line (my selectionGraphics.get(), 0, i, SIDE, i);
Graphics_line (my selectionGraphics.get(), i, 0, i, SIDE);
}
/* Draw red ticks and numbers for feedback on viewport measurement. */
Graphics_setColour (my selectionGraphics.get(), Graphics_RED);
for (int i = 1; i < SIDE; i ++) {
double x = i;
Graphics_setTextAlignment (my selectionGraphics.get(), Graphics_CENTRE, Graphics_TOP);
Graphics_text (my selectionGraphics.get(), x, SIDE, i);
Graphics_setTextAlignment (my selectionGraphics.get(), Graphics_CENTRE, Graphics_BOTTOM);
Graphics_text (my selectionGraphics.get(), x, 0, i);
}
for (int i = 1; i < SQUARES ; i ++) { // vertical ticks
double x = 0.5 * i;
Graphics_line (my selectionGraphics.get(), x, SIDE - 0.04, x, SIDE);
Graphics_line (my selectionGraphics.get(), x, 0, x, 0.04);
}
for (int i = 1; i < SIDE; i ++) {
double y = SIDE - i;
Graphics_setTextAlignment (my selectionGraphics.get(), Graphics_LEFT, Graphics_HALF);
Graphics_text (my selectionGraphics.get(), 0.04, y, i);
Graphics_setTextAlignment (my selectionGraphics.get(), Graphics_RIGHT, Graphics_HALF);
Graphics_text (my selectionGraphics.get(), SIDE - 0.03, y, i);
}
for (int i = 1; i < SQUARES; i ++) { // horizontal ticks
double y = SIDE - 0.5 * i;
Graphics_line (my selectionGraphics.get(), SIDE - 0.04, y, SIDE, y);
Graphics_line (my selectionGraphics.get(), 0, y, 0.04, y);
}
Graphics_setColour (my selectionGraphics.get(), Graphics_BLACK);
}
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);
}
}
}
static void logo_defaultDraw (Graphics g) {
Graphics_setColour (g, Graphics_MAGENTA);
Graphics_fillRectangle (g, 0, 1, 0, 1);
Graphics_setGrey (g, 0.5);
Graphics_fillRectangle (g, 0.05, 0.95, 0.1, 0.9);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
Graphics_setColour (g, Graphics_YELLOW);
Graphics_setFont (g, kGraphics_font_TIMES);
Graphics_setFontSize (g, 24);
Graphics_setFontStyle (g, Graphics_ITALIC);
Graphics_setUnderscoreIsSubscript (g, false); // because program names may contain underscores
Graphics_text (g, 0.5, 0.6, praatP.title);
Graphics_setFontStyle (g, 0);
Graphics_setFontSize (g, 12);
Graphics_text (g, 0.5, 0.25, U"\\s{Built on the} %%Praat shell%\\s{,© Paul Boersma, 1992-2015");
}
void Polygon_paint (Polygon me, Graphics g, Graphics_Colour colour, double xmin, double xmax, double ymin, double ymax) {
Graphics_setInner (g);
setWindow (me, g, xmin, xmax, ymin, ymax);
Graphics_setColour (g, colour);
Graphics_fillArea (g, my numberOfPoints, & my x [1], & my y [1]);
Graphics_unsetInner (g);
}
void structSpectrogramEditor :: v_draw () {
Spectrogram spectrogram = (Spectrogram) our data;
Graphics_setWindow (our d_graphics.get(), 0.0, 1.0, 0.0, 1.0);
Graphics_setColour (our d_graphics.get(), Graphics_WHITE);
Graphics_fillRectangle (our d_graphics.get(), 0.0, 1.0, 0.0, 1.0);
Graphics_setColour (our d_graphics.get(), Graphics_BLACK);
Graphics_rectangle (our d_graphics.get(), 0.0, 1.0, 0.0, 1.0);
long itmin, itmax;
Sampled_getWindowSamples (spectrogram, our d_startWindow, our d_endWindow, & itmin, & itmax);
/*
* Autoscale frequency axis.
*/
our maximum = spectrogram -> ymax;
Graphics_setWindow (our d_graphics.get(), our d_startWindow, our d_endWindow, 0.0, our maximum);
Spectrogram_paintInside (spectrogram, our d_graphics.get(), our d_startWindow, our d_endWindow, 0, 0, 0.0, true,
60, 6.0, 0);
/*
* Horizontal scaling lines.
*/
Graphics_setWindow (our d_graphics.get(), 0.0, 1.0, 0.0, our maximum);
Graphics_setTextAlignment (our d_graphics.get(), Graphics_RIGHT, Graphics_HALF);
Graphics_setColour (our d_graphics.get(), Graphics_RED);
long df = 1000;
for (long f = df; f <= our maximum; f += df) {
Graphics_line (our d_graphics.get(), 0.0, f, 1.0, f);
Graphics_text (our d_graphics.get(), -0.01, f, f, U" Hz");
}
/*
* Vertical cursor lines.
*/
Graphics_setWindow (our d_graphics.get(), our d_startWindow, our d_endWindow, 0.0, our maximum);
if (our d_startSelection > our d_startWindow && our d_startSelection < our d_endWindow)
Graphics_line (our d_graphics.get(), our d_startSelection, 0, our d_startSelection, our maximum);
if (our d_endSelection > our d_startWindow && d_endSelection < d_endWindow)
Graphics_line (our d_graphics.get(), our d_endSelection, 0, our d_endSelection, our maximum);
Graphics_setColour (our d_graphics.get(), Graphics_BLACK);
}
void structSpectrumEditor :: v_draw () {
Spectrum spectrum = (Spectrum) data;
Graphics_setWindow (d_graphics, 0, 1, 0, 1);
Graphics_setColour (d_graphics, Graphics_WHITE);
Graphics_fillRectangle (d_graphics, 0, 1, 0, 1);
Graphics_setColour (d_graphics, Graphics_BLACK);
Graphics_rectangle (d_graphics, 0, 1, 0, 1);
Spectrum_drawInside (spectrum, d_graphics, d_startWindow, d_endWindow, minimum, maximum);
FunctionEditor_drawRangeMark (this, maximum, Melder_fixed (maximum, 1), L" dB", Graphics_TOP);
FunctionEditor_drawRangeMark (this, minimum, Melder_fixed (minimum, 1), L" dB", Graphics_BOTTOM);
if (cursorHeight > minimum && cursorHeight < maximum)
FunctionEditor_drawHorizontalHair (this, cursorHeight, Melder_fixed (cursorHeight, 1), L" dB");
Graphics_setColour (d_graphics, Graphics_BLACK);
/* Update buttons. */
long first, last;
long selectedSamples = Sampled_getWindowSamples (spectrum, d_startSelection, d_endSelection, & first, & last);
publishBandButton -> f_setSensitive (selectedSamples != 0);
publishSoundButton -> f_setSensitive (selectedSamples != 0);
}
void Graphics_matrixAsSquares (Graphics g, double **matrix, long numberOfRows, long numberOfColumns, double zmin, double zmax, double cellSizeFactor, int randomFillOrder) {
long numberOfCells = numberOfRows * numberOfColumns;
autoPermutation p = Permutation_create (numberOfCells);
if (randomFillOrder) {
Permutation_permuteRandomly_inline (p.peek(), 1, numberOfCells);
}
double zAbsMax = fabs (zmax) > fabs (zmin) ? fabs (zmax) : fabs (zmin);
Graphics_Colour colour = Graphics_inqColour (g);
double x1WC, x2WC, y1WC, y2WC;
Graphics_inqWindow (g, &x1WC, &x2WC, &y1WC, &y2WC);
double dx = fabs (x2WC - x1WC) / numberOfColumns;
double dy = fabs (y2WC - y1WC) / numberOfRows;
for (long i = 1; i <= numberOfCells; i++) {
long index = Permutation_getValueAtIndex (p.peek(), i);
long irow = (index - 1) / numberOfColumns + 1;
long icol = (index - 1) % numberOfColumns + 1;
double z = matrix[irow][icol];
z = z < zmin ? zmin : z;
z = z > zmax ? zmax : z;
double zweight = sqrt (fabs (z) / zAbsMax); // Area length^2)
double xcenter = (icol - 0.5) * dx;
double ycenter = (irow - 0.5) * dy;
double x1 = x1WC + xcenter - zweight * 0.5 * dx * cellSizeFactor;
x1 = x1 < x1WC ? x1WC : x1;
double x2 = x1WC + xcenter + zweight * 0.5 * dx * cellSizeFactor;
x2 = x2 > x2WC ? x2WC : x2;
double y1 = y1WC + ycenter - zweight * 0.5 * dy * cellSizeFactor;
y1 = y1 < y1WC ? y1WC : y1;
double y2 = y1WC + ycenter + zweight * 0.5 * dy * cellSizeFactor;
y2 = y2 > y2WC ? y2WC : y2;
if (z > 0) {
Graphics_setColour (g, Graphics_WHITE);
}
Graphics_fillRectangle (g, x1, x2, y1, y2);
Graphics_setColour (g, colour);
Graphics_rectangle (g, x1, x2 , y1, y2);
}
}
void TableOfReal_drawAsSquares (TableOfReal me, Graphics graphics, long rowmin, long rowmax,
long colmin, long colmax, int garnish)
{
double dx = 1, dy = 1;
Graphics_Colour colour = Graphics_inqColour (graphics);
fixRows (me, & rowmin, & rowmax);
fixColumns (me, & colmin, & colmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, colmin - 0.5, colmax + 0.5, rowmin - 0.5, rowmax + 0.5);
double datamax = my data [rowmin] [colmin];
for (long irow = 1; irow <= my numberOfRows; irow ++)
for (long icol = 1; icol <= my numberOfColumns; icol ++)
if (fabs (my data [irow] [icol]) > datamax) datamax = fabs (my data [irow] [icol]);
for (long irow = rowmin; irow <= rowmax; irow ++) {
double y = rowmax + rowmin - irow;
for (long icol = colmin; icol <= colmax; icol ++) {
double x = icol;
/* two neighbouring squares should not touch -> 0.95 */
double d = 0.95 * sqrt (fabs (my data [irow] [icol]) / datamax);
double x1WC = x - d * dx / 2, x2WC = x + d * dx / 2;
double y1WC = y - d * dy / 2, y2WC = y + d * dy / 2;
if (my data [irow] [icol] > 0) Graphics_setColour (graphics, Graphics_WHITE);
Graphics_fillRectangle (graphics, x1WC, x2WC, y1WC, y2WC);
Graphics_setColour (graphics, colour);
Graphics_rectangle (graphics, x1WC, x2WC , y1WC, y2WC);
}
}
Graphics_setGrey (graphics, 0.0);
Graphics_unsetInner (graphics);
if (garnish) {
for (long irow = rowmin; irow <= rowmax; irow ++) if (my rowLabels [irow])
Graphics_markLeft (graphics, rowmax + rowmin - irow, 0, 0, 0, my rowLabels [irow]);
for (long icol = colmin; icol <= colmax; icol ++) if (my columnLabels [icol])
Graphics_markTop (graphics, icol, 0, 0, 0, my columnLabels [icol]);
}
}
static void logo (Graphics g) {
Graphics_setWindow (g, 0, 1, 0.00, 0.80);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
Graphics_setFont (g, kGraphics_font_TIMES);
Graphics_setFontSize (g, 45);
Graphics_setColour (g, Graphics_MAROON);
Graphics_text (g, 0.385, 0.66, L"P");
Graphics_text (g, 0.448, 0.66, L"\\s{R}");
Graphics_text (g, 0.510, 0.66, L"\\s{A}");
Graphics_text (g, 0.575, 0.66, L"\\s{A}");
Graphics_text (g, 0.628, 0.66, L"\\s{T}");
Graphics_setFontSize (g, 15);
Graphics_text (g, 0.5, 0.55, L"%%doing phonetics by computer");
#define xstr(s) str(s)
#define str(s) #s
Graphics_text (g, 0.5, 0.45, L"version " xstr(PRAAT_VERSION_STR));
Graphics_setColour (g, Graphics_BLACK);
Graphics_setFontSize (g, 14);
Graphics_text (g, 0.5, 0.33, L"www.praat.org");
Graphics_setFont (g, kGraphics_font_HELVETICA);
Graphics_setFontSize (g, 10);
Graphics_text (g, 0.5, 0.16, L"Copyright \\co 1992-" xstr(PRAAT_YEAR) " by Paul Boersma and David Weenink");
}
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 FFNet_drawActivation (FFNet me, Graphics g) {
long node = 1, maxNumOfUnits = my nUnitsInLayer[0];
int dxIsFixed = 1;
Graphics_Colour colour = Graphics_inqColour (g);
double dy = 1.0 / (my nLayers + 1);
Graphics_setInner (g);
Graphics_setWindow (g, 0.0, 1.0, 0.0, 1.0);
for (long i = 1; i <= my nLayers; i++) {
if (my nUnitsInLayer[i] > maxNumOfUnits) {
maxNumOfUnits = my nUnitsInLayer[i];
}
}
double dx = 1.0 / maxNumOfUnits;
double r1 = dx / 2.0; /* May touch when neighbouring activities are both 1 (very rare). */
for (long i = 0; i <= my nLayers; i++, node++) {
double dx2 = dx, x2WC, y2WC = dy / 2.0 + i * dy;
double x2 = (maxNumOfUnits - my nUnitsInLayer[i] + 1) * dx2 / 2.0;
if (! dxIsFixed) {
dx2 = 1.0 / my nUnitsInLayer[i];
x2 = dx2 / 2.0;
}
x2WC = x2;
for (long j = 1; j <= my nUnitsInLayer[i]; j++, node++) {
double activity = my activity[node];
double radius = r1 * (fabs (activity) < 0.05 ? 0.05 : fabs (activity));
/*Graphics_setColour (g, activity < 0 ? Graphics_BLACK : Graphics_RED);*/
Graphics_circle (g, x2WC, y2WC, radius);
if (activity < 0) {
Graphics_fillCircle (g, x2WC, y2WC, radius);
}
x2WC += dx2;
}
}
Graphics_setColour (g, colour);
Graphics_unsetInner (g);
}
void structERP :: f_drawScalp (Graphics graphics, double tmin, double tmax, double vmin, double vmax, bool garnish) {
Graphics_setInner (graphics);
Graphics_setWindow (graphics, -1.0, 1.0, -1.0, 1.0);
//Graphics_setGrey (graphics, 1.0);
//Graphics_fillRectangle (graphics, -1.1, 1.1, -1.01, 1.19);
//Graphics_setColour (graphics, Graphics_BLACK);
long numberOfDrawableChannels =
this -> ny >= 64 && Melder_wcsequ (this -> d_channelNames [64], L"O2") ? 64 :
this -> ny >= 32 && Melder_wcsequ (this -> d_channelNames [32], L"Cz") ? 32 :
0;
BiosemiLocationData *biosemiLocationData = numberOfDrawableChannels == 64 ? biosemiCapCoordinates64 : numberOfDrawableChannels == 32 ? biosemiCapCoordinates32 : 0;
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
double inclination = (double) biosemiLocationData [ichan]. inclination;
double azimuth = (double) biosemiLocationData [ichan]. azimuth;
bool rightHemisphere = inclination >= 0.0;
double r = fabs (inclination / 115.0);
double theta = rightHemisphere ? azimuth * (NUMpi / 180.0) : (azimuth + 180.0) * (NUMpi / 180.0);
biosemiLocationData [ichan]. topX = r * cos (theta);
biosemiLocationData [ichan]. topY = r * sin (theta);
}
long n = 201;
double d = 2.0 / (n - 1);
autoNUMvector <double> mean (1, numberOfDrawableChannels);
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
mean [ichan] = tmin == tmax ?
Sampled_getValueAtX (this, tmin, ichan, 0, true) :
Vector_getMean (this, tmin, tmax, ichan);
}
autoNUMmatrix <double> image (1, n, 1, n);
for (long irow = 1; irow <= n; irow ++) {
double y = -1.0 + (irow - 1) * d;
for (long icol = 1; icol <= n; icol ++) {
double x = -1.0 + (icol - 1) * d;
if (x * x + y * y <= 1.0) {
double value = NUMundefined, sum = 0.0, weight = 0.0;
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
double dx = x - biosemiLocationData [ichan]. topX;
double dy = y - biosemiLocationData [ichan]. topY;
double distance = sqrt (dx * dx + dy * dy);
if (distance < 1e-12) {
value = mean [ichan];
break;
}
distance = distance * distance * distance * distance * distance * distance;
sum += mean [ichan] / distance;
weight += 1.0 / distance;
}
if (value == NUMundefined)
value = ( sum == 0.0 ? 0.0 : sum / weight );
image [irow] [icol] = value;
}
}
}
for (long irow = 1; irow <= n; irow ++) {
double y = -1.0 + (irow - 1) * d;
for (long icol = 1; icol <= n; icol ++) {
double x = -1.0 + (icol - 1) * d;
if (x * x + y * y > 1.0) {
image [irow] [icol] = vmin;
}
}
}
Graphics_image (graphics, image.peek(), 1, n, -1.0-0.5/n, 1.0+0.5/n, 1, n, -1.0-0.5/n, 1.0+0.5/n, vmin, vmax);
Graphics_setLineWidth (graphics, 2.0);
/*
* Nose.
*/
Graphics_setGrey (graphics, 0.5);
{// scope
double x [3] = { -0.08, 0.0, 0.08 }, y [3] = { 0.99, 1.18, 0.99 };
Graphics_fillArea (graphics, 3, x, y);
}
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_line (graphics, -0.08, 0.99, 0.0, 1.18);
Graphics_line (graphics, 0.08, 0.99, 0.0, 1.18);
/*
* Ears.
*/
Graphics_setGrey (graphics, 0.5);
Graphics_fillRectangle (graphics, -1.09, -1.00, -0.08, 0.08);
Graphics_fillRectangle (graphics, 1.09, 1.00, -0.08, 0.08);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_line (graphics, -0.99, 0.08, -1.09, 0.08);
Graphics_line (graphics, -1.09, 0.08, -1.09, -0.08);
Graphics_line (graphics, -1.09, -0.08, -0.99, -0.08);
Graphics_line (graphics, 0.99, 0.08, 1.09, 0.08);
Graphics_line (graphics, 1.09, 0.08, 1.09, -0.08);
Graphics_line (graphics, 1.09, -0.08, 0.99, -0.08);
/*
* Scalp.
*/
Graphics_ellipse (graphics, -1.0, 1.0, -1.0, 1.0);
Graphics_setLineWidth (graphics, 1.0);
Graphics_unsetInner (graphics);
if (garnish) {
autoNUMmatrix <double> legend (1, n, 1, 2);
for (long irow = 1; irow <= n; irow ++) {
for (long icol = 1; icol <= 2; icol ++) {
legend [irow] [icol] = (irow - 1) / (n - 1.0);
}
}
Graphics_image (graphics, legend.peek(), 1, 2, 0.78, 0.98, 1, n, -0.8, +0.8, 0.0, 1.0);
Graphics_rectangle (graphics, 0.78, 0.98, -0.8, +0.8);
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_TOP);
Graphics_text2 (graphics, 1.0, -0.8, Melder_double (vmin * 1e6), L" \\muV");
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_BOTTOM);
Graphics_text2 (graphics, 1.0, +0.8, Melder_double (vmax * 1e6), L" \\muV");
}
}
void SoundEditor::draw () {
long first, last, selectedSamples;
Graphics_Viewport viewport;
int showAnalysis = _spectrogram.show || _pitch.show || _intensity.show || _formant.show;
Melder_assert (_data != NULL);
Melder_assert (_sound.data != NULL || _longSound.data != NULL);
/*
* We check beforehand whether the window fits the LongSound buffer.
*/
if (_longSound.data && _endWindow - _startWindow > _longSound.data -> bufferLength) {
Graphics_setColour (_graphics, Graphics_WHITE);
Graphics_setWindow (_graphics, 0, 1, 0, 1);
Graphics_fillRectangle (_graphics, 0, 1, 0, 1);
Graphics_setColour (_graphics, Graphics_BLACK);
Graphics_setTextAlignment (_graphics, Graphics_CENTRE, Graphics_BOTTOM);
Graphics_text3 (_graphics, 0.5, 0.5, L"(window longer than ", Melder_float (Melder_single (_longSound.data -> bufferLength)), L" seconds)");
Graphics_setTextAlignment (_graphics, Graphics_CENTRE, Graphics_TOP);
Graphics_text1 (_graphics, 0.5, 0.5, L"(zoom in to see the samples)");
return;
}
/* Draw sound. */
if (showAnalysis)
viewport = Graphics_insetViewport (_graphics, 0, 1, 0.5, 1);
Graphics_setColour (_graphics, Graphics_WHITE);
Graphics_setWindow (_graphics, 0, 1, 0, 1);
Graphics_fillRectangle (_graphics, 0, 1, 0, 1);
draw_sound (_sound.minimum, _sound.maximum);
Graphics_flushWs (_graphics);
if (showAnalysis)
Graphics_resetViewport (_graphics, viewport);
/* Draw analyses. */
if (showAnalysis) {
/* Draw spectrogram, pitch, formants. */
viewport = Graphics_insetViewport (_graphics, 0, 1, 0, 0.5);
draw_analysis ();
Graphics_flushWs (_graphics);
Graphics_resetViewport (_graphics, viewport);
}
/* Draw pulses. */
if (_pulses.show) {
if (showAnalysis)
viewport = Graphics_insetViewport (_graphics, 0, 1, 0.5, 1);
draw_analysis_pulses ();
draw_sound (_sound.minimum, _sound.maximum); /* Second time, partially across the pulses. */
Graphics_flushWs (_graphics);
if (showAnalysis)
Graphics_resetViewport (_graphics, viewport);
}
/* Update buttons. */
selectedSamples = Sampled_getWindowSamples (_data, _startSelection, _endSelection, & first, & last);
updateMenuItems_file ();
if (_sound.data) {
GuiObject_setSensitive (_cutButton, selectedSamples != 0 && selectedSamples < _sound.data -> nx);
GuiObject_setSensitive (_copyButton, selectedSamples != 0);
GuiObject_setSensitive (_zeroButton, selectedSamples != 0);
GuiObject_setSensitive (_reverseButton, selectedSamples != 0);
}
}
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);
}
Sound Artword_Speaker_to_Sound (Artword artword, Speaker speaker,
double fsamp, int oversampling,
Sound *out_w1, int iw1, Sound *out_w2, int iw2, Sound *out_w3, int iw3,
Sound *out_p1, int ip1, Sound *out_p2, int ip2, Sound *out_p3, int ip3,
Sound *out_v1, int iv1, Sound *out_v2, int iv2, Sound *out_v3, int iv3)
{
try {
autoSound result = Sound_createSimple (1, artword -> totalTime, fsamp);
long numberOfSamples = result -> nx;
double minTract [1+78], maxTract [1+78]; /* For drawing. */
double Dt = 1 / fsamp / oversampling,
rho0 = 1.14,
c = 353,
onebyc2 = 1.0 / (c * c),
rho0c2 = rho0 * c * c,
halfDt = 0.5 * Dt,
twoDt = 2 * Dt,
halfc2Dt = 0.5 * c * c * Dt,
twoc2Dt = 2 * c * c * Dt,
onebytworho0 = 1.0 / (2.0 * rho0),
Dtbytworho0 = Dt / (2.0 * rho0);
double tension, rrad, onebygrad, totalVolume;
autoArt art = Art_create ();
long sample;
int n, m, M;
autoDelta delta = Speaker_to_Delta (speaker);
autoMelderMonitor monitor (U"Articulatory synthesis");
Artword_intoArt (artword, art.peek(), 0.0);
Art_Speaker_intoDelta (art.peek(), speaker, delta.peek());
M = delta -> numberOfTubes;
autoSound w1, w2, w3, p1, p2, p3, v1, v2, v3;
if (iw1 > 0 && iw1 <= M) w1.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else iw1 = 0;
if (iw2 > 0 && iw2 <= M) w2.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else iw2 = 0;
if (iw3 > 0 && iw3 <= M) w3.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else iw3 = 0;
if (ip1 > 0 && ip1 <= M) p1.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else ip1 = 0;
if (ip2 > 0 && ip2 <= M) p2.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else ip2 = 0;
if (ip3 > 0 && ip3 <= M) p3.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else ip3 = 0;
if (iv1 > 0 && iv1 <= M) v1.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else iv1 = 0;
if (iv2 > 0 && iv2 <= M) v2.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else iv2 = 0;
if (iv3 > 0 && iv3 <= M) v3.reset (Sound_createSimple (1, artword -> totalTime, fsamp)); else iv3 = 0;
/* Initialize drawing. */
{ int i; for (i = 1; i <= 78; i ++) { minTract [i] = 100; maxTract [i] = -100; } }
totalVolume = 0.0;
for (m = 1; m <= M; m ++) {
Delta_Tube t = delta->tube + m;
if (! t -> left1 && ! t -> right1) continue;
t->Dx = t->Dxeq; t->dDxdt = 0; /* 5.113 */
t->Dy = t->Dyeq; t->dDydt = 0; /* 5.113 */
t->Dz = t->Dzeq; /* 5.113 */
t->A = t->Dz * ( t->Dy >= t->dy ? t->Dy + Dymin :
t->Dy <= - t->dy ? Dymin :
(t->dy + t->Dy) * (t->dy + t->Dy) / (4 * t->dy) + Dymin ); /* 4.4, 4.5 */
#if EQUAL_TUBE_WIDTHS
t->A = 0.0001;
#endif
t->Jleft = t->Jright = 0; /* 5.113 */
t->Qleft = t->Qright = rho0c2; /* 5.113 */
t->pleft = t->pright = 0; /* 5.114 */
t->Kleft = t->Kright = 0; /* 5.114 */
t->V = t->A * t->Dx; /* 5.114 */
totalVolume += t->V;
}
//Melder_casual (U"Starting volume: ", totalVolume * 1000, U" litres.");
for (sample = 1; sample <= numberOfSamples; sample ++) {
double time = (sample - 1) / fsamp;
Artword_intoArt (artword, art.peek(), time);
Art_Speaker_intoDelta (art.peek(), speaker, delta.peek());
if (sample % MONITOR_SAMPLES == 0 && monitor.graphics()) { // because we can be in batch
Graphics graphics = monitor.graphics();
double area [1+78];
Graphics_Viewport vp;
for (int i = 1; i <= 78; i ++) {
area [i] = delta -> tube [i]. A;
if (area [i] < minTract [i]) minTract [i] = area [i];
if (area [i] > maxTract [i]) maxTract [i] = area [i];
}
Graphics_clearWs (graphics);
vp = Graphics_insetViewport (monitor.graphics(), 0, 0.5, 0.5, 1);
Graphics_setWindow (graphics, 0, 1, 0, 0.05);
Graphics_setColour (graphics, Graphics_RED);
Graphics_function (graphics, minTract, 1, 35, 0, 0.9);
Graphics_function (graphics, maxTract, 1, 35, 0, 0.9);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_function (graphics, area, 1, 35, 0, 0.9);
Graphics_setLineType (graphics, Graphics_DOTTED);
Graphics_line (graphics, 0, 0, 1, 0);
Graphics_setLineType (graphics, Graphics_DRAWN);
Graphics_resetViewport (graphics, vp);
vp = Graphics_insetViewport (graphics, 0, 0.5, 0, 0.5);
Graphics_setWindow (graphics, 0, 1, -0.000003, 0.00001);
Graphics_setColour (graphics, Graphics_RED);
Graphics_function (graphics, minTract, 36, 37, 0.2, 0.8);
Graphics_function (graphics, maxTract, 36, 37, 0.2, 0.8);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_function (graphics, area, 36, 37, 0.2, 0.8);
Graphics_setLineType (graphics, Graphics_DOTTED);
Graphics_line (graphics, 0, 0, 1, 0);
Graphics_setLineType (graphics, Graphics_DRAWN);
Graphics_resetViewport (graphics, vp);
vp = Graphics_insetViewport (graphics, 0.5, 1, 0.5, 1);
Graphics_setWindow (graphics, 0, 1, 0, 0.001);
Graphics_setColour (graphics, Graphics_RED);
Graphics_function (graphics, minTract, 38, 64, 0, 1);
Graphics_function (graphics, maxTract, 38, 64, 0, 1);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_function (graphics, area, 38, 64, 0, 1);
Graphics_setLineType (graphics, Graphics_DOTTED);
Graphics_line (graphics, 0, 0, 1, 0);
Graphics_setLineType (graphics, Graphics_DRAWN);
Graphics_resetViewport (graphics, vp);
vp = Graphics_insetViewport (graphics, 0.5, 1, 0, 0.5);
Graphics_setWindow (graphics, 0, 1, 0.001, 0);
Graphics_setColour (graphics, Graphics_RED);
Graphics_function (graphics, minTract, 65, 78, 0.5, 1);
Graphics_function (graphics, maxTract, 65, 78, 0.5, 1);
Graphics_setColour (graphics, Graphics_BLACK);
Graphics_function (graphics, area, 65, 78, 0.5, 1);
Graphics_setLineType (graphics, Graphics_DRAWN);
Graphics_resetViewport (graphics, vp);
Melder_monitor ((double) sample / numberOfSamples, U"Articulatory synthesis: ", Melder_half (time), U" seconds");
}
for (n = 1; n <= oversampling; n ++) {
for (m = 1; m <= M; m ++) {
Delta_Tube t = delta -> tube + m;
if (! t -> left1 && ! t -> right1) continue;
/* New geometry. */
#if CONSTANT_TUBE_LENGTHS
t->Dxnew = t->Dx;
#else
t->dDxdtnew = (t->dDxdt + Dt * 10000 * (t->Dxeq - t->Dx)) /
(1 + 200 * Dt); /* Critical damping, 10 ms. */
t->Dxnew = t->Dx + t->dDxdtnew * Dt;
#endif
/* 3-way: equal lengths. */
/* This requires left tubes to be processed before right tubes. */
if (t->left1 && t->left1->right2) t->Dxnew = t->left1->Dxnew;
t->Dz = t->Dzeq; /* immediate... */
t->eleft = (t->Qleft - t->Kleft) * t->V; /* 5.115 */
t->eright = (t->Qright - t->Kright) * t->V; /* 5.115 */
t->e = 0.5 * (t->eleft + t->eright); /* 5.116 */
t->p = 0.5 * (t->pleft + t->pright); /* 5.116 */
t->DeltaP = t->e / t->V - rho0c2; /* 5.117 */
t->v = t->p / (rho0 + onebyc2 * t->DeltaP); /* 5.118 */
{
double dDy = t->Dyeq - t->Dy;
double cubic = t->k3 * dDy * dDy;
Delta_Tube l1 = t->left1, l2 = t->left2, r1 = t->right1, r2 = t->right2;
tension = dDy * (t->k1 + cubic);
t->B = 2 * t->Brel * sqrt (t->mass * (t->k1 + 3 * cubic));
if (t->k1left1 != 0.0 && l1)
tension += t->k1left1 * t->k1 * (dDy - (l1->Dyeq - l1->Dy));
if (t->k1left2 != 0.0 && l2)
tension += t->k1left2 * t->k1 * (dDy - (l2->Dyeq - l2->Dy));
if (t->k1right1 != 0.0 && r1)
tension += t->k1right1 * t->k1 * (dDy - (r1->Dyeq - r1->Dy));
if (t->k1right2 != 0.0 && r2)
tension += t->k1right2 * t->k1 * (dDy - (r2->Dyeq - r2->Dy));
}
if (t->Dy < t->dy) {
if (t->Dy >= - t->dy) {
double dDy = t->dy - t->Dy, dDy2 = dDy * dDy;
tension += dDy2 / (4 * t->dy) * (t->s1 + 0.5 * t->s3 * dDy2);
t->B += 2 * dDy / (2 * t->dy) *
sqrt (t->mass * (t->s1 + t->s3 * dDy2));
} else {
tension -= t->Dy * (t->s1 + t->s3 * (t->Dy * t->Dy + t->dy * t->dy));
t->B += 2 * sqrt (t->mass * (t->s1 + t->s3 * (3 * t->Dy * t->Dy + t->dy * t->dy)));
}
}
t->dDydtnew = (t->dDydt + Dt / t->mass * (tension + 2 * t->DeltaP * t->Dz * t->Dx)) /
(1 + t->B * Dt / t->mass); /* 5.119 */
t->Dynew = t->Dy + t->dDydtnew * Dt; /* 5.119 */
#if NO_MOVING_WALLS
t->Dynew = t->Dy;
#endif
t->Anew = t->Dz * ( t->Dynew >= t->dy ? t->Dynew + Dymin :
t->Dynew <= - t->dy ? Dymin :
(t->dy + t->Dynew) * (t->dy + t->Dynew) / (4 * t->dy) + Dymin ); /* 4.4, 4.5 */
#if EQUAL_TUBE_WIDTHS
t->Anew = 0.0001;
#endif
t->Ahalf = 0.5 * (t->A + t->Anew); /* 5.120 */
t->Dxhalf = 0.5 * (t->Dxnew + t->Dx); /* 5.121 */
t->Vnew = t->Anew * t->Dxnew; /* 5.128 */
{ double oneByDyav = t->Dz / t->A;
/*t->R = 12 * 1.86e-5 * t->parallel * t->parallel * oneByDyav * oneByDyav;*/
if (t->Dy < 0)
t->R = 12 * 1.86e-5 / (Dymin * Dymin + t->dy * t->dy);
else
t->R = 12 * 1.86e-5 * t->parallel * t->parallel /
((t->Dy + Dymin) * (t->Dy + Dymin) + t->dy * t->dy);
t->R += 0.3 * t->parallel * oneByDyav; /* 5.23 */ }
t->r = (1 + t->R * Dt / rho0) * t->Dxhalf / t->Anew; /* 5.122 */
t->ehalf = t->e + halfc2Dt * (t->Jleft - t->Jright); /* 5.123 */
t->phalf = (t->p + halfDt * (t->Qleft - t->Qright) / t->Dx) / (1 + Dtbytworho0 * t->R); /* 5.123 */
#if MASS_LEAPFROG
t->ehalf = t->ehalfold + 2 * halfc2Dt * (t->Jleft - t->Jright);
#endif
t->Jhalf = t->phalf * t->Ahalf; /* 5.124 */
t->Qhalf = t->ehalf / (t->Ahalf * t->Dxhalf) + onebytworho0 * t->phalf * t->phalf; /* 5.124 */
#if NO_BERNOULLI_EFFECT
t->Qhalf = t->ehalf / (t->Ahalf * t->Dxhalf);
#endif
}
for (m = 1; m <= M; m ++) { /* Compute Jleftnew and Qleftnew. */
Delta_Tube l = delta->tube + m, r1 = l -> right1, r2 = l -> right2, r = r1;
Delta_Tube l1 = l, l2 = r ? r -> left2 : NULL;
if (l->left1 == NULL) { /* Closed boundary at the left side (diaphragm)? */
if (r == NULL) continue; /* Tube not connected at all. */
l->Jleftnew = 0; /* 5.132. */
l->Qleftnew = (l->eleft - twoc2Dt * l->Jhalf) / l->Vnew; /* 5.132. */
}
else /* Left boundary open to another tube will be handled... */
(void) 0; /* ...together with the right boundary of the tube to the left. */
if (r == NULL) { /* Open boundary at the right side (lips, nostrils)? */
rrad = 1 - c * Dt / 0.02; /* Radiation resistance, 5.135. */
onebygrad = 1 / (1 + c * Dt / 0.02); /* Radiation conductance, 5.135. */
#if NO_RADIATION_DAMPING
rrad = 0;
onebygrad = 0;
#endif
l->prightnew = ((l->Dxhalf / Dt + c * onebygrad) * l->pright +
2 * ((l->Qhalf - rho0c2) - (l->Qright - rho0c2) * onebygrad)) /
(l->r * l->Anew / Dt + c * onebygrad); /* 5.136 */
l->Jrightnew = l->prightnew * l->Anew; /* 5.136 */
l->Qrightnew = (rrad * (l->Qright - rho0c2) +
c * (l->prightnew - l->pright)) * onebygrad + rho0c2; /* 5.136 */
} else if (l2 == NULL && r2 == NULL) { /* Two-way boundary. */
if (l->v > criticalVelocity && l->A < r->A) {
l->Pturbrightnew = -0.5 * rho0 * (l->v - criticalVelocity) *
(1 - l->A / r->A) * (1 - l->A / r->A) * l->v;
if (l->Pturbrightnew != 0.0)
l->Pturbrightnew *= 1 + NUMrandomGauss (0, noiseFactor) /* * l->A */;
}
if (r->v < - criticalVelocity && r->A < l->A) {
l->Pturbrightnew = 0.5 * rho0 * (r->v + criticalVelocity) *
(1 - r->A / l->A) * (1 - r->A / l->A) * r->v;
if (l->Pturbrightnew != 0.0)
l->Pturbrightnew *= 1 + NUMrandomGauss (0, noiseFactor) /* * r->A */;
}
#if NO_TURBULENCE
l->Pturbrightnew = 0;
#endif
l->Jrightnew = r->Jleftnew =
(l->Dxhalf * l->pright + r->Dxhalf * r->pleft +
twoDt * (l->Qhalf - r->Qhalf + l->Pturbright)) /
(l->r + r->r); /* 5.127 */
#if B91
l->Jrightnew = r->Jleftnew =
(l->pright + r->pleft +
2 * twoDt * (l->Qhalf - r->Qhalf + l->Pturbright) / (l->Dxhalf + r->Dxhalf)) /
(l->r / l->Dxhalf + r->r / r->Dxhalf);
#endif
l->prightnew = l->Jrightnew / l->Anew; /* 5.128 */
r->pleftnew = r->Jleftnew / r->Anew; /* 5.128 */
l->Krightnew = onebytworho0 * l->prightnew * l->prightnew; /* 5.128 */
r->Kleftnew = onebytworho0 * r->pleftnew * r->pleftnew; /* 5.128 */
#if NO_BERNOULLI_EFFECT
l->Krightnew = r->Kleftnew = 0;
#endif
l->Qrightnew =
(l->eright + r->eleft + twoc2Dt * (l->Jhalf - r->Jhalf)
+ l->Krightnew * l->Vnew + (r->Kleftnew - l->Pturbrightnew) * r->Vnew) /
(l->Vnew + r->Vnew); /* 5.131 */
r->Qleftnew = l->Qrightnew + l->Pturbrightnew; /* 5.131 */
} else if (r2) { /* Two adjacent tubes at the right side (velic). */
r1->Jleftnew =
(r1->Jleft * r1->Dxhalf * (1 / (l->A + r2->A) + 1 / r1->A) +
twoDt * ((l->Ahalf * l->Qhalf + r2->Ahalf * r2->Qhalf ) / (l->Ahalf + r2->Ahalf) - r1->Qhalf)) /
(1 / (1 / l->r + 1 / r2->r) + r1->r); /* 5.138 */
r2->Jleftnew =
(r2->Jleft * r2->Dxhalf * (1 / (l->A + r1->A) + 1 / r2->A) +
twoDt * ((l->Ahalf * l->Qhalf + r1->Ahalf * r1->Qhalf ) / (l->Ahalf + r1->Ahalf) - r2->Qhalf)) /
(1 / (1 / l->r + 1 / r1->r) + r2->r); /* 5.138 */
l->Jrightnew = r1->Jleftnew + r2->Jleftnew; /* 5.139 */
l->prightnew = l->Jrightnew / l->Anew; /* 5.128 */
r1->pleftnew = r1->Jleftnew / r1->Anew; /* 5.128 */
r2->pleftnew = r2->Jleftnew / r2->Anew; /* 5.128 */
l->Krightnew = onebytworho0 * l->prightnew * l->prightnew; /* 5.128 */
r1->Kleftnew = onebytworho0 * r1->pleftnew * r1->pleftnew; /* 5.128 */
r2->Kleftnew = onebytworho0 * r2->pleftnew * r2->pleftnew; /* 5.128 */
#if NO_BERNOULLI_EFFECT
l->Krightnew = r1->Kleftnew = r2->Kleftnew = 0;
#endif
l->Qrightnew = r1->Qleftnew = r2->Qleftnew =
(l->eright + r1->eleft + r2->eleft + twoc2Dt * (l->Jhalf - r1->Jhalf - r2->Jhalf) +
l->Krightnew * l->Vnew + r1->Kleftnew * r1->Vnew + r2->Kleftnew * r2->Vnew) /
(l->Vnew + r1->Vnew + r2->Vnew); /* 5.137 */
} else {
Melder_assert (l2 != NULL);
l1->Jrightnew =
(l1->Jright * l1->Dxhalf * (1 / (r->A + l2->A) + 1 / l1->A) -
twoDt * ((r->Ahalf * r->Qhalf + l2->Ahalf * l2->Qhalf ) / (r->Ahalf + l2->Ahalf) - l1->Qhalf)) /
(1 / (1 / r->r + 1 / l2->r) + l1->r); /* 5.138 */
l2->Jrightnew =
(l2->Jright * l2->Dxhalf * (1 / (r->A + l1->A) + 1 / l2->A) -
twoDt * ((r->Ahalf * r->Qhalf + l1->Ahalf * l1->Qhalf ) / (r->Ahalf + l1->Ahalf) - l2->Qhalf)) /
(1 / (1 / r->r + 1 / l1->r) + l2->r); /* 5.138 */
r->Jleftnew = l1->Jrightnew + l2->Jrightnew; /* 5.139 */
r->pleftnew = r->Jleftnew / r->Anew; /* 5.128 */
l1->prightnew = l1->Jrightnew / l1->Anew; /* 5.128 */
l2->prightnew = l2->Jrightnew / l2->Anew; /* 5.128 */
r->Kleftnew = onebytworho0 * r->pleftnew * r->pleftnew; /* 5.128 */
l1->Krightnew = onebytworho0 * l1->prightnew * l1->prightnew; /* 5.128 */
l2->Krightnew = onebytworho0 * l2->prightnew * l2->prightnew; /* 5.128 */
#if NO_BERNOULLI_EFFECT
r->Kleftnew = l1->Krightnew = l2->Krightnew = 0;
#endif
r->Qleftnew = l1->Qrightnew = l2->Qrightnew =
(r->eleft + l1->eright + l2->eright + twoc2Dt * (l1->Jhalf + l2->Jhalf - r->Jhalf) +
r->Kleftnew * r->Vnew + l1->Krightnew * l1->Vnew + l2->Krightnew * l2->Vnew) /
(r->Vnew + l1->Vnew + l2->Vnew); /* 5.137 */
}
}
/* Save some results. */
if (n == (oversampling + 1) / 2) {
double out = 0.0;
for (m = 1; m <= M; m ++) {
Delta_Tube t = delta->tube + m;
out += rho0 * t->Dx * t->Dz * t->dDydt * Dt * 1000; /* Radiation of wall movement, 5.140. */
if (t->right1 == NULL)
out += t->Jrightnew - t->Jright; /* Radiation of open tube end. */
}
result -> z [1] [sample] = out /= 4 * NUMpi * 0.4 * Dt; /* At 0.4 metres. */
if (iw1) w1 -> z [1] [sample] = delta->tube[iw1].Dy;
if (iw2) w2 -> z [1] [sample] = delta->tube[iw2].Dy;
if (iw3) w3 -> z [1] [sample] = delta->tube[iw3].Dy;
if (ip1) p1 -> z [1] [sample] = delta->tube[ip1].DeltaP;
if (ip2) p2 -> z [1] [sample] = delta->tube[ip2].DeltaP;
if (ip3) p3 -> z [1] [sample] = delta->tube[ip3].DeltaP;
if (iv1) v1 -> z [1] [sample] = delta->tube[iv1].v;
if (iv2) v2 -> z [1] [sample] = delta->tube[iv2].v;
if (iv3) v3 -> z [1] [sample] = delta->tube[iv3].v;
}
for (m = 1; m <= M; m ++) {
Delta_Tube t = delta->tube + m;
t->Jleft = t->Jleftnew;
t->Jright = t->Jrightnew;
t->Qleft = t->Qleftnew;
t->Qright = t->Qrightnew;
t->Dy = t->Dynew;
t->dDydt = t->dDydtnew;
t->A = t->Anew;
t->Dx = t->Dxnew;
t->dDxdt = t->dDxdtnew;
t->eleft = t->eleftnew;
t->eright = t->erightnew;
#if MASS_LEAPFROG
t->ehalfold = t->ehalf;
#endif
t->pleft = t->pleftnew;
t->pright = t->prightnew;
t->Kleft = t->Kleftnew;
t->Kright = t->Krightnew;
t->V = t->Vnew;
t->Pturbright = t->Pturbrightnew;
}
}
}
totalVolume = 0.0;
for (m = 1; m <= M; m ++)
totalVolume += delta->tube [m]. V;
//Melder_casual (U"Ending volume: ", totalVolume * 1000, U" litres.");
if (out_w1) *out_w1 = w1.transfer();
if (out_w2) *out_w2 = w2.transfer();
if (out_w3) *out_w3 = w3.transfer();
if (out_p1) *out_p1 = p1.transfer();
if (out_p2) *out_p2 = p2.transfer();
if (out_p3) *out_p3 = p3.transfer();
if (out_v1) *out_v1 = v1.transfer();
if (out_v2) *out_v2 = v2.transfer();
if (out_v3) *out_v3 = v3.transfer();
return result.transfer();
} catch (MelderError) {
Melder_throw (artword, U" & ", speaker, U": articulatory synthesis not performed.");
}
}
void structPitchEditor :: v_draw () {
Pitch pitch = (Pitch) our data;
long it, it1, it2;
double dyUnv, dyIntens;
Graphics_setWindow (our d_graphics, 0, 1, 0, 1);
Graphics_setColour (our d_graphics, Graphics_WHITE);
Graphics_fillRectangle (our d_graphics, 0, 1, 0, 1);
Graphics_setColour (our d_graphics, Graphics_BLACK);
Graphics_rectangle (our d_graphics, 0, 1, 0, 1);
dyUnv = Graphics_dyMMtoWC (our d_graphics, HEIGHT_UNV);
dyIntens = Graphics_dyMMtoWC (our d_graphics, HEIGHT_INTENS);
Sampled_getWindowSamples (pitch, our d_startWindow, our d_endWindow, & it1, & it2);
/*
* Show pitch.
*/
{
long df =
pitch -> ceiling > 10000 ? 2000 :
pitch -> ceiling > 5000 ? 1000 :
pitch -> ceiling > 2000 ? 500 :
pitch -> ceiling > 800 ? 200 :
pitch -> ceiling > 400 ? 100 :
50;
double radius;
Graphics_Viewport previous;
previous = Graphics_insetViewport (our d_graphics, 0, 1, dyUnv, 1 - dyIntens);
Graphics_setWindow (our d_graphics, our d_startWindow, our d_endWindow, 0, pitch -> ceiling);
radius = Graphics_dxMMtoWC (our d_graphics, RADIUS);
/* Horizontal hair at current pitch. */
if (our d_startSelection == our d_endSelection && our d_startSelection >= our d_startWindow && our d_startSelection <= our d_endWindow) {
double f = Pitch_getValueAtTime (pitch, our d_startSelection, kPitch_unit_HERTZ, Pitch_LINEAR);
if (NUMdefined (f)) {
Graphics_setColour (our d_graphics, Graphics_RED);
Graphics_line (our d_graphics, our d_startWindow - radius, f, our d_endWindow, f);
Graphics_setTextAlignment (our d_graphics, Graphics_RIGHT, Graphics_HALF);
Graphics_text1 (our d_graphics, our d_startWindow - radius, f, Melder_fixed (f, 2));
}
}
/* Horizontal scaling lines. */
Graphics_setColour (our d_graphics, Graphics_BLUE);
Graphics_setLineType (our d_graphics, Graphics_DOTTED);
Graphics_setTextAlignment (our d_graphics, Graphics_LEFT, Graphics_HALF);
for (long f = df; f <= pitch -> ceiling; f += df) {
Graphics_line (our d_graphics, our d_startWindow, f, our d_endWindow, f);
Graphics_text2 (our d_graphics, our d_endWindow + radius/2, f, Melder_integer (f), L" Hz");
}
Graphics_setLineType (our d_graphics, Graphics_DRAWN);
/* Show candidates. */
for (it = it1; it <= it2; it ++) {
Pitch_Frame frame = & pitch -> frame [it];
double t = Sampled_indexToX (pitch, it);
double f = frame -> candidate [1]. frequency;
if (f > 0.0 && f < pitch -> ceiling) {
Graphics_setColour (our d_graphics, Graphics_MAGENTA);
Graphics_fillCircle_mm (our d_graphics, t, f, RADIUS * 2);
}
Graphics_setColour (our d_graphics, Graphics_BLACK);
Graphics_setTextAlignment (our d_graphics, Graphics_CENTRE, Graphics_HALF);
for (int icand = 1; icand <= frame -> nCandidates; icand ++) {
int strength = (int) floor (10 * frame -> candidate [icand]. strength + 0.5);
f = frame -> candidate [icand]. frequency;
if (strength > 9) strength = 9;
if (f > 0 && f <= pitch -> ceiling) Graphics_text1 (our d_graphics, t, f, Melder_integer (strength));
}
}
Graphics_resetViewport (our d_graphics, previous);
}
/*
* Show intensity.
*/
{
Graphics_Viewport previous = Graphics_insetViewport (our d_graphics, 0, 1, 1 - dyIntens, 1);
Graphics_setWindow (our d_graphics, our d_startWindow, our d_endWindow, 0, 1);
Graphics_setColour (our d_graphics, Graphics_BLACK);
Graphics_setTextAlignment (our d_graphics, Graphics_RIGHT, Graphics_HALF);
Graphics_text (our d_graphics, our d_startWindow, 0.5, L"intens");
Graphics_setTextAlignment (our d_graphics, Graphics_LEFT, Graphics_HALF);
Graphics_text (our d_graphics, our d_endWindow, 0.5, L"intens");
Graphics_setTextAlignment (our d_graphics, Graphics_CENTRE, Graphics_HALF);
for (it = it1; it <= it2; it ++) {
Pitch_Frame frame = & pitch -> frame [it];
double t = Sampled_indexToX (pitch, it);
int strength = (int) floor (10 * frame -> intensity + 0.5); // map 0.0-1.0 to 0-9
if (strength > 9) strength = 9;
Graphics_text1 (our d_graphics, t, 0.5, Melder_integer (strength));
}
Graphics_resetViewport (our d_graphics, previous);
}
if (it1 > 1) it1 -= 1;
if (it2 < pitch -> nx) it2 += 1;
/*
* Show voicelessness.
*/
{
Graphics_Viewport previous = Graphics_insetViewport (our d_graphics, 0, 1, 0, dyUnv);
Graphics_setColour (our d_graphics, Graphics_BLUE);
Graphics_line (our d_graphics, our d_startWindow, 1, our d_endWindow, 1);
Graphics_setTextAlignment (our d_graphics, Graphics_RIGHT, Graphics_HALF);
Graphics_text (our d_graphics, our d_startWindow, 0.5, L"Unv");
Graphics_setTextAlignment (our d_graphics, Graphics_LEFT, Graphics_HALF);
Graphics_text (our d_graphics, our d_endWindow, 0.5, L"Unv");
for (it = it1; it <= it2; it ++) {
Pitch_Frame frame = & pitch -> frame [it];
double t = Sampled_indexToX (pitch, it), tleft = t - 0.5 * pitch -> dx, tright = t + 0.5 * pitch -> dx;
double f = frame -> candidate [1]. frequency;
if ((f > 0.0 && f < pitch -> ceiling) || tright <= our d_startWindow || tleft >= our d_endWindow) continue;
if (tleft < our d_startWindow) tleft = our d_startWindow;
if (tright > our d_endWindow) tright = our d_endWindow;
Graphics_fillRectangle (our d_graphics, tleft, tright, 0, 1);
}
Graphics_setColour (our d_graphics, Graphics_BLACK);
Graphics_resetViewport (our d_graphics, previous);
}
}
static void gui_drawingarea_cb_expose (I, GuiDrawingAreaExposeEvent event) {
iam (RunnerMFC);
Melder_assert (event -> widget == my d_drawingArea);
if (my graphics == NULL) return; // Could be the case in the very beginning.
ExperimentMFC experiment = (ExperimentMFC) my data;
long iresponse;
if (my data == NULL) return;
Graphics_setGrey (my graphics, 0.8);
Graphics_fillRectangle (my graphics, 0, 1, 0, 1);
Graphics_setGrey (my graphics, 0.0);
if (experiment -> trial == 0) {
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (my graphics, 24);
Graphics_text (my graphics, 0.5, 0.5, experiment -> startText);
} else if (experiment -> pausing) {
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (my graphics, 24);
Graphics_text (my graphics, 0.5, 0.5, experiment -> pauseText);
if (experiment -> oops_right > experiment -> oops_left && experiment -> trial > 1) {
drawControlButton (me,
experiment -> oops_left, experiment -> oops_right, experiment -> oops_bottom, experiment -> oops_top,
experiment -> oops_label);
}
} else if (experiment -> trial <= experiment -> numberOfTrials) {
const wchar_t *visibleText = experiment -> stimulus [experiment -> stimuli [experiment -> trial]]. visibleText;
wchar_t *visibleText_dup = Melder_wcsdup_f (visibleText ? visibleText : L""), *visibleText_p = visibleText_dup;
Graphics_setFont (my graphics, kGraphics_font_TIMES);
Graphics_setFontSize (my graphics, 10);
Graphics_setColour (my graphics, Graphics_BLACK);
Graphics_setTextAlignment (my graphics, Graphics_LEFT, Graphics_TOP);
Graphics_text3 (my graphics, 0, 1, Melder_integer (experiment -> trial), L" / ", Melder_integer (experiment -> numberOfTrials));
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_TOP);
Graphics_setFontSize (my graphics, 24);
/*
* The run text.
*/
if (visibleText_p [0] != '\0') {
wchar_t *visibleText_q = wcschr (visibleText_p, '|');
if (visibleText_q) *visibleText_q = '\0';
Graphics_text (my graphics, 0.5, 1.0, visibleText_p [0] != '\0' ? visibleText_p : experiment -> runText);
if (visibleText_q) visibleText_p = visibleText_q + 1; else visibleText_p += wcslen (visibleText_p);
} else {
Graphics_text (my graphics, 0.5, 1.0, experiment -> runText);
}
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_HALF);
for (iresponse = 1; iresponse <= experiment -> numberOfDifferentResponses; iresponse ++) {
ResponseMFC response = & experiment -> response [iresponse];
wchar_t *textToDraw = response -> label; // can be overridden
if (visibleText_p [0] != '\0') {
wchar_t *visibleText_q = wcschr (visibleText_p, '|');
if (visibleText_q) *visibleText_q = '\0';
textToDraw = visibleText_p; // override
if (visibleText_q) visibleText_p = visibleText_q + 1; else visibleText_p += wcslen (visibleText_p);
}
if (wcsnequ (textToDraw, L"\\FI", 3)) {
structMelderFile file;
MelderDir_relativePathToFile (& experiment -> rootDirectory, textToDraw + 3, & file);
Graphics_imageFromFile (my graphics, Melder_fileToPath (& file), response -> left, response -> right, response -> bottom, response -> top);
} else {
Graphics_setColour (my graphics,
response -> name [0] == '\0' ? Graphics_SILVER :
experiment -> responses [experiment -> trial] == iresponse ? Graphics_RED :
experiment -> ok_right > experiment -> ok_left || experiment -> responses [experiment -> trial] == 0 ?
Graphics_YELLOW : Graphics_SILVER);
Graphics_setLineWidth (my graphics, 3.0);
Graphics_fillRectangle (my graphics, response -> left, response -> right, response -> bottom, response -> top);
Graphics_setColour (my graphics, Graphics_MAROON);
Graphics_rectangle (my graphics, response -> left, response -> right, response -> bottom, response -> top);
Graphics_setFontSize (my graphics, response -> fontSize ? response -> fontSize : 24);
Graphics_text (my graphics, 0.5 * (response -> left + response -> right),
0.5 * (response -> bottom + response -> top), textToDraw);
}
Graphics_setFontSize (my graphics, 24);
}
for (iresponse = 1; iresponse <= experiment -> numberOfGoodnessCategories; iresponse ++) {
GoodnessMFC goodness = & experiment -> goodness [iresponse];
Graphics_setColour (my graphics, experiment -> responses [experiment -> trial] == 0 ? Graphics_SILVER :
experiment -> goodnesses [experiment -> trial] == iresponse ? Graphics_RED : Graphics_YELLOW);
Graphics_setLineWidth (my graphics, 3.0);
Graphics_fillRectangle (my graphics, goodness -> left, goodness -> right, goodness -> bottom, goodness -> top);
Graphics_setColour (my graphics, Graphics_MAROON);
Graphics_rectangle (my graphics, goodness -> left, goodness -> right, goodness -> bottom, goodness -> top);
Graphics_text (my graphics, 0.5 * (goodness -> left + goodness -> right), 0.5 * (goodness -> bottom + goodness -> top), goodness -> label);
}
if (experiment -> replay_right > experiment -> replay_left && my numberOfReplays < experiment -> maximumNumberOfReplays) {
drawControlButton (me,
experiment -> replay_left, experiment -> replay_right, experiment -> replay_bottom, experiment -> replay_top,
experiment -> replay_label);
}
if (experiment -> ok_right > experiment -> ok_left &&
experiment -> responses [experiment -> trial] != 0 &&
(experiment -> numberOfGoodnessCategories == 0 || experiment -> goodnesses [experiment -> trial] != 0))
{
drawControlButton (me,
experiment -> ok_left, experiment -> ok_right, experiment -> ok_bottom, experiment -> ok_top,
experiment -> ok_label);
}
if (experiment -> oops_right > experiment -> oops_left && experiment -> trial > 1) {
drawControlButton (me,
experiment -> oops_left, experiment -> oops_right, experiment -> oops_bottom, experiment -> oops_top,
experiment -> oops_label);
}
Melder_free (visibleText_dup);
} else {
Graphics_setTextAlignment (my graphics, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (my graphics, 24);
Graphics_text (my graphics, 0.5, 0.5, experiment -> endText);
if (experiment -> oops_right > experiment -> oops_left && experiment -> trial > 1) {
drawControlButton (me,
experiment -> oops_left, experiment -> oops_right, experiment -> oops_bottom, experiment -> oops_top,
experiment -> oops_label);
}
}
}
void FFNet_drawTopology (FFNet me, Graphics g) {
long maxNumOfUnits = my nUnitsInLayer[0];
int dxIsFixed = 1;
double dy = 1.0 / (my nLayers + 1);
for (long i = 1; i <= my nLayers; i++) {
if (my nUnitsInLayer[i] > maxNumOfUnits) {
maxNumOfUnits = my nUnitsInLayer[i];
}
}
double dx = 1.0 / maxNumOfUnits;
double radius = dx / 10.0;
Graphics_setInner (g);
Graphics_setWindow (g, 0.0, 1.0, 0.0, 1.0);
for (long i = 0; i <= my nLayers; i++) {
double dx2 = dx, x2WC, y2WC = dy / 2 + i * dy;
double x2 = (maxNumOfUnits - my nUnitsInLayer[i] + 1) * dx2 / 2;
/* draw the units */
if (! dxIsFixed) {
dx2 = 1.0 / my nUnitsInLayer[i];
x2 = dx2 / 2.0;
}
if (i == 0) {
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_TOP);
x2WC = x2;
for (long j = 1; j <= my nInputs; j++) {
Graphics_arrow (g, x2WC, y2WC - radius - dy / 4.0, x2WC, y2WC - radius);
x2WC += dx2;
}
}
Graphics_setColour (g, Graphics_RED);
x2WC = x2;
for (long j = 1; j <= my nUnitsInLayer[i]; j++) {
Graphics_circle (g, x2WC, y2WC, radius);
if (i > 0) {
Graphics_fillCircle (g, x2WC, y2WC, radius);
}
x2WC += dx2;
}
Graphics_setColour (g, Graphics_BLACK);
if (i > 0) {
double dx1 = dx;
double x1 = (maxNumOfUnits - my nUnitsInLayer[i - 1] + 1) * dx1 / 2.0;
double y1WC = y2WC - dy;
if (! dxIsFixed) {
dx1 = 1.0 / my nUnitsInLayer[i - 1];
x1 = dx1 / 2.0;
}
x2WC = x2;
for (long j = 1; j <= my nUnitsInLayer[i]; j++) {
double x1WC = x1;
for (long k = 1; k <= my nUnitsInLayer[i - 1]; k++) {
double xd = x2WC - x1WC;
double cosa = xd / sqrt (xd * xd + dy * dy);
double sina = dy / sqrt (xd * xd + dy * dy);
Graphics_line (g, x1WC + radius * cosa, y1WC + radius * sina, x2WC - radius * cosa, y2WC - radius * sina);
x1WC += dx1;
}
x2WC += dx2;
}
}
if (i == my nLayers) {
x2WC = x2;
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_BOTTOM);
for (long j = 1; j <= my nOutputs; j++) {
Graphics_arrow (g, x2WC, y2WC + radius, x2WC, y2WC + radius + dy / 4.0);
if (my outputCategories) {
Categories_drawItem (my outputCategories.peek(), g, j, x2WC, y2WC + radius + dy / 4.0);
}
x2WC += dx2;
}
}
}
Graphics_unsetInner (g);
}
void structTableEditor :: v_draw () {
Table table = static_cast<Table> (data);
double spacing = 2.0; // millimetres at both edges
double columnWidth, cellWidth;
/*
* We fit 200 rows in 40 inches, which is 14.4 points per row.
*/
long rowmin = topRow, rowmax = rowmin + 197;
long colmin = leftColumn, colmax = colmin + (kTableEditor_MAXNUM_VISIBLE_COLUMNS - 1);
if (rowmax > table -> rows.size) rowmax = table -> rows.size;
if (colmax > table -> numberOfColumns) colmax = table -> numberOfColumns;
Graphics_clearWs (graphics.get());
Graphics_setTextAlignment (graphics.get(), Graphics_CENTRE, Graphics_HALF);
Graphics_setWindow (graphics.get(), 0.0, 1.0, rowmin + 197.5, rowmin - 2.5);
Graphics_setColour (graphics.get(), Graphics_SILVER);
Graphics_fillRectangle (graphics.get(), 0.0, 1.0, rowmin - 2.5, rowmin - 0.5);
Graphics_setColour (graphics.get(), Graphics_BLACK);
Graphics_line (graphics.get(), 0.0, rowmin - 0.5, 1.0, rowmin - 0.5);
Graphics_setWindow (graphics.get(), 0.0, Graphics_dxWCtoMM (graphics.get(), 1.0), rowmin + 197.5, rowmin - 2.5);
/*
* Determine the width of the column with the row numbers.
*/
columnWidth = Graphics_textWidth (graphics.get(), U"row");
for (long irow = rowmin; irow <= rowmax; irow ++) {
cellWidth = Graphics_textWidth (graphics.get(), Melder_integer (irow));
if (cellWidth > columnWidth) columnWidth = cellWidth;
}
columnLeft [0] = columnWidth + 2 * spacing;
Graphics_setColour (graphics.get(), Graphics_SILVER);
Graphics_fillRectangle (graphics.get(), 0.0, columnLeft [0], rowmin - 0.5, rowmin + 197.5);
Graphics_setColour (graphics.get(), Graphics_BLACK);
Graphics_line (graphics.get(), columnLeft [0], rowmin - 0.5, columnLeft [0], rowmin + 197.5);
/*
* Determine the width of the columns.
*/
for (long icol = colmin; icol <= colmax; icol ++) {
const char32 *columnLabel = table -> columnHeaders [icol]. label;
columnWidth = Graphics_textWidth (graphics.get(), Melder_integer (icol));
if (! columnLabel) columnLabel = U"";
cellWidth = Graphics_textWidth (graphics.get(), columnLabel);
if (cellWidth > columnWidth) columnWidth = cellWidth;
for (long irow = rowmin; irow <= rowmax; irow ++) {
const char32 *cell = Table_getStringValue_Assert (table, irow, icol);
Melder_assert (cell);
if (cell [0] == U'\0') cell = U"?";
cellWidth = Graphics_textWidth (graphics.get(), cell);
if (cellWidth > columnWidth) columnWidth = cellWidth;
}
columnRight [icol - colmin] = columnLeft [icol - colmin] + columnWidth + 2 * spacing;
if (icol < colmax) columnLeft [icol - colmin + 1] = columnRight [icol - colmin];
}
/*
Text can be "graphic" or not.
*/
Graphics_setPercentSignIsItalic (our graphics.get(), our p_useTextStyles);
Graphics_setNumberSignIsBold (our graphics.get(), our p_useTextStyles);
Graphics_setCircumflexIsSuperscript (our graphics.get(), our p_useTextStyles);
Graphics_setUnderscoreIsSubscript (our graphics.get(), our p_useTextStyles);
/*
* Show the row numbers.
*/
Graphics_text (graphics.get(), columnLeft [0] / 2, rowmin - 1, U"row");
for (long irow = rowmin; irow <= rowmax; irow ++) {
Graphics_text (graphics.get(), columnLeft [0] / 2, irow, irow);
}
/*
* Show the column labels.
*/
for (long icol = colmin; icol <= colmax; icol ++) {
double mid = (columnLeft [icol - colmin] + columnRight [icol - colmin]) / 2;
const char32 *columnLabel = table -> columnHeaders [icol]. label;
if (! columnLabel || columnLabel [0] == U'\0') columnLabel = U"?";
Graphics_text (graphics.get(), mid, rowmin - 2, icol);
Graphics_text (graphics.get(), mid, rowmin - 1, columnLabel);
}
/*
* Show the cell contents.
*/
for (long irow = rowmin; irow <= rowmax; irow ++) {
for (long icol = colmin; icol <= colmax; icol ++) {
double mid = (columnLeft [icol - colmin] + columnRight [icol - colmin]) / 2;
const char32 *cell = Table_getStringValue_Assert (table, irow, icol);
Melder_assert (cell);
if (cell [0] == U'\0') cell = U"?";
Graphics_text (graphics.get(), mid, irow, cell);
}
}
}
void structSoundEditor :: v_draw () {
Sampled data = (Sampled) this -> data;
Graphics_Viewport viewport;
bool showAnalysis = p_spectrogram_show || p_pitch_show || p_intensity_show || p_formant_show;
Melder_assert (data);
Melder_assert (d_sound.data || d_longSound.data);
/*
* We check beforehand whether the window fits the LongSound buffer.
*/
if (d_longSound.data && d_endWindow - d_startWindow > d_longSound.data -> bufferLength) {
Graphics_setColour (d_graphics.get(), Graphics_WHITE);
Graphics_setWindow (d_graphics.get(), 0.0, 1.0, 0.0, 1.0);
Graphics_fillRectangle (d_graphics.get(), 0.0, 1.0, 0.0, 1.0);
Graphics_setColour (d_graphics.get(), Graphics_BLACK);
Graphics_setTextAlignment (d_graphics.get(), Graphics_CENTRE, Graphics_BOTTOM);
Graphics_text (d_graphics.get(), 0.5, 0.5, U"(window longer than ", Melder_float (Melder_single (d_longSound.data -> bufferLength)), U" seconds)");
Graphics_setTextAlignment (d_graphics.get(), Graphics_CENTRE, Graphics_TOP);
Graphics_text (d_graphics.get(), 0.5, 0.5, U"(zoom in to see the samples)");
return;
}
/* Draw sound. */
if (showAnalysis)
viewport = Graphics_insetViewport (d_graphics.get(), 0.0, 1.0, 0.5, 1.0);
Graphics_setColour (d_graphics.get(), Graphics_WHITE);
Graphics_setWindow (d_graphics.get(), 0.0, 1.0, 0.0, 1.0);
Graphics_fillRectangle (d_graphics.get(), 0.0, 1.0, 0.0, 1.0);
TimeSoundEditor_drawSound (this, d_sound.minimum, d_sound.maximum);
Graphics_flushWs (d_graphics.get());
if (showAnalysis)
Graphics_resetViewport (d_graphics.get(), viewport);
/* Draw analyses. */
if (showAnalysis) {
/* Draw spectrogram, pitch, formants. */
viewport = Graphics_insetViewport (d_graphics.get(), 0.0, 1.0, 0.0, 0.5);
v_draw_analysis ();
Graphics_flushWs (d_graphics.get());
Graphics_resetViewport (d_graphics.get(), viewport);
}
/* Draw pulses. */
if (p_pulses_show) {
if (showAnalysis)
viewport = Graphics_insetViewport (d_graphics.get(), 0.0, 1.0, 0.5, 1.0);
v_draw_analysis_pulses ();
TimeSoundEditor_drawSound (this, d_sound.minimum, d_sound.maximum); // second time, partially across the pulses
Graphics_flushWs (d_graphics.get());
if (showAnalysis)
Graphics_resetViewport (d_graphics.get(), viewport);
}
/* Update buttons. */
long first, last;
long selectedSamples = Sampled_getWindowSamples (data, d_startSelection, d_endSelection, & first, & last);
v_updateMenuItems_file ();
if (d_sound.data) {
GuiThing_setSensitive (cutButton , selectedSamples != 0 && selectedSamples < d_sound.data -> nx);
GuiThing_setSensitive (copyButton , selectedSamples != 0);
GuiThing_setSensitive (zeroButton , selectedSamples != 0);
GuiThing_setSensitive (reverseButton , selectedSamples != 0);
}
}
int HyperPage_script (I, double width_inches, double height_inches, const wchar_t *script) {
iam (HyperPage);
wchar_t *text = Melder_wcsdup_f (script);
Interpreter interpreter = Interpreter_createFromEnvironment (NULL);
double topSpacing = 0.1, bottomSpacing = 0.1, minFooterDistance = 0.0;
kGraphics_font font = my font;
int size = my fontSize;
double true_width_inches = width_inches * ( width_inches < 0.0 ? -1.0 : size / 12.0 );
double true_height_inches = height_inches * ( height_inches < 0.0 ? -1.0 : size / 12.0 );
if (! my printing) {
my d_y -= ( my previousBottomSpacing > topSpacing ? my previousBottomSpacing : topSpacing ) * size / 12.0;
if (my d_y > PAGE_HEIGHT + true_height_inches || my d_y < PAGE_HEIGHT - SCREEN_HEIGHT) {
my d_y -= true_height_inches;
} else {
my d_y -= true_height_inches;
Graphics_setFont (my g, font);
Graphics_setFontStyle (my g, 0);
Graphics_setFontSize (my g, size);
my d_x = true_width_inches > my rightMargin ? 0 : 0.5 * (my rightMargin - true_width_inches);
Graphics_setWrapWidth (my g, 0);
long x1DCold, x2DCold, y1DCold, y2DCold;
Graphics_inqWsViewport (my g, & x1DCold, & x2DCold, & y1DCold, & y2DCold);
double x1NDCold, x2NDCold, y1NDCold, y2NDCold;
Graphics_inqWsWindow (my g, & x1NDCold, & x2NDCold, & y1NDCold, & y2NDCold);
{
if (my praatApplication == NULL) my praatApplication = Melder_calloc_f (structPraatApplication, 1);
if (my praatObjects == NULL) my praatObjects = Melder_calloc_f (structPraatObjects, 1);
if (my praatPicture == NULL) my praatPicture = Melder_calloc_f (structPraatPicture, 1);
theCurrentPraatApplication = (PraatApplication) my praatApplication;
theCurrentPraatApplication -> batch = true; // prevent creation of editor windows
theCurrentPraatApplication -> topShell = theForegroundPraatApplication. topShell; // needed for UiForm_create () in dialogs
theCurrentPraatObjects = (PraatObjects) my praatObjects;
theCurrentPraatPicture = (PraatPicture) my praatPicture;
theCurrentPraatPicture -> graphics = my g; // has to draw into HyperPage rather than Picture window
theCurrentPraatPicture -> font = font;
theCurrentPraatPicture -> fontSize = size;
theCurrentPraatPicture -> lineType = Graphics_DRAWN;
theCurrentPraatPicture -> colour = Graphics_BLACK;
theCurrentPraatPicture -> lineWidth = 1.0;
theCurrentPraatPicture -> arrowSize = 1.0;
theCurrentPraatPicture -> x1NDC = my d_x;
theCurrentPraatPicture -> x2NDC = my d_x + true_width_inches;
theCurrentPraatPicture -> y1NDC = my d_y;
theCurrentPraatPicture -> y2NDC = my d_y + true_height_inches;
Graphics_setViewport (my g, theCurrentPraatPicture -> x1NDC, theCurrentPraatPicture -> x2NDC, theCurrentPraatPicture -> y1NDC, theCurrentPraatPicture -> y2NDC);
Graphics_setWindow (my g, 0.0, 1.0, 0.0, 1.0);
long x1DC, y1DC, x2DC, y2DC;
Graphics_WCtoDC (my g, 0.0, 0.0, & x1DC, & y2DC);
Graphics_WCtoDC (my g, 1.0, 1.0, & x2DC, & y1DC);
Graphics_resetWsViewport (my g, x1DC, x2DC, y1DC, y2DC);
Graphics_setWsWindow (my g, 0, width_inches, 0, height_inches);
theCurrentPraatPicture -> x1NDC = 0;
theCurrentPraatPicture -> x2NDC = width_inches;
theCurrentPraatPicture -> y1NDC = 0;
theCurrentPraatPicture -> y2NDC = height_inches;
Graphics_setViewport (my g, theCurrentPraatPicture -> x1NDC, theCurrentPraatPicture -> x2NDC, theCurrentPraatPicture -> y1NDC, theCurrentPraatPicture -> y2NDC);
{ // scope
autoMelderProgressOff progress;
autoMelderWarningOff warning;
autoMelderSaveDefaultDir saveDir;
if (! MelderDir_isNull (& my rootDirectory)) {
Melder_setDefaultDir (& my rootDirectory);
}
try {
Interpreter_run (interpreter, text);
} catch (MelderError) {
if (my scriptErrorHasBeenNotified) {
Melder_clearError ();
} else {
Melder_flushError (NULL);
my scriptErrorHasBeenNotified = true;
}
}
}
Graphics_setLineType (my g, Graphics_DRAWN);
Graphics_setLineWidth (my g, 1.0);
Graphics_setArrowSize (my g, 1.0);
Graphics_setColour (my g, Graphics_BLACK);
/*Graphics_Link *paragraphLinks;
long numberOfParagraphLinks = Graphics_getLinks (& paragraphLinks);
if (my links) for (long ilink = 1; ilink <= numberOfParagraphLinks; ilink ++) {
HyperLink link = HyperLink_create (paragraphLinks [ilink]. name,
paragraphLinks [ilink]. x1, paragraphLinks [ilink]. x2,
paragraphLinks [ilink]. y1, paragraphLinks [ilink]. y2);
Collection_addItem (my links, link);
}*/
theCurrentPraatApplication = & theForegroundPraatApplication;
theCurrentPraatObjects = & theForegroundPraatObjects;
theCurrentPraatPicture = & theForegroundPraatPicture;
}
Graphics_resetWsViewport (my g, x1DCold, x2DCold, y1DCold, y2DCold);
Graphics_setWsWindow (my g, x1NDCold, x2NDCold, y1NDCold, y2NDCold);
Graphics_setViewport (my g, 0, 1, 0, 1);
Graphics_setWindow (my g, 0, 1, 0, 1);
Graphics_setTextAlignment (my g, Graphics_LEFT, Graphics_BOTTOM);
}
} else {
Graphics_setFont (my ps, font);
Graphics_setFontStyle (my ps, 0);
Graphics_setFontSize (my ps, size);
my d_y -= my d_y == PAPER_TOP - TOP_MARGIN ? 0 : ( my previousBottomSpacing > topSpacing ? my previousBottomSpacing : topSpacing ) * size / 12.0;
my d_y -= true_height_inches;
if (my d_y < PAPER_BOTTOM + BOTTOM_MARGIN + minFooterDistance) {
Graphics_nextSheetOfPaper (my ps);
if (my d_printingPageNumber) my d_printingPageNumber ++;
HyperPage_initSheetOfPaper (me);
Graphics_setFont (my ps, font);
Graphics_setFontSize (my ps, size);
my d_y -= true_height_inches;
}
my d_x = 3.7 - 0.5 * true_width_inches;
if (my d_x < 0) my d_x = 0;
Graphics_setWrapWidth (my ps, 0);
long x1DCold, x2DCold, y1DCold, y2DCold;
Graphics_inqWsViewport (my ps, & x1DCold, & x2DCold, & y1DCold, & y2DCold);
double x1NDCold, x2NDCold, y1NDCold, y2NDCold;
Graphics_inqWsWindow (my ps, & x1NDCold, & x2NDCold, & y1NDCold, & y2NDCold);
{
if (my praatApplication == NULL) my praatApplication = Melder_calloc_f (structPraatApplication, 1);
if (my praatObjects == NULL) my praatObjects = Melder_calloc_f (structPraatObjects, 1);
if (my praatPicture == NULL) my praatPicture = Melder_calloc_f (structPraatPicture, 1);
theCurrentPraatApplication = (PraatApplication) my praatApplication;
theCurrentPraatApplication -> batch = true;
theCurrentPraatApplication -> topShell = theForegroundPraatApplication. topShell; // needed for UiForm_create () in dialogs
theCurrentPraatObjects = (PraatObjects) my praatObjects;
theCurrentPraatPicture = (PraatPicture) my praatPicture;
theCurrentPraatPicture -> graphics = my ps;
theCurrentPraatPicture -> font = font;
theCurrentPraatPicture -> fontSize = size;
theCurrentPraatPicture -> lineType = Graphics_DRAWN;
theCurrentPraatPicture -> colour = Graphics_BLACK;
theCurrentPraatPicture -> lineWidth = 1.0;
theCurrentPraatPicture -> arrowSize = 1.0;
theCurrentPraatPicture -> x1NDC = my d_x;
theCurrentPraatPicture -> x2NDC = my d_x + true_width_inches;
theCurrentPraatPicture -> y1NDC = my d_y;
theCurrentPraatPicture -> y2NDC = my d_y + true_height_inches;
Graphics_setViewport (my ps, theCurrentPraatPicture -> x1NDC, theCurrentPraatPicture -> x2NDC, theCurrentPraatPicture -> y1NDC, theCurrentPraatPicture -> y2NDC);
Graphics_setWindow (my ps, 0.0, 1.0, 0.0, 1.0);
long x1DC, y1DC, x2DC, y2DC;
Graphics_WCtoDC (my ps, 0.0, 0.0, & x1DC, & y2DC);
Graphics_WCtoDC (my ps, 1.0, 1.0, & x2DC, & y1DC);
long shift = (long) (Graphics_getResolution (my ps) * true_height_inches) + (y1DCold - y2DCold);
Graphics_resetWsViewport (my ps, x1DC, x2DC, y1DC + shift, y2DC + shift);
Graphics_setWsWindow (my ps, 0, width_inches, 0, height_inches);
theCurrentPraatPicture -> x1NDC = 0;
theCurrentPraatPicture -> x2NDC = width_inches;
theCurrentPraatPicture -> y1NDC = 0;
theCurrentPraatPicture -> y2NDC = height_inches;
Graphics_setViewport (my ps, theCurrentPraatPicture -> x1NDC, theCurrentPraatPicture -> x2NDC, theCurrentPraatPicture -> y1NDC, theCurrentPraatPicture -> y2NDC);
{ // scope
autoMelderProgressOff progress;
autoMelderWarningOff warning;
autoMelderSaveDefaultDir saveDir;
if (! MelderDir_isNull (& my rootDirectory)) {
Melder_setDefaultDir (& my rootDirectory);
}
try {
Interpreter_run (interpreter, text);
} catch (MelderError) {
Melder_clearError ();
}
}
Graphics_setLineType (my ps, Graphics_DRAWN);
Graphics_setLineWidth (my ps, 1.0);
Graphics_setArrowSize (my ps, 1.0);
Graphics_setColour (my ps, Graphics_BLACK);
theCurrentPraatApplication = & theForegroundPraatApplication;
theCurrentPraatObjects = & theForegroundPraatObjects;
theCurrentPraatPicture = & theForegroundPraatPicture;
}
Graphics_resetWsViewport (my ps, x1DCold, x2DCold, y1DCold, y2DCold);
Graphics_setWsWindow (my ps, x1NDCold, x2NDCold, y1NDCold, y2NDCold);
Graphics_setViewport (my ps, 0, 1, 0, 1);
Graphics_setWindow (my ps, 0, 1, 0, 1);
Graphics_setTextAlignment (my ps, Graphics_LEFT, Graphics_BOTTOM);
}
my previousBottomSpacing = bottomSpacing;
forget (interpreter);
Melder_free (text);
return 1;
}
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 structERPWindow :: v_drawSelectionViewer () {
ERP erp = (ERP) data;
Graphics_setWindow (d_graphics, -1.1, 1.1, -1.01, 1.19);
Graphics_setGrey (d_graphics, 0.85);
Graphics_fillRectangle (d_graphics, -1.1, 1.1, -1.01, 1.19);
Graphics_setColour (d_graphics, Graphics_BLACK);
long numberOfDrawableChannels =
erp -> ny >= 64 && Melder_wcsequ (erp -> d_channelNames [64], L"O2") ? 64 :
erp -> ny >= 32 && Melder_wcsequ (erp -> d_channelNames [32], L"Cz") ? 32 :
0;
BiosemiLocationData *biosemiLocationData = numberOfDrawableChannels == 64 ? biosemiCapCoordinates64 : numberOfDrawableChannels == 32 ? biosemiCapCoordinates32 : 0;
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
double inclination = (double) biosemiLocationData [ichan]. inclination;
double azimuth = (double) biosemiLocationData [ichan]. azimuth;
bool rightHemisphere = inclination >= 0.0;
double r = fabs (inclination / 115.0);
double theta = rightHemisphere ? azimuth * (NUMpi / 180.0) : (azimuth + 180.0) * (NUMpi / 180.0);
biosemiLocationData [ichan]. topX = r * cos (theta);
biosemiLocationData [ichan]. topY = r * sin (theta);
}
long n = 201;
double d = 2.0 / (n - 1);
autoNUMvector <double> mean (1, numberOfDrawableChannels);
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
mean [ichan] =
d_startSelection == d_endSelection ?
Sampled_getValueAtX (erp, d_startSelection, ichan, 0, true) :
Vector_getMean (erp, d_startSelection, d_endSelection, ichan);
}
autoNUMmatrix <double> image (1, n, 1, n);
for (long irow = 1; irow <= n; irow ++) {
double y = -1.0 + (irow - 1) * d;
for (long icol = 1; icol <= n; icol ++) {
double x = -1.0 + (icol - 1) * d;
if (x * x + y * y <= 1.0) {
double value = NUMundefined, sum = 0.0, weight = 0.0;
for (long ichan = 1; ichan <= numberOfDrawableChannels; ichan ++) {
double dx = x - biosemiLocationData [ichan]. topX;
double dy = y - biosemiLocationData [ichan]. topY;
double distance = sqrt (dx * dx + dy * dy);
if (distance < 1e-12) {
value = mean [ichan];
break;
}
distance = distance * distance * distance * distance * distance * distance;
sum += mean [ichan] / distance;
weight += 1.0 / distance;
}
if (value == NUMundefined)
value = ( sum == 0.0 ? 0.0 : sum / weight );
image [irow] [icol] = value;
}
}
}
double minimum = 0.0, maximum = 0.0;
for (long irow = 1; irow <= n; irow ++) {
for (long icol = 1; icol <= n; icol ++) {
double value = image [irow] [icol];
if (value < minimum) minimum = value;
else if (value > maximum) maximum = value;
}
}
double absoluteExtremum = - minimum > maximum ? - minimum : maximum;
if (d_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_FIXED_RANGE) {
minimum = d_sound_scaling_minimum;
maximum = d_sound_scaling_maximum;
} else if (d_sound_scalingStrategy == kTimeSoundEditor_scalingStrategy_FIXED_HEIGHT) {
double mean = 0.5 * (minimum + maximum);
minimum = mean - 0.5 * d_sound_scaling_height;
maximum = mean + 0.5 * d_sound_scaling_height;
} else {
minimum = - absoluteExtremum;
maximum = absoluteExtremum;
}
for (long irow = 1; irow <= n; irow ++) {
double y = -1.0 + (irow - 1) * d;
for (long icol = 1; icol <= n; icol ++) {
double x = -1.0 + (icol - 1) * d;
if (x * x + y * y > 1.0) {
image [irow] [icol] = minimum + 0.1875 * (maximum - minimum); // -0.625 * absoluteExtremum;
}
}
}
Graphics_image (d_graphics, image.peek(), 1, n, -1.0-0.5/n, 1.0+0.5/n, 1, n, -1.0-0.5/n, 1.0+0.5/n, minimum, maximum);
Graphics_setLineWidth (d_graphics, 2.0);
/*
* Nose.
*/
Graphics_setGrey (d_graphics, 0.5);
{// scope
double x [3] = { -0.08, 0.0, 0.08 }, y [3] = { 0.99, 1.18, 0.99 };
Graphics_fillArea (d_graphics, 3, x, y);
}
Graphics_setColour (d_graphics, Graphics_BLACK);
Graphics_line (d_graphics, -0.08, 0.99, 0.0, 1.18);
Graphics_line (d_graphics, 0.08, 0.99, 0.0, 1.18);
/*
* Ears.
*/
Graphics_setGrey (d_graphics, 0.5);
Graphics_fillRectangle (d_graphics, -1.09, -1.00, -0.08, 0.08);
Graphics_fillRectangle (d_graphics, 1.09, 1.00, -0.08, 0.08);
Graphics_setColour (d_graphics, Graphics_BLACK);
Graphics_line (d_graphics, -0.99, 0.08, -1.09, 0.08);
Graphics_line (d_graphics, -1.09, 0.08, -1.09, -0.08);
Graphics_line (d_graphics, -1.09, -0.08, -0.99, -0.08);
Graphics_line (d_graphics, 0.99, 0.08, 1.09, 0.08);
Graphics_line (d_graphics, 1.09, 0.08, 1.09, -0.08);
Graphics_line (d_graphics, 1.09, -0.08, 0.99, -0.08);
/*
* Scalp.
*/
Graphics_ellipse (d_graphics, -1.0, 1.0, -1.0, 1.0);
Graphics_setLineWidth (d_graphics, 1.0);
}