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);
}
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 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 gui_drawingarea_cb_click (Picture me, GuiDrawingArea_ClickEvent event) {
int xstart = event -> x;
int ystart = event -> y;
double xWC, yWC;
int ixstart, iystart, ix, iy, oldix = 0, oldiy = 0;
Graphics_DCtoWC (my selectionGraphics.get(), xstart, ystart, & xWC, & yWC);
ix = ixstart = 1 + floor (xWC * SQUARES / SIDE);
iy = iystart = SQUARES - floor (yWC * SQUARES / SIDE);
if (ixstart < 1 || ixstart > SQUARES || iystart < 1 || iystart > SQUARES) return;
if (event -> shiftKeyPressed) {
int ix1 = 1 + floor (my selx1 * SQUARES / SIDE);
int ix2 = floor (my selx2 * SQUARES / SIDE);
int iy1 = SQUARES + 1 - floor (my sely2 * SQUARES / SIDE);
int iy2 = SQUARES - floor (my sely1 * SQUARES / SIDE);
ixstart = ix < (ix1 + ix2) / 2 ? ix2 : ix1;
iystart = iy < (iy1 + iy2) / 2 ? iy2 : iy1;
}
//while (Graphics_mouseStillDown (my selectionGraphics)) {
do {
Graphics_getMouseLocation (my selectionGraphics.get(), & xWC, & yWC);
ix = 1 + floor (xWC * SQUARES / SIDE);
iy = SQUARES - floor (yWC * SQUARES / SIDE);
if (ix >= 1 && ix <= SQUARES && iy >= 1 && iy <= SQUARES && (ix != oldix || iy != oldiy)) {
int ix1, ix2, iy1, iy2;
if (ix < ixstart) { ix1 = ix; ix2 = ixstart; }
else { ix1 = ixstart; ix2 = ix; }
if (iy < iystart) { iy1 = iy; iy2 = iystart; }
else { iy1 = iystart; iy2 = iy; }
if (my mouseSelectsInnerViewport) {
int fontSize = Graphics_inqFontSize (my graphics.get());
double xmargin = fontSize * 4.2 / 72.0, ymargin = fontSize * 2.8 / 72.0;
if (xmargin > ix2 - ix1 + 1) xmargin = ix2 - ix1 + 1;
if (ymargin > iy2 - iy1 + 1) ymargin = iy2 - iy1 + 1;
Picture_setSelection (me, 0.5 * (ix1 - 1) - xmargin, 0.5 * ix2 + xmargin,
0.5 * (SQUARES - iy2) - ymargin, 0.5 * (SQUARES + 1 - iy1) + ymargin, false);
} else {
Picture_setSelection (me, 0.5 * (ix1 - 1), 0.5 * ix2,
0.5 * (SQUARES - iy2), 0.5 * (SQUARES + 1 - iy1), false);
}
oldix = ix; oldiy = iy;
}
} while (Graphics_mouseStillDown (my selectionGraphics.get()));
// }
#if cocoa
Graphics_updateWs (my selectionGraphics.get()); // to change the dark red back into black
#endif
if (my selectionChangedCallback) {
//Melder_casual (U"selectionChangedCallback from gui_drawingarea_cb_click");
my selectionChangedCallback (me, my selectionChangedClosure,
my selx1, my selx2, my sely1, my sely2);
}
}
static void drawSelection (Picture me, int high) {
if (my backgrounding) return;
double dy = 2.8 * Graphics_inqFontSize (my graphics.get()) / 72.0;
double dx = 1.5 * dy;
if (dy > 0.4 * (my sely2 - my sely1)) dy = 0.4 * (my sely2 - my sely1);
if (dx > 0.4 * (my selx2 - my selx1)) dx = 0.4 * (my selx2 - my selx1);
if (high) {
Graphics_highlight2 (my selectionGraphics.get(), my selx1, my selx2, my sely1, my sely2,
my selx1 + dx, my selx2 - dx, my sely1 + dy, my sely2 - dy);
} else {
Graphics_unhighlight2 (my selectionGraphics.get(), my selx1, my selx2, my sely1, my sely2,
my selx1 + dx, my selx2 - dx, my sely1 + dy, my sely2 - dy);
}
}
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 double getLineSpacing (Graphics graphics) {
return Graphics_dyMMtoWC (graphics, 1.5 * Graphics_inqFontSize (graphics) * 25.4 / 72);
}
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");
}
}
