自学教程：C++ Graphics_setWindow函数代码示例

void TableOfReal_drawVerticalLines (TableOfReal me, Graphics graphics, long rowmin, long rowmax) {	long colmin = 1, colmax = my numberOfColumns;	fixRows (me, & rowmin, & rowmax);	Graphics_setInner (graphics);	Graphics_setWindow (graphics, colmin - 0.5, colmax + 0.5, 0, 1);	double lineSpacing = getLineSpacing (graphics);   // not earlier!	double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);	double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);	if (maxTextWidth > 0.0) colmin -= 1;	for (long col = colmin + 1; col <= colmax; col ++)		Graphics_line (graphics, col - 0.5, 1 + maxTextHeight, col - 0.5, 1 - lineSpacing * (rowmax - rowmin + 1));	Graphics_unsetInner (graphics);}

void Spectrogram_paintInside (Spectrogram me, Graphics g, double tmin, double tmax, double fmin, double fmax,	double maximum, int autoscaling, double dynamic, double preemphasis, double dynamicCompression){	if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; }	if (fmax <= fmin) { fmin = my ymin; fmax = my ymax; }	long itmin, itmax, ifmin, ifmax;	if (! Matrix_getWindowSamplesX (me, tmin - 0.49999 * my dx, tmax + 0.49999 * my dx, & itmin, & itmax) ||		 ! Matrix_getWindowSamplesY (me, fmin - 0.49999 * my dy, fmax + 0.49999 * my dy, & ifmin, & ifmax))		return;	Graphics_setWindow (g, tmin, tmax, fmin, fmax);	autoNUMvector <double> preemphasisFactor (ifmin, ifmax);	autoNUMvector <double> dynamicFactor (itmin, itmax);	/* Pre-emphasis in place; also compute maximum after pre-emphasis. */	for (long ifreq = ifmin; ifreq <= ifmax; ifreq ++) {		preemphasisFactor [ifreq] = (preemphasis / NUMln2) * log (ifreq * my dy / 1000.0);		for (long itime = itmin; itime <= itmax; itime ++) {			double value = my z [ifreq] [itime];   /* Power. */			value = (10.0/NUMln10) * log ((value + 1e-30) / 4.0e-10) + preemphasisFactor [ifreq];   /* dB */			if (value > dynamicFactor [itime]) dynamicFactor [itime] = value;   /* Local maximum. */			my z [ifreq] [itime] = value;		}	}	/* Compute global maximum. */	if (autoscaling) {		maximum = 0.0;		for (long itime = itmin; itime <= itmax; itime ++)			if (dynamicFactor [itime] > maximum) maximum = dynamicFactor [itime];	}	/* Dynamic compression in place. */	for (long itime = itmin; itime <= itmax; itime ++) {		dynamicFactor [itime] = dynamicCompression * (maximum - dynamicFactor [itime]);		for (long ifreq = ifmin; ifreq <= ifmax; ifreq ++)			my z [ifreq] [itime] += dynamicFactor [itime];	}	Graphics_image (g, my z,		itmin, itmax,		Matrix_columnToX (me, itmin - 0.5),		Matrix_columnToX (me, itmax + 0.5),		ifmin, ifmax,		Matrix_rowToY (me, ifmin - 0.5),		Matrix_rowToY (me, ifmax + 0.5),		maximum - dynamic, maximum);	for (long ifreq = ifmin; ifreq <= ifmax; ifreq ++)		for (long itime = itmin; itime <= itmax; itime ++) {			double value = 4.0e-10 * exp ((my z [ifreq] [itime] - dynamicFactor [itime]				- preemphasisFactor [ifreq]) * (NUMln10 / 10.0)) - 1e-30;			my z [ifreq] [itime] = value > 0.0 ? value : 0.0;		}}

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 Matrix_drawRows (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax,	double minimum, double maximum){	if (xmax <= xmin) { xmin = my xmin; xmax = my xmax; }	if (ymax <= ymin) { ymin = my ymin; ymax = my ymax; }	long ixmin, ixmax, iymin, iymax;	(void) Matrix_getWindowSamplesX (me, xmin, xmax, & ixmin, & ixmax);	(void) Matrix_getWindowSamplesY (me, ymin, ymax, & iymin, & iymax);	if (maximum <= minimum)		(void) Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, & minimum, & maximum);	if (maximum <= minimum) { minimum -= 1.0; maximum += 1.0; }	if (xmin >= xmax) return;	Graphics_setInner (g);	for (long iy = iymin; iy <= iymax; iy ++) {		Graphics_setWindow (g, xmin, xmax,			minimum - (iy - iymin) * (maximum - minimum),			maximum + (iymax - iy) * (maximum - minimum));		Graphics_function (g, my z [iy], ixmin, ixmax,			Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax));	}	Graphics_unsetInner (g);	if (iymin < iymax)		Graphics_setWindow (g, xmin, xmax, my y1 + (iymin - 1.5) * my dy, my y1 + (iymax - 0.5) * my dy);}

