ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

MeshTools: port away from std::pair in remaining APIs. 

Same here, PairStl.h added for backwards compatibility. Finally allows
me to remove silly std::tie() and <tuple> includes from most example
code.
pull/617/head
Vladimír Vondruš 3 years ago
parent
06832574a2
commit
9bbbee6f56
10 changed files with 106 additions and 100 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      doc/changelog.dox
  2. 11
      doc/snippets/MagnumGL.cpp
  3. 12
      doc/snippets/MagnumMeshTools-gl.cpp
  4. 12
      doc/snippets/MagnumMeshTools.cpp
  5. 33
      src/Magnum/MeshTools/CompressIndices.cpp
  6. 20
      src/Magnum/MeshTools/CompressIndices.h
  7. 17
      src/Magnum/MeshTools/RemoveDuplicates.cpp
  8. 13
      src/Magnum/MeshTools/RemoveDuplicates.h
  9. 57
      src/Magnum/MeshTools/Test/CompressIndicesTest.cpp
  10. 28
      src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp

3
doc/changelog.dox
Unescape View File

@ -1304,6 +1304,9 @@ See also:
@ref GL::Buffer::setLabel() "setLabel()" APIs now work with a @ref GL::Buffer::setLabel() "setLabel()" APIs now work with a
@relativeref{Corrade,Containers::StringView} / @relativeref{Corrade,Containers::StringView} /
@relativeref{Corrade,Containers::String} instead of a @ref std::string @relativeref{Corrade,Containers::String} instead of a @ref std::string
- @ref MeshTools::compressIndices(), @ref MeshTools::removeDuplicates()
and related APIs now return a @relativeref{Corrade,Containers::Pair}
instead of a @ref std::pair
- @ref Vk::DescriptorPoolCreateInfo and @ref Vk::AttachmentDescription - @ref Vk::DescriptorPoolCreateInfo and @ref Vk::AttachmentDescription
APIs now take a @relativeref{Corrade,Containers::Pair} instead of a APIs now take a @relativeref{Corrade,Containers::Pair} instead of a
@ref std::pair @ref std::pair

11
doc/snippets/MagnumGL.cpp
Unescape View File

@ -23,9 +23,9 @@
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <tuple> /* for std::tie() :( */
#include <Corrade/Containers/ArrayViewStl.h> #include <Corrade/Containers/ArrayViewStl.h>
#include <Corrade/Containers/Iterable.h> #include <Corrade/Containers/Iterable.h>
#include <Corrade/Containers/Pair.h>
#include <Corrade/Containers/Reference.h> #include <Corrade/Containers/Reference.h>
#include <Corrade/Containers/StringIterable.h> #include <Corrade/Containers/StringIterable.h>
#include <Corrade/Containers/StringView.h> #include <Corrade/Containers/StringView.h>
@ -1146,13 +1146,12 @@ mesh.addVertexBuffer(vertices, 0,
GL::Mesh mesh; GL::Mesh mesh;
const UnsignedInt indexData[1]{}; const UnsignedInt indexData[1]{};
/* [Mesh-indices-tool] */ /* [Mesh-indices-tool] */
Containers::Array<char> compressed; Containers::Pair<Containers::Array<char>, MeshIndexType> compressed =
MeshIndexType type; MeshTools::compressIndices(indexData);
std::tie(compressed, type) = MeshTools::compressIndices(indexData); GL::Buffer indices{compressed.first()};
GL::Buffer indices{compressed};
DOXYGEN_ELLIPSIS() DOXYGEN_ELLIPSIS()
mesh.setIndexBuffer(indices, 0, type); mesh.setIndexBuffer(indices, 0, compressed.second());
/* [Mesh-indices-tool] */ /* [Mesh-indices-tool] */
} }

12
doc/snippets/MagnumMeshTools-gl.cpp
Unescape View File

@ -23,7 +23,7 @@
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <tuple> /* for std::tie() :( */ #include <Corrade/Containers/Pair.h>
#include <Corrade/Containers/StridedArrayView.h> #include <Corrade/Containers/StridedArrayView.h>
#include "Magnum/GL/AbstractShaderProgram.h" #include "Magnum/GL/AbstractShaderProgram.h"
@ -36,6 +36,7 @@
#include "Magnum/Trade/MeshData.h" #include "Magnum/Trade/MeshData.h"
#ifdef MAGNUM_BUILD_DEPRECATED #ifdef MAGNUM_BUILD_DEPRECATED
#include <tuple>
#include <vector> #include <vector>
#endif #endif
@ -83,16 +84,15 @@ mesh.addVertexBuffer(std::move(vertices),
/* [compressIndices] */ /* [compressIndices] */
Containers::Array<UnsignedInt> indices; Containers::Array<UnsignedInt> indices;
Containers::Array<char> indexData; Containers::Pair<Containers::Array<char>, MeshIndexType> compressed =
MeshIndexType indexType; MeshTools::compressIndices(indices);
std::tie(indexData, indexType) = MeshTools::compressIndices(indices);
GL::Buffer indexBuffer; GL::Buffer indexBuffer;
indexBuffer.setData(indexData); indexBuffer.setData(compressed.first());
GL::Mesh mesh; GL::Mesh mesh;
mesh.setCount(indices.size()) mesh.setCount(indices.size())
.setIndexBuffer(indexBuffer, 0, indexType); .setIndexBuffer(indexBuffer, 0, compressed.second());
/* [compressIndices] */ /* [compressIndices] */
} }

