ImgComparison.h

Go to the documentation of this file.

// ImgComparison.h:
// ----------------
//

#ifndef __IPSDKUNITTESTTOOLS_IMGCOMPARISON_H__
#define __IPSDKUNITTESTTOOLS_IMGCOMPARISON_H__

#include <IPSDKImage/Image/BaseImage.h>
#include <IPSDKIPL/IPSDKIPLUtility/Processor/CompareImg/CompareImg.h>
#include <UnitTest/IPSDKUnitTestTools/UnitTestMacros.h>
#include <boost/format.hpp>

namespace ipsdk {
namespace unittest {

inline std::string convertPixelPositionToString(
    const ipsdk::imaproc::attr::PixelPosition& pixPos,
    const image::ImageConstPtr& pImg)
{
    std::string str = (boost::format("x=%d, y=%d")
        % pixPos.getValue<imaproc::attr::PixelPosition::X>()
        % pixPos.getValue<imaproc::attr::PixelPosition::Y>()).str();
    if(pImg->getVolumeGeometryType() == image::eVolumeGeometryType::eVGT_3d)
        str += (boost::format(", z=%d") % pixPos.getValue<imaproc::attr::PixelPosition::Z>()).str();
    if(pImg->getColorGeometryType() != image::eColorGeometryType::eCGT_Grey)
        str += (boost::format(", c=%d") % pixPos.getValue<imaproc::attr::PixelPosition::C>()).str();
    if (pImg->getTemporalGeometryType() == image::eTemporalGeometryType::eTGT_Sequence)
        str += (boost::format(", t=%d") % pixPos.getValue<imaproc::attr::PixelPosition::T>()).str();
    return str;
}

inline std::string convertImgComparisonTolToString(const imaproc::attr::ImgComparisonTolerance& tol)
{
    const imaproc::attr::eImgComparisonToleranceType& tolType =
        tol.getValue<imaproc::attr::ImgComparisonTolerance::ToleranceType>();
    switch (tolType.value()) {
    case imaproc::attr::eImgComparisonToleranceType::eICTT_None:
        return std::string("");
    case imaproc::attr::eImgComparisonToleranceType::eICTT_Absolute:
        return (boost::format(" with absolute tolerance=%e") % tol.getValue<imaproc::attr::ImgComparisonTolerance::AbsTol>()).str();
    case imaproc::attr::eImgComparisonToleranceType::eICTT_Relative:
        return (boost::format(" with relative tolerance=%e") % tol.getValue<imaproc::attr::ImgComparisonTolerance::RelTol>()).str();
    case imaproc::attr::eImgComparisonToleranceType::eICTT_AbsoluteOrRelative:
        return (boost::format(" with tolerance[absolute=%e, relative=%e]") % tol.getValue<imaproc::attr::ImgComparisonTolerance::AbsTol>() % tol.getValue<imaproc::attr::ImgComparisonTolerance::RelTol>()).str();
    default:
        return std::string("with unknown tolerance");
    }
}

inline BoolResult convertImgComparisonResToBoolResult(
    const image::ImageConstPtr& pImg1,
    const image::ImageConstPtr& pImg2,
    const std::string& strPrefix,
    const std::string& strImg1VarName,
    const std::string& strImg2VarName)
{
    const ipsdk::imaproc::attr::CompareResultPtr pRes =
        ipsdk::imaproc::util::compareImg(pImg1, pImg2);

    if (pRes->getValue<ipsdk::imaproc::attr::CompareResult::BEqual>() == true)
        return BoolResult(true, (boost::format("%s (for comparison of images %s and %s)") 
            % strPrefix
            % strImg1VarName
            % strImg2VarName).str());
    else
        return BoolResult(false, (boost::format("%s ([value1=%e not equals value2=%e at (%s)] for comparison of images %s and %s)")
            % strPrefix
            % pRes->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix1Value>()
            % pRes->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix2Value>()
            % convertPixelPositionToString(pRes->getNode<imaproc::attr::CompareResult::OutOfTolPixPosition>(), pImg1)
            % strImg1VarName
            % strImg2VarName).str());
}

inline BoolResult convertImgComparison1Or2ResToBoolResult(
    const image::ImageConstPtr& pImg,
    const image::ImageConstPtr& pImgRef1,
    const image::ImageConstPtr& pImgRef2,
    const std::string& strPrefix,
    const std::string& strImgVarName,
    const std::string& strImgRef1VarName,
    const std::string& strImgRef2VarName)
{
    const ipsdk::imaproc::attr::CompareResultPtr pRes1 =
        ipsdk::imaproc::util::compareImg(pImg, pImgRef1);

    const ipsdk::imaproc::attr::CompareResultPtr pRes2 =
        ipsdk::imaproc::util::compareImg(pImg, pImgRef2);

    if (pRes1->getValue<ipsdk::imaproc::attr::CompareResult::BEqual>() == true)
        return BoolResult(true, (boost::format("%s (for comparison of images %s and %s)")
            % strPrefix
            % strImgVarName
            % strImgRef1VarName).str());
    else if(pRes2->getValue<ipsdk::imaproc::attr::CompareResult::BEqual>() == true)
        return BoolResult(true, (boost::format("%s (for comparison of images %s and %s)")
            % strPrefix
            % strImgVarName
            % strImgRef2VarName).str());
    else
        return BoolResult(false, (boost::format("%s ([value1=%e not equals value2=%e at (%s)] for comparison of images %s and %s and [value1=%e not equals value2=%e at(%s)] for comparison of images %s and %s)")
            % strPrefix
            % pRes1->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix1Value>()
            % pRes1->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix2Value>()
            % convertPixelPositionToString(pRes1->getNode<imaproc::attr::CompareResult::OutOfTolPixPosition>(), pImg)
            % strImgVarName
            % strImgRef1VarName
            % pRes2->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix1Value>()
            % pRes2->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix2Value>()
            % convertPixelPositionToString(pRes2->getNode<imaproc::attr::CompareResult::OutOfTolPixPosition>(), pImg)
            % strImgVarName
            % strImgRef2VarName
            ).str());
}

inline BoolResult convertImgComparisonResToBoolResult(
    const image::ImageConstPtr& pImg1,
    const image::ImageConstPtr& pImg2,
    const imaproc::attr::ImgComparisonToleranceConstPtr& pTol,
    const std::string& strPrefix,
    const std::string& strImg1VarName,
    const std::string& strImg2VarName)
{
    ipsdk::imaproc::attr::CompareResultPtr pRes =
        ipsdk::imaproc::util::compareImg(pImg1, pImg2, pTol);
    std::string strMsgInsideMacro;
    if (pRes->getValue<ipsdk::imaproc::attr::CompareResult::BEqual>() == true)
        return BoolResult(true, (boost::format("%s (for comparison of images %s and %s%s)")
            % strPrefix
            % strImg1VarName
            % strImg2VarName
            % convertImgComparisonTolToString(*pTol)).str());
    else
        return BoolResult(false, (boost::format("%s ([value1=%e not equals value2=%e at (%s)] for comparison of images %s and %s%s)")
            % strPrefix
            % pRes->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix1Value>()
            % pRes->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix2Value>()
            % convertPixelPositionToString(pRes->getNode<ipsdk::imaproc::attr::CompareResult::OutOfTolPixPosition>(), pImg1)
            % strImg1VarName
            % strImg2VarName
            % convertImgComparisonTolToString(*pTol)).str());
}

inline BoolResult convertImgComparison1Or2ResToBoolResult(
    const image::ImageConstPtr& pImg,
    const image::ImageConstPtr& pImgRef1,
    const image::ImageConstPtr& pImgRef2,
    const imaproc::attr::ImgComparisonToleranceConstPtr& pTol,
    const std::string& strPrefix,
    const std::string& strImgVarName,
    const std::string& strImgRef1VarName,
    const std::string& strImgRef2VarName)
{
    ipsdk::imaproc::attr::CompareResultPtr pRes1 =
        ipsdk::imaproc::util::compareImg(pImg, pImgRef1, pTol);
    ipsdk::imaproc::attr::CompareResultPtr pRes2 =
        ipsdk::imaproc::util::compareImg(pImg, pImgRef2, pTol);
    std::string strMsgInsideMacro;
    if (pRes1->getValue<ipsdk::imaproc::attr::CompareResult::BEqual>() == true)
        return BoolResult(true, (boost::format("%s (for comparison of images %s and %s%s)")
            % strPrefix
            % strImgVarName
            % strImgRef1VarName
            % convertImgComparisonTolToString(*pTol)).str());
    else if (pRes2->getValue<ipsdk::imaproc::attr::CompareResult::BEqual>() == true)
        return BoolResult(true, (boost::format("%s (for comparison of images %s and %s%s)")
            % strPrefix
            % strImgVarName
            % strImgRef2VarName
            % convertImgComparisonTolToString(*pTol)).str());
    else
        return BoolResult(false, (boost::format("%s ([value1=%e not equals value2=%e at (%s)] for comparison of images %s and %s and [value1=%e not equals value2=%e at(%s)] for comparison of images %s and %s%s )")
            % strPrefix
            % pRes1->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix1Value>()
            % pRes1->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix2Value>()
            % convertPixelPositionToString(pRes1->getNode<ipsdk::imaproc::attr::CompareResult::OutOfTolPixPosition>(), pImg)
            % strImgVarName
            % strImgRef1VarName
            % pRes2->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix1Value>()
            % pRes2->getValue<ipsdk::imaproc::attr::CompareResult::OutOfTolPix2Value>()
            % convertPixelPositionToString(pRes2->getNode<ipsdk::imaproc::attr::CompareResult::OutOfTolPixPosition>(), pImg)
            % strImgVarName
            % strImgRef2VarName
            % convertImgComparisonTolToString(*pTol)).str());
}



}   // end of namespace unittest
}   // end of namespace ipsdk