void Matrix_scatterPlot (Matrix me, Graphics g, long icx, long icy, double xmin, double xmax, double ymin, double ymax, double size_mm, const char32 *mark, int garnish) {	long ix = labs (icx), iy = labs (icy);	if (ix < 1 || ix > my nx || iy < 1 || iy > my nx) {		return;	}	if (xmax <= xmin) {		(void) Matrix_getWindowExtrema (me, ix, ix, 1, my ny, & xmin, & xmax);		if (xmax <= xmin) {			xmin -= 0.5; xmax += 0.5;		}	}	if (ymax <= ymin) {		(void) Matrix_getWindowExtrema (me, iy, iy, 1, my ny, & ymin, & ymax);		if (ymax <= ymin) {			ymin -= 0.5; ymax += 0.5;		}	}	Graphics_setInner (g);	if (icx < 0) {		double t = xmin;		xmin = xmax;		xmax = t;	}	if (icy < 0) {		double t = ymin;		ymin = ymax;		ymax = t;	}	Graphics_setWindow (g, xmin, xmax, ymin, ymax);	for (long i = 1; i <= my ny; i++) {		if (my z[i][ix] >= xmin && my z[i][ix] <= xmax && my z[i][iy] >= ymin && my z[i][iy] <= ymax) {			Graphics_mark (g, my z[i][ix], my z[i][iy], size_mm, mark);		}	}	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_marksLeft (g, 2, true, true, false);		if (ymin * ymax < 0.0) {			Graphics_markLeft (g, 0.0, true, true, true, nullptr);		}		Graphics_marksBottom (g, 2, true, true, false);		if (xmin * xmax < 0.0) {			Graphics_markBottom (g, 0.0, true, true, true, nullptr);		}	}}

void ERP_drawChannel_number (ERP me, Graphics graphics, long channelNumber, double tmin, double tmax, double vmin, double vmax, bool garnish) {	if (channelNumber < 1 || channelNumber > my ny) return;	/*	 * Automatic domain.	 */	if (tmin == tmax) {		tmin = my xmin;		tmax = my xmax;	}	/*	 * Domain expressed in sample numbers.	 */	long ixmin, ixmax;	Matrix_getWindowSamplesX (me, tmin, tmax, & ixmin, & ixmax);	/*	 * Automatic vertical range.	 */	if (vmin == vmax) {		Matrix_getWindowExtrema (me, ixmin, ixmax, channelNumber, channelNumber, & vmin, & vmax);		if (vmin == vmax) {			vmin -= 1.0;			vmax += 1.0;		}	}	/*	 * Set coordinates for drawing.	 */	Graphics_setInner (graphics);	Graphics_setWindow (graphics, tmin, tmax, vmin, vmax);	Graphics_function (graphics, my z [channelNumber], ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax));	Graphics_unsetInner (graphics);	if (garnish) {		Graphics_drawInnerBox (graphics);		Graphics_textTop (graphics, true, Melder_wcscat (L"Channel ", my channelNames [channelNumber]));		Graphics_textBottom (graphics, true, L"Time (s)");		Graphics_marksBottom (graphics, 2, true, true, false);		if (0.0 > tmin && 0.0 < tmax)			Graphics_markBottom (graphics, 0.0, true, true, true, NULL);		Graphics_markLeft (graphics, vmin, true, true, false, NULL);		Graphics_markLeft (graphics, vmax, true, true, false, NULL);			Graphics_markBottom (graphics, 0.0, true, true, true, NULL);		if (vmin != 0.0 && vmax != 0.0 && (vmin > 0.0) != (vmax > 0.0)) {			Graphics_markLeft (graphics, 0.0, true, true, true, NULL);		}	}}

void Cepstrum_draw (Cepstrum me, Graphics g, double qmin, double qmax,                    double minimum, double maximum, int garnish) {	int autoscaling = minimum >= maximum;	Graphics_setInner (g);	if (qmax <= qmin) {		qmin = my xmin; qmax = my xmax;	}	long imin, imax;	if (! Matrix_getWindowSamplesX (me, qmin, qmax, & imin, & imax)) {		return;	}	autoNUMvector<double> y (imin, imax);	double *z = my z[1];	for (long i = imin; i <= imax; i++) {		y[i] = z[i];	}	if (autoscaling) {		NUMvector_extrema (y.peek(), imin, imax, & minimum, & maximum);	}	for (long i = imin; i <= imax; i ++) {		if (y[i] > maximum) {			y[i] = maximum;		} else if (y[i] < minimum) {			y[i] = minimum;		}	}	Graphics_setWindow (g, qmin, qmax, minimum, maximum);	Graphics_function (g, y.peek(), imin, imax, Matrix_columnToX (me, imin), Matrix_columnToX (me, imax));	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, 1, L"Quefrency");		Graphics_marksBottom (g, 2, TRUE, TRUE, FALSE);		Graphics_textLeft (g, 1, L"Amplitude");	}}

void LineSpectralFrequencies_drawFrequencies (LineSpectralFrequencies me, Graphics g, double tmin, double tmax, double fmin, double fmax, bool garnish) {	if (tmax <= tmin) {		tmin = my xmin;		tmax = my xmax;	}	long itmin, itmax;	if (! Sampled_getWindowSamples (me, tmin, tmax, & itmin, & itmax)) {		return;	}	if (fmax <= fmin) {		double f1max, f2min; 		autoNUMvector<double> f1 (itmin, itmax), f2 (itmin, itmax);		for (long iframe = itmin; iframe <= itmax; iframe++) {			f1[iframe] = my d_frames[iframe].frequencies[1];			f2[iframe] = my d_frames[iframe].frequencies[my d_frames[iframe].numberOfFrequencies];		}		NUMvector_extrema (f1.peek(), itmin, itmax, & fmin, & f1max);		NUMvector_extrema (f2.peek(), itmin, itmax, & f2min, & fmax);	}	if (fmax == fmin) {		fmin = 0;		fmax += 0.5;	}	Graphics_setInner (g);	Graphics_setWindow (g, tmin, tmax, fmin, fmax);	for (long iframe = itmin; iframe <= itmax; iframe++) {		LineSpectralFrequencies_Frame lsf = & my d_frames[iframe];		double x = Sampled_indexToX (me, iframe);		for (long ifreq = 1; ifreq <= lsf -> numberOfFrequencies; ifreq++) {			double y = lsf -> frequencies [ifreq];			if (y >= fmin && y <= fmax) { 				Graphics_speckle (g, x, y);			}		}	}	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, true, U"Time (seconds)");		Graphics_textLeft (g, true, U"Frequency (Hz)");		Graphics_marksBottom (g, 2, true, true, false);		Graphics_marksLeft (g, 2, true, true, false);	}}

