bool fillRegularVolumeInfo( VolumeInformation& info ) { const Vector3ui& blockSize = info.maximumBlockSize - info.overlap * 2; if( !checkCompatibility( info.voxels, blockSize )) return false; const float maxDim = float( info.voxels.find_max( )); info.maximumBlockSize = blockSize + info.overlap * 2; info.dataType = DT_UINT8; info.compCount = 1; info.isBigEndian = false; info.worldSpacePerVoxel = 1.0f / maxDim; info.worldSize = Vector3f( info.voxels[0], info.voxels[1], info.voxels[2] ) / maxDim; // Find the depth of hierarchy const Vector3ui numBlocks = info.voxels / blockSize; Vector3ui blocksSize = numBlocks; const uint32_t xDepth = std::log2( blocksSize[0] ); const uint32_t yDepth = std::log2( blocksSize[1] ); const uint32_t zDepth = std::log2( blocksSize[2] ); const uint32_t depth = std::min( xDepth, std::min( yDepth, zDepth )); blocksSize = blocksSize / ( 1u << depth ); info.rootNode = RootNode( depth + 1, blocksSize ); return true; }
RemoteInformation deserializeDataSourceData( const ::zeq::Event& event ) { if( event.getType() != EVENT_DATASOURCE_DATA ) return RemoteInformation(); auto data = GetVolumeInformation( event.getData( )); RemoteInformation info; livre::VolumeInformation& vi = info.second; info.first.low() = data->eventLow(); info.first.high() = data->eventHigh(); vi.isBigEndian = data->isBigEndian(); vi.compCount = data->compCount(); vi.dataType = DataType( data->dataType( )); vi.overlap = _deserializeVector3< unsigned >( data->overlap( )); vi.maximumBlockSize = _deserializeVector3< unsigned >( data->maximumBlockSize( )); vi.minPos = _deserializeVector3< float >( data->minPos( )); vi.maxPos = _deserializeVector3< float >( data->maxPos( )); vi.voxels = _deserializeVector3< unsigned >( data->voxels( )); vi.worldSize = _deserializeVector3< float >( data->worldSize( )); vi.boundingBox.getMin() = _deserializeVector3< float >( data->boundingBoxMin( )); vi.boundingBox.getMax() = _deserializeVector3< float >( data->boundingBoxMax( )); vi.worldSpacePerVoxel = data->worldSpacePerVoxel(); const Vector3ui& blockSize = vi.maximumBlockSize - vi.overlap * 2; Vector3ui blocksSize = vi.voxels / blockSize; blocksSize = blocksSize / ( 1u << data->depth( )); vi.rootNode = RootNode( data->depth(), blocksSize ); return info; }
void CachedExtentTree::DumpInOrder() const { TRACE("\n"); _DumpInOrder(RootNode()); TRACE("\n"); }
bool fillRegularVolumeInfo( VolumeInformation& info ) { info.worldSpacePerVoxel = 1.0f / float( info.voxels.find_max( )); info.worldSize = Vector3f( info.voxels[0], info.voxels[1], info.voxels[2] ) * info.worldSpacePerVoxel; // Create the rootNode of the LOD hierarchy const Vector3ui blockSize = info.maximumBlockSize - info.overlap * 2; const Vector3ui numBlocks( std::ceil( float( info.voxels.x( )) / blockSize.x( )), std::ceil( float( info.voxels.y( )) / blockSize.y( )), std::ceil( float( info.voxels.z( )) / blockSize.z( )) ); const Vector3ui lodLevels( std::ceil( std::log2( numBlocks.x( ))), std::ceil( std::log2( numBlocks.y( ))), std::ceil( std::log2( numBlocks.z( ))) ); const uint32_t depth = lodLevels.find_min(); const Vector3ui rootNodeBlocksCount( std::ceil( float( info.voxels.x() >> depth ) / blockSize.x( )), std::ceil( float( info.voxels.y() >> depth ) / blockSize.y( )), std::ceil( float( info.voxels.z() >> depth ) / blockSize.z( )) ); info.rootNode = RootNode( depth + 1, rootNodeBlocksCount ); return true; }
status_t Volume::Unmount() { TRACE("Volume::Unmount()\n"); TRACE("Volume::Unmount(): Putting root node\n"); put_vnode(fFSVolume, RootNode()->ID()); TRACE("Volume::Unmount(): Deleting the block cache\n"); block_cache_delete(fBlockCache, !IsReadOnly()); TRACE("Volume::Unmount(): Closing device\n"); close(fDevice); TRACE("Volume::Unmount(): Done\n"); return B_OK; }
// // Scene::Scene - Chapter 16, page 539 // // Note: The shared_ptr<IRenderer> was added to allow for both D3D9 and D3D11 renderer implementations. // The book only describes D3D11, so to find all the differences, just search for m_Renderer! // SceneManager::SceneManager(std::shared_ptr<IRenderer> renderer) { m_Root.reset(TYW_NEW RootNode()); m_Renderer = renderer; m_LightManager = TYW_NEW LightManager; //D3DXCreateMatrixStack(0, &m_MatrixStack); // [mrmike] - event delegates were added post-press // IEventManager* pEventMgr = IEventManager::Get(); // pEventMgr->VAddListener(MakeDelegate(this, &Scene::NewRenderComponentDelegate), EvtData_New_Render_Component::sk_EventType); // pEventMgr->VAddListener(MakeDelegate(this, &Scene::DestroyActorDelegate), EvtData_Destroy_Actor::sk_EventType); // pEventMgr->VAddListener(MakeDelegate(this, &Scene::MoveActorDelegate), EvtData_Move_Actor::sk_EventType); // pEventMgr->VAddListener(MakeDelegate(this, &Scene::ModifiedRenderComponentDelegate), EvtData_Modified_Render_Component::sk_EventType); }
status_t Volume::Unmount() { TRACE("Volume::Unmount()\n"); status_t status = fJournal->Uninit(); delete fJournal; delete fJournalInode; TRACE("Volume::Unmount(): Putting root node\n"); put_vnode(fFSVolume, RootNode()->ID()); TRACE("Volume::Unmount(): Deleting the block cache\n"); block_cache_delete(fBlockCache, !IsReadOnly()); TRACE("Volume::Unmount(): Closing device\n"); close(fDevice); TRACE("Volume::Unmount(): Done\n"); return status; }
void CachedExtentTree::Delete() { _Delete(RootNode()); Clear(); }
//--------// main() function //---------------------------------------------// int main(int argc, char* argv[]){ /* general variables */ int retrieve_buffer = 0; unsigned char data; /* retrieve data from stdin */ int byte_counter = 0; /* counts bytes received from stdin */ unsigned int index_counter = 0; /* counts factors created */ node_t trie = RootNode(); node_t *parent_node = ≜ node_t *temp_node = ≜ dict_t dict = EmptyDict(); dict_t *dict_ptr = &dict; unsigned char* output; size_t t_memblock = 0; /* last-factor variables */ unsigned char data_buffer; /* retains data when EOF is reached */ int is_added = FALSE; /* indicates if data_buffer is added */ while((retrieve_buffer = fgetc(stdin)) != EOF){ //fprintf(stderr, "%02x ", retrieve_buffer); data = (unsigned char) retrieve_buffer; byte_counter++; /* update current parent_node */ parent_node = temp_node; /* if data is a member of current parent_node: * set the node that representing data as next parent_node */ if((temp_node = SearchNode(parent_node, data)) != NULL){ /* set data to data_buffer */ is_added = FALSE; data_buffer = data; continue; } /* if data is not a member of current parent_node: * create a child node to represent data, * and create the associated dictionary element */ index_counter++; temp_node = AddNode(parent_node, data, index_counter); dict_ptr = AddDict(dict_ptr, temp_node, parent_node->index); is_added = TRUE; /* reset parent_node */ temp_node = ≜ } /* create factor for data_buffer if required */ if(is_added == FALSE){ /* temp_node is NULL if data_buffer is not member of parent_node, * indicating parent_node needs to be reset */ if(temp_node == NULL){ parent_node = ≜ } index_counter++; temp_node = AddNode(parent_node, data_buffer, index_counter); dict_ptr = AddDict(dict_ptr, temp_node, parent_node->index); } /* skip the first element of the dictionary */ output = PrintDict(dict.next, index_counter); t_memblock = (index_counter * 4) + WIDTH_HEADER + 1; fwrite(output, sizeof(char), t_memblock, stdout); #if DEBUG { char temp_char; int k = 0; while(k < t_memblock){ temp_char = output[k]; fprintf(stderr, "output = %02x\n", temp_char); k++; } } #endif #if SUMMARY { /* SUMMARY INFO */ fprintf(stderr, "encode: %6d bytes input\n", byte_counter); fprintf(stderr, "encode: %6d factors generated\n", index_counter); fprintf(stderr, "encode: %6zu bytes output\n", t_memblock); } #endif free(output); output = NULL; return 0; }