12
doc/snippets/MagnumMeshTools.cpp
Unescape View File

@ -23,8 +23,8 @@
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#include <tuple>
#include <vector> #include <vector>
#include <Corrade/Containers/Pair.h>
#include "Magnum/Math/Color.h" #include "Magnum/Math/Color.h"
#include "Magnum/Math/FunctionsBatch.h" #include "Magnum/Math/FunctionsBatch.h"
@ -73,7 +73,7 @@ CORRADE_IGNORE_DEPRECATED_POP
/* [compressIndices-offset] */ /* [compressIndices-offset] */
Containers::ArrayView<const UnsignedInt> indices; Containers::ArrayView<const UnsignedInt> indices;
UnsignedInt offset = Math::min(indices); UnsignedInt offset = Math::min(indices);
std::pair<Containers::Array<char>, MeshIndexType> result = Containers::Pair<Containers::Array<char>, MeshIndexType> compressed =
MeshTools::compressIndices(indices, offset); MeshTools::compressIndices(indices, offset);
// use `offset` to adjust vertex attribute offset … // use `offset` to adjust vertex attribute offset …
@ -153,11 +153,9 @@ Trade::MeshData indexed{data.primitive(),
/* [removeDuplicates] */ /* [removeDuplicates] */
Containers::ArrayView<Vector3i> data; Containers::ArrayView<Vector3i> data;
std::size_t size; Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> unique =
Containers::Array<UnsignedInt> indices; MeshTools::removeDuplicatesInPlace(Containers::arrayCast<2, char>(data));
std::tie(indices, size) = MeshTools::removeDuplicatesInPlace( data = data.prefix(unique.second());
Containers::arrayCast<2, char>(data));
data = data.prefix(size);
/* [removeDuplicates] */ /* [removeDuplicates] */
} }

33
src/Magnum/MeshTools/CompressIndices.cpp
Unescape View File