void Art_Speaker_fillInnerContour (Art art, Speaker speaker, Graphics g) {	double f = speaker -> relativeSize * 1e-3;	double intX [1 + 16], intY [1 + 16], extX [1 + 11], extY [1 + 11];	double x [1 + 16], y [1 + 16];	double bodyX, bodyY;	int i;	Graphics_Viewport previous;	Art_Speaker_toVocalTract (art, speaker, intX, intY, extX, extY, & bodyX, & bodyY);	previous = Graphics_insetViewport (g, 0.1, 0.9, 0.1, 0.9);	Graphics_setWindow (g, -0.05, 0.05, -0.05, 0.05);	for (i = 1; i <= 16; i ++) { x [i] = intX [i]; y [i] = intY [i]; }	Graphics_setGrey (g, 0.8);	Graphics_fillArea (g, 16, & x [1], & y [1]);	Graphics_fillCircle (g, bodyX, bodyY, 20 * f);	Graphics_setGrey (g, 0.0);	Graphics_resetViewport (g, previous);}

void TableOfReal_drawTopAndBottomLines (TableOfReal me, Graphics graphics, long rowmin, long rowmax) {	long colmin = 1, colmax = my numberOfColumns;	fixRows (me, & rowmin, & rowmax);	Graphics_setInner (graphics);	Graphics_setWindow (graphics, colmin - 0.5, colmax + 0.5, 0, 1);	double lineSpacing = getLineSpacing (graphics);	double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);	double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);	double left = 0.5;	if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * lineSpacing;	double right = colmax + 0.5;	double top = 1 + maxTextHeight;	double bottom = 1 - lineSpacing * (rowmax - rowmin + 1);	Graphics_line (graphics, left, top, right, top);	Graphics_line (graphics, left, bottom, right, bottom);	Graphics_unsetInner (graphics);}

// xmin, xmax in hz versus bark/mel or linvoid BandFilterSpectrogram_drawFrequencyScale (BandFilterSpectrogram me, Graphics g, double xmin, double xmax, double ymin, double ymax, int garnish) {	if (xmin < 0 || xmax < 0 || ymin < 0 || ymax < 0) {		Melder_warning (U"Frequencies must be >= 0.");		return;	}	// scale is in hertz	if (xmin >= xmax) { // autoscaling		xmin = 0;		xmax = my v_frequencyToHertz (my ymax);	}	if (ymin >= ymax) { // autoscaling		ymin = my ymin;		ymax = my ymax;	}	long n = 2000;	Graphics_setInner (g);	Graphics_setWindow (g, xmin, xmax, ymin, ymax);	double dx = (xmax - xmin) / (n - 1);	double x1 = xmin, y1 = my v_hertzToFrequency (x1);	for (long i = 2; i <= n;  i++) {		double x2 = x1 + dx, y2 = my v_hertzToFrequency (x2);		if (NUMdefined (y1) && NUMdefined (y2)) {			double xo1, yo1, xo2, yo2;			if (NUMclipLineWithinRectangle (x1, y1, x2, y2, xmin, ymin, xmax, ymax, &xo1, &yo1, &xo2, &yo2)) {				Graphics_line (g, xo1, yo1, xo2, yo2);			}		}		x1 = x2; y1 = y2;	}	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_marksLeft (g, 2, 1, 1, 0);		Graphics_textLeft (g, 1, Melder_cat (U"Frequency (", my v_getFrequencyUnit (), U")"));		Graphics_marksBottom (g, 2, 1, 1, 0);		Graphics_textBottom (g, 1, U"Frequency (Hz)");	}}

void RealTier_draw (RealTier me, Graphics g, double tmin, double tmax, double fmin, double fmax,	int garnish, const char32 *method, const char32 *quantity){	bool drawLines = str32str (method, U"lines") || str32str (method, U"Lines");	bool drawSpeckles = str32str (method, U"speckles") || str32str (method, U"Speckles");	long n = my points.size, imin, imax, i;	if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; }	Graphics_setWindow (g, tmin, tmax, fmin, fmax);	Graphics_setInner (g);	imin = AnyTier_timeToHighIndex (me->asAnyTier(), tmin);	imax = AnyTier_timeToLowIndex (me->asAnyTier(), tmax);	if (n == 0) {	} else if (imax < imin) {		double fleft = RealTier_getValueAtTime (me, tmin);		double fright = RealTier_getValueAtTime (me, tmax);		if (drawLines) Graphics_line (g, tmin, fleft, tmax, fright);	} else for (i = imin; i <= imax; i ++) {		RealPoint point = my points.at [i];		double t = point -> number, f = point -> value;		if (drawSpeckles) Graphics_speckle (g, t, f);		if (drawLines) {			if (i == 1)				Graphics_line (g, tmin, f, t, f);			else if (i == imin)				Graphics_line (g, t, f, tmin, RealTier_getValueAtTime (me, tmin));			if (i == n)				Graphics_line (g, t, f, tmax, f);			else if (i == imax)				Graphics_line (g, t, f, tmax, RealTier_getValueAtTime (me, tmax));			else {				RealPoint pointRight = my points.at [i + 1];				Graphics_line (g, t, f, pointRight -> number, pointRight -> value);			}		}	}	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, true, my v_getUnitText (0, 0, 0));		Graphics_marksBottom (g, 2, true, true, false);		Graphics_marksLeft (g, 2, true, true, false);		if (quantity) Graphics_textLeft (g, true, quantity);	}}

