TEST_F() [10/72]

SpicesTest::TEST_F	(	kd_tree_test	,
		NearestNeighbourSearch	)

Testing if NearestNeighbourSearch successfully.

Search for specific points.

Definition at line 104 of file KDTree_test.h.

                                                 {
 
        SPICESTEST_PROFILE_FUNCTION();
 
        scl::kd_tree<2>::item val = { 2, 2 };
 
        EXPECT_EQ(m_KDTree.nearest_neighbour_search({ 2.0, 0.0 }, { 3.0, 3.0 }), val);
 
        constexpr int nPoints  = 1000;
        constexpr int nSearchs = 1000;
        scl::kd_tree<3> modelKDTree;
        std::vector<scl::kd_tree<3>::item> points;
        const scl::kd_tree<3>::item findVal = { 50.2f, 87.3f, 12.6f };
 
        {
            SPICESTEST_PROFILE_SCOPE("Create Points Collection.");
 
            points.resize(nPoints);
            for (int i = 0; i < nPoints; i++)
            {
                points[i][0] = std::rand() / float(RAND_MAX) * 100.0f;
                points[i][1] = std::rand() / float(RAND_MAX) * 100.0f;
                points[i][2] = std::rand() / float(RAND_MAX) * 100.0f;
            }
        }
 
        {
            SPICESTEST_PROFILE_SCOPE("Insert to KDTree");
 
            Spices::ThreadPool threadPool;
            threadPool.SetMode(Spices::PoolMode::MODE_FIXED);
            threadPool.Start(10);
            modelKDTree.insert_async(points, &threadPool);
            EXPECT_EQ(modelKDTree.size(), nPoints);
        }
 
        {
            SPICESTEST_PROFILE_SCOPE("Search in KDTree");
 
            for (int i = 0; i < nSearchs; i++)
            {
                auto rval = modelKDTree.nearest_neighbour_search(findVal, { 10.0f, 10.0f, 10.0f });
                bool check = 10.0f - std::abs(rval[0] - findVal[0]) > 0.0f;
                EXPECT_EQ(check, true);
            }
        }
 
#if 1
 
        {
            SPICESTEST_PROFILE_SCOPE("Search in Loop");
 
            for (int i = 0; i < nSearchs; i++)
            {
                scl::kd_tree<3>::item nearVal = { 1E11, 1E11, 1E11 };
 
                for (int j = 0; j < nPoints; j++)
                {
                    if (std::abs(points[j][0] - findVal[0]) < nearVal[0] &&
                        std::abs(points[j][1] - findVal[1]) < nearVal[1] && 
                        std::abs(points[j][2] - findVal[2]) < nearVal[2])
                    {
                        nearVal = points[j];
                    }
                }
 
                bool check = 10.0f - nearVal[0] > 0.0f;
                EXPECT_EQ(check, true);
            }
        }
 
#endif
 
    }