ShapeMatching

// main.cpp:
// ---------
//
//

// --- IPSDK includes
// ------------------

// used to initialize IPSDK environment
#include <IPSDKCore/Config/LibraryInitializer.h>

// used to retrieve usual folders (IPSDK temporary folder, root development folder, etc.)
#include <IPSDKUtil/Tools/LibraryPath.h>

// used to catch exceptions potentially thrown  by functions loadRawImageFile and saveRawImageFile
#include <IPSDKImageFile/Logger/IPSDKImageFileException.h>

// used to read/write an image from/to a TIFF file:
#include <IPSDKImageFile/Tiff/TiffImageFileUtils.h>

// used to smooth images with a Gaussian kernel
#include <IPSDKIPL/IPSDKIPLFiltering/Processor/GaussianSmoothing2dImg/GaussianSmoothing2dImg.h>

// used to threshold images
#include <IPSDKIPL/IPSDKIPLBinarization/Processor/ThresholdImg/ThresholdImg.h>

// used to compute a label image
#include <IPSDKIPL/IPSDKIPLAdvancedMorphology/Processor/ConnectedComponent2dImg/ConnectedComponent2dImg.h>

// used to exstract shapes from label images
#include <IPSDKIPL/IPSDKIPLShapeSegmentation/Processor/LabelShapeExtraction2d/LabelShapeExtraction2d.h>

// used for Shape2dColl
#include <IPSDKBaseShapeSegmentation/Entity/2d/Shape2dColl.h>

// used for Hu moments and its distance
#include <IPSDKGeometry/Measure/2d/Moments/HuMomentsUtils.h>

// used for numeric limits (minimum, maximum and epsilon)
#include <IPSDKUtil/Tools/NumericLimits.h>

// used for LUT transform
#include <IPSDKIPL/IPSDKIPLIntensityTransform/Processor/LUTTransform2dImg/LUTTransform2dImg.h>

// used to display log messages
#include <Sample/Sample_ShapeMatching2d/Logger/Sample_ShapeMatching2dLog.h>

// --- third-party boost includes
// ------------------------------

// boost/filesystem/*: contains functions and classes providing facilities to
// manipulate files and directories, and associated paths
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/convenience.hpp>

// boost/program_options/*: contains functions and classes used to manage and
// interpret arguments of command line
#include <boost/program_options/cmdline.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>

// --- third-party log4cplus include
// ---------------------------------

// used to add console as output support of logs
#include <log4cplus/consoleappender.h>

// --- STL include
// ---------------

#include <iostream>
#include <fstream>

using namespace boost::filesystem;
using namespace boost::program_options;

using namespace ipsdk;
using namespace ipsdk::image;
using namespace ipsdk::sample;
using namespace ipsdk::shape::segmentation;

bool
readCmdArguments(int argc, char* argv[],
    boost::filesystem::path& inImgFilePath,
    std::vector<boost::filesystem::path>& vInTemplateImgFilePath,
    boost::filesystem::path& outImgFilePath,
    boost::filesystem::path& outputCsvResultPath,
    ipReal64& thresholdBinarization, ipReal64& thresholdDistance, ipReal32& stdDev);


ipBool writeToCsvFile(const boost::filesystem::path& fileName, const ipsdk::geom::MatchShapesInfo& bestMatches, const ipReal64 threshold)
{
    // Open the tile
    std::ofstream file(fileName.c_str(), std::ios::out | std::ios::trunc);
    if (!file)
        // Return false if the file does not exist
        return false;

    // Write the titles
    file << "Shape Index;Matched Template Index; Distance\n";

    // For each shape (do not process the background)
    const ipUInt32 nbTemplates = static_cast<ipUInt32>(bestMatches._shapesIdx.size());
    for (ipUInt32 i = 0; i < nbTemplates; i++) {
        file << (i + 1) << ";";

        // Test for a bad match
        if (bestMatches._shapesHuDistance[i] < threshold)
            file << bestMatches._shapesIdx[i];
        else
            file << "Bad match according to threshold ( = " << threshold << ")";
        file << ";" << bestMatches._shapesHuDistance[i] << "\n";
    }

    // Close the file
    file.close();

    return true;
}