void PitchTier_Pitch_draw (PitchTier me, Pitch uv, Graphics g,	double tmin, double tmax, double fmin, double fmax, int nonPeriodicLineType, int garnish, const char32 *method){	long n = my points.size, imin, imax, i;	if (nonPeriodicLineType == 0) {		PitchTier_draw (me, g, tmin, tmax, fmin, fmax, garnish, method);		return;	}	if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; }	Graphics_setWindow (g, tmin, tmax, fmin, fmax);	Graphics_setInner (g);	imin = AnyTier_timeToHighIndex (me->asAnyTier(), tmin);	imax = AnyTier_timeToLowIndex (me->asAnyTier(), tmax);	if (n == 0) {	} else if (imax < imin) {		double fleft = RealTier_getValueAtTime (me, tmin);		double fright = RealTier_getValueAtTime (me, tmax);		Pitch_line (uv, g, tmin, fleft, tmax, fright, nonPeriodicLineType);	} else for (i = imin; i <= imax; i ++) {		RealPoint point = my points.at [i];		double t = point -> number, f = point -> value;		Graphics_speckle (g, t, f);		if (i == 1)			Pitch_line (uv, g, tmin, f, t, f, nonPeriodicLineType);		else if (i == imin)			Pitch_line (uv, g, t, f, tmin, RealTier_getValueAtTime (me, tmin), nonPeriodicLineType);		if (i == n)			Pitch_line (uv, g, t, f, tmax, f, nonPeriodicLineType);		else if (i == imax)			Pitch_line (uv, g, t, f, tmax, RealTier_getValueAtTime (me, tmax), nonPeriodicLineType);		else {			RealPoint pointRight = my points.at [i + 1];			Pitch_line (uv, g, t, f, pointRight -> number, pointRight -> value, nonPeriodicLineType);		}	}	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, true, U"Time (s)");		Graphics_marksBottom (g, 2, true, true, false);		Graphics_marksLeft (g, 2, true, true, false);		Graphics_textLeft (g, true, U"Frequency (Hz)");	}}

void TextGrid_Pitch_drawSeparately (TextGrid grid, Pitch pitch, Graphics g, double tmin, double tmax,	double fmin, double fmax, int showBoundaries, int useTextStyles, int garnish, int speckle, int unit){	int ntier = grid -> tiers -> size;	if (tmax <= tmin) tmin = grid -> xmin, tmax = grid -> xmax;	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);	}	if (unit == kPitch_unit_HERTZ_LOGARITHMIC)		Pitch_draw (pitch, g, tmin, tmax, pow (10, fmin - 0.25 * (fmax - fmin) * ntier), pow (10, fmax), FALSE, speckle, unit);	else		Pitch_draw (pitch, g, tmin, tmax, fmin - 0.25 * (fmax - fmin) * ntier, fmax, FALSE, speckle, unit);	TextGrid_Sound_draw (grid, NULL, g, tmin, tmax, showBoundaries, useTextStyles, FALSE);	/*	 * Restore window for the sake of margin drawing.	 */	Graphics_setWindow (g, tmin, tmax, fmin - 0.25 * (fmax - fmin) * ntier, fmax);	if (unit == kPitch_unit_HERTZ_LOGARITHMIC)		fmin = pow (10, fmin), fmax = pow (10, fmax);	if (garnish) {		Graphics_drawInnerBox (g);		if (unit == kPitch_unit_HERTZ_LOGARITHMIC) {			Graphics_markLeftLogarithmic (g, fmin, TRUE, TRUE, FALSE, NULL);			Graphics_markLeftLogarithmic (g, fmax, TRUE, TRUE, FALSE, NULL);			autoMarks_logarithmic (g, fmin, fmax, FALSE);		} else if (unit == kPitch_unit_SEMITONES_100) {			Graphics_markLeft (g, fmin, TRUE, TRUE, FALSE, NULL);			Graphics_markLeft (g, fmax, TRUE, TRUE, FALSE, NULL);			autoMarks_semitones (g, fmin, fmax, FALSE);		} else {			Graphics_markLeft (g, fmin, TRUE, TRUE, FALSE, NULL);			Graphics_markLeft (g, fmax, TRUE, TRUE, FALSE, NULL);			autoMarks (g, fmin, fmax, FALSE);		}		static MelderString buffer = { 0 };		MelderString_empty (& buffer);		MelderString_append (& buffer, L"Pitch (", Function_getUnitText (pitch, Pitch_LEVEL_FREQUENCY, unit, Function_UNIT_TEXT_GRAPHICAL), L")");		Graphics_textLeft (g, true, buffer.string);		Graphics_textBottom (g, true, L"Time (s)");		Graphics_marksBottom (g, 2, true, true, true);	}}