#define IPSDK_CHECK_IMG_EQUAL(pImg1, pImg2, strPrefix)  \
do {   \
    const ipsdk::BoolResult __ipsdkInternalBRes = convertImgComparisonResToBoolResult(pImg1, pImg2, strPrefix, BOOST_PP_STRINGIZE(pImg1), BOOST_PP_STRINGIZE(pImg2));   \
    IPSDK_UT_LOG_TEST_RES(strPrefix, __ipsdkInternalBRes)\
    BOOST_CHECK_MESSAGE(__ipsdkInternalBRes, __ipsdkInternalBRes.getMsg()); \
} while(0)

#define IPSDK_CHECK_IMG_EQUAL_TO_1_OR_2(pImg, pImgRef1, pImgRef2, strPrefix)  \
do {   \
    const ipsdk::BoolResult __ipsdkInternalBRes = convertImgComparison1Or2ResToBoolResult(pImg, pImgRef1, pImgRef2, strPrefix, BOOST_PP_STRINGIZE(pImg), BOOST_PP_STRINGIZE(pImgRef1), BOOST_PP_STRINGIZE(pImgRef2));   \
    IPSDK_UT_LOG_TEST_RES(strPrefix, __ipsdkInternalBRes)\
    BOOST_CHECK_MESSAGE(__ipsdkInternalBRes, __ipsdkInternalBRes.getMsg()); \
} while(0)