@ -27,6 +27,7 @@
#include <cstring> #include <cstring>
#include <Corrade/Containers/Array.h> #include <Corrade/Containers/Array.h>
#include <Corrade/Containers/Pair.h>
#include <Corrade/Utility/Algorithms.h> #include <Corrade/Utility/Algorithms.h>
#include "Magnum/Math/FunctionsBatch.h" #include "Magnum/Math/FunctionsBatch.h"
@ -54,10 +55,10 @@ template<class T, class U> inline Containers::Array<char> compress(const Contain
return buffer; return buffer;
} }
template<class T> std::pair<Containers::Array<char>, MeshIndexType> compressIndicesImplementation(const Containers::StridedArrayView1D<const T>& indices, const MeshIndexType atLeast, const Long offset) { template<class T> Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndicesImplementation(const Containers::StridedArrayView1D<const T>& indices, const MeshIndexType atLeast, const Long offset) {
CORRADE_ASSERT(!isMeshIndexTypeImplementationSpecific(atLeast), CORRADE_ASSERT(!isMeshIndexTypeImplementationSpecific(atLeast),
"MeshTools::compressIndices(): can't compress to an implementation-specific index type" << reinterpret_cast<void*>(meshIndexTypeUnwrap(atLeast)), "MeshTools::compressIndices(): can't compress to an implementation-specific index type" << reinterpret_cast<void*>(meshIndexTypeUnwrap(atLeast)),
(std::pair<Containers::Array<char>, MeshIndexType>{nullptr, MeshIndexType::UnsignedInt})); (Containers::Pair<Containers::Array<char>, MeshIndexType>{nullptr, MeshIndexType::UnsignedInt}));
const UnsignedInt max = Math::max(indices) - offset; const UnsignedInt max = Math::max(indices) - offset;
Containers::Array<char> out; Containers::Array<char> out;
@ -86,31 +87,31 @@ template<class T> std::pair<Containers::Array<char>, MeshIndexType> compressIndi
} }
std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const MeshIndexType atLeast, const Long offset) { Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const MeshIndexType atLeast, const Long offset) {
return compressIndicesImplementation(indices, atLeast, offset); return compressIndicesImplementation(indices, atLeast, offset);
} }
std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const MeshIndexType atLeast, const Long offset) { Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const MeshIndexType atLeast, const Long offset) {
return compressIndicesImplementation(indices, atLeast, offset); return compressIndicesImplementation(indices, atLeast, offset);
} }
std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const MeshIndexType atLeast, const Long offset) { Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const MeshIndexType atLeast, const Long offset) {
return compressIndicesImplementation(indices, atLeast, offset); return compressIndicesImplementation(indices, atLeast, offset);
} }
std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const Long offset) { Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, const Long offset) {
return compressIndicesImplementation(indices, MeshIndexType::UnsignedShort, offset); return compressIndicesImplementation(indices, MeshIndexType::UnsignedShort, offset);
} }
std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const Long offset) { Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, const Long offset) {
return compressIndicesImplementation(indices, MeshIndexType::UnsignedShort, offset); return compressIndicesImplementation(indices, MeshIndexType::UnsignedShort, offset);
} }
std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Long offset) { Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, const Long offset) {
return compressIndicesImplementation(indices, MeshIndexType::UnsignedShort, offset); return compressIndicesImplementation(indices, MeshIndexType::UnsignedShort, offset);
} }
std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView2D<const char>& indices, const MeshIndexType atLeast, const Long offset) { Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView2D<const char>& indices, const MeshIndexType atLeast, const Long offset) {
CORRADE_ASSERT(indices.isContiguous<1>(), "MeshTools::compressIndices(): second view dimension is not contiguous", {}); CORRADE_ASSERT(indices.isContiguous<1>(), "MeshTools::compressIndices(): second view dimension is not contiguous", {});
if(indices.size()[1] == 4) if(indices.size()[1] == 4)
return compressIndicesImplementation(Containers::arrayCast<1, const UnsignedInt>(indices), atLeast, offset); return compressIndicesImplementation(Containers::arrayCast<1, const UnsignedInt>(indices), atLeast, offset);
@ -122,7 +123,7 @@ std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containe
} }
} }
std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView2D<const char>& indices, const Long offset) { Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView2D<const char>& indices, const Long offset) {
return compressIndices(indices, MeshIndexType::UnsignedShort, offset); return compressIndices(indices, MeshIndexType::UnsignedShort, offset);
} }
@ -142,7 +143,7 @@ Trade::MeshData compressIndices(Trade::MeshData&& data, MeshIndexType atLeast) {
/* Compress the indices */ /* Compress the indices */
UnsignedInt offset; UnsignedInt offset;
std::pair<Containers::Array<char>, MeshIndexType> result; Containers::Pair<Containers::Array<char>, MeshIndexType> result;
if(data.indexType() == MeshIndexType::UnsignedInt) { if(data.indexType() == MeshIndexType::UnsignedInt) {
auto indices = data.indices<UnsignedInt>(); auto indices = data.indices<UnsignedInt>();
offset = Math::min(indices); offset = Math::min(indices);
@ -172,8 +173,8 @@ Trade::MeshData compressIndices(Trade::MeshData&& data, MeshIndexType atLeast) {
data.attributeArraySize(i)}; data.attributeArraySize(i)};
} }
Trade::MeshIndexData indices{result.second, result.first}; Trade::MeshIndexData indices{result.second(), result.first()};
return Trade::MeshData{data.primitive(), std::move(result.first), indices, return Trade::MeshData{data.primitive(), std::move(result.first()), indices,
std::move(vertexData), std::move(attributeData), newVertexCount}; std::move(vertexData), std::move(attributeData), newVertexCount};
} }
@ -186,10 +187,8 @@ Trade::MeshData compressIndices(const Trade::MeshData& data, MeshIndexType atLea
#ifdef MAGNUM_BUILD_DEPRECATED #ifdef MAGNUM_BUILD_DEPRECATED
std::tuple<Containers::Array<char>, MeshIndexType, UnsignedInt, UnsignedInt> compressIndices(const std::vector<UnsignedInt>& indices) { std::tuple<Containers::Array<char>, MeshIndexType, UnsignedInt, UnsignedInt> compressIndices(const std::vector<UnsignedInt>& indices) {
const auto minmax = Math::minmax(indices); const auto minmax = Math::minmax(indices);
Containers::Array<char> data; Containers::Pair<Containers::Array<char>, MeshIndexType> dataType = compressIndices(indices, MeshIndexType::UnsignedByte);
MeshIndexType type; return std::make_tuple(std::move(dataType.first()), dataType.second(), minmax.first, minmax.second);
std::tie(data, type) = compressIndices(indices, MeshIndexType::UnsignedByte);
return std::make_tuple(std::move(data), type, minmax.first, minmax.second);
} }
template<class T> Containers::Array<T> compressIndicesAs(const std::vector<UnsignedInt>& indices) { template<class T> Containers::Array<T> compressIndicesAs(const std::vector<UnsignedInt>& indices) {

20
src/Magnum/MeshTools/CompressIndices.h
Unescape View File

@ -29,7 +29,6 @@
* @brief Function @ref Magnum::MeshTools::compressIndices() * @brief Function @ref Magnum::MeshTools::compressIndices()
*/ */
#include <utility>
#include <Corrade/Containers/Containers.h> #include <Corrade/Containers/Containers.h>
#include "Magnum/Mesh.h" #include "Magnum/Mesh.h"
@ -40,6 +39,9 @@
#include <Corrade/Utility/Macros.h> #include <Corrade/Utility/Macros.h>
#include <Corrade/Utility/StlForwardVector.h> #include <Corrade/Utility/StlForwardVector.h>
#include <Corrade/Utility/StlForwardTuple.h> #include <Corrade/Utility/StlForwardTuple.h>
/* The APIs used to return std::pair before */
#include <Corrade/Containers/PairStl.h>
#endif #endif
namespace Magnum { namespace MeshTools { namespace Magnum { namespace MeshTools {
@ -79,19 +81,19 @@ operation directly on a @ref Trade::MeshData instance.
The @p atLeast parameter is expected to not be an implementation-specific type. The @p atLeast parameter is expected to not be an implementation-specific type.
@see @ref isMeshIndexTypeImplementationSpecific() @see @ref isMeshIndexTypeImplementationSpecific()
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0);
/** /**
@overload @overload
@m_since{2020,06} @m_since{2020,06}
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0);
/** /**
@overload @overload
@m_since{2020,06} @m_since{2020,06}
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0);
/** /**
@overload @overload
@ -100,7 +102,7 @@ MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compre
Same as @ref compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>&, MeshIndexType, Long) Same as @ref compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>&, MeshIndexType, Long)
with @p atLeast set to @ref MeshIndexType::UnsignedShort. with @p atLeast set to @ref MeshIndexType::UnsignedShort.
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, Long offset); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>& indices, Long offset);
/** /**
@overload @overload
@ -109,7 +111,7 @@ MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compre
Same as @ref compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>&, MeshIndexType, Long) Same as @ref compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>&, MeshIndexType, Long)
with @p atLeast set to @ref MeshIndexType::UnsignedShort. with @p atLeast set to @ref MeshIndexType::UnsignedShort.
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, Long offset); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedShort>& indices, Long offset);
/** /**
@overload @overload
@ -118,7 +120,7 @@ MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compre
Same as @ref compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>&, MeshIndexType, Long) Same as @ref compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>&, MeshIndexType, Long)
with @p atLeast set to @ref MeshIndexType::UnsignedShort. with @p atLeast set to @ref MeshIndexType::UnsignedShort.
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, Long offset); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView1D<const UnsignedByte>& indices, Long offset);
/** /**
@brief Compress a type-erased index array @brief Compress a type-erased index array
@ -132,7 +134,7 @@ etc. overloads.
The @p atLeast parameter is expected to not be an implementation-specific type. The @p atLeast parameter is expected to not be an implementation-specific type.
@see @ref isMeshIndexTypeImplementationSpecific() @see @ref isMeshIndexTypeImplementationSpecific()
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView2D<const char>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView2D<const char>& indices, MeshIndexType atLeast = MeshIndexType::UnsignedShort, Long offset = 0);
/** /**
@overload @overload
@ -141,7 +143,7 @@ MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compre
Same as @ref compressIndices(const Containers::StridedArrayView2D<const char>&, MeshIndexType, Long) Same as @ref compressIndices(const Containers::StridedArrayView2D<const char>&, MeshIndexType, Long)
with @p atLeast set to @ref MeshIndexType::UnsignedShort. with @p atLeast set to @ref MeshIndexType::UnsignedShort.
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView2D<const char>& indices, Long offset); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<char>, MeshIndexType> compressIndices(const Containers::StridedArrayView2D<const char>& indices, Long offset);
/** /**
@brief Compress mesh data indices @brief Compress mesh data indices

17
src/Magnum/MeshTools/RemoveDuplicates.cpp
Unescape View File

@ -30,6 +30,7 @@
#include <numeric> #include <numeric>
#include <unordered_map> #include <unordered_map>
#include <Corrade/Containers/Array.h> #include <Corrade/Containers/Array.h>
#include <Corrade/Containers/Pair.h>
#include <Corrade/Containers/StridedArrayView.h> #include <Corrade/Containers/StridedArrayView.h>
#include <Corrade/Utility/Algorithms.h> #include <Corrade/Utility/Algorithms.h>
#include <Corrade/Utility/MurmurHash2.h> #include <Corrade/Utility/MurmurHash2.h>
@ -97,7 +98,7 @@ std::size_t removeDuplicatesInto(const Containers::StridedArrayView2D<const char
return table.size(); return table.size();
} }
std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicates(const Containers::StridedArrayView2D<const char>& data) { Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicates(const Containers::StridedArrayView2D<const char>& data) {
Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]}; Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
const std::size_t size = removeDuplicatesInto(data, indices); const std::size_t size = removeDuplicatesInto(data, indices);
return {std::move(indices), size}; return {std::move(indices), size};
@ -155,7 +156,7 @@ std::size_t removeDuplicatesInPlaceInto(const Containers::StridedArrayView2D<cha
return table.size(); return table.size();
} }
std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesInPlace(const Containers::StridedArrayView2D<char>& data) { Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesInPlace(const Containers::StridedArrayView2D<char>& data) {
Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]}; Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
const std::size_t size = removeDuplicatesInPlaceInto(data, indices); const std::size_t size = removeDuplicatesInPlaceInto(data, indices);
return {std::move(indices), size}; return {std::move(indices), size};
@ -174,9 +175,9 @@ template<class IndexType> std::size_t removeDuplicatesIndexedInPlaceImplementati
original order, which is an useful property. The float version has this original order, which is an useful property. The float version has this
inverted (having the *Indexed() variant as the main implementation) inverted (having the *Indexed() variant as the main implementation)
because the remapping there has to be done once for every dimension. */ because the remapping there has to be done once for every dimension. */
std::pair<Containers::Array<UnsignedInt>, std::size_t> result = removeDuplicatesInPlace(data); const Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> result = removeDuplicatesInPlace(data);
for(auto& i: indices) i = result.first[i]; for(auto& i: indices) i = result.first()[i];
return result.second; return result.second();
} }
} }
@ -348,7 +349,7 @@ template<class T> std::size_t removeDuplicatesFuzzyInPlaceIntoImplementation(con
return size; return size;
} }
template<class T> std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlaceImplementation(const Containers::StridedArrayView2D<T>& data, const T epsilon) { template<class T> Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlaceImplementation(const Containers::StridedArrayView2D<T>& data, const T epsilon) {
Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]}; Containers::Array<UnsignedInt> indices{NoInit, data.size()[0]};
const std::size_t size = removeDuplicatesFuzzyInPlaceIntoImplementation(data, indices, epsilon); const std::size_t size = removeDuplicatesFuzzyInPlaceIntoImplementation(data, indices, epsilon);
return {std::move(indices), size}; return {std::move(indices), size};
@ -356,11 +357,11 @@ template<class T> std::pair<Containers::Array<UnsignedInt>, std::size_t> removeD
} }
std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlace(const Containers::StridedArrayView2D<Float>& data, const Float epsilon) { Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlace(const Containers::StridedArrayView2D<Float>& data, const Float epsilon) {
return removeDuplicatesFuzzyInPlaceImplementation(data, epsilon); return removeDuplicatesFuzzyInPlaceImplementation(data, epsilon);
} }
std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlace(const Containers::StridedArrayView2D<Double>& data, const Double epsilon) { Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlace(const Containers::StridedArrayView2D<Double>& data, const Double epsilon) {
return removeDuplicatesFuzzyInPlaceImplementation(data, epsilon); return removeDuplicatesFuzzyInPlaceImplementation(data, epsilon);
} }