void SPINET_drawSpectrum (SPINET me, Graphics g, double time, double fromErb, double toErb,                          double minimum, double maximum, int enhanced, int garnish) {	long ifmin, ifmax, icol = Sampled2_xToLowColumn (me, time);   // ppgb: don't use Sampled2_xToColumn for integer rounding	double **z = enhanced ? my s : my y;	if (icol < 1 || icol > my nx) {		return;	}	if (toErb <= fromErb) {		fromErb = my ymin;		toErb = my ymax;	}	Sampled2_getWindowSamplesY (me, fromErb, toErb, &ifmin, &ifmax);	autoNUMvector<double> spec (1, my ny);	for (long i = 1; i <= my ny; i++) {		spec[i] = z[i][icol];	}	if (maximum <= minimum) {		NUMvector_extrema (spec.peek(), ifmin, ifmax, &minimum, &maximum);	}	if (maximum <= minimum) {		minimum -= 1;		maximum += 1;	}	for (long i = ifmin; i <= ifmax; i++) {		if (spec[i] > maximum) {			spec[i] = maximum;		} else if (spec[i] < minimum) {			spec[i] = minimum;		}	}	Graphics_setInner (g);	Graphics_setWindow (g, fromErb, toErb, minimum, maximum);	Graphics_function (g, spec.peek(), ifmin, ifmax, Sampled2_rowToY (me, ifmin), Sampled2_rowToY (me, ifmax));	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, 1, U"Frequency (ERB)");		Graphics_marksBottom (g, 2, 1, 1, 0);		Graphics_textLeft (g, 1, U"strength");		Graphics_marksLeft (g, 2, 1, 1, 0);	}}

static void _Cepstrum_draw (Cepstrum me, Graphics g, double qmin, double qmax, double minimum, double maximum, int power, int garnish) {	int autoscaling = minimum >= maximum;	Graphics_setInner (g);	if (qmax <= qmin) {		qmin = my xmin; qmax = my xmax;	}	long imin, imax;	if (! Matrix_getWindowSamplesX (me, qmin, qmax, & imin, & imax)) {		return;	}	autoNUMvector<double> y (imin, imax);	for (long i = imin; i <= imax; i++) {		y[i] = my v_getValueAtSample (i, (power ? 1 : 0), 0);	}	if (autoscaling) {		NUMvector_extrema (y.peek(), imin, imax, & minimum, & maximum);	} else {		for (long i = imin; i <= imax; i ++) {			if (y[i] > maximum) {				y[i] = maximum;			} else if (y[i] < minimum) {				y[i] = minimum;			}		}	}	Graphics_setWindow (g, qmin, qmax, minimum, maximum);	Graphics_function (g, y.peek(), imin, imax, Matrix_columnToX (me, imin), Matrix_columnToX (me, imax));	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, true, U"Quefrency (s)");		Graphics_marksBottom (g, 2, true, true, false);		Graphics_textLeft (g, true, power ? U"Amplitude (dB)" : U"Amplitude");		Graphics_marksLeft (g, 2, true, true, false);	}}

void Matrix_paintSurface (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax,	double minimum, double maximum, double elevation, double azimuth){	if (xmax <= xmin) { xmin = my xmin; xmax = my xmax; }	if (ymax <= ymin) { ymin = my ymin; ymax = my ymax; }	long ixmin, ixmax, iymin, iymax;	(void) Matrix_getWindowSamplesX (me, xmin, xmax, & ixmin, & ixmax);	(void) Matrix_getWindowSamplesY (me, ymin, ymax, & iymin, & iymax);	if (maximum <= minimum)		(void) Matrix_getWindowExtrema (me, ixmin, ixmax, iymin, iymax, & minimum, & maximum);	if (maximum <= minimum) { minimum -= 1.0; maximum += 1.0; }	Graphics_setInner (g);	Graphics_setWindow (g, -1.0, 1.0, minimum, maximum);	Graphics_surface (g, my z,		ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax),		iymin, iymax, Matrix_rowToY (me, iymin), Matrix_rowToY (me, iymax),		minimum, maximum, elevation, azimuth);	Graphics_unsetInner (g);}

void GaussianMixture_drawMarginalPdf (GaussianMixture me, Graphics g, long d, double xmin, double xmax, double ymin, double ymax, long npoints, long nbins, int garnish){	if (d < 1 || d > my dimension)	{ Melder_warning1 (L"Dimension doesn't agree."); return;}	if (npoints <= 1) npoints = 1000;	double *p = NUMdvector (1, npoints);	if (p == 0) return;	double nsigmas = 2, *v = NUMdvector (1, my dimension);	if (v == NULL) goto end;	if (xmax <= xmin &&		! GaussianMixture_getIntervalAlongDirection (me, d, nsigmas, &xmin, &xmax)) goto end;	{		double pmax = 0, dx = (xmax - xmin) / (npoints - 1);		double scalef = nbins <= 0 ? 1 : 1; // TODO		for (long i = 1; i <= npoints; i++)		{			double x = xmin + (i - 1) * dx;			for (long k = 1; k <= my dimension; k++) v[k] = k == d ? 1 : 0;			p[i] = scalef * GaussianMixture_getMarginalProbabilityAtPosition (me, v, x);			if (p[i] > pmax) pmax = p[i];		}		if (ymin >= ymax) { ymin = 0; ymax = pmax; }		Graphics_setInner (g);		Graphics_setWindow (g, xmin, xmax, ymin, ymax);		Graphics_function (g, p, 1, npoints, xmin, xmax);		Graphics_unsetInner (g);		if (garnish)		{			Graphics_drawInnerBox (g);			Graphics_markBottom (g, xmin, 1, 1, 0, NULL);			Graphics_markBottom (g, xmax, 1, 1, 0, NULL);			Graphics_markLeft (g, ymin, 1, 1, 0, NULL);			Graphics_markLeft (g, ymax, 1, 1, 0, NULL);		}	}end:	NUMdvector_free (p, 1); NUMdvector_free (v, 1);}

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.");	}}

void TableOfReal_drawHorizontalLines (TableOfReal me, Graphics graphics, long rowmin, long rowmax) {	long colmin = 1, colmax = my numberOfColumns;	fixRows (me, & rowmin, & rowmax);	Graphics_setInner (graphics);	Graphics_setWindow (graphics, colmin - 0.5, colmax + 0.5, 0, 1);	double lineSpacing = getLineSpacing (graphics);	double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);	double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);	double left = 0.5;	double top = rowmin;	if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * lineSpacing;	if (maxTextHeight > 0.0) rowmin -= 1;	double right = colmax + 0.5;	for (long irow = rowmin; irow < rowmax; irow ++) {		double y = 1 - lineSpacing * (irow - top + 1);		Graphics_line (graphics, left, y, right, y);	}	Graphics_unsetInner (graphics);}

