static void Run()
{
CImg Source, SourceMask;
InitSourceImage(gFilterRecord, Source, SourceMask);
Parameters params;
params.Init();
ReadRegistryParameters(params);
ReadScriptParameters(params);
/* Run the UI if we've been told to. */
bool bApplyToImage = true;
if(!gFilterRecord->descriptorParameters || gFilterRecord->descriptorParameters->playInfo == plugInDialogDisplay)
{
PreviewRenderer pr;
pr.Source.Hold(Source);
pr.SourceMask.Hold(SourceMask);
pr.FilterSettings = params.FilterSettings;
pr.FilterOptions = params.FilterOptions;
SetFromImage(gFilterRecord, pr.Source, pr.Image.PreviewImage);
UIResult ret = DoUI(&pr);
pr.m_pAlgorithm->Abort();
pr.Image.PreviewImage.Free();
if(ret == UI_CANCEL)
{
/* The user cancelled. */
throw PhotoshopErrorException(userCanceledErr);
}
if(ret == UI_SAVE_ONLY)
bApplyToImage = false;
params.FilterSettings = pr.FilterSettings;
params.FilterOptions = pr.FilterOptions;
WriteRegistryParameters(params);
}
WriteScriptParameters(params);
if(!bApplyToImage)
return;
/* Run the main filter. */
auto_ptr<Algorithm> pAlgo(new Algorithm);
pAlgo->SetTarget(Source);
pAlgo->SetMask(SourceMask);
pAlgo->GetSettings() = params.FilterSettings;
pAlgo->GetOptions() = params.FilterOptions;
if(Source.m_iBytesPerChannel == 2)
pAlgo->GetSettings().m_fInputScale = 255.0f / 32768.0f;
else
pAlgo->GetSettings().m_fInputScale = 1.0f;
pAlgo->Run();
if(!ShowProgressDialog(pAlgo.get()))
throw PhotoshopErrorException(userCanceledErr);
string sError;
if(pAlgo->GetError(sError))
throw Exception(sError);
}
void AnalyzeSet_GLSL(std::shared_ptr<DatasetUtils::Segm::Image::Set> pCurrSet) {
srand(0); // for now, assures that two consecutive runs on the same data return the same results
//srand((unsigned int)time(NULL));
size_t nCurrImageIdx = 0;
size_t nNextImageIdx = nCurrImageIdx+1;
bool bGPUContextInitialized = false;
try {
glfwSetErrorCallback(GLFWErrorCallback);
CV_Assert(pCurrSet.get() && pCurrSet->GetTotalImageCount()>0);
if(pCurrSet->m_pEvaluator==nullptr && EVALUATE_OUTPUT)
throw std::runtime_error(cv::format("Missing evaluation impl for image segmentation dataset '%s'",g_pDatasetInfo->m_sDatasetName.c_str()));
const std::string sCurrSetName = pCurrSet->m_sName.size()>12?pCurrSet->m_sName.substr(0,12):pCurrSet->m_sName;
const size_t nImageCount = pCurrSet->GetTotalImageCount();
cv::Mat oCurrInputImage = pCurrSet->GetInputFromIndex(nCurrImageIdx).clone();
CV_Assert(!oCurrInputImage.empty());
CV_Assert(oCurrInputImage.isContinuous());
#if NEED_GT_MASK
cv::Mat oCurrGTMask = pCurrSet->GetGTFromIndex(nCurrImageIdx).clone();
CV_Assert(!oCurrGTMask.empty() && oCurrGTMask.isContinuous());
#endif //NEED_GT_MASK
#if DISPLAY_OUTPUT
cv::Mat oLastInputImage = oCurrInputImage.clone();
#endif //DISPLAY_OUTPUT
cv::Mat oNextInputImage = pCurrSet->GetInputFromIndex(nNextImageIdx);
#if NEED_GT_MASK
#if NEED_LAST_GT_MASK
cv::Mat oLastGTMask = oCurrGTMask.clone();
#endif // NEED_LAST_GT_MASK
cv::Mat oNextGTMask = pCurrSet->GetGTFromIndex(nNextImageIdx);
#endif //NEED_GT_MASK
#if NEED_EDGES_MASK
cv::Mat oLastEdgeMask(oCurrInputImage.size(),CV_8UC1,cv::Scalar_<uchar>(0));
#endif //NEED_EDGES_MASK
glAssert(oCurrInputImage.channels()==1 || oCurrInputImage.channels()==4);
cv::Size oWindowSize = pCurrSet->GetMaxImageSize();
// note: never construct GL classes before context initialization
if(glfwInit()==GL_FALSE)
glError("Failed to init GLFW");
bGPUContextInitialized = true;
glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,TARGET_GL_VER_MAJOR);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,TARGET_GL_VER_MINOR);
glfwWindowHint(GLFW_RESIZABLE,GL_FALSE);
#if !DISPLAY_OUTPUT
glfwWindowHint(GLFW_VISIBLE,GL_FALSE);
#endif //!DISPLAY_OUTPUT
std::unique_ptr<GLFWwindow,void(*)(GLFWwindow*)> pWindow(glfwCreateWindow(oWindowSize.width,oWindowSize.height,(pCurrSet->m_sRelativePath+" [GPU]").c_str(),nullptr,nullptr),glfwDestroyWindow);
if(!pWindow)
glError("Failed to create window via GLFW");
glfwMakeContextCurrent(pWindow.get());
glewInitErrorCheck;
#if USE_CANNY
#error "Missing glsl impl." // ... @@@@@
std::shared_ptr<BackgroundSubtractorLOBSTER_GLSL> pAlgo(new BackgroundSubtractorLOBSTER_GLSL());
#elif USE_LBSP
#error "Missing glsl impl." // ... @@@@@
std::shared_ptr<BackgroundSubtractorSuBSENSE_GLSL> pAlgo(new BackgroundSubtractorSuBSENSE_GLSL());
#endif //USE_...
#if DISPLAY_OUTPUT
bool bContinuousUpdates = false;
std::string sDisplayName = pCurrSet->m_sRelativePath;
cv::namedWindow(sDisplayName);
#endif //DISPLAY_OUTPUT
std::shared_ptr<GLImageProcAlgo> pGLSLAlgo = std::dynamic_pointer_cast<GLImageProcAlgo>(pAlgo);
if(pGLSLAlgo==nullptr)
glError("Segmentation algorithm has no GLImageProcAlgo interface");
pGLSLAlgo->setOutputFetching(NEED_EDGES_MASK);
if(!pGLSLAlgo->getIsUsingDisplay() && DISPLAY_OUTPUT) // @@@@ determine in advance to hint window to hide? or just always hide, and show when needed?
glfwHideWindow(pWindow.get());
#if USE_GLSL_EVALUATION
std::shared_ptr<DatasetUtils::EvaluatorBase::GLEvaluatorBase> pGLSLAlgoEvaluator;
if(pCurrSet->m_pEvaluator!=nullptr)
pGLSLAlgoEvaluator = std::dynamic_pointer_cast<DatasetUtils::EvaluatorBase::GLEvaluatorBase>(pCurrSet->m_pEvaluator->CreateGLEvaluator(pGLSLAlgo,nImageCount));
if(pGLSLAlgoEvaluator==nullptr)
glError("Segmentation evaluation algorithm has no GLSegmEvaluator interface");
pGLSLAlgoEvaluator->initialize(oCurrGTMask,cv::Mat(oCurrInputImage.size(),CV_8UC1,cv::Scalar_<uchar>(255)));
oWindowSize.width *= pGLSLAlgoEvaluator->m_nSxSDisplayCount;
#else //!USE_GLSL_EVALUATION
oWindowSize.width *= pGLSLAlgo->m_nSxSDisplayCount;
#endif //!USE_GLSL_EVALUATION
glfwSetWindowSize(pWindow.get(),oWindowSize.width,oWindowSize.height);
glViewport(0,0,oWindowSize.width,oWindowSize.height);
TIMER_TIC(MainLoop);
while(nNextImageIdx<=nImageCount) {
//if(!((nCurrImageIdx+1)%100))
std::cout << "\t\t" << std::setfill(' ') << std::setw(12) << sCurrSetName << " @ F:" << std::setfill('0') << std::setw(PlatformUtils::decimal_integer_digit_count((int)nImageCount)) << nCurrImageIdx+1 << "/" << nImageCount << " [GPU]" << std::endl;
TIMER_INTERNAL_TIC(OverallLoop);
TIMER_INTERNAL_TIC(PipelineUpdate);
pAlgo->apply_async(oNextInputImage);
TIMER_INTERNAL_TOC(PipelineUpdate);
#if USE_GLSL_EVALUATION
pGLSLAlgoEvaluator->apply_async(oNextGTMask);
#endif //USE_GLSL_EVALUATION
TIMER_INTERNAL_TIC(ImageQuery);
#if DISPLAY_OUTPUT
oCurrInputImage.copyTo(oLastInputImage);
oNextInputImage.copyTo(oCurrInputImage);
#endif //DISPLAY_OUTPUT
if(++nNextImageIdx<nImageCount)
oNextInputImage = pCurrSet->GetInputFromIndex(nNextImageIdx);
#if NEED_GT_MASK
#if NEED_LAST_GT_MASK
oCurrGTMask.copyTo(oLastGTMask);
oNextGTMask.copyTo(oCurrGTMask);
#endif //NEED_LAST_GT_MASK
if(nNextImageIdx<nImageCount)
oNextGTMask = pCurrSet->GetGTFromIndex(nNextImageIdx);
#endif //NEED_GT_MASK
TIMER_INTERNAL_TOC(ImageQuery);
glErrorCheck;
if(glfwWindowShouldClose(pWindow.get()))
break;
glfwPollEvents();
#if DISPLAY_OUTPUT
if(glfwGetKey(pWindow.get(),GLFW_KEY_ESCAPE) || glfwGetKey(pWindow.get(),GLFW_KEY_Q))
break;
glfwSwapBuffers(pWindow.get());
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
#endif //DISPLAY_OUTPUT
#if NEED_EDGES_MASK
pAlgo->getLatestEdgeMask(oLastEdgeMask);
#endif //NEED_EDGES_MASK
#if DISPLAY_OUTPUT
@@@ update via copy of non-parallel impl
cv::Mat oDisplayImage = DatasetUtils::GetDisplayImage(oLastInputImage,oLastEdgeMask,pCurrSet->m_pEvaluator?pCurrSet->m_pEvaluator->GetColoredSegmMaskFromResult(oLastEdgeMask,oLastGTMask,cv::Mat()):oLastEdgeMask,nCurrImageIdx);
cv::Mat oDisplayImageResized;
if(oDisplayImage.cols>1920 || oDisplayImage.rows>1080)
cv::resize(oDisplayImage,oDisplayImageResized,cv::Size(oDisplayImage.cols/2,oDisplayImage.rows/2));
else
oDisplayImageResized = oDisplayImage;
cv::imshow(sDisplayName,oDisplayImageResized);
int nKeyPressed;
if(bContinuousUpdates)
nKeyPressed = cv::waitKey(1);
else
nKeyPressed = cv::waitKey(0);
if(nKeyPressed!=-1)
nKeyPressed %= (UCHAR_MAX+1); // fixes return val bug in some opencv versions
if(nKeyPressed==' ')
bContinuousUpdates = !bContinuousUpdates;
else if(nKeyPressed==(int)'q')
break;
#endif //DISPLAY_OUTPUT
#if WRITE_IMG_OUTPUT
pCurrSet->WriteResult(nCurrImageIdx,oLastEdgeMask);
#endif //WRITE_IMG_OUTPUT
#if (EVALUATE_OUTPUT && (!USE_GLSL_EVALUATION || VALIDATE_GPU_EVALUATION))
if(pCurrSet->m_pEvaluator)
pCurrSet->m_pEvaluator->AccumulateMetricsFromResult(oCurrEdgeMask,oCurrGTMask,cv::Mat());
#endif //(EVALUATE_OUTPUT && (!USE_GLSL_EVALUATION || VALIDATE_GPU_EVALUATION))
TIMER_INTERNAL_TOC(OverallLoop);
#if DISPLAY_TIMERS
std::cout << "ImageQuery=" << TIMER_INTERNAL_ELAPSED_MS(ImageQuery) << "ms, "
<< "PipelineUpdate=" << TIMER_INTERNAL_ELAPSED_MS(PipelineUpdate) << "ms, "
<< "OverallLoop=" << TIMER_INTERNAL_ELAPSED_MS(OverallLoop) << "ms" << std::endl;
#endif //ENABLE_INTERNAL_TIMERS
++nCurrImageIdx;
}
TIMER_TOC(MainLoop);
const double dTimeElapsed = TIMER_ELAPSED_MS(MainLoop)/1000;
const double dAvgFPS = (double)nCurrImageIdx/dTimeElapsed;
std::cout << "\t\t" << std::setfill(' ') << std::setw(12) << sCurrSetName << " @ end, " << int(dTimeElapsed) << " sec in-thread (" << (int)floor(dAvgFPS+0.5) << " FPS)" << std::endl;
#if EVALUATE_OUTPUT
if(pCurrSet->m_pEvaluator) {
#if USE_GLSL_EVALUATION
#if VALIDATE_GPU_EVALUATION
printf("cpu eval:\n\tnTP=%" PRIu64 ", nTN=%" PRIu64 ", nFP=%" PRIu64 ", nFN=%" PRIu64 ", nSE=%" PRIu64 ", tot=%" PRIu64 "\n",pCurrSet->m_pEvaluator->m_oBasicMetrics.nTP,pCurrSet->m_pEvaluator->m_oBasicMetrics.nTN,pCurrSet->m_pEvaluator->m_oBasicMetrics.nFP,pCurrSet->m_pEvaluator->m_oBasicMetrics.nFN,pCurrSet->m_pEvaluator->m_oBasicMetrics.nSE,pCurrSet->m_pEvaluator->m_oBasicMetrics.nTP+pCurrSet->m_pEvaluator->m_oBasicMetrics.nTN+pCurrSet->m_pEvaluator->m_oBasicMetrics.nFP+pCurrSet->m_pEvaluator->m_oBasicMetrics.nFN);
#endif //VALIDATE_USE_GLSL_EVALUATION
pCurrSet->m_pEvaluator->FetchGLEvaluationResults(pGLSLAlgoEvaluator);
#if VALIDATE_GPU_EVALUATION
printf("gpu eval:\n\tnTP=%" PRIu64 ", nTN=%" PRIu64 ", nFP=%" PRIu64 ", nFN=%" PRIu64 ", nSE=%" PRIu64 ", tot=%" PRIu64 "\n",pCurrSet->m_pEvaluator->m_oBasicMetrics.nTP,pCurrSet->m_pEvaluator->m_oBasicMetrics.nTN,pCurrSet->m_pEvaluator->m_oBasicMetrics.nFP,pCurrSet->m_pEvaluator->m_oBasicMetrics.nFN,pCurrSet->m_pEvaluator->m_oBasicMetrics.nSE,pCurrSet->m_pEvaluator->m_oBasicMetrics.nTP+pCurrSet->m_pEvaluator->m_oBasicMetrics.nTN+pCurrSet->m_pEvaluator->m_oBasicMetrics.nFP+pCurrSet->m_pEvaluator->m_oBasicMetrics.nFN);
#endif //VALIDATE_USE_GLSL_EVALUATION
#endif //USE_GLSL_EVALUATION
pCurrSet->m_pEvaluator->dTimeElapsed_sec = dTimeElapsed;
}
#endif //EVALUATE_OUTPUT
#if DISPLAY_OUTPUT
cv::destroyWindow(sDisplayName);
#endif //DISPLAY_OUTPUT
}
catch(const CxxUtils::Exception& e) {
std::cout << "\nAnalyzeSequence caught Exception:\n" << e.what();
if(!g_sLatestGLFWErrorMessage.empty()) {
std::cout << " (" << g_sLatestGLFWErrorMessage << ")" << "\n" << std::endl;
g_sLatestGLFWErrorMessage = std::string();
}
else
std::cout << "\n" << std::endl;
}
catch(const cv::Exception& e) {std::cout << "\nAnalyzeSequence caught cv::Exception:\n" << e.what() << "\n" << std::endl;}
catch(const std::exception& e) {std::cout << "\nAnalyzeSequence caught std::exception:\n" << e.what() << "\n" << std::endl;}
catch(...) {std::cout << "\nAnalyzeSequence caught unhandled exception\n" << std::endl;}
if(bGPUContextInitialized)
glfwTerminate();
if(pCurrSet.get()) {
#if DATASET_PRECACHING
pCurrSet->StopPrecaching();
#endif //DATASET_PRECACHING
pCurrSet->m_nImagesProcessed.set_value(nCurrImageIdx);
}
}
void AnalyzeSet(int nThreadIdx, std::shared_ptr<DatasetUtils::Segm::Image::Set> pCurrSet) {
srand(0); // for now, assures that two consecutive runs on the same data return the same results
//srand((unsigned int)time(NULL));
size_t nCurrImageIdx = 0;
try {
CV_Assert(pCurrSet.get() && pCurrSet->GetTotalImageCount()>0);
if(pCurrSet->m_pEvaluator==nullptr && EVALUATE_OUTPUT)
throw std::runtime_error(cv::format("Missing evaluation impl for image segmentation dataset '%s'",g_pDatasetInfo->m_sDatasetName.c_str()));
const std::string sCurrSetName = pCurrSet->m_sName.size()>12?pCurrSet->m_sName.substr(0,12):pCurrSet->m_sName;
const size_t nImageCount = pCurrSet->GetTotalImageCount();
cv::Mat oCurrInputImage = pCurrSet->GetInputFromIndex(nCurrImageIdx).clone();
CV_Assert(!oCurrInputImage.empty());
CV_Assert(oCurrInputImage.isContinuous());
#if NEED_GT_MASK
cv::Mat oCurrGTMask = pCurrSet->GetGTFromIndex(nCurrImageIdx).clone();
CV_Assert(!oCurrGTMask.empty() && oCurrGTMask.isContinuous());
#endif //NEED_GT_MASK
cv::Mat oCurrEdgeMask(oCurrInputImage.size(),CV_8UC1,cv::Scalar_<uchar>(0));
#if USE_CANNY
std::shared_ptr<EdgeDetector> pAlgo(new EdgeDetectorCanny());
#elif USE_LBSP
std::shared_ptr<EdgeDetector> pAlgo(new EdgeDetectorLBSP());
#endif //USE_...
#if !FULL_THRESH_ANALYSIS
const double dDefaultThreshold = pAlgo->getDefaultThreshold();
#endif //!FULL_THRESH_ANALYSIS
#if DISPLAY_OUTPUT
bool bContinuousUpdates = false;
std::string sDisplayName = pCurrSet->m_sRelativePath;
cv::namedWindow(sDisplayName);
#endif //DISPLAY_OUTPUT
#if DEBUG_OUTPUT
cv::FileStorage oDebugFS = cv::FileStorage(pCurrSet->m_sResultsPath+"../"+pCurrSet->m_sName+"_debug.yml",cv::FileStorage::WRITE);
pAlgo->m_pDebugFS = &oDebugFS;
pAlgo->m_sDebugName = pCurrSet->m_sName;
#endif //DEBUG_OUTPUT
bool bExit = false;
TIMER_TIC(MainLoop);
while(nCurrImageIdx<nImageCount && !bExit) {
//if(!((nCurrImageIdx+1)%100))
std::cout << "\t\t" << std::setfill(' ') << std::setw(12) << sCurrSetName << " @ F:" << std::setfill('0') << std::setw(PlatformUtils::decimal_integer_digit_count((int)nImageCount)) << nCurrImageIdx+1 << "/" << nImageCount << " [T=" << nThreadIdx << "]" << std::endl;
TIMER_INTERNAL_TIC(OverallLoop);
TIMER_INTERNAL_TIC(ImageQuery);
oCurrInputImage = pCurrSet->GetInputFromIndex(nCurrImageIdx);
#if NEED_GT_MASK
oCurrGTMask = pCurrSet->GetGTFromIndex(nCurrImageIdx);
#endif //NEED_GT_MASK
TIMER_INTERNAL_TOC(ImageQuery);
TIMER_INTERNAL_TIC(PipelineUpdate);
#if FULL_THRESH_ANALYSIS
pAlgo->apply(oCurrInputImage,oCurrEdgeMask);
#else //!FULL_THRESH_ANALYSIS
pAlgo->apply_threshold(oCurrInputImage,oCurrEdgeMask,dDefaultThreshold);
#endif //!FULL_THRESH_ANALYSIS
TIMER_INTERNAL_TOC(PipelineUpdate);
#if DISPLAY_OUTPUT
cv::Mat oDisplayImage = DatasetUtils::GetDisplayImage(oCurrInputImage,oCurrEdgeMask,pCurrSet->m_pEvaluator?pCurrSet->m_pEvaluator->GetColoredSegmMaskFromResult(oCurrEdgeMask,oCurrGTMask,cv::Mat()):oCurrEdgeMask,nCurrImageIdx);
cv::Mat oDisplayImageResized;
if(oDisplayImage.cols>1920 || oDisplayImage.rows>1080)
cv::resize(oDisplayImage,oDisplayImageResized,cv::Size(oDisplayImage.cols/2,oDisplayImage.rows/2));
else
oDisplayImageResized = oDisplayImage;
cv::imshow(sDisplayName,oDisplayImageResized);
int nKeyPressed;
if(bContinuousUpdates)
nKeyPressed = cv::waitKey(1);
else
nKeyPressed = cv::waitKey(0);
if(nKeyPressed!=-1)
nKeyPressed %= (UCHAR_MAX+1); // fixes return val bug in some opencv versions
if(nKeyPressed==' ')
bContinuousUpdates = !bContinuousUpdates;
else if(nKeyPressed==(int)'q')
bExit = true;
#endif //DISPLAY_OUTPUT
#if WRITE_IMG_OUTPUT
pCurrSet->WriteResult(nCurrImageIdx,oCurrEdgeMask);
#endif //WRITE_IMG_OUTPUT
#if EVALUATE_OUTPUT
//@@@ FULL_THRESH_ANALYSIS oCurrEdgeMask
if(pCurrSet->m_pEvaluator)
pCurrSet->m_pEvaluator->AccumulateMetricsFromResult(oCurrEdgeMask,oCurrGTMask,cv::Mat());
#endif //EVALUATE_OUTPUT
TIMER_INTERNAL_TOC(OverallLoop);
#if DISPLAY_TIMERS
std::cout << "ImageQuery=" << TIMER_INTERNAL_ELAPSED_MS(ImageQuery) << "ms, "
<< "PipelineUpdate=" << TIMER_INTERNAL_ELAPSED_MS(PipelineUpdate) << "ms, "
<< "OverallLoop=" << TIMER_INTERNAL_ELAPSED_MS(OverallLoop) << "ms" << std::endl;
#endif //ENABLE_INTERNAL_TIMERS
++nCurrImageIdx;
}
TIMER_TOC(MainLoop);
const double dTimeElapsed = TIMER_ELAPSED_MS(MainLoop)/1000;
const double dAvgFPS = (double)nCurrImageIdx/dTimeElapsed;
std::cout << "\t\t" << std::setfill(' ') << std::setw(12) << sCurrSetName << " @ end, " << int(dTimeElapsed) << " sec in-thread (" << (int)floor(dAvgFPS+0.5) << " FPS)" << std::endl;
#if EVALUATE_OUTPUT
if(pCurrSet->m_pEvaluator) {
pCurrSet->m_pEvaluator->dTimeElapsed_sec = dTimeElapsed;
//pCurrSet->m_pEvaluator->WriteMetrics(pCurrSet->m_sResultsPath+"../"+pCurrSet->m_sName+".txt",*pCurrSet);
}
#endif //EVALUATE_OUTPUT
#if DISPLAY_OUTPUT
cv::destroyWindow(sDisplayName);
#endif //DISPLAY_OUTPUT
}
catch(const cv::Exception& e) {std::cout << "\nAnalyzeSequence caught cv::Exception:\n" << e.what() << "\n" << std::endl;}
catch(const std::exception& e) {std::cout << "\nAnalyzeSequence caught std::exception:\n" << e.what() << "\n" << std::endl;}
catch(...) {std::cout << "\nAnalyzeSequence caught unhandled exception\n" << std::endl;}
g_nActiveThreads--;
if(pCurrSet.get()) {
#if DATASET_PRECACHING
pCurrSet->StopPrecaching();
#endif //DATASET_PRECACHING
pCurrSet->m_nImagesProcessed.set_value(nCurrImageIdx);
}
}
void AnalyzeSequence(int nThreadIdx, std::shared_ptr<DatasetUtils::Segm::Video::Sequence> pCurrSequence) {
srand(0); // for now, assures that two consecutive runs on the same data return the same results
//srand((unsigned int)time(NULL));
size_t nCurrFrameIdx = 0;
try {
CV_Assert(pCurrSequence.get() && pCurrSequence->GetTotalImageCount()>1);
if(pCurrSequence->m_pEvaluator==nullptr && EVALUATE_OUTPUT)
throw std::runtime_error(cv::format("Missing evaluation impl for video segmentation dataset '%s'",g_pDatasetInfo->m_sDatasetName.c_str()));
const std::string sCurrSeqName = pCurrSequence->m_sName.size()>12?pCurrSequence->m_sName.substr(0,12):pCurrSequence->m_sName;
const size_t nFrameCount = pCurrSequence->GetTotalImageCount();
const cv::Mat oROI = LIMIT_MODEL_TO_SEQUENCE_ROI?pCurrSequence->GetROI():cv::Mat();
cv::Mat oCurrInputFrame = pCurrSequence->GetInputFromIndex(nCurrFrameIdx).clone();
CV_Assert(!oCurrInputFrame.empty());
CV_Assert(oCurrInputFrame.isContinuous());
#if NEED_GT_MASK
cv::Mat oCurrGTMask = pCurrSequence->GetGTFromIndex(nCurrFrameIdx).clone();
CV_Assert(!oCurrGTMask.empty() && oCurrGTMask.isContinuous());
#endif //NEED_GT_MASK
cv::Mat oCurrFGMask(oCurrInputFrame.size(),CV_8UC1,cv::Scalar_<uchar>(0));
#if DISPLAY_OUTPUT
cv::Mat oCurrBGImg;
#endif //DISPLAY_OUTPUT
#if USE_LOBSTER
std::shared_ptr<BackgroundSubtractorLOBSTER> pAlgo(new BackgroundSubtractorLOBSTER());
const double dDefaultLearningRate = BGSLOBSTER_DEFAULT_LEARNING_RATE;
pAlgo->initialize(oCurrInputFrame,oROI);
#elif USE_SUBSENSE
std::shared_ptr<BackgroundSubtractorSuBSENSE> pAlgo(new BackgroundSubtractorSuBSENSE());
const double dDefaultLearningRate = 0;
pAlgo->initialize(oCurrInputFrame,oROI);
#elif USE_PAWCS
std::shared_ptr<BackgroundSubtractorPAWCS> pAlgo(new BackgroundSubtractorPAWCS());
const double dDefaultLearningRate = 0;
pAlgo->initialize(oCurrInputFrame,oROI);
#else //USE_VIBE || USE_PBAS
const size_t m_nInputChannels = (size_t)oCurrInputFrame.channels();
#if USE_VIBE
std::shared_ptr<BackgroundSubtractorViBe> pAlgo;
if(m_nInputChannels==3)
pAlgo = std::shared_ptr<BackgroundSubtractorViBe>(new BackgroundSubtractorViBe_3ch());
else
pAlgo = std::shared_ptr<BackgroundSubtractorViBe>(new BackgroundSubtractorViBe_1ch());
const double dDefaultLearningRate = BGSVIBE_DEFAULT_LEARNING_RATE;
#else //USE_PBAS
std::shared_ptr<BackgroundSubtractorPBAS> pAlgo;
if(m_nInputChannels==3)
pAlgo = std::shared_ptr<BackgroundSubtractorPBAS>(new BackgroundSubtractorPBAS_3ch());
else
pAlgo = std::shared_ptr<BackgroundSubtractorPBAS>(new BackgroundSubtractorPBAS_1ch());
const double dDefaultLearningRate = BGSPBAS_DEFAULT_LEARNING_RATE_OVERRIDE;
#endif //USE_PBAS
pAlgo->initialize(oCurrInputFrame);
#endif //USE_VIBE || USE_PBAS
#if (DEBUG_OUTPUT && (USE_LOBSTER || USE_SUBSENSE || USE_PAWCS))
cv::FileStorage oDebugFS = cv::FileStorage(pCurrSequence->m_sResultsPath+"../"+pCurrSequence->m_sName+"_debug.yml",cv::FileStorage::WRITE);
pAlgo->m_pDebugFS = &oDebugFS;
pAlgo->m_sDebugName = pCurrSequence->m_sName;
g_pnLatestMouseX = &pAlgo->m_nDebugCoordX;
g_pnLatestMouseY = &pAlgo->m_nDebugCoordY;
std::string sMouseDebugDisplayName = pCurrSequence->m_sName + " [MOUSE DEBUG]";
cv::namedWindow(sMouseDebugDisplayName,0);
cv::setMouseCallback(sMouseDebugDisplayName,OnMouseEvent,nullptr);
#endif //(DEBUG_OUTPUT && (USE_LOBSTER || USE_SUBSENSE || USE_PAWCS))
#if DISPLAY_OUTPUT
bool bContinuousUpdates = false;
std::string sDisplayName = pCurrSequence->m_sRelativePath;
cv::namedWindow(sDisplayName);
#endif //DISPLAY_OUTPUT
#if (WRITE_IMG_OUTPUT || WRITE_AVI_OUTPUT)
#if WRITE_AVI_OUTPUT
cv::VideoWriter oSegmWriter(pCurrSequence->m_sResultsPath+"../"+pCurrSequence->m_sName+"_segm.avi",CV_FOURCC('F','F','V','1'),30,pCurrSequence->GetImageSize(),false);
#endif //WRITE_AVI_OUTPUT
#endif //(WRITE_IMG_OUTPUT || WRITE_AVI_OUTPUT)
TIMER_TIC(MainLoop);
while(nCurrFrameIdx<nFrameCount) {
if(!((nCurrFrameIdx+1)%100))
std::cout << "\t\t" << std::setfill(' ') << std::setw(12) << sCurrSeqName << " @ F:" << std::setfill('0') << std::setw(PlatformUtils::decimal_integer_digit_count((int)nFrameCount)) << nCurrFrameIdx+1 << "/" << nFrameCount << " [T=" << nThreadIdx << "]" << std::endl;
const double dCurrLearningRate = (BOOTSTRAP_100_FIRST_FRAMES&&nCurrFrameIdx<=100)?1:dDefaultLearningRate;
TIMER_INTERNAL_TIC(OverallLoop);
TIMER_INTERNAL_TIC(VideoQuery);
oCurrInputFrame = pCurrSequence->GetInputFromIndex(nCurrFrameIdx);
#if DEBUG_OUTPUT
cv::imshow(sMouseDebugDisplayName,oCurrInputFrame);
#endif //DEBUG_OUTPUT
#if NEED_GT_MASK
oCurrGTMask = pCurrSequence->GetGTFromIndex(nCurrFrameIdx);
#endif //NEED_GT_MASK
TIMER_INTERNAL_TOC(VideoQuery);
TIMER_INTERNAL_TIC(PipelineUpdate);
pAlgo->apply(oCurrInputFrame,oCurrFGMask,dCurrLearningRate);
TIMER_INTERNAL_TOC(PipelineUpdate);
if(!oROI.empty())
cv::bitwise_or(oCurrFGMask,UCHAR_MAX/2,oCurrFGMask,oROI==0);
#if DISPLAY_OUTPUT
pAlgo->getBackgroundImage(oCurrBGImg);
if(!oROI.empty())
cv::bitwise_or(oCurrBGImg,UCHAR_MAX/2,oCurrBGImg,oROI==0);
cv::Mat oDisplayFrame = DatasetUtils::GetDisplayImage(oCurrInputFrame,oCurrBGImg,pCurrSequence->m_pEvaluator?pCurrSequence->m_pEvaluator->GetColoredSegmMaskFromResult(oCurrFGMask,oCurrGTMask,oROI):oCurrFGMask,nCurrFrameIdx,cv::Point(*g_pnLatestMouseX,*g_pnLatestMouseY));
cv::Mat oDisplayFrameResized;
if(oDisplayFrame.cols>1920 || oDisplayFrame.rows>1080)
cv::resize(oDisplayFrame,oDisplayFrameResized,cv::Size(oDisplayFrame.cols/2,oDisplayFrame.rows/2));
else
oDisplayFrameResized = oDisplayFrame;
cv::imshow(sDisplayName,oDisplayFrameResized);
int nKeyPressed;
if(bContinuousUpdates)
nKeyPressed = cv::waitKey(1);
else
nKeyPressed = cv::waitKey(0);
if(nKeyPressed!=-1)
nKeyPressed %= (UCHAR_MAX+1); // fixes return val bug in some opencv versions
if(nKeyPressed==' ')
bContinuousUpdates = !bContinuousUpdates;
else if(nKeyPressed==(int)'q')
break;
#endif //DISPLAY_OUTPUT
#if WRITE_AVI_OUTPUT
oSegmWriter.write(oCurrFGMask);
#endif //WRITE_AVI_OUTPUT
#if WRITE_IMG_OUTPUT
pCurrSequence->WriteResult(nCurrFrameIdx,oCurrFGMask);
#endif //WRITE_IMG_OUTPUT
#if EVALUATE_OUTPUT
if(pCurrSequence->m_pEvaluator)
pCurrSequence->m_pEvaluator->AccumulateMetricsFromResult(oCurrFGMask,oCurrGTMask,oROI);
#endif //EVALUATE_OUTPUT
TIMER_INTERNAL_TOC(OverallLoop);
#if DISPLAY_TIMERS
std::cout << "VideoQuery=" << TIMER_INTERNAL_ELAPSED_MS(VideoQuery) << "ms, "
<< "PipelineUpdate=" << TIMER_INTERNAL_ELAPSED_MS(PipelineUpdate) << "ms, "
<< "OverallLoop=" << TIMER_INTERNAL_ELAPSED_MS(OverallLoop) << "ms" << std::endl;
#endif //ENABLE_INTERNAL_TIMERS
++nCurrFrameIdx;
}
TIMER_TOC(MainLoop);
const double dTimeElapsed = TIMER_ELAPSED_MS(MainLoop)/1000;
const double dAvgFPS = (double)nCurrFrameIdx/dTimeElapsed;
std::cout << "\t\t" << std::setfill(' ') << std::setw(12) << sCurrSeqName << " @ end, " << int(dTimeElapsed) << " sec in-thread (" << (int)floor(dAvgFPS+0.5) << " FPS)" << std::endl;
#if EVALUATE_OUTPUT
if(pCurrSequence->m_pEvaluator) {
pCurrSequence->m_pEvaluator->dTimeElapsed_sec = dTimeElapsed;
//pCurrSequence->m_pEvaluator->WriteMetrics(pCurrSequence->m_sResultsPath+"../"+pCurrSequence->m_sName+".txt",*pCurrSequence);
}
#endif //EVALUATE_OUTPUT
#if DISPLAY_OUTPUT
cv::destroyWindow(sDisplayName);
#endif //DISPLAY_OUTPUT
#if DEBUG_OUTPUT
cv::setMouseCallback(sMouseDebugDisplayName,OnMouseEvent,nullptr);
cv::destroyWindow(sMouseDebugDisplayName);
g_pnLatestMouseX = &g_nLatestMouseX;
g_pnLatestMouseY = &g_nLatestMouseY;
#endif //DEBUG_OUTPUT
}
catch(const cv::Exception& e) {
std::cout << "\nAnalyzeSequence caught cv::Exception:\n" << e.what() << "\n" << std::endl;
}
catch(const std::exception& e) {
std::cout << "\nAnalyzeSequence caught std::exception:\n" << e.what() << "\n" << std::endl;
}
catch(...) {
std::cout << "\nAnalyzeSequence caught unhandled exception\n" << std::endl;
}
g_nActiveThreads--;
if(pCurrSequence.get()) {
#if DATASET_PRECACHING
pCurrSequence->StopPrecaching();
#endif //DATASET_PRECACHING
pCurrSequence->m_nImagesProcessed.set_value(nCurrFrameIdx);
}
}
