QOpenGLWidget显示点云

最新推荐文章于 2025-03-26 15:24:42 发布
最新推荐文章于 2025-03-26 15:24:42 发布
阅读量777 收藏 4
点赞数 3
分类专栏： Qt 文章标签： qt opengl 点云
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/taifyang/article/details/142771813
版权

纯Qt实现使用QOpenGLWidget显示点云，无需借助PCL、VTK、Open3d等第三方库。

myqopenglwidget.h

#ifndef MYQOPENGLWIDGET_H
#define MYQOPENGLWIDGET_H

#include <QtGui/QOpenGLFunctions>
#include <QtWidgets/QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <QPainter>
#include <QOpenGLContext>
#include <QOpenGLPaintDevice>
#include <QOpenGLShaderProgram>
#include <QOpenGLShader>
#include <QTime>
#include <QTimer>
#include <QVector3D>
#include <QMouseEvent>
#include <QKeyEvent>

QT_BEGIN_NAMESPACE
class QPainter;
class QOpenGLContext;
class QOpenGLPaintDevice;
class QOpenGLShaderProgram;
class QOpenGLShader;
QT_END_NAMESPACE

struct PointXYZRGB
{
    float x;
    float y;
    float z;
    int r;
    int g;
    int b;
};

struct BoundingBox
{
    float width;
    float height;
    float depth;
    QVector3D maxPoint;
    QVector3D minPoint;
    QVector3D centerPoint;
};

class MyQOpenglWidget: public QOpenGLWidget, protected QOpenGLFunctions
{
    Q_OBJECT
public:
    explicit MyQOpenglWidget(QWidget *parent = 0);
    ~MyQOpenglWidget();
    void showPointCloud(const std::vector<PointXYZRGB>& cloud);
    virtual void resizeGL(int w, int h);
    void setBackgroundColor(QVector3D color);

protected:
    virtual void initializeGL(void);
    virtual void paintGL(void);

    struct VertexInfo
    {
        float pos[3];
        float normal[3];
        float color[4];
    };
private slots:
    void onTimerOut(void);
    virtual void mousePressEvent(QMouseEvent * e);
    virtual void mouseMoveEvent(QMouseEvent * e);
    virtual void mouseReleaseEvent(QMouseEvent * e);
    virtual void wheelEvent(QWheelEvent * e);
    virtual void keyPressEvent(QKeyEvent *e);
    virtual void leaveEvent(QEvent *);
    virtual void enterEvent(QEvent *);

private:
    QTimer *m_Timer;
    QOpenGLContext *m_context;					
    QOpenGLShaderProgram *m_Program;			
    QOpenGLFunctions_3_3_Core *OpenGLCore;
    QOpenGLShader *m_VertexShader;
    QOpenGLShader *m_FragmentShader;

	// shader spara
    GLuint m_posAttr;                           
    GLuint m_colAttr;                          
    GLuint m_norAttr;                           
    GLuint m_matrixUniform;						
	GLuint m_VBO;
    GLuint m_VAO;
    QVector4D m_backgroundColor;

	//store points
	QVector<VertexInfo> m_PointsVertex;				
    BoundingBox m_box;
   
    QVector3D m_lineMove;
    QQuaternion m_rotate;
	QVector3D m_rotationAxis;
    float m_scale;

    QVector2D m_lastPoint;

    GLuint createGPUProgram(QString nVertexShaderFile, QString nFragmentShaderFile);
    void GetShaderUniformPara();
    bool InitShader();                    

    void LineMove(QVector2D posOrgin, QVector2D posEnd);
    void Rotate(QVector2D posOrgin, QVector2D posEnd);
    void modelZoomInOrOut(bool ZoomInOrOut);
    QVector3D pixelPosToViewPos(const QVector2D& p);
    void calRotation(QVector2D posOrgin, QVector2D posEnd);
    void calculateBoundingBox(const std::vector<PointXYZRGB>& cloud);
    void initPointCloud(const std::vector<PointXYZRGB>& cloud);
    void gray2Pseudocolor(const PointXYZRGB pos, float color[4]);
    void changePointCloud();
    void setMatrixUniform();
    void ResetView();
    void initCloud();
};

#endif // MYQOPENGLWIDGET_H

myqopenglwidget.cpp

#include "myqopenglwidget.h"
#include <QtMath>

