TEST(PrecomputationTest, AnisotropicComputeSectorCenters) {
gpuNUFFT::Dimensions imgDim;
imgDim.width = 16;
imgDim.height = 16;
imgDim.depth = 8;
DType osr = 1.5;
IndType sectorWidth = 8;
gpuNUFFT::Dimensions gridDim = imgDim*osr;
gpuNUFFT::Dimensions sectorDims= computeSectorCountPerDimension(gridDim,sectorWidth);
EXPECT_EQ(18,sectorDims.count());
EXPECT_EQ(2,sectorDims.depth);
gpuNUFFT::Array<IndType3> sectorCenters;
sectorCenters.data = (IndType3*)malloc(sectorDims.count() * sizeof(IndType3));
sectorCenters.dim.length = sectorDims.count();
for (IndType z=0;z<sectorDims.depth; z++)
for (IndType y=0;y<sectorDims.height;y++)
for (IndType x=0;x<sectorDims.width;x++)
{
IndType3 center;
center.x = x*sectorWidth + std::floor(static_cast<DType>(sectorWidth) / (DType)2.0);
center.y = y*sectorWidth + std::floor(static_cast<DType>(sectorWidth) / (DType)2.0);
center.z = z*sectorWidth + std::floor(static_cast<DType>(sectorWidth) / (DType)2.0);
sectorCenters.data[computeXYZ2Lin(x,y,z,sectorDims)] = center;
}
if (DEBUG)
for (int i=0; i<sectorDims.count(); i++)
{
std::cout << " x: " << sectorCenters.data[i].x << " y: " << sectorCenters.data[i].y << " z: " << sectorCenters.data[i].z << std::endl;
}
EXPECT_EQ(4,sectorCenters.data[0].x);
EXPECT_EQ(4,sectorCenters.data[0].y);
EXPECT_EQ(4,sectorCenters.data[0].z);
EXPECT_EQ(4,sectorCenters.data[9].x);
EXPECT_EQ(4,sectorCenters.data[9].y);
EXPECT_EQ(12,sectorCenters.data[9].z);
EXPECT_EQ(20,sectorCenters.data[17].x);
EXPECT_EQ(20,sectorCenters.data[17].y);
EXPECT_EQ(12,sectorCenters.data[17].z);
free(sectorCenters.data);
}
static void SetUpTestCase()
{
gpuNUFFT::Dimensions dims(16,16,6);
data.clear();
// row major
for (unsigned slice = 0; slice < dims.depth; slice++)
for (unsigned row = 0; row < dims.height; ++row)
for (unsigned column = 0; column < dims.width; ++column)
{
CufftType val;
val.x = (DType)computeXYZ2Lin(column, row, slice, dims);
val.y = (DType)0.0;
data.push_back(val);
}
}
void debugGrid(int* data,IndType3 gridDims)
{
if (DEBUG)
{
for (unsigned k=0; k<gridDims.z; k++)
{
for (unsigned j=0; j<gridDims.y; j++)
{
for (unsigned i=0; i<gridDims.x; i++)
printf("%d ",data[computeXYZ2Lin(i,gridDims.x-1-j,k,gridDims)]);
printf("\n");
}
printf("-------------------------------------------------------------\n");
}
}
}
void debug(const char* title, std::vector<CufftType> data, gpuNUFFT::Dimensions imgDims)
{
if (DEBUG)
{
printf("%s:\n",title);
for (unsigned k=0; k<std::max(imgDims.depth,1u); k++)
{
for (unsigned j=0; j<imgDims.height; j++)
{
for (unsigned i=0; i<imgDims.width; i++)
printf("%3.0f ",data[computeXYZ2Lin(i,j,k,imgDims)].x);
printf("\n");
}
printf("---------------------------------------------------\n");
}
}
}
void fftShift(int* data,int N,IndType3 gridDims,IndType3 offset)
{
int t = 0;
int x, y, z, x_opp, y_opp, z_opp, ind_opp;
while (t < N/2)
{
getCoordsFromIndex(t, &x, &y, &z, gridDims.x,gridDims.y,gridDims.z);
//calculate "opposite" coord pair
x_opp = (x + offset.x) % gridDims.x;
y_opp = (y + offset.y) % gridDims.y;
z_opp = (z + offset.z) % gridDims.z;
ind_opp = computeXYZ2Lin(x_opp,y_opp,z_opp,gridDims);
//swap points
int temp = data[t];
data[t] = data[ind_opp];
data[ind_opp] = temp;
t++;
}
}
gpuNUFFT::Array<IndType> gpuNUFFT::GpuNUFFTOperatorFactory::computeSectorCenters(gpuNUFFT::GpuNUFFTOperator *gpuNUFFTOp)
{
gpuNUFFT::Dimensions sectorDims = gpuNUFFTOp->getGridSectorDims();
IndType sectorWidth = gpuNUFFTOp->getSectorWidth();
gpuNUFFT::Array<IndType> sectorCenters = initSectorCenters(gpuNUFFTOp,sectorDims.count());
for (IndType z=0;z<sectorDims.depth; z++)
for (IndType y=0;y<sectorDims.height;y++)
for (IndType x=0;x<sectorDims.width;x++)
{
IndType3 center;
center.x = computeSectorCenter(x,sectorWidth);
center.y = computeSectorCenter(y,sectorWidth);
center.z = computeSectorCenter(z,sectorWidth);
int index = computeXYZ2Lin((int)x,(int)y,(int)z,sectorDims);
//necessary in order to avoid 2d or 3d typed array
sectorCenters.data[3*index] = center.x;
sectorCenters.data[3*index+1] = center.y;
sectorCenters.data[3*index+2] = center.z;
}
return sectorCenters;
}
TEST(PrecomputationTest, AssignSectors3D_20x20x10_15) {
gpuNUFFT::Dimensions imgDim;
imgDim.width = 20;
imgDim.height = 20;
imgDim.depth = 10;
DType osr = 1.5;
IndType sectorWidth = 5;
gpuNUFFT::Dimensions gridDim = imgDim * osr;
const IndType coordCnt = 6;
// Coords as StructureOfArrays
// i.e. first x-vals, then y-vals and z-vals
DType coords[coordCnt*3] = {-0.5,-0.3,-0.1, 0.1, 0.3, 0.5,//x
-0.5,-0.5, 0, 0, 0.5, 0.45,//y
-0.33,-0.16666,-0.08,0,0.08, 0.45};//z
gpuNUFFT::Array<DType> kSpaceData;
kSpaceData.data = coords;
kSpaceData.dim.length = coordCnt;
gpuNUFFT::Dimensions sectorDims= computeSectorCountPerDimension(gridDim,sectorWidth);
DType expected[7] = {-0.5000,-0.3333,-0.1666,0,0.1666,0.3333,0.5000};
DType* sectorRange = (DType*)malloc((sectorDims.width +1) * sizeof(DType));
//linspace in range from -0.5 to 0.5
for (int i=0; i <= sectorDims.width; i++)
{
sectorRange[i] = -0.5 + i*(static_cast<DType>(1.0) / (sectorDims.width));
EXPECT_NEAR(sectorRange[i],expected[i],EPS);
}
IndType expectedSec[6] = {0,37,56,57,70,107};
for (int cCnt = 0; cCnt < coordCnt; cCnt++)
{
DType3 coord;
coord.x = kSpaceData.data[cCnt];
coord.y = kSpaceData.data[cCnt + kSpaceData.count()];
coord.z = kSpaceData.data[cCnt + 2*kSpaceData.count()];
if (DEBUG)
std::cout << "processing x var: " << coord.x << " y: " << coord.y << " z: " << coord.z << std::endl;
IndType x_sector = computeSectorMapping(coord.x,sectorDims.width);
IndType y_sector = computeSectorMapping(coord.y,sectorDims.height);
IndType z_sector = computeSectorMapping(coord.z,sectorDims.depth);
if (DEBUG)
std::cout << "into sector x: " << x_sector << " y: " << y_sector << " z: " << z_sector << std::endl;
EXPECT_EQ(expectedSec[cCnt],computeXYZ2Lin(x_sector,y_sector,z_sector,sectorDims));
IndType3 mappedSectors = computeSectorMapping(coord,sectorDims);
EXPECT_EQ(expectedSec[cCnt],computeInd32Lin(mappedSectors,sectorDims));
}
free(sectorRange);
}
