|
|
#include "FITKPolyDataTool.h"
|
|
|
|
|
|
#include "qmath.h"
|
|
|
|
|
|
#include <QVector3D>
|
|
|
#include <vtkCellData.h>
|
|
|
#include <vtkIdList.h>
|
|
|
#include <vtkLine.h>
|
|
|
#include <vtkMath.h>
|
|
|
#include <vtkPolyData.h>
|
|
|
#include <vtkIntArray.h>
|
|
|
|
|
|
#include <vtkPolygon.h>
|
|
|
|
|
|
namespace Common
|
|
|
{
|
|
|
FITKPolyDataTool::FITKPolyDataTool(vtkPolyData* poly, vtkDataArray* normal)
|
|
|
: _poly(poly), _normals(normal)
|
|
|
{
|
|
|
m_scanPointCoPlaneFlag = vtkIntArray::New();
|
|
|
m_scanPointCoPlaneFlag->SetNumberOfComponents(1);
|
|
|
|
|
|
int ptNum = _poly->GetNumberOfPoints();
|
|
|
for (int iPt = 0; iPt < ptNum; ++iPt)
|
|
|
{
|
|
|
QVector3D pt;
|
|
|
double pos[3] = { .0 };
|
|
|
_poly->GetPoint(iPt, pos);
|
|
|
pt.setX(pos[0]);
|
|
|
pt.setY(pos[1]);
|
|
|
pt.setZ(pos[2]);
|
|
|
_points.insert(iPt, pt);
|
|
|
|
|
|
m_scanPointCoPlaneFlag->InsertNextValue(0);
|
|
|
}
|
|
|
|
|
|
// 初始化数组，全部置空标识。
|
|
|
int nCell = _poly->GetNumberOfCells();
|
|
|
|
|
|
m_scanCellFlag = vtkIntArray::New();
|
|
|
m_scanCellFlag->SetNumberOfComponents(1);
|
|
|
m_scanCellFlag->SetNumberOfValues(nCell);
|
|
|
m_scanCellFlag->FillComponent(0, 0);
|
|
|
|
|
|
m_scanCellCoPlaneFlag = vtkIntArray::New();
|
|
|
m_scanCellCoPlaneFlag->SetNumberOfComponents(1);
|
|
|
m_scanCellCoPlaneFlag->SetNumberOfValues(nCell);
|
|
|
m_scanCellCoPlaneFlag->FillComponent(0, 0);
|
|
|
}
|
|
|
|
|
|
FITKPolyDataTool::~FITKPolyDataTool()
|
|
|
{
|
|
|
// 析构。
|
|
|
if (m_scanCellFlag)
|
|
|
{
|
|
|
m_scanCellFlag->Delete();
|
|
|
m_scanCellFlag = nullptr;
|
|
|
}
|
|
|
|
|
|
if (m_scanCellCoPlaneFlag)
|
|
|
{
|
|
|
m_scanCellCoPlaneFlag->Delete();
|
|
|
m_scanCellCoPlaneFlag = nullptr;
|
|
|
}
|
|
|
|
|
|
if (m_scanPointCoPlaneFlag)
|
|
|
{
|
|
|
m_scanPointCoPlaneFlag->Delete();
|
|
|
m_scanPointCoPlaneFlag = nullptr;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
QList< int > FITKPolyDataTool::getCoPlanePointIDs(int seedID, double angleHold)
|
|
|
{
|
|
|
//错误输入判断
|
|
|
if (_poly == nullptr || angleHold < 0 || angleHold >= 180 || !m_scanPointCoPlaneFlag) return QList< int >();
|
|
|
vtkSmartPointer<vtkIdList> cellids = vtkSmartPointer<vtkIdList>::New();
|
|
|
_poly->GetPointCells(seedID, cellids);
|
|
|
//选择一个节点所在的单元，作为起始种子点
|
|
|
if (cellids->GetNumberOfIds() == 0) return QList< int >();
|
|
|
const int acell = cellids->GetId(0);
|
|
|
//获取在同一个平面的单元
|
|
|
QList< int > neighborCells = this->getCoPlaneCellIDs(acell, angleHold);
|
|
|
for (int cell : neighborCells)
|
|
|
{
|
|
|
vtkSmartPointer<vtkIdList> cellPointIds = vtkSmartPointer<vtkIdList>::New();
|
|
|
_poly->GetCellPoints(cell, cellPointIds);
|
|
|
for (vtkIdType i = 0; i < cellPointIds->GetNumberOfIds(); i++)
|
|
|
{
|
|
|
int pt = cellPointIds->GetId(i);
|
|
|
|
|
|
// Modified by CHT
|
|
|
//@{
|
|
|
m_scanPointCoPlaneFlag->SetValue(pt, 1);
|
|
|
// if (!cellPoints.contains(pt)) cellPoints.append(pt);
|
|
|
//@}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Added by CHT
|
|
|
//@{
|
|
|
QList< int > cellPoints;
|
|
|
|
|
|
int nPt = m_scanPointCoPlaneFlag->GetNumberOfValues();
|
|
|
for (int i = 0; i < nPt; i++)
|
|
|
{
|
|
|
if (m_scanPointCoPlaneFlag->GetValue(i))
|
|
|
{
|
|
|
cellPoints.push_back(i);
|
|
|
}
|
|
|
}
|
|
|
//@}
|
|
|
|
|
|
qSort(cellPoints);
|
|
|
return cellPoints;
|
|
|
}
|
|
|
|
|
|
QList< int > FITKPolyDataTool::getCoPlaneCellIDs(int seedID, double angleHold)
|
|
|
{
|
|
|
if (_poly == nullptr || _normals == nullptr) return QList< int >();
|
|
|
|
|
|
// Modified by CHT 修改记录单元方式。
|
|
|
//@{
|
|
|
m_scanCellCoPlaneFlag->SetValue(seedID, 1);
|
|
|
QList< int > afWave = { seedID };
|
|
|
|
|
|
//QList< int > coPlaneIDs{ seedID };
|
|
|
//QList< int > scanedCell = coPlaneIDs;
|
|
|
//QList< int > afWave = coPlaneIDs;
|
|
|
//@}
|
|
|
|
|
|
while (!afWave.isEmpty())
|
|
|
{
|
|
|
QList< int > tempAF = afWave;
|
|
|
afWave.clear();
|
|
|
QList< CELLPAIR > afRound;
|
|
|
//计算所有最外层单元的邻接单元
|
|
|
for (int cellID : tempAF)
|
|
|
{
|
|
|
QList< CELLPAIR > pa = getNeighborCell(cellID/*, scanedCell*/);
|
|
|
afRound.append(pa);
|
|
|
}
|
|
|
//计算法向夹角，产生新的最外层单元
|
|
|
for (CELLPAIR p : afRound)
|
|
|
{
|
|
|
const int cell0 = p.second, cell1 = p.first;
|
|
|
double normal0[3] = { 0, 0, 0 }, normal1[3] = { 0, 0, 0 };
|
|
|
// vtkPolygon::ComputeNormal(_poly->GetCell(cell0)->GetPoints(), normal0);
|
|
|
_normals->GetTuple(cell0, normal0);
|
|
|
double norm0 = vtkMath::Norm(normal0);
|
|
|
// vtkPolygon::ComputeNormal(_poly->GetCell(cell1)->GetPoints(), normal1);
|
|
|
_normals->GetTuple(cell1, normal1);
|
|
|
double norm1 = vtkMath::Norm(normal1);
|
|
|
double numerator = normal0[0] * normal1[0] + normal0[1] * normal1[1] + normal0[2] * normal1[2];
|
|
|
double value = numerator / (norm0 * norm1);
|
|
|
value = value > 0.99999999999999 ? 0.99999999999999 : value;
|
|
|
|
|
|
double angle1 = acos(value) * 180.0 / 3.141592654;
|
|
|
if (angle1 <= angleHold)
|
|
|
{
|
|
|
// Modified by CHT 修改记录单元方式。
|
|
|
//@{
|
|
|
if (!m_scanCellCoPlaneFlag->GetValue(cell1)) afWave.append(cell1);
|
|
|
m_scanCellCoPlaneFlag->SetValue(cell1, 1);
|
|
|
//@}
|
|
|
|
|
|
// if (!coPlaneIDs.contains(cell1)) coPlaneIDs.append(cell1);
|
|
|
}
|
|
|
|
|
|
// Modified by CHT 将表示设置为true，后续跳过检索。
|
|
|
//@{
|
|
|
m_scanCellFlag->SetValue(cell1, 1);
|
|
|
//@}
|
|
|
// if (!scanedCell.contains(cell1)) scanedCell.append(cell1);
|
|
|
}
|
|
|
|
|
|
afRound.clear();
|
|
|
}
|
|
|
|
|
|
// Added by CHT 通过标识数组获取共面单元。
|
|
|
//@{
|
|
|
QList<int> coPlaneIDs;
|
|
|
int nCell = m_scanCellCoPlaneFlag->GetNumberOfValues();
|
|
|
for (int i = 0; i < nCell; i++)
|
|
|
{
|
|
|
if (m_scanCellCoPlaneFlag->GetValue(i))
|
|
|
{
|
|
|
coPlaneIDs.push_back(i);
|
|
|
}
|
|
|
}
|
|
|
//@}
|
|
|
|
|
|
return coPlaneIDs;
|
|
|
}
|
|
|
|
|
|
QList< int > FITKPolyDataTool::getNormalSingularID(const int seedID, const QList< int >& eles)
|
|
|
{
|
|
|
if (_poly == nullptr || _normals == nullptr || !eles.contains(seedID)) return QList< int >();
|
|
|
|
|
|
QList< int > singualIDs;
|
|
|
|
|
|
QList< int > coPlaneIDs{ seedID };
|
|
|
QList< int > scanedCell = coPlaneIDs;
|
|
|
QList< int > afWave = coPlaneIDs;
|
|
|
|
|
|
while (!afWave.isEmpty())
|
|
|
{
|
|
|
QList< int > tempAF = afWave;
|
|
|
afWave.clear();
|
|
|
QList< CELLPAIR > afRound;
|
|
|
//计算所有最外层单元的邻接单元
|
|
|
for (int cellID : tempAF)
|
|
|
{
|
|
|
QList< CELLPAIR > pa = getNeighborCell(cellID/*, scanedCell*/);
|
|
|
afRound.append(pa);
|
|
|
}
|
|
|
//计算法向夹角，产生新的最外层单元
|
|
|
for (CELLPAIR p : afRound)
|
|
|
{
|
|
|
const int cell0 = p.second, cell1 = p.first;
|
|
|
if (!eles.contains(cell0) || !eles.contains(cell1))
|
|
|
continue;
|
|
|
|
|
|
double normal0[3] = { 0, 0, 0 }, normal1[3] = { 0, 0, 0 };
|
|
|
this->calculateCellNormal(cell0, normal0);
|
|
|
double norm0 = vtkMath::Norm(normal0);
|
|
|
this->calculateCellNormal(cell1, normal1);
|
|
|
double norm1 = vtkMath::Norm(normal1);
|
|
|
if (singualIDs.contains(cell0))
|
|
|
vtkMath::MultiplyScalar(normal0, -1);
|
|
|
// if (singualIDs.contains(cell1))
|
|
|
// vtkMath::MultiplyScalar(normal1, -1);
|
|
|
|
|
|
double numerator = normal0[0] * normal1[0] + normal0[1] * normal1[1] + normal0[2] * normal1[2];
|
|
|
double angle1 = acos(numerator / (norm0 * norm1)) * 180.0 / 3.141592654;
|
|
|
|
|
|
if (angle1 <= 180)
|
|
|
{
|
|
|
if (!afWave.contains(cell1)) afWave.append(cell1);
|
|
|
if (!coPlaneIDs.contains(cell1)) coPlaneIDs.append(cell1);
|
|
|
if (angle1 > 90 && !scanedCell.contains(cell1))
|
|
|
singualIDs.append(cell1);
|
|
|
}
|
|
|
if (!scanedCell.contains(cell1)) scanedCell.append(cell1);
|
|
|
}
|
|
|
afRound.clear();
|
|
|
}
|
|
|
return singualIDs;
|
|
|
}
|
|
|
|
|
|
int FITKPolyDataTool::getCellIdFromEdgePoint(int pointID, bool& isFirst)
|
|
|
{
|
|
|
if (_poly == nullptr ||
|
|
|
pointID < 0 ||
|
|
|
pointID > _poly->GetNumberOfPoints())
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
auto cellNum = _poly->GetNumberOfCells();
|
|
|
for (int iCell = 0; iCell < cellNum; ++iCell)
|
|
|
{
|
|
|
auto cell = _poly->GetCell(iCell);
|
|
|
if (!cell)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
auto idList = cell->GetPointIds();
|
|
|
if (idList->GetNumberOfIds() != 2)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
auto id0 = idList->GetId(0);
|
|
|
auto id1 = idList->GetId(1);
|
|
|
|
|
|
if (id0 == pointID)
|
|
|
{
|
|
|
isFirst = true;
|
|
|
return iCell;
|
|
|
}
|
|
|
else if (id1 == pointID)
|
|
|
{
|
|
|
isFirst = false;
|
|
|
return iCell;
|
|
|
}
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
QList< int > FITKPolyDataTool::getEdgePointsByAngle(int pointID, double angle)
|
|
|
{
|
|
|
/// 对传入参数进行合法性筛选
|
|
|
QSet< int > result;
|
|
|
if (!_poly ||
|
|
|
pointID < 0 ||
|
|
|
pointID >= _poly->GetNumberOfPoints() ||
|
|
|
angle < 0 ||
|
|
|
angle > 90)
|
|
|
{
|
|
|
return result.toList();
|
|
|
}
|
|
|
|
|
|
/// 获取所有该选取点所在单元
|
|
|
vtkSmartPointer<vtkIdList> cellIDs = vtkSmartPointer<vtkIdList>::New();
|
|
|
_poly->GetPointCells(pointID, cellIDs);
|
|
|
int iCellNum = cellIDs->GetNumberOfIds();
|
|
|
|
|
|
/// 当前在此处对正反向单元只保留一个，提高效率，后续根据业务可能需要添加逻辑
|
|
|
QList< QPair< int, int > > linePointRelation;
|
|
|
for (int iCell = 0; iCell < iCellNum; ++iCell)
|
|
|
{
|
|
|
/// 基于线单元查找线单元所在的所有单元
|
|
|
int cellID = cellIDs->GetId(iCell);
|
|
|
vtkCell* cell = _poly->GetCell(cellID);
|
|
|
int findCellPt0 = cell->GetPointId(0);
|
|
|
int findCellPt1 = cell->GetPointId(1);
|
|
|
QPair< int, int > direction1(findCellPt0, findCellPt1), direction2(findCellPt1, findCellPt0);
|
|
|
if (linePointRelation.contains(direction1) ||
|
|
|
linePointRelation.contains(direction2))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
linePointRelation.append(direction1);
|
|
|
|
|
|
/// 基于获取的单元进行逐单元双向查找
|
|
|
QList< int > lines = getEdgeLinesByAngle(cellID, angle);
|
|
|
for (int findCellID : lines)
|
|
|
{
|
|
|
vtkCell* findCell = _poly->GetCell(findCellID);
|
|
|
if (!cell) { return result.toList(); }
|
|
|
|
|
|
result.insert(findCell->GetPointId(0));
|
|
|
result.insert(findCell->GetPointId(1));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return result.toList();
|
|
|
}
|
|
|
|
|
|
QList< int > FITKPolyDataTool::getEdgeLinesByAngle(int cellID, double angle)
|
|
|
{
|
|
|
/// 对输入参数进行合法性检查
|
|
|
QSet< int > lines;
|
|
|
if (!_poly ||
|
|
|
cellID < 0 ||
|
|
|
cellID >= _poly->GetNumberOfCells() ||
|
|
|
angle < 0 ||
|
|
|
angle > 90 ||
|
|
|
_poly->GetCell(cellID)->GetCellType() != VTK_LINE)
|
|
|
{
|
|
|
return lines.toList();
|
|
|
}
|
|
|
lines.insert(cellID);
|
|
|
|
|
|
/// 获取线单元首点方向、尾点方向向下查找的所有单元
|
|
|
for (int pointIndex = 0; pointIndex <= 1; ++pointIndex)
|
|
|
{
|
|
|
/// 首次进入，或单方向完成、确认查找的起始单元及查找方向
|
|
|
int nextPointIndex = pointIndex;
|
|
|
int nextCellID = cellID;
|
|
|
|
|
|
/// 循环直至该方向不存在符合条件的后续线单元
|
|
|
while (true)
|
|
|
{
|
|
|
int p0 = _poly->GetCell(nextCellID)->GetPointId(0);
|
|
|
int p1 = _poly->GetCell(nextCellID)->GetPointId(1);
|
|
|
|
|
|
nextCellID = getNextEdgeLineByAngle(nextCellID, nextPointIndex, angle);
|
|
|
if (nextCellID < 0) { break; }
|
|
|
if (lines.contains(nextCellID)) { break; }
|
|
|
|
|
|
/// 准备下一个节点向下推导
|
|
|
lines.insert(nextCellID);
|
|
|
|
|
|
int p2 = _poly->GetCell(nextCellID)->GetPointId(0);
|
|
|
int p3 = _poly->GetCell(nextCellID)->GetPointId(1);
|
|
|
Q_UNUSED(p3);
|
|
|
|
|
|
/// 查找到单元中不与初始单元共用的节点所在方向为下次查找方向
|
|
|
if (nextPointIndex == 0)
|
|
|
{
|
|
|
if (p2 == p0)
|
|
|
{
|
|
|
nextPointIndex = 1;
|
|
|
}
|
|
|
else
|
|
|
nextPointIndex = 0;
|
|
|
}
|
|
|
else if (nextPointIndex == 1)
|
|
|
{
|
|
|
if (p1 == p2)
|
|
|
{
|
|
|
nextPointIndex = 1;
|
|
|
}
|
|
|
else
|
|
|
nextPointIndex = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return lines.toList();
|
|
|
}
|
|
|
|
|
|
int FITKPolyDataTool::getCellIDbyPtID(int pt1ID, int pt2ID)
|
|
|
{
|
|
|
vtkSmartPointer<vtkIdList> cellIDs = vtkSmartPointer<vtkIdList>::New();
|
|
|
_poly->GetPointCells(pt1ID, cellIDs);
|
|
|
int cellNum = cellIDs->GetNumberOfIds();
|
|
|
for (int iCell = 0; iCell < cellNum; ++iCell)
|
|
|
{
|
|
|
int cellID = cellIDs->GetId(iCell);
|
|
|
vtkCell* cell = _poly->GetCell(cellID);
|
|
|
int cellPt0ID = cell->GetPointId(0);
|
|
|
int cellPt1ID = cell->GetPointId(1);
|
|
|
|
|
|
if ((pt1ID == cellPt0ID && pt2ID == cellPt1ID) ||
|
|
|
(pt2ID == cellPt0ID && pt1ID == cellPt1ID))
|
|
|
{
|
|
|
return cellID;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
int FITKPolyDataTool::getNextEdgeLineByAngle(int cellID, int pointIndex, double angle)
|
|
|
{
|
|
|
/// 对输入变量进行有效性判定，由于是私有内部接口，上层函数中进行了校验，本函数无需校验，若需暴露外部使用，需放开
|
|
|
if (!_poly ||
|
|
|
cellID < 0 ||
|
|
|
cellID >= _poly->GetNumberOfCells() ||
|
|
|
(pointIndex != 0 && pointIndex != 1) ||
|
|
|
angle > 90 ||
|
|
|
angle < 0)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
/// 构造输入单元向量
|
|
|
double p0[3] = { 0 }, p1[3] = { 0 };
|
|
|
vtkCell* cell = _poly->GetCell(cellID);
|
|
|
int pt1ID = cell->GetPointId(0);
|
|
|
int pt2ID = cell->GetPointId(1);
|
|
|
_poly->GetPoint(pt1ID, p0);
|
|
|
_poly->GetPoint(pt2ID, p1);
|
|
|
double vec1[3] = { p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2] };
|
|
|
|
|
|
/// 查找推导方向上，节点所有单元
|
|
|
int ptID = cell->GetPointId(pointIndex);
|
|
|
vtkSmartPointer< vtkIdList > cellIDs = vtkSmartPointer< vtkIdList >::New();
|
|
|
_poly->GetPointCells(ptID, cellIDs);
|
|
|
int cellsNum = cellIDs->GetNumberOfIds();
|
|
|
|
|
|
QMap< double, int > nextLineDegrees;
|
|
|
for (int iCell = 0; iCell < cellsNum; ++iCell)
|
|
|
{
|
|
|
int findCellID = cellIDs->GetId(iCell);
|
|
|
|
|
|
/// 该单元为当前查找单元，跳过查找下一个
|
|
|
if (findCellID == cellID) { continue; }
|
|
|
|
|
|
/// 存在当前查找到单元使用节点相同，顺序相反情况，这种情况不能作为最优解，该单元应因正反面情况后生成的，后续是否可考虑优化掉
|
|
|
vtkCell* cell = _poly->GetCell(findCellID);
|
|
|
int findPt1ID = cell->GetPointId(0);
|
|
|
int findPt2ID = cell->GetPointId(1);
|
|
|
|
|
|
if ((findPt1ID == pt2ID && findPt2ID == pt1ID) ||
|
|
|
(findPt1ID == pt1ID && findPt2ID == pt2ID))
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
/// 构造查找到的线单元向量
|
|
|
double p2[3] = { 0 }, p3[3] = { 0 };
|
|
|
_poly->GetPoint(findPt1ID, p2);
|
|
|
_poly->GetPoint(findPt2ID, p3);
|
|
|
double vec2[3] = { p3[0] - p2[0], p3[1] - p2[1], p3[2] - p2[2] };
|
|
|
|
|
|
/// 计算两个线单元夹角，不考虑矢量方向，按照最小夹角进行数据记录
|
|
|
double currentAngle = vtkMath::Dot(vec1, vec2) / (vtkMath::Norm(vec1) * vtkMath::Norm(vec2));
|
|
|
currentAngle = acos(currentAngle) * 180 / M_PI;
|
|
|
if (currentAngle >= 90)
|
|
|
{
|
|
|
currentAngle = 180 - currentAngle;
|
|
|
}
|
|
|
|
|
|
nextLineDegrees.insert(currentAngle, findCellID);
|
|
|
}
|
|
|
|
|
|
/// 返回符合角度要求的最小夹角线单元
|
|
|
if (nextLineDegrees.isEmpty()) { return -1; }
|
|
|
double minAngle = nextLineDegrees.firstKey();
|
|
|
if (minAngle < angle)
|
|
|
{
|
|
|
return nextLineDegrees.first();
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
QList< int > FITKPolyDataTool::getEdgeLinesByDirectionAndAngle(int cellID, double angle, bool endWithCross /*= false */)
|
|
|
{
|
|
|
/// 对输入参数进行合法性检查
|
|
|
QList< int > lookupCellIDs, finishedCellIDs;
|
|
|
if (!_poly || cellID < 0 || cellID >= _poly->GetNumberOfCells() || angle < 0 || angle > 90 || _poly->GetCell(cellID)->GetCellType() != VTK_LINE) { return finishedCellIDs; }
|
|
|
lookupCellIDs.append(cellID);
|
|
|
finishedCellIDs.append(cellID);
|
|
|
|
|
|
while (!lookupCellIDs.isEmpty())
|
|
|
{
|
|
|
int current = lookupCellIDs.takeFirst();
|
|
|
QList< int > ids = getNextEdgeLineByDirectionAndAngle(current, true, angle, endWithCross);
|
|
|
|
|
|
for (int id : ids)
|
|
|
{
|
|
|
if (finishedCellIDs.contains(id) || id < 0) { continue; }
|
|
|
lookupCellIDs.append(id);
|
|
|
finishedCellIDs.append(id);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// 向上查找
|
|
|
lookupCellIDs.append(cellID);
|
|
|
while (!lookupCellIDs.isEmpty())
|
|
|
{
|
|
|
int current = lookupCellIDs.takeFirst();
|
|
|
QList< int > ids = getNextEdgeLineByDirectionAndAngle(current, false, angle, endWithCross);
|
|
|
|
|
|
for (int id : ids)
|
|
|
{
|
|
|
if (finishedCellIDs.contains(id) || id < 0) { continue; }
|
|
|
lookupCellIDs.append(id);
|
|
|
finishedCellIDs.append(id);
|
|
|
}
|
|
|
}
|
|
|
return finishedCellIDs;
|
|
|
}
|
|
|
|
|
|
|
|
|
QList< int > FITKPolyDataTool::getNextEdgeLineByDirectionAndAngle(int cellID, bool down, double angle, bool endWithCross /*= false */)
|
|
|
{
|
|
|
/// 对输入变量进行有效性判定，由于是私有内部接口，上层函数中进行了校验，本函数无需校验，若需暴露外部使用，需放开
|
|
|
QMap< int, double > idAngles;
|
|
|
if (!_poly || cellID < 0 || cellID >= _poly->GetNumberOfCells() || angle > 90 || angle < 0) { return idAngles.keys(); }
|
|
|
|
|
|
/// 构造输入单元向量
|
|
|
double vec1[3] = { 0 };
|
|
|
getLineItemVector(cellID, vec1);
|
|
|
|
|
|
/// 查找推导方向上，节点所有单元
|
|
|
vtkCell* cell = _poly->GetCell(cellID);
|
|
|
int ptID = cell->GetPointId(down == true ? 1 : 0);
|
|
|
vtkSmartPointer<vtkIdList> cellIDs = vtkSmartPointer<vtkIdList>::New();
|
|
|
_poly->GetPointCells(ptID, cellIDs);
|
|
|
int cellsNum = cellIDs->GetNumberOfIds();
|
|
|
|
|
|
/// 相交即返回情况判定
|
|
|
if (endWithCross && cellsNum > 2) { return idAngles.keys(); }
|
|
|
|
|
|
for (int iCell = 0; iCell < cellsNum; ++iCell)
|
|
|
{
|
|
|
int findCellID = cellIDs->GetId(iCell);
|
|
|
|
|
|
/// 该单元为当前查找单元，跳过查找下一个
|
|
|
if (findCellID == cellID) { continue; }
|
|
|
|
|
|
vtkCell* cell = _poly->GetCell(findCellID);
|
|
|
int findPt0ID = cell->GetPointId(0);
|
|
|
int findPt1ID = cell->GetPointId(1);
|
|
|
|
|
|
/// 去除反向单元
|
|
|
if ((findPt1ID == ptID && down) || (findPt0ID == ptID && !down)) { continue; }
|
|
|
|
|
|
/// 构造查找到的线单元向量
|
|
|
double vec2[3] = { .0 };
|
|
|
getLineItemVector(findCellID, vec2);
|
|
|
|
|
|
/// 计算两个线单元夹角，不考虑矢量方向，按照最小夹角进行数据记录
|
|
|
double currentAngle = vtkMath::Dot(vec1, vec2) / (vtkMath::Norm(vec1) * vtkMath::Norm(vec2));
|
|
|
currentAngle = acos(currentAngle) * 180 / M_PI;
|
|
|
if (currentAngle <= angle)
|
|
|
{
|
|
|
idAngles.insert(findCellID, currentAngle);
|
|
|
}
|
|
|
}
|
|
|
return idAngles.keys();
|
|
|
}
|
|
|
|
|
|
int FITKPolyDataTool::getPointIDByPointPosition(double pos[3])
|
|
|
{
|
|
|
QVector3D pt(pos[0], pos[1], pos[2]);
|
|
|
return _points.key(pt);
|
|
|
}
|
|
|
|
|
|
|
|
|
QVector< int > FITKPolyDataTool::reuduceSharePointLine(QVector< int > cellIDs)
|
|
|
{
|
|
|
QVector< int > results;
|
|
|
QList< QPair< int, int > > pairs1;
|
|
|
QList< int > pairs2;
|
|
|
|
|
|
for (int current : cellIDs)
|
|
|
{
|
|
|
/// 已与前序线单元构成配对
|
|
|
if (pairs2.contains(current)) { continue; }
|
|
|
|
|
|
int p1Index = _poly->GetCell(current)->GetPointId(0);
|
|
|
int p2Index = _poly->GetCell(current)->GetPointId(1);
|
|
|
bool getCurrentPair = false;
|
|
|
|
|
|
for (int other : cellIDs)
|
|
|
{
|
|
|
if (current == other) { continue; }
|
|
|
int p3Index = _poly->GetCell(other)->GetPointId(0);
|
|
|
int p4Index = _poly->GetCell(other)->GetPointId(1);
|
|
|
|
|
|
/// 两条边共用节点，节点序号相反，其中一个要被去掉
|
|
|
if (p1Index == p4Index && p2Index == p3Index)
|
|
|
{
|
|
|
QPair< int, int > pair(current, other);
|
|
|
pairs1.append(pair);
|
|
|
pairs2.append(current);
|
|
|
pairs2.append(other);
|
|
|
getCurrentPair = true;
|
|
|
results.append(current);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (!getCurrentPair)
|
|
|
{
|
|
|
results.append(current);
|
|
|
}
|
|
|
}
|
|
|
return results;
|
|
|
}
|
|
|
|
|
|
QList< CELLPAIR > FITKPolyDataTool::getNeighborCell(int cellID/*, const QList< int >& scanedCellIDs*/)
|
|
|
{
|
|
|
QList< CELLPAIR > neighcells;
|
|
|
vtkSmartPointer<vtkIdList> cellPointIds = vtkSmartPointer<vtkIdList>::New();
|
|
|
_poly->GetCellPoints(cellID, cellPointIds);
|
|
|
|
|
|
QList< int > sigNeighbor{};
|
|
|
for (vtkIdType i = 0; i < cellPointIds->GetNumberOfIds(); i++)
|
|
|
{
|
|
|
vtkSmartPointer<vtkIdList> idList = vtkSmartPointer<vtkIdList>::New();
|
|
|
idList->InsertNextId(cellPointIds->GetId(i));
|
|
|
// get the neighbors of the cell
|
|
|
vtkSmartPointer<vtkIdList> neighborCellIds = vtkSmartPointer<vtkIdList>::New();
|
|
|
_poly->GetCellNeighbors(cellID, idList, neighborCellIds);
|
|
|
|
|
|
for (vtkIdType j = 0; j < neighborCellIds->GetNumberOfIds(); j++)
|
|
|
{
|
|
|
const int roundID = neighborCellIds->GetId(j);
|
|
|
|
|
|
// Modified by CHT 不通过数据包含关系判断，改用数组直接获取标识。
|
|
|
//@{
|
|
|
int flag = m_scanCellCoPlaneFlag->GetValue(roundID);
|
|
|
if (flag || sigNeighbor.contains(roundID)) continue;
|
|
|
//@}
|
|
|
|
|
|
// if (scanedCellIDs.contains(roundID) || sigNeighbor.contains(roundID)) continue;
|
|
|
neighcells.append(CELLPAIR(roundID, cellID));
|
|
|
sigNeighbor.append(roundID);
|
|
|
}
|
|
|
}
|
|
|
return neighcells;
|
|
|
}
|
|
|
|
|
|
/*bool FITKPolyDataTool::calculateCellNormal(const int cellID, double* normal)
|
|
|
{
|
|
|
if (_poly == nullptr) return false;
|
|
|
vtkCell* cell = _poly->GetCell(cellID);
|
|
|
if (cell == nullptr) return false;
|
|
|
|
|
|
const int nedge = cell->GetNumberOfEdges();
|
|
|
if (nedge <= 2) return false;
|
|
|
|
|
|
auto calEdgeDirection = [&](int p1, int p2, double* dir) -> bool {
|
|
|
if (dir == nullptr) return false;
|
|
|
|
|
|
double pcoor1[3] = { 0 }, pcoor2[3] = { 0 };
|
|
|
_poly->GetPoint(p1, pcoor1);
|
|
|
_poly->GetPoint(p2, pcoor1);
|
|
|
vtkMath::Subtract(pcoor2, pcoor1, dir);
|
|
|
|
|
|
return vtkMath::Norm(dir) > 1e-7;
|
|
|
};
|
|
|
|
|
|
const int np = cell->GetNumberOfPoints();
|
|
|
if (np < 3) return false;
|
|
|
const int p1 = cell->GetPointId(0);
|
|
|
const int p2 = cell->GetPointId(1);
|
|
|
const int p3 = cell->GetPointId(np - 1);
|
|
|
|
|
|
double dir0[3] = { 0 }, dir1[3] = { 0 };
|
|
|
bool ok = calEdgeDirection(p1, p2, dir0);
|
|
|
if (!ok) return false;
|
|
|
ok = calEdgeDirection(p2, p3, dir1);
|
|
|
if (!ok) return false;
|
|
|
|
|
|
vtkMath::Cross(dir0, dir1, normal);
|
|
|
return true;
|
|
|
}*/
|
|
|
|
|
|
bool FITKPolyDataTool::calculateCellNormal(const int cellID, double* normal)
|
|
|
{
|
|
|
vtkCell* cell = _poly->GetCell(cellID);
|
|
|
if (cell == nullptr) return false;
|
|
|
vtkPolygon::ComputeNormal(cell->GetPoints(), normal);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
void FITKPolyDataTool::getLineItemVector(int cellID, double(&vec)[3])
|
|
|
{
|
|
|
vtkCell* cell = _poly->GetCell(cellID);
|
|
|
if (!cell || cell->GetCellType() != VTK_LINE) { return; }
|
|
|
|
|
|
double p1[3] = { 0 }, p2[3] = { 0 };
|
|
|
int pt1ID = cell->GetPointId(0);
|
|
|
int pt2ID = cell->GetPointId(1);
|
|
|
_poly->GetPoint(pt1ID, p1);
|
|
|
_poly->GetPoint(pt2ID, p2);
|
|
|
|
|
|
for (int iCnt = 0; iCnt < 3; ++iCnt)
|
|
|
{
|
|
|
vec[iCnt] = p2[iCnt] - p1[iCnt];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
} // namespace Common
|