1 files changed, 244 insertions, 244 deletions

diff --git a/source/LinearUpscale.h b/source/LinearUpscale.h
index 9f40b5d81..b7ac84c6a 100644
--- a/source/LinearUpscale.h
+++ b/source/LinearUpscale.h
@@ -1,244 +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_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;

-	}

-	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

-}

-

-

-

-

-

+
+// 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_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;
+	}
+	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
+}
+
+
+
+
+