assimp/code/PostProcessing/FindInvalidDataProcess.cpp

410 lines
15 KiB
C++
Raw Normal View History

/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------
2021-02-28 11:17:54 +00:00
Copyright (c) 2006-2021, assimp team
2018-01-28 18:42:05 +00:00
All rights reserved.
2015-05-19 03:52:10 +00:00
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.
2015-05-19 03:52:10 +00:00
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
2015-05-19 03:52:10 +00:00
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2015-05-19 03:52:10 +00:00
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2015-05-19 03:52:10 +00:00
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
/** @file Defines a post processing step to search an importer's output
for data that is obviously invalid */
#ifndef ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS
// internal headers
#include "FindInvalidDataProcess.h"
#include "ProcessHelper.h"
#include <assimp/Exceptional.h>
#include <assimp/qnan.h>
using namespace Assimp;
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
2020-03-15 11:16:17 +00:00
FindInvalidDataProcess::FindInvalidDataProcess() :
configEpsilon(0.0), mIgnoreTexCoods(false) {
2015-05-19 03:57:13 +00:00
// nothing to do here
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
FindInvalidDataProcess::~FindInvalidDataProcess() {
2015-05-19 03:57:13 +00:00
// nothing to do here
}
// ------------------------------------------------------------------------------------------------
// Returns whether the processing step is present in the given flag field.
2020-03-15 11:16:17 +00:00
bool FindInvalidDataProcess::IsActive(unsigned int pFlags) const {
2015-05-19 03:57:13 +00:00
return 0 != (pFlags & aiProcess_FindInvalidData);
}
// ------------------------------------------------------------------------------------------------
// Setup import configuration
2020-03-15 11:16:17 +00:00
void FindInvalidDataProcess::SetupProperties(const Importer *pImp) {
2015-05-19 03:57:13 +00:00
// Get the current value of AI_CONFIG_PP_FID_ANIM_ACCURACY
2020-03-15 11:16:17 +00:00
configEpsilon = (0 != pImp->GetPropertyFloat(AI_CONFIG_PP_FID_ANIM_ACCURACY, 0.f));
mIgnoreTexCoods = pImp->GetPropertyBool(AI_CONFIG_PP_FID_IGNORE_TEXTURECOORDS, false);
}
// ------------------------------------------------------------------------------------------------
// Update mesh references in the node graph
2020-03-15 11:16:17 +00:00
void UpdateMeshReferences(aiNode *node, const std::vector<unsigned int> &meshMapping) {
if (node->mNumMeshes) {
2015-05-19 03:57:13 +00:00
unsigned int out = 0;
2020-03-15 11:16:17 +00:00
for (unsigned int a = 0; a < node->mNumMeshes; ++a) {
2015-05-19 03:57:13 +00:00
unsigned int ref = node->mMeshes[a];
2020-03-15 11:16:17 +00:00
if (UINT_MAX != (ref = meshMapping[ref])) {
2015-05-19 03:57:13 +00:00
node->mMeshes[out++] = ref;
}
}
// just let the members that are unused, that's much cheaper
// than a full array realloc'n'copy party ...
2020-03-15 11:16:17 +00:00
node->mNumMeshes = out;
if (0 == out) {
2015-05-19 03:57:13 +00:00
delete[] node->mMeshes;
node->mMeshes = nullptr;
2015-05-19 03:57:13 +00:00
}
}
// recursively update all children
2020-03-15 11:16:17 +00:00
for (unsigned int i = 0; i < node->mNumChildren; ++i) {
UpdateMeshReferences(node->mChildren[i], meshMapping);
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
// Executes the post processing step on the given imported data.
2020-03-15 11:16:17 +00:00
void FindInvalidDataProcess::Execute(aiScene *pScene) {
2018-04-26 12:10:18 +00:00
ASSIMP_LOG_DEBUG("FindInvalidDataProcess begin");
2015-05-19 03:57:13 +00:00
bool out = false;
std::vector<unsigned int> meshMapping(pScene->mNumMeshes);
unsigned int real = 0;
// Process meshes
2020-03-15 11:16:17 +00:00
for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
2020-02-16 14:37:20 +00:00
int result = ProcessMesh(pScene->mMeshes[a]);
2020-03-15 11:16:17 +00:00
if (0 == result) {
2015-05-19 03:57:13 +00:00
out = true;
2020-03-15 11:16:17 +00:00
}
if (2 == result) {
// remove this mesh
delete pScene->mMeshes[a];
pScene->mMeshes[a] = nullptr;
2015-05-19 03:57:13 +00:00
2020-03-15 11:16:17 +00:00
meshMapping[a] = UINT_MAX;
out = true;
2020-03-15 11:16:17 +00:00
continue;
2015-05-19 03:57:13 +00:00
}
2020-03-15 11:16:17 +00:00
2015-05-19 03:57:13 +00:00
pScene->mMeshes[real] = pScene->mMeshes[a];
meshMapping[a] = real++;
}
// Process animations
2020-03-15 11:16:17 +00:00
for (unsigned int animIdx = 0; animIdx < pScene->mNumAnimations; ++animIdx) {
ProcessAnimation(pScene->mAnimations[animIdx]);
2015-05-19 03:57:13 +00:00
}
2020-03-15 11:16:17 +00:00
if (out) {
if (real != pScene->mNumMeshes) {
2015-05-19 03:57:13 +00:00
if (!real) {
throw DeadlyImportError("No meshes remaining");
}
// we need to remove some meshes.
// therefore we'll also need to remove all references
// to them from the scenegraph
2020-03-15 11:16:17 +00:00
UpdateMeshReferences(pScene->mRootNode, meshMapping);
2015-05-19 03:57:13 +00:00
pScene->mNumMeshes = real;
}
2018-04-26 12:10:18 +00:00
ASSIMP_LOG_INFO("FindInvalidDataProcess finished. Found issues ...");
} else {
ASSIMP_LOG_DEBUG("FindInvalidDataProcess finished. Everything seems to be OK.");
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
template <typename T>
2020-03-15 11:16:17 +00:00
inline const char *ValidateArrayContents(const T * /*arr*/, unsigned int /*size*/,
const std::vector<bool> & /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/) {
return nullptr;
}
// ------------------------------------------------------------------------------------------------
template <>
2020-03-15 11:16:17 +00:00
inline const char *ValidateArrayContents<aiVector3D>(const aiVector3D *arr, unsigned int size,
const std::vector<bool> &dirtyMask, bool mayBeIdentical, bool mayBeZero) {
2015-05-19 03:57:13 +00:00
bool b = false;
unsigned int cnt = 0;
2020-03-15 11:16:17 +00:00
for (unsigned int i = 0; i < size; ++i) {
2015-05-19 03:57:13 +00:00
if (dirtyMask.size() && dirtyMask[i]) {
continue;
}
++cnt;
2020-03-15 11:16:17 +00:00
const aiVector3D &v = arr[i];
if (is_special_float(v.x) || is_special_float(v.y) || is_special_float(v.z)) {
2015-05-19 03:57:13 +00:00
return "INF/NAN was found in a vector component";
}
2020-03-15 11:16:17 +00:00
if (!mayBeZero && !v.x && !v.y && !v.z) {
2015-05-19 03:57:13 +00:00
return "Found zero-length vector";
}
2020-03-15 11:16:17 +00:00
if (i && v != arr[i - 1]) b = true;
2015-05-19 03:57:13 +00:00
}
if (cnt > 1 && !b && !mayBeIdentical) {
return "All vectors are identical";
}
return nullptr;
}
// ------------------------------------------------------------------------------------------------
template <typename T>
2020-03-15 11:16:17 +00:00
inline bool ProcessArray(T *&in, unsigned int num, const char *name,
const std::vector<bool> &dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true) {
const char *err = ValidateArrayContents(in, num, dirtyMask, mayBeIdentical, mayBeZero);
if (err) {
ASSIMP_LOG_ERROR_F("FindInvalidDataProcess fails on mesh ", name, ": ", err);
2015-05-19 03:57:13 +00:00
delete[] in;
in = nullptr;
2015-05-19 03:57:13 +00:00
return true;
}
return false;
}
// ------------------------------------------------------------------------------------------------
template <typename T>
2020-03-15 11:16:17 +00:00
AI_FORCE_INLINE bool EpsilonCompare(const T &n, const T &s, ai_real epsilon);
// ------------------------------------------------------------------------------------------------
AI_FORCE_INLINE bool EpsilonCompare(ai_real n, ai_real s, ai_real epsilon) {
2020-03-15 11:16:17 +00:00
return std::fabs(n - s) > epsilon;
}
// ------------------------------------------------------------------------------------------------
template <>
2020-03-15 11:16:17 +00:00
bool EpsilonCompare<aiVectorKey>(const aiVectorKey &n, const aiVectorKey &s, ai_real epsilon) {
return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) &&
EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) &&
EpsilonCompare(n.mValue.z, s.mValue.z, epsilon);
}
// ------------------------------------------------------------------------------------------------
template <>
2020-03-15 11:16:17 +00:00
bool EpsilonCompare<aiQuatKey>(const aiQuatKey &n, const aiQuatKey &s, ai_real epsilon) {
return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) &&
EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) &&
EpsilonCompare(n.mValue.z, s.mValue.z, epsilon) &&
EpsilonCompare(n.mValue.w, s.mValue.w, epsilon);
}
// ------------------------------------------------------------------------------------------------
template <typename T>
2020-03-15 11:16:17 +00:00
inline bool AllIdentical(T *in, unsigned int num, ai_real epsilon) {
2015-05-19 03:57:13 +00:00
if (num <= 1) {
return true;
}
if (fabs(epsilon) > 0.f) {
2020-03-15 11:16:17 +00:00
for (unsigned int i = 0; i < num - 1; ++i) {
if (!EpsilonCompare(in[i], in[i + 1], epsilon)) {
2015-05-19 03:57:13 +00:00
return false;
}
}
} else {
2020-03-15 11:16:17 +00:00
for (unsigned int i = 0; i < num - 1; ++i) {
if (in[i] != in[i + 1]) {
2015-05-19 03:57:13 +00:00
return false;
}
}
}
return true;
}
// ------------------------------------------------------------------------------------------------
// Search an animation for invalid content
2020-03-15 11:16:17 +00:00
void FindInvalidDataProcess::ProcessAnimation(aiAnimation *anim) {
2015-05-19 03:57:13 +00:00
// Process all animation channels
2020-03-15 11:16:17 +00:00
for (unsigned int a = 0; a < anim->mNumChannels; ++a) {
ProcessAnimationChannel(anim->mChannels[a]);
2015-05-19 03:57:13 +00:00
}
}
// ------------------------------------------------------------------------------------------------
2020-03-15 11:16:17 +00:00
void FindInvalidDataProcess::ProcessAnimationChannel(aiNodeAnim *anim) {
ai_assert(nullptr != anim);
if (anim->mNumPositionKeys == 0 && anim->mNumRotationKeys == 0 && anim->mNumScalingKeys == 0) {
ai_assert_entry();
return;
}
2015-05-19 03:57:13 +00:00
// Check whether all values in a tracks are identical - in this case
// we can remove al keys except one.
// POSITIONS
int i = 0;
2020-03-15 11:16:17 +00:00
if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys, anim->mNumPositionKeys, configEpsilon)) {
2015-05-19 03:57:13 +00:00
aiVectorKey v = anim->mPositionKeys[0];
// Reallocate ... we need just ONE element, it makes no sense to reuse the array
delete[] anim->mPositionKeys;
anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys = 1];
anim->mPositionKeys[0] = v;
i = 1;
}
// ROTATIONS
2020-03-15 11:16:17 +00:00
if (anim->mNumRotationKeys > 1 && AllIdentical(anim->mRotationKeys, anim->mNumRotationKeys, configEpsilon)) {
2015-05-19 03:57:13 +00:00
aiQuatKey v = anim->mRotationKeys[0];
// Reallocate ... we need just ONE element, it makes no sense to reuse the array
delete[] anim->mRotationKeys;
anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys = 1];
anim->mRotationKeys[0] = v;
i = 1;
}
// SCALINGS
2020-03-15 11:16:17 +00:00
if (anim->mNumScalingKeys > 1 && AllIdentical(anim->mScalingKeys, anim->mNumScalingKeys, configEpsilon)) {
2015-05-19 03:57:13 +00:00
aiVectorKey v = anim->mScalingKeys[0];
// Reallocate ... we need just ONE element, it makes no sense to reuse the array
delete[] anim->mScalingKeys;
anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys = 1];
anim->mScalingKeys[0] = v;
i = 1;
}
2020-03-15 11:16:17 +00:00
if (1 == i) {
2018-04-19 15:21:21 +00:00
ASSIMP_LOG_WARN("Simplified dummy tracks with just one key");
}
}
// ------------------------------------------------------------------------------------------------
// Search a mesh for invalid contents
2020-03-15 11:16:17 +00:00
int FindInvalidDataProcess::ProcessMesh(aiMesh *pMesh) {
2015-05-19 03:57:13 +00:00
bool ret = false;
2017-11-25 10:38:12 +00:00
std::vector<bool> dirtyMask(pMesh->mNumVertices, pMesh->mNumFaces != 0);
2015-05-19 03:57:13 +00:00
// Ignore elements that are not referenced by vertices.
// (they are, for example, caused by the FindDegenerates step)
2017-10-31 19:18:08 +00:00
for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) {
2020-03-15 11:16:17 +00:00
const aiFace &f = pMesh->mFaces[m];
2015-05-19 03:57:13 +00:00
2017-10-31 19:18:08 +00:00
for (unsigned int i = 0; i < f.mNumIndices; ++i) {
2015-05-19 03:57:13 +00:00
dirtyMask[f.mIndices[i]] = false;
}
}
// Process vertex positions
2017-10-31 19:18:08 +00:00
if (pMesh->mVertices && ProcessArray(pMesh->mVertices, pMesh->mNumVertices, "positions", dirtyMask)) {
2018-04-26 12:10:18 +00:00
ASSIMP_LOG_ERROR("Deleting mesh: Unable to continue without vertex positions");
2017-10-31 19:18:08 +00:00
2015-05-19 03:57:13 +00:00
return 2;
}
// process texture coordinates
if (!mIgnoreTexCoods) {
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS && pMesh->mTextureCoords[i]; ++i) {
if (ProcessArray(pMesh->mTextureCoords[i], pMesh->mNumVertices, "uvcoords", dirtyMask)) {
pMesh->mNumUVComponents[i] = 0;
// delete all subsequent texture coordinate sets.
for (unsigned int a = i + 1; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
delete[] pMesh->mTextureCoords[a];
pMesh->mTextureCoords[a] = nullptr;
pMesh->mNumUVComponents[a] = 0;
}
ret = true;
2015-05-19 03:57:13 +00:00
}
}
}
// -- we don't validate vertex colors, it's difficult to say whether
// they are invalid or not.
// Normals and tangents are undefined for point and line faces.
2020-03-15 11:16:17 +00:00
if (pMesh->mNormals || pMesh->mTangents) {
2015-05-19 03:57:13 +00:00
if (aiPrimitiveType_POINT & pMesh->mPrimitiveTypes ||
2020-03-15 11:16:17 +00:00
aiPrimitiveType_LINE & pMesh->mPrimitiveTypes) {
2015-05-19 03:57:13 +00:00
if (aiPrimitiveType_TRIANGLE & pMesh->mPrimitiveTypes ||
2020-03-15 11:16:17 +00:00
aiPrimitiveType_POLYGON & pMesh->mPrimitiveTypes) {
2015-05-19 03:57:13 +00:00
// We need to update the lookup-table
2020-03-15 11:16:17 +00:00
for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) {
const aiFace &f = pMesh->mFaces[m];
2015-05-19 03:57:13 +00:00
2020-03-15 11:16:17 +00:00
if (f.mNumIndices < 3) {
2015-05-19 03:57:13 +00:00
dirtyMask[f.mIndices[0]] = true;
if (f.mNumIndices == 2) {
dirtyMask[f.mIndices[1]] = true;
}
}
}
}
// Normals, tangents and bitangents are undefined for
// the whole mesh (and should not even be there)
else {
return ret;
}
2015-05-19 03:57:13 +00:00
}
// Process mesh normals
2020-03-15 11:16:17 +00:00
if (pMesh->mNormals && ProcessArray(pMesh->mNormals, pMesh->mNumVertices,
"normals", dirtyMask, true, false))
2015-05-19 03:57:13 +00:00
ret = true;
// Process mesh tangents
2020-03-15 11:16:17 +00:00
if (pMesh->mTangents && ProcessArray(pMesh->mTangents, pMesh->mNumVertices, "tangents", dirtyMask)) {
delete[] pMesh->mBitangents;
pMesh->mBitangents = nullptr;
2015-05-19 03:57:13 +00:00
ret = true;
}
// Process mesh bitangents
2020-03-15 11:16:17 +00:00
if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents, pMesh->mNumVertices, "bitangents", dirtyMask)) {
delete[] pMesh->mTangents;
pMesh->mTangents = nullptr;
2015-05-19 03:57:13 +00:00
ret = true;
}
}
return ret ? 1 : 0;
}
#endif // !! ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS