diff --git a/code/Common/SpatialSort.cpp b/code/Common/SpatialSort.cpp index a32ff5f90..352a36fba 100644 --- a/code/Common/SpatialSort.cpp +++ b/code/Common/SpatialSort.cpp @@ -5,8 +5,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -50,71 +48,64 @@ using namespace Assimp; // CHAR_BIT seems to be defined under MVSC, but not under GCC. Pray that the correct value is 8. #ifndef CHAR_BIT -# define CHAR_BIT 8 +#define CHAR_BIT 8 #endif #ifdef _WIN32 -# pragma warning(disable : 4127) +//# pragma warning(disable : 4127) #endif // _WIN32 -// ------------------------------------------------------------------------------------------------ -// Constructs a spatially sorted representation from the given position array. -SpatialSort::SpatialSort( const aiVector3D* pPositions, unsigned int pNumPositions, - unsigned int pElementOffset) +const aiVector3D PlaneInit( 0.8523f, 0.34321f, 0.5736f ); - // define the reference plane. We choose some arbitrary vector away from all basic axises - // in the hope that no model spreads all its vertices along this plane. - : mPlaneNormal(0.8523f, 0.34321f, 0.5736f) -{ + // ------------------------------------------------------------------------------------------------ +// Constructs a spatially sorted representation from the given position array. +// define the reference plane. We choose some arbitrary vector away from all basic axises +// in the hope that no model spreads all its vertices along this plane. +SpatialSort::SpatialSort(const aiVector3D *pPositions, unsigned int pNumPositions, unsigned int pElementOffset) : + mPlaneNormal(PlaneInit) { mPlaneNormal.Normalize(); - Fill(pPositions,pNumPositions,pElementOffset); + Fill(pPositions, pNumPositions, pElementOffset); } // ------------------------------------------------------------------------------------------------ -SpatialSort :: SpatialSort() -: mPlaneNormal(0.8523f, 0.34321f, 0.5736f) -{ +SpatialSort::SpatialSort() : + mPlaneNormal(PlaneInit) { mPlaneNormal.Normalize(); } // ------------------------------------------------------------------------------------------------ // Destructor -SpatialSort::~SpatialSort() -{ - // nothing to do here, everything destructs automatically +SpatialSort::~SpatialSort() { + // empty } // ------------------------------------------------------------------------------------------------ -void SpatialSort::Fill( const aiVector3D* pPositions, unsigned int pNumPositions, - unsigned int pElementOffset, - bool pFinalize /*= true */) -{ +void SpatialSort::Fill(const aiVector3D *pPositions, unsigned int pNumPositions, + unsigned int pElementOffset, + bool pFinalize /*= true */) { mPositions.clear(); - Append(pPositions,pNumPositions,pElementOffset,pFinalize); + Append(pPositions, pNumPositions, pElementOffset, pFinalize); } // ------------------------------------------------------------------------------------------------ -void SpatialSort :: Finalize() -{ - std::sort( mPositions.begin(), mPositions.end()); +void SpatialSort::Finalize() { + std::sort(mPositions.begin(), mPositions.end()); } // ------------------------------------------------------------------------------------------------ -void SpatialSort::Append( const aiVector3D* pPositions, unsigned int pNumPositions, - unsigned int pElementOffset, - bool pFinalize /*= true */) -{ +void SpatialSort::Append(const aiVector3D *pPositions, unsigned int pNumPositions, + unsigned int pElementOffset, + bool pFinalize /*= true */) { // store references to all given positions along with their distance to the reference plane const size_t initial = mPositions.size(); - mPositions.reserve(initial + (pFinalize?pNumPositions:pNumPositions*2)); - for( unsigned int a = 0; a < pNumPositions; a++) - { - const char* tempPointer = reinterpret_cast (pPositions); - const aiVector3D* vec = reinterpret_cast (tempPointer + a * pElementOffset); + mPositions.reserve(initial + (pFinalize ? pNumPositions : pNumPositions * 2)); + for (unsigned int a = 0; a < pNumPositions; a++) { + const char *tempPointer = reinterpret_cast(pPositions); + const aiVector3D *vec = reinterpret_cast(tempPointer + a * pElementOffset); // store position by index and distance ai_real distance = *vec * mPlaneNormal; - mPositions.push_back( Entry( static_cast(a+initial), *vec, distance)); + mPositions.push_back(Entry(static_cast(a + initial), *vec, distance)); } if (pFinalize) { @@ -125,9 +116,8 @@ void SpatialSort::Append( const aiVector3D* pPositions, unsigned int pNumPositio // ------------------------------------------------------------------------------------------------ // Returns an iterator for all positions close to the given position. -void SpatialSort::FindPositions( const aiVector3D& pPosition, - ai_real pRadius, std::vector& poResults) const -{ +void SpatialSort::FindPositions(const aiVector3D &pPosition, + ai_real pRadius, std::vector &poResults) const { const ai_real dist = pPosition * mPlaneNormal; const ai_real minDist = dist - pRadius, maxDist = dist + pRadius; @@ -135,19 +125,18 @@ void SpatialSort::FindPositions( const aiVector3D& pPosition, poResults.clear(); // quick check for positions outside the range - if( mPositions.size() == 0) + if (mPositions.size() == 0) return; - if( maxDist < mPositions.front().mDistance) + if (maxDist < mPositions.front().mDistance) return; - if( minDist > mPositions.back().mDistance) + if (minDist > mPositions.back().mDistance) return; // do a binary search for the minimal distance to start the iteration there unsigned int index = (unsigned int)mPositions.size() / 2; unsigned int binaryStepSize = (unsigned int)mPositions.size() / 4; - while( binaryStepSize > 1) - { - if( mPositions[index].mDistance < minDist) + while (binaryStepSize > 1) { + if (mPositions[index].mDistance < minDist) index += binaryStepSize; else index -= binaryStepSize; @@ -157,21 +146,20 @@ void SpatialSort::FindPositions( const aiVector3D& pPosition, // depending on the direction of the last step we need to single step a bit back or forth // to find the actual beginning element of the range - while( index > 0 && mPositions[index].mDistance > minDist) + while (index > 0 && mPositions[index].mDistance > minDist) index--; - while( index < (mPositions.size() - 1) && mPositions[index].mDistance < minDist) + while (index < (mPositions.size() - 1) && mPositions[index].mDistance < minDist) index++; // Mow start iterating from there until the first position lays outside of the distance range. // Add all positions inside the distance range within the given radius to the result aray std::vector::const_iterator it = mPositions.begin() + index; - const ai_real pSquared = pRadius*pRadius; - while( it->mDistance < maxDist) - { - if( (it->mPosition - pPosition).SquareLength() < pSquared) - poResults.push_back( it->mIndex); + const ai_real pSquared = pRadius * pRadius; + while (it->mDistance < maxDist) { + if ((it->mPosition - pPosition).SquareLength() < pSquared) + poResults.push_back(it->mIndex); ++it; - if( it == mPositions.end()) + if (it == mPositions.end()) break; } @@ -180,70 +168,71 @@ void SpatialSort::FindPositions( const aiVector3D& pPosition, namespace { - // Binary, signed-integer representation of a single-precision floating-point value. - // IEEE 754 says: "If two floating-point numbers in the same format are ordered then they are - // ordered the same way when their bits are reinterpreted as sign-magnitude integers." - // This allows us to convert all floating-point numbers to signed integers of arbitrary size - // and then use them to work with ULPs (Units in the Last Place, for high-precision - // computations) or to compare them (integer comparisons are faster than floating-point - // comparisons on many platforms). - typedef ai_int BinFloat; +// Binary, signed-integer representation of a single-precision floating-point value. +// IEEE 754 says: "If two floating-point numbers in the same format are ordered then they are +// ordered the same way when their bits are reinterpreted as sign-magnitude integers." +// This allows us to convert all floating-point numbers to signed integers of arbitrary size +// and then use them to work with ULPs (Units in the Last Place, for high-precision +// computations) or to compare them (integer comparisons are faster than floating-point +// comparisons on many platforms). +typedef ai_int BinFloat; - // -------------------------------------------------------------------------------------------- - // Converts the bit pattern of a floating-point number to its signed integer representation. - BinFloat ToBinary( const ai_real & pValue) { +// -------------------------------------------------------------------------------------------- +// Converts the bit pattern of a floating-point number to its signed integer representation. +BinFloat ToBinary(const ai_real &pValue) { - // If this assertion fails, signed int is not big enough to store a float on your platform. - // Please correct the declaration of BinFloat a few lines above - but do it in a portable, - // #ifdef'd manner! - static_assert( sizeof(BinFloat) >= sizeof(ai_real), "sizeof(BinFloat) >= sizeof(ai_real)"); + // If this assertion fails, signed int is not big enough to store a float on your platform. + // Please correct the declaration of BinFloat a few lines above - but do it in a portable, + // #ifdef'd manner! + static_assert(sizeof(BinFloat) >= sizeof(ai_real), "sizeof(BinFloat) >= sizeof(ai_real)"); - #if defined( _MSC_VER) - // If this assertion fails, Visual C++ has finally moved to ILP64. This means that this - // code has just become legacy code! Find out the current value of _MSC_VER and modify - // the #if above so it evaluates false on the current and all upcoming VC versions (or - // on the current platform, if LP64 or LLP64 are still used on other platforms). - static_assert( sizeof(BinFloat) == sizeof(ai_real), "sizeof(BinFloat) == sizeof(ai_real)"); +#if defined(_MSC_VER) + // If this assertion fails, Visual C++ has finally moved to ILP64. This means that this + // code has just become legacy code! Find out the current value of _MSC_VER and modify + // the #if above so it evaluates false on the current and all upcoming VC versions (or + // on the current platform, if LP64 or LLP64 are still used on other platforms). + static_assert(sizeof(BinFloat) == sizeof(ai_real), "sizeof(BinFloat) == sizeof(ai_real)"); - // This works best on Visual C++, but other compilers have their problems with it. - const BinFloat binValue = reinterpret_cast(pValue); - #else - // On many compilers, reinterpreting a float address as an integer causes aliasing - // problems. This is an ugly but more or less safe way of doing it. - union { - ai_real asFloat; - BinFloat asBin; - } conversion; - conversion.asBin = 0; // zero empty space in case sizeof(BinFloat) > sizeof(float) - conversion.asFloat = pValue; - const BinFloat binValue = conversion.asBin; - #endif + // This works best on Visual C++, but other compilers have their problems with it. + const BinFloat binValue = reinterpret_cast(pValue); + //::memcpy(&binValue, &pValue, sizeof(pValue)); + //return binValue; +#else + // On many compilers, reinterpreting a float address as an integer causes aliasing + // problems. This is an ugly but more or less safe way of doing it. + union { + ai_real asFloat; + BinFloat asBin; + } conversion; + conversion.asBin = 0; // zero empty space in case sizeof(BinFloat) > sizeof(float) + conversion.asFloat = pValue; + const BinFloat binValue = conversion.asBin; +#endif - // floating-point numbers are of sign-magnitude format, so find out what signed number - // representation we must convert negative values to. - // See http://en.wikipedia.org/wiki/Signed_number_representations. + // floating-point numbers are of sign-magnitude format, so find out what signed number + // representation we must convert negative values to. + // See http://en.wikipedia.org/wiki/Signed_number_representations. - // Two's complement? - if( (-42 == (~42 + 1)) && (binValue & 0x80000000)) - return BinFloat(1 << (CHAR_BIT * sizeof(BinFloat) - 1)) - binValue; - // One's complement? - else if ( (-42 == ~42) && (binValue & 0x80000000)) - return BinFloat(-0) - binValue; - // Sign-magnitude? - else if( (-42 == (42 | (-0))) && (binValue & 0x80000000)) // -0 = 1000... binary - return binValue; - else - return binValue; - } + // Two's complement? + /*if ((-42 == (~42 + 1)) && (binValue & 0x80000000)) + return BinFloat(1 << (CHAR_BIT * sizeof(BinFloat) - 1)) - binValue; + // One's complement? + else if ((-42 == ~42) && (binValue & 0x80000000)) + return BinFloat(-0) - binValue; + // Sign-magnitude? + else if ((-42 == (42 | (-0))) && (binValue & 0x80000000)) // -0 = 1000... binary + return binValue; + else*/ + + return binValue; +} } // namespace // ------------------------------------------------------------------------------------------------ // Fills an array with indices of all positions identical to the given position. In opposite to // FindPositions(), not an epsilon is used but a (very low) tolerance of four floating-point units. -void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition, - std::vector& poResults) const -{ +void SpatialSort::FindIdenticalPositions(const aiVector3D &pPosition, std::vector &poResults) const { // Epsilons have a huge disadvantage: they are of constant precision, while floating-point // values are of log2 precision. If you apply e=0.01 to 100, the epsilon is rather small, but // if you apply it to 0.001, it is enormous. @@ -269,20 +258,19 @@ void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition, // Convert the plane distance to its signed integer representation so the ULPs tolerance can be // applied. For some reason, VC won't optimize two calls of the bit pattern conversion. - const BinFloat minDistBinary = ToBinary( pPosition * mPlaneNormal) - distanceToleranceInULPs; + const BinFloat minDistBinary = ToBinary(pPosition * mPlaneNormal) - distanceToleranceInULPs; const BinFloat maxDistBinary = minDistBinary + 2 * distanceToleranceInULPs; // clear the array in this strange fashion because a simple clear() would also deallocate // the array which we want to avoid - poResults.resize( 0 ); + poResults.resize(0); // do a binary search for the minimal distance to start the iteration there unsigned int index = (unsigned int)mPositions.size() / 2; unsigned int binaryStepSize = (unsigned int)mPositions.size() / 4; - while( binaryStepSize > 1) - { + while (binaryStepSize > 1) { // Ugly, but conditional jumps are faster with integers than with floats - if( minDistBinary > ToBinary(mPositions[index].mDistance)) + if (minDistBinary > ToBinary(mPositions[index].mDistance)) index += binaryStepSize; else index -= binaryStepSize; @@ -292,20 +280,19 @@ void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition, // depending on the direction of the last step we need to single step a bit back or forth // to find the actual beginning element of the range - while( index > 0 && minDistBinary < ToBinary(mPositions[index].mDistance) ) + while (index > 0 && minDistBinary < ToBinary(mPositions[index].mDistance)) index--; - while( index < (mPositions.size() - 1) && minDistBinary > ToBinary(mPositions[index].mDistance)) + while (index < (mPositions.size() - 1) && minDistBinary > ToBinary(mPositions[index].mDistance)) index++; // Now start iterating from there until the first position lays outside of the distance range. // Add all positions inside the distance range within the tolerance to the result array std::vector::const_iterator it = mPositions.begin() + index; - while( ToBinary(it->mDistance) < maxDistBinary) - { - if( distance3DToleranceInULPs >= ToBinary((it->mPosition - pPosition).SquareLength())) + while (ToBinary(it->mDistance) < maxDistBinary) { + if (distance3DToleranceInULPs >= ToBinary((it->mPosition - pPosition).SquareLength())) poResults.push_back(it->mIndex); ++it; - if( it == mPositions.end()) + if (it == mPositions.end()) break; } @@ -313,22 +300,19 @@ void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition, } // ------------------------------------------------------------------------------------------------ -unsigned int SpatialSort::GenerateMappingTable(std::vector& fill, ai_real pRadius) const -{ - fill.resize(mPositions.size(),UINT_MAX); +unsigned int SpatialSort::GenerateMappingTable(std::vector &fill, ai_real pRadius) const { + fill.resize(mPositions.size(), UINT_MAX); ai_real dist, maxDist; - unsigned int t=0; - const ai_real pSquared = pRadius*pRadius; + unsigned int t = 0; + const ai_real pSquared = pRadius * pRadius; for (size_t i = 0; i < mPositions.size();) { dist = mPositions[i].mPosition * mPlaneNormal; maxDist = dist + pRadius; fill[mPositions[i].mIndex] = t; - const aiVector3D& oldpos = mPositions[i].mPosition; - for (++i; i < fill.size() && mPositions[i].mDistance < maxDist - && (mPositions[i].mPosition - oldpos).SquareLength() < pSquared; ++i) - { + const aiVector3D &oldpos = mPositions[i].mPosition; + for (++i; i < fill.size() && mPositions[i].mDistance < maxDist && (mPositions[i].mPosition - oldpos).SquareLength() < pSquared; ++i) { fill[mPositions[i].mIndex] = t; } ++t; @@ -338,7 +322,7 @@ unsigned int SpatialSort::GenerateMappingTable(std::vector& fill, // debug invariant: mPositions[i].mIndex values must range from 0 to mPositions.size()-1 for (size_t i = 0; i < fill.size(); ++i) { - ai_assert(fill[i] #include +#include namespace Assimp { @@ -62,10 +62,8 @@ namespace Assimp { * time, with O(n) worst case complexity when all vertices lay on the plane. The plane is chosen * so that it avoids common planes in usual data sets. */ // ------------------------------------------------------------------------------------------------ -class ASSIMP_API SpatialSort -{ +class ASSIMP_API SpatialSort { public: - SpatialSort(); // ------------------------------------------------------------------------------------ @@ -76,14 +74,12 @@ public: * @param pNumPositions Number of vectors to expect in that array. * @param pElementOffset Offset in bytes from the beginning of one vector in memory * to the beginning of the next vector. */ - SpatialSort( const aiVector3D* pPositions, unsigned int pNumPositions, - unsigned int pElementOffset); + SpatialSort(const aiVector3D *pPositions, unsigned int pNumPositions, + unsigned int pElementOffset); /** Destructor */ ~SpatialSort(); -public: - // ------------------------------------------------------------------------------------ /** Sets the input data for the SpatialSort. This replaces existing data, if any. * The new data receives new indices in ascending order. @@ -97,17 +93,15 @@ public: * required in order to use #FindPosition() or #GenerateMappingTable(). * If you don't finalize yet, you can use #Append() to add data from * other sources.*/ - void Fill( const aiVector3D* pPositions, unsigned int pNumPositions, - unsigned int pElementOffset, - bool pFinalize = true); - + void Fill(const aiVector3D *pPositions, unsigned int pNumPositions, + unsigned int pElementOffset, + bool pFinalize = true); // ------------------------------------------------------------------------------------ /** Same as #Fill(), except the method appends to existing data in the #SpatialSort. */ - void Append( const aiVector3D* pPositions, unsigned int pNumPositions, - unsigned int pElementOffset, - bool pFinalize = true); - + void Append(const aiVector3D *pPositions, unsigned int pNumPositions, + unsigned int pElementOffset, + bool pFinalize = true); // ------------------------------------------------------------------------------------ /** Finalize the spatial hash data structure. This can be useful after @@ -123,8 +117,8 @@ public: * @param poResults The container to store the indices of the found positions. * Will be emptied by the call so it may contain anything. * @return An iterator to iterate over all vertices in the given area.*/ - void FindPositions( const aiVector3D& pPosition, ai_real pRadius, - std::vector& poResults) const; + void FindPositions(const aiVector3D &pPosition, ai_real pRadius, + std::vector &poResults) const; // ------------------------------------------------------------------------------------ /** Fills an array with indices of all positions identical to the given position. In @@ -133,8 +127,8 @@ public: * @param pPosition The position to look for vertices. * @param poResults The container to store the indices of the found positions. * Will be emptied by the call so it may contain anything.*/ - void FindIdenticalPositions( const aiVector3D& pPosition, - std::vector& poResults) const; + void FindIdenticalPositions(const aiVector3D &pPosition, + std::vector &poResults) const; // ------------------------------------------------------------------------------------ /** Compute a table that maps each vertex ID referring to a spatially close @@ -144,8 +138,8 @@ public: * @param pRadius Maximal distance from the position a vertex may have to * be counted in. * @return Number of unique vertices (n). */ - unsigned int GenerateMappingTable(std::vector& fill, - ai_real pRadius) const; + unsigned int GenerateMappingTable(std::vector &fill, + ai_real pRadius) const; protected: /** Normal of the sorting plane, normalized. The center is always at (0, 0, 0) */ @@ -159,15 +153,17 @@ protected: ai_real mDistance; ///< Distance of this vertex to the sorting plane Entry() AI_NO_EXCEPT - : mIndex( 999999999 ), mPosition(), mDistance( 99999. ) { - // empty + : mIndex(999999999), + mPosition(), + mDistance(99999.) { + // empty } - Entry( unsigned int pIndex, const aiVector3D& pPosition, ai_real pDistance) - : mIndex( pIndex), mPosition( pPosition), mDistance( pDistance) { + Entry(unsigned int pIndex, const aiVector3D &pPosition, ai_real pDistance) : + mIndex(pIndex), mPosition(pPosition), mDistance(pDistance) { // empty } - bool operator < (const Entry& e) const { return mDistance < e.mDistance; } + bool operator<(const Entry &e) const { return mDistance < e.mDistance; } }; // all positions, sorted by distance to the sorting plane diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index fac246d68..bf6694845 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -86,6 +86,7 @@ SET( COMMON unit/utStringUtils.cpp unit/Common/uiScene.cpp unit/Common/utLineSplitter.cpp + unit/Common/utSpatialSort.cpp ) SET( IMPORTERS diff --git a/test/unit/Common/utSpatialSort.cpp b/test/unit/Common/utSpatialSort.cpp new file mode 100644 index 000000000..0783cf5e2 --- /dev/null +++ b/test/unit/Common/utSpatialSort.cpp @@ -0,0 +1,84 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (assimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2020, assimp team + +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the following +conditions are met: + +* Redistributions of source code must retain the above +copyright notice, this list of conditions and the +following disclaimer. + +* Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the +following disclaimer in the documentation and/or other +materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its +contributors may be used to endorse or promote products +derived from this software without specific prior +written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--------------------------------------------------------------------------- +*/ +#include "UnitTestPCH.h" + +#include + +using namespace Assimp; + +class utSpatialSort : public ::testing::Test { +public + : + aiVector3D *vecs; + +protected: + void SetUp() override { + ::srand(static_cast(time(0))); + vecs = new aiVector3D[100]; + for (size_t i = 0; i < 100; ++i) { + vecs[i].x = static_cast(rand()) / (static_cast(RAND_MAX / 100)); + vecs[i].y = static_cast(rand()) / (static_cast(RAND_MAX / 100)); + vecs[i].z = static_cast(rand()) / (static_cast(RAND_MAX / 100)); + } + } + + void TearDown() override { + delete[] vecs; + } +}; + +TEST_F( utSpatialSort, findIdenticalsTest ) { + SpatialSort sSort; + sSort.Fill(vecs, 100, sizeof(aiVector3D)); + + std::vector indices; + sSort.FindIdenticalPositions(vecs[0], indices); + EXPECT_EQ(1u, indices.size()); +} + +TEST_F(utSpatialSort, findPositionsTest) { + SpatialSort sSort; + sSort.Fill(vecs, 100, sizeof(aiVector3D)); + + std::vector indices; + sSort.FindPositions(vecs[0], 0.01f, indices); + EXPECT_EQ(1u, indices.size()); +} diff --git a/test/unit/utStringUtils.cpp b/test/unit/utStringUtils.cpp index c5493c502..cb91897e3 100644 --- a/test/unit/utStringUtils.cpp +++ b/test/unit/utStringUtils.cpp @@ -5,8 +5,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - - All rights reserved. Redistribution and use of this software in source and binary forms,