#define IPSDK_CHECK_IMG_CLOSE(pImg1, pImg2, pTol, strPrefix)  \
do {   \
    const ipsdk::BoolResult __ipsdkInternalBRes = convertImgComparisonResToBoolResult(pImg1, pImg2, pTol, strPrefix, BOOST_PP_STRINGIZE(pImg1), BOOST_PP_STRINGIZE(pImg2));   \
    IPSDK_UT_LOG_TEST_RES(strPrefix, __ipsdkInternalBRes)\
    BOOST_CHECK_MESSAGE(__ipsdkInternalBRes, __ipsdkInternalBRes.getMsg()); \
} while(0)

#define IPSDK_CHECK_IMG_CLOSE_TO_1_OR_2(pImg, pImgRef1, pImgRef2, pTol, strPrefix)  \
do {   \
    const ipsdk::BoolResult __ipsdkInternalBRes = convertImgComparison1Or2ResToBoolResult(pImg, pImgRef1, pImgRef2, pTol, strPrefix, BOOST_PP_STRINGIZE(pImg), BOOST_PP_STRINGIZE(pImgRef1), BOOST_PP_STRINGIZE(pImgRef2));   \
    IPSDK_UT_LOG_TEST_RES(strPrefix, __ipsdkInternalBRes)\
    BOOST_CHECK_MESSAGE(__ipsdkInternalBRes, __ipsdkInternalBRes.getMsg()); \
} while(0)

#endif // __IPSDKUNITTESTTOOLS_IMGCOMPARISON_H__