static const char *vertexShaderSource =
        "attribute highp vec3 posAttr;\n"
        "attribute lowp vec4 colAttr;\n"
        "varying lowp vec4 col;\n"
        "uniform highp mat4 matrix;\n"
        "void main() {\n"
        "  col=colAttr;\n"
        "  gl_Position=matrix * vec4(posAttr,1.0f);\n"
        "}\n";

static const char *fragmentShaderSource =   
        "varying lowp vec4 col;\n"
        "void main() {\n"
        "   gl_FragColor = col;\n"
        "}\n";

MyQOpenglWidget::MyQOpenglWidget(QWidget *parent)
    : QOpenGLWidget(parent)
    ,m_context(NULL)
    ,m_Program(NULL)
    ,OpenGLCore(NULL)
    ,m_posAttr(0)    
    ,m_colAttr(0)
    ,m_norAttr(0)
    ,m_matrixUniform(0)
    ,m_VBO(0)
    ,m_VAO(0)
    ,m_VertexShader(NULL)
    ,m_FragmentShader(NULL)
    ,m_scale(1.0f)
{
    m_Timer = new QTimer;
    m_PointsVertex = QVector<VertexInfo>();
    ResetView();
    this->grabKeyboard();
}

MyQOpenglWidget::~MyQOpenglWidget()
{
    if(m_context)
    {
        delete m_context;
        m_context = NULL;
    }
    if(m_Program)
    {
        delete m_Program;
        m_Program = NULL;
    }
    m_PointsVertex.clear();
}

void MyQOpenglWidget::showPointCloud(const std::vector<PointXYZRGB> &cloud)
{
    QTime startTime = QTime::currentTime();
    initPointCloud(cloud);
    startTime = QTime::currentTime();
    changePointCloud();
    ResetView();
    repaint();
}

void MyQOpenglWidget::calculateBoundingBox(const std::vector<PointXYZRGB> &cloud)
{
    float x_max=INT_MIN, y_max=INT_MIN, z_max=INT_MIN;
    float x_min=INT_MAX, y_min=INT_MAX, z_min=INT_MAX;
    for(int i = 0;i<cloud.size();i++)
    {
        if(cloud[i].x>x_max)    x_max=cloud[i].x;
        if(cloud[i].x<x_min)    x_min=cloud[i].x;
        if(cloud[i].y>y_max)    y_max=cloud[i].y;
        if(cloud[i].y<y_min)    y_min=cloud[i].y;
        if(cloud[i].z>z_max)    z_max=cloud[i].z;
        if(cloud[i].z<z_max)    z_min=cloud[i].z;
    }
    float width = x_max - x_min;
    float height = y_max - y_min;
    float depth = z_max - z_min;
    QVector3D maxPoint(x_max, y_max, z_max);
    QVector3D minPoint(x_min, y_min, z_min);
    QVector3D centerPoint((x_max+x_min)/2, (y_max+y_min)/2, (z_max+z_min)/2);
    m_box.width = width;
    m_box.height = height;
    m_box.depth = depth;
    m_box.maxPoint = maxPoint;
    m_box.minPoint = minPoint;
    m_box.centerPoint = centerPoint;
}

void MyQOpenglWidget::initPointCloud(const std::vector<PointXYZRGB> &cloud)
{
    m_PointsVertex.clear();
    m_PointsVertex.resize((int)cloud.size());
    
    calculateBoundingBox(cloud);
    
    for(int i = 0;i<cloud.size();i++)
    {
        //move cloud center to origin
        m_PointsVertex[i].pos[0] = cloud[i].x;
        m_PointsVertex[i].pos[1] = cloud[i].y;
        m_PointsVertex[i].pos[2] = cloud[i].z;
        gray2Pseudocolor(cloud[i], m_PointsVertex[i].color);
        m_PointsVertex[i].normal[0] = 0.0f;
        m_PointsVertex[i].normal[1] = 1.0f;
        m_PointsVertex[i].normal[2] = 0.0f;
    }
}

void MyQOpenglWidget::gray2Pseudocolor(const PointXYZRGB pos,float color[4])
{
    color[0] = pos.r *1.0f/255;
    color[1] = pos.g *1.0f/255;
    color[2] = pos.b *1.0f/255;
    color[3] = 1.0f;
}

