1 files changed, 244 insertions, 0 deletions

diff --git a/src/LinearUpscale.h b/src/LinearUpscale.h
new file mode 100644
index 000000000..b337b3219
--- /dev/null
+++ b/src/LinearUpscale.h
@@ -0,0 +1,244 @@
+
+// LinearUpscale.h
+
+// Declares the functions for linearly upscaling arrays
+
+/*
+Upscaling means that the array is divided into same-size "cells", and each cell is
+linearly interpolated between its corners. The array's dimensions are therefore
+1 + CellSize * NumCells, for each direction.
+
+Upscaling is more efficient than linear interpolation, because the cell sizes are integral
+and therefore the cells' boundaries are on the array points.
+
+However, upscaling usually requires generating the "1 +" in each direction.
+
+Upscaling is implemented in templates, so that it's compatible with multiple datatypes.
+Therefore, there is no cpp file.
+
+InPlace upscaling works on a single array and assumes that the values to work on have already
+been interspersed into the array to the cell boundaries.
+Specifically, a_Array[x * a_AnchorStepX + y * a_AnchorStepY] contains the anchor value.
+
+Regular upscaling takes two arrays and "moves" the input from src to dst; src is expected packed.
+*/
+
+
+
+
+/**
+Linearly interpolates values in the array between the equidistant anchor points (upscales).
+Works in-place (input is already present at the correct output coords)
+*/
+template<typename TYPE> void LinearUpscale2DArrayInPlace(
+	TYPE * a_Array,
+	int a_SizeX, int a_SizeY,  // Dimensions of the array
+	int a_AnchorStepX, int a_AnchorStepY  // Distances between the anchor points in each direction
+)
+{
+	// First interpolate columns where the anchor points are:
+	int LastYCell = a_SizeY - a_AnchorStepY;
+	for (int y = 0; y < LastYCell; y += a_AnchorStepY)
+	{
+		int Idx = a_SizeX * y;
+		for (int x = 0; x < a_SizeX; x += a_AnchorStepX)
+		{
+			TYPE StartValue = a_Array[Idx];
+			TYPE EndValue   = a_Array[Idx + a_SizeX * a_AnchorStepY];
+			TYPE Diff = EndValue - StartValue;
+			for (int CellY = 1; CellY < a_AnchorStepY; CellY++)
+			{
+				a_Array[Idx + a_SizeX * CellY] = StartValue + Diff * CellY / a_AnchorStepY;
+			}  // for CellY
+			Idx += a_AnchorStepX;
+		}  // for x
+	}  // for y
+
+	// Now interpolate in rows, each row has values in the anchor columns
+	int LastXCell = a_SizeX - a_AnchorStepX;
+	for (int y = 0; y < a_SizeY; y++)
+	{
+		int Idx = a_SizeX * y;
+		for (int x = 0; x < LastXCell; x += a_AnchorStepX)
+		{
+			TYPE StartValue = a_Array[Idx];
+			TYPE EndValue   = a_Array[Idx + a_AnchorStepX];
+			TYPE Diff = EndValue - StartValue;
+			for (int CellX = 1; CellX < a_AnchorStepX; CellX++)
+			{
+				a_Array[Idx + CellX] = StartValue + CellX * Diff / a_AnchorStepX;
+			}  // for CellY
+			Idx += a_AnchorStepX;
+		}
+	}
+}
+
+
+
+
+
+/**
+Linearly interpolates values in the array between the equidistant anchor points (upscales).
+Works on two arrays, input is packed and output is to be completely constructed.
+*/
+template<typename TYPE> void LinearUpscale2DArray(
+	TYPE * a_Src,                    ///< Source array of size a_SrcSizeX x a_SrcSizeY
+	int a_SrcSizeX, int a_SrcSizeY,  ///< Dimensions of the src array
+	TYPE * a_Dst,                    ///< Dest array, of size (a_SrcSizeX * a_UpscaleX + 1) x (a_SrcSizeY * a_UpscaleY + 1)
+	int a_UpscaleX, int a_UpscaleY   ///< Upscale factor for each direction
+)
+{
+	// For optimization reasons, we're storing the upscaling ratios in a fixed-size arrays of these sizes
+	// Feel free to enlarge them if needed, but keep in mind that they're on the stack
+	const int MAX_UPSCALE_X = 128;
+	const int MAX_UPSCALE_Y = 128;
+
+	ASSERT(a_Src != NULL);
+	ASSERT(a_Dst != NULL);
+	ASSERT(a_SrcSizeX > 0);
+	ASSERT(a_SrcSizeY > 0);
+	ASSERT(a_UpscaleX > 0);
+	ASSERT(a_UpscaleY > 0);
+	ASSERT(a_UpscaleX <= MAX_UPSCALE_X);
+	ASSERT(a_UpscaleY <= MAX_UPSCALE_Y);
+
+	// Pre-calculate the upscaling ratios:
+	TYPE RatioX[MAX_UPSCALE_X];
+	TYPE RatioY[MAX_UPSCALE_Y];
+	for (int x = 0; x <= a_UpscaleX; x++)
+	{
+		RatioX[x] = (TYPE)x / a_UpscaleX;
+	}
+	for (int y = 0; y <= a_UpscaleY; y++)
+	{
+		RatioY[y] = (TYPE)y / a_UpscaleY;
+	}
+
+	// Interpolate each XY cell:
+	int DstSizeX = (a_SrcSizeX - 1) * a_UpscaleX + 1;
+	int DstSizeY = (a_SrcSizeY - 1) * a_UpscaleY + 1;
+	for (int y = 0; y < (a_SrcSizeY - 1); y++)
+	{
+		int DstY = y * a_UpscaleY;
+		int idx = y * a_SrcSizeX;
+		for (int x = 0; x < (a_SrcSizeX - 1); x++, idx++)
+		{
+			int DstX = x * a_UpscaleX;
+			TYPE LoXLoY = a_Src[idx];
+			TYPE LoXHiY = a_Src[idx + a_SrcSizeX];
+			TYPE HiXLoY = a_Src[idx + 1];
+			TYPE HiXHiY = a_Src[idx + 1 + a_SrcSizeX];
+			for (int CellY = 0; CellY <= a_UpscaleY; CellY++)
+			{
+				int DestIdx = (DstY + CellY) * DstSizeX + DstX;
+				ASSERT(DestIdx + a_UpscaleX < DstSizeX * DstSizeY);
+				TYPE LoXInY = LoXLoY + (LoXHiY - LoXLoY) * RatioY[CellY];
+				TYPE HiXInY = HiXLoY + (HiXHiY - HiXLoY) * RatioY[CellY];
+				for (int CellX = 0; CellX <= a_UpscaleX; CellX++, DestIdx++)
+				{
+					a_Dst[DestIdx] = LoXInY + (HiXInY - LoXInY) * RatioX[CellX];
+				}
+			}  // for CellY
+		}  // for x
+	}  // for y
+}
+
+
+
+
+
+/**
+Linearly interpolates values in the array between the equidistant anchor points (upscales).
+Works on two arrays, input is packed and output is to be completely constructed.
+*/
+template<typename TYPE> void LinearUpscale3DArray(
+	TYPE * a_Src,                                    ///< Source array of size a_SrcSizeX x a_SrcSizeY x a_SrcSizeZ
+	int a_SrcSizeX, int a_SrcSizeY, int a_SrcSizeZ,  ///< Dimensions of the src array
+	TYPE * a_Dst,                                    ///< Dest array, of size (a_SrcSizeX * a_UpscaleX + 1) x (a_SrcSizeY * a_UpscaleY + 1) x (a_SrcSizeZ * a_UpscaleZ + 1)
+	int a_UpscaleX, int a_UpscaleY, int a_UpscaleZ   ///< Upscale factor for each direction
+)
+{
+	// For optimization reasons, we're storing the upscaling ratios in a fixed-size arrays of these sizes
+	// Feel free to enlarge them if needed, but keep in mind that they're on the stack
+	const int MAX_UPSCALE_X = 128;
+	const int MAX_UPSCALE_Y = 128;
+	const int MAX_UPSCALE_Z = 128;
+
+	ASSERT(a_Src != NULL);
+	ASSERT(a_Dst != NULL);
+	ASSERT(a_SrcSizeX > 0);
+	ASSERT(a_SrcSizeY > 0);
+	ASSERT(a_SrcSizeZ > 0);
+	ASSERT(a_UpscaleX > 0);
+	ASSERT(a_UpscaleY > 0);
+	ASSERT(a_UpscaleZ > 0);
+	ASSERT(a_UpscaleX <= MAX_UPSCALE_X);
+	ASSERT(a_UpscaleY <= MAX_UPSCALE_Y);
+	ASSERT(a_UpscaleZ <= MAX_UPSCALE_Z);
+
+	// Pre-calculate the upscaling ratios:
+	TYPE RatioX[MAX_UPSCALE_X];
+	TYPE RatioY[MAX_UPSCALE_Y];
+	TYPE RatioZ[MAX_UPSCALE_Z];
+	for (int x = 0; x <= a_UpscaleX; x++)
+	{
+		RatioX[x] = (TYPE)x / a_UpscaleX;
+	}
+	for (int y = 0; y <= a_UpscaleY; y++)
+	{
+		RatioY[y] = (TYPE)y / a_UpscaleY;
+	}
+	for (int z = 0; z <= a_UpscaleZ; z++)
+	{
+		RatioZ[z] = (TYPE)z / a_UpscaleZ;
+	}
+
+	// Interpolate each XYZ cell:
+	int DstSizeX = (a_SrcSizeX - 1) * a_UpscaleX + 1;
+	int DstSizeY = (a_SrcSizeY - 1) * a_UpscaleY + 1;
+	int DstSizeZ = (a_SrcSizeZ - 1) * a_UpscaleZ + 1;
+	for (int z = 0; z < (a_SrcSizeZ - 1); z++)
+	{
+		int DstZ = z * a_UpscaleZ;
+		for (int y = 0; y < (a_SrcSizeY - 1); y++)
+		{
+			int DstY = y * a_UpscaleY;
+			int idx = y * a_SrcSizeX + z * a_SrcSizeX * a_SrcSizeY;
+			for (int x = 0; x < (a_SrcSizeX - 1); x++, idx++)
+			{
+				int DstX = x * a_UpscaleX;
+				TYPE LoXLoYLoZ = a_Src[idx];
+				TYPE LoXLoYHiZ = a_Src[idx + a_SrcSizeX * a_SrcSizeY];
+				TYPE LoXHiYLoZ = a_Src[idx + a_SrcSizeX];
+				TYPE LoXHiYHiZ = a_Src[idx + a_SrcSizeX + a_SrcSizeX * a_SrcSizeY];
+				TYPE HiXLoYLoZ = a_Src[idx + 1];
+				TYPE HiXLoYHiZ = a_Src[idx + 1 + a_SrcSizeX * a_SrcSizeY];
+				TYPE HiXHiYLoZ = a_Src[idx + 1 + a_SrcSizeX];
+				TYPE HiXHiYHiZ = a_Src[idx + 1 + a_SrcSizeX + a_SrcSizeX * a_SrcSizeY];
+				for (int CellZ = 0; CellZ <= a_UpscaleZ; CellZ++)
+				{
+					TYPE LoXLoYInZ = LoXLoYLoZ + (LoXLoYHiZ - LoXLoYLoZ) * RatioZ[CellZ];
+					TYPE LoXHiYInZ = LoXHiYLoZ + (LoXHiYHiZ - LoXHiYLoZ) * RatioZ[CellZ];
+					TYPE HiXLoYInZ = HiXLoYLoZ + (HiXLoYHiZ - HiXLoYLoZ) * RatioZ[CellZ];
+					TYPE HiXHiYInZ = HiXHiYLoZ + (HiXHiYHiZ - HiXHiYLoZ) * RatioZ[CellZ];
+					for (int CellY = 0; CellY <= a_UpscaleY; CellY++)
+					{
+						int DestIdx = (DstZ + CellZ) * DstSizeX * DstSizeY + (DstY + CellY) * DstSizeX + DstX;
+						ASSERT(DestIdx + a_UpscaleX < DstSizeX * DstSizeY * DstSizeZ);
+						TYPE LoXInY = LoXLoYInZ + (LoXHiYInZ - LoXLoYInZ) * RatioY[CellY];
+						TYPE HiXInY = HiXLoYInZ + (HiXHiYInZ - HiXLoYInZ) * RatioY[CellY];
+						for (int CellX = 0; CellX <= a_UpscaleX; CellX++, DestIdx++)
+						{
+							a_Dst[DestIdx] = LoXInY + (HiXInY - LoXInY) * RatioX[CellX];
+						}
+					}  // for CellY
+				}  // for CellZ
+			}  // for x
+		}  // for y
+	}  // for z
+}
+
+
+
+
+