DataPoints.cpp

Go to the documentation of this file.

#include "../utest.h"

using namespace std;
using namespace PointMatcherSupport;

//---------------------------
// Point-cloud structures
//---------------------------

TEST(PointCloudTest, CopyConstructor2D)
{
        const DP ref2DCopy(ref2D);
        EXPECT_TRUE(ref2DCopy.features == ref2D.features);
        EXPECT_TRUE(ref2DCopy.featureLabels == ref2D.featureLabels);
        EXPECT_TRUE(ref2DCopy.descriptors == ref2D.descriptors);
        EXPECT_TRUE(ref2DCopy.descriptorLabels == ref2D.descriptorLabels);
        EXPECT_TRUE(ref2DCopy == ref2D);
}


TEST(PointCloudTest, FeatureConstructor2D)
{
        const DP ref2DCopy(ref2D.features, ref2D.featureLabels);
        EXPECT_TRUE(ref2DCopy.features == ref2D.features);
        EXPECT_TRUE(ref2DCopy.featureLabels == ref2D.featureLabels);
        EXPECT_TRUE(ref2DCopy == ref2D);
        EXPECT_TRUE(ref2DCopy.descriptors.rows() == 0);
        EXPECT_TRUE(ref2DCopy.descriptors.cols() == 0);
}

TEST(PointCloudTest, FeatureConstructor3D)
{
        // Note: this test cover also the operator ==

        DP ref3DCopy = DP();
        EXPECT_TRUE(ref3DCopy.features.rows() == 0);
        EXPECT_TRUE(ref3DCopy.features.cols() == 0);
        EXPECT_TRUE(ref3DCopy.descriptors.rows() == 0);
        EXPECT_TRUE(ref3DCopy.descriptors.cols() == 0);


        ref3DCopy = DP(ref3D.features, ref3D.featureLabels);
        EXPECT_TRUE(ref3DCopy.features == ref3D.features);
        EXPECT_TRUE(ref3DCopy.featureLabels == ref3D.featureLabels);
        
        // descriptor missing in ref3DCopy
        EXPECT_FALSE(ref3DCopy == ref3D); 
        
        EXPECT_TRUE(ref3DCopy.descriptors.rows() == 0);
        EXPECT_TRUE(ref3DCopy.descriptors.cols() == 0);

        ref3DCopy = DP(ref3D.features, ref3D.featureLabels, ref3D.descriptors, ref3D.descriptorLabels);
        
        EXPECT_TRUE(ref3DCopy.features == ref3D.features);
        EXPECT_TRUE(ref3DCopy.featureLabels == ref3D.featureLabels);
        EXPECT_TRUE(ref3DCopy.descriptors== ref3D.descriptors);
        EXPECT_TRUE(ref3DCopy.descriptorLabels == ref3D.descriptorLabels);
        

        EXPECT_TRUE(ref3DCopy == ref3D); 
        
        ref3DCopy = DP(ref3D);
        
        EXPECT_TRUE(ref3DCopy.features == ref3D.features);
        EXPECT_TRUE(ref3DCopy.featureLabels == ref3D.featureLabels);
        EXPECT_TRUE(ref3DCopy.descriptors== ref3D.descriptors);
        EXPECT_TRUE(ref3DCopy.descriptorLabels == ref3D.descriptorLabels);
        

        EXPECT_TRUE(ref3DCopy == ref3D);
}

TEST(PointCloudTest, ConcatenateFeatures2D)
{
        const int leftPoints(ref2D.features.cols() / 2);
        const int rightPoints(ref2D.features.cols() - leftPoints);
        DP lefts(
                ref2D.features.leftCols(leftPoints),
                ref2D.featureLabels
        );
        DP rights(
                ref2D.features.rightCols(rightPoints),
                ref2D.featureLabels
        );
        lefts.concatenate(rights);
        EXPECT_TRUE(lefts == ref2D);
}

TEST(PointCloudTest, ConcatenateFeatures3D)
{
        const int leftPoints(ref3D.features.cols() / 2);
        const int rightPoints(ref3D.features.cols() - leftPoints);
        DP lefts(
                ref3D.features.leftCols(leftPoints),
                ref3D.featureLabels
        );
        DP rights(
                ref3D.features.rightCols(rightPoints),
                ref3D.featureLabels
        );
        lefts.concatenate(rights);
        EXPECT_TRUE(lefts.features == ref3D.features);
}

TEST(PointCloudTest, ConcatenateDescSame)
{
        typedef DP::Label Label;
        typedef DP::Labels Labels;
        
        const int leftPoints(ref2D.features.cols() / 2);
        const int rightPoints(ref2D.features.cols() - leftPoints);
        DP lefts(
                ref2D.features.leftCols(leftPoints),
                ref2D.featureLabels,
                PM::Matrix::Random(5, leftPoints),
                Labels(Label("Desc5D", 5))
        );
        DP rights(
                ref2D.features.rightCols(rightPoints),
                ref2D.featureLabels,
                PM::Matrix::Random(5, rightPoints),
                Labels(Label("Desc5D", 5))
        );
        lefts.concatenate(rights);
        EXPECT_TRUE(lefts.descriptors.rows() == 5);
        EXPECT_TRUE(lefts.descriptors.cols() == lefts.features.cols());
}