void VocalTract_drawSegments (VocalTract me, Graphics g, double maxLength, double maxArea, bool closedAtGlottis){	Graphics_setInner (g);	double maxCrossection = sqrt (maxArea);	Graphics_setWindow (g, 0, maxLength, -maxCrossection, maxCrossection);	for (long isection = 1; isection <= my nx; isection++) {		double x1 = (isection - 1.0) * my dx, x2 = x1 + my dx;		double crosssection2 = sqrt (my z[1][isection]);		Graphics_line (g, x1, crosssection2, x2, crosssection2);		Graphics_line (g, x1, -crosssection2, x2, -crosssection2);		if (isection > 1) {			double crosssection1 = sqrt (my z[1][isection - 1]);			Graphics_line (g, x1, crosssection1, x1, crosssection2);			Graphics_line (g, x1, -crosssection1, x1, -crosssection2);		} else if (isection == 1 and closedAtGlottis) {			Graphics_line (g, x1, crosssection2, x1, -crosssection2);		}	}	Graphics_unsetInner (g);}

void PowerCepstrogram_paint (PowerCepstrogram me, Graphics g, double tmin, double tmax, double qmin, double qmax, double dBminimum, double dBmaximum, int garnish) {	if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; }	if (qmax <= qmin) { qmin = my ymin; qmax = my ymax; }	long itmin, itmax, ifmin, ifmax;	if (! Matrix_getWindowSamplesX (me, tmin - 0.49999 * my dx, tmax + 0.49999 * my dx, & itmin, & itmax) ||		 ! Matrix_getWindowSamplesY (me, qmin - 0.49999 * my dy, qmax + 0.49999 * my dy, & ifmin, & ifmax)) {		return;	}	autoMatrix thee = (Matrix) Data_copy (me);	double min = 1e38, max = -min;	for (long i = 1; i <= my ny; i++) {		for (long j = 1; j <= my nx; j++) {			double val = TO10LOG (my z[i][j]);			min = val < min ? val : min;			max = val > max ? val : max;			thy z[i][j] = val;		}	}	if (dBmaximum <= dBminimum) {		dBminimum = min; dBmaximum = max;	}	Graphics_setInner (g);	Graphics_setWindow (g, tmin, tmax, qmin, qmax);	Graphics_image (g, thy z,		itmin, itmax,		Matrix_columnToX (thee.peek(), itmin - 0.5),		Matrix_columnToX (thee.peek(), itmax + 0.5),		ifmin, ifmax,		Matrix_rowToY (thee.peek(), ifmin - 0.5),		Matrix_rowToY (thee.peek(), ifmax + 0.5),		dBminimum, dBmaximum);	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, 1, L"Time (s)");		Graphics_marksBottom (g, 2, 1, 1, 0);		Graphics_marksLeft (g, 2, 1, 1, 0);		Graphics_textLeft (g, 1, L"Quefrency (s)");	}}