int
main(int argc, char* argv[])
{
    // add console appender for application logs
    log4cplus::SharedAppenderPtr pConsole(new log4cplus::ConsoleAppender);
    log4cplus::Logger::getRoot().addAppender(pConsole);
    log4cplus::Logger::getRoot().setLogLevel(log4cplus::INFO_LOG_LEVEL);

    // initialize IPSDK environment (first call to be done before calling any
    // function or using any entity of IPSDK environment)
    const ipsdk::core::LibInitResult initRes =
        ipsdk::core::LibraryInitializer::getInstance().init();

    switch (initRes.getResult().value()) {
    case ipsdk::core::eLibInitStatus::eLIS_Warn:
        // IPSDK library is initialized but there were warnings;
        // notify the user by displaying a message
        SAMPLE_SHAPEMATCHING2D_LOG_WARN(
            [eSample_ShapeMatching2dMessage::eIPSDKLibInitWarn] % initRes.getMsg());
        break;
    case ipsdk::core::eLibInitStatus::eLIS_Failed:
        // IPSDK library initialization; notify the user and exit
        SAMPLE_SHAPEMATCHING2D_LOG_ERROR(
            [eSample_ShapeMatching2dMessage::eIPSDKLibInitFailed] % initRes.getMsg());
        return -1;
        break;
    default:
        break;
    }

    // boost objects, used to store input and output images files paths
    boost::filesystem::path inImgFilePath, outImgFilePath, outputCsvResultPath;
    std::vector<boost::filesystem::path> vInTemplateImgFilePath;

    // variables storing dimensions of input image
    ipReal64 thresholdDistance, thresholdBinarization;
    ipReal32 stdDev;

    // read program options from command line, and, if appropriate,
    // initialize input and output images files paths
    if (!readCmdArguments(argc, argv, inImgFilePath, vInTemplateImgFilePath, outImgFilePath, outputCsvResultPath, thresholdBinarization, thresholdDistance, stdDev))
        return -1;

    // display a log message in "INFO" level, to notify the user of the current step
    SAMPLE_SHAPEMATCHING2D_LOG_INFO(
        [eSample_ShapeMatching2dMessage::eLoadingInputImgFromTiffFile]
        % inImgFilePath.string());

    // declare the variable that will contain the input image, loaded from TIFF file
    ipsdk::image::ImagePtr pInImg;

    try {
        // read input image from specified path
        pInImg = image::file::loadTiffImageFile(inImgFilePath);
    }
    catch (const image::file::IPSDKImageFileException& e) {

        // loadRawImageFile function threw an exception; display error log
        // message
        SAMPLE_SHAPEMATCHING2D_LOG_ERROR(
            [eSample_ShapeMatching2dMessage::eErrorLoadingInputImgFromTiffFile]
        % inImgFilePath.string() % e.getMsg());

        // clear IPSDK environment features; should be called before exiting
        // program
        ipsdk::core::LibraryInitializer::getInstance().clear();

        // quit the application with an exit code indicating an error
        return -1;
    }

    // display a log message in "INFO" level, to notify the user of the current step
    SAMPLE_SHAPEMATCHING2D_LOG_INFO(
        [eSample_ShapeMatching2dMessage::eLoadingTemplateImgFromTiffFiles]
    % inImgFilePath.string());

    const ipUInt32 nbTemplates = static_cast<ipUInt32>(vInTemplateImgFilePath.size());

    // declare the collection of template images, loaded from TIFF file
    std::vector<ipsdk::image::ImagePtr> vTemplateImg;
    vTemplateImg.resize(nbTemplates);

    // For each template image path
    for (ipUInt32 i = 0; i < nbTemplates; ++i) {
        try {
            vTemplateImg[i] = image::file::loadTiffImageFile(vInTemplateImgFilePath[i]);
        }
        catch (const image::file::IPSDKImageFileException& e) {

            // loadRawImageFile function threw an exception; display error log
            // message
            SAMPLE_SHAPEMATCHING2D_LOG_ERROR(
                [eSample_ShapeMatching2dMessage::eErrorLoadingTemplateImgFromTiffFile]
            % vInTemplateImgFilePath[i].string() % e.getMsg());

            // clear IPSDK environment features; should be called before exiting
            // program
            ipsdk::core::LibraryInitializer::getInstance().clear();

            // quit the application with an exit code indicating an error
            return -1;
        }
    }

    // display a log message in "INFO" level, to notify the user of the current step
    if (stdDev > 0.f)
        SAMPLE_SHAPEMATCHING2D_LOG_INFO([eSample_ShapeMatching2dMessage::eBlurringImages]);

    if (stdDev > 0.f) {
        // Blur the images to degrade them and avoid smooth the edges
        try {
            const ipReal32 gaussRatio = 0.99f;
            ipsdk::imaproc::filter::gaussianSmoothing2dImg(pInImg, stdDev, stdDev, ipsdk::imaproc::attr::createGaussianCoverage(gaussRatio, 2), pInImg);
            for(ipUInt32 i = 0; i<nbTemplates; ++i)
                ipsdk::imaproc::filter::gaussianSmoothing2dImg(vTemplateImg[i], stdDev, stdDev, ipsdk::imaproc::attr::createGaussianCoverage(gaussRatio, 2), vTemplateImg[i]);
        }
        catch (const image::file::IPSDKImageFileException& e) {

            // loadRawImageFile function threw an exception; display error log
            // message
            SAMPLE_SHAPEMATCHING2D_LOG_ERROR(
                [eSample_ShapeMatching2dMessage::eErrorBlurringImages] % e.getMsg());

            // clear IPSDK environment features; should be called before exiting
            // program
            ipsdk::core::LibraryInitializer::getInstance().clear();

            // quit the application with an exit code indicating an error
            return -1;
        }
    }

    // display a log message in "INFO" level, to notify the user of the current step
    SAMPLE_SHAPEMATCHING2D_LOG_INFO(
        [eSample_ShapeMatching2dMessage::eExtractingShapes]);

    Shape2dCollPtr pShape2dColl;
    std::vector<Shape2dCollPtr> vTemplateShape2dCollPtr;

    // Label image pointer is declared out of the try-catch block because it is used later
    ImagePtr pLabelImg;
    try {
        // Binarize the input image
        ImagePtr pBinImg = ipsdk::imaproc::bin::thresholdImg(pInImg, thresholdBinarization, 255);

        // Compute the corresponding label image
        pLabelImg = ipsdk::imaproc::advmorpho::connectedComponent2dImg(pBinImg);

        // Extract the shapes from the label image
        pShape2dColl = ipsdk::imaproc::shape::segmentation::labelShapeExtraction2d(pLabelImg);

        // For each template input image
        for (ipUInt32 i = 0; i < nbTemplates; ++i) {
            // Binarize the current template image
            ImagePtr pBinImg_template = ipsdk::imaproc::bin::thresholdImg(vTemplateImg[i], thresholdBinarization, 255);
            // Compute the label image
            ImagePtr pLabelImg_template = ipsdk::imaproc::advmorpho::connectedComponent2dImg(pBinImg_template);

            // Extrac tthe current template shapes
            Shape2dCollPtr pShape2dColl_template = ipsdk::imaproc::shape::segmentation::labelShapeExtraction2d(pLabelImg_template);
            vTemplateShape2dCollPtr.push_back(pShape2dColl_template);
        }
    }
    catch (const image::file::IPSDKImageFileException& e) {

        // loadRawImageFile function threw an exception; display error log
        // message
        SAMPLE_SHAPEMATCHING2D_LOG_ERROR(
            [eSample_ShapeMatching2dMessage::eErrorExtractingShapes] % e.getMsg());

        // clear IPSDK environment features; should be called before exiting
        // program
        ipsdk::core::LibraryInitializer::getInstance().clear();

        // quit the application with an exit code indicating an error
        return -1;
    }

    // display a log message in "INFO" level, to notify the user of the current step
    SAMPLE_SHAPEMATCHING2D_LOG_INFO(
        [eSample_ShapeMatching2dMessage::eComputingShapeMatching]);


    std::vector<ipsdk::geom::MatchShapesInfo> vMatches;
    vMatches.resize(nbTemplates);

    // For each template
    for (ipUInt32 templateIdx = 0; templateIdx < nbTemplates; ++templateIdx) {
        // Compute the distance between the template and the shapes in the input image
        ipsdk::geom::MatchShapesInfo matches = ipsdk::geom::matchShapes(vTemplateShape2dCollPtr[templateIdx]->getColl()[1], pShape2dColl->getColl(), ipsdk::geom::eShapeHuDistanceType::eSDT_Type3, false);

        // Store the result
        vMatches[templateIdx] = matches;
    }

    // Declare and allocate the collection
    // bestMatches is the collection of (_shapeHuDistance, _shapeIdx) structures
    // where _shapeHuDistance is the minimum distance between a shape in the 
    // input image and the most similar template of index _shapeIdx
    ipsdk::geom::MatchShapesInfo bestMatches;
    const ipUInt32 nbShapes = static_cast<ipUInt32>(vMatches[0]._shapesIdx.size());
    bestMatches._shapesHuDistance.resize(nbShapes);
    bestMatches._shapesIdx.resize(nbShapes);

    // Initialize the best matches for each templates
    for (ipUInt32 shapeIdx = 0; shapeIdx < nbShapes; ++shapeIdx) {
        bestMatches._shapesHuDistance[shapeIdx] = NumericLimits<ipReal64>::max();

        // For each template
        for (ipUInt32 templateIdx = 0; templateIdx < nbTemplates; ++templateIdx) {
            // Check if we find a new minimum distance
            const ipsdk::geom::MatchShapesInfo matches = vMatches[templateIdx];
            if (bestMatches._shapesHuDistance[shapeIdx] > matches._shapesHuDistance[shapeIdx]) {
                bestMatches._shapesHuDistance[shapeIdx] = matches._shapesHuDistance[shapeIdx];
                bestMatches._shapesIdx[shapeIdx] = templateIdx;
            }
        }

        // Validate the match : if the distance is lower than the input threshold,
        // then the algorithm considers that the match is correct, otherwise, it
        // notes the match is unsatisfying by assigning the shape index to its 
        // maximum possible value
        if (bestMatches._shapesHuDistance[shapeIdx] >= thresholdDistance)
            bestMatches._shapesIdx[shapeIdx] = NumericLimits<ipUInt32>::max();
    }

    SAMPLE_SHAPEMATCHING2D_LOG_INFO(
        [eSample_ShapeMatching2dMessage::eSavingOutputImgToTiffFile] % outImgFilePath.string());

    // Initialize the LUT
    boost::shared_ptr<ipsdk::imaproc::attr::IntensityLUT> pLut = ipsdk::imaproc::attr::IntensityLUT::createNode();
    pLut->setValue<ipsdk::imaproc::attr::IntensityLUT::BinWidth>(1.0);
    pLut->setValue<ipsdk::imaproc::attr::IntensityLUT::InMin>(.0);

    // Add the first value : the background is 0
    pLut->push_back<ipsdk::imaproc::attr::IntensityLUT::LookupTable>(0);

    // Add the other values
    const ipUInt32 nbLabels = pShape2dColl->getSize();
    for (ipUInt32 i = 1; i < nbLabels; ++i) {
        const ipUInt32 matchIndex = static_cast<ipUInt32>(bestMatches._shapesIdx[i - 1] + 1);
        if(matchIndex < NumericLimits<ipUInt32>::max())
            pLut->push_back<ipsdk::imaproc::attr::IntensityLUT::LookupTable>(matchIndex);
        else
            pLut->push_back<ipsdk::imaproc::attr::IntensityLUT::LookupTable>(0);
    }
    // Apply the LUT
    ImagePtr pMatchImg = ipsdk::imaproc::itrans::lutTransform2dImg(pLabelImg, pLut);

    SAMPLE_SHAPEMATCHING2D_LOG_INFO(
        [eSample_ShapeMatching2dMessage::eSavingOutputImgToTiffFile] % outImgFilePath);

    try {
        ipsdk::image::file::saveTiffImageFile(outImgFilePath, pMatchImg);
    }
    catch (const image::file::IPSDKImageFileException& e) {

        SAMPLE_SHAPEMATCHING2D_LOG_INFO(
            [eSample_ShapeMatching2dMessage::eErrorSavingImgTiffFile] % outImgFilePath % e.getMsg());

        // clear IPSDK environment features; should be called before exiting
        // program
        ipsdk::core::LibraryInitializer::getInstance().clear();

        // quit the application with an exit code indicating an error
        return -1;
    }

    SAMPLE_SHAPEMATCHING2D_LOG_INFO(
        [eSample_ShapeMatching2dMessage::eSavingOutputCsvResultsFile] % outputCsvResultPath.string());

    // save matching results to output csv file
    ipBool bWritten = writeToCsvFile(outputCsvResultPath, bestMatches, thresholdDistance);
    if (bWritten == false) {

        SAMPLE_SHAPEMATCHING2D_LOG_INFO(
            [eSample_ShapeMatching2dMessage::eFailedToSaveCsvResultsFile] % outputCsvResultPath.string());

        // clear IPSDK environment features; should be called before exiting
        // program
        ipsdk::core::LibraryInitializer::getInstance().clear();

        return -1;
    }

    // display a log message in "INFO" level, to notify the user that the job
    // is successfully done
    SAMPLE_SHAPEMATCHING2D_LOG_INFO([eSample_ShapeMatching2dMessage::eSuccessfullyDone]);

    // clearing IPSDK environment features; should be called before exiting
    // program
    ipsdk::core::LibraryInitializer::getInstance().clear();
    return 0;
}

