//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rendering::renderOverlayItems(OpenGLContext* oglContext, bool useSoftwareRendering)
{
OverlayItemRectMap itemRectMap;
calculateOverlayItemLayout(&itemRectMap);
// Must setup a scissor to limit the overlay items to the current viewport, as they might setup a local viewport (e.g. navigation cube)
GLboolean scissorWasOn = glIsEnabled(GL_SCISSOR_TEST);
int scissorBox[4] = {0, 0, -1, -1};
glGetIntegerv(GL_SCISSOR_BOX, scissorBox);
glScissor(static_cast<GLsizei>(m_camera->viewport()->x()), static_cast<GLsizei>(m_camera->viewport()->y()), static_cast<GLsizei>(m_camera->viewport()->width()), static_cast<GLsizei>(m_camera->viewport()->height()));
glEnable(GL_SCISSOR_TEST);
OverlayItemRectMap::iterator it;
for (it = itemRectMap.begin(); it != itemRectMap.end(); ++it)
{
OverlayItem* item = it->first;
Recti rect = it->second;
if (useSoftwareRendering)
{
item->renderSoftware(oglContext, rect.min(), Vec2ui(static_cast<cvf::uint>(rect.width()), static_cast<cvf::uint>(rect.height())));
}
else
{
item->render(oglContext, rect.min(), Vec2ui(static_cast<cvf::uint>(rect.width()), static_cast<cvf::uint>(rect.height())));
}
}
// Restore scissor settings
if (!scissorWasOn) glDisable(GL_SCISSOR_TEST);
glScissor(scissorBox[0], scissorBox[1], scissorBox[2], scissorBox[3]);
}
void make_box(Vec2f bottom_left, float height, float width, std::vector<Vec2f>& verts, std::vector<Vec2ui>& edges) {
verts.clear();
edges.clear();
verts.push_back(bottom_left);
verts.push_back(bottom_left+Vec2f(width,0));
verts.push_back(bottom_left+Vec2f(width,height));
verts.push_back(bottom_left+Vec2f(0,height));
edges.push_back(Vec2ui(0,1));
edges.push_back(Vec2ui(1,2));
edges.push_back(Vec2ui(2,3));
edges.push_back(Vec2ui(3,0));
}
const Vec2ui UIWidget::GetSize() const {
if (uIControl != nullptr) {
return uIControl->GetSize();
} else {
return Vec2ui(0);
}
}
std::vector<Vec2ui> *ParticleExtractor::exportParticlesFromImageToListAll(GPUMapped<Image> *inputImage)
{
auto *result = new std::vector<Vec2ui>();
inputImage->ensureIsUpToDateOnCPU();
Vec2ui size = inputImage->getResolution();
float value;
for( unsigned int j = 0; j < size.y; ++j )
{
for( unsigned int i = 0; i < size.x; ++i )
{
value = inputImage->getObjectOnCPU()->getPixel((int)i, (int)j);
if( value > 0.0f )
{
result->push_back(Vec2ui(i, j));
}
}
}
std::sort(result->begin(), result->end(), [&](const Vec2ui& left, const Vec2ui& right)
{
float lVal = inputImage->getObjectOnCPU()->getPixel(left.x, left.y);
float rVal = inputImage->getObjectOnCPU()->getPixel(right.x, right.y);
return lVal > rVal;
});
result->shrink_to_fit();
return result;
}
ParticleData ParticleExtractor::loadFromFile(std::string filename)
{
ParticleData result;
result.data = new std::vector<Vec2ui>();
std::ifstream input(filename, std::ifstream::in);
if(!input.good())
{
std::cout << "Wrong particle file name " << filename << "!" << std::endl;
return result;
}
input >> result.size.x >> result.size.y;
unsigned int temp, temp2;
input >> temp;
if( temp )
result.coordinateOfCenter = true;
else
result.coordinateOfCenter = false;
while(input.good())
{
input >> temp >> temp2;
result.data->push_back(Vec2ui(temp, temp2));
}
input.close();
result.data->shrink_to_fit();
return result;
}
RegularizationBackProjectionKernel::RegularizationBackProjectionKernel(Framework* framework, const GeometricSetup* geometricSetup, GPUMapped<Image>* residual, GPUMapped<Image>* rayLength, GPUMapped<SubVolume>* subvolume, float lambda, bool useLongObjectCompensation)
: ComputeKernel(framework, Voxel_by_Voxel_Regularization_Backprojection_kernel_SourceCode, "correct", "RegularizationBackProjectionKernel")
, projectionResolution(geometricSetup->getResolution())
, geometricSetup(geometricSetup)
, residual(residual)
, rayLength(rayLength)
, subvolume(subvolume)
, lambda(lambda)
{
transformMatrix = new GPUMapped<Matrix4x4>(abstractionLayer, Vec2ui(4, 4));
}
void make_circle(Vec2f centre, float radius, int segments, std::vector<Vec2f>& verts, std::vector<Vec2ui>& edges ) {
verts.clear();
edges.clear();
float d_angle = 2.0f*(float)M_PI / (float)segments;
float angle = 0;
for(int i = 0; i < segments; ++i) {
verts.push_back(centre + radius*Vec2f(cos(angle), sin(angle)));
edges.push_back(Vec2ui(i,i+1));
angle+=d_angle;
}
edges[edges.size()-1][1] = 0; //fix the last one
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rendering::renderOverlayItems(OpenGLContext* oglContext, bool useSoftwareRendering)
{
OverlayItemRectMap itemRectMap;
calculateOverlayItemLayout(&itemRectMap);
OverlayItemRectMap::iterator it;
for (it = itemRectMap.begin(); it != itemRectMap.end(); ++it)
{
OverlayItem* item = it->first;
Recti rect = it->second;
if (useSoftwareRendering)
{
item->renderSoftware(oglContext, rect.min(), Vec2ui(static_cast<cvf::uint>(rect.width()), static_cast<cvf::uint>(rect.height())));
}
else
{
item->render(oglContext, rect.min(), Vec2ui(static_cast<cvf::uint>(rect.width()), static_cast<cvf::uint>(rect.height())));
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rendering::renderOverlayItems(OpenGLContext* oglContext, bool useSoftwareRendering)
{
OverlayItemRectMap itemRectMap;
calculateOverlayItemLayout(&itemRectMap);
OverlayItemRectMap::iterator it;
for (it = itemRectMap.begin(); it != itemRectMap.end(); ++it)
{
OverlayItem* item = it->first;
Recti rect = it->second;
if (useSoftwareRendering)
{
item->renderSoftware(oglContext, rect.min(), Vec2ui(static_cast<cvf::uint>(rect.width()), static_cast<cvf::uint>(rect.height())));
}
else
{
item->render(oglContext, rect.min(), Vec2ui(static_cast<cvf::uint>(rect.width()), static_cast<cvf::uint>(rect.height())));
}
}
for (size_t i = 0; i < m_overlayItems.size(); i++)
{
OverlayItemLayout item = m_overlayItems.at(i);
if ((item.corner == OverlayItem::UNMANAGED) )
{
Vec2ui size = item.overlayItem->sizeHint();
Vec2i pos = item.overlayItem->unmanagedPosition();
if (useSoftwareRendering)
{
item.overlayItem->renderSoftware(oglContext, pos, size);
}
else
{
item.overlayItem->render(oglContext, pos, size);
}
}
}
}
//--------------------------------------------------------------------------------------------------
/// Set the size of the text box to fit the current text.
///
/// The method will also add a bit of space for the border or background if enabled.
//--------------------------------------------------------------------------------------------------
void OverlayTextBox::setSizeToFitText()
{
cvf::Vec2ui textSize = m_font->textExtent(m_text);
// Add the size of an 'A' as the margin, same as used in the Text Drawer
ref<Glyph> glyph = m_font->getGlyph(L'A');
Vec2ui size = Vec2ui(textSize.x() + glyph->width(), textSize.y() + glyph->height());
if (m_drawBorder)
{
size.x() += 4;
size.y() += 4;
}
setPixelSize(size);
}
//--------------------------------------------------------------------------------------------------
/// Get the extent (width and height) of the given text with this font in pixels
//--------------------------------------------------------------------------------------------------
cvf::Vec2ui Font::textExtent(const String& text)
{
std::vector<cvf::String> lines = text.split("\n");
float maxLineWidth = 0;
uint textHeight = 0;
uint lineSpacing = static_cast<uint>(this->lineSpacing());
for (size_t lineIdx = 0; lineIdx < lines.size(); ++lineIdx)
{
String line = lines[lineIdx];
size_t numCharacters = line.size();
float lineWidth = 0;
for (size_t j = 0; j < numCharacters; ++j)
{
wchar_t character = line[j];
// Jump to the next character in the string, if any
if (j < (numCharacters - 1))
{
float advance = static_cast<float>(this->advance(character, text[j + 1]));
lineWidth += advance;
}
else
{
ref<Glyph> glyph = getGlyph(character);
lineWidth += static_cast<float>(glyph->width()) + static_cast<float>(glyph->horizontalBearingX());
}
}
maxLineWidth = CVF_MAX(lineWidth, maxLineWidth);
if (lineIdx == 0)
{
ref<Glyph> glyph = getGlyph(L'A');
textHeight += glyph->height();
}
else
{
textHeight += lineSpacing;
}
}
return Vec2ui(static_cast<uint>(maxLineWidth), textHeight);
}
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());
}
//--------------------------------------------------------------------------------------------------
/// Get the extent (width and height) of the given text with this font in pixels
//--------------------------------------------------------------------------------------------------
cvf::Vec2ui Font::textExtent(const String& text)
{
Vec2ui textBB(0,0);
int minHeight = std::numeric_limits<int>::max();
int maxHeight = std::numeric_limits<int>::min();
size_t numCharacters = text.size();
for (size_t j = 0; j < numCharacters; j++)
{
wchar_t character = text[j];
ref<Glyph> glyph = getGlyph(character);
// Find bottom and top with regards to baseline (Y = 0)
int minY = static_cast<int>(glyph->horizontalBearingY()) - static_cast<int>(glyph->height());
int maxY = glyph->horizontalBearingY();
if (minHeight > minY) minHeight = minY;
if (maxHeight < maxY) maxHeight = maxY;
uint charWidth = 0;
if (j < (numCharacters - 1))
{
charWidth = advance(character, text[j + 1]);
}
else
{
charWidth = glyph->width() + glyph->horizontalBearingX();
}
textBB.x() += charWidth;
}
if (maxHeight < minHeight)
{
return Vec2ui(0,0);
}
textBB.y() = static_cast<uint>(maxHeight - minHeight);
return textBB;
}
//--------------------------------------------------------------------------------------------------
/// Get the the overlay item (if any) at the given cursor position
//--------------------------------------------------------------------------------------------------
OverlayItem* Rendering::overlayItemFromWindowCoordinates(int x, int y)
{
OverlayItemRectMap itemRectMap;
calculateOverlayItemLayout(&itemRectMap);
OverlayItemRectMap::iterator it;
for (it = itemRectMap.begin(); it != itemRectMap.end(); ++it)
{
OverlayItem* item = it->first;
Recti rect = it->second;
if (item->pick(x, y, rect.min(), Vec2ui(static_cast<cvf::uint>(rect.width()), static_cast<cvf::uint>(rect.height()))))
{
return item;
}
}
return NULL;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool OverlayScalarMapperLegend::pick(int oglXCoord, int oglYCoord, const Vec2i& position, const Vec2ui& size)
{
Recti oglRect(position, size.x(), size.y());
OverlayColorLegendLayoutInfo layoutInViewPortCoords(oglRect.min(), Vec2ui(oglRect.width(), oglRect.height()));
layoutInfo(&layoutInViewPortCoords);
Vec2i legendBarOrigin = oglRect.min();
legendBarOrigin.x() += static_cast<uint>(layoutInViewPortCoords.legendRect.min().x());
legendBarOrigin.y() += static_cast<uint>(layoutInViewPortCoords.legendRect.min().y());
Recti legendBarRect = Recti(legendBarOrigin, static_cast<uint>(layoutInViewPortCoords.legendRect.width()), static_cast<uint>(layoutInViewPortCoords.legendRect.height()));
if ((oglXCoord > legendBarRect.min().x()) && (oglXCoord < legendBarRect.max().x()) &&
(oglYCoord > legendBarRect.min().y()) && (oglYCoord < legendBarRect.max().y()))
{
return true;
}
return false;
}
//--------------------------------------------------------------------------------------------------
/// Get the the overlay item (if any) at the given cursor position
//--------------------------------------------------------------------------------------------------
OverlayItem* Rendering::overlayItemFromWindowCoordinates(int x, int y)
{
OverlayItemRectMap itemRectMap;
calculateOverlayItemLayout(&itemRectMap);
const size_t numOverlayItems = m_overlayItems.size();
for (size_t i = 0; i < numOverlayItems; i++)
{
OverlayItem* item = m_overlayItems.at(i);
OverlayItemRectMap::iterator it = itemRectMap.find(item);
if (it != itemRectMap.end())
{
Recti rect = it->second;
if (item->pick(x, y, rect.min(), Vec2ui(static_cast<cvf::uint>(rect.width()), static_cast<cvf::uint>(rect.height()))))
{
return item;
}
}
}
return NULL;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec2ui OverlayScalarMapperLegend::minimumSize()
{
return Vec2ui(100,100);
}
void InitGameMemory(game_memory *Memory, Canvas &canvas)
{
// �I�~�y���y�p�|�y�x�p���y��
game_state* GameState = (game_state*)Memory->PermanentStorage;
InitializeArena(&GameState->WorldArena, Memory->PermanentStorageSize - sizeof(game_state), (uint8*)Memory->PermanentStorage + sizeof(game_state));
GameState->World = PushStruct(&GameState->WorldArena, world);
world *World = GameState->World;
World->TileMap = PushStruct(&GameState->WorldArena, tile_map);
tile_map *TileMap = World->TileMap;
GameState->Tick = 0;
GameState->TimeElapsedFromLastTick = 0;
// Camera
GameState->CameraPos.Tile = Vec2i(0, 0);
GameState->CameraPos.TilePos = Vec2f(0, 0);
GameState->CameraOrigin = GameState->ScreenSize / 2.0f;
GameState->EntityToCameraIn = Rect(-7, -5, 7, 5);
GameState->EntityToCameraOut = Rect(-8, -6, 8, 6);
// �H�p�s�����x�y���� �������p�z����
GameState->LoadGameSpriteFromImage(canvas, GameState->GameSprites.tmp_sprite, "sand_tile_01.png");
GameState->LoadGameSpriteFromImage(canvas, GameState->GameSprites.tmp_object_sprite_001, "object_storage_01.png");
GameState->LoadGameSpriteFromImage(canvas, GameState->GameSprites.tmp_object_sprite_stone1, "object_stone_01.png");
GameState->LoadGameSpriteFromImage(canvas, GameState->GameSprites.tmp_player_image, "robot_base_horizontal.png");
GameState->LoadGameSpriteFromImage(canvas, GameState->GameSprites.tmp_player_image_v, "robot_base_vertical.png");
GameState->LoadGameSpriteFromImage(canvas, GameState->GameSprites.tmp_player_image_ur, "robot_base_diagonal_ur.png");
GameState->LoadGameSpriteFromImage(canvas, GameState->GameSprites.tmp_player_image_ul, "robot_base_diagonal_ul.png");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_ground_sprite_01, "ground_concrete_tileset");
GameState->AddGameSpriteFrameFromImage(canvas, GameState->GameSprites.tmp_ground_sprite_01, "ground_tile_01.png");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_torso, "robot_torso");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_track_down, "track_v_down");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_track_left, "track_h_left");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_track_right, "track_h_right");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_track_up, "track_v_up");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_track_ur, "track_d_ur");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_track_ul, "track_d_ul");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_track_br, "track_d_br");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_player_image_track_bl, "track_d_bl");
GameState->LoadGameSpriteFromResource(canvas, &GameState->game_resources, GameState->GameSprites.tmp_wall_sprite1, "tileset_brick_wall");
// Player entity
//
GameState->PlayerEntity = AddEntity(GameState);
GameState->PlayerEntity->Position.Tile = Vec2i(0, 0);
GameState->PlayerEntity->Position.TilePos = Vec2f(0, 0);
GameState->PlayerEntity->EntityType = EntityType_Robot;
GameState->PlayerEntity->CollisionType = 1;
GameState->PlayerEntity->CollisionBox = Rectf(-0.45f, -0.25f, 0.45f, 0.25f);
GameState->PlayerEntity->Controller.Active = 1;
GameState->PlayerEntity->Mass = 20000.0f;
GameState->PlayerEntity->RResistance = 0.008f;
SetEntityToActive(GameState->PlayerEntity, GameState);
World->TileSizeMeters = Vec2f(1.0f, 1.0f);
World->TileSizePixels = Vec2f(100.0f, 100.0f);
World->MetersToPixels = World->TileSizePixels / World->TileSizeMeters;
World->g = 4.2f;
TileMap->TileChunkSize = Vec2ui(16, 16);
//TileMap->CenterChunkPosition = TileMap->TileChunksCount / (uint32)2;
GameState->TilesOnHalfScreen.width = (int)((GameState->ScreenSize.width / 2) / World->TileSizePixels.x) + 1;
GameState->TilesOnHalfScreen.height = (int)((GameState->ScreenSize.height / 2) / World->TileSizePixels.y) + 1;
Vec2i TilesPerScreen = GameState->TilesOnHalfScreen * 2;
for (int32 ScreenY = -16; ScreenY < 16; ScreenY++)
{
for (int32 ScreenX = -16; ScreenX < 16; ScreenX++)
{
for (int32 TY = 0; TY < TilesPerScreen.y; TY++)
{
for (int32 TX = 0; TX < TilesPerScreen.x; TX++)
{
int32 AbsTileX = ScreenX * TilesPerScreen.x + TX;
int32 AbsTileY = ScreenY * TilesPerScreen.y + TY;
SetTileValue(&GameState->WorldArena, TileMap, Vec2i(AbsTileX, AbsTileY), rand() % 16 + 1);
}
}
}
}
/*
for (int32 Y = 1; Y < 4; Y++)
{
for (int32 X = 1; X < 5; X++)
{
SetTileValue(&GameState->WorldArena, TileMap, Vec2i(X, Y), 5);
SetTileValue(&GameState->WorldArena, TileMap, Vec2i(X - 7, Y), 5);
SetTileValue(&GameState->WorldArena, TileMap, Vec2i(X - 5, Y + 6), 4);
}
}
*/
// Game entities
GameState->TiledEntities.Entities = PushArray(&GameState->WorldArena, 4096, entity);
GameState->TiledEntities.GroupSize = 4096;
GameState->TiledEntities.EntityCount = 0;
GameState->TiledEntities.NextGroup = 0;
AddEntityToGroup(&GameState->WorldArena, &GameState->TiledEntities); // �N���|�u�r���z ���q���u�{�� �~�u �y�������|���x���u������
// Add many stone entities
world_position EntityPos;
//Rectf CollisionBox(-0.4f, 0.0f, 0.4f, 0.3f);
Rectf CollisionBox(-0.5f, -0.5f, 0.5f, 0.5f);
for (int32 Y = 1; Y < 10; Y++)
{
for (int32 X = 1; X < 10; X++)
{
EntityPos.Tile = Vec2i(X, Y);
EntityPos.TilePos = Vec2f(0, 0);
uint32 StoneIndex = AddEntityToGroup(&GameState->WorldArena, &GameState->TiledEntities);
entity *Entity = GetEntityFromGroupByIndex(&GameState->TiledEntities, StoneIndex);
Entity->EntityType = EntityType_Storage;
Entity->Position = EntityPos;
Entity->CollisionType = 1;
Entity->CollisionBox = CollisionBox;
AddEntityToTile(GameState->World->TileMap, EntityPos.Tile, StoneIndex);
}
}
/*
EntityPos.Tile = Vec2i(1, 1);
EntityPos.TilePos = Vec2f(0, 0);
entity *Entity = AddEntity(GameState);
Entity->EntityType = EntityType_Stone;
Entity->Position = EntityPos;
Entity->CollisionType = 1;
Entity->CollisionBox = CollisionBox;
//SetEntityToActive(Entity, GameState);
/*
Entity = AddEntity(GameState);
Entity->EntityType = EntityType_Wall;
EntityPos.Tile = Vec2i(0, -2);
Entity->Position = EntityPos;
Entity->CollisionType = 1;
Entity->CollisionBox = Rectf(-0.5f, -0.1f, 0.5f, 0.1f);
Entity->EntityFrame = 0;
//SetEntityToActive(Entity, GameState);
*/
// Call to camera reset to activate entities in camera space
MapEntitiesInCameraSpace(GameState);
GameState->IsInitialized = 1;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec2ui OverlayColorLegend::minimumSize()
{
return Vec2ui(100,100);
}
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;
}
