void TextGrid_Pitch_draw (TextGrid grid, Pitch pitch, Graphics g,
long tierNumber, double tmin, double tmax, double fmin, double fmax,
double fontSize, int useTextStyles, int horizontalAlignment, int garnish, int speckle, int unit)
{
try {
TextGrid_checkSpecifiedTierNumberWithinRange (grid, tierNumber);
double oldFontSize = Graphics_inqFontSize (g);
Pitch_draw (pitch, g, tmin, tmax, fmin, fmax, garnish, speckle, unit);
if (tmax <= tmin) tmin = grid -> xmin, tmax = grid -> xmax;
autoPitchTier pitchTier = Pitch_to_PitchTier (pitch);
if (Function_isUnitLogarithmic (pitch, Pitch_LEVEL_FREQUENCY, unit)) {
fmin = Function_convertStandardToSpecialUnit (pitch, fmin, Pitch_LEVEL_FREQUENCY, unit);
fmax = Function_convertStandardToSpecialUnit (pitch, fmax, Pitch_LEVEL_FREQUENCY, unit);
}
Graphics_setTextAlignment (g, horizontalAlignment, Graphics_BOTTOM);
Graphics_setInner (g);
Graphics_setFontSize (g, fontSize);
Graphics_setPercentSignIsItalic (g, useTextStyles);
Graphics_setNumberSignIsBold (g, useTextStyles);
Graphics_setCircumflexIsSuperscript (g, useTextStyles);
Graphics_setUnderscoreIsSubscript (g, useTextStyles);
Function anyTier = (Function) grid -> tiers -> item [tierNumber];
if (anyTier -> classInfo == classIntervalTier) {
IntervalTier tier = (IntervalTier) anyTier;
for (long i = 1; i <= tier -> intervals -> size; i ++) {
TextInterval interval = (TextInterval) tier -> intervals -> item [i];
double tleft = interval -> xmin, tright = interval -> xmax, tmid, f0;
if (! interval -> text || ! interval -> text [0]) continue;
if (tleft < pitch -> xmin) tleft = pitch -> xmin;
if (tright > pitch -> xmax) tright = pitch -> xmax;
tmid = (tleft + tright) / 2;
if (tmid < tmin || tmid > tmax) continue;
f0 = Function_convertStandardToSpecialUnit (pitch, RealTier_getValueAtTime (pitchTier.peek(), tmid), Pitch_LEVEL_FREQUENCY, unit);
if (f0 < fmin || f0 > fmax) continue;
Graphics_text (g,
horizontalAlignment == Graphics_LEFT ? tleft : horizontalAlignment == Graphics_RIGHT ? tright : tmid,
f0, interval -> text);
}
} else {
TextTier tier = (TextTier) anyTier;
for (long i = 1; i <= tier -> points -> size; i ++) {
TextPoint point = (TextPoint) tier -> points -> item [i];
double t = point -> number, f0;
if (! point -> mark || ! point -> mark [0]) continue;
if (t < tmin || t > tmax) continue;
f0 = Function_convertStandardToSpecialUnit (pitch, RealTier_getValueAtTime (pitchTier.peek(), t), Pitch_LEVEL_FREQUENCY, unit);
if (f0 < fmin || f0 > fmax) continue;
Graphics_text (g, t, f0, point -> mark);
}
}
Graphics_setPercentSignIsItalic (g, TRUE);
Graphics_setNumberSignIsBold (g, TRUE);
Graphics_setCircumflexIsSuperscript (g, TRUE);
Graphics_setUnderscoreIsSubscript (g, TRUE);
Graphics_setFontSize (g, oldFontSize);
Graphics_unsetInner (g);
} catch (MelderError) {
Melder_throw (grid, " & ", pitch, ": not drawn.");
}
}
static void drawWhileDragging (FormantGridEditor me, double xWC, double yWC, long first, long last, double dt, double dy) {
FormantGrid grid = (FormantGrid) my data;
Ordered tiers = my editingBandwidths ? grid -> bandwidths : grid -> formants;
RealTier tier = (RealTier) tiers -> item [my selectedFormant];
double ymin = my editingBandwidths ? my p_bandwidthFloor : my p_formantFloor;
double ymax = my editingBandwidths ? my p_bandwidthCeiling : my p_formantCeiling;
(void) xWC;
(void) yWC;
/*
* Draw all selected points as magenta empty circles, if inside the window.
*/
for (long i = first; i <= last; i ++) {
RealPoint point = (RealPoint) tier -> points -> item [i];
double t = point -> number + dt, y = point -> value + dy;
if (t >= my d_startWindow && t <= my d_endWindow)
Graphics_circle_mm (my d_graphics, t, y, 3);
}
if (last == first) {
/*
* Draw a crosshair with time and y.
*/
RealPoint point = (RealPoint) tier -> points -> item [first];
double t = point -> number + dt, y = point -> value + dy;
Graphics_line (my d_graphics, t, ymin, t, ymax - Graphics_dyMMtoWC (my d_graphics, 4.0));
Graphics_setTextAlignment (my d_graphics, kGraphics_horizontalAlignment_CENTRE, Graphics_TOP);
Graphics_text (my d_graphics, t, ymax, Melder_fixed (t, 6));
Graphics_line (my d_graphics, my d_startWindow, y, my d_endWindow, y);
Graphics_setTextAlignment (my d_graphics, Graphics_LEFT, Graphics_BOTTOM);
Graphics_text (my d_graphics, my d_startWindow, y, Melder_fixed (y, 6));
}
}
void Transition_drawAsNumbers (I, Graphics g, int iformat, int precision) {
iam (Transition);
double maxTextWidth = 0, maxTextHeight = 0;
Graphics_setInner (g);
Graphics_setWindow (g, 0.5, my numberOfStates + 0.5, 0, 1);
double leftMargin = Graphics_dxMMtoWC (g, 1);
double lineSpacing = Graphics_dyMMtoWC (g, 1.5 * Graphics_inqFontSize (g) * 25.4 / 72);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_BOTTOM);
for (long col = 1; col <= my numberOfStates; col ++) {
if (my stateLabels && my stateLabels [col] && my stateLabels [col] [0]) {
Graphics_text (g, col, 1, my stateLabels [col]);
if (! maxTextHeight) maxTextHeight = lineSpacing;
}
}
for (long row = 1; row <= my numberOfStates; row ++) {
double y = 1 - lineSpacing * (row - 1 + 0.7);
Graphics_setTextAlignment (g, Graphics_RIGHT, Graphics_HALF);
if (my stateLabels && my stateLabels [row]) {
double textWidth = Graphics_textWidth (g, my stateLabels [row]);
if (textWidth > maxTextWidth) maxTextWidth = textWidth;
Graphics_text (g, 0.5 - leftMargin, y, my stateLabels [row]);
}
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
for (long col = 1; col <= my numberOfStates; col ++) {
wchar text [40];
print4 (text, my data [row] [col], iformat, 0, precision);
Graphics_text (g, col, y, text);
}
}
if (maxTextWidth)
Graphics_line (g, 0.5 - maxTextWidth - leftMargin, 1, my numberOfStates + 0.5, 1);
if (maxTextHeight)
Graphics_line (g, 0.5, 1 + maxTextHeight, 0.5, 1 - lineSpacing * (my numberOfStates + 0.2));
Graphics_unsetInner (g);
}
void TableOfReal_drawAsNumbers (TableOfReal me, Graphics graphics, long rowmin, long rowmax, int iformat, int precision) {
fixRows (me, & rowmin, & rowmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, 0.5, my numberOfColumns + 0.5, 0, 1);
double leftMargin = getLeftMargin (graphics); // not earlier!
double lineSpacing = getLineSpacing (graphics); // not earlier!
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_BOTTOM);
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
if (my columnLabels && my columnLabels [icol] && my columnLabels [icol] [0])
Graphics_text (graphics, icol, 1, my columnLabels [icol]);
}
for (long irow = rowmin; irow <= rowmax; irow ++) {
double y = 1 - lineSpacing * (irow - rowmin + 0.6);
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_HALF);
if (my rowLabels && my rowLabels [irow] && my rowLabels [irow] [0])
Graphics_text (graphics, 0.5 - leftMargin, y, my rowLabels [irow]);
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_HALF);
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
wchar_t text [40];
print4 (text, my data [irow] [icol], iformat, 0, precision);
Graphics_text (graphics, icol, y, text);
}
}
if (maxTextHeight) {
double left = 0.5;
if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * leftMargin;
Graphics_line (graphics, left, 1, my numberOfColumns + 0.5, 1);
}
Graphics_unsetInner (graphics);
}
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 EditDistanceTable_draw (EditDistanceTable me, Graphics graphics, int iformat, int precision, double angle) {
long rowmin = 1, rowmax = my numberOfRows;
Graphics_setInner (graphics);
Graphics_setWindow (graphics, 0.5, my numberOfColumns + 0.5, 0, 1);
double leftMargin = getLeftMargin (graphics); // not earlier!
double lineSpacing = getLineSpacing (graphics); // not earlier!
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double y = 1 + 0.1 * lineSpacing;
autoNUMmatrix<bool> onPath (1, my numberOfRows, 1, my numberOfColumns);
for (long i = 1; i <= my warpingPath -> pathLength; i++) {
structPairOfInteger poi = my warpingPath -> path[i];
onPath[poi.y] [poi.x] = true;
}
for (long irow = my numberOfRows; irow > 0; irow --) {
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_HALF);
if (my rowLabels && my rowLabels [irow] && my rowLabels [irow] [0])
Graphics_text (graphics, 0.5 - leftMargin, y, my rowLabels [irow]);
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_HALF);
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
char text [40];
print4 (text, my data [irow] [icol], iformat, 0, precision);
Graphics_setBold (graphics, onPath[irow][icol]);
Graphics_text (graphics, icol, y, Melder_peek8to32 (text));
if (onPath[irow][icol]) {
Graphics_rectangle (graphics, icol-0.5, icol+0.5, y - 0.5*lineSpacing, y + 0.5*lineSpacing);
}
}
y -= lineSpacing;
Graphics_setBold (graphics, false);
}
double left = 0.5;
if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * leftMargin;
Graphics_line (graphics, left, y, my numberOfColumns + 0.5, y);
Graphics_setTextRotation (graphics, angle);
if (angle < 0) {
y -= 0.3*lineSpacing;
Graphics_setTextAlignment (graphics, Graphics_LEFT, Graphics_HALF);
} else if (angle > 0) {
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_HALF);
y -= 0.3*lineSpacing;
} else {
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_TOP);
}
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
if (my columnLabels && my columnLabels [icol] && my columnLabels [icol] [0])
Graphics_text (graphics, icol, y, my columnLabels [icol]);
}
Graphics_setTextRotation (graphics, 0);
y -= lineSpacing;
Graphics_line (graphics, 0.5, y, 0.5, 1 + 0.5 * lineSpacing);
Graphics_unsetInner (graphics);
}
void EditDistanceTable_drawEditOperations (EditDistanceTable me, Graphics graphics) {
const char32 *oinsertion = U"i", *insertion = U"*", *odeletion = U"d", *deletion = U"*", *osubstitution = U"s", *oequal = U"";
Graphics_setWindow (graphics, 0.5, my warpingPath -> pathLength - 0.5, 0, 1); // pathLength-1 symbols
double lineSpacing = getLineSpacing (graphics);
double ytarget = 1 - lineSpacing, ysource = ytarget - 2 * lineSpacing, yoper = ysource - lineSpacing;
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_BOTTOM);
for (long i = 2; i <= my warpingPath -> pathLength; i++) {
structPairOfInteger p = my warpingPath -> path[i], p1 = my warpingPath -> path[i - 1];
double x = i - 1;
if (p.x == p1.x) { // insertion
Graphics_text (graphics, x, ytarget, my rowLabels[p.y]);
Graphics_text (graphics, x, ysource, deletion);
Graphics_text (graphics, x, yoper, oinsertion);
} else if (p.y == p1.y) { // deletion
Graphics_text (graphics, x, ytarget, insertion);
Graphics_text (graphics, x, ysource, my columnLabels[p.x]);
Graphics_text (graphics, x, yoper, odeletion);
} else { // substitution ?
Graphics_text (graphics, x, ytarget, my rowLabels[p.y]);
Graphics_text (graphics, x, ysource, my columnLabels[p.x]);
Graphics_text (graphics, x, yoper, (Melder_equ (my rowLabels[p.y], my columnLabels[p.x]) ? oequal : osubstitution));
}
Graphics_line (graphics, x, ysource + lineSpacing, x, ytarget - 0.1 * lineSpacing);
}
}
void Art_Speaker_drawMesh (Art art, Speaker speaker, Graphics graphics) {
double xi [40], yi [40], xe [40], ye [40], xmm [40], ymm [40];
int closed [40];
int i;
Graphics_Viewport previous;
int oldLineType = Graphics_inqLineType (graphics);
Art_Speaker_meshVocalTract (art, speaker, xi, yi, xe, ye, xmm, ymm, closed);
previous = Graphics_insetViewport (graphics, 0.1, 0.9, 0.1, 0.9); /* Must be square. */
Graphics_setWindow (graphics, -0.05, 0.05, -0.05, 0.05);
/* Mesh lines. */
for (i = 1; i <= Art_Speaker_meshCount; i ++)
Graphics_line (graphics, xi [i], yi [i], xe [i], ye [i]);
/* Radii. */
Graphics_setLineType (graphics, Graphics_DOTTED);
for (i = 1; i <= Art_Speaker_meshCount; i ++)
if (xe [i] <= 0.0 && ye [i] >= 0.0)
Graphics_line (graphics, 0.0, 0.0, 0.9 * xi [i], 0.9 * yi [i]);
Graphics_setLineType (graphics, oldLineType);
/* Lengths. */
for (i = 1; i <= Art_Speaker_meshCount; i ++)
Graphics_line (graphics, xmm [i], ymm [i], xmm [i + 1], ymm [i + 1]);
for (i = 1; i <= Art_Speaker_meshCount + 1; i ++)
Graphics_speckle (graphics, xmm [i], ymm [i]);
Graphics_setTextAlignment (graphics, Graphics_LEFT, Graphics_HALF);
Graphics_text (graphics, 0.0, 0.0, U"O"); // origin
Graphics_resetViewport (graphics, previous);
}
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 Graphics_quantileQuantilePlot (Graphics g, long numberOfQuantiles, double xdata[], long xnumberOfData, double ydata[], long ynumberOfData, double xmin, double xmax, double ymin, double ymax, int labelSize, const wchar_t *plotLabel) {
int fontSize = Graphics_inqFontSize (g);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (g, labelSize);
autoNUMvector<double> xsorted (NUMvector_copy<double> (xdata, 1, xnumberOfData), 1);
autoNUMvector<double> ysorted (NUMvector_copy<double> (ydata, 1, ynumberOfData), 1);
NUMsort_d (xnumberOfData, xsorted.peek());
NUMsort_d (ynumberOfData, ysorted.peek());
long numberOfData = xnumberOfData < ynumberOfData ? xnumberOfData : ynumberOfData;
numberOfQuantiles = numberOfData < numberOfQuantiles ? numberOfData : numberOfQuantiles;
double un = pow (0.5, 1.0 / numberOfQuantiles);
double u1 = 1 - un;
if (xmin == xmax) {
xmin = NUMquantile (xnumberOfData, xsorted.peek(), u1);
xmax = NUMquantile (xnumberOfData, xsorted.peek(), un);
}
if (ymin == ymax) {
ymin = NUMquantile (ynumberOfData, ysorted.peek(), u1);
ymax = NUMquantile (ynumberOfData, ysorted.peek(), un);
}
for (long i = 1; i <= numberOfQuantiles; i++) {
double ui = i == 1 ? u1 : (i == numberOfQuantiles ? un : (i - 0.3175) / (numberOfQuantiles + 0.365));
double qx = NUMquantile (xnumberOfData, xsorted.peek(), ui);
double qy = NUMquantile (ynumberOfData, ysorted.peek(), ui);
if (qx < xmin || qx > xmax || qy < ymin || qy > ymax) continue; // outside area
Graphics_text (g, qx, qy, plotLabel);
}
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, xmin, ymin, xmax, ymax);
Graphics_setLineType (g, Graphics_DRAWN);
Graphics_setFontSize (g, fontSize);
}
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);
}
void TableOfReal_drawAsNumbers_if (TableOfReal me, Graphics graphics, long rowmin, long rowmax, int iformat, int precision,
const wchar_t *conditionFormula, Interpreter interpreter)
{
try {
autoMatrix original = TableOfReal_to_Matrix (me);
autoMatrix conditions = original.clone ();
fixRows (me, & rowmin, & rowmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, 0.5, my numberOfColumns + 0.5, 0, 1);
double leftMargin = getLeftMargin (graphics); // not earlier!
double lineSpacing = getLineSpacing (graphics); // not earlier!
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);
Matrix_formula (original.peek(), conditionFormula, interpreter, conditions.peek());
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_BOTTOM);
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
if (my columnLabels && my columnLabels [icol] && my columnLabels [icol] [0])
Graphics_text (graphics, icol, 1, my columnLabels [icol]);
}
for (long irow = rowmin; irow <= rowmax; irow ++) {
double y = 1 - lineSpacing * (irow - rowmin + 0.6);
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_HALF);
if (my rowLabels && my rowLabels [irow] && my rowLabels [irow] [0])
Graphics_text (graphics, 0.5 - leftMargin, y, my rowLabels [irow]);
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_HALF);
for (long icol = 1; icol <= my numberOfColumns; icol ++) if (conditions -> z [irow] [icol] != 0.0) {
wchar_t text [40];
print4 (text, my data [irow] [icol], iformat, 0, precision);
Graphics_text (graphics, icol, y, text);
}
}
if (maxTextHeight) {
double left = 0.5;
if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * leftMargin;
Graphics_line (graphics, left, 1, my numberOfColumns + 0.5, 1);
}
Graphics_unsetInner (graphics);
} catch (MelderError) {
Melder_throw (me, ": numbers not drawn.");
}
}
int HyperPage_formula (I, const wchar_t *formula) {
iam (HyperPage);
double topSpacing = 0.2, bottomSpacing = 0.2, minFooterDistance = 0.0;
kGraphics_font font = my font;
int size = my fontSize;
if (! my printing) {
my d_y -= ( my previousBottomSpacing > topSpacing ? my previousBottomSpacing : topSpacing ) * size / 12.0;
my d_y -= size * (1.2/72);
if (my d_y > PAGE_HEIGHT + 2.0 || my d_y < PAGE_HEIGHT - SCREEN_HEIGHT) {
} else {
Graphics_setFont (my g, font);
Graphics_setFontStyle (my g, 0);
Graphics_setFontSize (my g, size);
Graphics_setWrapWidth (my g, 0);
Graphics_setTextAlignment (my g, Graphics_CENTRE, Graphics_BOTTOM);
Graphics_text (my g, my rightMargin / 2, my d_y, formula);
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 -= size * (1.2/72);
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 -= size * (1.2/72);
}
Graphics_setWrapWidth (my ps, 0);
Graphics_setTextAlignment (my ps, Graphics_CENTRE, Graphics_BOTTOM);
Graphics_text (my ps, 3.7, my d_y, formula);
Graphics_setTextAlignment (my ps, Graphics_LEFT, Graphics_BOTTOM);
}
my previousBottomSpacing = bottomSpacing;
return 1;
}
void Graphics_lagPlot (Graphics g, double data[], long numberOfData, double xmin, double xmax, long lag, int labelSize, const wchar_t *plotLabel) {
if (lag < 0 || lag >= numberOfData) {
return;
}
int fontSize = Graphics_inqFontSize (g);
Graphics_setFontSize (g, labelSize);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
// plot x[i] vertically and x[i-lag] horizontally
for (long i = 1; i <= numberOfData - lag; i++) {
double x = data[i + lag], y = data[i];
if (x >= xmin && x <= xmax && y >= xmin && y <= xmax) {
Graphics_text (g, x, y, plotLabel);
}
}
Graphics_setLineType (g, Graphics_DRAWN);
Graphics_setFontSize (g, fontSize);
}
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 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);
}
/* This routine is deprecated since praat-4.2.4 20040422 and will be removed in the future. */
void FFNet_drawWeightsToLayer (FFNet me, Graphics g, int layer, int scaling, int garnish) {
if (layer < 1 || layer > my nLayers) {
Melder_throw (U"Layer must be in [1,", my nLayers, U"].");
}
autoMatrix weights = FFNet_weightsToMatrix (me, layer, 0);
Matrix_scale (weights.peek(), scaling);
Matrix_drawAsSquares (weights.peek(), g, 0.0, 0.0, 0.0, 0.0, 0);
if (garnish) {
double x1WC, x2WC, y1WC, y2WC;
Graphics_inqWindow (g, & x1WC, & x2WC, & y1WC, & y2WC);
Graphics_textBottom (g, false, Melder_cat (U"Units in layer ", layer, U" ->"));
if (layer == 1) {
Graphics_textLeft (g, false, U"Input units ->");
} else {
Graphics_textLeft (g, false, Melder_cat (U"Units in layer ", layer - 1, U" ->"));
}
/* how do I find out the current settings ??? */
Graphics_setTextAlignment (g, Graphics_RIGHT, Graphics_HALF);
Graphics_setInner (g);
Graphics_text (g, 0.5, weights->ny, U"bias");
Graphics_unsetInner (g);
}
}
void HyperPage_initSheetOfPaper (HyperPage me) {
int reflect = my mirror && (my d_printingPageNumber & 1) == 0;
wchar_t *leftHeader = reflect ? my outsideHeader : my insideHeader;
wchar_t *rightHeader = reflect ? my insideHeader : my outsideHeader;
wchar_t *leftFooter = reflect ? my outsideFooter : my insideFooter;
wchar_t *rightFooter = reflect ? my insideFooter : my outsideFooter;
my d_y = PAPER_TOP - TOP_MARGIN;
my d_x = 0;
my previousBottomSpacing = 0.0;
Graphics_setFont (my ps, kGraphics_font_TIMES);
Graphics_setFontSize (my ps, 12);
Graphics_setFontStyle (my ps, Graphics_ITALIC);
if (leftHeader) {
Graphics_setTextAlignment (my ps, Graphics_LEFT, Graphics_TOP);
Graphics_text (my ps, 0.7, PAPER_TOP, leftHeader);
}
if (my middleHeader) {
Graphics_setTextAlignment (my ps, Graphics_CENTRE, Graphics_TOP);
Graphics_text (my ps, 0.7 + 3, PAPER_TOP, my middleHeader);
}
if (rightHeader) {
Graphics_setTextAlignment (my ps, Graphics_RIGHT, Graphics_TOP);
Graphics_text (my ps, 0.7 + 6, PAPER_TOP, rightHeader);
}
if (leftFooter) {
Graphics_setTextAlignment (my ps, Graphics_LEFT, Graphics_BOTTOM);
Graphics_text (my ps, 0.7, PAPER_BOTTOM, leftFooter);
}
if (my middleFooter) {
Graphics_setTextAlignment (my ps, Graphics_CENTRE, Graphics_BOTTOM);
Graphics_text (my ps, 0.7 + 3, PAPER_BOTTOM, my middleFooter);
}
if (rightFooter) {
Graphics_setTextAlignment (my ps, Graphics_RIGHT, Graphics_BOTTOM);
Graphics_text (my ps, 0.7 + 6, PAPER_BOTTOM, rightFooter);
}
Graphics_setFontStyle (my ps, Graphics_NORMAL);
if (my d_printingPageNumber)
Graphics_text1 (my ps, 0.7 + ( reflect ? 0 : 6 ), PAPER_BOTTOM, Melder_integer (my d_printingPageNumber));
Graphics_setTextAlignment (my ps, Graphics_LEFT, Graphics_BOTTOM);
}
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 SimpleString_draw (SimpleString me, Graphics g, double xWC, double yWC) {
Graphics_text (g, xWC, yWC, my string);
}
void Graphics_boxAndWhiskerPlot (Graphics g, double data[], long ndata, double x, double r, double w, double ymin, double ymax) {
int lineType = Graphics_inqLineType (g);
Melder_assert (r > 0 && w > 0);
if (ndata < 3) {
return;
}
/*
Sort the data (ascending: data[1] <= ... <= data[ndata]).
Get the median (q50) and the upper and lower quartile points
(q25 and q75).
Now q25 and q75 are the lower and upper hinges, respectively.
The fances can be calcultaed from q25 and q75.
The spread is defined as the interquartile range or midrange
|q75 - q25|.
The fences are defined as:
(lower/upper) innerfence = (lower/upper) hinge +/- 1.5 hspread
(lower/upper) outerfence = (lower/upper) hinge +/- 3.0 hspread
*/
NUMsort_d (ndata, data);
if (ymax <= ymin) {
ymin = data[1]; ymax = data[ndata];
}
if (data[1] > ymax || data[ndata] < ymin) {
return;
}
double mean = 0;
for (long i = 1; i <= ndata; i++) {
mean += data[i];
}
mean /= ndata;
double q25 = NUMquantile (ndata, data, 0.25);
double q50 = NUMquantile (ndata, data, 0.5);
double q75 = NUMquantile (ndata, data, 0.75);
double hspread = fabs (q75 - q25);
double lowerOuterFence = q25 - 3.0 * hspread;
double lowerInnerFence = q25 - 1.5 * hspread;
double upperInnerFence = q75 + 1.5 * hspread;
double upperOuterFence = q75 + 3.0 * hspread;
/*
Decide whether there are outliers that have to be drawn.
First process data from below (data are sorted).
*/
long i = 1, ie = ndata;
while (i <= ie && data[i] < ymin) {
i++;
}
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
while (i <= ie && data[i] < lowerOuterFence) {
Graphics_text (g, x, data[i], L"o"); i++;
}
while (i <= ie && data[i] < lowerInnerFence) {
Graphics_text (g, x, data[i], L"*"); i++;
}
double lowerWhisker = data[i] < q25 ? data[i] : lowerInnerFence;
if (lowerWhisker > ymax) {
return;
}
// Next process data from above.
i = ndata; ie = i;
while (i >= ie && data[i] > ymax) {
i--;
}
while (i >= ie && data[i] > upperOuterFence) {
Graphics_text (g, x, data[i], L"o"); i--;
}
while (i >= ie && data[i] > upperInnerFence) {
Graphics_text (g, x, data[i], L"*"); i--;
}
double upperWhisker = data[i] > q75 ? data[i] : upperInnerFence;
if (upperWhisker < ymin) {
return;
}
/*
Determine what parts of the "box" have to be drawn within the
range [ymin, ymax].
Horizontal lines first.
*/
double y1 = lowerWhisker;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - r, y1, x + r, y1);
}
y1 = q25;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = q50;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = q75;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - w, y1, x + w, y1);
}
y1 = upperWhisker;
if (ymax > y1 && ymin < y1) {
Graphics_line (g, x - r, y1, x + r, y1);
}
// Extension: draw the mean too.
y1 = mean;
if (ymax > y1 && ymin < y1) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, x - w, y1, x + w, y1);
Graphics_setLineType (g, lineType);
}
// Now process the vertical lines.
y1 = lowerWhisker;
double y2 = q25;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x, y1, x, y2);
}
y1 = q25; y2 = q75;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x - w, y1, x - w, y2);
Graphics_line (g, x + w, y1, x + w, y2);
}
y1 = q75; y2 = upperWhisker;
if (ymax > y1 && ymin < y2) {
y1 = y1 > ymin ? y1 : ymin;
y2 = y2 < ymax ? y2 : ymax;
Graphics_line (g, x, y1, x, y2);
}
}
void TextGrid_Sound_draw (TextGrid me, Sound sound, Graphics g, double tmin, double tmax,
int showBoundaries, int useTextStyles, int garnish) // STEREO BUG
{
long numberOfTiers = my tiers -> size;
/*
* Automatic windowing:
*/
if (tmax <= tmin) tmin = my xmin, tmax = my xmax;
Graphics_setInner (g);
Graphics_setWindow (g, tmin, tmax, -1.0 - 0.5 * numberOfTiers, 1.0);
/*
* Draw sound in upper part.
*/
long first, last;
if (sound && Sampled_getWindowSamples (sound, tmin, tmax, & first, & last) > 1) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, tmin, 0.0, tmax, 0.0);
Graphics_setLineType (g, Graphics_DRAWN);
Graphics_function (g, sound -> z [1], first, last,
Sampled_indexToX (sound, first), Sampled_indexToX (sound, last));
}
/*
* Draw labels in lower part.
*/
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
Graphics_setPercentSignIsItalic (g, useTextStyles);
Graphics_setNumberSignIsBold (g, useTextStyles);
Graphics_setCircumflexIsSuperscript (g, useTextStyles);
Graphics_setUnderscoreIsSubscript (g, useTextStyles);
for (long itier = 1; itier <= numberOfTiers; itier ++) {
Function anyTier = (Function) my tiers -> item [itier];
double ymin = -1.0 - 0.5 * itier, ymax = ymin + 0.5;
Graphics_rectangle (g, tmin, tmax, ymin, ymax);
if (anyTier -> classInfo == classIntervalTier) {
IntervalTier tier = (IntervalTier) anyTier;
long ninterval = tier -> intervals -> size;
for (long iinterval = 1; iinterval <= ninterval; iinterval ++) {
TextInterval interval = (TextInterval) tier -> intervals -> item [iinterval];
double intmin = interval -> xmin, intmax = interval -> xmax;
if (intmin < tmin) intmin = tmin;
if (intmax > tmax) intmax = tmax;
if (intmin >= intmax) continue;
if (showBoundaries && intmin > tmin && intmin < tmax) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, intmin, -1.0, intmin, 1.0); /* In sound part. */
Graphics_setLineType (g, Graphics_DRAWN);
}
/* Draw left boundary. */
if (intmin > tmin && intmin < tmax) Graphics_line (g, intmin, ymin, intmin, ymax);
/* Draw label text. */
if (interval -> text && intmax >= tmin && intmin <= tmax) {
double t1 = tmin > intmin ? tmin : intmin;
double t2 = tmax < intmax ? tmax : intmax;
Graphics_text (g, 0.5 * (t1 + t2), 0.5 * (ymin + ymax), interval -> text);
}
}
} else {
TextTier tier = (TextTier) anyTier;
long numberOfPoints = tier -> points -> size;
for (long ipoint = 1; ipoint <= numberOfPoints; ipoint ++) {
TextPoint point = (TextPoint) tier -> points -> item [ipoint];
double t = point -> number;
if (t > tmin && t < tmax) {
if (showBoundaries) {
Graphics_setLineType (g, Graphics_DOTTED);
Graphics_line (g, t, -1.0, t, 1.0); /* In sound part. */
Graphics_setLineType (g, Graphics_DRAWN);
}
Graphics_line (g, t, ymin, t, 0.8 * ymin + 0.2 * ymax);
Graphics_line (g, t, 0.2 * ymin + 0.8 * ymax, t, ymax);
if (point -> mark)
Graphics_text (g, t, 0.5 * (ymin + ymax), point -> mark);
}
}
}
}
Graphics_setPercentSignIsItalic (g, TRUE);
Graphics_setNumberSignIsBold (g, TRUE);
Graphics_setCircumflexIsSuperscript (g, TRUE);
Graphics_setUnderscoreIsSubscript (g, TRUE);
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_textBottom (g, 1, L"Time (s)");
Graphics_marksBottom (g, 2, 1, 1, 1);
}
}
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);
}
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 Configuration_draw (Configuration me, Graphics g, int xCoordinate, int yCoordinate, double xmin, double xmax, double ymin, double ymax, int labelSize, int useRowLabels, const char32 *label, int garnish) {
long nPoints = my numberOfRows, numberOfDimensions = my numberOfColumns;
if (numberOfDimensions > 1 && (xCoordinate > numberOfDimensions || yCoordinate > numberOfDimensions)) {
return;
}
if (numberOfDimensions == 1) {
xCoordinate = 1;
}
int fontSize = Graphics_inqFontSize (g), noLabel = 0;
if (labelSize == 0) {
labelSize = fontSize;
}
autoNUMvector<double> x (1, nPoints);
autoNUMvector<double> y (1, nPoints);
for (long i = 1; i <= nPoints; i++) {
x[i] = my data[i][xCoordinate] * my w[xCoordinate];
y[i] = numberOfDimensions > 1 ? my data[i][yCoordinate] * my w[yCoordinate] : 0.0;
}
if (xmax <= xmin) {
NUMvector_extrema (x.peek(), 1, nPoints, &xmin, &xmax);
}
if (xmax <= xmin) {
xmax += 1.0;
xmin -= 1.0;
}
if (ymax <= ymin) {
NUMvector_extrema (y.peek(), 1, nPoints, &ymin, &ymax);
}
if (ymax <= ymin) {
ymax += 1.0;
ymin -= 1.0;
}
Graphics_setWindow (g, xmin, xmax, ymin, ymax);
Graphics_setInner (g);
Graphics_setTextAlignment (g, Graphics_CENTRE, Graphics_HALF);
Graphics_setFontSize (g, labelSize);
for (long i = 1; i <= my numberOfRows; i++) {
if (x[i] >= xmin && x[i] <= xmax && y[i] >= ymin && y[i] <= ymax) {
const char32 *plotLabel = useRowLabels ? my rowLabels[i] : label;
if (NUMstring_containsPrintableCharacter (plotLabel)) {
Graphics_text (g, x[i], y[i], plotLabel);
} else {
noLabel++;
}
}
}
Graphics_setFontSize (g, fontSize);
Graphics_setTextAlignment (g, Graphics_LEFT, Graphics_BOTTOM);
Graphics_unsetInner (g);
if (garnish) {
Graphics_drawInnerBox (g);
Graphics_marksBottom (g, 2, true, true, false);
if (numberOfDimensions > 1) {
Graphics_marksLeft (g, 2, true, true, false);
if (my columnLabels[xCoordinate]) {
Graphics_textBottom (g, true, my columnLabels[xCoordinate]);
}
if (my columnLabels[yCoordinate]) {
Graphics_textLeft (g, true, my columnLabels[yCoordinate]);
}
}
}
if (noLabel > 0) {
Melder_warning (U"Configuration_draw: ", noLabel, U" from ", my numberOfRows, U" labels are not visible because they are empty or they contain only spaces or they contain only non-printable characters");
}
}
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 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);
}
int HyperPage_any (I, const wchar_t *text, enum kGraphics_font font, int size, int style, double minFooterDistance,
double x, double secondIndent, double topSpacing, double bottomSpacing, unsigned long method)
{
iam (HyperPage);
double heightGuess;
if (my rightMargin == 0) return 0;
// Melder_assert (my rightMargin != 0);
heightGuess = size * (1.2/72) * ((long) size * wcslen (text) / (int) (my rightMargin * 150));
if (! my printing) {
Graphics_Link *paragraphLinks;
int numberOfParagraphLinks, ilink;
if (my entryHint && (method & HyperPage_USE_ENTRY_HINT) && wcsequ (text, my entryHint)) {
my entryPosition = my d_y;
}
my d_y -= ( my previousBottomSpacing > topSpacing ? my previousBottomSpacing : topSpacing ) * size / 12.0;
my d_y -= size * (1.2/72);
my d_x = x;
if (/* my d_y > PAGE_HEIGHT + 2.0 + heightGuess || */ my d_y < PAGE_HEIGHT - SCREEN_HEIGHT) {
my d_y -= heightGuess;
} else {
Graphics_setFont (my g, font);
Graphics_setFontSize (my g, size);
Graphics_setWrapWidth (my g, my rightMargin - x - 0.1);
Graphics_setSecondIndent (my g, secondIndent);
Graphics_setFontStyle (my g, style);
Graphics_text (my g, my d_x, my d_y, text);
numberOfParagraphLinks = Graphics_getLinks (& paragraphLinks);
if (my links) for (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);
}
if (method & HyperPage_ADD_BORDER) {
Graphics_setLineWidth (my g, 2);
Graphics_line (my g, 0.0, my d_y, my rightMargin, my d_y);
Graphics_setLineWidth (my g, 1);
}
/*
* The text may have wrapped.
* Ask the Graphics manager by how much, and update our text position accordingly.
*/
my d_y = Graphics_inqTextY (my g);
}
} else {
Graphics_setFont (my ps, font);
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 -= size * (1.2/72);
if (my d_y < PAPER_BOTTOM + BOTTOM_MARGIN + minFooterDistance + size * (1.2/72) * (wcslen (text) / (6.0 * 10))) {
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 -= size * (1.2/72);
}
my d_x = 0.7 + x;
Graphics_setWrapWidth (my ps, 6.0 - x);
Graphics_setSecondIndent (my ps, secondIndent);
Graphics_setFontStyle (my ps, style);
Graphics_text (my ps, my d_x, my d_y, text);
if (method & HyperPage_ADD_BORDER) {
Graphics_setLineWidth (my ps, 3);
/*Graphics_line (my ps, 0.7, my d_y, 6.7, my d_y);*/
Graphics_line (my ps, 0.7, my d_y + size * (1.2/72) + 0.07, 6.7, my d_y + size * (1.2/72) + 0.07);
Graphics_setLineWidth (my ps, 1);
}
my d_y = Graphics_inqTextY (my ps);
}
my previousBottomSpacing = bottomSpacing;
return 1;
}
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);
}
}