bool
readCmdArguments(int argc, char* argv[],
                 boost::filesystem::path& inImgFilePath,
                 std::vector<boost::filesystem::path>& vInTemplateImgFilePath,
                 boost::filesystem::path& outImgFilePath,
                 boost::filesystem::path& outputCsvResultPath,
                 ipReal64& thresholdBinarization, ipReal64& thresholdDistance, ipReal32& stdDev)
{
    // list of allowed program options
    boost::program_options::options_description desc("Allowed options");
    desc.add_options()
        ("help", "produce help message")
        ("inputImgFilePath", value<path>(),
            "input image file path (optional; only TIFF format is accepted)")
        ("inTemplatePathList", boost::program_options::value< std::vector<boost::filesystem::path> >()->multitoken(),
            "list of input template image file path (optional; only TIFF format is accepted)")
        ("inThresholdBinarization", value<ipReal64>(),
           "input binarization used for shape extraction (optional; default value = 15)")
        ("inThresholdDistance", value<ipReal64>(),
           "input shape distance threshold (optional; default value = 0.2)")
        ("inStdDev", value<ipReal32>(),
           "standard deviation for Gaussian smoothing, used to blur the edges (optional; default value = 1)")
        ("outputImgFilePath", value<path>(),
            "output image file path (optional; only TIFF format is accepted)")
        ("outputCsvResultPath", value<path>(),
            "output CSV file path (optional; the file is named shapeMatches.csv and is located in the same directory thant the output image path if not specified)")
        ;

    // vm stores options found in command line
    boost::program_options::variables_map vm;

    try {
        boost::program_options::store(parse_command_line(argc, argv, desc), vm);
    }
    catch (const std::exception& e) {
        SAMPLE_SHAPEMATCHING2D_LOG_ERROR(
            [eSample_ShapeMatching2dMessage::eErrorReadingCmdLine]
        % e.what());
        return false;
    }

    boost::program_options::notify(vm);

    // if the user typed "<app_name>.exe --help"...
    if (vm.count("help")) {
        // ... the application displays help message
        std::cout << desc << "\n";
        return false;
    }

    // initialize input image file path with a default file path
    inImgFilePath = getIPSDKDirectory(eInternalDirectory::eID_Images) / "shapes.tif";

    // if the user specified his own input image file path as argument...
    if (vm.count("inputImgFilePath")) {
        // ... replace the default one by his own
        inImgFilePath = vm["inputImgFilePath"].as<path>();
    }

    // check that input image file path exists. If not...
    if (!boost::filesystem::exists(inImgFilePath)) {
        // ... notify the user, and abort
        SAMPLE_SHAPEMATCHING2D_LOG_ERROR(
            [eSample_ShapeMatching2dMessage::eErrorInputImgTiffFileNotFound]
        % inImgFilePath);
        return false;
    }

    // Read the orientation class centers
    if (vm.count("inTemplatePathList")) {
        vInTemplateImgFilePath = vm["inTemplatePathList"].as< std::vector<boost::filesystem::path> >();
    }
    else {
        vInTemplateImgFilePath.clear();
        vInTemplateImgFilePath.push_back(getIPSDKDirectory(eInternalDirectory::eID_Images) / "Templates/templateSquare.tif");
        vInTemplateImgFilePath.push_back(getIPSDKDirectory(eInternalDirectory::eID_Images) / "Templates/templateTriangle.tif");
        vInTemplateImgFilePath.push_back(getIPSDKDirectory(eInternalDirectory::eID_Images) / "Templates/templateHexagon.tif");
        vInTemplateImgFilePath.push_back(getIPSDKDirectory(eInternalDirectory::eID_Images) / "Templates/templateCircle.tif");
    }

    // if the user specified his own input image file path as argument...
    if (vm.count("outputImgFilePath"))
        // ... replace the default one by his own
        outImgFilePath = vm["outputImgFilePath"].as<path>();
    else {
        // ... otherwise, output image will be saved in temporary user directory
        const path outputDir =
            getIPSDKDefaultDirectory(eDefaultExternalDirectory::eDED_Tmp) /
            "Sample";

        // if output directory does not exist, we try to create it
        if (!boost::filesystem::exists(outputDir)) {
            try {
                boost::filesystem::create_directories(outputDir);
            }
            catch (const std::exception& e) {
                SAMPLE_SHAPEMATCHING2D_LOG_ERROR(
                    [eSample_ShapeMatching2dMessage::eErrorSavingImgTiffFile]
                % outputDir % e.what());
            }
        }

        // initialize output image file path with a default file path
        outImgFilePath = outputDir / "shapeMatch.tif";
    }

    // if the user specified his own input CSV file path as argument...
    if (vm.count("outputCsvResultPath"))
        // ... replace the default one by his own
        outputCsvResultPath = vm["outputCsvResultPath"].as<path>();
    else {
        // ... otherwise, output image will be saved in temporary user directory
        const path outputDir = outImgFilePath.parent_path();

        // initialize output image file path with a default file path
        outputCsvResultPath = outputDir / "shapeMatch.csv";
    }

    // if the user specified his own input binarization threshold as argument...
    if (vm.count("inThresholdBinarization")) {
        thresholdBinarization = vm["inThresholdBinarization"].as<ipReal64>();
    }
    else thresholdBinarization = 15;

    // if the user specified his own input distance threshold as argument...
    if (vm.count("inThresholdDistance")) {
        thresholdDistance = vm["inThresholdDistance"].as<ipReal64>();
    }
    else thresholdDistance = 0.2;

    // if the user specified his own input Gaussian blurring standard deviation path as argument...
    if (vm.count("inStdDev")) {
        stdDev = vm["inStdDev"].as<ipReal32>();
    }
    else stdDev = 1.f;

    return true;
}