ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8014 Commits
21 Branches
19 Tags
70 MiB
Tree: 55ee67c5ca
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '55ee67c5ca'
${ noResults }
magnum/src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp

1126 lines
48 KiB
Raw Normal View History Unescape

Splitting tools from MeshBuilderBenchmark to MeshTools. Moved unit tests and benchmarks accordingly.
15 years ago
/*
This file is part of Magnum.
Updated copyright year.
7 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
Happy new year too.
12 years ago
Vladimír Vondruš <mosra@centrum.cz>
Relicensing to MIT/Expat license, part 3: source files. Added license header also to shader sources. Hopefully it won't harm compilation times too much.
13 years ago
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
Splitting tools from MeshBuilderBenchmark to MeshTools. Moved unit tests and benchmarks accordingly.
15 years ago
Relicensing to MIT/Expat license, part 3: source files. Added license header also to shader sources. Hopefully it won't harm compilation times too much.
13 years ago
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
Splitting tools from MeshBuilderBenchmark to MeshTools. Moved unit tests and benchmarks accordingly.
15 years ago
*/
MeshTools: add a soak test for removeDuplicates[Fuzzy]InPlace(). Something fishy going on in there, caused by the algorithm overwriting the key values (and the map relying on them being immutable). Interestingly enough the fuzzy variants works on GCC's libstdc++ even though the key data get changed every entry, fails only on libc++.
6 years ago
#include <algorithm>
#include <random>
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
#include <sstream>
MeshTools: implement removeDuplicatesFuzzy() for MeshData.
6 years ago
#include <Corrade/Containers/GrowableArray.h>
Making includes absolute, part 4: using absolute includes for Corrade. Also adapted to some Corrade renames.
12 years ago
#include <Corrade/TestSuite/Tester.h>
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
#include <Corrade/TestSuite/Compare/Container.h>
#include <Corrade/Utility/DebugStl.h>
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
#include <Corrade/Utility/FormatStl.h>
Splitting tools from MeshBuilderBenchmark to MeshTools. Moved unit tests and benchmarks accordingly.
15 years ago
MeshTools: put subdivide / removeDuplicates benchamrks into their tests. One less executable to build, and we need to test more variants. The original measured thing ("when to remove duplicates") is no longer really relevant. Interestingly enough the fuzzy variant isn't that much slower.
6 years ago
#include "Magnum/Math/Vector3.h"
Making includes absolute, part 5: absolute includes everywhere. The only places where they aren't absolute are: - when header is included from corresponding source file - when including headers which are not part of final installation (e.g. test-specific configuration, headers from Implementation/)
12 years ago
#include "Magnum/MeshTools/RemoveDuplicates.h"
MeshTools: add removeDuplicates() operating directly on MeshData.
6 years ago
#include "Magnum/Trade/MeshData.h"
Splitting tools from MeshBuilderBenchmark to MeshTools. Moved unit tests and benchmarks accordingly.
15 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
namespace Magnum { namespace MeshTools { namespace Test { namespace {
Splitting tools from MeshBuilderBenchmark to MeshTools. Moved unit tests and benchmarks accordingly.
15 years ago
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
struct RemoveDuplicatesTest: TestSuite::Tester {
explicit RemoveDuplicatesTest();
Got rid of header files in tests. They have no practical use and they only bloat codebase size and add maintenance burden.
14 years ago
MeshTools: add a comment to the test. So I don't spend ages searching for where the heck are the other overloads tested, if at all.
6 years ago
/* These test also the InPlace variant */
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
void removeDuplicates();
void removeDuplicatesNonContiguous();
void removeDuplicatesIntoWrongOutputSize();
MeshTools: add a comment to the test. So I don't spend ages searching for where the heck are the other overloads tested, if at all.
6 years ago
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
template<class T> void removeDuplicatesIndexedInPlace();
void removeDuplicatesIndexedInPlaceSmallType();
void removeDuplicatesIndexedInPlaceEmptyIndices();
void removeDuplicatesIndexedInPlaceEmptyIndicesVertices();
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
template<class T> void removeDuplicatesIndexedInPlaceErased();
void removeDuplicatesIndexedInPlaceErasedNonContiguous();
void removeDuplicatesIndexedInPlaceErasedWrongIndexSize();
MeshTools: doc++
6 years ago
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
template<class T> void removeDuplicatesFuzzyInPlaceOneDimension();
template<class T> void removeDuplicatesFuzzyInPlaceMoreDimensions();
template<class T> void removeDuplicatesFuzzyInPlaceInto();
MeshTools: add removeDuplicatesFuzzyInPlaceInto(). I need a variant of removeDuplicatesFuzzyInPlace() that doesn't allocate the output array but instead puts the data into a pre-existing location. The discrete / non-fuzzy variant had this already, but this one not.
6 years ago
void removeDuplicatesFuzzyInPlaceIntoWrongOutputSize();
MeshTools: deprecate remaining STL-ridden APIs. The combineIndexArrays() and combineIndexedArrays() API is replaced with a more generic combineIndexedAttributes(), and thanks to that we also don't need STL-based duplicate() and removeDuplicates().
6 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
void removeDuplicatesFuzzyStl();
MeshTools: deprecate remaining STL-ridden APIs. The combineIndexArrays() and combineIndexedArrays() API is replaced with a more generic combineIndexedAttributes(), and thanks to that we also don't need STL-based duplicate() and removeDuplicates().
6 years ago
#endif
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
template<class IndexType, class T> void removeDuplicatesFuzzyIndexedInPlace();
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
void removeDuplicatesFuzzyIndexedInPlaceSmallType();
void removeDuplicatesFuzzyIndexedInPlaceEmptyIndices();
void removeDuplicatesFuzzyIndexedInPlaceEmptyIndicesVertices();
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
template<class IndexType, class T> void removeDuplicatesFuzzyIndexedInPlaceErased();
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
void removeDuplicatesFuzzyIndexedInPlaceErasedNonContiguous();
void removeDuplicatesFuzzyIndexedInPlaceErasedWrongIndexSize();
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
MeshTools: doc++
6 years ago
/* this is additionally regression-tested in PrimitivesIcosphereTest */
MeshTools: add removeDuplicates() operating directly on MeshData.
6 years ago
void removeDuplicatesMeshData();
void removeDuplicatesMeshDataAttributeless();
MeshTools: add a soak test for removeDuplicates[Fuzzy]InPlace(). Something fishy going on in there, caused by the algorithm overwriting the key values (and the map relying on them being immutable). Interestingly enough the fuzzy variants works on GCC's libstdc++ even though the key data get changed every entry, fails only on libc++.
6 years ago
MeshTools: implement removeDuplicatesFuzzy() for MeshData.
6 years ago
void removeDuplicatesMeshDataFuzzy();
void removeDuplicatesMeshDataFuzzyDouble();
void removeDuplicatesMeshDataFuzzyAttributeless();
void removeDuplicatesMeshDataFuzzyImplementationSpecific();
MeshTools: add a soak test for removeDuplicates[Fuzzy]InPlace(). Something fishy going on in there, caused by the algorithm overwriting the key values (and the map relying on them being immutable). Interestingly enough the fuzzy variants works on GCC's libstdc++ even though the key data get changed every entry, fails only on libc++.
6 years ago
void soakTest();
void soakTestFuzzy();
MeshTools: put subdivide / removeDuplicates benchamrks into their tests. One less executable to build, and we need to test more variants. The original measured thing ("when to remove duplicates") is no longer really relevant. Interestingly enough the fuzzy variant isn't that much slower.
6 years ago
void benchmark();
void benchmarkFuzzy();
MeshTools: add removeDuplicates() operating directly on MeshData.
6 years ago
};
const struct {
const char* name;
bool indexed;
} RemoveDuplicatesMeshDataData[] {
{"", false},
{"indexed", true}
Adapted to Corrade changes. Allowing to instantiate Trade::AbstractImporter subclasses directly without plugin manager.
13 years ago
};
MeshTools: implement removeDuplicatesFuzzy() for MeshData.
6 years ago
const struct {
const char* name;
Containers::Array<Trade::MeshAttributeData> attributes;
Float offset, scale, epsilon;
UnsignedInt vertexCount;
bool indexed;
} RemoveDuplicatesMeshDataFuzzyData[] {
{"position, normal", Containers::array({
Trade::MeshAttributeData{Trade::MeshAttribute::Position,
VertexFormat::Vector3, 0, 10, 6*sizeof(Float)},
Trade::MeshAttributeData{Trade::MeshAttribute::Normal,
VertexFormat::Vector3, 3*sizeof(Float), 10, 6*sizeof(Float)}
}), 0.0f, 1.0f, Math::TypeTraits<Float>::epsilon(), 7, false},
{"position, normal, epsilon 0", Containers::array({
Trade::MeshAttributeData{Trade::MeshAttribute::Position,
VertexFormat::Vector3, 0, 10, 6*sizeof(Float)},
Trade::MeshAttributeData{Trade::MeshAttribute::Normal,
VertexFormat::Vector3, 3*sizeof(Float), 10, 6*sizeof(Float)}
/* Only the bit-exact value gets removed */
}), 0.0f, 1.0f, 0.0f, 9, false},
{"position, normal, indexed", Containers::array({
Trade::MeshAttributeData{Trade::MeshAttribute::Position,
VertexFormat::Vector3, 0, 10, 6*sizeof(Float)},
Trade::MeshAttributeData{Trade::MeshAttribute::Normal,
VertexFormat::Vector3, 3*sizeof(Float), 10, 6*sizeof(Float)}
}), 0.0f, 1.0f, Math::TypeTraits<Float>::epsilon(), 7, true},
{"custom mat3x2, offset 100",Containers::array({
Trade::MeshAttributeData{Trade::meshAttributeCustom(42),
VertexFormat::Matrix3x2, 0, 10, 6*sizeof(Float)}
}), 100.0f, 1.0f, Math::TypeTraits<Float>::epsilon(), 7, false},
{"position + custom float[3], offset 100, scale 10, indexed",Containers::array({
Trade::MeshAttributeData{Trade::meshAttributeCustom(42),
VertexFormat::Float, 0, 10, 6*sizeof(Float), 3},
Trade::MeshAttributeData{Trade::MeshAttribute::Position,
VertexFormat::Vector3, 3*sizeof(Float), 10, 6*sizeof(Float)}
}), 100.0f, 10.0f, Math::TypeTraits<Float>::epsilon(), 7, true},
{"normal. bitangent, scale 2", Containers::array({
Trade::MeshAttributeData{Trade::MeshAttribute::Normal,
VertexFormat::Vector3, 0, 10, 6*sizeof(Float)},
Trade::MeshAttributeData{Trade::MeshAttribute::Bitangent,
VertexFormat::Vector3, 3*sizeof(Float), 10, 6*sizeof(Float)}
/* Should still fit into the epsilon as the range is [-1, 1] */
}), 0.0f, 2.0f, Math::TypeTraits<Float>::epsilon(), 7, false},
{"color, texcoord, scale 10", Containers::array({
Trade::MeshAttributeData{Trade::MeshAttribute::Color,
VertexFormat::Vector4, 0, 10, 6*sizeof(Float)},
Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates,
VertexFormat::Vector2, 4*sizeof(Float), 10, 6*sizeof(Float)}
/* Should not fit into the epsilon, only the bit-exact value gets
removed */
}), 0.0f, 10.0f, Math::TypeTraits<Float>::epsilon(), 9, true},
{"color, texcoord, scale 10, epsilon *10",Containers::array({
Trade::MeshAttributeData{Trade::MeshAttribute::Color,
VertexFormat::Vector4, 0, 10, 6*sizeof(Float)},
Trade::MeshAttributeData{Trade::MeshAttribute::TextureCoordinates,
VertexFormat::Vector2, 4*sizeof(Float), 10, 6*sizeof(Float)}
/* Fit into the epsilon again */
}), 0.0f, 10.0f, 10.0f*Math::TypeTraits<Float>::epsilon(), 7, false}
};
MeshTools: renamed clean() to removeDuplicates().
13 years ago
RemoveDuplicatesTest::RemoveDuplicatesTest() {
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
addTests({&RemoveDuplicatesTest::removeDuplicates,
&RemoveDuplicatesTest::removeDuplicatesNonContiguous,
&RemoveDuplicatesTest::removeDuplicatesIntoWrongOutputSize,
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlace<UnsignedByte>,
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlace<UnsignedShort>,
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlace<UnsignedInt>,
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceSmallType,
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceEmptyIndices,
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceEmptyIndicesVertices,
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceErased<UnsignedByte>,
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceErased<UnsignedShort>,
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceErased<UnsignedInt>,
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceErasedNonContiguous,
&RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceErasedWrongIndexSize,
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceOneDimension<Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceOneDimension<Double>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceMoreDimensions<Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceMoreDimensions<Double>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceInto<Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceInto<Double>,
MeshTools: add removeDuplicatesFuzzyInPlaceInto(). I need a variant of removeDuplicatesFuzzyInPlace() that doesn't allocate the output array but instead puts the data into a pre-existing location. The discrete / non-fuzzy variant had this already, but this one not.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceIntoWrongOutputSize,
MeshTools: deprecate remaining STL-ridden APIs. The combineIndexArrays() and combineIndexedArrays() API is replaced with a more generic combineIndexedAttributes(), and thanks to that we also don't need STL-based duplicate() and removeDuplicates().
6 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesFuzzyStl,
MeshTools: deprecate remaining STL-ridden APIs. The combineIndexArrays() and combineIndexedArrays() API is replaced with a more generic combineIndexedAttributes(), and thanks to that we also don't need STL-based duplicate() and removeDuplicates().
6 years ago
#endif
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlace<UnsignedByte, Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlace<UnsignedByte, Double>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlace<UnsignedShort, Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlace<UnsignedShort, Double>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlace<UnsignedInt, Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlace<UnsignedInt, Double>,
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceSmallType,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceEmptyIndices,
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceEmptyIndicesVertices,
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErased<UnsignedByte, Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErased<UnsignedByte, Double>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErased<UnsignedShort, Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErased<UnsignedShort, Double>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErased<UnsignedInt, Float>,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErased<UnsignedInt, Double>,
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErasedNonContiguous,
&RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErasedWrongIndexSize});
MeshTools: add removeDuplicates() operating directly on MeshData.
6 years ago
addInstancedTests({&RemoveDuplicatesTest::removeDuplicatesMeshData},
Containers::arraySize(RemoveDuplicatesMeshDataData));
addTests({&RemoveDuplicatesTest::removeDuplicatesMeshDataAttributeless});
MeshTools: add a soak test for removeDuplicates[Fuzzy]InPlace(). Something fishy going on in there, caused by the algorithm overwriting the key values (and the map relying on them being immutable). Interestingly enough the fuzzy variants works on GCC's libstdc++ even though the key data get changed every entry, fails only on libc++.
6 years ago
MeshTools: implement removeDuplicatesFuzzy() for MeshData.
6 years ago
addInstancedTests({&RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzy},
Containers::arraySize(RemoveDuplicatesMeshDataFuzzyData));
addTests({&RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzyDouble,
&RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzyAttributeless,
&RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzyImplementationSpecific});
MeshTools: add a soak test for removeDuplicates[Fuzzy]InPlace(). Something fishy going on in there, caused by the algorithm overwriting the key values (and the map relying on them being immutable). Interestingly enough the fuzzy variants works on GCC's libstdc++ even though the key data get changed every entry, fails only on libc++.
6 years ago
addRepeatedTests({&RemoveDuplicatesTest::soakTest,
&RemoveDuplicatesTest::soakTestFuzzy}, 10);
MeshTools: put subdivide / removeDuplicates benchamrks into their tests. One less executable to build, and we need to test more variants. The original measured thing ("when to remove duplicates") is no longer really relevant. Interestingly enough the fuzzy variant isn't that much slower.
6 years ago
addBenchmarks({&RemoveDuplicatesTest::benchmark,
&RemoveDuplicatesTest::benchmarkFuzzy}, 10);
Got rid of Qt's QtTest in favor of Corrade's TestSuite. Now we can use CORRADE_COMPARE() almost exclusively for comparing Vector, Matrix instances and all containers from STL. Tests running time for all 31 tests is now around 0.1 sec instead of two seconds like before. Disabled compilation of all benchmarks, because TestSuite cannot handle them yet. PKGBUILD from AUR now can shamelessly use check() function without unnecessary dependencies.
14 years ago
}
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
void RemoveDuplicatesTest::removeDuplicates() {
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
Int data[]{-15, 32, 24, -15, 15, 7541, 24, 32};
std::pair<Containers::Array<UnsignedInt>, std::size_t> result =
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
MeshTools::removeDuplicates(Containers::arrayCast<2, char>(Containers::arrayView(data)));
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayView(result.first),
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
Containers::arrayView<UnsignedInt>({0, 1, 2, 0, 4, 5, 2, 1}),
TestSuite::Compare::Container);
std::pair<Containers::Array<UnsignedInt>, std::size_t> resultInPlace =
MeshTools::removeDuplicatesInPlace(Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE_AS(Containers::arrayView(resultInPlace.first),
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
Containers::arrayView<UnsignedInt>({0, 1, 2, 0, 3, 4, 2, 1}),
TestSuite::Compare::Container);
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(resultInPlace.second),
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
Containers::arrayView<Int>({-15, 32, 24, 15, 7541}),
TestSuite::Compare::Container);
}
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesNonContiguous() {
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
Int data[8]{};
std::ostringstream out;
Error redirectError{&out};
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
MeshTools::removeDuplicates(Containers::arrayCast<2, const char>(Containers::arrayView(data)).every({1, 2}));
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
MeshTools::removeDuplicatesInPlace(Containers::arrayCast<2, char>(Containers::arrayView(data)).every({1, 2}));
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
CORRADE_COMPARE(out.str(),
"MeshTools::removeDuplicatesInto(): second data view dimension is not contiguous\n"
"MeshTools::removeDuplicatesInPlaceInto(): second data view dimension is not contiguous\n");
MeshTools: added removeDuplicatesInPlaceInto(). I need to put the resulting index array into a pre-existing allocation.
6 years ago
}
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesIntoWrongOutputSize() {
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
MeshTools: added removeDuplicatesInPlaceInto(). I need to put the resulting index array into a pre-existing allocation.
6 years ago
Int data[8]{};
UnsignedInt output[7];
std::ostringstream out;
Error redirectError{&out};
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
MeshTools::removeDuplicatesInto(
Containers::arrayCast<2, const char>(Containers::arrayView(data)),
output);
MeshTools: added removeDuplicatesInPlaceInto(). I need to put the resulting index array into a pre-existing allocation.
6 years ago
MeshTools::removeDuplicatesInPlaceInto(
Containers::arrayCast<2, char>(Containers::arrayView(data)),
output);
MeshTools: added removeDuplicates() / removeDuplicatesInto(). Those work without modifying the input data. The *Indexed and fuzzy variants are missing as I don't need those right now, but might get added later.
6 years ago
CORRADE_COMPARE(out.str(),
"MeshTools::removeDuplicatesInto(): output index array has 7 elements but expected 8\n"
"MeshTools::removeDuplicatesInPlaceInto(): output index array has 7 elements but expected 8\n");
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
}
template<class T> void RemoveDuplicatesTest::removeDuplicatesIndexedInPlace() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
T indices[]{3, 2, 0, 1, 7, 6, 4, 2, 5, 0};
Int data[]{-15, 32, 24, -15, 15, 7541, 24, 32};
std::size_t count = MeshTools::removeDuplicatesIndexedInPlace(indices,
Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE_AS(Containers::arrayView(indices),
Containers::arrayView<T>({0, 2, 0, 1, 1, 2, 3, 2, 4, 0}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(count),
Containers::arrayView<Int>({-15, 32, 24, 15, 7541}),
TestSuite::Compare::Container);
}
void RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceSmallType() {
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
std::stringstream out;
Error redirectError{&out};
UnsignedByte indices[1];
Vector2i data[256]{};
MeshTools::removeDuplicatesIndexedInPlace(
Containers::stridedArrayView(indices),
Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE(out.str(), "MeshTools::removeDuplicatesIndexedInPlace(): a 1-byte index type is too small for 256 vertices\n");
}
void RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceEmptyIndices() {
Int data[]{-15, 32, 24, -15, 15, 7541, 24, 32};
std::size_t count = MeshTools::removeDuplicatesIndexedInPlace(
Containers::StridedArrayView1D<UnsignedInt>{},
Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(count),
Containers::arrayView<Int>({-15, 32, 24, 15, 7541}),
TestSuite::Compare::Container);
}
void RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceEmptyIndicesVertices() {
CORRADE_COMPARE(MeshTools::removeDuplicatesIndexedInPlace(
Containers::StridedArrayView1D<UnsignedInt>{}, {}), 0);
}
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
template<class T> void RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceErased() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
T indices[]{3, 2, 0, 1, 7, 6, 4, 2, 5, 0};
Int data[]{-15, 32, 24, -15, 15, 7541, 24, 32};
std::size_t count = MeshTools::removeDuplicatesIndexedInPlace(
Containers::arrayCast<2, char>(Containers::arrayView(indices)),
Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE_AS(Containers::arrayView(indices),
Containers::arrayView<T>({0, 2, 0, 1, 1, 2, 3, 2, 4, 0}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(count),
Containers::arrayView<Int>({-15, 32, 24, 15, 7541}),
TestSuite::Compare::Container);
}
void RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceErasedNonContiguous() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
char indices[6*4]{};
Int data[1]{};
std::stringstream out;
Error redirectError{&out};
MeshTools::removeDuplicatesIndexedInPlace(
Containers::StridedArrayView2D<char>{indices, {6, 2}, {4, 2}},
Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE(out.str(),
"MeshTools::removeDuplicatesIndexedInPlace(): second index view dimension is not contiguous\n");
}
void RemoveDuplicatesTest::removeDuplicatesIndexedInPlaceErasedWrongIndexSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
char indices[6*3]{};
Int data[1]{};
std::stringstream out;
Error redirectError{&out};
MeshTools::removeDuplicatesIndexedInPlace(
Containers::StridedArrayView2D<char>{indices, {6, 3}},
Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE(out.str(),
"MeshTools::removeDuplicatesIndexedInPlace(): expected index type size 1, 2 or 4 but got 3\n");
}
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
template<class T> void RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceOneDimension() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
MeshTools: test reducing of last dimension in removeDuplicatesFuzzy(). I spotted a potential bug -- and it clearly *is* a bug. The test doesn't reduce the data size in the last dimension, leaving a duplicate (and unused) item at the end.
6 years ago
/* Numbers with distance <=1 should be merged. In the first iteration item
2 gets collapsed into item 1, in the second iteration item 3 gets
collapsed into item 1, reducing to 2 items in total. */
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
T data[]{
T(1.0), /* bucket 0 in 1st iteration, bucket 1 in 2nd */
T(2.9), /* bucket 2 in 1st iteration, bucket 3 in 2nd */
T(0.0), /* bucket 0 in 1st iteration, bucket 0 in 2nd */
T(3.4) /* bucket 3 in 1st iteration, bucket 3 in 2nd */
MeshTools: test reducing of last dimension in removeDuplicatesFuzzy(). I spotted a potential bug -- and it clearly *is* a bug. The test doesn't reduce the data size in the last dimension, leaving a duplicate (and unused) item at the end.
6 years ago
};
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
std::pair<Containers::Array<UnsignedInt>, std::size_t> result =
MeshTools::removeDuplicatesFuzzyInPlace(
Containers::arrayCast<2, T>(Containers::stridedArrayView(data)),
T(1.00001));
MeshTools: test reducing of last dimension in removeDuplicatesFuzzy(). I spotted a potential bug -- and it clearly *is* a bug. The test doesn't reduce the data size in the last dimension, leaving a duplicate (and unused) item at the end.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayView(result.first),
Containers::arrayView<UnsignedInt>({0, 1, 0, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(result.second),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
(Containers::arrayView<T>({T(1.0), T(2.9)})),
MeshTools: test reducing of last dimension in removeDuplicatesFuzzy(). I spotted a potential bug -- and it clearly *is* a bug. The test doesn't reduce the data size in the last dimension, leaving a duplicate (and unused) item at the end.
6 years ago
TestSuite::Compare::Container);
}
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
template<class T> void RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceMoreDimensions() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
MeshTools: reworked removeDuplicates(). It now returns new index array instead of operating on already existing one and also custom vector size is removed. The internal implementation is now much simpler and cleaner. The old way (but still without custom vector size) is now alias to the new implementation, is marked as deprecated and will be removed in future release. Renamed the parameters and reworded the documentation so it doesn't talk about vertices, but rather about generic floating-point vector data.
12 years ago
/* Numbers with distance 1 should be merged, numbers with distance 2 should
be kept. Testing both even-odd and odd-even sequence to verify that
half-epsilon translations are applied properly. */
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Math::Vector2<T> data[]{
{T(1.0), T(0.0)},
{T(2.0), T(1.0)},
{T(0.0), T(4.0)},
{T(1.0), T(5.0)}
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
};
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
std::pair<Containers::Array<UnsignedInt>, std::size_t> result =
MeshTools::removeDuplicatesFuzzyInPlace(
Containers::arrayCast<2, T>(Containers::stridedArrayView(data)),
T(2.0));
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayView(result.first),
Containers::arrayView<UnsignedInt>({0, 0, 1, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(result.second),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayView<Math::Vector2<T>>({{T(1.0), T(0.0)}, {T(0.0), T(4.0)}}),
TestSuite::Compare::Container);
}
template<class T> void RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceInto() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
/* Same as above, but using the Into variant */
Math::Vector2<T> data[]{
{T(1.0), T(0.0)},
{T(2.0), T(1.0)},
{T(0.0), T(4.0)},
{T(1.0), T(5.0)}
};
Containers::Array<UnsignedInt> indices{Containers::NoInit, Containers::arraySize(data)};
std::size_t result = MeshTools::removeDuplicatesFuzzyInPlaceInto(
Containers::arrayCast<2, T>(Containers::stridedArrayView(data)),
indices, T(2.0));
CORRADE_COMPARE_AS(indices,
Containers::arrayView<UnsignedInt>({0, 0, 1, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(result),
Containers::arrayView<Math::Vector2<T>>({{T(1.0), T(0.0)}, {T(0.0), T(4.0)}}),
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
TestSuite::Compare::Container);
}
MeshTools: add removeDuplicatesFuzzyInPlaceInto(). I need a variant of removeDuplicatesFuzzyInPlace() that doesn't allocate the output array but instead puts the data into a pre-existing location. The discrete / non-fuzzy variant had this already, but this one not.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceIntoWrongOutputSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Vector2 data[8]{};
UnsignedInt output[7];
std::ostringstream out;
Error redirectError{&out};
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
MeshTools::removeDuplicatesFuzzyInPlaceInto(
Containers::arrayCast<2, Float>(Containers::stridedArrayView(data)),
output);
MeshTools: add removeDuplicatesFuzzyInPlaceInto(). I need a variant of removeDuplicatesFuzzyInPlace() that doesn't allocate the output array but instead puts the data into a pre-existing location. The discrete / non-fuzzy variant had this already, but this one not.
6 years ago
CORRADE_COMPARE(out.str(),
"MeshTools::removeDuplicatesFuzzyInPlaceInto(): output index array has 7 elements but expected 8\n");
}
MeshTools: deprecate remaining STL-ridden APIs. The combineIndexArrays() and combineIndexedArrays() API is replaced with a more generic combineIndexedAttributes(), and thanks to that we also don't need STL-based duplicate() and removeDuplicates().
6 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesFuzzyStl() {
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
/* Same but with implicit bloat. HEH HEH */
MeshTools: use floats for removeDuplicatesFuzzy() tests. Because it makes no sense to use ints for this, and I'll be removing the template to make it work only on floating-point types anyway.
6 years ago
std::vector<Vector2> data{
{1.0f, 0.0f},
{2.0f, 1.0f},
{0.0f, 4.0f},
{1.0f, 5.0f}
MeshTools: reworked removeDuplicates(). It now returns new index array instead of operating on already existing one and also custom vector size is removed. The internal implementation is now much simpler and cleaner. The old way (but still without custom vector size) is now alias to the new implementation, is marked as deprecated and will be removed in future release. Renamed the parameters and reworded the documentation so it doesn't talk about vertices, but rather about generic floating-point vector data.
12 years ago
};
Splitting tools from MeshBuilderBenchmark to MeshTools. Moved unit tests and benchmarks accordingly.
15 years ago
MeshTools: deprecate remaining STL-ridden APIs. The combineIndexArrays() and combineIndexedArrays() API is replaced with a more generic combineIndexedAttributes(), and thanks to that we also don't need STL-based duplicate() and removeDuplicates().
6 years ago
CORRADE_IGNORE_DEPRECATED_PUSH
MeshTools: use floats for removeDuplicatesFuzzy() tests. Because it makes no sense to use ints for this, and I'll be removing the template to make it work only on floating-point types anyway.
6 years ago
const std::vector<UnsignedInt> indices = MeshTools::removeDuplicates(data, 2.0f);
MeshTools: deprecate remaining STL-ridden APIs. The combineIndexArrays() and combineIndexedArrays() API is replaced with a more generic combineIndexedAttributes(), and thanks to that we also don't need STL-based duplicate() and removeDuplicates().
6 years ago
CORRADE_IGNORE_DEPRECATED_POP
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
CORRADE_COMPARE_AS(indices,
(std::vector<UnsignedInt>{0, 0, 1, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(data,
MeshTools: use floats for removeDuplicatesFuzzy() tests. Because it makes no sense to use ints for this, and I'll be removing the template to make it work only on floating-point types anyway.
6 years ago
(std::vector<Vector2>{{1.0f, 0.0f}, {0.0f, 4.0f}}),
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
TestSuite::Compare::Container);
}
MeshTools: deprecate remaining STL-ridden APIs. The combineIndexArrays() and combineIndexedArrays() API is replaced with a more generic combineIndexedAttributes(), and thanks to that we also don't need STL-based duplicate() and removeDuplicates().
6 years ago
#endif
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
template<class IndexType, class T> void RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlace() {
setTestCaseTemplateName(Utility::formatString("{}, {}",
Math::TypeTraits<IndexType>::name(),
Math::TypeTraits<T>::name()));
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
/* Same as above, but with an explicit index buffer */
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
IndexType indices[]{3, 2, 0, 1, 2, 3};
Math::Vector2<T> data[]{
{T(1.0), T(0.0)},
{T(2.0), T(1.0)},
{T(0.0), T(4.0)},
{T(1.0), T(5.0)}
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
};
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
std::size_t count = MeshTools::removeDuplicatesFuzzyIndexedInPlace(
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
Containers::stridedArrayView(indices),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayCast<2, T>(Containers::stridedArrayView(data)), 2);
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayView(indices),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayView<IndexType>({1, 1, 0, 0, 1, 1}),
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(count),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayView<Math::Vector2<T>>({{T(1.0), T(0.0)}, {T(0.0), T(4.0)}}),
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
TestSuite::Compare::Container);
}
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceSmallType() {
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
std::stringstream out;
Error redirectError{&out};
UnsignedByte indices[1];
MeshTools: use floats for removeDuplicatesFuzzy() tests. Because it makes no sense to use ints for this, and I'll be removing the template to make it work only on floating-point types anyway.
6 years ago
Vector2 data[256]{};
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
MeshTools::removeDuplicatesFuzzyIndexedInPlace(
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
Containers::stridedArrayView(indices),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayCast<2, Float>(Containers::stridedArrayView(data)));
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
CORRADE_COMPARE(out.str(), "MeshTools::removeDuplicatesFuzzyIndexedInPlace(): a 1-byte index type is too small for 256 vertices\n");
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
}
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceEmptyIndices() {
MeshTools: use floats for removeDuplicatesFuzzy() tests. Because it makes no sense to use ints for this, and I'll be removing the template to make it work only on floating-point types anyway.
6 years ago
Vector2 data[]{
{1.0f, 0.0f},
{2.0f, 1.0f},
{0.0f, 4.0f},
{1.0f, 5.0f}
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
};
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
std::size_t count = MeshTools::removeDuplicatesFuzzyIndexedInPlace(
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
Containers::StridedArrayView1D<UnsignedInt>{},
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayCast<2, Float>(Containers::stridedArrayView(data)), 2.0f);
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(count),
MeshTools: use floats for removeDuplicatesFuzzy() tests. Because it makes no sense to use ints for this, and I'll be removing the template to make it work only on floating-point types anyway.
6 years ago
Containers::arrayView<Vector2>({{1.0f, 0.0f}, {0.0f, 4.0f}}),
MeshTools: add STL-free removeDuplicatesInPlace() & an indexed variant also.
6 years ago
TestSuite::Compare::Container);
}
MeshTools: implement removeDuplicates() for discrete data as well.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceEmptyIndicesVertices() {
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
CORRADE_COMPARE((MeshTools::removeDuplicatesFuzzyIndexedInPlace(
Containers::StridedArrayView1D<UnsignedInt>{},
Containers::StridedArrayView2D<Float>{})), 0);
Splitting tools from MeshBuilderBenchmark to MeshTools. Moved unit tests and benchmarks accordingly.
15 years ago
}
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
template<class IndexType, class T> void RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErased() {
setTestCaseTemplateName(Utility::formatString("{}, {}",
Math::TypeTraits<IndexType>::name(),
Math::TypeTraits<T>::name()));
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
/* Same as above, but with an explicit index buffer */
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
IndexType indices[]{3, 2, 0, 1, 2, 3};
Math::Vector2<T> data[]{
{T(1.0), T(0.0)},
{T(2.0), T(1.0)},
{T(0.0), T(4.0)},
{T(1.0), T(5.0)}
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
};
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
std::size_t count = MeshTools::removeDuplicatesFuzzyIndexedInPlace(
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
Containers::arrayCast<2, char>(Containers::arrayView(indices)),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayCast<2, T>(Containers::stridedArrayView(data)), 2);
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayView(indices),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayView<IndexType>({1, 1, 0, 0, 1, 1}),
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(count),
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayView<Math::Vector2<T>>({{T(1.0), T(0.0)}, {T(0.0), T(4.0)}}),
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
TestSuite::Compare::Container);
}
void RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErasedNonContiguous() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
char indices[6*4]{};
MeshTools: use floats for removeDuplicatesFuzzy() tests. Because it makes no sense to use ints for this, and I'll be removing the template to make it work only on floating-point types anyway.
6 years ago
Vector2 data[1];
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
std::stringstream out;
Error redirectError{&out};
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
MeshTools::removeDuplicatesFuzzyIndexedInPlace(
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
Containers::StridedArrayView2D<char>{indices, {6, 2}, {4, 2}},
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayCast<2, Float>(Containers::stridedArrayView(data)));
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
CORRADE_COMPARE(out.str(),
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
"MeshTools::removeDuplicatesFuzzyIndexedInPlace(): second index view dimension is not contiguous\n");
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
}
void RemoveDuplicatesTest::removeDuplicatesFuzzyIndexedInPlaceErasedWrongIndexSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
char indices[6*3]{};
MeshTools: use floats for removeDuplicatesFuzzy() tests. Because it makes no sense to use ints for this, and I'll be removing the template to make it work only on floating-point types anyway.
6 years ago
Vector2 data[1];
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
std::stringstream out;
Error redirectError{&out};
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
MeshTools::removeDuplicatesFuzzyIndexedInPlace(
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
Containers::StridedArrayView2D<char>{indices, {6, 3}},
MeshTools: de-template removeDuplicatesFuzzy(). Basically using the same idea as with the discrete version -- having the second dimension dynamic, together with restricting the implementation to just Float and Double. According to the SubdivideRemoveDuplicatesBenchmark, this makes the implementation slightly slower. I presume this is due to how minmax and offsets are calculated which is quite cache-inefficient as it goes over the same memory block multiple times. Added a TODO for later.
6 years ago
Containers::arrayCast<2, Float>(Containers::stridedArrayView(data)));
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
CORRADE_COMPARE(out.str(),
MeshTools: rename removeDuplicates{ => Fuzzy}[Indexed]InPlace(). A breaking change, sorry, but I don't want to add yet another layer of backwards compatibility on APIs that are in master for just a month or so. This is a test for how many people actually use these APIs -- if nobody complains, great! Conflating the fuzzy operation with the discrete one wasn't a good idea, as people could be unintentionally using the (slower) fuzzy variant on data that could be easily deduplicated using the discrete variant. One such case is in the icosphere primitive, and I'm going to look at that right now.
6 years ago
"MeshTools::removeDuplicatesFuzzyIndexedInPlace(): expected index type size 1, 2 or 4 but got 3\n");
MeshTools: removeDuplicatesIndexedInPlace() for type-erased indices. Next step is a variant operating directly on a MeshData.
6 years ago
}
MeshTools: add removeDuplicates() operating directly on MeshData.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesMeshData() {
auto&& data = RemoveDuplicatesMeshDataData[testCaseInstanceId()];
setTestCaseDescription(data.name);
/* Deliberately not owned and not interleaved to verify that the function
will handle this */
struct Vertex {
Vector2 positions[10]{
{1.0f, 2.0f},
{3.0f, 4.0f},
{5.0f, 6.0f},
{7.0f, 8.0f},
{7.0f, 8.0f},
{7.0f, 8.0f},
{9.0f, 10.0f},
{3.0f, 4.0f},
{5.0f, 6.0f},
{5.0f, 6.0f}
};
Short data[10][2]{
{-15, 2},
{2, 32},
{24, 2},
{-15, 2},
{15, 2},
{2, 7541},
{24, 2},
{2, 32},
{24, 2},
{15, 2}
};
} vertexData[1];
const UnsignedShort indexData[]{1, 2, 5, 9, 7, 6, 4, 7, 5, 0, 3, 8, 3};
Containers::ArrayView<const void> indexView;
Trade::MeshIndexData indices;
if(data.indexed) {
indexView = indexData;
indices = Trade::MeshIndexData{indexData};
}
Trade::MeshData mesh{MeshPrimitive::Lines,
{}, indexView, indices,
{}, vertexData, {
Trade::MeshAttributeData{Trade::MeshAttribute::Position,
Containers::arrayView(vertexData->positions)},
Trade::MeshAttributeData{Trade::meshAttributeCustom(42),
VertexFormat::ShortNormalized, 2,
Containers::stridedArrayView(vertexData->data)},
}};
Trade::MeshData unique = MeshTools::removeDuplicates(mesh);
CORRADE_COMPARE(unique.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(unique.isIndexed());
if(data.indexed) {
CORRADE_COMPARE(unique.indexCount(), mesh.indexCount());
{
CORRADE_EXPECT_FAIL("The function currently doesn't preserve the index type.");
CORRADE_COMPARE(unique.indexType(), MeshIndexType::UnsignedShort);
}
CORRADE_COMPARE(unique.indexType(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE_AS(unique.indices<UnsignedInt>(),
Containers::arrayView<UnsignedInt>({1, 2, 5, 7, 1, 6, 4, 1, 5, 0, 3, 2, 3}),
TestSuite::Compare::Container);
} else {
CORRADE_COMPARE(unique.indexCount(), mesh.vertexCount());
CORRADE_COMPARE(unique.indexType(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE_AS(unique.indices<UnsignedInt>(),
Containers::arrayView<UnsignedInt>({0, 1, 2, 3, 4, 5, 6, 1, 2, 7}),
TestSuite::Compare::Container);
}
CORRADE_COMPARE(unique.vertexCount(), 8);
CORRADE_COMPARE(unique.attributeCount(), 2);
CORRADE_COMPARE(unique.attributeName(0), Trade::MeshAttribute::Position);
CORRADE_COMPARE(unique.attributeFormat(0), VertexFormat::Vector2);
CORRADE_COMPARE_AS(unique.attribute<Vector2>(0),
Containers::arrayView<Vector2>({
{1.0f, 2.0f},
{3.0f, 4.0f},
{5.0f, 6.0f},
{7.0f, 8.0f},
{7.0f, 8.0f},
{7.0f, 8.0f},
{9.0f, 10.0f},
{5.0f, 6.0f}
}),
TestSuite::Compare::Container);
CORRADE_COMPARE(unique.attributeName(1), Trade::meshAttributeCustom(42));
CORRADE_COMPARE(unique.attributeFormat(1), VertexFormat::ShortNormalized);
CORRADE_COMPARE(unique.attributeArraySize(1), 2);
CORRADE_COMPARE_AS((Containers::arrayCast<1, const Vector2s>(unique.attribute<Short[]>(1))),
Containers::arrayView<Vector2s>({
{-15, 2},
{2, 32},
{24, 2},
{-15, 2},
{15, 2},
{2, 7541},
{24, 2},
{15, 2}
}),
TestSuite::Compare::Container);
}
void RemoveDuplicatesTest::removeDuplicatesMeshDataAttributeless() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
std::ostringstream out;
Error redirectError{&out};
MeshTools::removeDuplicates(Trade::MeshData{MeshPrimitive::Points, 10});
CORRADE_COMPARE(out.str(),
"MeshTools::removeDuplicates(): can't remove duplicates in an attributeless mesh\n");
}
MeshTools: implement removeDuplicatesFuzzy() for MeshData.
6 years ago
void RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzy() {
auto&& data = RemoveDuplicatesMeshDataFuzzyData[testCaseInstanceId()];
setTestCaseDescription(data.name);
/* Deliberately not owned and not interleaved to verify that the function
will handle this */
struct Vertex {
Short ints[10][2]{
{15, 2},
{15, 2},
{15, 2},
{2365, -2},
{-2, 2365},
{-2, 2365},
{2365, -2},
{37, 0},
{37, 0},
{37, 0}
};
Math::Vector<6, Float> floats[10]{
{0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f},
/* This one gets collapsed to the above */
{0.0f, 1.0f, 0.0f, 1.0f - Math::TypeTraits<Float>::epsilon()/4, 0.0f, 0.0f},
/* This one not */
{0.0f, 1.0f, 0.0f, 1.0f - Math::TypeTraits<Float>::epsilon()*4, 0.0f, 0.0f},
/* These are bit-equivalent, but not all get collapsed because the
ints are different */
{0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
/* Same as above, only at a smaller scale */
{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f + Math::TypeTraits<Float>::epsilon()/2, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f + Math::TypeTraits<Float>::epsilon()*2, 0.0f, 0.0f, 0.0f},
};
UnsignedByte intsAgain[10]{
33,
33,
33,
15,
15,
15,
17,
223,
223,
223
};
UnsignedInt objectId[10]{ 15, 15, 15, 15, 15, 15, 15, 15, 15, 15 };
} vertexData[1];
const UnsignedShort indexData[]{1, 2, 5, 9, 7, 6, 4, 7, 5, 0, 3, 8, 3};
/* Scale and offset the floats */
for(Math::Vector<6, Float>& f: vertexData->floats)
f = f*data.scale + Math::Vector<6, Float>{data.offset};
/* Create a combined attribute list */
Containers::Array<Trade::MeshAttributeData> attributes;
arrayAppend(attributes, Trade::MeshAttributeData{
Trade::meshAttributeCustom(15), VertexFormat::Short, 0, 10, 4, 2});
for(const Trade::MeshAttributeData& a: data.attributes)
arrayAppend(attributes, Trade::MeshAttributeData{
a.name(), a.format(), offsetof(Vertex, floats) + a.offset({}), 10, a.stride(), a.arraySize()});
arrayAppend(attributes, Trade::MeshAttributeData{
Trade::meshAttributeCustom(16), VertexFormat::UnsignedByte, offsetof(Vertex, intsAgain), 10, 1});
arrayAppend(attributes, Trade::MeshAttributeData{
Trade::MeshAttribute::ObjectId, VertexFormat::UnsignedInt, offsetof(Vertex, objectId), 10, 4});
Containers::ArrayView<const void> indexView;
Trade::MeshIndexData indices;
if(data.indexed) {
indexView = indexData;
indices = Trade::MeshIndexData{indexData};
}
Trade::MeshData mesh{MeshPrimitive::Lines,
{}, indexView, indices,
{}, vertexData, std::move(attributes)};
Trade::MeshData unique = MeshTools::removeDuplicatesFuzzy(mesh,
data.epsilon);
CORRADE_COMPARE(unique.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(unique.isIndexed());
if(data.indexed)
CORRADE_COMPARE(unique.indexCount(), mesh.indexCount());
else
CORRADE_COMPARE(unique.indexCount(), mesh.vertexCount());
CORRADE_COMPARE(unique.indexType(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE(unique.attributeCount(), 3 + data.attributes.size());
/* Verify that all attributes have expected metadata and are interleaved */
for(UnsignedInt i = 0; i != unique.attributeCount(); ++i) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(unique.attributeStride(i), 4 + 6*sizeof(float) + 5);
}
CORRADE_COMPARE(unique.attributeFormat(0), VertexFormat::Short);
CORRADE_COMPARE(unique.attributeOffset(0), 0);
CORRADE_COMPARE(unique.attributeName(0), Trade::meshAttributeCustom(15));
CORRADE_COMPARE(unique.attributeArraySize(0), 2);
for(std::size_t i = 0; i != data.attributes.size(); ++i) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(unique.attributeFormat(1 + i), data.attributes[i].format());
CORRADE_COMPARE(unique.attributeOffset(1 + i), 4 + data.attributes[i].offset({}));
CORRADE_COMPARE(unique.attributeName(1 + i), data.attributes[i].name());
CORRADE_COMPARE(unique.attributeArraySize(1 + i), data.attributes[i].arraySize());
}
CORRADE_COMPARE(unique.attributeFormat(1 + data.attributes.size()), VertexFormat::UnsignedByte);
CORRADE_COMPARE(unique.attributeOffset(1 + data.attributes.size()), 4 + 6*sizeof(Float));
CORRADE_COMPARE(unique.attributeName(1 + data.attributes.size()), Trade::meshAttributeCustom(16));
CORRADE_COMPARE(unique.attributeFormat(2 + data.attributes.size()), VertexFormat::UnsignedInt);
CORRADE_COMPARE(unique.attributeOffset(2 + data.attributes.size()), 5 + 6*sizeof(Float));
CORRADE_COMPARE(unique.attributeName(2 + data.attributes.size()), Trade::MeshAttribute::ObjectId);
/* The data differ depending on how much is actually removed */
if(data.vertexCount == 7) {
if(data.indexed) CORRADE_COMPARE_AS(unique.indices<UnsignedInt>(),
Containers::arrayView<UnsignedInt>({0, 1, 3, 6, 5, 4, 3, 5, 3, 0, 2, 5, 2}),
TestSuite::Compare::Container);
else CORRADE_COMPARE_AS(unique.indices<UnsignedInt>(),
Containers::arrayView<UnsignedInt>({0, 0, 1, 2, 3, 3, 4, 5, 5, 6}),
TestSuite::Compare::Container);
/* Compare the integer data through the attribute API */
CORRADE_COMPARE_AS((Containers::arrayCast<1, const Vector2s>(unique.attribute<Short[]>(Trade::meshAttributeCustom(15)))),
Containers::arrayView<Vector2s>({
{15, 2},
{15, 2},
{2365, -2},
{-2, 2365},
{2365, -2},
{37, 0},
{37, 0}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(unique.attribute<UnsignedByte>(Trade::meshAttributeCustom(16)),
Containers::arrayView<UnsignedByte>({
33,
33,
15,
15,
17,
223,
223
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(unique.attribute<UnsignedInt>(Trade::MeshAttribute::ObjectId),
Containers::arrayView<UnsignedInt>({
15, 15, 15, 15, 15, 15, 15
}), TestSuite::Compare::Container);
/* Compare the float/double data as a single block independently of the
attribute layout */
Math::Vector<6, Float> expectedFloats[]{
{0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f},
{0.0f, 1.0f, 0.0f, 1.0f - Math::TypeTraits<Float>::epsilon()*4, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f + Math::TypeTraits<Float>::epsilon()*2, 0.0f, 0.0f, 0.0f},
};
for(Math::Vector<6, Float>& f: expectedFloats)
f = f*data.scale + Math::Vector<6, Float>{data.offset};
/** @todo i need some feature like "gimme just the top-level dimension" */
Containers::StridedArrayView1D<const char> floats{unique.vertexData(),
unique.vertexData() + unique.attributeOffset(1),
unique.vertexCount(), unique.attributeStride(1)};
CORRADE_COMPARE_AS((Containers::arrayCast<const Math::Vector<6, Float>>(floats)),
Containers::arrayView(expectedFloats),
TestSuite::Compare::Container);
} else if(data.vertexCount == 9) {
if(data.indexed) CORRADE_COMPARE_AS(unique.indices<UnsignedInt>(),
Containers::arrayView<UnsignedInt>({1, 2, 4, 8, 6, 5, 4, 6, 4, 0, 3, 7, 3}),
TestSuite::Compare::Container);
else CORRADE_COMPARE_AS(unique.indices<UnsignedInt>(),
Containers::arrayView<UnsignedInt>({0, 1, 2, 3, 4, 4, 5, 6, 7, 8}),
TestSuite::Compare::Container);
/* Not testing the rest, it's verified well enough in the other cases */
}
}
void RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzyDouble() {
/* Deliberately not owned and not interleaved to verify that the function
will handle this */
const struct Vertex {
/* Epsilon enlarged a lot to ensure the cell size isn't too small for
the grid size to fit into 32 bit std::size_t */
Math::Vector<3, Double> doubles[10]{
{110.0, 100.0, 100.0},
/* This one gets collapsed to the above */
{110.0 - 250000*Math::TypeTraits<Double>::epsilon()/2, 100.0, 100.0},
/* This one not */
{110.0 - 250000*Math::TypeTraits<Double>::epsilon()*2, 100.0, 100.0},
/* These are bit-equivalent, but not all get collapsed because the
ints are different */
{100.0, 100.0, 110.0},
{100.0, 100.0, 110.0},
{100.0, 100.0, 110.0},
{100.0, 100.0, 110.0},
/* Same as above, only at a smaller scale */
{100.0, 100.0, 100.0},
{100.0, 100.0, 100.0 + 250000*Math::TypeTraits<Double>::epsilon()/2},
{100.0, 100.0, 100.0 + 250000*Math::TypeTraits<Double>::epsilon()*2},
};
UnsignedByte objectId[10]{
33,
33,
33,
15,
16,
15,
17,
223,
223,
223
};
MeshTools: fix build on old Clang.
6 years ago
/* Old Clang complains that "error: default initialization of struct"
without the {} */
} vertexData[1]{};
MeshTools: implement removeDuplicatesFuzzy() for MeshData.
6 years ago
Trade::MeshData mesh{MeshPrimitive::Points,
{}, vertexData, {
Trade::MeshAttributeData{Trade::meshAttributeCustom(10),
VertexFormat::Double, 0, 10, 3*sizeof(Double)},
Trade::MeshAttributeData{Trade::meshAttributeCustom(11),
VertexFormat::Double, sizeof(Double), 10, 3*sizeof(Double), 2},
Trade::MeshAttributeData{
Trade::MeshAttribute::ObjectId, VertexFormat::UnsignedByte, offsetof(Vertex, objectId), 10, 1}
}};
Trade::MeshData unique = MeshTools::removeDuplicatesFuzzy(mesh,
Math::TypeTraits<Float>::epsilon(),
/* Epsilon enlarged a lot to ensure the cell size isn't too small for
the grid size to fit into 32 bit std::size_t */
25000*Math::TypeTraits<Double>::epsilon());
CORRADE_COMPARE(unique.primitive(), MeshPrimitive::Points);
CORRADE_VERIFY(unique.isIndexed());
CORRADE_COMPARE(unique.indexCount(), mesh.vertexCount());
CORRADE_COMPARE(unique.indexType(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE(unique.attributeCount(), 3);
/* Verify that all attributes have expected metadata and are interleaved */
for(UnsignedInt i = 0; i != unique.attributeCount(); ++i) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(unique.attributeStride(i), 3*sizeof(Double) + 1);
}
CORRADE_COMPARE(unique.attributeFormat(0), VertexFormat::Double);
CORRADE_COMPARE(unique.attributeOffset(0), 0);
CORRADE_COMPARE(unique.attributeName(0), Trade::meshAttributeCustom(10));
CORRADE_COMPARE(unique.attributeFormat(1), VertexFormat::Double);
CORRADE_COMPARE(unique.attributeOffset(1), sizeof(Double));
CORRADE_COMPARE(unique.attributeName(1), Trade::meshAttributeCustom(11));
CORRADE_COMPARE(unique.attributeArraySize(1), 2);
CORRADE_COMPARE(unique.attributeFormat(2), VertexFormat::UnsignedByte);
CORRADE_COMPARE(unique.attributeOffset(2), 3*sizeof(Double));
CORRADE_COMPARE(unique.attributeName(2), Trade::MeshAttribute::ObjectId);
CORRADE_COMPARE_AS(unique.indices<UnsignedInt>(),
Containers::arrayView<UnsignedInt>({0, 0, 1, 2, 3, 2, 4, 5, 5, 6}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(unique.attribute<UnsignedByte>(Trade::MeshAttribute::ObjectId),
Containers::arrayView<UnsignedByte>({
33,
33,
15,
16,
17,
223,
223
}), TestSuite::Compare::Container);
/* Compare the float/double data as a single block independently of the
attribute layout */
Math::Vector<3, Double> expectedFloats[]{
{110.0, 100.0, 100.0},
{110.0 - 250000*Math::TypeTraits<Double>::epsilon()*2, 100.0, 100.0},
{100.0, 100.0, 110.0},
{100.0, 100.0, 110.0},
{100.0, 100.0, 110.0},
{100.0, 100.0, 100.0},
{100.0, 100.0, 100.0 + 250000*Math::TypeTraits<Double>::epsilon()*2},
};
/** @todo i need some feature like "gimme just the top-level dimension" */
Containers::StridedArrayView1D<const char> floats{unique.vertexData(),
unique.vertexData() + unique.attributeOffset(0),
unique.vertexCount(), unique.attributeStride(0)};
CORRADE_COMPARE_AS((Containers::arrayCast<const Math::Vector<3, Double>>(floats)),
Containers::arrayView(expectedFloats),
TestSuite::Compare::Container);
}
void RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzyAttributeless() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
std::ostringstream out;
Error redirectError{&out};
MeshTools::removeDuplicatesFuzzy(Trade::MeshData{MeshPrimitive::Points, 10});
CORRADE_COMPARE(out.str(),
"MeshTools::removeDuplicatesFuzzy(): can't remove duplicates in an attributeless mesh\n");
}
void RemoveDuplicatesTest::removeDuplicatesMeshDataFuzzyImplementationSpecific() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
std::ostringstream out;
Error redirectError{&out};
CORRADE_EXPECT_FAIL("The function currently uses concatenate() to make data owned, which fails earlier with a different (and confusing) assert message.");
CORRADE_VERIFY(false);
// MeshTools::removeDuplicatesFuzzy(Trade::MeshData{MeshPrimitive::Points,
// nullptr, {Trade::MeshAttributeData{Trade::MeshAttribute::Position,
// vertexFormatWrap(0x1234), nullptr}}});
// CORRADE_COMPARE(out.str(),
// "MeshTools::removeDuplicatesFuzzy(): can't remove duplicates in an implementation-specific format 0x1234\n");
}
MeshTools: add a soak test for removeDuplicates[Fuzzy]InPlace(). Something fishy going on in there, caused by the algorithm overwriting the key values (and the map relying on them being immutable). Interestingly enough the fuzzy variants works on GCC's libstdc++ even though the key data get changed every entry, fails only on libc++.
6 years ago
void RemoveDuplicatesTest::soakTest() {
/* Array of 100 unique items with 10 duplicates each, randomly shuffled */
UnsignedInt data[1000];
for(std::size_t i = 0; i != Containers::arraySize(data); ++i)
data[i] = i / 10 + testCaseRepeatId()*909091;
std::shuffle(std::begin(data), std::end(data), std::minstd_rand{std::random_device{}()});
CORRADE_COMPARE(MeshTools::removeDuplicatesInPlace(
Containers::StridedArrayView2D<char>{
Containers::arrayCast<char>(Containers::arrayView(data)), {1000, 4}}
).second, 100);
}
void RemoveDuplicatesTest::soakTestFuzzy() {
/* Array of 100 unique items with 10 duplicates each, randomly shuffled */
Float data[1000];
for(std::size_t i = 0; i != Containers::arraySize(data); ++i)
data[i] = Float(Int(i/10) + testCaseRepeatId()*909091);
std::shuffle(std::begin(data), std::end(data), std::minstd_rand{std::random_device{}()});
CORRADE_COMPARE(MeshTools::removeDuplicatesFuzzyInPlace(
Containers::arrayCast<2, Float>(Containers::arrayView(data))).second,
100);
}
MeshTools: put subdivide / removeDuplicates benchamrks into their tests. One less executable to build, and we need to test more variants. The original measured thing ("when to remove duplicates") is no longer really relevant. Interestingly enough the fuzzy variant isn't that much slower.
6 years ago
void RemoveDuplicatesTest::benchmark() {
/* Array of 100 unique items with 100 duplicates each, shuffled */
Vector3i data[10000];
for(std::size_t i = 0; i != Containers::arraySize(data); ++i)
data[i].x() = i/100;
std::shuffle(std::begin(data), std::end(data), std::minstd_rand{std::random_device{}()});
std::size_t count;
UnsignedInt indices[10000];
CORRADE_BENCHMARK(1)
count = MeshTools::removeDuplicatesInPlaceInto(
Containers::arrayCast<2, char>(Containers::arrayView(data)),
indices);
CORRADE_COMPARE(count, 100);
}
void RemoveDuplicatesTest::benchmarkFuzzy() {
/* Array of 100 unique items with 100 duplicates each, shuffled */
Vector3 data[10000];
for(std::size_t i = 0; i != Containers::arraySize(data); ++i)
data[i].x() = i/100;
std::shuffle(std::begin(data), std::end(data), std::minstd_rand{std::random_device{}()});
std::size_t count;
UnsignedInt indices[10000];
CORRADE_BENCHMARK(1)
count = MeshTools::removeDuplicatesFuzzyInPlaceInto(
Containers::arrayCast<2, Float>(Containers::arrayView(data)),
indices);
CORRADE_COMPARE(count, 100);
}
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
}}}}
Got rid of header files in tests. They have no practical use and they only bloat codebase size and add maintenance burden.
14 years ago
MeshTools: renamed clean() to removeDuplicates().
13 years ago
CORRADE_TEST_MAIN(Magnum::MeshTools::Test::RemoveDuplicatesTest)