// load data using the currently set VOI tf::uint8* CVolume::loadData() throw (tf::RuntimeException) { try { // get volume at the currently selected resolution VirtualVolume* volume = CImport::instance()->getVolume(voiResIndex); // set volume active time frames volume->setActiveFrames(voiT0, voiT1); /**/tf::debug(tf::LEV3, "load data", __itm__current__function__); QElapsedTimer timer; timer.start(); uint8* imgData = volume->loadSubvolume_to_UINT8(voiV0, voiV1, voiH0, voiH1, voiD0, voiD1); PLog::instance()->appendOperation(new NewViewerOperation(strprintf("Block X=[%d, %d) Y=[%d, %d) Z=[%d, %d), T=[%d, %d] loaded from res %d", voiH0, voiH1, voiV0, voiV1, voiD0, voiD1, voiT0, voiT1, voiResIndex), tf::IO, timer.elapsed())); return imgData; } catch( iim::IOException& exception) { throw tf::RuntimeException(exception.what()); } catch( iom::exception& exception) { throw RuntimeException(exception.what()); } catch(const char* error) { throw RuntimeException(error); } catch(...) { throw RuntimeException("Unknown error occurred"); } }
unsigned char *loadSubvolume ( void *obj, int V0, int V1, int H0, int H1, int D0, int D1 ) { VirtualVolume *volume = (VirtualVolume *) obj; int channels; // dummy argument try { return volume->loadSubvolume_to_UINT8(V0,V1,H0,H1,D0,D1,&channels,0); // always require native type } catch( iim::IOException& exception){ return (unsigned char *) 0; } catch(char* error){ return (unsigned char *) 0; } }
void getInfo ( void *obj, info_t *info_ ) { VirtualVolume *volume = (VirtualVolume *) obj; std::string fmt = volume->getPrintableFormat(); info_->root_dir = volume->getROOT_DIR(); info_->VXL_V = volume->getVXL_V(); info_->VXL_H = volume->getVXL_H(); info_->VXL_D = volume->getVXL_D(); info_->ORG_V = volume->getORG_V(); info_->ORG_H = volume->getORG_H(); info_->ORG_D = volume->getORG_D(); info_->DIM_V = volume->getDIM_V(); info_->DIM_H = volume->getDIM_H(); info_->DIM_D = volume->getDIM_D(); info_->DIM_C = volume->getDIM_C(); info_->BYTESxCHAN = volume->getBYTESxCHAN(); info_->n_active = volume->getNACtiveChannels(); info_->active = volume->getActiveChannels(); info_->DIM_T = volume->getDIM_T(); info_->t0 = volume->getT0(); info_->t1 = volume->getT1(); }
//automatically called when current thread is started void CImport::run() { /**/itm::debug(itm::LEV1, 0, __itm__current__function__); try { timerIO.start(); /********************* 1) IMPORTING CURRENT VOLUME *********************** PRECONDITIONS: reimport = true ==> the volume cannot be directly imported (i.e., w/o the additional info provided by the user) or the user explicitly asked for re- importing the volume. reimport = false ==> the volume is directly importable *************************************************************************/ /**/itm::debug(itm::LEV_MAX, strprintf("importing current volume at \"%s\"", path.c_str()).c_str(), __itm__current__function__); // skip nonmatching entries QDir dir(path.c_str()); if( dir.dirName().toStdString().substr(0,3).compare(itm::RESOLUTION_PREFIX) != 0) throw RuntimeException(strprintf("\"%s\" is not a valid resolution: the name of the folder does not start with \"%s\"", path.c_str(), itm::RESOLUTION_PREFIX.c_str() ).c_str()); if(reimport) volumes.push_back(VirtualVolume::instance(path.c_str(), format, AXS_1, AXS_2, AXS_3, VXL_1, VXL_2, VXL_3)); else volumes.push_back(VirtualVolume::instance(path.c_str())); /********************* 2) IMPORTING OTHER VOLUMES *********************** Importing all the available resolutions within the current volume's parent directory. *************************************************************************/ /**/itm::debug(itm::LEV_MAX, "Importing other volumes of the multiresolution octree", __itm__current__function__); /* -------------------- detect candidate volumes -----------------------*/ /**/itm::debug(itm::LEV_MAX, "Detecting volumes that CAN be loaded (let us call them CANDIDATE volumes: the correspondent structures will be destroyed after this step)", __itm__current__function__); vector<VirtualVolume*> candidateVols; QDir curParentDir(path.c_str()); curParentDir.cdUp(); QStringList otherDirs = curParentDir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot); for(int k=0; k<otherDirs.size(); k++) { string path_i = curParentDir.absolutePath().append("/").append(otherDirs.at(k).toLocal8Bit().constData()).toStdString(); QDir dir_i(path_i.c_str()); // skip volumes[0] if(dir.dirName() == dir_i.dirName()) continue; // skip nonmatching entries if(dir_i.dirName().toStdString().substr(0,3).compare(itm::RESOLUTION_PREFIX) != 0) continue; /**/itm::debug(itm::LEV_MAX, strprintf("Checking for loadable volume at \"%s\"", path_i.c_str()).c_str(), __itm__current__function__); if( !reimport && VirtualVolume::isDirectlyImportable( path_i.c_str()) ) candidateVols.push_back(VirtualVolume::instance(path_i.c_str())); else volumes.push_back(VirtualVolume::instance(path_i.c_str(), volumes[0]->getPrintableFormat(), volumes[0]->getAXS_1(), volumes[0]->getAXS_2(), volumes[0]->getAXS_3(), volumes[0]->getVXL_1(), volumes[0]->getVXL_2(), volumes[0]->getVXL_3())); } /* -------------------- import candidate volumes ------------------------*/ /**/itm::debug(itm::LEV_MAX, "Importing loadable volumes (previously checked)", __itm__current__function__); for(int k=0; k<candidateVols.size(); k++) { int ratio = iim::round( pow((volumes[0]->getMVoxels() / candidateVols[k]->getMVoxels()),(1/3.0f)) ); /**/itm::debug(itm::LEV_MAX, strprintf("Importing loadable volume at \"%s\"", candidateVols[k]->getROOT_DIR()).c_str(), __itm__current__function__); if( !reimport && VirtualVolume::isDirectlyImportable( candidateVols[k]->getROOT_DIR()) ) volumes.push_back(VirtualVolume::instance(candidateVols[k]->getROOT_DIR())); else volumes.push_back(VirtualVolume::instance(candidateVols[k]->getROOT_DIR(), candidateVols[k]->getPrintableFormat(), volumes[0]->getAXS_1(), volumes[0]->getAXS_2(), volumes[0]->getAXS_3(), volumes[0]->getVXL_1()*ratio, volumes[0]->getVXL_2()*ratio, volumes[0]->getVXL_3()*ratio)); } /* -------------------- destroy candidate volumes -----------------------*/ /**/itm::debug(itm::LEV_MAX, "Destroying candidate volumes", __itm__current__function__); for(int k=0; k<candidateVols.size(); k++) delete candidateVols[k]; /* ------------- sort imported volumes by ascending size ---------------*/ /**/itm::debug(itm::LEV_MAX, "Sorting volumes by ascending size", __itm__current__function__); std::sort(volumes.begin(), volumes.end(), sortVolumesAscendingSize); /* ---------------------- check imported volumes -----------------------*/ if(volumes.size() < 2) throw RuntimeException(strprintf("%d resolution found at %s: at least two resolutions are needed for the multiresolution mode", volumes.size(), qPrintable(curParentDir.path()) ).c_str()); for(int k=0; k<volumes.size()-1; k++) { if(volumes[k]->getPrintableFormat().compare( volumes[k+1]->getPrintableFormat() ) != 0) throw RuntimeException(strprintf("Volumes have different formats at \"%s\"", qPrintable(curParentDir.absolutePath())).c_str()); if(volumes[k]->getDIM_T() != volumes[k+1]->getDIM_T()) throw RuntimeException(strprintf("Volumes have different time frames at \"%s\"", qPrintable(curParentDir.absolutePath())).c_str()); } /**************** 3) GENERATING / LOADING VOLUME 3D MAP ***************** We generate once for all a volume map from lowest-resolution volume. *************************************************************************/ string volMapPath = curParentDir.path().toStdString() + "/" + VMAP_BIN_FILE_NAME; if(hasVolumeMapToBeRegenerated(volMapPath.c_str(), "0.9.42", vmapTDimMax, volumes[0]->getDIM_T()) || reimport || regenerateVMap) { /**/itm::debug(itm::LEV_MAX, "Entering volume's map generation section", __itm__current__function__); // check that the lowest resolution does not exceed the maximum allowed size for the volume map VirtualVolume* lowestResVol = volumes[0]; if(lowestResVol->getDIM_H() > vmapXDimMax || lowestResVol->getDIM_V() > vmapYDimMax || lowestResVol->getDIM_D() > vmapZDimMax) itm::warning("@TODO: resample along XYZ so as to match the volume map maximum size", __itm__current__function__); vmapXDim = lowestResVol->getDIM_H(); vmapYDim = lowestResVol->getDIM_V(); vmapZDim = lowestResVol->getDIM_D(); vmapCDim = lowestResVol->getDIM_C(); // if the number of time frames exceeds the maximum, we put only the first vmapTDimMax in the volume map vmapTDim = std::min(vmapTDimMax, lowestResVol->getDIM_T()); // generate volume map lowestResVol->setActiveFrames(0, vmapTDimMax -1); vmapData = lowestResVol->loadSubvolume_to_UINT8(); FILE *volMapBin = fopen(volMapPath.c_str(), "wb"); if(!volMapBin) throw RuntimeException(strprintf("Cannot write volume map at \"%s\". Please check your write permissions.", volMapPath.c_str()).c_str()); uint16 verstr_size = static_cast<uint16>(strlen(itm::version.c_str()) + 1); fwrite(&verstr_size, sizeof(uint16), 1, volMapBin); fwrite(itm::version.c_str(), verstr_size, 1, volMapBin); fwrite(&vmapTDim, sizeof(uint32), 1, volMapBin); fwrite(&vmapCDim, sizeof(uint32), 1, volMapBin); fwrite(&vmapYDim, sizeof(uint32), 1, volMapBin); fwrite(&vmapXDim, sizeof(uint32), 1, volMapBin); fwrite(&vmapZDim, sizeof(uint32), 1, volMapBin); size_t vmapSize = ((size_t)vmapYDim)*vmapXDim*vmapZDim*vmapCDim*vmapTDim; fwrite(vmapData, vmapSize, 1, volMapBin); fclose(volMapBin); } else { /**/itm::debug(itm::LEV_MAX, "Entering volume's map loading section", __itm__current__function__); // load volume map FILE *volMapBin = fopen(volMapPath.c_str(), "rb"); uint16 verstr_size; if(!volMapBin) throw RuntimeException(strprintf("Cannot read volume map at \"%s\". Please check your read permissions.", volMapPath.c_str()).c_str()); if(!fread(&verstr_size, sizeof(uint16), 1, volMapBin)) throw RuntimeException("Unable to read volume map file (<version_size> field). Please delete the volume map and re-open the volume."); char ver[1024]; if(!fread(ver, verstr_size, 1, volMapBin)) throw RuntimeException("Unable to read volume map file (<version> field). Please delete the volume map and re-open the volume."); if(fread(&vmapTDim, sizeof(uint32), 1, volMapBin) != 1) throw RuntimeException("Unable to read volume map file (<vmapTDim> field). Please delete the volume map and re-open the volume."); if(fread(&vmapCDim, sizeof(uint32), 1, volMapBin) != 1) throw RuntimeException("Unable to read volume map file (<vmapCDim> field). Please delete the volume map and re-open the volume."); if(fread(&vmapYDim, sizeof(uint32), 1, volMapBin) != 1) throw RuntimeException("Unable to read volume map file (<vmapYDim> field). Please delete the volume map and re-open the volume."); if(fread(&vmapXDim, sizeof(uint32), 1, volMapBin)!= 1) throw RuntimeException("Unable to read volume map file (<vmapXDim> field). Please delete the volume map and re-open the volume."); if(fread(&vmapZDim, sizeof(uint32), 1, volMapBin)!= 1) throw RuntimeException("Unable to read volume map file (<vmapZDim> field). Please delete the volume map and re-open the volume."); size_t vmapSize = ((size_t)vmapYDim)*vmapXDim*vmapZDim*vmapCDim*vmapTDim; vmapData = new uint8[vmapSize]; if(fread(vmapData, vmapSize, 1, volMapBin) != 1) throw RuntimeException("Unable to read volume map file (<vmapData> field). Please delete the volume map and re-open the volume."); fclose(volMapBin); //--- Alessandro 29/09/2013: checking that the loaded vmap corresponds to one of the loaded volumes // /**/itm::debug(itm::LEV_MAX, "checking that the loaded vmap corresponds to one of the loaded volumes", __itm__current__function__); // bool check_passed = false; // for(int i=0; i<volumes.size() && !check_passed; i++) // if(volumes[i]->getDIM_V() == vmapYDim && // volumes[i]->getDIM_H() == vmapXDim && // volumes[i]->getDIM_D() == vmapZDim && // volumes[i]->getDIM_C() == vmapCDim) // check_passed = true; // if(!check_passed) // throw RuntimeException(QString("Volume map stored at \"").append(volMapPath.c_str()).append("\" does not correspond to any of the loaded resolutions. Please delete or regenerate the volume map.").toStdString().c_str()); } //everything went OK emit sendOperationOutcome(0, timerIO.elapsed()); /**/itm::debug(itm::LEV1, "EOF", __itm__current__function__); } catch( iim::IOException& exception) {reset(); emit sendOperationOutcome(new RuntimeException(exception.what()));} catch( iom::exception& exception) {reset(); emit sendOperationOutcome(new RuntimeException(exception.what()));} catch( RuntimeException& exception) {reset(); emit sendOperationOutcome(new RuntimeException(exception.what()));} catch(const char* error) {reset(); emit sendOperationOutcome(new RuntimeException(error));} catch(...) {reset(); emit sendOperationOutcome(new RuntimeException("Unknown error occurred"));} }
//automatically called when current thread is started void CVolume::run() { /**/tf::debug(tf::LEV1, 0, __itm__current__function__); try { VirtualVolume* volume = CImport::instance()->getVolume(voiResIndex); //---- Alessandro 2013-04-17: if VOI exceeds limits it is automatically adjusted. This is very useful in the cases the user is zooming-in //around peripheral regions voiV0 = voiV0 >=0 ? voiV0 : 0; voiV1 = voiV1 <= volume->getDIM_V() ? voiV1 : volume->getDIM_V(); voiH0 = voiH0 >=0 ? voiH0 : 0; voiH1 = voiH1 <= volume->getDIM_H() ? voiH1 : volume->getDIM_H(); voiD0 = voiD0 >=0 ? voiD0 : 0; voiD1 = voiD1 <= volume->getDIM_D() ? voiD1 : volume->getDIM_D(); // voiT0 = voiT0 >=0 ? voiT0 : 0; // voiT1 = voiT1 < volume->getDIM_T() ? voiT1 : volume->getDIM_T()-1; // check subvolume interval if(voiV1 - voiV0 <=0 || voiH1 - voiH0 <=0 || voiD1 - voiD0 <=0 || voiT1 - voiT0 <0) throw RuntimeException(strprintf("Invalid subvolume intervals inserted: X=[%d, %d), Y=[%d, %d), Z=[%d, %d), T=[%d, %d]", voiH0, voiH1, voiV0, voiV1, voiD0, voiD1, voiT0, voiT1)); // check destination /**/tf::debug(tf::LEV2, "Check destination", __itm__current__function__); CViewer* destination = dynamic_cast<CViewer*>(source); if(!destination) throw RuntimeException("Destination type not supported"); /**/tf::debug(tf::LEV2, strprintf("destination registered as \"%s\"", destination->title.c_str()).c_str(), __itm__current__function__); //checking for an imported volume if(volume) { if(streamingSteps == 1) { // 5D data with instant visualization of selected frame if(voiT0 != voiT1 && cur_t != -1) { // load selected frame QElapsedTimer timerIO; timerIO.start(); volume->setActiveFrames(cur_t, cur_t); /**/tf::debug(tf::LEV3, "load selected time frame", __itm__current__function__); uint8* voiData = volume->loadSubvolume_to_UINT8(voiV0, voiV1, voiH0, voiH1, voiD0, voiD1); qint64 elapsedTime = timerIO.elapsed(); // wait for GUI thread to update graphics /**/tf::debug(tf::LEV3, "Waiting for updateGraphicsInProgress mutex", __itm__current__function__); /**/ updateGraphicsInProgress.lock(); /**/tf::debug(tf::LEV3, "Access granted from updateGraphicsInProgress mutex", __itm__current__function__); // send data integer_array data_s = make_vector<int>() << voiH0 << voiV0 << voiD0 << 0 << cur_t; integer_array data_c = make_vector<int>() << voiH1-voiH0 << voiV1-voiV0 << voiD1-voiD0 << volume->getNACtiveChannels() << 1; emit sendData(voiData, data_s, data_c, source, false, 0, elapsedTime, strprintf("Block X=[%d, %d) Y=[%d, %d) Z=[%d, %d), T=[%d, %d] loaded from res %d", voiH0, voiH1, voiV0, voiV1, voiD0, voiD1, cur_t, cur_t, voiResIndex).c_str()); // unlock updateGraphicsInProgress mutex /**/tf::debug(tf::LEV3, strprintf("updateGraphicsInProgress.unlock()").c_str(), __itm__current__function__); /**/ updateGraphicsInProgress.unlock(); } { // load data QElapsedTimer timerIO; timerIO.start(); volume->setActiveFrames(voiT0, voiT1); /**/tf::debug(tf::LEV3, "load data", __itm__current__function__); uint8* voiData = volume->loadSubvolume_to_UINT8(voiV0, voiV1, voiH0, voiH1, voiD0, voiD1); qint64 elapsedTime = timerIO.elapsed(); // wait for GUI thread to update graphics /**/tf::debug(tf::LEV3, "Waiting for updateGraphicsInProgress mutex", __itm__current__function__); /**/ updateGraphicsInProgress.lock(); /**/tf::debug(tf::LEV3, "Access granted from updateGraphicsInProgress mutex", __itm__current__function__); // send data integer_array data_s = make_vector<int>() << voiH0 << voiV0 << voiD0 << 0 << voiT0; integer_array data_c = make_vector<int>() << voiH1-voiH0 << voiV1-voiV0 << voiD1-voiD0 << volume->getNACtiveChannels() << voiT1-voiT0+1; emit sendData(voiData, data_s, data_c, source, true, 0, elapsedTime, strprintf("Block X=[%d, %d) Y=[%d, %d) Z=[%d, %d), T=[%d, %d] loaded from res %d", voiH0, voiH1, voiV0, voiV1, voiD0, voiD1, voiT0, voiT1, voiResIndex).c_str()); /**/tf::debug(tf::LEV3, "sendData signal emitted", __itm__current__function__); // unlock updateGraphicsInProgress mutex /**/tf::debug(tf::LEV3, strprintf("updateGraphicsInProgress.unlock()").c_str(), __itm__current__function__); /**/ updateGraphicsInProgress.unlock(); } } else { throw RuntimeException("Streaming != 1 has been temporarily disabled. Please contact the developer."); // // precondition checks // if(!buffer) // throw RuntimeException("Buffer not initialized"); // CViewer* destination = dynamic_cast<CViewer*>(source); // if(!destination) // throw RuntimeException("Streaming not yet supported for this type of destination"); // if(streamingSteps != 2) // throw RuntimeException("Only streaming steps = 2 supported for 5D data"); // for (int step = 1; step <= streamingSteps; step++) // { // // load current selected frame // /**/tf::debug(tf::LEV3, strprintf("Time step %d/2: loading data", step).c_str(), __itm__current__function__); // volume->setActiveFrames(step == 1 ? cur_t : voiT0, step == 1 ? cur_t : voiT1); // QElapsedTimer timerIO; // timerIO.start(); // uint8* data = volume->loadSubvolume_to_UINT8(voiV0, voiV1, voiH0, voiH1, voiD0, voiD1); // qint64 elapsedTime = timerIO.elapsed(); // // copy frame to buffer ( ** CRITICAL SECTION ** ) // /**/tf::debug(tf::LEV3, strprintf("Time step %d/2: waiting for buffer mutex", step).c_str(), __itm__current__function__); // /**/ bufferMutex.lock(); // /**/tf::debug(tf::LEV3, strprintf("Time step %d/2: access granted on buffer mutex", step).c_str(), __itm__current__function__); // uint32 buf_dims[5] = {voiH1-voiH0, voiV1-voiV0, voiD1-voiD0, volume->getDIM_C(), voiT1 - voiT0 +1}; // uint32 buf_offset[5] = {0, 0, 0, 0, cur_t-voiT0}; // uint32 cur_t_dims[5] = {voiH1-voiH0, voiV1-voiV0, voiD1-voiD0, volume->getDIM_C(), 1}; // uint32 cur_t_offset[5] = {0, 0, 0, 0, 0}; // uint32 cur_t_count[5] = {voiH1-voiH0, voiV1-voiV0, voiD1-voiD0, volume->getDIM_C(), 1}; // CViewer::copyVOI(cur_t_data, cur_t_dims, cur_t_offset, cur_t_count, buffer, buf_dims, buf_offset); // delete[] cur_t_data; // /**/ bufferMutex.unlock(); // /**/tf::debug(tf::LEV3, strprintf("Time step %d/2: unlocked buffer mutex", step).c_str(), __itm__current__function__); // // wait GUI thread to complete update graphics // /**/tf::debug(tf::LEV3, strprintf("Time step %d/2: waiting for updateGraphicsInProgress mutex", step).c_str(), __itm__current__function__); // /**/ destination->updateGraphicsInProgress.lock(); // /**/ destination->updateGraphicsInProgress.unlock(); // /**/tf::debug(tf::LEV3, strprintf("Time step %d/2: unlocked updateGraphicsInProgress mutex", step).c_str(), __itm__current__function__); // // send data to GUI thread // finished = false; // /**/tf::debug(tf::LEV3, strprintf("Time step %d/2: sendOperationOutcome", step).c_str(), __itm__current__function__); // sprintf(msg, "Streaming %d/%d: Block X=[%d, %d) Y=[%d, %d) Z=[%d, %d) loaded from res %d", // 1, 2, voiH0, voiH1, voiV0, voiV1, voiD0, voiD1, voiResIndex); // emit sendOperationOutcome(buffer, 0, destination, elapsedTime, msg, 1); // } // // load current selected frame // /**/tf::debug(tf::LEV3, "Time step 1/2: loading data", __itm__current__function__); // volume->setActiveFrames(cur_t, cur_t); // QElapsedTimer timerIO; // timerIO.start(); // uint8* cur_t_data = volume->loadSubvolume_to_UINT8(voiV0, voiV1, voiH0, voiH1, voiD0, voiD1); // qint64 elapsedTime = timerIO.elapsed(); // /**/tf::debug(tf::LEV3, "Time step 2/2: waiting for buffer mutex", __itm__current__function__); // /**/ bufferMutex.lock(); // /**/tf::debug(tf::LEV3, "Time step 2/2: access granted on buffer mutex", __itm__current__function__); // timerIO.start(); // volume->setActiveFrames(voiT0 + (voiT1-voiT0)/2, voiT1); // /**/tf::debug(tf::LEV3, "Time step 2/2: loading data", __itm__current__function__); // buffer = volume->loadSubvolume_to_UINT8(voiV0, voiV1, voiH0, voiH1, voiD0, voiD1); // elapsedTime = timerIO.elapsed(); // /**/ bufferMutex.unlock(); // /**/tf::debug(tf::LEV3, "Time step 2/2: unlocked buffer mutex", __itm__current__function__); // sprintf(msg, "Streaming %d/%d: Block X=[%d, %d) Y=[%d, %d) Z=[%d, %d) loaded from res %d", // 2, 2, voiH0, voiH1, voiV0, voiV1, voiD0, voiD1, voiResIndex); // /**/tf::debug(tf::LEV3, "Time step 1/2: waiting for updateGraphicsInProgress mutex", __itm__current__function__); // /**/ destination->updateGraphicsInProgress.lock(); // /**/ destination->updateGraphicsInProgress.unlock(); // /**/tf::debug(tf::LEV3, "Time step 1/2: unlocked updateGraphicsInProgress mutex", __itm__current__function__); // finished = true; // /**/tf::debug(tf::LEV3, "Time step 1/2: sendOperationOutcome", __itm__current__function__); // emit sendOperationOutcome(buffer, 0, destination, elapsedTime, msg, 2); // //checking preconditions // TiledVolume* vaa3D_volume_RGB = dynamic_cast<TiledVolume*>(volume); // TiledMCVolume* vaa3D_volume_4D= dynamic_cast<TiledMCVolume*>(volume); // if(!vaa3D_volume_RGB && !vaa3D_volume_4D) // throw RuntimeException("Streaming not yet supported for the current format. Please restart the plugin."); // if(!buffer) // throw RuntimeException("Buffer not initialized"); // CViewer* destination = dynamic_cast<CViewer*>(source); // if(!destination) // throw RuntimeException("Streaming not yet supported for this type of destination"); // //reading/writing from/to the same buffer with MUTEX (see Producer-Consumer problem) // /**/tf::debug(tf::LEV3, "Calling streamedLoadSubvolume_open", __itm__current__function__); // void *stream_descr = 0; // if(vaa3D_volume_RGB) // stream_descr = vaa3D_volume_RGB->streamedLoadSubvolume_open(streamingSteps, buffer, voiV0, voiV1, voiH0, voiH1, voiD0, voiD1); // else // stream_descr = vaa3D_volume_4D->streamedLoadSubvolume_open(streamingSteps, buffer, voiV0, voiV1, voiH0, voiH1, voiD0, voiD1); // for (int currentStep = 1; currentStep <= streamingSteps; currentStep++) // { // /**/tf::debug(tf::LEV3, "Waiting for buffer mutex", __itm__current__function__); // /**/ bufferMutex.lock(); // /**/tf::debug(tf::LEV3, "Access granted to buffer mutex, locking", __itm__current__function__); // QElapsedTimer timerIO; // timerIO.start(); // if(vaa3D_volume_RGB) // buffer = vaa3D_volume_RGB->streamedLoadSubvolume_dostep(stream_descr); // else if(vaa3D_volume_4D) // buffer = vaa3D_volume_4D->streamedLoadSubvolume_dostep(stream_descr); // qint64 elapsedTime = timerIO.elapsed(); // /**/ bufferMutex.unlock(); // /**/tf::debug(tf::LEV3, "Unlocked buffer mutex", __itm__current__function__); // sprintf(msg, "Streaming %d/%d: Block X=[%d, %d) Y=[%d, %d) Z=[%d, %d) loaded from res %d", // currentStep, streamingSteps, voiH0, voiH1, voiV0, voiV1, voiD0, voiD1, voiResIndex); // /**/tf::debug(tf::LEV3, "Waiting for updateGraphicsInProgress mutex", __itm__current__function__); // /**/ destination->updateGraphicsInProgress.lock(); // /**/ destination->updateGraphicsInProgress.unlock(); // /**/tf::debug(tf::LEV3, "Unlocked updateGraphicsInProgress mutex", __itm__current__function__); // finished = currentStep == streamingSteps; // if(finished) // { // /**/tf::debug(tf::LEV3, "Calling streamedLoadSubvolume_close", __itm__current__function__); // if(vaa3D_volume_RGB) // buffer = vaa3D_volume_RGB->streamedLoadSubvolume_close(stream_descr); // else if(vaa3D_volume_4D) // buffer = vaa3D_volume_4D->streamedLoadSubvolume_close(stream_descr); // } // /**/tf::debug(tf::LEV3, strprintf("sendOperationOutcome, step %d", currentStep).c_str(), __itm__current__function__); // emit sendOperationOutcome(buffer, 0, destination, elapsedTime, msg, currentStep); } } else throw RuntimeException("No volume has been imported yet."); /**/tf::debug(tf::LEV1, "EOF", __itm__current__function__); } catch( iim::IOException& exception) { // before emit signal, it is necessary to wait for updateGraphicsInProgress mutex CViewer* dest = dynamic_cast<CViewer*>(source); /**/ updateGraphicsInProgress.lock(); reset(); //bufferMutex.unlock(); tf::warning(exception.what(), "CVolume"); /**/ updateGraphicsInProgress.unlock(); emit sendData(0, make_vector<int>(), make_vector<int>(), dest, true, new RuntimeException(exception.what()), 0, ""); } catch( iom::exception& exception) { // before emit signal, it is necessary to wait for updateGraphicsInProgress mutex CViewer* dest = dynamic_cast<CViewer*>(source); /**/ updateGraphicsInProgress.lock(); reset(); //bufferMutex.unlock(); tf::warning(exception.what(), "CVolume"); /**/ updateGraphicsInProgress.unlock(); emit sendData(0, make_vector<int>(), make_vector<int>(), dest, true, new RuntimeException(exception.what()), 0, ""); } catch( RuntimeException& exception) { // before emit signal, it is necessary to wait for updateGraphicsInProgress mutex CViewer* dest = dynamic_cast<CViewer*>(source); /**/ updateGraphicsInProgress.lock(); reset(); //bufferMutex.unlock(); tf::warning(exception.what(), "CVolume"); /**/ updateGraphicsInProgress.unlock(); emit sendData(0, make_vector<int>(), make_vector<int>(), dest, true, new RuntimeException(exception.what()), 0, ""); } catch(const char* error) { // before emit signal, it is necessary to wait for updateGraphicsInProgress mutex CViewer* dest = dynamic_cast<CViewer*>(source); /**/ updateGraphicsInProgress.lock(); reset(); //bufferMutex.unlock(); tf::warning(error, "CVolume"); /**/ updateGraphicsInProgress.unlock(); emit sendData(0, make_vector<int>(), make_vector<int>(), dest, true, new RuntimeException(error), 0, ""); } catch(...) { // before emit signal, it is necessary to wait for updateGraphicsInProgress mutex CViewer* dest = dynamic_cast<CViewer*>(source); /**/ updateGraphicsInProgress.lock(); reset(); //bufferMutex.unlock(); tf::warning("Unknown error occurred", "CVolume"); /**/ updateGraphicsInProgress.unlock(); emit sendData(0, make_vector<int>(), make_vector<int>(), dest, true, new RuntimeException("Unknown error occurred"), 0, ""); } }