1 files changed, 0 insertions, 244 deletions

diff --git a/source/LinearUpscale.h b/source/LinearUpscale.h
deleted file mode 100644
index b337b3219..000000000
--- a/source/LinearUpscale.h
+++ /dev/null
@@ -1,244 +0,0 @@
-
-// 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
-}
-
-
-
-
-