void TestComputeMinMaxValues(Volume* volume)
{
volume->setVoxelToValue(Vec3ui(0, 0, 0), 1.0f);
volume->setVoxelToValue(Vec3ui(15, 15, 15), 121.0f);
volume->setVoxelToValue(Vec3ui(15, 15, 15), 2.0f);
size_t test = volume->getProperties().getVolumeVoxelCount();
auto volumeStats = VolumeStatistics::compute(volume);
ASSERT_FLOAT_EQ(volumeStats.getMin(), 0.0f);
ASSERT_FLOAT_EQ(volumeStats.getMax(), 2.0f);
ASSERT_FLOAT_EQ(volumeStats.getMean(), 0.000732421875f);
}
void AccelerationGrid::add_element(unsigned int idx, const Vec3d& xmin, const Vec3d& xmax)
{
if(m_elementidxs.size() <= idx)
{
m_elementidxs.resize(idx+1);
m_elementxmins.resize(idx+1);
m_elementxmaxs.resize(idx+1);
m_elementquery.resize(idx+1);
}
m_elementxmins[idx] = xmin;
m_elementxmaxs[idx] = xmax;
m_elementquery[idx] = 0;
Vec3i xmini, xmaxi;
boundstoindices(xmin, xmax, xmini, xmaxi);
for(int i = xmini[0]; i <= xmaxi[0]; i++)
{
for(int j = xmini[1]; j <= xmaxi[1]; j++)
{
for(int k = xmini[2]; k <= xmaxi[2]; k++)
{
std::vector<unsigned int>*& cell = m_cells(i, j, k);
if(!cell)
cell = new std::vector<unsigned int>();
cell->push_back(idx);
m_elementidxs[idx].push_back(Vec3ui(i, j, k));
}
}
}
}
void ParticleExtractor::createUniquePointsListFrom2DCoordinates(const std::vector<Vec2ui> *points, std::vector<Vec3ui> &uniquePoints)
{
unsigned int nextId = 1;
for( auto it = points->begin(); it != points->end(); ++it, ++nextId )
{
uniquePoints.push_back(Vec3ui(it->x, it->y, nextId));
}
}
virtual void SetUp() override
{
TestBase::SetUp();
Logger::getInstance();
projectionResolution = Vec2ui(2048, 2048);
Vec3ui volumeResolution;
if(framework->on64bitArchitecture())
{
volumeResolution = Vec3ui(2000, 2000, 100);
}
else
{
volumeResolution = Vec3ui(2000, 2000, 100);
}
volumeOptions = new VolumeParameterSet(volumeResolution);
subVolumeCount = 4;
volume = new FloatVolume(volumeOptions->getResolution(), 1.0f, subVolumeCount);
Vec3f sourcePosition(-1000.0f, -1000.0f, -100.0f);
Vec3f detectorPosition(-1000.0f, -1000.0f, 100.0f);
Vec3f horizontalPitch(1.0f, 0.0f, 0.0f);
Vec3f verticalPitch(0.0f, 1.0f, 0.0f);
ScannerGeometry* initialScannerGeometry = new ParallelScannerGeometry ( projectionResolution );
initialScannerGeometry->set(sourcePosition,
detectorPosition,
horizontalPitch,
verticalPitch);
satRotator->setBaseScannerGeometry(initialScannerGeometry);
geometricSetup = new GeometricSetup(initialScannerGeometry->clone(), volume);
accumulatedVolume = new GPUMappedVolume(framework->getOpenCLStack(), volume);
residual = new GPUMapped<Image>(framework->getOpenCLStack(), projectionResolution);
rayLengthImage = new GPUMapped<Image>(framework->getOpenCLStack(), projectionResolution);
computeRayLength = new ComputeRayLengthKernel(framework, geometricSetup, rayLengthImage);
backProjectKernel = new ParallelBeamsBackProjectionKernel(framework,
geometricSetup,
accumulatedVolume,
nullptr,
1.0f,
1,
false);
backProjectKernel->SetInput(residual, computeRayLength->getOutput());
}
bool write_binary_file_with_velocities( const NonDestructiveTriMesh &mesh,
const std::vector<Vec3d> &x,
const std::vector<double> &masses,
const std::vector<Vec3d> &v,
double curr_t,
const char *filename_format, ...)
{
va_list ap;
va_start(ap, filename_format);
bofstream outfile( filename_format, ap );
va_end(ap);
outfile.write_endianity();
outfile << curr_t;
unsigned int nverts = static_cast<unsigned int>( x.size() );
outfile << nverts;
for ( unsigned int i = 0; i < x.size(); ++i )
{
outfile << x[i][0];
outfile << x[i][1];
outfile << x[i][2];
}
assert( x.size() == masses.size() );
for ( unsigned int i = 0; i < masses.size(); ++i )
{
outfile << masses[i];
}
for ( unsigned int i = 0; i < v.size(); ++i )
{
outfile << v[i][0];
outfile << v[i][1];
outfile << v[i][2];
}
unsigned int ntris = static_cast<unsigned int>( mesh.num_triangles() );
outfile << ntris;
for ( unsigned int t = 0; t < mesh.num_triangles(); ++t )
{
const Vec3ui& tri = Vec3ui( mesh.get_triangle(t) );
outfile << tri[0];
outfile << tri[1];
outfile << tri[2];
}
outfile.close();
return outfile.good();
}
void TestSetZSlice(Volume* volume)
{
Image* image = ImageDeserializer::readImage(std::string(TESTDATA_DIR) + "/data/volume/striped_slice.tif");
volume->setZSlice(2, image);
delete image;
for(unsigned int y = 1; y < volume->getProperties().getVolumeResolution().y; y += 2)
{
float expectedValueFromImage = (float)((y + 1) / 2);
ASSERT_FLOAT_EQ(expectedValueFromImage, volume->getVoxelValue(Vec3ui(y, y, 2)));
}
}
TEST_F(VolumeTest, Test_SliceExtraction_FloatVolume)
{
static const float gaussKernel3D[] =
{
1.0f, 4.0f, 6.0f, 4.0f, 1.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
6.0f, 24.0f, 36.0f, 24.0f, 6.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
1.0f, 4.0f, 6.0f, 4.0f, 1.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
16.0f, 64.0f, 96.0f, 64.0f, 16.0f,
24.0f, 96.0f, 144.0f, 96.0f, 24.0f,
16.0f, 64.0f, 96.0f, 64.0f, 16.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
6.0f, 24.0f, 36.0f, 24.0f, 6.0f,
24.0f, 96.0f, 144.0f, 96.0f, 24.0f,
36.0f, 144.0f, 216.0f, 144.0f, 36.0f,
24.0f, 96.0f, 144.0f, 96.0f, 24.0f,
6.0f, 24.0f, 36.0f, 24.0f, 6.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
16.0f, 64.0f, 96.0f, 64.0f, 16.0f,
24.0f, 96.0f, 144.0f, 96.0f, 24.0f,
16.0f, 64.0f, 96.0f, 64.0f, 16.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
1.0f, 4.0f, 6.0f, 4.0f, 1.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
6.0f, 24.0f, 36.0f, 24.0f, 6.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
1.0f, 4.0f, 6.0f, 4.0f, 1.0f
};
static const float slice1ThroughXZPLane[] =
{
4.0f, 16.0f, 24.0f, 16.0f, 4.0f,
16.0f, 64.0f, 96.0f, 64.0f, 16.0f,
24.0f, 96.0f, 144.0f, 96.0f, 24.0f,
16.0f, 64.0f, 96.0f, 64.0f, 16.0f,
4.0f, 16.0f, 24.0f, 16.0f, 4.0f
};
static const float slice2ThroughXYPLane[] =
{
6.0f, 24.0f, 36.0f, 24.0f, 6.0f,
24.0f, 96.0f, 144.0f, 96.0f, 24.0f,
36.0f, 144.0f, 216.0f, 144.0f, 36.0f,
24.0f, 96.0f, 144.0f, 96.0f, 24.0f,
6.0f, 24.0f, 36.0f, 24.0f, 6.0f
};
Volume *volume = new FloatVolume(Vec3ui(5, 5, 5), gaussKernel3D);
Image *image1 = new Image(Vec2ui(5, 5), slice1ThroughXZPLane);
Image *image2 = new Image(Vec2ui(5, 5), slice2ThroughXYPLane);
TestSliceExtraction(volume, 1, ORDER_XZY, image1); // test general (Volume) slice extraction
TestSliceExtraction(volume, 2, ORDER_XYZ, image2); // test special (FloatVolume, XYZ) slice extraction (memcpy)
auto *options = new OutputParameterSet(IO_VOXEL_TYPE_FLOAT_32, ORDER_XYZ);
framework->getVolumeSerializer()->write( volume, std::string(TESTDATA_DIR) + "/work/volume/gaussian3dKernel.mrc", ".mrc", options);
delete options;
delete image1;
delete image2;
delete volume;
}
void Test_Voxel_Access(Volume* volume)
{
ASSERT_FLOAT_EQ(volume->getVoxelValue(Vec3ui(0, 0, 0)), 0.0f);
ASSERT_FLOAT_EQ(volume->getVoxelValue(Vec3ui(15, 15, 15)), 0.0f);
ASSERT_THROW(volume->getVoxelValue(Vec3ui(16, 0, 0)), Exception);
ASSERT_THROW(volume->getVoxelValue(Vec3ui(0, 16, 0)), Exception);
ASSERT_THROW(volume->getVoxelValue(Vec3ui(0, 0, 16)), Exception);
volume->setVoxelToValue(Vec3ui(0, 0, 0), 1.0f);
volume->setVoxelToValue(Vec3ui(15, 15, 15), 1.0f);
ASSERT_FLOAT_EQ(volume->getVoxelValue(Vec3ui(0, 1, 0)), 0.0f);
ASSERT_FLOAT_EQ(volume->getVoxelValue(Vec3ui(15, 14, 15)), 0.0f);
ASSERT_FLOAT_EQ(volume->getVoxelValue(Vec3ui(0, 0, 0)), 1.0f);
ASSERT_FLOAT_EQ(volume->getVoxelValue(Vec3ui(15, 15, 15)), 1.0f);
}
TEST_F(VolumeTest, UpdateRegion)
{
Volume *volumeOnCPU = new FloatVolume(Vec3ui(16, 16, 16), 0.0f);
auto volume = new GPUMappedVolume(framework->getOpenCLStack(), volumeOnCPU);
Vec3ui subVolumeBase(4, 5, 6);
Vec3ui subVolumeRes(8, 6, 4);
Vec3ui updateRegionBase(3, 3, 3);
Vec3ui updateRegionRes(6, 6, 6);
volume->setArbitrarySubVolume(subVolumeBase, subVolumeRes);
volume->ensureIsUpToDateOnGPU();
// set voxels in region to some values
for(unsigned int z = 0; z < updateRegionRes.z; ++z)
{
for(unsigned int y = 0; y < updateRegionRes.y; ++y)
{
for(unsigned int x = 0; x < updateRegionRes.x; ++x)
{
Vec3ui coords = updateRegionBase + Vec3ui(x, y, z);
volumeOnCPU->setVoxelToValue(coords, -(float)(z * updateRegionRes.y * updateRegionRes.x + y * updateRegionRes.x + x));
}
}
}
volume->updateRegionOnGPU(updateRegionBase, updateRegionRes);
for(unsigned int z = 0; z < updateRegionRes.z; ++z)
{
for(unsigned int y = 0; y < updateRegionRes.y; ++y)
{
for(unsigned int x = 0; x < updateRegionRes.x; ++x)
{
Vec3ui coords = updateRegionBase + Vec3ui(x, y, z);
volume->getObjectOnCPU()->setVoxelToValue(coords, 0.0f);
}
}
}
volume->markAsChangedOnGPU();
volume->ensureIsUpToDateOnCPU();
// now every voxel should be 0 except for the voxels in the updateregion intersected with the subvolume
for(unsigned int z = 0; z < volumeOnCPU->getProperties().getVolumeResolution().z; ++z)
{
for(unsigned int y = 0; y < volumeOnCPU->getProperties().getVolumeResolution().y; ++y)
{
for(unsigned int x = 0; x < volumeOnCPU->getProperties().getVolumeResolution().x; ++x)
{
Vec3ui coords(x, y, z);
float value = volumeOnCPU->getVoxelValue(coords);
BoundingBox3ui aabbUpdateRegion(updateRegionBase, updateRegionBase + updateRegionRes - Vec3ui(1,1,1));
BoundingBox3ui aabbSubVolume(subVolumeBase, subVolumeBase + subVolumeRes - Vec3ui(1, 1, 1));
if (aabbUpdateRegion.isInside(coords) && aabbSubVolume.isInside(coords))
{
Vec3ui coordsInRegion = Vec3ui(x, y, z) - updateRegionBase;
float expectedValue = -(float)(coordsInRegion.z * updateRegionRes.y * updateRegionRes.x + coordsInRegion.y * updateRegionRes.x + coordsInRegion.x);
ASSERT_EQ(value, expectedValue);
}
else
{
ASSERT_EQ(value, 0.0f);
}
}
}
}
/*TEST_F(VolumeTest, DISABLED_Test_Voxel_Raw_Representation_Float32)
{
Volume* volume = new FloatVolume(Vec3ui(16, 16, 16), 0.0f);
ASSERT_EQ(volume->computeDistanceBetweenVoxelsInMemory(0, 1), 4);
volume->setVoxelToValue(Vec3ui(0, 0, 0), 1.0f);
volume->setVoxelToValue(Vec3ui(15, 15, 15), 1.0f);
float* ptr = NULL;
ptr = (float*)volume->getRawPointerOfVoxel(Vec3ui(0, 0, 0));
ASSERT_FLOAT_EQ(*ptr, 1.0f);
ptr = (float*)volume->getRawPointerOfVoxel(Vec3ui(15, 15, 15));
ASSERT_FLOAT_EQ(*ptr, 1.0f);
ptr = (float*)volume->getRawPointerOfVoxel(Vec3ui(1, 0, 0));
ASSERT_FLOAT_EQ(*ptr, 0.0f);
ptr = (float*)volume->getRawPointerOfVoxel(Vec3ui(0, 1, 0));
ASSERT_FLOAT_EQ(*ptr, 0.0f);
ptr = (float*)volume->getRawPointerOfVoxel(Vec3ui(0, 0, 1));
ASSERT_FLOAT_EQ(*ptr, 0.0f);
ASSERT_THROW(volume->getRawPointerOfVoxel(Vec3ui(16, 0, 0)), Exception);
ASSERT_THROW(volume->getRawPointerOfVoxel(Vec3ui(0, 16, 0)), Exception);
ASSERT_THROW(volume->getRawPointerOfVoxel(Vec3ui(0, 0, 16)), Exception);
delete volume;
}
TEST_F(VolumeTest, DISABLED_Test_Voxel_Raw_Representation_HalfFloat16)
{
Volume* volume = new FloatVolume(Vec3ui(16, 16, 16), 0.0f);
ASSERT_EQ(volume->computeDistanceBetweenVoxelsInMemory(0, 1), 2);
volume->setVoxelToValue(Vec3ui(0, 0, 0), 1.0f);
volume->setVoxelToValue(Vec3ui(15, 15, 15), 2.0f);
unsigned short* ptr = NULL;
ptr = (unsigned short*)volume->getRawPointerOfVoxel(Vec3ui(0, 0, 0));
ASSERT_FLOAT_EQ(Float16Compressor::decompress(*ptr), 1.0f);
ptr = (unsigned short*)volume->getRawPointerOfVoxel(Vec3ui(15, 15, 15));
ASSERT_FLOAT_EQ(Float16Compressor::decompress(*ptr), 2.0f);
ptr = (unsigned short*)volume->getRawPointerOfVoxel(Vec3ui(1, 0, 0));
ASSERT_FLOAT_EQ(Float16Compressor::decompress(*ptr), 0.0f);
ASSERT_THROW(volume->getRawPointerOfVoxel(Vec3ui(16, 0, 0)), Exception);
ASSERT_THROW(volume->getRawPointerOfVoxel(Vec3ui(0, 16, 0)), Exception);
ASSERT_THROW(volume->getRawPointerOfVoxel(Vec3ui(0, 0, 16)), Exception);
delete volume;
}*/
delete volumeOnCPU;
delete volume;
}
//.obj files sometimes contain vertex normals indicated by "vn"
if(line.substr(0,1) == std::string("v") && line.substr(0,2) != std::string("vn")){
std::stringstream data(line);
char c;
Vec3f point;
data >> c >> point[0] >> point[1] >> point[2];
vertList.push_back(point);
update_minmax(point, min_box, max_box);
}
else if(line.substr(0,1) == std::string("f")) {
std::stringstream data(line);
char c;
int v0,v1,v2;
data >> c >> v0 >> v1 >> v2;
faceList.push_back(Vec3ui(v0-1,v1-1,v2-1));
}
else if( line.substr(0,2) == std::string("vn") ){
std::cerr << "Obj-loader is not able to parse vertex normals, please strip them from the input file. \n";
exit(-2);
}
else {
++ignored_lines;
}
}
infile.close();
if(ignored_lines > 0)
std::cout << "Warning: " << ignored_lines << " lines were ignored since they did not contain faces or vertices.\n";
std::cout << "Read in " << vertList.size() << " vertices and " << faceList.size() << " faces." << std::endl;
TEST_F(VolumeTest, Test_MinMaxValues_UChar8)
{
Volume* volume = new ByteVolume(Vec3ui(16, 16, 16), 0.0f);
TestComputeMinMaxValues(volume);
delete volume;
}
TEST_F(VolumeTest, Test_MinMaxValues_HalfFloat16)
{
Volume* volume = new HalfFloatVolume(Vec3ui(16, 16, 16), 0.0f);
TestComputeMinMaxValues(volume);
delete volume;
}
TEST_F(VolumeTest, Test_Voxel_Access_UChar8)
{
auto* volume = new ByteVolume(Vec3ui(16, 16, 16), 0.0f);
Test_Voxel_Access(volume);
delete volume;
}
TEST_F(VolumeTest, Test_Voxel_Access_HalfFloat16)
{
auto* volume = new HalfFloatVolume(Vec3ui(16, 16, 16), 0.0f);
Test_Voxel_Access(volume);
delete volume;
}
TEST_F(VolumeTest, Test_Instance_ByteVolume)
{
ByteVolume *volume = new ByteVolume(Vec3ui(16, 16, 16), 0.0f);
Test_Voxel_Access(volume);
delete volume;
}
TEST_F(VolumeTest, Test_Instance_HalfFloatVolume)
{
HalfFloatVolume *volume = new HalfFloatVolume(Vec3ui(16, 16, 16), 0.0f);
Test_Voxel_Access(volume);
delete volume;
}
void Mesh::addTriangles(unsigned int id_1, unsigned int id_2, unsigned int id_3, Vec3f& color) {
Vec3f norm = normalize( cross(rowVertices[id_2] - rowVertices[id_1], rowVertices[id_3] - rowVertices[id_1]));
triangles.push_back(Triangle(Vec3ui(id_1, id_2, id_3), norm, color));
}
TEST_F(VolumeTest, Test_SetZSlice_HalfFloat16)
{
auto* volume = new HalfFloatVolume(Vec3ui(16, 16, 16), 0.0f);
TestSetZSlice(volume);
delete volume;
}
Vec3ui BlobVoxelizationKernelValues::getKernelResolution() const
{
return getValuesPerDimension() * Vec3ui(1, 1, 1);
}
TEST_F(VolumeTest, Test_SetZSlice_UChar8)
{
auto* volume = new ByteVolume(Vec3ui(16, 16, 16), 0.0f);
TestSetZSlice(volume);
delete volume;
}
