IO.cpp

Go to the documentation of this file.

#include "../utest.h"

using namespace std;
using namespace PointMatcherSupport;

//---------------------------
// Tests for IO
//---------------------------

TEST(IOTest, loadYaml)
{

        // Test loading configuration files for data filters
        std::ifstream ifs0((dataPath + "default-convert.yaml").c_str());
        EXPECT_NO_THROW(PM::DataPointsFilters filters(ifs0));

        // Test loading configuration files for ICP
        PM::ICP icp;

        std::ifstream ifs1((dataPath + "default.yaml").c_str());
        EXPECT_NO_THROW(icp.loadFromYaml(ifs1));

        std::ifstream ifs2((dataPath + "unit_tests/badIcpConfig_InvalidParameter.yaml").c_str());
        EXPECT_THROW(icp.loadFromYaml(ifs2), PointMatcherSupport::Parametrizable::InvalidParameter);
        
        std::ifstream ifs3((dataPath + "unit_tests/badIcpConfig_InvalidModuleType.yaml").c_str());
        EXPECT_THROW(icp.loadFromYaml(ifs3), PointMatcherSupport::InvalidModuleType);
}

TEST(IOTest, loadPLY)
{
        typedef PointMatcherIO<float> IO;
        std::istringstream is;
        
        is.str(
        ""
        );

        EXPECT_THROW(IO::loadPLY(is), runtime_error);

        is.clear();
        is.str(
        "ply\n"
        "format binary_big_endian 1.0\n"
        );

        EXPECT_THROW(IO::loadPLY(is), runtime_error);
        
        is.clear();
        is.str(
        "ply\n"
        "format ascii 2.0\n"
        );
        
        EXPECT_THROW(IO::loadPLY(is), runtime_error);

        is.clear();
        is.str(
        "ply\n"
        "format ascii 1.0\n"
        );
        
        EXPECT_THROW(IO::loadPLY(is), runtime_error);

        is.clear();
        is.str(
        "ply\n"
        "format ascii 1.0\n"
        "element vertex 5\n"
        "\n" //empty line
        "property float z\n" // wrong order
        "property float y\n"
        "property float x\n"
        "property float grrrr\n" //unknown property
        "property float nz\n" // wrong order
        "property float ny\n"
        "property float nx\n"
        "end_header\n"
        "3 2 1 99 33 22 11\n"
        "3 2 1 99 33 22 11\n"
        "\n" //empty line
        "3 2 1 99 33 22 11 3 2 1 99 33 22 11\n" // no line break
        "3 2 1 99 33 22 11\n"

        );
        
        DP pointCloud = IO::loadPLY(is);
        
        // Confirm sizes and dimensions
        EXPECT_TRUE(pointCloud.features.cols() == 5);
        EXPECT_TRUE(pointCloud.features.rows() == 4);
        EXPECT_TRUE(pointCloud.descriptors.cols() == 5);
        EXPECT_TRUE(pointCloud.descriptors.rows() == 3);
        
        // Random value check
        EXPECT_TRUE(pointCloud.features(0, 0) == 1);
        EXPECT_TRUE(pointCloud.features(2, 2) == 3);
        EXPECT_TRUE(pointCloud.descriptors(1, 1) == 22);
        EXPECT_TRUE(pointCloud.descriptors(2, 4) == 33);

}

class IOLoadSaveTest : public testing::Test
{

public:
        virtual void SetUp()
        {
                nbPts = 10;
                addRandomFeature("x", 1);
                addRandomFeature("y", 1);
                addRandomFeature("z", 1);
                ptCloud.addFeature("pad", PM::Matrix::Ones(1, nbPts));

                addRandomDescriptor("normals",3);
                addRandomDescriptor("eigValues",3);
                addRandomDescriptor("eigVectors",9);
                addRandomDescriptor("color",4);
        }

        void addRandomFeature(const string& featureName, const int rows)
        {
                ptCloud.addFeature(featureName,PM::Matrix::Random(rows, nbPts));
        }