void GaussianMixture_and_PCA_drawMarginalPdf (GaussianMixture me, PCA thee, Graphics g, long d, double xmin, double xmax, double ymin, double ymax, long npoints, long nbins, int garnish){	if (my dimension != thy dimension || d < 1 || d > my dimension)	{ Melder_warning1 (L"Dimensions don't agree."); return;}	if (npoints <= 1) npoints = 1000;	double *p = NUMdvector (1, npoints);	if (p == 0) return;	double nsigmas = 2;	if (xmax <= xmin &&		! GaussianMixture_and_PCA_getIntervalAlongDirection (me, thee, d, nsigmas, &xmin, &xmax)) goto end;	{		double pmax = 0, dx = (xmax - xmin) / npoints, x1 = xmin + 0.5 * dx;		double scalef = nbins <= 0 ? 1 : 1; // TODO		for (long i = 1; i <= npoints; i++)		{			double x = x1 + (i - 1) * dx;			p[i] = scalef * GaussianMixture_getMarginalProbabilityAtPosition (me, thy eigenvectors[d], x);			if (p[i] > pmax) pmax = p[i];		}		if (ymin >= ymax) { ymin = 0; ymax = pmax; }		Graphics_setInner (g);		Graphics_setWindow (g, xmin, xmax, ymin, ymax);		Graphics_function (g, p, 1, npoints, x1, xmax - 0.5 * dx);		Graphics_unsetInner (g);		if (garnish)		{			Graphics_drawInnerBox (g);			Graphics_markBottom (g, xmin, 1, 1, 0, NULL);			Graphics_markBottom (g, xmax, 1, 1, 0, NULL);			Graphics_markLeft (g, ymin, 1, 1, 0, NULL);			Graphics_markLeft (g, ymax, 1, 1, 0, NULL);		}	}end:	NUMdvector_free (p, 1);}

void Polygon_Categories_draw (Polygon me, thou, Graphics graphics, double xmin, double xmax,                              double ymin, double ymax, int garnish) {	thouart (Categories);	double min, max, tmp;	if (my numberOfPoints != thy size) {		return;	}	if (xmax == xmin) {		NUMvector_extrema (my x, 1, my numberOfPoints, & min, & max);		tmp = max - min == 0 ? 0.5 : 0.0;		xmin = min - tmp; xmax = max + tmp;	}	if (ymax == ymin) {		NUMvector_extrema (my y, 1, my numberOfPoints, & min, & max);		tmp = max - min == 0 ? 0.5 : 0.0;		ymin = min - tmp; ymax = max + tmp;	}	Graphics_setInner (graphics);	Graphics_setWindow (graphics, xmin, xmax, ymin, ymax);	Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_HALF);	for (long i = 1; i <= my numberOfPoints; i++) {		OrderedOfString_drawItem (thee, graphics, i, my x[i], my y[i]);	}	Graphics_unsetInner (graphics);	if (garnish) {		Graphics_drawInnerBox (graphics);		Graphics_marksLeft (graphics, 2, 1, 1, 0);		if (ymin * ymax < 0.0) {			Graphics_markLeft (graphics, 0.0, 1, 1, 1, NULL);		}		Graphics_marksBottom (graphics, 2, 1, 1, 0);		if (xmin * xmax < 0.0) {			Graphics_markBottom (graphics, 0.0, 1, 1, 1, NULL);		}	}}

void Matrix_drawOneContour (Matrix me, Graphics g, double xmin, double xmax, double ymin, double ymax,	double height){	bool xreversed = xmin > xmax, yreversed = ymin > ymax;	if (xmax == xmin) { xmin = my xmin; xmax = my xmax; }	if (ymax == ymin) { ymin = my ymin; ymax = my ymax; }	if (xreversed) { double temp = xmin; xmin = xmax; xmax = temp; }	if (yreversed) { double temp = ymin; ymin = ymax; ymax = temp; }	long ixmin, ixmax, iymin, iymax;	(void) Matrix_getWindowSamplesX (me, xmin, xmax, & ixmin, & ixmax);	(void) Matrix_getWindowSamplesY (me, ymin, ymax, & iymin, & iymax);	if (xmin == xmax || ymin == ymax) return;	Graphics_setInner (g);	Graphics_setWindow (g, xreversed ? xmax : xmin, xreversed ? xmin : xmax, yreversed ? ymax : ymin, yreversed ? ymin : ymax);	Graphics_contour (g, my z,		ixmin, ixmax, Matrix_columnToX (me, ixmin), Matrix_columnToX (me, ixmax),		iymin, iymax, Matrix_rowToY (me, iymin), Matrix_rowToY (me, iymax),		height);	Graphics_rectangle (g, xmin, xmax, ymin, ymax);	Graphics_unsetInner (g);}

void PointProcess_draw (PointProcess me, Graphics g, double tmin, double tmax, bool garnish) {	if (tmax <= tmin) { tmin = my xmin; tmax = my xmax; }	Graphics_setWindow (g, tmin, tmax, -1.0, 1.0);	if (my nt) {		long imin = PointProcess_getHighIndex (me, tmin);		long imax = PointProcess_getLowIndex  (me, tmax);		int lineType = Graphics_inqLineType (g);		Graphics_setLineType (g, Graphics_DOTTED);		Graphics_setInner (g);		for (long i = imin; i <= imax; i ++) {			Graphics_line (g, my t [i], -1.0, my t [i], 1.0);		}		Graphics_setLineType (g, lineType);		Graphics_unsetInner (g);	}	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, true, U"Time (s)");		Graphics_marksBottom (g, 2, true, true, false);	}}

void TextGrid_Pitch_drawSeparately (TextGrid grid, Pitch pitch, Graphics g, double tmin, double tmax,	double fmin, double fmax, bool showBoundaries, bool useTextStyles, bool garnish, bool speckle, int unit){	int ntier = grid -> tiers->size;	if (tmax <= tmin) tmin = grid -> xmin, tmax = grid -> xmax;	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);	}	if (unit == kPitch_unit_HERTZ_LOGARITHMIC)		Pitch_draw (pitch, g, tmin, tmax, pow (10.0, fmin - 0.25 * (fmax - fmin) * ntier), pow (10.0, fmax), false, speckle, unit);	else		Pitch_draw (pitch, g, tmin, tmax, fmin - 0.25 * (fmax - fmin) * ntier, fmax, false, speckle, unit);	TextGrid_Sound_draw (grid, nullptr, g, tmin, tmax, showBoundaries, useTextStyles, false);	/*	 * Restore window for the sake of margin drawing.	 */	Graphics_setWindow (g, tmin, tmax, fmin - 0.25 * (fmax - fmin) * ntier, fmax);	if (unit == kPitch_unit_HERTZ_LOGARITHMIC)		fmin = pow (10, fmin), fmax = pow (10.0, fmax);	if (garnish) {		Graphics_drawInnerBox (g);		if (unit == kPitch_unit_HERTZ_LOGARITHMIC) {			Graphics_markLeftLogarithmic (g, fmin, true, true, false, nullptr);			Graphics_markLeftLogarithmic (g, fmax, true, true, false, nullptr);			autoMarks_logarithmic (g, fmin, fmax, false);		} else if (unit == kPitch_unit_SEMITONES_100) {			Graphics_markLeft (g, fmin, true, true, false, nullptr);			Graphics_markLeft (g, fmax, true, true, false, nullptr);			autoMarks_semitones (g, fmin, fmax, false);		} else {			Graphics_markLeft (g, fmin, true, true, false, nullptr);			Graphics_markLeft (g, fmax, true, true, false, nullptr);			autoMarks (g, fmin, fmax, false);		}		Graphics_textLeft (g, true, Melder_cat (U"Pitch (", Function_getUnitText (pitch, Pitch_LEVEL_FREQUENCY, unit, Function_UNIT_TEXT_GRAPHICAL), U")"));		Graphics_textBottom (g, true, U"Time (s)");		Graphics_marksBottom (g, 2, true, true, false);	}}