void MyQOpenglWidget::changePointCloud()
{
    if(m_PointsVertex.size()<=0)
    {
        return ;
    }
    OpenGLCore->glBindVertexArray(m_VAO);
    glBindBuffer(GL_ARRAY_BUFFER, m_VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(VertexInfo)*(int)m_PointsVertex.size(), m_PointsVertex.data(), GL_DYNAMIC_DRAW);
    
    glEnableVertexAttribArray(m_posAttr);
    glVertexAttribPointer(m_posAttr, 3, GL_FLOAT, GL_FALSE, sizeof(VertexInfo), (void*)(offsetof(VertexInfo, pos)));
    glEnableVertexAttribArray(m_colAttr);
    glVertexAttribPointer(m_colAttr, 4, GL_FLOAT, GL_FALSE, sizeof(VertexInfo), (void*)(offsetof(VertexInfo,color)));
    
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    OpenGLCore->glBindVertexArray(0);
}

void MyQOpenglWidget::ResetView()
{
    m_lineMove = QVector3D();
    m_rotate = QQuaternion(); 
    m_rotate *= QQuaternion::fromAxisAndAngle(QVector3D(0,0,1),180);
    m_rotationAxis = QVector3D();
    m_scale = 1.0f;
}

void MyQOpenglWidget::setBackgroundColor(QVector3D color)
{
    m_backgroundColor= QVector4D(color, 1.0f);
}

void MyQOpenglWidget::resizeGL(int w, int h)
{
    const qreal retinaScale = devicePixelRatio();
    glViewport(0, 0, w * retinaScale, h * retinaScale);
    repaint();
}

void MyQOpenglWidget::initializeGL()
{
    bool binit = true;
    binit &= InitShader();
    if (!binit)
    {
        return;
    }
    OpenGLCore = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_3_Core>();
    initializeOpenGLFunctions();
    glEnable(GL_DEPTH_TEST);
    OpenGLCore->glGenVertexArrays(1, &m_VAO);
    glGenBuffers(1, &m_VBO);
    
    //init need import a point data
    initCloud();
    changePointCloud();
    
    QObject::connect(m_Timer, SIGNAL(timeout()), this, SLOT(onTimerOut()));
    m_Timer->start(50);
}

bool MyQOpenglWidget::InitShader()
{
    m_Program = new QOpenGLShaderProgram(this);
    bool success = true;
    success &= m_Program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource);
    success &= m_Program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource);
    success &= m_Program->link();
    GetShaderUniformPara();
    return success;
}

void MyQOpenglWidget::GetShaderUniformPara()
{
    m_posAttr = m_Program->attributeLocation("posAttr");
    m_colAttr = m_Program->attributeLocation("colAttr");  
    m_matrixUniform = m_Program->uniformLocation("matrix");
}

void MyQOpenglWidget::paintGL()
{
    m_Program->bind();
    glClearColor(m_backgroundColor.x(), m_backgroundColor.y(), m_backgroundColor.z(), m_backgroundColor.w());
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BITS);
    
    OpenGLCore->glBindVertexArray(m_VAO);
    setMatrixUniform();
    glDrawArrays(GL_POINTS, 0,(GLsizei ) m_PointsVertex.size());    
    OpenGLCore->glPointSize(2.0f);
    
    OpenGLCore->glBindVertexArray(0);
    m_Program->release();
}

void MyQOpenglWidget::setMatrixUniform()
{
    QMatrix4x4 matrix = QMatrix4x4();
    QMatrix4x4 matrixPerspect= QMatrix4x4();;
    QMatrix4x4 matrixView= QMatrix4x4();;
    QMatrix4x4 matrixModel= QMatrix4x4();;
    
    QVector3D minPos = (m_box.minPoint - m_box.centerPoint);
    QVector3D maxPos = (m_box.maxPoint - m_box.centerPoint);
    float maxAxis =qAbs(qMax(qMax(m_box.width,m_box.height),m_box.depth)) ;
    
    matrixPerspect.ortho(2*minPos[0], 2*maxPos[0], 2*minPos[1], 2*maxPos[1], -2*maxAxis, 2*maxAxis);
    
    matrixView.lookAt(QVector3D(0, 0, 1.0),QVector3D(0.0,0.0,-1),QVector3D(0.0,1.0,0.0));
    matrixView.translate(m_lineMove.x(),m_lineMove.y(),m_lineMove.z());
    
    matrixModel.rotate(m_rotate);
    matrixModel.scale(m_scale);
    
    matrix = matrixPerspect*matrixView*matrixModel;
    
    m_Program->setUniformValue(m_matrixUniform, matrix);
}