13
src/Magnum/MeshTools/RemoveDuplicates.h
Unescape View File

@ -29,8 +29,6 @@
* @brief Function @ref Magnum::MeshTools::removeDuplicatesInPlace(), @ref Magnum::MeshTools::removeDuplicatesIndexedInPlace() * @brief Function @ref Magnum::MeshTools::removeDuplicatesInPlace(), @ref Magnum::MeshTools::removeDuplicatesIndexedInPlace()
*/ */
#include <utility>
#include "Magnum/Magnum.h" #include "Magnum/Magnum.h"
#include "Magnum/Math/TypeTraits.h" #include "Magnum/Math/TypeTraits.h"
#include "Magnum/MeshTools/visibility.h" #include "Magnum/MeshTools/visibility.h"
@ -40,6 +38,9 @@
#include <vector> #include <vector>
#include <Corrade/Containers/ArrayViewStl.h> #include <Corrade/Containers/ArrayViewStl.h>
#include <Corrade/Containers/StridedArrayView.h> #include <Corrade/Containers/StridedArrayView.h>
/* The function used to return a std::pair */
#include <Corrade/Containers/PairStl.h>
#endif #endif
namespace Magnum { namespace MeshTools { namespace Magnum { namespace MeshTools {
@ -68,7 +69,7 @@ an index array pointing to original data locations.
@see @ref Corrade::Containers::StridedArrayView::isContiguous(), @see @ref Corrade::Containers::StridedArrayView::isContiguous(),
@ref removeDuplicatesInPlaceInto() @ref removeDuplicatesInPlaceInto()
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesInPlace(const Containers::StridedArrayView2D<char>& data); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesInPlace(const Containers::StridedArrayView2D<char>& data);
/** /**
@brief Remove duplicate data from given array in-place into given output index array @brief Remove duplicate data from given array in-place into given output index array
@ -95,7 +96,7 @@ Compared to @ref removeDuplicatesInPlace(const Containers::StridedArrayView2D<ch
this function doesn't modify the input data array in any way but instead this function doesn't modify the input data array in any way but instead
returns an index array pointing to original data locations. returns an index array pointing to original data locations.
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicates(const Containers::StridedArrayView2D<const char>& data); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicates(const Containers::StridedArrayView2D<const char>& data);
/** /**
@brief Remove duplicate data from given array into given output index array @brief Remove duplicate data from given array into given output index array
@ -173,13 +174,13 @@ If you want to remove duplicates in multiple incidental arrays, first remove
duplicates in each array separately and then combine the resulting index arrays duplicates in each array separately and then combine the resulting index arrays
back into a single one using @ref combineIndexedAttributes(). back into a single one using @ref combineIndexedAttributes().
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlace(const Containers::StridedArrayView2D<Float>& data, Float epsilon = Math::TypeTraits<Float>::epsilon()); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlace(const Containers::StridedArrayView2D<Float>& data, Float epsilon = Math::TypeTraits<Float>::epsilon());
/** /**
* @overload * @overload
* @m_since{2020,06} * @m_since{2020,06}
*/ */
MAGNUM_MESHTOOLS_EXPORT std::pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlace(const Containers::StridedArrayView2D<Double>& data, Double epsilon = Math::TypeTraits<Double>::epsilon()); MAGNUM_MESHTOOLS_EXPORT Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> removeDuplicatesFuzzyInPlace(const Containers::StridedArrayView2D<Double>& data, Double epsilon = Math::TypeTraits<Double>::epsilon());
/** /**
@brief Remove duplicate data from given array using fuzzy comparison in-place into given output index array @brief Remove duplicate data from given array using fuzzy comparison in-place into given output index array

57
src/Magnum/MeshTools/Test/CompressIndicesTest.cpp
Unescape View File

@ -25,6 +25,7 @@
#include <sstream> #include <sstream>
#include <Corrade/Containers/Array.h> #include <Corrade/Containers/Array.h>
#include <Corrade/Containers/Pair.h>
#include <Corrade/Containers/StridedArrayView.h> #include <Corrade/Containers/StridedArrayView.h>
#include <Corrade/TestSuite/Tester.h> #include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Container.h> #include <Corrade/TestSuite/Compare/Container.h>
@ -105,19 +106,19 @@ template<class T> void CompressIndicesTest::compressUnsignedByte() {
const T indices[]{1, 2, 3, 0, 4}; const T indices[]{1, 2, 3, 0, 4};
/* By default it has 16-byte type as minimum, override */ /* By default it has 16-byte type as minimum, override */
std::pair<Containers::Array<char>, MeshIndexType> out = Containers::Pair<Containers::Array<char>, MeshIndexType> out =
compressIndices(indices, MeshIndexType::UnsignedByte); compressIndices(indices, MeshIndexType::UnsignedByte);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedByte); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedByte);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(out.first()),
Containers::arrayView<UnsignedByte>({1, 2, 3, 0, 4}), Containers::arrayView<UnsignedByte>({1, 2, 3, 0, 4}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
/* Test the type-erased variant as well */ /* Test the type-erased variant as well */
out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)), MeshIndexType::UnsignedByte); out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)), MeshIndexType::UnsignedByte);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedByte); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedByte);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(out.first()),
Containers::arrayView<UnsignedByte>({1, 2, 3, 0, 4}), Containers::arrayView<UnsignedByte>({1, 2, 3, 0, 4}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }
@ -126,18 +127,18 @@ template<class T> void CompressIndicesTest::compressUnsignedShort() {
setTestCaseTemplateName(Math::TypeTraits<T>::name()); setTestCaseTemplateName(Math::TypeTraits<T>::name());
const T indices[]{1, 256, 0, 5}; const T indices[]{1, 256, 0, 5};
std::pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices); Containers::Pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedShort); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first()),
Containers::arrayView<UnsignedShort>({1, 256, 0, 5}), Containers::arrayView<UnsignedShort>({1, 256, 0, 5}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
/* Test the type-erased variant as well */ /* Test the type-erased variant as well */
out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices))); out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)));
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedShort); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first()),
Containers::arrayView<UnsignedShort>({1, 256, 0, 5}), Containers::arrayView<UnsignedShort>({1, 256, 0, 5}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }
@ -146,18 +147,18 @@ template<class T> void CompressIndicesTest::compressUnsignedInt() {
setTestCaseTemplateName(Math::TypeTraits<T>::name()); setTestCaseTemplateName(Math::TypeTraits<T>::name());
const T indices[]{65536, 3, 2}; const T indices[]{65536, 3, 2};
std::pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices); Containers::Pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedInt); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(out.first()),
Containers::arrayView<UnsignedInt>({65536, 3, 2}), Containers::arrayView<UnsignedInt>({65536, 3, 2}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
/* Test the type-erased variant as well */ /* Test the type-erased variant as well */
out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices))); out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)));
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedInt); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(out.first()),
Containers::arrayView<UnsignedInt>({65536, 3, 2}), Containers::arrayView<UnsignedInt>({65536, 3, 2}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }
@ -165,28 +166,28 @@ template<class T> void CompressIndicesTest::compressUnsignedInt() {
void CompressIndicesTest::compressUnsignedByteInflateToShort() { void CompressIndicesTest::compressUnsignedByteInflateToShort() {
const UnsignedByte indices[]{1, 2, 3, 0, 4}; const UnsignedByte indices[]{1, 2, 3, 0, 4};
/* That's the default */ /* That's the default */
std::pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices); Containers::Pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedShort); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first()),
Containers::arrayView<UnsignedShort>({1, 2, 3, 0, 4}), Containers::arrayView<UnsignedShort>({1, 2, 3, 0, 4}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }
void CompressIndicesTest::compressOffset() { void CompressIndicesTest::compressOffset() {
const UnsignedInt indices[]{75000 + 1, 75000 + 256, 75000 + 0, 75000 + 5}; const UnsignedInt indices[]{75000 + 1, 75000 + 256, 75000 + 0, 75000 + 5};
std::pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices, 75000); Containers::Pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices, 75000);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedShort); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first()),
Containers::arrayView<UnsignedShort>({1, 256, 0, 5}), Containers::arrayView<UnsignedShort>({1, 256, 0, 5}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
/* Test the type-erased variant as well */ /* Test the type-erased variant as well */
out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)), 75000); out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)), 75000);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedShort); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(out.first()),
Containers::arrayView<UnsignedShort>({1, 256, 0, 5}), Containers::arrayView<UnsignedShort>({1, 256, 0, 5}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }
@ -195,18 +196,18 @@ template<class T> void CompressIndicesTest::compressOffsetNegative() {
setTestCaseTemplateName(Math::TypeTraits<T>::name()); setTestCaseTemplateName(Math::TypeTraits<T>::name());
const T indices[]{1, 255, 0, 5}; const T indices[]{1, 255, 0, 5};
std::pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices, -75000); Containers::Pair<Containers::Array<char>, MeshIndexType> out = compressIndices(indices, -75000);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedInt); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(out.first()),
Containers::arrayView<UnsignedInt>({75000 + 1, 75000 + 255, 75000 + 0, 75000 + 5}), Containers::arrayView<UnsignedInt>({75000 + 1, 75000 + 255, 75000 + 0, 75000 + 5}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
/* Test the type-erased variant as well */ /* Test the type-erased variant as well */
out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)), -75000); out = compressIndices(Containers::arrayCast<2, const char>(Containers::stridedArrayView(indices)), -75000);
CORRADE_COMPARE(out.second, MeshIndexType::UnsignedInt); CORRADE_COMPARE(out.second(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(out.first), CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(out.first()),
Containers::arrayView<UnsignedInt>({75000 + 1, 75000 + 255, 75000 + 0, 75000 + 5}), Containers::arrayView<UnsignedInt>({75000 + 1, 75000 + 255, 75000 + 0, 75000 + 5}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }

28
src/Magnum/MeshTools/Test/RemoveDuplicatesTest.cpp
Unescape View File

@ -27,6 +27,7 @@
#include <random> /* random device for std::shuffle() */ #include <random> /* random device for std::shuffle() */
#include <sstream> #include <sstream>
#include <Corrade/Containers/GrowableArray.h> #include <Corrade/Containers/GrowableArray.h>
#include <Corrade/Containers/Pair.h>
#include <Corrade/TestSuite/Tester.h> #include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Container.h> #include <Corrade/TestSuite/Compare/Container.h>
#include <Corrade/Utility/DebugStl.h> #include <Corrade/Utility/DebugStl.h>
@ -266,18 +267,19 @@ RemoveDuplicatesTest::RemoveDuplicatesTest() {
void RemoveDuplicatesTest::removeDuplicates() { void RemoveDuplicatesTest::removeDuplicates() {
Int data[]{-15, 32, 24, -15, 15, 7541, 24, 32}; Int data[]{-15, 32, 24, -15, 15, 7541, 24, 32};
std::pair<Containers::Array<UnsignedInt>, std::size_t> result = Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> result =
MeshTools::removeDuplicates(Containers::arrayCast<2, char>(Containers::arrayView(data))); MeshTools::removeDuplicates(Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE_AS(Containers::arrayView(result.first), CORRADE_COMPARE_AS(Containers::arrayView(result.first()),
Containers::arrayView<UnsignedInt>({0, 1, 2, 0, 4, 5, 2, 1}), Containers::arrayView<UnsignedInt>({0, 1, 2, 0, 4, 5, 2, 1}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
CORRADE_COMPARE(result.second(), 5);
std::pair<Containers::Array<UnsignedInt>, std::size_t> resultInPlace = Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> resultInPlace =
MeshTools::removeDuplicatesInPlace(Containers::arrayCast<2, char>(Containers::arrayView(data))); MeshTools::removeDuplicatesInPlace(Containers::arrayCast<2, char>(Containers::arrayView(data)));
CORRADE_COMPARE_AS(Containers::arrayView(resultInPlace.first), CORRADE_COMPARE_AS(Containers::arrayView(resultInPlace.first()),
Containers::arrayView<UnsignedInt>({0, 1, 2, 0, 3, 4, 2, 1}), Containers::arrayView<UnsignedInt>({0, 1, 2, 0, 3, 4, 2, 1}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(resultInPlace.second), CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(resultInPlace.second()),
Containers::arrayView<Int>({-15, 32, 24, 15, 7541}), Containers::arrayView<Int>({-15, 32, 24, 15, 7541}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }
@ -421,14 +423,14 @@ template<class T> void RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceOneDime
T(3.4) /* bucket 3 in 1st iteration, bucket 3 in 2nd */ T(3.4) /* bucket 3 in 1st iteration, bucket 3 in 2nd */
}; };
std::pair<Containers::Array<UnsignedInt>, std::size_t> result = Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> result =
MeshTools::removeDuplicatesFuzzyInPlace( MeshTools::removeDuplicatesFuzzyInPlace(
Containers::arrayCast<2, T>(Containers::stridedArrayView(data)), Containers::arrayCast<2, T>(Containers::stridedArrayView(data)),
T(1.00001)); T(1.00001));
CORRADE_COMPARE_AS(Containers::arrayView(result.first), CORRADE_COMPARE_AS(Containers::arrayView(result.first()),
Containers::arrayView<UnsignedInt>({0, 1, 0, 1}), Containers::arrayView<UnsignedInt>({0, 1, 0, 1}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(result.second), CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(result.second()),
(Containers::arrayView<T>({T(1.0), T(2.9)})), (Containers::arrayView<T>({T(1.0), T(2.9)})),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }
@ -446,14 +448,14 @@ template<class T> void RemoveDuplicatesTest::removeDuplicatesFuzzyInPlaceMoreDim
{T(1.0), T(5.0)} {T(1.0), T(5.0)}
}; };
std::pair<Containers::Array<UnsignedInt>, std::size_t> result = Containers::Pair<Containers::Array<UnsignedInt>, std::size_t> result =
MeshTools::removeDuplicatesFuzzyInPlace( MeshTools::removeDuplicatesFuzzyInPlace(
Containers::arrayCast<2, T>(Containers::stridedArrayView(data)), Containers::arrayCast<2, T>(Containers::stridedArrayView(data)),
T(2.0)); T(2.0));
CORRADE_COMPARE_AS(Containers::arrayView(result.first), CORRADE_COMPARE_AS(Containers::arrayView(result.first()),
Containers::arrayView<UnsignedInt>({0, 0, 1, 1}), Containers::arrayView<UnsignedInt>({0, 0, 1, 1}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(result.second), CORRADE_COMPARE_AS(Containers::arrayView(data).prefix(result.second()),
Containers::arrayView<Math::Vector2<T>>({{T(1.0), T(0.0)}, {T(0.0), T(4.0)}}), Containers::arrayView<Math::Vector2<T>>({{T(1.0), T(0.0)}, {T(0.0), T(4.0)}}),
TestSuite::Compare::Container); TestSuite::Compare::Container);
} }
@ -1215,7 +1217,7 @@ void RemoveDuplicatesTest::soakTest() {
CORRADE_COMPARE(MeshTools::removeDuplicatesInPlace( CORRADE_COMPARE(MeshTools::removeDuplicatesInPlace(
Containers::StridedArrayView2D<char>{ Containers::StridedArrayView2D<char>{
Containers::arrayCast<char>(Containers::arrayView(data)), {1000, 4}} Containers::arrayCast<char>(Containers::arrayView(data)), {1000, 4}}
).second, 100); ).second(), 100);
} }
void RemoveDuplicatesTest::soakTestFuzzy() { void RemoveDuplicatesTest::soakTestFuzzy() {
@ -1226,7 +1228,7 @@ void RemoveDuplicatesTest::soakTestFuzzy() {
std::shuffle(std::begin(data), std::end(data), std::minstd_rand{std::random_device{}()}); std::shuffle(std::begin(data), std::end(data), std::minstd_rand{std::random_device{}()});
CORRADE_COMPARE(MeshTools::removeDuplicatesFuzzyInPlace( CORRADE_COMPARE(MeshTools::removeDuplicatesFuzzyInPlace(
Containers::arrayCast<2, Float>(Containers::arrayView(data))).second, Containers::arrayCast<2, Float>(Containers::arrayView(data))).second(),
100); 100);
} }

Write Preview
Loading…
Cancel
Save