        void addRandomDescriptor(const string& descriptorName, const int rows)
        {
                ptCloud.addDescriptor(descriptorName, PM::Matrix::Random(rows, nbPts));
        }

        virtual void loadSaveTest(const string& testFileName, bool plyFormat = false, const int nbPts = 10)
        {
                this->testFileName = testFileName;

                if (plyFormat) {
                        // make sure randam values generated for colors are within ply format range
                        int pointCount(ptCloud.features.cols());
                        int descRows(ptCloud.descriptors.rows());
                        bool datawithColor = ptCloud.descriptorExists("color");
                        int colorStartingRow = ptCloud.getDescriptorStartingRow("color");
                        int colorEndRow = colorStartingRow + ptCloud.getDescriptorDimension("color");
                        for (int p = 0; p < pointCount; ++p)
                        {
                                for (int d = 0; d < descRows; ++d)
                                {
                                        if (datawithColor && d >= colorStartingRow && d < colorEndRow) {
                                                if (ptCloud.descriptors(d, p) < 0) { ptCloud.descriptors.coeffRef(d, p) = -(ptCloud.descriptors(d, p)); }
                                                ptCloud.descriptors.coeffRef(d, p) = (static_cast<unsigned>(ptCloud.descriptors(d, p) * 255.0)) / 255.0;
                                        }
                                }
                        }
                }

                ptCloud.save(testFileName);

                ptCloudFromFile = DP::load(testFileName);

                EXPECT_TRUE(ptCloudFromFile.features.cols() == ptCloud.features.cols());
                EXPECT_TRUE(ptCloudFromFile.descriptorExists("normals",3));
                EXPECT_TRUE(ptCloudFromFile.getDescriptorViewByName("normals").isApprox(ptCloud.getDescriptorViewByName("normals")));
                EXPECT_TRUE(ptCloudFromFile.descriptorExists("eigValues",3));
                EXPECT_TRUE(ptCloudFromFile.getDescriptorViewByName("eigValues").isApprox(ptCloud.getDescriptorViewByName("eigValues")));
                EXPECT_TRUE(ptCloudFromFile.descriptorExists("eigVectors",9));
                EXPECT_TRUE(ptCloudFromFile.getDescriptorViewByName("eigVectors").isApprox(ptCloud.getDescriptorViewByName("eigVectors")));
                EXPECT_TRUE(ptCloudFromFile.descriptorExists("color",4));
                if (plyFormat) {
                        EXPECT_TRUE(((ptCloudFromFile.getDescriptorViewByName("color") * 255.0)).isApprox((ptCloud.getDescriptorViewByName("color") * 255.0), 1.0));
                } else {
                        EXPECT_TRUE(ptCloudFromFile.getDescriptorViewByName("color").isApprox(ptCloud.getDescriptorViewByName("color")));
                }

                EXPECT_TRUE(ptCloudFromFile.features.isApprox(ptCloud.features));

        }

        virtual void TearDown()
        {
                EXPECT_TRUE(boost::filesystem::remove(boost::filesystem::path(testFileName)));
        }


protected:
        int nbPts;
        DP::Labels featureLabels;
        DP ptCloud;
        DP ptCloudFromFile;
        string testFileName;

};

TEST_F(IOLoadSaveTest, VTK)
{
        ptCloud.addDescriptor("genericScalar", PM::Matrix::Random(1, nbPts));
        ptCloud.addDescriptor("genericVector", PM::Matrix::Random(3, nbPts));

        loadSaveTest(dataPath + "unit_test.vtk");

        EXPECT_TRUE(ptCloudFromFile.descriptorExists("genericScalar",1));
        EXPECT_TRUE(ptCloudFromFile.descriptorExists("genericVector",3));

}

TEST_F(IOLoadSaveTest, PLY)
{
        loadSaveTest(dataPath + "unit_test.ply", true);
}

TEST_F(IOLoadSaveTest, PCD)
{
        loadSaveTest(dataPath + "unit_test.pcd");
}

TEST_F(IOLoadSaveTest, CSV)
{
        loadSaveTest(dataPath + "unit_test.csv");
}