|
|
#include "nmVTKPlanarScaleGridLayer.h"
|
|
|
|
|
|
#include <QByteArray>
|
|
|
#include <QCoreApplication>
|
|
|
#include <QThread>
|
|
|
|
|
|
#include <vtkActor.h>
|
|
|
#include <vtkCamera.h>
|
|
|
#include <vtkCellArray.h>
|
|
|
#include <vtkMath.h>
|
|
|
#include <vtkObjectFactory.h>
|
|
|
#include <vtkPoints.h>
|
|
|
#include <vtkPolyData.h>
|
|
|
#include <vtkPolyDataMapper.h>
|
|
|
#include <vtkPropAssembly.h>
|
|
|
#include <vtkProperty.h>
|
|
|
#include <vtkProperty2D.h>
|
|
|
#include <vtkRenderer.h>
|
|
|
#include <vtkTextActor.h>
|
|
|
#include <vtkTextProperty.h>
|
|
|
#include <vtkViewport.h>
|
|
|
|
|
|
#include <cstddef>
|
|
|
#include <cmath>
|
|
|
#include <vector>
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
const double PLANAR_AXIS_DEPTH_FACTOR = 0.00020;
|
|
|
const double PLANAR_GRID_DEPTH_FACTOR = 0.00050;
|
|
|
const double PLANAR_BACKGROUND_DEPTH_FACTOR = 0.00100;
|
|
|
const double PLANAR_CAMERA_SIDE_TOLERANCE_FACTOR = 0.000001;
|
|
|
const double PLANAR_EDGE_SWITCH_PIXEL_TOLERANCE = 2.0;
|
|
|
const double PLANAR_TICK_LENGTH_FACTOR = 0.012;
|
|
|
const int PLANAR_LABEL_PIXEL_GAP = 8;
|
|
|
const int PLANAR_CORNER_LABEL_PIXEL_SHIFT = 12;
|
|
|
const int PLANAR_TARGET_INTERVAL_COUNT = 6;
|
|
|
|
|
|
bool isPlanarScaleGridGuiThread()
|
|
|
{
|
|
|
QCoreApplication* pApplication = QCoreApplication::instance();
|
|
|
return pApplication == nullptr ||
|
|
|
pApplication->thread() == QThread::currentThread();
|
|
|
}
|
|
|
|
|
|
bool isValidPlanarBounds(double dXMinimum,
|
|
|
double dXMaximum,
|
|
|
double dYMinimum,
|
|
|
double dYMaximum,
|
|
|
double dPlaneZ)
|
|
|
{
|
|
|
return vtkMath::IsFinite(dXMinimum) &&
|
|
|
vtkMath::IsFinite(dXMaximum) &&
|
|
|
vtkMath::IsFinite(dYMinimum) &&
|
|
|
vtkMath::IsFinite(dYMaximum) &&
|
|
|
vtkMath::IsFinite(dPlaneZ) &&
|
|
|
dXMinimum < dXMaximum && dYMinimum < dYMaximum;
|
|
|
}
|
|
|
|
|
|
void appendLine(vtkPoints* pPoints,
|
|
|
vtkCellArray* pLines,
|
|
|
double dX1,
|
|
|
double dY1,
|
|
|
double dZ1,
|
|
|
double dX2,
|
|
|
double dY2,
|
|
|
double dZ2)
|
|
|
{
|
|
|
if(pPoints == nullptr || pLines == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
vtkIdType nPointIds[2];
|
|
|
nPointIds[0] = pPoints->InsertNextPoint(dX1, dY1, dZ1);
|
|
|
nPointIds[1] = pPoints->InsertNextPoint(dX2, dY2, dZ2);
|
|
|
pLines->InsertNextCell(2, nPointIds);
|
|
|
}
|
|
|
|
|
|
void applyLineData(vtkPolyData* pPolyData,
|
|
|
vtkPoints* pPoints,
|
|
|
vtkCellArray* pLines)
|
|
|
{
|
|
|
if(pPolyData == nullptr || pPoints == nullptr || pLines == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
pPolyData->SetPoints(pPoints);
|
|
|
pPolyData->SetLines(pLines);
|
|
|
pPolyData->Modified();
|
|
|
}
|
|
|
|
|
|
void applySurfaceData(vtkPolyData* pPolyData,
|
|
|
vtkPoints* pPoints,
|
|
|
vtkCellArray* pPolygons)
|
|
|
{
|
|
|
if(pPolyData == nullptr || pPoints == nullptr || pPolygons == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
pPolyData->SetPoints(pPoints);
|
|
|
pPolyData->SetPolys(pPolygons);
|
|
|
pPolyData->Modified();
|
|
|
}
|
|
|
|
|
|
void updatePolyDataZ(vtkPolyData* pPolyData, double dZ)
|
|
|
{
|
|
|
vtkPoints* pPoints = pPolyData != nullptr
|
|
|
? pPolyData->GetPoints() : nullptr;
|
|
|
if(pPoints == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
double dPoint[3];
|
|
|
const vtkIdType nPointCount = pPoints->GetNumberOfPoints();
|
|
|
for(vtkIdType nPoint = 0; nPoint < nPointCount; ++nPoint) {
|
|
|
pPoints->GetPoint(nPoint, dPoint);
|
|
|
dPoint[2] = dZ;
|
|
|
pPoints->SetPoint(nPoint, dPoint);
|
|
|
}
|
|
|
pPoints->Modified();
|
|
|
pPolyData->Modified();
|
|
|
}
|
|
|
|
|
|
void configureLineActor(vtkPolyData* pPolyData,
|
|
|
vtkPolyDataMapper* pMapper,
|
|
|
vtkActor* pActor,
|
|
|
double dRed,
|
|
|
double dGreen,
|
|
|
double dBlue,
|
|
|
float fLineWidth)
|
|
|
{
|
|
|
if(pPolyData == nullptr || pMapper == nullptr || pActor == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
pMapper->SetInputData(pPolyData);
|
|
|
pMapper->ScalarVisibilityOff();
|
|
|
pActor->SetMapper(pMapper);
|
|
|
pActor->GetProperty()->SetColor(dRed, dGreen, dBlue);
|
|
|
pActor->GetProperty()->SetLineWidth(fLineWidth);
|
|
|
pActor->GetProperty()->SetOpacity(1.0);
|
|
|
pActor->GetProperty()->LightingOff();
|
|
|
pActor->PickableOff();
|
|
|
}
|
|
|
|
|
|
void configureBackgroundActor(vtkPolyData* pPolyData,
|
|
|
vtkPolyDataMapper* pMapper,
|
|
|
vtkActor* pActor)
|
|
|
{
|
|
|
if(pPolyData == nullptr || pMapper == nullptr || pActor == nullptr) {
|
|
|
return;
|
|
|
}
|
|
|
pMapper->SetInputData(pPolyData);
|
|
|
pMapper->ScalarVisibilityOff();
|
|
|
pActor->SetMapper(pMapper);
|
|
|
pActor->GetProperty()->SetColor(
|
|
|
171.0 / 255.0, 232.0 / 255.0, 241.0 / 255.0);
|
|
|
pActor->GetProperty()->SetOpacity(1.0);
|
|
|
pActor->GetProperty()->SetRepresentationToSurface();
|
|
|
pActor->GetProperty()->EdgeVisibilityOff();
|
|
|
pActor->GetProperty()->LightingOff();
|
|
|
// 底板两面都需要可见，相机翻到 XY 平面另一侧时仍由深度关系遮挡。
|
|
|
pActor->GetProperty()->FrontfaceCullingOff();
|
|
|
pActor->GetProperty()->BackfaceCullingOff();
|
|
|
pActor->PickableOff();
|
|
|
}
|
|
|
|
|
|
bool calculateNiceTicks(double dMinimum,
|
|
|
double dMaximum,
|
|
|
std::vector<double>& vTicks,
|
|
|
double& dStep)
|
|
|
{
|
|
|
vTicks.clear();
|
|
|
dStep = 0.0;
|
|
|
const double dRange = dMaximum - dMinimum;
|
|
|
if(!vtkMath::IsFinite(dRange) || dRange <= 0.0) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const double dRawStep =
|
|
|
dRange / static_cast<double>(PLANAR_TARGET_INTERVAL_COUNT);
|
|
|
const double dMagnitude = std::pow(
|
|
|
10.0, std::floor(std::log10(dRawStep)));
|
|
|
if(!vtkMath::IsFinite(dMagnitude) || dMagnitude <= 0.0) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const double dNormalizedStep = dRawStep / dMagnitude;
|
|
|
double dNiceFactor = 10.0;
|
|
|
if(dNormalizedStep <= 1.0) {
|
|
|
dNiceFactor = 1.0;
|
|
|
} else if(dNormalizedStep <= 2.0) {
|
|
|
dNiceFactor = 2.0;
|
|
|
} else if(dNormalizedStep <= 2.5) {
|
|
|
dNiceFactor = 2.5;
|
|
|
} else if(dNormalizedStep <= 5.0) {
|
|
|
dNiceFactor = 5.0;
|
|
|
}
|
|
|
dStep = dNiceFactor * dMagnitude;
|
|
|
if(!vtkMath::IsFinite(dStep) || dStep <= 0.0) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const double dTolerance = dStep * 0.00000001;
|
|
|
const double dFirstTick =
|
|
|
std::ceil((dMinimum - dTolerance) / dStep) * dStep;
|
|
|
for(int nIndex = 0; nIndex < 128; ++nIndex) {
|
|
|
double dValue = dFirstTick + static_cast<double>(nIndex) * dStep;
|
|
|
if(dValue > dMaximum + dTolerance) {
|
|
|
break;
|
|
|
}
|
|
|
if(dValue >= dMinimum - dTolerance) {
|
|
|
if(std::fabs(dValue) < dTolerance) {
|
|
|
dValue = 0.0;
|
|
|
}
|
|
|
vTicks.push_back(dValue);
|
|
|
}
|
|
|
}
|
|
|
return !vTicks.empty();
|
|
|
}
|
|
|
|
|
|
QString formatTickValue(double dValue, double dStep)
|
|
|
{
|
|
|
const double dAbsoluteStep = std::fabs(dStep);
|
|
|
if(std::fabs(dValue) < dAbsoluteStep * 0.00000001) {
|
|
|
dValue = 0.0;
|
|
|
}
|
|
|
|
|
|
if(std::fabs(dValue) >= 1000000000.0) {
|
|
|
return QString::number(dValue, 'g', 8);
|
|
|
}
|
|
|
|
|
|
int nDecimalCount = 0;
|
|
|
double dScaledStep = dAbsoluteStep;
|
|
|
while(nDecimalCount < 8 &&
|
|
|
std::fabs(dScaledStep - std::floor(dScaledStep + 0.5)) >
|
|
|
0.00000001) {
|
|
|
dScaledStep *= 10.0;
|
|
|
++nDecimalCount;
|
|
|
}
|
|
|
return QString::number(dValue, 'f', nDecimalCount);
|
|
|
}
|
|
|
|
|
|
int roundedPixelOffset(double dValue)
|
|
|
{
|
|
|
return static_cast<int>(dValue >= 0.0
|
|
|
? std::floor(dValue + 0.5)
|
|
|
: std::ceil(dValue - 0.5));
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
class nmVTKPlanarScaleGridLayerPrivate;
|
|
|
|
|
|
/**
|
|
|
* @brief 在 VTK 每次绘制组合 Prop 前更新相机相关轴边，不注册额外 Observer。
|
|
|
*/
|
|
|
class vtkNmPlanarScaleGridProp : public vtkPropAssembly
|
|
|
{
|
|
|
public:
|
|
|
static vtkNmPlanarScaleGridProp* New();
|
|
|
vtkTypeMacro(vtkNmPlanarScaleGridProp, vtkPropAssembly);
|
|
|
|
|
|
void setOwner(nmVTKPlanarScaleGridLayerPrivate* pOwner)
|
|
|
{
|
|
|
m_pOwner = pOwner;
|
|
|
}
|
|
|
|
|
|
virtual int RenderOpaqueGeometry(vtkViewport* pViewport);
|
|
|
virtual int RenderOverlay(vtkViewport* pViewport);
|
|
|
|
|
|
protected:
|
|
|
vtkNmPlanarScaleGridProp()
|
|
|
: m_pOwner(nullptr)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
virtual ~vtkNmPlanarScaleGridProp()
|
|
|
{
|
|
|
m_pOwner = nullptr;
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
vtkNmPlanarScaleGridProp(const vtkNmPlanarScaleGridProp&);
|
|
|
void operator=(const vtkNmPlanarScaleGridProp&);
|
|
|
|
|
|
nmVTKPlanarScaleGridLayerPrivate* m_pOwner; ///< 非所有权指针。
|
|
|
};
|
|
|
|
|
|
vtkStandardNewMacro(vtkNmPlanarScaleGridProp);
|
|
|
|
|
|
class nmVTKPlanarScaleGridLayerPrivate
|
|
|
{
|
|
|
public:
|
|
|
nmVTKPlanarScaleGridLayerPrivate()
|
|
|
: m_pRootProp(vtkSmartPointer<vtkNmPlanarScaleGridProp>::New()),
|
|
|
m_pBackgroundData(vtkSmartPointer<vtkPolyData>::New()),
|
|
|
m_pGridData(vtkSmartPointer<vtkPolyData>::New()),
|
|
|
m_pFrameData(vtkSmartPointer<vtkPolyData>::New()),
|
|
|
m_pXAxisData(vtkSmartPointer<vtkPolyData>::New()),
|
|
|
m_pYAxisData(vtkSmartPointer<vtkPolyData>::New()),
|
|
|
m_pBackgroundMapper(vtkSmartPointer<vtkPolyDataMapper>::New()),
|
|
|
m_pGridMapper(vtkSmartPointer<vtkPolyDataMapper>::New()),
|
|
|
m_pFrameMapper(vtkSmartPointer<vtkPolyDataMapper>::New()),
|
|
|
m_pXAxisMapper(vtkSmartPointer<vtkPolyDataMapper>::New()),
|
|
|
m_pYAxisMapper(vtkSmartPointer<vtkPolyDataMapper>::New()),
|
|
|
m_pBackgroundActor(vtkSmartPointer<vtkActor>::New()),
|
|
|
m_pGridActor(vtkSmartPointer<vtkActor>::New()),
|
|
|
m_pFrameActor(vtkSmartPointer<vtkActor>::New()),
|
|
|
m_pXAxisActor(vtkSmartPointer<vtkActor>::New()),
|
|
|
m_pYAxisActor(vtkSmartPointer<vtkActor>::New()),
|
|
|
m_pLabelTextProperty(vtkSmartPointer<vtkTextProperty>::New()),
|
|
|
m_dPlaneZ(0.0),
|
|
|
m_dScale(0.0),
|
|
|
m_dBackgroundZ(0.0),
|
|
|
m_dGridZ(0.0),
|
|
|
m_dAxisZ(0.0),
|
|
|
m_dTickLength(0.0),
|
|
|
m_dXTickStep(0.0),
|
|
|
m_dYTickStep(0.0),
|
|
|
m_bHasBounds(false),
|
|
|
m_bAxesInitialized(false),
|
|
|
m_bXAxisAtMaximum(false),
|
|
|
m_bYAxisAtMaximum(false),
|
|
|
m_nCameraSide(1)
|
|
|
{
|
|
|
for(int nIndex = 0; nIndex < 4; ++nIndex) {
|
|
|
m_dBounds[nIndex] = 0.0;
|
|
|
}
|
|
|
|
|
|
configureBackgroundActor(m_pBackgroundData,
|
|
|
m_pBackgroundMapper,
|
|
|
m_pBackgroundActor);
|
|
|
configureLineActor(m_pGridData, m_pGridMapper, m_pGridActor,
|
|
|
25.0 / 255.0, 25.0 / 255.0,
|
|
|
112.0 / 255.0, 1.0f);
|
|
|
// 先使用 VTK 7.1 原生线型；不支持线型的后端会自然回退为实线。
|
|
|
m_pGridActor->GetProperty()->SetLineStipplePattern(0xF0F0);
|
|
|
m_pGridActor->GetProperty()->SetLineStippleRepeatFactor(1);
|
|
|
configureLineActor(m_pFrameData, m_pFrameMapper, m_pFrameActor,
|
|
|
25.0 / 255.0, 25.0 / 255.0,
|
|
|
112.0 / 255.0, 1.5f);
|
|
|
m_pFrameActor->GetProperty()->SetLineStipplePattern(0xFFFF);
|
|
|
m_pFrameActor->GetProperty()->SetLineStippleRepeatFactor(1);
|
|
|
configureLineActor(m_pXAxisData, m_pXAxisMapper, m_pXAxisActor,
|
|
|
1.0, 0.0, 0.0, 1.5f);
|
|
|
configureLineActor(m_pYAxisData, m_pYAxisMapper, m_pYAxisActor,
|
|
|
0.0, 160.0 / 255.0, 0.0, 1.5f);
|
|
|
|
|
|
m_pLabelTextProperty->SetFontFamilyToArial();
|
|
|
m_pLabelTextProperty->SetFontSize(14);
|
|
|
m_pLabelTextProperty->SetColor(
|
|
|
235.0 / 255.0, 235.0 / 255.0, 190.0 / 255.0);
|
|
|
m_pLabelTextProperty->SetBold(0);
|
|
|
m_pLabelTextProperty->SetItalic(0);
|
|
|
// VTK 7.1 根据浅色文字自动计算黑色对比阴影，没有 SetShadowColor 接口。
|
|
|
m_pLabelTextProperty->SetShadow(1);
|
|
|
m_pLabelTextProperty->SetShadowOffset(1, -1);
|
|
|
m_pLabelTextProperty->SetBackgroundOpacity(0.0);
|
|
|
m_pLabelTextProperty->SetJustificationToCentered();
|
|
|
m_pLabelTextProperty->SetVerticalJustificationToCentered();
|
|
|
|
|
|
// RootProp 是 Scene 唯一接管的主 Prop，其余 Actor 生命周期均归本图层。
|
|
|
m_pRootProp->setOwner(this);
|
|
|
m_pRootProp->AddPart(m_pBackgroundActor);
|
|
|
m_pRootProp->AddPart(m_pGridActor);
|
|
|
m_pRootProp->AddPart(m_pFrameActor);
|
|
|
m_pRootProp->AddPart(m_pXAxisActor);
|
|
|
m_pRootProp->AddPart(m_pYAxisActor);
|
|
|
m_pRootProp->PickableOff();
|
|
|
}
|
|
|
|
|
|
~nmVTKPlanarScaleGridLayerPrivate()
|
|
|
{
|
|
|
// 先断开逐帧回调目标，再从组合 Prop 移除其持有的所有子 Prop 引用。
|
|
|
m_pRootProp->setOwner(nullptr);
|
|
|
clearLabels();
|
|
|
m_pRootProp->RemovePart(m_pBackgroundActor);
|
|
|
m_pRootProp->RemovePart(m_pGridActor);
|
|
|
m_pRootProp->RemovePart(m_pFrameActor);
|
|
|
m_pRootProp->RemovePart(m_pXAxisActor);
|
|
|
m_pRootProp->RemovePart(m_pYAxisActor);
|
|
|
}
|
|
|
|
|
|
vtkProp* getRootProp() const
|
|
|
{
|
|
|
return m_pRootProp;
|
|
|
}
|
|
|
|
|
|
bool setBounds(double dXMinimum,
|
|
|
double dXMaximum,
|
|
|
double dYMinimum,
|
|
|
double dYMaximum,
|
|
|
double dPlaneZ)
|
|
|
{
|
|
|
std::vector<double> vXTicks;
|
|
|
std::vector<double> vYTicks;
|
|
|
double dXTickStep = 0.0;
|
|
|
double dYTickStep = 0.0;
|
|
|
if(!isValidPlanarBounds(dXMinimum, dXMaximum,
|
|
|
dYMinimum, dYMaximum, dPlaneZ) ||
|
|
|
!calculateNiceTicks(dXMinimum, dXMaximum,
|
|
|
vXTicks, dXTickStep) ||
|
|
|
!calculateNiceTicks(dYMinimum, dYMaximum,
|
|
|
vYTicks, dYTickStep)) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
m_dBounds[0] = dXMinimum;
|
|
|
m_dBounds[1] = dXMaximum;
|
|
|
m_dBounds[2] = dYMinimum;
|
|
|
m_dBounds[3] = dYMaximum;
|
|
|
m_vXTicks = vXTicks;
|
|
|
m_vYTicks = vYTicks;
|
|
|
m_dXTickStep = dXTickStep;
|
|
|
m_dYTickStep = dYTickStep;
|
|
|
m_dPlaneZ = dPlaneZ;
|
|
|
|
|
|
m_dScale = dXMaximum - dXMinimum;
|
|
|
if(dYMaximum - dYMinimum > m_dScale) {
|
|
|
m_dScale = dYMaximum - dYMinimum;
|
|
|
}
|
|
|
m_dTickLength = m_dScale * PLANAR_TICK_LENGTH_FACTOR;
|
|
|
updateDepthCoordinates();
|
|
|
|
|
|
rebuildBackgroundGeometry();
|
|
|
rebuildGridGeometry();
|
|
|
rebuildLabels();
|
|
|
rebuildAxisGeometry(false, false);
|
|
|
m_bHasBounds = true;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool getBounds(double dBounds[4]) const
|
|
|
{
|
|
|
if(dBounds == nullptr || !m_bHasBounds) {
|
|
|
return false;
|
|
|
}
|
|
|
for(int nIndex = 0; nIndex < 4; ++nIndex) {
|
|
|
dBounds[nIndex] = m_dBounds[nIndex];
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
void updateForRenderer(vtkRenderer* pRenderer)
|
|
|
{
|
|
|
if(pRenderer == nullptr || !m_bHasBounds) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 仅当相机明确越过带容差的平面分界时翻转深度顺序，侧视附近沿用上次侧别。
|
|
|
const bool bDepthChanged = updateCameraSide(pRenderer);
|
|
|
if(bDepthChanged) {
|
|
|
updateGeometryDepth();
|
|
|
}
|
|
|
|
|
|
double dCornerDisplay[4][3];
|
|
|
const double dCorners[4][3] = {
|
|
|
{ m_dBounds[0], m_dBounds[2], m_dPlaneZ },
|
|
|
{ m_dBounds[1], m_dBounds[2], m_dPlaneZ },
|
|
|
{ m_dBounds[1], m_dBounds[3], m_dPlaneZ },
|
|
|
{ m_dBounds[0], m_dBounds[3], m_dPlaneZ }
|
|
|
};
|
|
|
for(int nCorner = 0; nCorner < 4; ++nCorner) {
|
|
|
if(!projectPoint(pRenderer, dCorners[nCorner],
|
|
|
dCornerDisplay[nCorner])) {
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const double dMinimumYAverage =
|
|
|
(dCornerDisplay[0][1] + dCornerDisplay[1][1]) * 0.5;
|
|
|
const double dMaximumYAverage =
|
|
|
(dCornerDisplay[2][1] + dCornerDisplay[3][1]) * 0.5;
|
|
|
const double dMinimumXAverage =
|
|
|
(dCornerDisplay[0][0] + dCornerDisplay[3][0]) * 0.5;
|
|
|
const double dMaximumXAverage =
|
|
|
(dCornerDisplay[1][0] + dCornerDisplay[2][0]) * 0.5;
|
|
|
|
|
|
// VTK 显示坐标原点位于左下角，平均值较小的边即当前底边或左边。
|
|
|
const bool bXAxisAtMaximum = selectMaximumEdge(
|
|
|
dMinimumYAverage, dMaximumYAverage,
|
|
|
m_bXAxisAtMaximum);
|
|
|
const bool bYAxisAtMaximum = selectMaximumEdge(
|
|
|
dMinimumXAverage, dMaximumXAverage,
|
|
|
m_bYAxisAtMaximum);
|
|
|
if(!m_bAxesInitialized ||
|
|
|
bXAxisAtMaximum != m_bXAxisAtMaximum ||
|
|
|
bYAxisAtMaximum != m_bYAxisAtMaximum) {
|
|
|
rebuildAxisGeometry(bXAxisAtMaximum, bYAxisAtMaximum);
|
|
|
}
|
|
|
updateLabelPositions(pRenderer,
|
|
|
bXAxisAtMaximum,
|
|
|
bYAxisAtMaximum);
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
void updateDepthCoordinates()
|
|
|
{
|
|
|
const double dCameraSide = static_cast<double>(m_nCameraSide);
|
|
|
m_dAxisZ = m_dPlaneZ + dCameraSide *
|
|
|
m_dScale * PLANAR_AXIS_DEPTH_FACTOR;
|
|
|
m_dGridZ = m_dPlaneZ - dCameraSide *
|
|
|
m_dScale * PLANAR_GRID_DEPTH_FACTOR;
|
|
|
m_dBackgroundZ = m_dPlaneZ - dCameraSide *
|
|
|
m_dScale * PLANAR_BACKGROUND_DEPTH_FACTOR;
|
|
|
}
|
|
|
|
|
|
bool updateCameraSide(vtkRenderer* pRenderer)
|
|
|
{
|
|
|
vtkCamera* pCamera = pRenderer != nullptr
|
|
|
? pRenderer->GetActiveCamera() : nullptr;
|
|
|
const double* pCameraPosition = pCamera != nullptr
|
|
|
? pCamera->GetPosition() : nullptr;
|
|
|
if(pCameraPosition == nullptr ||
|
|
|
!vtkMath::IsFinite(pCameraPosition[2])) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const double dDistanceToPlane = pCameraPosition[2] - m_dPlaneZ;
|
|
|
const double dTolerance =
|
|
|
m_dScale * PLANAR_CAMERA_SIDE_TOLERANCE_FACTOR;
|
|
|
int nCameraSide = m_nCameraSide;
|
|
|
if(dDistanceToPlane > dTolerance) {
|
|
|
nCameraSide = 1;
|
|
|
} else if(dDistanceToPlane < -dTolerance) {
|
|
|
nCameraSide = -1;
|
|
|
}
|
|
|
if(nCameraSide == m_nCameraSide) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
m_nCameraSide = nCameraSide;
|
|
|
updateDepthCoordinates();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool selectMaximumEdge(double dMinimumEdgeAverage,
|
|
|
double dMaximumEdgeAverage,
|
|
|
bool bCurrentMaximum) const
|
|
|
{
|
|
|
const double dDifference =
|
|
|
dMaximumEdgeAverage - dMinimumEdgeAverage;
|
|
|
if(dDifference < -PLANAR_EDGE_SWITCH_PIXEL_TOLERANCE) {
|
|
|
return true;
|
|
|
}
|
|
|
if(dDifference > PLANAR_EDGE_SWITCH_PIXEL_TOLERANCE) {
|
|
|
return false;
|
|
|
}
|
|
|
return m_bAxesInitialized ? bCurrentMaximum : false;
|
|
|
}
|
|
|
|
|
|
void updateGeometryDepth()
|
|
|
{
|
|
|
// 相机翻面只改已有点的 Z，不重建底板、比例线拓扑或任何 VTK Prop。
|
|
|
updatePolyDataZ(m_pBackgroundData, m_dBackgroundZ);
|
|
|
updatePolyDataZ(m_pGridData, m_dGridZ);
|
|
|
updatePolyDataZ(m_pFrameData, m_dAxisZ);
|
|
|
updatePolyDataZ(m_pXAxisData, m_dAxisZ);
|
|
|
updatePolyDataZ(m_pYAxisData, m_dAxisZ);
|
|
|
}
|
|
|
|
|
|
void rebuildBackgroundGeometry()
|
|
|
{
|
|
|
vtkSmartPointer<vtkPoints> pPoints =
|
|
|
vtkSmartPointer<vtkPoints>::New();
|
|
|
vtkSmartPointer<vtkCellArray> pPolygons =
|
|
|
vtkSmartPointer<vtkCellArray>::New();
|
|
|
pPoints->SetDataTypeToDouble();
|
|
|
|
|
|
vtkIdType nPointIds[4];
|
|
|
nPointIds[0] = pPoints->InsertNextPoint(
|
|
|
m_dBounds[0], m_dBounds[2], m_dBackgroundZ);
|
|
|
nPointIds[1] = pPoints->InsertNextPoint(
|
|
|
m_dBounds[1], m_dBounds[2], m_dBackgroundZ);
|
|
|
nPointIds[2] = pPoints->InsertNextPoint(
|
|
|
m_dBounds[1], m_dBounds[3], m_dBackgroundZ);
|
|
|
nPointIds[3] = pPoints->InsertNextPoint(
|
|
|
m_dBounds[0], m_dBounds[3], m_dBackgroundZ);
|
|
|
pPolygons->InsertNextCell(4, nPointIds);
|
|
|
applySurfaceData(m_pBackgroundData, pPoints, pPolygons);
|
|
|
}
|
|
|
|
|
|
void rebuildGridGeometry()
|
|
|
{
|
|
|
vtkSmartPointer<vtkPoints> pPoints =
|
|
|
vtkSmartPointer<vtkPoints>::New();
|
|
|
vtkSmartPointer<vtkCellArray> pLines =
|
|
|
vtkSmartPointer<vtkCellArray>::New();
|
|
|
pPoints->SetDataTypeToDouble();
|
|
|
|
|
|
// 内部主刻度使用虚线；矩形外框由独立实线 Actor 绘制。
|
|
|
const double dXTolerance = m_dXTickStep * 0.00000001;
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vXTicks.size(); ++nIndex) {
|
|
|
const double dX = m_vXTicks[nIndex];
|
|
|
if(dX > m_dBounds[0] + dXTolerance &&
|
|
|
dX < m_dBounds[1] - dXTolerance) {
|
|
|
appendLine(pPoints, pLines, dX, m_dBounds[2], m_dGridZ,
|
|
|
dX, m_dBounds[3], m_dGridZ);
|
|
|
}
|
|
|
}
|
|
|
const double dYTolerance = m_dYTickStep * 0.00000001;
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vYTicks.size(); ++nIndex) {
|
|
|
const double dY = m_vYTicks[nIndex];
|
|
|
if(dY > m_dBounds[2] + dYTolerance &&
|
|
|
dY < m_dBounds[3] - dYTolerance) {
|
|
|
appendLine(pPoints, pLines, m_dBounds[0], dY, m_dGridZ,
|
|
|
m_dBounds[1], dY, m_dGridZ);
|
|
|
}
|
|
|
}
|
|
|
applyLineData(m_pGridData, pPoints, pLines);
|
|
|
}
|
|
|
|
|
|
void rebuildAxisGeometry(bool bXAxisAtMaximum,
|
|
|
bool bYAxisAtMaximum)
|
|
|
{
|
|
|
const double dXAxisY = bXAxisAtMaximum
|
|
|
? m_dBounds[3] : m_dBounds[2];
|
|
|
const double dXAxisDirection = bXAxisAtMaximum ? 1.0 : -1.0;
|
|
|
vtkSmartPointer<vtkPoints> pXPoints =
|
|
|
vtkSmartPointer<vtkPoints>::New();
|
|
|
vtkSmartPointer<vtkCellArray> pXLines =
|
|
|
vtkSmartPointer<vtkCellArray>::New();
|
|
|
pXPoints->SetDataTypeToDouble();
|
|
|
appendLine(pXPoints, pXLines,
|
|
|
m_dBounds[0], dXAxisY, m_dAxisZ,
|
|
|
m_dBounds[1], dXAxisY, m_dAxisZ);
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vXTicks.size(); ++nIndex) {
|
|
|
appendLine(pXPoints, pXLines,
|
|
|
m_vXTicks[nIndex], dXAxisY, m_dAxisZ,
|
|
|
m_vXTicks[nIndex],
|
|
|
dXAxisY + dXAxisDirection * m_dTickLength,
|
|
|
m_dAxisZ);
|
|
|
}
|
|
|
applyLineData(m_pXAxisData, pXPoints, pXLines);
|
|
|
|
|
|
const double dYAxisX = bYAxisAtMaximum
|
|
|
? m_dBounds[1] : m_dBounds[0];
|
|
|
const double dYAxisDirection = bYAxisAtMaximum ? 1.0 : -1.0;
|
|
|
vtkSmartPointer<vtkPoints> pYPoints =
|
|
|
vtkSmartPointer<vtkPoints>::New();
|
|
|
vtkSmartPointer<vtkCellArray> pYLines =
|
|
|
vtkSmartPointer<vtkCellArray>::New();
|
|
|
pYPoints->SetDataTypeToDouble();
|
|
|
appendLine(pYPoints, pYLines,
|
|
|
dYAxisX, m_dBounds[2], m_dAxisZ,
|
|
|
dYAxisX, m_dBounds[3], m_dAxisZ);
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vYTicks.size(); ++nIndex) {
|
|
|
appendLine(pYPoints, pYLines,
|
|
|
dYAxisX, m_vYTicks[nIndex], m_dAxisZ,
|
|
|
dYAxisX + dYAxisDirection * m_dTickLength,
|
|
|
m_vYTicks[nIndex], m_dAxisZ);
|
|
|
}
|
|
|
applyLineData(m_pYAxisData, pYPoints, pYLines);
|
|
|
|
|
|
// 外框只绘制当前坐标轴的两条对边，底边和左边分别由红、绿轴覆盖。
|
|
|
vtkSmartPointer<vtkPoints> pFramePoints =
|
|
|
vtkSmartPointer<vtkPoints>::New();
|
|
|
vtkSmartPointer<vtkCellArray> pFrameLines =
|
|
|
vtkSmartPointer<vtkCellArray>::New();
|
|
|
pFramePoints->SetDataTypeToDouble();
|
|
|
const double dOppositeXAxisY = bXAxisAtMaximum
|
|
|
? m_dBounds[2] : m_dBounds[3];
|
|
|
const double dOppositeYAxisX = bYAxisAtMaximum
|
|
|
? m_dBounds[0] : m_dBounds[1];
|
|
|
appendLine(pFramePoints, pFrameLines,
|
|
|
m_dBounds[0], dOppositeXAxisY, m_dAxisZ,
|
|
|
m_dBounds[1], dOppositeXAxisY, m_dAxisZ);
|
|
|
appendLine(pFramePoints, pFrameLines,
|
|
|
dOppositeYAxisX, m_dBounds[2], m_dAxisZ,
|
|
|
dOppositeYAxisX, m_dBounds[3], m_dAxisZ);
|
|
|
applyLineData(m_pFrameData, pFramePoints, pFrameLines);
|
|
|
|
|
|
m_bXAxisAtMaximum = bXAxisAtMaximum;
|
|
|
m_bYAxisAtMaximum = bYAxisAtMaximum;
|
|
|
m_bAxesInitialized = true;
|
|
|
}
|
|
|
|
|
|
vtkSmartPointer<vtkTextActor> createLabel(
|
|
|
const QString& sText)
|
|
|
{
|
|
|
vtkSmartPointer<vtkTextActor> pLabel =
|
|
|
vtkSmartPointer<vtkTextActor>::New();
|
|
|
const QByteArray aText = sText.toUtf8();
|
|
|
pLabel->SetInput(aText.constData());
|
|
|
pLabel->SetTextProperty(m_pLabelTextProperty);
|
|
|
pLabel->SetTextScaleModeToNone();
|
|
|
pLabel->GetProperty()->SetDisplayLocationToForeground();
|
|
|
pLabel->PickableOff();
|
|
|
m_pRootProp->AddPart(pLabel);
|
|
|
return pLabel;
|
|
|
}
|
|
|
|
|
|
void rebuildLabels()
|
|
|
{
|
|
|
clearLabels();
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vXTicks.size(); ++nIndex) {
|
|
|
m_vXLabels.push_back(createLabel(
|
|
|
formatTickValue(m_vXTicks[nIndex],
|
|
|
m_dXTickStep)));
|
|
|
}
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vYTicks.size(); ++nIndex) {
|
|
|
m_vYLabels.push_back(createLabel(
|
|
|
formatTickValue(m_vYTicks[nIndex],
|
|
|
m_dYTickStep)));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void clearLabels()
|
|
|
{
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vXLabels.size(); ++nIndex) {
|
|
|
m_pRootProp->RemovePart(m_vXLabels[nIndex]);
|
|
|
}
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vYLabels.size(); ++nIndex) {
|
|
|
m_pRootProp->RemovePart(m_vYLabels[nIndex]);
|
|
|
}
|
|
|
m_vXLabels.clear();
|
|
|
m_vYLabels.clear();
|
|
|
}
|
|
|
|
|
|
bool projectPoint(vtkRenderer* pRenderer,
|
|
|
const double dWorld[3],
|
|
|
double dDisplay[3]) const
|
|
|
{
|
|
|
if(pRenderer == nullptr || dWorld == nullptr || dDisplay == nullptr) {
|
|
|
return false;
|
|
|
}
|
|
|
pRenderer->SetWorldPoint(
|
|
|
dWorld[0], dWorld[1], dWorld[2], 1.0);
|
|
|
pRenderer->WorldToDisplay();
|
|
|
const double* pDisplay = pRenderer->GetDisplayPoint();
|
|
|
if(pDisplay == nullptr ||
|
|
|
!vtkMath::IsFinite(pDisplay[0]) ||
|
|
|
!vtkMath::IsFinite(pDisplay[1]) ||
|
|
|
!vtkMath::IsFinite(pDisplay[2])) {
|
|
|
return false;
|
|
|
}
|
|
|
dDisplay[0] = pDisplay[0];
|
|
|
dDisplay[1] = pDisplay[1];
|
|
|
dDisplay[2] = pDisplay[2];
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool calculateDisplayDirection(vtkRenderer* pRenderer,
|
|
|
const double dAnchor[3],
|
|
|
const double dOuterPoint[3],
|
|
|
double dDirection[2]) const
|
|
|
{
|
|
|
double dAnchorDisplay[3];
|
|
|
double dOuterDisplay[3];
|
|
|
if(!projectPoint(pRenderer, dAnchor, dAnchorDisplay) ||
|
|
|
!projectPoint(pRenderer, dOuterPoint, dOuterDisplay)) {
|
|
|
return false;
|
|
|
}
|
|
|
const double dX = dOuterDisplay[0] - dAnchorDisplay[0];
|
|
|
const double dY = dOuterDisplay[1] - dAnchorDisplay[1];
|
|
|
const double dLength = std::sqrt(dX * dX + dY * dY);
|
|
|
if(!vtkMath::IsFinite(dLength) || dLength < 0.000001) {
|
|
|
return false;
|
|
|
}
|
|
|
dDirection[0] = dX / dLength;
|
|
|
dDirection[1] = dY / dLength;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
void updateLabelPositions(vtkRenderer* pRenderer,
|
|
|
bool bXAxisAtMaximum,
|
|
|
bool bYAxisAtMaximum)
|
|
|
{
|
|
|
const double dXAxisY = bXAxisAtMaximum
|
|
|
? m_dBounds[3] : m_dBounds[2];
|
|
|
const double dXAxisDirection = bXAxisAtMaximum ? 1.0 : -1.0;
|
|
|
const double dXAxisAnchor[3] = {
|
|
|
(m_dBounds[0] + m_dBounds[1]) * 0.5,
|
|
|
dXAxisY,
|
|
|
m_dAxisZ
|
|
|
};
|
|
|
const double dXAxisOuterPoint[3] = {
|
|
|
dXAxisAnchor[0],
|
|
|
dXAxisY + dXAxisDirection * m_dTickLength,
|
|
|
m_dAxisZ
|
|
|
};
|
|
|
double dXAxisDisplayDirection[2] = { 0.0, -1.0 };
|
|
|
calculateDisplayDirection(pRenderer,
|
|
|
dXAxisAnchor,
|
|
|
dXAxisOuterPoint,
|
|
|
dXAxisDisplayDirection);
|
|
|
const int nXAxisOffsetX = roundedPixelOffset(
|
|
|
dXAxisDisplayDirection[0] * PLANAR_LABEL_PIXEL_GAP);
|
|
|
const int nXAxisOffsetY = roundedPixelOffset(
|
|
|
dXAxisDisplayDirection[1] * PLANAR_LABEL_PIXEL_GAP);
|
|
|
|
|
|
const double dXAxisMinimumPoint[3] = {
|
|
|
m_dBounds[0], dXAxisY, m_dAxisZ
|
|
|
};
|
|
|
const double dXAxisMaximumPoint[3] = {
|
|
|
m_dBounds[1], dXAxisY, m_dAxisZ
|
|
|
};
|
|
|
double dXAxisPositiveDirection[2] = { 1.0, 0.0 };
|
|
|
calculateDisplayDirection(pRenderer,
|
|
|
dXAxisMinimumPoint,
|
|
|
dXAxisMaximumPoint,
|
|
|
dXAxisPositiveDirection);
|
|
|
const double dXAxisCornerValue = bYAxisAtMaximum
|
|
|
? m_dBounds[1] : m_dBounds[0];
|
|
|
const double dXAxisCornerDirection = bYAxisAtMaximum ? -1.0 : 1.0;
|
|
|
const double dXAxisTolerance = m_dXTickStep * 0.00000001;
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vXLabels.size(); ++nIndex) {
|
|
|
const double dLabelWorld[3] = {
|
|
|
m_vXTicks[nIndex], dXAxisOuterPoint[1], m_dAxisZ
|
|
|
};
|
|
|
double dLabelDisplay[3];
|
|
|
if(!projectPoint(pRenderer, dLabelWorld, dLabelDisplay)) {
|
|
|
m_vXLabels[nIndex]->SetVisibility(0);
|
|
|
continue;
|
|
|
}
|
|
|
int nOffsetX = nXAxisOffsetX;
|
|
|
int nOffsetY = nXAxisOffsetY;
|
|
|
if(std::fabs(m_vXTicks[nIndex] - dXAxisCornerValue) <=
|
|
|
dXAxisTolerance) {
|
|
|
nOffsetX += roundedPixelOffset(
|
|
|
dXAxisPositiveDirection[0] *
|
|
|
dXAxisCornerDirection *
|
|
|
PLANAR_CORNER_LABEL_PIXEL_SHIFT);
|
|
|
nOffsetY += roundedPixelOffset(
|
|
|
dXAxisPositiveDirection[1] *
|
|
|
dXAxisCornerDirection *
|
|
|
PLANAR_CORNER_LABEL_PIXEL_SHIFT);
|
|
|
}
|
|
|
m_vXLabels[nIndex]->SetDisplayPosition(
|
|
|
roundedPixelOffset(dLabelDisplay[0]) + nOffsetX,
|
|
|
roundedPixelOffset(dLabelDisplay[1]) + nOffsetY);
|
|
|
m_vXLabels[nIndex]->SetVisibility(1);
|
|
|
}
|
|
|
|
|
|
const double dYAxisX = bYAxisAtMaximum
|
|
|
? m_dBounds[1] : m_dBounds[0];
|
|
|
const double dYAxisDirection = bYAxisAtMaximum ? 1.0 : -1.0;
|
|
|
const double dYAxisAnchor[3] = {
|
|
|
dYAxisX,
|
|
|
(m_dBounds[2] + m_dBounds[3]) * 0.5,
|
|
|
m_dAxisZ
|
|
|
};
|
|
|
const double dYAxisOuterPoint[3] = {
|
|
|
dYAxisX + dYAxisDirection * m_dTickLength,
|
|
|
dYAxisAnchor[1],
|
|
|
m_dAxisZ
|
|
|
};
|
|
|
double dYAxisDisplayDirection[2] = { -1.0, 0.0 };
|
|
|
calculateDisplayDirection(pRenderer,
|
|
|
dYAxisAnchor,
|
|
|
dYAxisOuterPoint,
|
|
|
dYAxisDisplayDirection);
|
|
|
const int nYAxisOffsetX = roundedPixelOffset(
|
|
|
dYAxisDisplayDirection[0] * PLANAR_LABEL_PIXEL_GAP);
|
|
|
const int nYAxisOffsetY = roundedPixelOffset(
|
|
|
dYAxisDisplayDirection[1] * PLANAR_LABEL_PIXEL_GAP);
|
|
|
|
|
|
const double dYAxisMinimumPoint[3] = {
|
|
|
dYAxisX, m_dBounds[2], m_dAxisZ
|
|
|
};
|
|
|
const double dYAxisMaximumPoint[3] = {
|
|
|
dYAxisX, m_dBounds[3], m_dAxisZ
|
|
|
};
|
|
|
double dYAxisPositiveDirection[2] = { 0.0, 1.0 };
|
|
|
calculateDisplayDirection(pRenderer,
|
|
|
dYAxisMinimumPoint,
|
|
|
dYAxisMaximumPoint,
|
|
|
dYAxisPositiveDirection);
|
|
|
const double dYAxisCornerValue = bXAxisAtMaximum
|
|
|
? m_dBounds[3] : m_dBounds[2];
|
|
|
const double dYAxisCornerDirection = bXAxisAtMaximum ? -1.0 : 1.0;
|
|
|
const double dYAxisTolerance = m_dYTickStep * 0.00000001;
|
|
|
for(std::size_t nIndex = 0; nIndex < m_vYLabels.size(); ++nIndex) {
|
|
|
const double dLabelWorld[3] = {
|
|
|
dYAxisOuterPoint[0], m_vYTicks[nIndex], m_dAxisZ
|
|
|
};
|
|
|
double dLabelDisplay[3];
|
|
|
if(!projectPoint(pRenderer, dLabelWorld, dLabelDisplay)) {
|
|
|
m_vYLabels[nIndex]->SetVisibility(0);
|
|
|
continue;
|
|
|
}
|
|
|
int nOffsetX = nYAxisOffsetX;
|
|
|
int nOffsetY = nYAxisOffsetY;
|
|
|
if(std::fabs(m_vYTicks[nIndex] - dYAxisCornerValue) <=
|
|
|
dYAxisTolerance) {
|
|
|
nOffsetX += roundedPixelOffset(
|
|
|
dYAxisPositiveDirection[0] *
|
|
|
dYAxisCornerDirection *
|
|
|
PLANAR_CORNER_LABEL_PIXEL_SHIFT);
|
|
|
nOffsetY += roundedPixelOffset(
|
|
|
dYAxisPositiveDirection[1] *
|
|
|
dYAxisCornerDirection *
|
|
|
PLANAR_CORNER_LABEL_PIXEL_SHIFT);
|
|
|
}
|
|
|
m_vYLabels[nIndex]->SetDisplayPosition(
|
|
|
roundedPixelOffset(dLabelDisplay[0]) + nOffsetX,
|
|
|
roundedPixelOffset(dLabelDisplay[1]) + nOffsetY);
|
|
|
m_vYLabels[nIndex]->SetVisibility(1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
vtkSmartPointer<vtkNmPlanarScaleGridProp> m_pRootProp;
|
|
|
vtkSmartPointer<vtkPolyData> m_pBackgroundData;
|
|
|
vtkSmartPointer<vtkPolyData> m_pGridData;
|
|
|
vtkSmartPointer<vtkPolyData> m_pFrameData;
|
|
|
vtkSmartPointer<vtkPolyData> m_pXAxisData;
|
|
|
vtkSmartPointer<vtkPolyData> m_pYAxisData;
|
|
|
vtkSmartPointer<vtkPolyDataMapper> m_pBackgroundMapper;
|
|
|
vtkSmartPointer<vtkPolyDataMapper> m_pGridMapper;
|
|
|
vtkSmartPointer<vtkPolyDataMapper> m_pFrameMapper;
|
|
|
vtkSmartPointer<vtkPolyDataMapper> m_pXAxisMapper;
|
|
|
vtkSmartPointer<vtkPolyDataMapper> m_pYAxisMapper;
|
|
|
vtkSmartPointer<vtkActor> m_pBackgroundActor;
|
|
|
vtkSmartPointer<vtkActor> m_pGridActor;
|
|
|
vtkSmartPointer<vtkActor> m_pFrameActor;
|
|
|
vtkSmartPointer<vtkActor> m_pXAxisActor;
|
|
|
vtkSmartPointer<vtkActor> m_pYAxisActor;
|
|
|
vtkSmartPointer<vtkTextProperty> m_pLabelTextProperty;
|
|
|
std::vector<vtkSmartPointer<vtkTextActor> > m_vXLabels;
|
|
|
std::vector<vtkSmartPointer<vtkTextActor> > m_vYLabels;
|
|
|
std::vector<double> m_vXTicks;
|
|
|
std::vector<double> m_vYTicks;
|
|
|
double m_dBounds[4];
|
|
|
double m_dPlaneZ;
|
|
|
double m_dScale;
|
|
|
double m_dBackgroundZ;
|
|
|
double m_dGridZ;
|
|
|
double m_dAxisZ;
|
|
|
double m_dTickLength;
|
|
|
double m_dXTickStep;
|
|
|
double m_dYTickStep;
|
|
|
bool m_bHasBounds;
|
|
|
bool m_bAxesInitialized;
|
|
|
bool m_bXAxisAtMaximum;
|
|
|
bool m_bYAxisAtMaximum;
|
|
|
int m_nCameraSide;
|
|
|
};
|
|
|
|
|
|
int vtkNmPlanarScaleGridProp::RenderOpaqueGeometry(vtkViewport* pViewport)
|
|
|
{
|
|
|
if(m_pOwner != nullptr) {
|
|
|
m_pOwner->updateForRenderer(vtkRenderer::SafeDownCast(pViewport));
|
|
|
}
|
|
|
return this->Superclass::RenderOpaqueGeometry(pViewport);
|
|
|
}
|
|
|
|
|
|
int vtkNmPlanarScaleGridProp::RenderOverlay(vtkViewport* pViewport)
|
|
|
{
|
|
|
if(m_pOwner != nullptr) {
|
|
|
// Overlay 阶段再次同步屏幕坐标，确保文字使用本帧最终相机矩阵。
|
|
|
m_pOwner->updateForRenderer(vtkRenderer::SafeDownCast(pViewport));
|
|
|
}
|
|
|
return this->Superclass::RenderOverlay(pViewport);
|
|
|
}
|
|
|
|
|
|
nmVTKPlanarScaleGridLayer::nmVTKPlanarScaleGridLayer(
|
|
|
const QString& sLayerId)
|
|
|
: nmVTKRenderLayer(sLayerId),
|
|
|
m_pPrivate(new nmVTKPlanarScaleGridLayerPrivate)
|
|
|
{
|
|
|
Q_ASSERT(isPlanarScaleGridGuiThread());
|
|
|
setRenderProp(m_pPrivate->getRootProp());
|
|
|
}
|
|
|
|
|
|
nmVTKPlanarScaleGridLayer::~nmVTKPlanarScaleGridLayer()
|
|
|
{
|
|
|
Q_ASSERT(isPlanarScaleGridGuiThread());
|
|
|
// 先从 Renderer 移除组合 Prop，再清除其逐帧更新目标和子 Prop 引用。
|
|
|
detach();
|
|
|
delete m_pPrivate;
|
|
|
m_pPrivate = nullptr;
|
|
|
}
|
|
|
|
|
|
bool nmVTKPlanarScaleGridLayer::setBounds(
|
|
|
double dXMinimum,
|
|
|
double dXMaximum,
|
|
|
double dYMinimum,
|
|
|
double dYMaximum,
|
|
|
double dPlaneZ)
|
|
|
{
|
|
|
Q_ASSERT(isPlanarScaleGridGuiThread());
|
|
|
return isPlanarScaleGridGuiThread() && m_pPrivate != nullptr &&
|
|
|
m_pPrivate->setBounds(dXMinimum, dXMaximum,
|
|
|
dYMinimum, dYMaximum, dPlaneZ);
|
|
|
}
|
|
|
|
|
|
bool nmVTKPlanarScaleGridLayer::getBounds(double dBounds[4]) const
|
|
|
{
|
|
|
return m_pPrivate != nullptr && m_pPrivate->getBounds(dBounds);
|
|
|
}
|