659 lines
19 KiB
C++
659 lines
19 KiB
C++
#include "BoundarySetting.h"
|
||
|
||
#include <vtkDataSetSurfaceFilter.h>
|
||
#include <vtkExtractGeometry.h>
|
||
#include <vtkPolyDataNormals.h>
|
||
#include "PhysicalField.h"
|
||
|
||
BoundarySetting::BoundarySetting()
|
||
{
|
||
m_picker = PropPickerInteractionStyle::New(this);
|
||
m_visualWidgetService = ServiceRegistry<VisualWidgetService>::instance().getService();
|
||
ServiceRegistry<VisualWidgetService>::instance().getService()->getInteractor()->AddObserver(vtkCommand::LeftButtonPressEvent, m_picker, 0.5f);
|
||
m_picker->setSelectModel(0);
|
||
}
|
||
|
||
void BoundarySetting::setPhyicalField(PhysicalField *physicalField)
|
||
{
|
||
m_physicalField = physicalField;
|
||
|
||
m_displacementLimitSettingWidget = m_physicalField->getDisplacementLimitSettingWidget();
|
||
m_distributedLoadSettingWidget = m_physicalField->getDistributedLoadSettingWidget();
|
||
}
|
||
void BoundarySetting::select()
|
||
{
|
||
m_gridFaceToCell.resize(m_faceNum+1);
|
||
m_gridFaceToPoint.resize(m_faceNum+1);
|
||
|
||
m_points = vtkSmartPointer<vtkPoints>::New();
|
||
m_cells = vtkSmartPointer<vtkCellArray>::New();
|
||
|
||
QMap<int,int>pointMap;
|
||
// for (const auto& quad : m_quads) {
|
||
// //真实的id
|
||
// int ids[4];
|
||
// ids[0] = quad.n2;
|
||
// ids[1] = quad.n3;
|
||
// ids[2] = quad.n4;
|
||
// ids[3] = quad.n5;
|
||
|
||
// //插入到points，映射点的id
|
||
// for(int i=0;i<4;i++)
|
||
// {
|
||
// if(pointMap[ids[i]] == 1) continue;
|
||
// else
|
||
// {
|
||
// int id = (int)m_points->InsertNextPoint(m_nodes[ids[i]-1].x,m_nodes[ids[i]-1].y,m_nodes[ids[i]-1].z);
|
||
// pointMap[ids[i]] = 1;
|
||
// m_pointIdToTruePointId[id] = ids[i];
|
||
// m_truePointIdToPointId[ids[i]] = id;
|
||
// }
|
||
// }
|
||
// }
|
||
//m_cellPoly = vtkSmartPointer<vtkUnstructuredGrid>::New();
|
||
// for(const auto& node : m_nodes)
|
||
// {
|
||
// m_points->InsertNextPoint(node.x, node.y,node.z);
|
||
// }
|
||
|
||
// qDebug()<<"sssssssssss";
|
||
// m_cellPoly->SetPoints(m_points);
|
||
// //体
|
||
|
||
// for (const auto& quad2 : m_hexahedrons) {
|
||
// int quad[8];
|
||
// vtkSmartPointer<vtkHexahedron> hexpoly = vtkSmartPointer<vtkHexahedron>::New();
|
||
// quad[0]=quad2.n2;
|
||
// quad[1]=quad2.n3;
|
||
// quad[2]=quad2.n4;
|
||
// quad[3]=quad2.n5;
|
||
// quad[4]=quad2.n6;
|
||
// quad[5]=quad2.n7;
|
||
// quad[6]=quad2.n8;
|
||
// quad[7]=quad2.n9;
|
||
// hexpoly->GetPointIds()->SetId(0, quad[0]-1);
|
||
// hexpoly->GetPointIds()->SetId(1, quad[1]-1);
|
||
// hexpoly->GetPointIds()->SetId(2, quad[2]-1);
|
||
// hexpoly->GetPointIds()->SetId(3, quad[3]-1);
|
||
// hexpoly->GetPointIds()->SetId(4, quad[4]-1);
|
||
// hexpoly->GetPointIds()->SetId(5, quad[5]-1);
|
||
// hexpoly->GetPointIds()->SetId(6, quad[6]-1);
|
||
// hexpoly->GetPointIds()->SetId(7, quad[7]-1);
|
||
// m_cellPoly->InsertNextCell(hexpoly->GetCellType(), hexpoly->GetPointIds());
|
||
// }
|
||
// //面cell
|
||
// for (const auto& quad : m_quads) {
|
||
// // Add points
|
||
// vtkIdType ids[4];
|
||
// ids[0] = m_truePointIdToPointId[quad.n2];
|
||
// ids[1] = m_truePointIdToPointId[quad.n3];
|
||
// ids[2] = m_truePointIdToPointId[quad.n4];
|
||
// ids[3] = m_truePointIdToPointId[quad.n5];
|
||
// int id = m_cells->InsertNextCell(4, ids);
|
||
|
||
// int hexahedronsPos = 0;
|
||
// while(hexahedronsPos<m_hexahedrons.size())
|
||
// {
|
||
// QMap<int,int>temp;
|
||
// int j = hexahedronsPos;
|
||
|
||
// temp[m_hexahedrons[j].n2] = 1;
|
||
// temp[m_hexahedrons[j].n3] = 1;
|
||
// temp[m_hexahedrons[j].n4] = 1;
|
||
// temp[m_hexahedrons[j].n5] = 1;
|
||
// temp[m_hexahedrons[j].n6] = 1;
|
||
// temp[m_hexahedrons[j].n7] = 1;
|
||
// temp[m_hexahedrons[j].n8] = 1;
|
||
// temp[m_hexahedrons[j].n9] = 1;
|
||
// for(int i=0;i<4;i++)
|
||
// {
|
||
// if(temp[m_pointIdToTruePointId[ids[i]]] == 0) {hexahedronsPos++;break;}
|
||
// }
|
||
|
||
// if(j == hexahedronsPos)
|
||
// {
|
||
// //属于哪一个体
|
||
// m_faceToGridMap[id] = m_hexahedrons[j].id;
|
||
// //面存入grid面
|
||
// m_gridFaceToCell[quad.n1].push_back(id);
|
||
|
||
// //点存入grid面
|
||
// m_gridFaceToPoint[quad.n1].push_back(ids[0]);
|
||
// m_gridFaceToPoint[quad.n1].push_back(ids[1]);
|
||
// m_gridFaceToPoint[quad.n1].push_back(ids[2]);
|
||
// m_gridFaceToPoint[quad.n1].push_back(ids[3]);
|
||
// break;
|
||
// }
|
||
// }
|
||
// }
|
||
|
||
//面
|
||
// m_cellPoly = vtkSmartPointer<vtkPolyData>::New();
|
||
// m_cellPoly->SetPoints(m_points);
|
||
// m_cellPoly->SetPolys(m_cells);
|
||
|
||
// //点
|
||
// m_nodePoly = vtkSmartPointer<vtkPolyData>::New();
|
||
// m_nodePoly->SetPoints(m_points);
|
||
// m_nodePoly->SetPolys(m_cells);
|
||
|
||
|
||
|
||
//------------------------------------整体
|
||
// Create a mapper
|
||
// vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
|
||
// mapper->SetInputData(m_cellPoly);
|
||
|
||
// m_faceActor = vtkSmartPointer<vtkActor>::New();
|
||
// m_faceActor->SetMapper(mapper);
|
||
|
||
// m_faceActor->GetProperty()->EdgeVisibilityOn();
|
||
|
||
// //设置颜色
|
||
// vtkDataArray *cellcolor = vtkUnsignedCharArray::New();
|
||
// cellcolor->SetNumberOfComponents(3);
|
||
// m_cellStructure->GetCellData()->SetScalars(cellcolor);
|
||
// cellcolor->SetNumberOfTuples(m_cellStructure->GetNumberOfCells());
|
||
// cellcolor->FillComponent(0, 255);
|
||
// cellcolor->FillComponent(1, 255);
|
||
// cellcolor->FillComponent(2, 255);
|
||
|
||
// //点
|
||
// vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
|
||
// sphereSource->SetRadius(0.00007); // Adjust the radius to change the size of the points
|
||
|
||
// vtkSmartPointer<vtkGlyph3D> glyphFilter = vtkSmartPointer<vtkGlyph3D>::New();
|
||
// glyphFilter->SetInputData(m_nodePoly);
|
||
// glyphFilter->SetSourceConnection(sphereSource->GetOutputPort());
|
||
// glyphFilter->SetColorModeToColorByScalar(); // Use scalar data for colors
|
||
// glyphFilter->Update();
|
||
|
||
// vtkSmartPointer<vtkPolyDataMapper> glyphMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
|
||
// glyphMapper->SetInputConnection(glyphFilter->GetOutputPort());
|
||
// glyphMapper->ScalarVisibilityOn(); // Ensure colors are visible
|
||
// glyphMapper->SetScalarModeToUsePointData();
|
||
|
||
// m_pointActor = vtkSmartPointer<vtkActor>::New();
|
||
// m_pointActor->SetMapper(glyphMapper);
|
||
|
||
// m_pointActor->SetPickable(false);
|
||
|
||
// //设置点颜色
|
||
// vtkSmartPointer<vtkUnsignedCharArray> pointColor = vtkSmartPointer<vtkUnsignedCharArray>::New();
|
||
// pointColor->SetNumberOfComponents(3);
|
||
// pointColor->SetName("Colors");
|
||
// pointColor->SetNumberOfTuples(m_nodePoly->GetNumberOfPoints());
|
||
// pointColor->FillComponent(0, 255);
|
||
// pointColor->FillComponent(1, 255);
|
||
// pointColor->FillComponent(2, 255);
|
||
// m_nodePoly->GetPointData()->SetScalars(pointColor);
|
||
|
||
// m_visualWidgetService->removeAllActor();
|
||
// m_visualWidgetService->addActor(m_faceActor);
|
||
// m_visualWidgetService->getRender()->ResetCamera();
|
||
// m_visualWidgetService->getrenderWindow()->Render();
|
||
}
|
||
|
||
void BoundarySetting::setSelectMode()
|
||
{
|
||
|
||
}
|
||
|
||
vtkSmartPointer<vtkUnstructuredGrid> BoundarySetting::getPointStructure()
|
||
{
|
||
return m_pointStructure;
|
||
}
|
||
|
||
bool BoundarySetting::setStructure(vtkSmartPointer<vtkUnstructuredGrid> cell,vtkSmartPointer<vtkUnstructuredGrid> point)
|
||
{
|
||
if(m_cellStructure == cell && m_pointStructure == point)
|
||
{
|
||
return false;
|
||
}
|
||
m_cellStructure = cell;
|
||
m_pointStructure = point;
|
||
|
||
m_uxSelectedPoint.clear();
|
||
m_uySelectedPoint.clear();
|
||
m_uzSelectedPoint.clear();
|
||
m_allSelectedPoint.clear();
|
||
|
||
m_oneSelectedFace.clear();
|
||
m_twoSelectedFace.clear();
|
||
m_threeSelectedFace.clear();
|
||
m_allSelectedFace.clear();
|
||
|
||
return true;
|
||
}
|
||
|
||
void BoundarySetting::setFaceToPoint(QVector<QSet<int>> point)
|
||
{
|
||
m_gridFaceToPoint = point;
|
||
}
|
||
|
||
void BoundarySetting::setFaceToCell(QVector<QVector<int>> cell)
|
||
{
|
||
m_gridFaceToCell = cell;
|
||
}
|
||
|
||
void BoundarySetting::setCellToGridMap(QMap <int , int> cellToGridMap)
|
||
{
|
||
m_faceToGridMap = cellToGridMap;
|
||
}
|
||
|
||
|
||
//设置选择方式0-不选，1-选点，2-选面
|
||
void BoundarySetting::setBoundarySettingStatus(int type)
|
||
{
|
||
m_picker->setSelectModel(type);
|
||
}
|
||
|
||
void BoundarySetting::set3DType(bool is3DType)
|
||
{
|
||
m_picker->set3DType(is3DType);
|
||
}
|
||
|
||
int BoundarySetting::getFaceNum()
|
||
{
|
||
return m_faceNum;
|
||
}
|
||
|
||
vtkSmartPointer<vtkUnstructuredGrid> BoundarySetting::getCellStructure()
|
||
{
|
||
return m_cellStructure;
|
||
}
|
||
|
||
int BoundarySetting::getFaceIdToGridId(int id)
|
||
{
|
||
return m_faceToGridMap[id];
|
||
}
|
||
int BoundarySetting::getPointIdToGridId(int id)
|
||
{
|
||
return m_pointIdToTruePointId[id];
|
||
}
|
||
|
||
//清除选中的点
|
||
void BoundarySetting::clearSelectedPoint()
|
||
{
|
||
double color[3] = {255,255,255};
|
||
double color2[3] = {255,0,255};
|
||
for (const int &point : m_picker->getSelectedPoint()) {
|
||
if(isSelectedPoint(point))
|
||
{
|
||
m_picker->setPointColor(point,color2);
|
||
}
|
||
else
|
||
{
|
||
m_picker->setPointColor(point,color);
|
||
}
|
||
}
|
||
m_picker->pointRefresh();
|
||
m_picker->clearSelectedPoint();
|
||
}
|
||
|
||
void BoundarySetting::setFaceData(bool enable[], double value[])
|
||
{
|
||
QSet<int>temp = m_picker->getSelectedFace();
|
||
if(enable[0])
|
||
{
|
||
for (const int &face : temp) {
|
||
m_oneSelectedFace.insert(face);
|
||
m_allSelectedFace.insert(face);
|
||
m_oneFace[face] = value[0];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (const int &face : temp) {
|
||
m_oneSelectedFace.remove(face);
|
||
}
|
||
}
|
||
if(enable[1])
|
||
{
|
||
for (const int &face : temp) {
|
||
m_twoSelectedFace.insert(face);
|
||
m_allSelectedFace.insert(face);
|
||
m_twoFace[face] = value[1];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (const int &face : temp) {
|
||
m_twoSelectedFace.remove(face);
|
||
}
|
||
}
|
||
if(enable[2])
|
||
{
|
||
for (const int &face : temp) {
|
||
m_threeSelectedFace.insert(face);
|
||
m_allSelectedFace.insert(face);
|
||
m_threeFace[face] = value[2];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (const int &face : temp) {
|
||
m_threeSelectedFace.remove(face);
|
||
}
|
||
}
|
||
if(enable[0] || enable[1] || enable[2])
|
||
{
|
||
double color[3] = {255,255,255};
|
||
double color2[3] = {255,0,255};
|
||
for (const int &face : temp) {
|
||
if(isSelectedFace(face))
|
||
{
|
||
m_picker->setFaceColor(face,color2);
|
||
}
|
||
else
|
||
{
|
||
m_picker->setFaceColor(face,color);
|
||
}
|
||
}
|
||
m_picker->faceRefresh();
|
||
}
|
||
m_picker->clearSelectedFace();
|
||
}
|
||
|
||
void BoundarySetting::deleteFaceData()
|
||
{
|
||
QSet<int>temp = m_picker->getSelectedFace();
|
||
|
||
for (const int &face : temp) {
|
||
m_allSelectedFace.remove(face);
|
||
m_oneSelectedFace.remove(face);
|
||
m_twoSelectedFace.remove(face);
|
||
m_threeSelectedFace.remove(face);
|
||
}
|
||
clearSelectedFace();
|
||
}
|
||
|
||
void BoundarySetting::batchSelectFace(int id)
|
||
{
|
||
double color[3] = {255,255,255};
|
||
// clearSelectedFace();
|
||
|
||
vtkDataArray *facecolor = m_cellStructure->GetCellData()->GetScalars();
|
||
|
||
qDebug()<<id;
|
||
for(int i=0;i<m_gridFaceToCell[id].size();i++)
|
||
{
|
||
int cellId = m_gridFaceToCell[id][i];
|
||
qDebug()<<cellId-1;
|
||
m_picker->addSelectedFace(cellId-1);
|
||
}
|
||
|
||
color[1] = 0;
|
||
color[2] = 0;
|
||
m_picker->setFaceColor(m_picker->getSelectedFace(),color);
|
||
qDebug()<<"m_gridFaceToCell[id].size()";
|
||
}
|
||
|
||
bool BoundarySetting::isSelectedFace(int face)
|
||
{
|
||
if(m_faceShowModel == 0)
|
||
{
|
||
return m_allSelectedFace.contains(face);
|
||
}
|
||
else if(m_faceShowModel == 1)
|
||
{
|
||
return m_oneSelectedFace.contains(face);
|
||
}
|
||
else if(m_faceShowModel == 2)
|
||
{
|
||
return m_twoSelectedFace.contains(face);
|
||
}
|
||
else if(m_faceShowModel == 3)
|
||
{
|
||
return m_threeSelectedFace.contains(face);
|
||
}
|
||
}
|
||
|
||
void BoundarySetting::setFaceShowModel(int type)
|
||
{
|
||
m_faceShowModel = type;
|
||
//清理所有颜色
|
||
m_picker->clearFaceColor();
|
||
//更新对应的颜色
|
||
double color[3] = {255,0,255};
|
||
if(m_faceShowModel == 0)
|
||
{
|
||
m_picker->setFaceColor(m_allSelectedFace,color);
|
||
}
|
||
else if(m_faceShowModel == 1)
|
||
{
|
||
m_picker->setFaceColor(m_oneSelectedFace,color);
|
||
}
|
||
else if(m_faceShowModel == 2)
|
||
{
|
||
m_picker->setFaceColor(m_twoSelectedFace,color);
|
||
}
|
||
else if(m_faceShowModel == 3)
|
||
{
|
||
m_picker->setFaceColor(m_threeSelectedFace,color);
|
||
}
|
||
else if(m_faceShowModel == 4)
|
||
{
|
||
color[1] = 255;
|
||
color[2] = 255;
|
||
m_picker->setFaceColor(m_threeSelectedFace,color);
|
||
}
|
||
//更新选中的颜色
|
||
color[1] = 0;
|
||
color[2] = 0;
|
||
m_picker->setFaceColor(m_picker->getSelectedFace(),color);
|
||
}
|
||
|
||
void BoundarySetting::clearSelectedFace()
|
||
{
|
||
double color[3] = {255,255,255};
|
||
double color2[3] = {255,0,255};
|
||
for (const int &face : m_picker->getSelectedFace()) {
|
||
if(isSelectedFace(face))
|
||
{
|
||
m_picker->setFaceColor(face,color2);
|
||
}
|
||
else
|
||
{
|
||
m_picker->setFaceColor(face,color);
|
||
}
|
||
}
|
||
m_picker->faceRefresh();
|
||
m_picker->clearSelectedFace();
|
||
}
|
||
|
||
void BoundarySetting::batchSelectPoint(int id)
|
||
{
|
||
double color[3] = {255,255,255};
|
||
// m_picker->setPointColor(m_picker->getSelectedPoint(),color); 清除之前的
|
||
// m_picker->clearSelectedPoint();
|
||
|
||
vtkDataArray *pointcolor = m_pointStructure->GetPointData()->GetScalars();
|
||
for(int pointId:m_gridFaceToPoint[id])
|
||
{
|
||
m_picker->addSelectedPoint(pointId-1);
|
||
}
|
||
|
||
color[1] = 0;
|
||
color[2] = 0;
|
||
m_picker->setPointColor(m_picker->getSelectedPoint(),color);
|
||
}
|
||
|
||
vtkSmartPointer<vtkActor> BoundarySetting::getPointActor()
|
||
{
|
||
return m_pointActor;
|
||
}
|
||
|
||
void BoundarySetting::setPointData(bool enable[3],double value[3])
|
||
{
|
||
QSet<int>temp = m_picker->getSelectedPoint();
|
||
if(enable[0])
|
||
{
|
||
for (const int &point : temp) {
|
||
m_uxSelectedPoint.insert(point);
|
||
m_allSelectedPoint.insert(point);
|
||
m_uxPoint[point] = value[0];
|
||
}
|
||
}
|
||
else//删除之前设置的
|
||
{
|
||
for (const int &point : temp) {
|
||
m_uxSelectedPoint.remove(point);
|
||
}
|
||
}
|
||
if(enable[1])
|
||
{
|
||
for (const int &point : temp) {
|
||
m_uySelectedPoint.insert(point);
|
||
m_allSelectedPoint.insert(point);
|
||
m_uyPoint[point] = value[1];
|
||
}
|
||
}
|
||
else//删除之前设置的
|
||
{
|
||
for (const int &point : temp) {
|
||
m_uySelectedPoint.remove(point);
|
||
}
|
||
}
|
||
if(enable[2])
|
||
{
|
||
for (const int &point : temp) {
|
||
m_uzSelectedPoint.insert(point);
|
||
m_allSelectedPoint.insert(point);
|
||
m_uzPoint[point] = value[2];
|
||
}
|
||
}
|
||
else//删除之前设置的
|
||
{
|
||
for (const int &point : temp) {
|
||
m_uzSelectedPoint.remove(point);
|
||
}
|
||
}
|
||
if(enable[0] || enable[1] || enable[2])
|
||
{
|
||
double color[3] = {255,255,255};
|
||
double color2[3] = {255,0,255};
|
||
for (const int &point : temp) {
|
||
if(isSelectedPoint(point))
|
||
{
|
||
m_picker->setPointColor(point,color2);
|
||
}
|
||
else
|
||
{
|
||
m_picker->setPointColor(point,color);
|
||
}
|
||
}
|
||
m_picker->pointRefresh();
|
||
}
|
||
m_picker->clearSelectedPoint();
|
||
}
|
||
|
||
void BoundarySetting::deletePointData()
|
||
{
|
||
QSet<int>temp = m_picker->getSelectedPoint();
|
||
|
||
for (const int &point : temp) {
|
||
m_allSelectedPoint.remove(point);
|
||
m_uxSelectedPoint.remove(point);
|
||
m_uySelectedPoint.remove(point);
|
||
m_uzSelectedPoint.remove(point);
|
||
}
|
||
clearSelectedPoint();
|
||
}
|
||
|
||
void BoundarySetting::setPointShowModel(int type)
|
||
{
|
||
m_pointShowModel = type;
|
||
//清理所有颜色
|
||
m_picker->clearPointColor();
|
||
//更新对应的颜色
|
||
double color[3] = {255,0,255};
|
||
if(m_pointShowModel == 0)
|
||
{
|
||
m_picker->setPointColor(m_allSelectedPoint,color);
|
||
}
|
||
else if(m_pointShowModel == 1)
|
||
{
|
||
m_picker->setPointColor(m_uxSelectedPoint,color);
|
||
}
|
||
else if(m_pointShowModel == 2)
|
||
{
|
||
m_picker->setPointColor(m_uySelectedPoint,color);
|
||
}
|
||
else if(m_pointShowModel == 3)
|
||
{
|
||
m_picker->setPointColor(m_uzSelectedPoint,color);
|
||
}
|
||
//更新选中的颜色
|
||
color[1] = 0;
|
||
color[2] = 0;
|
||
m_picker->setPointColor(m_picker->getSelectedPoint(),color);
|
||
}
|
||
|
||
bool BoundarySetting::isSelectedPoint(int point)
|
||
{
|
||
if(m_pointShowModel == 0)
|
||
{
|
||
return m_allSelectedPoint.contains(point);
|
||
}
|
||
else if(m_pointShowModel == 1)
|
||
{
|
||
return m_uxSelectedPoint.contains(point);
|
||
}
|
||
else if(m_pointShowModel == 2)
|
||
{
|
||
return m_uySelectedPoint.contains(point);
|
||
}
|
||
else if(m_pointShowModel == 3)
|
||
{
|
||
return m_uzSelectedPoint.contains(point);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void BoundarySetting::showPointData(int point)
|
||
{
|
||
bool enable[3] = {false,false,false};
|
||
double value[3];
|
||
if(m_uxSelectedPoint.contains(point))
|
||
{
|
||
enable[0] = true;
|
||
value[0] = m_uxPoint[point];
|
||
}
|
||
if(m_uySelectedPoint.contains(point))
|
||
{
|
||
enable[1] = true;
|
||
value[1] = m_uyPoint[point];
|
||
}
|
||
if(m_uzSelectedPoint.contains(point))
|
||
{
|
||
enable[2] = true;
|
||
value[2] = m_uzPoint[point];
|
||
}
|
||
m_displacementLimitSettingWidget->showData(point,enable,value);
|
||
}
|
||
|
||
void BoundarySetting::showFaceData(int faceId)
|
||
{
|
||
bool enable[3] = {false,false,false};
|
||
double value[3];
|
||
if(m_oneSelectedFace.contains(faceId))
|
||
{
|
||
enable[0] = true;
|
||
value[0] = m_oneFace[faceId];
|
||
}
|
||
if(m_twoSelectedFace.contains(faceId))
|
||
{
|
||
enable[1] = true;
|
||
value[1] = m_twoFace[faceId];
|
||
}
|
||
if(m_threeSelectedFace.contains(faceId))
|
||
{
|
||
enable[2] = true;
|
||
value[2] = m_threeFace[faceId];
|
||
}
|
||
m_distributedLoadSettingWidget->showData(faceId,enable,value);
|
||
}
|
||
|
||
|