void Spectrum_drawLogFreq (Spectrum me, Graphics g, double fmin, double fmax, double minimum, double maximum, int garnish) {	int autoscaling = minimum >= maximum;	if (fmax <= fmin) { fmin = my xmin; fmax = my xmax; }	long ifmin, ifmax;	if (! Matrix_getWindowSamplesX (me, fmin, fmax, & ifmin, & ifmax)) return;if(ifmin==1)ifmin=2;  /* BUG */	autoNUMvector <double> xWC (ifmin, ifmax);	autoNUMvector <double> yWC (ifmin, ifmax);	/*	 * First pass: compute power density.	 */	if (autoscaling) maximum = -1e6;	for (long ifreq = ifmin; ifreq <= ifmax; ifreq ++) {		xWC [ifreq] = log10 (my x1 + (ifreq - 1) * my dx);		yWC [ifreq] = my v_getValueAtSample (ifreq, 0, 2);		if (autoscaling && yWC [ifreq] > maximum) maximum = yWC [ifreq];	}	if (autoscaling) minimum = maximum - 60;   /* Default dynamic range is 60 dB. */	/*	 * Second pass: clip.	 */	for (long ifreq = ifmin; ifreq <= ifmax; ifreq ++) {		if (yWC [ifreq] < minimum) yWC [ifreq] = minimum;		else if (yWC [ifreq] > maximum) yWC [ifreq] = maximum;	}	Graphics_setInner (g);	Graphics_setWindow (g, log10 (fmin), log10 (fmax), minimum, maximum);	Graphics_polyline (g, ifmax - ifmin + 1, & xWC [ifmin], & yWC [ifmin]);	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, 1, L"Frequency (Hz)");		Graphics_marksBottomLogarithmic (g, 3, TRUE, TRUE, FALSE);		Graphics_textLeft (g, 1, L"Sound pressure level (dB/Hz)");		Graphics_marksLeftEvery (g, 1.0, 20.0, TRUE, TRUE, FALSE);	}}

void Pitch_Intensity_draw (Pitch pitch, Intensity intensity, Graphics g,	double f1, double f2, double s1, double s2, int garnish, int connect){	if (f2 <= f1) Pitch_getExtrema (pitch, & f1, & f2);	if (f1 == 0.0) return;   /* All voiceless. */	if (f1 == f2) { f1 -= 1.0; f2 += 1.0; }	if (s2 <= s1) Matrix_getWindowExtrema (intensity, 0, 0, 1, 1, & s1, & s2);	if (s1 == s2) { s1 -= 1.0; s2 += 1.0; }	Graphics_setWindow (g, f1, f2, s1, s2);	Graphics_setInner (g);	long previousI = 0;	double previousX = NUMundefined, previousY = NUMundefined;	for (long i = 1; i <= pitch -> nx; i ++) {		double t = Sampled_indexToX (pitch, i);		double x = pitch -> frame [i]. candidate [1]. frequency;		double y = Sampled_getValueAtX (intensity, t, Pitch_LEVEL_FREQUENCY, kPitch_unit_HERTZ, TRUE);		if (x == 0) {			continue;   /* Voiceless. */		}		if (connect & 1) Graphics_speckle (g, x, y);		if ((connect & 2) && NUMdefined (previousX)) {			if (previousI >= 1 && previousI < i - 1) {				Graphics_setLineType (g, Graphics_DOTTED);			}			Graphics_line (g, previousX, previousY, x, y);			Graphics_setLineType (g, Graphics_DRAWN);		}		previousX = x;		previousY = y;		previousI = i;	}	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, 1, L"Fundamental frequency (Hz)");		Graphics_marksBottom (g, 2, 1, 1, 0);		Graphics_textLeft (g, 1, L"Intensity (dB)");		Graphics_marksLeft (g, 2, 1, 1, 0);	}}

void Excitation_draw (Excitation me, Graphics g,	double fmin, double fmax, double minimum, double maximum, int garnish){	if (fmax <= fmin) { fmin = my xmin; fmax = my xmax; }	long ifmin, ifmax;	Matrix_getWindowSamplesX (me, fmin, fmax, & ifmin, & ifmax);	if (maximum <= minimum)		Matrix_getWindowExtrema (me, ifmin, ifmax, 1, 1, & minimum, & maximum);	if (maximum <= minimum) { minimum -= 20; maximum += 20; }	Graphics_setInner (g);	Graphics_setWindow (g, fmin, fmax, minimum, maximum);	Graphics_function (g, my z [1], ifmin, ifmax,		Matrix_columnToX (me, ifmin), Matrix_columnToX (me, ifmax));	Graphics_unsetInner (g);	if (garnish) {		Graphics_drawInnerBox (g);		Graphics_textBottom (g, 1, L"Frequency (Bark)");		Graphics_textLeft (g, 1, L"Excitation (phon)");		Graphics_marksBottomEvery (g, 1, 5, 1, 1, 0);		Graphics_marksLeftEvery (g, 1, 20, 1, 1, 0);	}}