#include "xgrafixint.h"

// Function void RescaleTwoDWindow(WindowType theWindow) {{{
void RescaleTwoDWindow(WindowType theWindow)
{
	DataType ptr, data_Ptr = theWindow->data;
	LabelType label_Ptr = theWindow->label;

	int i, n;
	double temp;

	/***************************/
	/* AutoRescaling the x-axis */

	if (Is_X_AutoRescale(theWindow) && (n = *(theWindow->data->npoints))) {
		label_Ptr->X_Max = label_Ptr->X_Min = CurveX(data_Ptr,0);
		for (ptr = data_Ptr; ptr != NULL; ptr = ptr->next) {
			n = *(ptr->npoints);
			ptr->w = (SCALAR**)0;
			ptr->z = (SCALAR**)n;
			for (i = 0; i < n; i++) {
				label_Ptr->X_Max = max(label_Ptr->X_Max, CurveX(ptr,i));
				label_Ptr->X_Min = min(label_Ptr->X_Min, CurveX(ptr,i));
			}
		}
		if (label_Ptr->X_Scale < 0.0) {
			temp = label_Ptr->X_Max;
			label_Ptr->X_Max = label_Ptr->X_Min;
			label_Ptr->X_Min = temp;
		}

		label_Ptr->X_Max *= label_Ptr->X_Scale;
		label_Ptr->X_Min *= label_Ptr->X_Scale;

		if (Is_X_Log(theWindow))
			label_Ptr->X_Min = max(label_Ptr->X_Min, label_Ptr->X_Max / 1e6);
	}
	else if (!Is_X_AutoRescale(theWindow) && (n = *(theWindow->data->npoints))) {
		label_Ptr->X_Max /= label_Ptr->X_Scale;
		label_Ptr->X_Min /= label_Ptr->X_Scale;

		for (ptr = data_Ptr; ptr != NULL; ptr = ptr->next) {
			n = *(ptr->npoints);
			ptr->w = (SCALAR**)0;
			ptr->z = (SCALAR**)n;
			for (i = 0; i < n; i++) {
				if (label_Ptr->X_Min <= CurveX(ptr,i)) {
					ptr->w = (SCALAR**)i;
					break;
				}
			}
			for (; i<n; i++) {
				if (label_Ptr->X_Max < CurveX(ptr,i)) {
					ptr->z = (SCALAR**)i;
					break;
				}
				else if (label_Ptr->X_Max == CurveX(ptr,i)) {
					ptr->z = (SCALAR**)(i+1);
					break;
				}
			}
		}

		label_Ptr->X_Max *= label_Ptr->X_Scale;
		label_Ptr->X_Min *= label_Ptr->X_Scale;
	}
	if (Is_X_Log(theWindow)) {
		label_Ptr->X_Max = pow(10.0, ceil(log10(max(label_Ptr->X_Max, DBL_MIN))));
		label_Ptr->X_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->X_Min,
							DBL_MIN))));
	}

	/****************************/
	/* AutoRescaling the y-axis */

	if (Is_Y_AutoRescale(theWindow) && (n = *(theWindow->data->npoints))) {
		label_Ptr->Y_Max = label_Ptr->Y_Min = CurveY(data_Ptr, (int)data_Ptr->w);
		for (ptr = data_Ptr; ptr != NULL; ptr = ptr->next) {
			n = *(ptr->npoints);
			for (i = (int)(ptr->w); i < (int)(ptr->z); i++) {
				label_Ptr->Y_Max = max(label_Ptr->Y_Max, CurveY(ptr,i));
				label_Ptr->Y_Min = min(label_Ptr->Y_Min, CurveY(ptr,i));
			}
		}
		if (label_Ptr->Y_Scale < 0.0) {
			temp = label_Ptr->Y_Max;
			label_Ptr->Y_Max = label_Ptr->Y_Min;
			label_Ptr->Y_Min = temp;
		}
		label_Ptr->Y_Max *= label_Ptr->Y_Scale;
		label_Ptr->Y_Min *= label_Ptr->Y_Scale;

		if (Is_Y_Log(theWindow))
			label_Ptr->Y_Min = max(label_Ptr->Y_Min, label_Ptr->Y_Max / 1e6);
	}
	if (Is_Y_Log(theWindow)) {
		label_Ptr->Y_Max = pow(10.0, ceil(log10(max(label_Ptr->Y_Max, DBL_MIN))));
		label_Ptr->Y_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Y_Min,
							DBL_MIN))));
	}
} // }}}