void MyQOpenglWidget::initCloud()
{
    m_PointsVertex.clear();
    VertexInfo point;
    point.pos[0] = 0.0f ;
    point.pos[1] = 0.0f ;
    point.pos[2] = 0.0f ;
    point.color[0] = m_backgroundColor.x();
    point.color[1] = m_backgroundColor.y();
    point.color[2] = m_backgroundColor.z();
    point.color[3] = m_backgroundColor.w();
    point.normal[0] = 0.0f;
    point.normal[1] = 1.0f;
    point.normal[2] = 0.0f;
    m_PointsVertex.push_back(point);
}

void MyQOpenglWidget::onTimerOut()
{
    if(this->isVisible())
    {
        repaint();
    }
}

void MyQOpenglWidget::mousePressEvent(QMouseEvent *e)
{
    if (e->buttons()&Qt::LeftButton || e->buttons()&Qt::MidButton)
    {
        setMouseTracking(true);
        m_lastPoint = QVector2D(e->localPos());
    }   
}

void MyQOpenglWidget::mouseMoveEvent(QMouseEvent *e)
{	
    if (e->buttons()&Qt::LeftButton)
    {
        Rotate(QVector2D(m_lastPoint), QVector2D(e->localPos()));
    }
    if (e->buttons()&Qt::MidButton)
    {
        LineMove(m_lastPoint, QVector2D(e->localPos()));
    }
    m_lastPoint = QVector2D(e->localPos());
}

void MyQOpenglWidget::mouseReleaseEvent(QMouseEvent *e)
{
    setMouseTracking(false);
}

void MyQOpenglWidget::wheelEvent(QWheelEvent *e)
{   
    if(e->delta() > 0)
    {
        modelZoomInOrOut(true);
    }
    else
    {
        modelZoomInOrOut(false);
    }
}

void MyQOpenglWidget::keyPressEvent(QKeyEvent *e)
{
    if (e->key() == Qt::Key_R)
    {
        ResetView();
    }
    QWidget::keyPressEvent(e);
}

void MyQOpenglWidget::leaveEvent(QEvent *)
{
    releaseKeyboard();
}

void MyQOpenglWidget::enterEvent(QEvent *)
{
    grabKeyboard();
}

GLuint MyQOpenglWidget::createGPUProgram(QString nVertexShaderFile, QString nFragmentShaderFile)
{
    m_VertexShader = new QOpenGLShader(QOpenGLShader::Vertex);
    bool isOK = m_VertexShader->compileSourceFile(nVertexShaderFile);
    if (!isOK)
    {
        delete m_VertexShader;
        m_VertexShader = nullptr;
        qDebug() << "compile vertex shader fail" ;
        return 0;
    }
    
    m_FragmentShader = new QOpenGLShader(QOpenGLShader::Fragment);
    if (!m_FragmentShader->compileSourceFile(nFragmentShaderFile))
    {
        delete m_VertexShader;
        delete m_FragmentShader;
        m_FragmentShader = nullptr;
        qDebug() << "compile fragment shader fail";
        return 0;
    }
    m_Program = new QOpenGLShaderProgram(this);
    m_Program->addShader(m_VertexShader);
    m_Program->addShader(m_FragmentShader);
    m_Program->link();
    GetShaderUniformPara();
    return m_Program->programId();
}

void MyQOpenglWidget::LineMove(QVector2D posOrgin, QVector2D posEnd)
{
    float ratio = 1.0f;
    float xoffset = posEnd.x() - posOrgin.x();
    float yoffset = posEnd.y() - posOrgin.y();
    
    m_lineMove.setX(m_lineMove.x()+xoffset*ratio);
    m_lineMove.setY(m_lineMove.y()-yoffset*ratio);
}

void MyQOpenglWidget::Rotate(QVector2D posOrgin, QVector2D posEnd)
{
    QVector2D diff = posEnd - posOrgin;
    qreal acc = diff.length() / 100.0;
    if (acc<0.01f)
    {
        return;
    }
    calRotation(posOrgin,posEnd);
}

