diff options
Diffstat (limited to 'source/LinearUpscale.h')
| -rw-r--r-- | source/LinearUpscale.h | 488 |
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 +} + + + + + |