TEST(PointCloudTest, ConcatenateDescSame2)
{
        typedef DP::Label Label;
        typedef DP::Labels Labels;
        
        DP ref3DCopy(ref3D.features, ref3D.featureLabels);
        ref3DCopy.descriptorLabels.push_back(Label("Desc5D", 5));
        ref3DCopy.descriptors = PM::Matrix::Random(5, ref3DCopy.features.cols());
        
        const int leftPoints(ref3DCopy.features.cols() / 2);
        const int rightPoints(ref3DCopy.features.cols() - leftPoints);
        DP lefts(
                ref3DCopy.features.leftCols(leftPoints),
                ref3DCopy.featureLabels,
                ref3DCopy.descriptors.leftCols(leftPoints),
                ref3DCopy.descriptorLabels
        );
        DP rights(
                ref3DCopy.features.rightCols(rightPoints),
                ref3DCopy.featureLabels,
                ref3DCopy.descriptors.rightCols(rightPoints),
                ref3DCopy.descriptorLabels
        );
        lefts.concatenate(rights);
        EXPECT_TRUE(lefts == ref3DCopy);
}

TEST(PointCloudTest, ConcatenateDescDiffName)
{
        typedef DP::Label Label;
        typedef DP::Labels Labels;
        
        const int leftPoints(ref2D.features.cols() / 2);
        const int rightPoints(ref2D.features.cols() - leftPoints);
        DP lefts(
                ref2D.features.leftCols(leftPoints),
                ref2D.featureLabels,
                PM::Matrix::Random(5, leftPoints),
                Labels(Label("MyDesc5D", 5))
        );
        DP rights(
                ref2D.features.rightCols(rightPoints),
                ref2D.featureLabels,
                PM::Matrix::Random(5, rightPoints),
                Labels(Label("YourDesc5D", 5))
        );
        lefts.concatenate(rights);
        EXPECT_TRUE(lefts.descriptors.rows() == 0);
        EXPECT_TRUE(lefts.descriptors.cols() == 0);
}

TEST(PointCloudTest, ConcatenateDescDiffSize)
{
        typedef DP::Label Label;
        typedef DP::Labels Labels;
        
        const int leftPoints(ref2D.features.cols() / 2);
        const int rightPoints(ref2D.features.cols() - leftPoints);
        DP lefts(
                ref2D.features.leftCols(leftPoints),
                ref2D.featureLabels,
                PM::Matrix::Random(3, leftPoints),
                Labels(Label("DescND", 3))
        );
        DP rights(
                ref2D.features.rightCols(rightPoints),
                ref2D.featureLabels,
                PM::Matrix::Random(5, rightPoints),
                Labels(Label("DescND", 5))
        );
        EXPECT_THROW(lefts.concatenate(rights), DP::InvalidField);
}

TEST(PointCloudTest, GetInfo)
{
        //cerr << ref2D.features.rows() << endl;
        //cerr << ref2D.features.cols() << endl;
        //cerr << ref2D.descriptors.rows() << endl;
        //cerr << ref2D.descriptors.cols() << endl;
        
        EXPECT_EQ(ref3D.getNbPoints(), 24989u);
        EXPECT_EQ(ref3D.getEuclideanDim(), 3u);
        EXPECT_EQ(ref3D.getHomogeneousDim(), 4u);
        EXPECT_EQ(ref3D.getNbGroupedDescriptors(), 1u);
        EXPECT_EQ(ref3D.getDescriptorDim(), 3u);
        
        EXPECT_EQ(ref2D.getNbPoints(), 361u);
        EXPECT_EQ(ref2D.getEuclideanDim(), 2u);
        EXPECT_EQ(ref2D.getHomogeneousDim(), 3u);
        EXPECT_EQ(ref2D.getNbGroupedDescriptors(), 0u);
        EXPECT_EQ(ref2D.getDescriptorDim(), 0u);

}

TEST(PointCloudTest, AddRemove)
{
        DP ref3DCopy = ref3D;
        const int testedValue = 9;

        PM::Matrix newFeature = PM::Matrix::Ones(1,ref3DCopy.getNbPoints())*testedValue;
        ref3DCopy.addFeature("testF", newFeature);

        //Is the new row added?
        EXPECT_EQ(ref3DCopy.getHomogeneousDim(), ref3D.getHomogeneousDim()+1);
        
        //Is padding still at the end?
        EXPECT_EQ(ref3DCopy.featureLabels.back().text, "pad");

        //Is the value right?
        DP::View newFeatureView = ref3DCopy.getFeatureViewByName("testF");
        EXPECT_EQ(newFeatureView(0,0), testedValue);

        ref3DCopy.removeFeature("testF");

        // Is the extra data removed?
        EXPECT_TRUE(ref3DCopy.features.isApprox(ref3D.features));


        const int testedValue2 = 88;
        PM::Matrix newDescriptor4D = PM::Matrix::Ones(4,ref3DCopy.getNbPoints())*testedValue;
        PM::Matrix newDescriptor2D = PM::Matrix::Ones(2,ref3DCopy.getNbPoints())*testedValue2;

        ref3DCopy.addDescriptor("test4D", newDescriptor4D);
        ref3DCopy.addDescriptor("test2D", newDescriptor2D);
        
        //Is the new row added?
        EXPECT_EQ(ref3DCopy.getDescriptorDim(), ref3D.getDescriptorDim()+6);
        EXPECT_EQ(ref3DCopy.getNbGroupedDescriptors(), ref3D.getNbGroupedDescriptors()+2);

        //Is the value right?
        DP::View newDescriptor4DView = ref3DCopy.getDescriptorViewByName("test4D");
        EXPECT_EQ(newDescriptor4DView(0,0), testedValue);
        DP::View newDescriptor2DView = ref3DCopy.getDescriptorViewByName("test2D");
        EXPECT_EQ(newDescriptor2DView(0,0), testedValue2);


        ref3DCopy.removeDescriptor("test4D");
        ref3DCopy.removeDescriptor("test2D");
        
        //removing random name shoudn't have any effect
        ref3DCopy.removeDescriptor("grrrrr");

        // Is the extra data removed?
        EXPECT_TRUE(ref3DCopy.descriptors.isApprox(ref3D.descriptors));

}