void MyQOpenglWidget::modelZoomInOrOut(bool ZoomInOrOut)
{
    if(ZoomInOrOut)//zoom in
    {
        m_scale*=1.1f;
    }
    else
    {
        m_scale*=0.9f;
        if(m_scale<0.5f)
        {
            m_scale = 0.5f;
        }
    }
}

void MyQOpenglWidget::calRotation(QVector2D posOrgin, QVector2D posEnd)
{
    QVector3D orginViewPos = pixelPosToViewPos(posOrgin);
    QVector3D endViewPos = pixelPosToViewPos(posEnd);
    float RotateAngle;
    RotateAngle = qRadiansToDegrees(std::acos(QVector3D::dotProduct(orginViewPos,endViewPos)));
    QVector3D axis;
    axis=QVector3D::crossProduct(orginViewPos, endViewPos);
    axis.normalize();
    m_rotate=  QQuaternion::fromAxisAndAngle(axis, RotateAngle)*m_rotate;
}

QVector3D MyQOpenglWidget::pixelPosToViewPos(const QVector2D &p)
{
    QVector3D viewPos(2.0 * float(p.x()) / width() - 1.0,  1.0 - 2.0 * float(p.y()) / height(), 0);
    float sqrZ = 1 - QVector3D::dotProduct(viewPos, viewPos);
    if(sqrZ>0)
    {
        viewPos.setZ(std::sqrt(sqrZ));
    }
    else
    {     
        viewPos.normalize();
    }
    return viewPos;
}

效果如下：
在这里插入图片描述
完整工程文件见下载链接：
https://download.youkuaiyun.com/download/taifyang/89862113