// Function void RescaleVectorDWindow(theWindow, ms, *me, ns, ne) {{{
void RescaleVectorDWindow(WindowType theWindow, int *ms, int *me, int *ns,
		int *ne)
{
	DataType data_Ptr = theWindow->data;
	LabelType label_Ptr = theWindow->label;
	int i, m, n, mstart, mend, nstart, nend;

	m = *(data_Ptr->mpoints);
	n = *(data_Ptr->npoints);
	mstart = 0;
	nstart = 0;
	mend   = m - 1;
	nend   = n - 1;


	/****************************/
	/* AutoRescaling the x-axis */

	if (Is_X_AutoRescale(theWindow)) {
		if (n) {
			label_Ptr->X_Max = label_Ptr->X_Min = VectorX(data_Ptr,0);
			for (i = 1; i < m; i++) {
				label_Ptr->X_Max = max(label_Ptr->X_Max, VectorX(data_Ptr,i));
				label_Ptr->X_Min = min(label_Ptr->X_Min, VectorX(data_Ptr,i));
			}
		}
		label_Ptr->X_Max *= label_Ptr->X_Scale;
		label_Ptr->X_Min *= label_Ptr->X_Scale;
	}
	else {
		while (VectorX(data_Ptr,mstart) * label_Ptr->X_Scale <
				label_Ptr->X_Min - DBL_MIN)
			mstart++;
		while (VectorX(data_Ptr,mend) * label_Ptr->X_Scale >
				label_Ptr->X_Max + DBL_MIN)
			mend--;
	}

	/****************************/
	/* AutoRescaling the y-axis */

	if (Is_Y_AutoRescale(theWindow)) {
		if (m) {
			label_Ptr->Y_Max = label_Ptr->Y_Min = VectorY(data_Ptr,0);
			for (i = 1; i < n; i++) {
				label_Ptr->Y_Max = max(label_Ptr->Y_Max, VectorY(data_Ptr,i));
				label_Ptr->Y_Min = min(label_Ptr->Y_Min, VectorY(data_Ptr,i));
			}
		}
		label_Ptr->Y_Max *= label_Ptr->Y_Scale;
		label_Ptr->Y_Min *= label_Ptr->Y_Scale;
	}
	else {
		while (VectorY(data_Ptr,nstart) * label_Ptr->Y_Scale <
				label_Ptr->Y_Min - DBL_MIN)
			nstart++;
		while (VectorY(data_Ptr,nend) * label_Ptr->Y_Scale >
				label_Ptr->Y_Max + DBL_MIN)
			nend--;
	}

	*ms = mstart;
	*me = mend;
	*ns = nstart;
	*ne = nend;
} // }}}

