|
|
#include "nmVolumeDataBuilder.h"
|
|
|
|
|
|
#include <QCoreApplication>
|
|
|
#include <QMap>
|
|
|
#include <QUuid>
|
|
|
#include <limits>
|
|
|
#include <new>
|
|
|
#include <vtkCellArray.h>
|
|
|
#include <vtkCellData.h>
|
|
|
#include <vtkCellType.h>
|
|
|
#include <vtkDataArray.h>
|
|
|
#include <vtkDoubleArray.h>
|
|
|
#include <vtkIdTypeArray.h>
|
|
|
#include <vtkMath.h>
|
|
|
#include <vtkPointData.h>
|
|
|
#include <vtkPoints.h>
|
|
|
#include <vtkUnsignedCharArray.h>
|
|
|
#include <vtkUnstructuredGrid.h>
|
|
|
|
|
|
namespace {
|
|
|
// 固定文本标记供 Qt 4 lupdate 提取；运行期通过统一上下文翻译。
|
|
|
static const char* const s_pVolumeTranslationMarkers[] = {
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "Not enough memory to import the volume mesh."),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "Only linear tetrahedron, voxel, hexahedron, wedge and pyramid volume cells are supported."),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "Skipped invalid scalar array: %1"),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "Skipped scalar array without finite values: %1"),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "The file contains no volume mesh."),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "The mesh connectivity is invalid."),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "The mesh contains an invalid point index."),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "The mesh contains non-finite coordinates."),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "The mesh contains repeated cell vertices."),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "The mesh must have a finite extent in all three directions."),
|
|
|
QT_TRANSLATE_NOOP("nmVolumeData", "Volume import canceled.")
|
|
|
};
|
|
|
|
|
|
/** @brief 数据层使用固定翻译上下文，避免依赖界面类。 */
|
|
|
QString volumeText(const char* pText)
|
|
|
{
|
|
|
Q_UNUSED(s_pVolumeTranslationMarkers);
|
|
|
return QCoreApplication::translate("nmVolumeData", pText);
|
|
|
}
|
|
|
/** @brief 可选反馈的取消查询，适用于所有较长的校验和属性复制循环。 */
|
|
|
bool canceled(nmVolumeImportFeedback* pFeedback)
|
|
|
{
|
|
|
return pFeedback != nullptr && pFeedback->isCanceled();
|
|
|
}
|
|
|
/** @brief 返回首版支持体单元的固定顶点数；零值表示明确不支持。 */
|
|
|
int expectedPointCount(int nCellType)
|
|
|
{
|
|
|
switch(nCellType) {
|
|
|
case VTK_TETRA: return 4;
|
|
|
case VTK_VOXEL: case VTK_HEXAHEDRON: return 8;
|
|
|
case VTK_WEDGE: return 6;
|
|
|
case VTK_PYRAMID: return 5;
|
|
|
default: return 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QSharedPointer<const nmVolumeData> nmVolumeDataBuilder::buildFromGrid(
|
|
|
vtkUnstructuredGrid* pGrid, const QString& sSourceName,
|
|
|
QString* pError, nmVolumeImportFeedback* pFeedback)
|
|
|
{
|
|
|
if(pError != nullptr) pError->clear();
|
|
|
QString sError;
|
|
|
try {
|
|
|
do {
|
|
|
if(canceled(pFeedback)) break;
|
|
|
if(pGrid == nullptr || pGrid->GetNumberOfPoints() <= 0 ||
|
|
|
pGrid->GetNumberOfCells() <= 0) {
|
|
|
sError = volumeText("The file contains no volume mesh.");
|
|
|
break;
|
|
|
}
|
|
|
const vtkIdType nPointCount = pGrid->GetNumberOfPoints();
|
|
|
const vtkIdType nCellCount = pGrid->GetNumberOfCells();
|
|
|
vtkCellArray* pCells = pGrid->GetCells();
|
|
|
vtkUnsignedCharArray* pTypes = pGrid->GetCellTypesArray();
|
|
|
vtkIdTypeArray* pLocations = pGrid->GetCellLocationsArray();
|
|
|
vtkIdTypeArray* pConnectivity = pCells == nullptr ? nullptr : pCells->GetData();
|
|
|
if(pConnectivity == nullptr || pTypes == nullptr || pLocations == nullptr ||
|
|
|
pTypes->GetNumberOfTuples() != nCellCount ||
|
|
|
pLocations->GetNumberOfTuples() != nCellCount ||
|
|
|
pTypes->GetNumberOfComponents() != 1 ||
|
|
|
pLocations->GetNumberOfComponents() != 1 ||
|
|
|
pConnectivity->GetNumberOfComponents() != 1) {
|
|
|
sError = volumeText("The mesh connectivity is invalid.");
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// 先按原始连接数组边界校验，再调用 VTK 的复制/渲染 API，避免非法索引被解引用。
|
|
|
vtkIdType nOffset = 0;
|
|
|
const vtkIdType nConnectivitySize = pConnectivity->GetNumberOfTuples();
|
|
|
for(vtkIdType nCell = 0; nCell < nCellCount; ++nCell) {
|
|
|
if((nCell % 4096) == 0 && canceled(pFeedback)) break;
|
|
|
const int nExpected = expectedPointCount(pTypes->GetValue(nCell));
|
|
|
if(nExpected == 0) {
|
|
|
sError = volumeText("Only linear tetrahedron, voxel, hexahedron, wedge and pyramid volume cells are supported.");
|
|
|
break;
|
|
|
}
|
|
|
if(nOffset >= nConnectivitySize || pLocations->GetValue(nCell) != nOffset ||
|
|
|
pConnectivity->GetValue(nOffset) != nExpected ||
|
|
|
nConnectivitySize - nOffset - 1 < nExpected) {
|
|
|
sError = volumeText("The mesh connectivity is invalid.");
|
|
|
break;
|
|
|
}
|
|
|
for(int nLocal = 0; nLocal < nExpected; ++nLocal) {
|
|
|
const vtkIdType nPoint = pConnectivity->GetValue(nOffset + 1 + nLocal);
|
|
|
if(nPoint < 0 || nPoint >= nPointCount) {
|
|
|
sError = volumeText("The mesh contains an invalid point index.");
|
|
|
break;
|
|
|
}
|
|
|
// 固定线性体单元中重复顶点通常表示损坏或退化拓扑。
|
|
|
for(int nPrevious = 0; nPrevious < nLocal; ++nPrevious) {
|
|
|
if(nPoint == pConnectivity->GetValue(nOffset + 1 + nPrevious)) {
|
|
|
sError = volumeText("The mesh contains repeated cell vertices.");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if(!sError.isEmpty()) break;
|
|
|
}
|
|
|
if(!sError.isEmpty()) break;
|
|
|
nOffset += nExpected + 1;
|
|
|
}
|
|
|
if(canceled(pFeedback) || !sError.isEmpty()) break;
|
|
|
if(nOffset != nConnectivitySize) {
|
|
|
sError = volumeText("The mesh connectivity is invalid.");
|
|
|
break;
|
|
|
}
|
|
|
for(vtkIdType nPoint = 0; nPoint < nPointCount; ++nPoint) {
|
|
|
if((nPoint % 4096) == 0 && canceled(pFeedback)) break;
|
|
|
double dPoint[3];
|
|
|
pGrid->GetPoint(nPoint, dPoint);
|
|
|
if(!vtkMath::IsFinite(dPoint[0]) || !vtkMath::IsFinite(dPoint[1]) ||
|
|
|
!vtkMath::IsFinite(dPoint[2])) {
|
|
|
sError = volumeText("The mesh contains non-finite coordinates.");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if(canceled(pFeedback) || !sError.isEmpty()) break;
|
|
|
QSharedPointer<nmVolumeData> pCandidate(new nmVolumeData);
|
|
|
pGrid->GetBounds(pCandidate->m_dBounds);
|
|
|
for(int nAxis = 0; nAxis < 3; ++nAxis) {
|
|
|
const double dLength = pCandidate->m_dBounds[nAxis * 2 + 1] -
|
|
|
pCandidate->m_dBounds[nAxis * 2];
|
|
|
if(!vtkMath::IsFinite(dLength) || dLength <= 0.0) {
|
|
|
sError = volumeText("The mesh must have a finite extent in all three directions.");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if(!sError.isEmpty()) break;
|
|
|
if(pFeedback != nullptr) pFeedback->reportProgress(65);
|
|
|
|
|
|
// 只复制几何拓扑；属性逐项规范化，避免复制无效数组和多分量大载荷。
|
|
|
vtkSmartPointer<vtkUnstructuredGrid> pStructure = vtkSmartPointer<vtkUnstructuredGrid>::New();
|
|
|
pStructure->CopyStructure(pGrid);
|
|
|
pCandidate->m_pGrid->DeepCopy(pStructure);
|
|
|
QString sActiveProperty;
|
|
|
for(int nAssociation = 0; nAssociation < 2 && !canceled(pFeedback); ++nAssociation) {
|
|
|
vtkDataSetAttributes* pSource = nAssociation == 0
|
|
|
? static_cast<vtkDataSetAttributes*>(pGrid->GetCellData())
|
|
|
: static_cast<vtkDataSetAttributes*>(pGrid->GetPointData());
|
|
|
vtkDataSetAttributes* pTarget = nAssociation == 0
|
|
|
? static_cast<vtkDataSetAttributes*>(pCandidate->m_pGrid->GetCellData())
|
|
|
: static_cast<vtkDataSetAttributes*>(pCandidate->m_pGrid->GetPointData());
|
|
|
const vtkIdType nTupleCount = nAssociation == 0 ? nCellCount : nPointCount;
|
|
|
QMap<QString, int> mapNameCounts;
|
|
|
for(int nArray = 0; nArray < pSource->GetNumberOfArrays(); ++nArray) {
|
|
|
const char* pName = pSource->GetArrayName(nArray);
|
|
|
if(pName != nullptr) ++mapNameCounts[QString::fromUtf8(pName)];
|
|
|
}
|
|
|
for(int nArray = 0; nArray < pSource->GetNumberOfArrays() && !canceled(pFeedback); ++nArray) {
|
|
|
vtkDataArray* pArray = pSource->GetArray(nArray);
|
|
|
const char* pName = pSource->GetArrayName(nArray);
|
|
|
const QString sName = pName == nullptr ? QString() : QString::fromUtf8(pName);
|
|
|
if(pArray == nullptr || sName.isEmpty() || mapNameCounts.value(sName) != 1 ||
|
|
|
pArray->GetNumberOfComponents() != 1 || pArray->GetNumberOfTuples() != nTupleCount) {
|
|
|
pCandidate->m_listDiagnostics.append(volumeText("Skipped invalid scalar array: %1").arg(sName));
|
|
|
continue;
|
|
|
}
|
|
|
vtkSmartPointer<vtkDoubleArray> pValues = vtkSmartPointer<vtkDoubleArray>::New();
|
|
|
pValues->SetName(sName.toUtf8().constData());
|
|
|
pValues->SetNumberOfTuples(nTupleCount);
|
|
|
double dMinimum = VTK_DOUBLE_MAX;
|
|
|
double dMaximum = -VTK_DOUBLE_MAX;
|
|
|
for(vtkIdType nTuple = 0; nTuple < nTupleCount; ++nTuple) {
|
|
|
if((nTuple % 4096) == 0 && canceled(pFeedback)) break;
|
|
|
double dValue = pArray->GetComponent(nTuple, 0);
|
|
|
if(vtkMath::IsFinite(dValue)) {
|
|
|
dMinimum = qMin(dMinimum, dValue);
|
|
|
dMaximum = qMax(dMaximum, dValue);
|
|
|
} else {
|
|
|
dValue = std::numeric_limits<double>::quiet_NaN();
|
|
|
}
|
|
|
pValues->SetValue(nTuple, dValue);
|
|
|
}
|
|
|
if(canceled(pFeedback)) break;
|
|
|
if(dMinimum > dMaximum) {
|
|
|
pCandidate->m_listDiagnostics.append(volumeText("Skipped scalar array without finite values: %1").arg(sName));
|
|
|
continue;
|
|
|
}
|
|
|
nmVolumePropertyDescriptor oProperty;
|
|
|
oProperty.m_eAssociation = nAssociation == 0 ? NM_VolumeProperty_CellData : NM_VolumeProperty_PointData;
|
|
|
oProperty.m_sArrayName = sName;
|
|
|
oProperty.m_sPropertyId = (nAssociation == 0 ? QString::fromLatin1("cell:") : QString::fromLatin1("point:")) + sName;
|
|
|
oProperty.m_dMinimum = dMinimum;
|
|
|
oProperty.m_dMaximum = dMaximum;
|
|
|
pCandidate->m_vecProperties.append(oProperty);
|
|
|
pTarget->AddArray(pValues);
|
|
|
if(pArray == pSource->GetScalars() && sActiveProperty.isEmpty()) sActiveProperty = oProperty.m_sPropertyId;
|
|
|
// 提前生成范围缓存；GUI 绑定时不再扫描整份标量。
|
|
|
double dCachedRange[2];
|
|
|
pValues->GetRange(dCachedRange);
|
|
|
}
|
|
|
if(pFeedback != nullptr) pFeedback->reportProgress(80 + nAssociation * 15);
|
|
|
}
|
|
|
if(canceled(pFeedback)) break;
|
|
|
pCandidate->m_sInitialPropertyId = sActiveProperty;
|
|
|
if(sActiveProperty.isEmpty() && !pCandidate->m_vecProperties.isEmpty()) {
|
|
|
pCandidate->m_sInitialPropertyId = pCandidate->m_vecProperties.first().m_sPropertyId;
|
|
|
}
|
|
|
pCandidate->m_sDataId = QUuid::createUuid().toString();
|
|
|
pCandidate->m_sSourceName = sSourceName;
|
|
|
if(pFeedback != nullptr) pFeedback->reportProgress(100);
|
|
|
return pCandidate;
|
|
|
} while(false);
|
|
|
} catch(const std::bad_alloc&) {
|
|
|
sError = volumeText("Not enough memory to import the volume mesh.");
|
|
|
}
|
|
|
if(pError != nullptr) {
|
|
|
*pError = canceled(pFeedback) ? volumeText("Volume import canceled.") : sError;
|
|
|
}
|
|
|
return QSharedPointer<const nmVolumeData>();
|
|
|
}
|