litiv::MetricsCalculator_<litiv::eDatasetEval_BinaryClassifier>::MetricsCalculator_(const IMetricsAccumulatorConstPtr& m) {
lvAssert(m.get());
const auto& m2 = std::dynamic_pointer_cast<const BinClassifMetricsAccumulator>(m);
lvAssert(m2.get());
const BinClassifMetricsAccumulator& m3 = *m2.get();
dRecall = CalcRecall(m3);
dSpecificity = CalcSpecificity(m3);
dFPR = CalcFalsePositiveRate(m3);
dFNR = CalcFalseNegativeRate(m3);
dPBC = CalcPercentBadClassifs(m3);
dPrecision = CalcPrecision(m3);
dFMeasure = CalcFMeasure(m3);
dMCC = CalcMatthewsCorrCoeff(m3);
}
litiv::IMetricsAccumulatorConstPtr litiv::IDataReporter_<litiv::eDatasetEval_BinaryClassifier>::getMetricsBase() const {
lvAssert(isGroup()); // non-group specialization should override this method
BinClassifMetricsAccumulatorPtr pMetricsBase = BinClassifMetricsAccumulator::create();
for(const auto& pBatch : getBatches(true))
pMetricsBase->accumulate(dynamic_cast<const IDataReporter_<eDatasetEval_BinaryClassifier>&>(*pBatch).getMetricsBase());
return pMetricsBase;
}
void litiv::IDatasetEvaluator_<litiv::eDatasetEval_BinaryClassifier>::writeEvalReport() const {
if(getBatches(false).empty() || !isUsingEvaluator()) {
IDatasetEvaluator_<litiv::eDatasetEval_None>::writeEvalReport();
return;
}
for(const auto& pGroupIter : getBatches(true))
pGroupIter->shared_from_this_cast<const IDataReporter_<eDatasetEval_BinaryClassifier>>(true)->IDataReporter_<eDatasetEval_BinaryClassifier>::writeEvalReport();
IMetricsCalculatorConstPtr pMetrics = getMetrics(true);
lvAssert(pMetrics.get());
const BinClassifMetricsCalculator& oMetrics = dynamic_cast<const BinClassifMetricsCalculator&>(*pMetrics.get());
std::cout << CxxUtils::clampString(getName(),12) << " => Rcl=" << std::fixed << std::setprecision(4) << oMetrics.dRecall << " Prc=" << oMetrics.dPrecision << " FM=" << oMetrics.dFMeasure << " MCC=" << oMetrics.dMCC << std::endl;
std::ofstream oMetricsOutput(getOutputPath()+"/overall.txt");
if(oMetricsOutput.is_open()) {
oMetricsOutput << std::fixed;
oMetricsOutput << "Video segmentation evaluation report for dataset '" << getName() << "' :\n\n";
oMetricsOutput << " | Rcl | Spc | FPR | FNR | PBC | Prc | FM | MCC \n";
oMetricsOutput << "------------|------------|------------|------------|------------|------------|------------|------------|------------\n";
size_t nOverallPacketCount = 0;
double dOverallTimeElapsed = 0.0;
for(const auto& pGroupIter : getBatches(true)) {
oMetricsOutput << pGroupIter->shared_from_this_cast<const IDataReporter_<eDatasetEval_BinaryClassifier>>(true)->IDataReporter_<eDatasetEval_BinaryClassifier>::writeInlineEvalReport(0);
nOverallPacketCount += pGroupIter->getTotPackets();
dOverallTimeElapsed += pGroupIter->getProcessTime();
}
oMetricsOutput << "------------|------------|------------|------------|------------|------------|------------|------------|------------\n";
oMetricsOutput << " overall|" <<
std::setw(12) << oMetrics.dRecall << "|" <<
std::setw(12) << oMetrics.dSpecificity << "|" <<
std::setw(12) << oMetrics.dFPR << "|" <<
std::setw(12) << oMetrics.dFNR << "|" <<
std::setw(12) << oMetrics.dPBC << "|" <<
std::setw(12) << oMetrics.dPrecision << "|" <<
std::setw(12) << oMetrics.dFMeasure << "|" <<
std::setw(12) << oMetrics.dMCC << "\n";
oMetricsOutput << "\nHz: " << nOverallPacketCount/dOverallTimeElapsed << "\n";
oMetricsOutput << CxxUtils::getLogStamp();
}
}
std::string litiv::IDataReporter_<litiv::eDatasetEval_BinaryClassifier>::writeInlineEvalReport(size_t nIndentSize) const {
if(!getTotPackets())
return std::string();
const size_t nCellSize = 12;
std::stringstream ssStr;
ssStr << std::fixed;
if(isGroup() && !isBare())
for(const auto& pBatch : getBatches(true))
ssStr << pBatch->shared_from_this_cast<const IDataReporter_<eDatasetEval_BinaryClassifier>>(true)->IDataReporter_<eDatasetEval_BinaryClassifier>::writeInlineEvalReport(nIndentSize+1);
IMetricsCalculatorConstPtr pMetrics = getMetrics(true);
lvAssert(pMetrics.get());
const BinClassifMetricsCalculator& oMetrics = dynamic_cast<const BinClassifMetricsCalculator&>(*pMetrics.get());
ssStr << CxxUtils::clampString((std::string(nIndentSize,'>')+' '+getName()),nCellSize) << "|" <<
std::setw(nCellSize) << oMetrics.dRecall << "|" <<
std::setw(nCellSize) << oMetrics.dSpecificity << "|" <<
std::setw(nCellSize) << oMetrics.dFPR << "|" <<
std::setw(nCellSize) << oMetrics.dFNR << "|" <<
std::setw(nCellSize) << oMetrics.dPBC << "|" <<
std::setw(nCellSize) << oMetrics.dPrecision << "|" <<
std::setw(nCellSize) << oMetrics.dFMeasure << "|" <<
std::setw(nCellSize) << oMetrics.dMCC << "\n";
return ssStr.str();
}
void litiv::IDataReporter_<litiv::eDatasetEval_BinaryClassifier>::writeEvalReport() const {
if(!getTotPackets() || !getDatasetInfo()->isUsingEvaluator()) {
IDataReporter_<litiv::eDatasetEval_None>::writeEvalReport();
return;
}
else if(isGroup() && !isBare())
for(const auto& pBatch : getBatches(true))
pBatch->writeEvalReport();
IMetricsCalculatorConstPtr pMetrics = getMetrics(true);
lvAssert(pMetrics.get());
const BinClassifMetricsCalculator& oMetrics = dynamic_cast<const BinClassifMetricsCalculator&>(*pMetrics.get());;
std::cout << "\t" << CxxUtils::clampString(std::string(size_t(!isGroup()),'>')+getName(),12) << " => Rcl=" << std::fixed << std::setprecision(4) << oMetrics.dRecall << " Prc=" << oMetrics.dPrecision << " FM=" << oMetrics.dFMeasure << " MCC=" << oMetrics.dMCC << std::endl;
std::ofstream oMetricsOutput(PlatformUtils::AddDirSlashIfMissing(getOutputPath())+"../"+getName()+".txt");
if(oMetricsOutput.is_open()) {
oMetricsOutput << std::fixed;
oMetricsOutput << "Video segmentation evaluation report for '" << getName() << "' :\n\n";
oMetricsOutput << " | Rcl | Spc | FPR | FNR | PBC | Prc | FM | MCC \n";
oMetricsOutput << "------------|------------|------------|------------|------------|------------|------------|------------|------------\n";
oMetricsOutput << IDataReporter_<eDatasetEval_BinaryClassifier>::writeInlineEvalReport(0);
oMetricsOutput << "\nHz: " << getTotPackets()/getProcessTime() << "\n";
oMetricsOutput << CxxUtils::getLogStamp();
}
}
lv::IMetricsCalculator_<lv::DatasetEval_BinaryClassifierArray>::IMetricsCalculator_(const std::vector<BinClassifMetrics>& vm, const std::vector<std::string>& vs) :
m_vMetrics(vm),m_vsStreamNames(vs) {
lvAssert(m_vMetrics.size()==m_vsStreamNames.size());
}
lv::IMetricsCalculator_<lv::DatasetEval_BinaryClassifierArray>::IMetricsCalculator_(const IIMetricsAccumulatorConstPtr& m) :
m_vMetrics(initMetricsArray(dynamic_cast<const BinClassifMetricsArrayAccumulator&>(*m.get()))),
m_vsStreamNames(dynamic_cast<const BinClassifMetricsArrayAccumulator&>(*m.get()).m_vsStreamNames) {
lvAssert(m_vMetrics.size()==m_vsStreamNames.size());
}
inline GLuint getSSBOId(size_t n) const {lvAssert(n<m_nSSBOs); return m_vnSSBO[n];}
void cv::DisplayHelper::display(const std::vector<std::vector<std::pair<cv::Mat,std::string>>>& vvImageNamePairs, const cv::Size& oSuggestedTileSize) {
lvAssert_(!vvImageNamePairs.empty(),"must provide at least one row to display");
lvAssert_(oSuggestedTileSize.area()>0,"must provide non-null tile size");
const size_t nRowCount = vvImageNamePairs.size();
size_t nColCount = SIZE_MAX;
for(size_t nRowIdx=0; nRowIdx<nRowCount; ++nRowIdx) {
lvAssert_(!vvImageNamePairs[nRowIdx].empty(),"must provide at least one column to display");
lvAssert_(nColCount==SIZE_MAX || vvImageNamePairs[nRowIdx].size()==nColCount,"image map column count mismatch");
nColCount = vvImageNamePairs[nRowIdx].size();
for(size_t nColIdx=0; nColIdx<nColCount; ++nColIdx) {
const cv::Mat& oImage = vvImageNamePairs[nRowIdx][nColIdx].first;
lvAssert_(!oImage.empty(),"all images must be non-null");
lvAssert_(oImage.channels()==1 || oImage.channels()==3 || oImage.channels()==4,"all images must be 1/3/4 channels");
lvAssert_(oImage.depth()==CV_8U || oImage.depth()==CV_16U || oImage.depth()==CV_32F,"all images must be 8u/16u/32f depth");
}
}
cv::Size oCurrDisplaySize(int(oSuggestedTileSize.width*nColCount),int(oSuggestedTileSize.height*nRowCount));
if(m_oMaxDisplaySize.area()>0 && (oCurrDisplaySize.width>m_oMaxDisplaySize.width || oCurrDisplaySize.height>m_oMaxDisplaySize.height)) {
if(oCurrDisplaySize.width>m_oMaxDisplaySize.width && oCurrDisplaySize.width>oCurrDisplaySize.height)
oCurrDisplaySize = cv::Size(m_oMaxDisplaySize.width,int(m_oMaxDisplaySize.width*float(oCurrDisplaySize.height)/oCurrDisplaySize.width));
else
oCurrDisplaySize = cv::Size(int(m_oMaxDisplaySize.height*(float(oCurrDisplaySize.width)/oCurrDisplaySize.height)),m_oMaxDisplaySize.height);
}
const cv::Size oNewTileSize(int(oCurrDisplaySize.width/nColCount),int(oCurrDisplaySize.height/nRowCount));
const cv::Size oFinalDisplaySize(int(oNewTileSize.width*nColCount),int(oNewTileSize.height*nRowCount));
const cv::Point2i& oDisplayPt = m_oLatestMouseEvent.oInternalPosition;
for(size_t nRowIdx=0; nRowIdx<nRowCount; ++nRowIdx) {
cv::Mat oOutputRow;
for(size_t nColIdx=0; nColIdx<nColCount; ++nColIdx) {
const cv::Mat& oImage = vvImageNamePairs[nRowIdx][nColIdx].first;
cv::Mat oImageBYTE3;
if(oImage.depth()==CV_16U)
oImage.convertTo(oImageBYTE3,CV_8U,double(UCHAR_MAX)/(USHRT_MAX));
else if(oImage.depth()==CV_32F)
oImage.convertTo(oImageBYTE3,CV_8U,double(UCHAR_MAX));
else
oImageBYTE3 = oImage.clone();
if(oImageBYTE3.channels()==1)
cv::cvtColor(oImageBYTE3,oImageBYTE3,cv::COLOR_GRAY2BGR);
else if(oImageBYTE3.channels()==4)
cv::cvtColor(oImageBYTE3,oImageBYTE3,cv::COLOR_BGRA2BGR);
if(oImageBYTE3.size()!=oNewTileSize)
cv::resize(oImageBYTE3,oImageBYTE3,oNewTileSize);
if(!vvImageNamePairs[nRowIdx][nColIdx].second.empty())
putText(oImageBYTE3,vvImageNamePairs[nRowIdx][nColIdx].second,cv::Scalar_<uchar>(0,0,255));
if(oDisplayPt.x>=0 && oDisplayPt.y>=0 && oDisplayPt.x<oNewTileSize.width && oDisplayPt.y<oNewTileSize.height && m_oLatestMouseEvent.oTileSize==oNewTileSize)
cv::circle(oImageBYTE3,oDisplayPt,5,cv::Scalar(255,255,255));
if(oOutputRow.empty())
oOutputRow = oImageBYTE3;
else
cv::hconcat(oOutputRow,oImageBYTE3,oOutputRow);
}
if(nRowIdx==0)
m_oLastDisplay = oOutputRow;
else
cv::vconcat(m_oLastDisplay,oOutputRow,m_oLastDisplay);
}
if(m_bFirstDisplay && !m_bContinuousUpdates) {
putText(m_oLastDisplay,"[Press space to continue]",cv::Scalar_<uchar>(0,0,255),true,cv::Point2i(m_oLastDisplay.cols/2-100,15),1,1.0);
m_bFirstDisplay = false;
}
lvAssert(m_oLastDisplay.size()==oFinalDisplaySize);
cv::imshow(m_sDisplayName,m_oLastDisplay);
m_oLastDisplaySize = m_oLastDisplay.size();
m_oLastTileSize = oNewTileSize;
}