// Function void RescaleThreeDWindow(theWindow, ms, me, ns, ne) {{{
void RescaleThreeDWindow(WindowType theWindow, int *ms, int *me, int *ns,
		int *ne)
{
	DataType data_Ptr = theWindow->data;
	LabelType label_Ptr = theWindow->label;
	int i, j;
	int m, n;
	int mstart, mend, nstart, nend;

	m = n = mstart = mend = nstart = nend = 0;

	/****************************/
	/* AutoRescaling the x-axis */

	if (!Is_Scatter(data_Ptr))
		m = *(data_Ptr->mpoints);
	n = *(data_Ptr->npoints);

	if (Is_X_AutoRescale(theWindow)) {
		if (Is_Scatter(data_Ptr)) {
			if (n) {
				label_Ptr->X_Max = label_Ptr->X_Min = ScatterX(data_Ptr,0);
				for (i = 1; i < n; i++) {
					label_Ptr->X_Max = max(label_Ptr->X_Max, ScatterX(data_Ptr,i));
					label_Ptr->X_Min = min(label_Ptr->X_Min, ScatterX(data_Ptr,i));
				}
				if (label_Ptr->X_Max == label_Ptr->X_Min) return;
			}
		}
		else if (Is_Irr_Surf(data_Ptr)) {
			if (n && m) {
				label_Ptr->X_Max = label_Ptr->X_Min = IrregularX(data_Ptr,0,0);
				for (i = 1; i < m; i++)
					for (j = 0; j < n; j++) {
						label_Ptr->X_Max =
							max(label_Ptr->X_Max, IrregularX(data_Ptr,i,j));
						label_Ptr->X_Min =
							min(label_Ptr->X_Min, IrregularX(data_Ptr,i,j));
					}
				if (label_Ptr->X_Max == label_Ptr->X_Min) return;
			}
		}
		else if (m) {
			label_Ptr->X_Max = SurfaceX(data_Ptr,m - 1);
			label_Ptr->X_Min = SurfaceX(data_Ptr,0);
			if (label_Ptr->X_Max == label_Ptr->X_Min) return;
		}
		label_Ptr->X_Max *= label_Ptr->X_Scale;
		label_Ptr->X_Min *= label_Ptr->X_Scale;
		if (Is_X_Log(theWindow))
			label_Ptr->X_Min = max(label_Ptr->X_Min, 1e-6 * label_Ptr->X_Max);
	}
	if (Is_X_Log(theWindow)) {
		label_Ptr->X_Max = pow(10.0, ceil(log10(max(label_Ptr->X_Max, DBL_MIN))));
		label_Ptr->X_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->X_Min,
							DBL_MIN))));
	}
	if (!Is_Scatter(data_Ptr)) {
		if (Is_Irr_Surf(data_Ptr)) {
			for (i = 0, j = 0; j < n; j++) {
				while (label_Ptr->X_Min / label_Ptr->X_Scale >
						IrregularX(data_Ptr,i,j)
						&& i < m - 1)
					i++;
				mstart = i;
			}
			for (i = m - 1, j = 0; j < n; j++) {
				while (label_Ptr->X_Max / label_Ptr->X_Scale <
						IrregularX(data_Ptr,i,j)
						&& i)
					i--;
				mend = i + 1;
			}
		}
		else {
			mstart = m * (label_Ptr->X_Min / label_Ptr->X_Scale -
					SurfaceX(data_Ptr,0)) /
				(SurfaceX(data_Ptr,m-1) - SurfaceX(data_Ptr,0)) + .5;
			mend = m * (label_Ptr->X_Max / label_Ptr->X_Scale -
					SurfaceX(data_Ptr,0)) /
				(SurfaceX(data_Ptr,m-1) - SurfaceX(data_Ptr,0));
		}
		if (mstart < 0)
			mstart = 0;
		else if (mstart > m - 1)
			mstart = m - 1;
		if (mend < 0)
			mend = 0;
		else if (mend > m)
			mend = m;
	}
	/****************************/
	/* AutoRescaling the y-axis */

	if (Is_Y_AutoRescale(theWindow)) {
		if (Is_Scatter(data_Ptr)) {
			if (n) {
				label_Ptr->Y_Max = label_Ptr->Y_Min = ScatterY(data_Ptr,0);
				for (i = 1; i < n; i++) {
					label_Ptr->Y_Max = max(label_Ptr->Y_Max,
							ScatterY(data_Ptr,i));
					label_Ptr->Y_Min = min(label_Ptr->Y_Min,
							ScatterY(data_Ptr,i));
				}
				if (label_Ptr->Y_Max == label_Ptr->Y_Min) return;
			}
		}
		else if (Is_Irr_Surf(data_Ptr)) {
			if (n && m) {
				label_Ptr->Y_Max = label_Ptr->Y_Min = IrregularY(data_Ptr,0,0);
				for (i = 1; i < m; i++)
					for (j = 0; j < n; j++) {
						label_Ptr->Y_Max =
							max(label_Ptr->Y_Max, IrregularY(data_Ptr,i,j));
						label_Ptr->Y_Min =
							min(label_Ptr->Y_Min, IrregularY(data_Ptr,i,j));
					}
				if (label_Ptr->Y_Max == label_Ptr->Y_Min) return;
			}
		}
		else if (n) {
			label_Ptr->Y_Max = SurfaceY(data_Ptr,n - 1);
			label_Ptr->Y_Min = SurfaceY(data_Ptr,0);
			if (label_Ptr->Y_Max == label_Ptr->Y_Min) return;
		}
		label_Ptr->Y_Max *= label_Ptr->Y_Scale;
		label_Ptr->Y_Min *= label_Ptr->Y_Scale;
		if (Is_Y_Log(theWindow))
			label_Ptr->Y_Min = max(label_Ptr->Y_Min, label_Ptr->Y_Max / 1e6);
	}
	if (Is_Y_Log(theWindow)) {
		label_Ptr->Y_Max = pow(10.0, ceil(log10(max(label_Ptr->Y_Max, DBL_MIN))));
		label_Ptr->Y_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Y_Min,
							DBL_MIN))));
	}
	if (!Is_Scatter(data_Ptr)) {
		if (Is_Irr_Surf(data_Ptr)) {
			for (j = 0, i = 0; i < m; i++) {
				while (label_Ptr->Y_Min / label_Ptr->Y_Scale >
						IrregularY(data_Ptr,i,j)
						&& j < n - 1)
					j++;
				nstart = j;
			}
			for (j = n - 1, i = 0; i < m; i++) {
				while (label_Ptr->Y_Max / label_Ptr->Y_Scale <
						IrregularY(data_Ptr,i,j)
						&& j)
					j--;
				nend = j + 1;
			}
		}
		else {
			nstart = n * (label_Ptr->Y_Min / label_Ptr->Y_Scale -
					SurfaceY(data_Ptr,0)) /
				(SurfaceY(data_Ptr,n - 1) - SurfaceY(data_Ptr,0)) + .5;
			nend = n * (label_Ptr->Y_Max / label_Ptr->Y_Scale -
					SurfaceY(data_Ptr,0)) /
				(SurfaceY(data_Ptr,n - 1) - SurfaceY(data_Ptr,0));
		}
		if (nstart < 0)
			nstart = 0;
		else if (nstart > n - 1)
			nstart = n - 1;
		if (nend < 0)
			nend = 0;
		else if (nend > n)
			nend = n;
	}
	/****************************/
	/* AutoRescaling the z-axis */

	if (Is_Z_AutoRescale(theWindow) && (n || m)) {
		if (Is_Scatter(data_Ptr)) {
			label_Ptr->Z_Max = label_Ptr->Z_Min = ScatterZ(data_Ptr,0);
			for (i = 1; i < n; i++) {
				label_Ptr->Z_Max = max(label_Ptr->Z_Max, ScatterZ(data_Ptr,i));
				label_Ptr->Z_Min = min(label_Ptr->Z_Min, ScatterZ(data_Ptr,i));
			}
		}
		else {
			label_Ptr->Z_Max = label_Ptr->Z_Min =
				SurfaceZ(data_Ptr,mstart,nstart);
			for (i = mstart; i < mend; i++)
				for (j = nstart; j < nend; j++) {
					label_Ptr->Z_Max =
						max(label_Ptr->Z_Max, SurfaceZ(data_Ptr,i,j));
					label_Ptr->Z_Min =
						min(label_Ptr->Z_Min, SurfaceZ(data_Ptr,i,j));
				}
		}
		label_Ptr->Z_Max *= label_Ptr->Z_Scale;
		label_Ptr->Z_Min *= label_Ptr->Z_Scale;
		if (Is_Z_Log(theWindow))
			label_Ptr->Z_Min = max(label_Ptr->Z_Min, label_Ptr->Z_Max / 1e6);
	}
	if (Is_Z_Log(theWindow)) {
		label_Ptr->Z_Max = pow(10.0, ceil(log10(max(label_Ptr->Z_Max, DBL_MIN))));
		label_Ptr->Z_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Z_Min,
							DBL_MIN))));
	}

	*ms = mstart;
	*me = mend;
	*ns = nstart;
	*ne = nend;
} // }}}


// Modeline for ViM {{{1
// vim:set ts=4:
// vim600:fdm=marker fdl=0 fdc=3:
// 1}}}