OpenGl点云显示
09-17
程序为c++平台编写的，利用OpenGl显示点云数据，达到了实现移动缩放等基本的功能
在Qt中使用OpenGL显示数据点
qq:1115926058
08-04 1885
显示三维点云，能对不同的点染色，可以调节视角及观察者的位置。
QOpenGLWidget动态加载功能实现教程(Qt+OpenGL)
最新发布
qq_37366618的博客
03-26 856
QOpenGLWidget实现加载模型功能
QT-opengl窗体，实现了 1.绘制立方体， 2.读取点云并显示 3.相机可以进行简单旋转，旋转速度可以渐渐变缓 4.可以半透明(融合)演示。
09-13
QT-opengl窗体，实现了 1.绘制立方体， 2.读取点云并显示 3.相机可以进行简单旋转，旋转速度可以渐渐变缓 4.可以半透明(融合)演示。
QT 使用OpenGL显示并查看点云图
Ray
01-18 1176
无需其他库，只使用OpenGL绘制图形类，计算点云的最小包围盒（轴对齐包围盒，AABB）,可以帮助确定视图的缩放级别，或者在用户进行平移和旋转操作时保持点云在视图内这两个类结合起来，前者提供了渲染和交互的框架，后者用于理解和限定点云的空间范围。
pcl+vtk（三）QT中使用QVTKOpenGLNativeWidget的简单教程以及案例，利用PCLVisualizer显示点云
m0_67254672的博客
10-17 1万+
先添加一个带有ui的QT应用程序。然后将QOpenGLWidget控件提升为QVTKOpenGLNativeWidget控件，步骤如下：
QT--OPENGL-串口-雷达点云图显示
05-07
可实现如下功能： 1：利用 OpenGL 进行点云及直线的显示（同时使用两个着色器）； 2：可以实现串口的自动识别及操作； 3：雷达图像的显示（可以实现点云数据及点云距离的同比例缩放及显示）； 4：在OpenGL显示部分，相机矩阵与代码中设置的一个矩阵进行相乘，将点云放置在 x-y 平面进行显示。 3：附加一个功能是 实现共用变量的上锁。
QT-opengl实现点云读取和显示
热门推荐
御伽草子的博客
09-13 2万+
先说一件小事——自己被上了一课。 今天被外面的人委托做一个点云拼接，用到pcl库，拼接的效果奇差，无论怎么修改参数都不行。 然后人家发给我一块完整的点云给我看。 我气不打一处来，说这块点云一定是扫描出来的，不是拼接的。 人家立刻就说，这实际上是用空间特征进行配准做出来的。 我变得哑口无言——我太自大了，我以为自己弄不出的东西别人也弄不出。 也许我被这种自大的心态蒙蔽了很久，但是我不想就
qt编写的点云显示工具可拖动缩放旋转
12-21
点云显示工具是计算机图形学领域中用于呈现三维数据的重要应用。在本项目中，"qt编写的点云显示工具可拖动缩放旋转"利用了Qt库的强大功能，特别是其QGLWidget组件，来创建一个用户交互式的3D点云查看器。QGLWidget是...
Qt3D显示点云，支持选中交互
03-27
要在Qt3D中显示点云，我们需要创建一个自定义实体，该实体包含表示每个点的几何形状（例如，QSphereGeometry）。每个点都可以用一个单独的球体表示，通过调整其半径来达到点的效果。同时，我们可以为这些球体分配...
OpenGL实现三维点云显示，鼠标控制
06-08
利用OpenGL实现了三维点云的显示，添加了鼠标控制事件，可以用鼠标对三维点云模型进行移动、缩放等功能。很不错的源代码，本代码运行环境是VS2010，需要添加OpenGL的配置。很不错的源代码分享给大家。
openGL实现三维点云显示
03-18
opengl实现三维点云的显示，放大，缩小，旋转，多角度浏览等功能。
QT显示LAS激光点云文件
05-05
qt显示LAS文件，用opengl实现旋转平移缩放，有显示界面，QT+OPENGL基本框架，可直接使用。
QtOpenGLWidget:一个基本的小部件，带有一些按钮和鼠标事件，用于控制Qt中的QGLWidget
04-29
QtOpenGLWidget QtOpenGLWidget提供了一个启动项目，用于进一步开发使用QGLWidget的应用程序，QGLWidget是允许使用OpenGL的Qt框架的一部分。 我将其用于我的地形生成器应用程序（当前正在开发中）。 我决定将已实现的OpenGL小部件的基本功能分开，以便其他人可以使用它，而不会剩下我的应用程序的其他开销。 该项目具有以下功能： OpenGL整合 OpenGL场景内的基本导航，结合使用Qt鼠标事件进行旋转，平移和缩放 使用按钮和组合框在小部件外部进行基本导航和控制 您可以编辑项目文件以构建共享库或应用程序。 结构非常简单。 有两个小部件，第一个被嵌入到第二个中： OpenGLContainer直接从QGLWidget和QGLFunctions继承（第二个是可选的，尽管如果不使用，则将极大地限制于您可以创建和显示的OpenGL）。 该组件是
2017-10-27 在以前的代码中加入了opengl ES2.0显示点云的功能，代码毫无保留的分享给大家
10-27
在OpenGL ES 2.0中显示点云，我们需要编写顶点着色器和片段着色器。顶点着色器处理每个输入点，确定其在屏幕上的位置，而片段着色器则决定每个像素的颜色。在实际应用中，可能还需要进行坐标变换、视口投影等操作。 ...
win下使用QT添加VTK插件实现点云可视化GUI
点云PCL
04-07 2530
摘要​ 大家在做点云的时候经常会用到QT，但是我们需要使用QT做点云的可视化的时候又需要VTK，虽然我们在windows下安装PCL的时候就已经安装了VTK，由于跟着PCL安装的VTK是没有和QT联合编译的，所以在使用PCL和QT做点云可视化界面的时候是无法使用可是QT的插件QVTKWidget，本文将主要讲解一些PCL在Ubuntu系统和windows使用QT做界面的一些分享。 ubuntu 中...
QT点云显示--基于QOpenGLWidget和QOpenGLFunctions实现
Jason的技术探索与分享
12-13 1万+
1、网格显示2、坐标轴显示3、鼠标操作旋转、平移、缩放4、点云显示
基于QGLViewer实现的点云显示、框选（实例）
御伽草子的博客
08-19 4694
生活中处处面临着狗血的选择，如果你是个很吸引人的青年，你会发现身边有很多选择，但做出选择往往是很难的。         而且大家有时候只能看,不能选，因为不会选，选错了你就完蛋了。         如果这时候你会选了，选对了，就不用一个人过节了。         好，那么今天讲一下究竟怎么选，怎么选才能得到你想要的。         （大家准备好鸡蛋）         其实点云的选择问题并不难。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

给算法爸爸上香

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值