CloudCompare3D显示库集成

已于 2022-05-17 11:07:08 修改
阅读量506 收藏 7
点赞数
文章标签： 3d qt c++
于 2021-06-08 15:18:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littleleafboy/article/details/117703691
版权

1、下载CC源码，下载CCoreLib源码，一起编译，生成以下4个库，拷贝对应的lib、dll、h文件备用

QCC_GL_LIB、QCC_DB_LIB、CCCoreLib、CC_FBO_LIB

2、工程定义宏

CC_CORE_LIB_USES_FLOAT
CC_CORE_LIB_USES_QT_CONCURRENT
NOMINMAX
WIN32_LEAN_AND_MEAN
_CRT_SECURE_NO_WARNINGS
__STDC_LIMIT_MACROS

3、工程链接以上4个lib

4、源代码

#ifndef SIMPLEGLWIDGET_H
#define SIMPLEGLWIDGET_H

#include <QWidget>
#include <ccHObject.h>

#include <QTimer>

#include <sptreader.hpp>
#include <gradcolor.hpp>
#include "datareader.h"
#include "VelodyneHdl.hpp"

class ccGLWindow;

namespace Ui {
class SimpleGlWidget;
}

class SimpleGlWidget : public QWidget
{
    Q_OBJECT

public:
    SimpleGlWidget(QWidget *parent = nullptr);
    ~SimpleGlWidget();

public:

    void addToDB(ccHObject* entity);

    void updateTrans(ccHObject* obj, CCVector3 povit, CCVector3 rot, CCVector3 pos);

    void OnTimerTick();

    void Demo(std::vector<ldrcali>& v);

    void onCaliChange();
signals  :
    void ManualUpdate();
public:

    //! Associated GL context
    ccGLWindow* m_glWindow;

    ccHObject* pRoot;
    ccHObject* pCloud;
    ccHObject* pCone;
    ccHObject* pTrack;

    QTimer updateTimer;

    CCVector3d global_offset;

    std::map<char, ccColor::Rgb> _color;

    velodyne::HDL::HDLDecoder _dec;

private:
    Ui::SimpleGlWidget *ui;
};

#endif // SIMPLEGLWIDGET_H

#include "simpleglwidget.h"
#include "ui_simpleglwidget.h"

#include <ccHObjectCaster.h>
#include <ccPointCloud.h>
#include <ccPlane.h>
#include <ccCone.h>

#include <ccGLWidget.h>
#include <QVBoxLayout>
#include <QDebug>

SimpleGlWidget::SimpleGlWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::SimpleGlWidget)
{
    ui->setupUi(this);

    //insert GL window in a vertical layout

    {
        QVBoxLayout* verticalLayout = new QVBoxLayout(ui->GLframe);
        verticalLayout->setSpacing(0);
        const int margin = 10;
        verticalLayout->setContentsMargins(margin, margin, margin, margin);

        bool stereoMode = QSurfaceFormat::defaultFormat().stereo();

        QWidget* glWidget = nullptr;
        CreateGLWindow(m_glWindow, glWidget, stereoMode);
        //assert(m_glWindow && glWidget);

        verticalLayout->addWidget(glWidget);
        pRoot = new ccHObject("root");

        pCloud = ccHObject::New(CC_TYPES::POINT_CLOUD, "PointCloud");
        pCone = ccHObject::New(CC_TYPES::CONE, "Camera1");
        pTrack = ccHObject::New(CC_TYPES::POINT_CLOUD, "Track");

        pRoot->addChild(pCloud);
        pRoot->addChild(pCone);
        pRoot->addChild(pTrack);
    }

    gradcolor gradd;
    gradd.calc();
    for (int var = 0; var < 255; ++var) {
        _color.insert(std::make_pair(var, ccColor::Rgb(
                                         gradd.grad[var].r,
                                         gradd.grad[var].g,
                                         gradd.grad[var].b)));
    }

    connect(&updateTimer, &QTimer::timeout, this, &SimpleGlWidget::OnTimerTick);
    connect(ui->pushButton, &QPushButton::clicked, this, [&](){
        _dec.nextframe();
    });

    /*
    connect(ui->doubleSpinBox, &QDoubleSpinBox::valueChanged, this, [&](double dv){
        _dec.nextframe();
    });
    */

    connect(ui->doubleSpinBox, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),
            this, [&](double v){ onCaliChange(); });
    connect(ui->doubleSpinBox_2, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),
            this, [&](double v){ onCaliChange(); });
    connect(ui->doubleSpinBox_3, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),
            this, [&](double v){ onCaliChange(); });
    connect(ui->doubleSpinBox_4, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),
            this, [&](double v){ onCaliChange(); });
    connect(ui->doubleSpinBox_5, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),
            this, [&](double v){ onCaliChange(); });
    connect(ui->doubleSpinBox_6, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),
            this, [&](double v){ onCaliChange(); });

    connect(ui->pushButton_2, &QPushButton::clicked, this, [&](){ m_glWindow->setView(CC_VIEW_ORIENTATION::CC_TOP_VIEW); });
    connect(ui->pushButton_3, &QPushButton::clicked, this, [&](){ m_glWindow->setView(CC_VIEW_ORIENTATION::CC_FRONT_VIEW); });
    connect(ui->pushButton_4, &QPushButton::clicked, this, [&](){ m_glWindow->setView(CC_VIEW_ORIENTATION::CC_RIGHT_VIEW); });

    connect(this, &SimpleGlWidget::ManualUpdate, this, [&]{        
        m_glWindow->redraw(true, false);
    });

    updateTimer.setInterval(100);
    updateTimer.start();
    std::thread* pThread = new std::thread([&](){


        _dec.init();

        CCVector3 xyz;
        ccPointCloud* cloud = ccHObjectCaster::ToPointCloud(pTrack);
        cloud->reset();

        global_offset.x = _dec.posVec[0].e;
        global_offset.y = _dec.posVec[0].n;
        global_offset.z = _dec.posVec[0].u;

        for (unsigned int i = 0; i < _dec.posVec.size(); ++ i){

            xyz.x = _dec.posVec[i].e - global_offset.x;
            xyz.y = _dec.posVec[i].n - global_offset.y;
            xyz.z = _dec.posVec[i].u - global_offset.z;

            cloud->addPoint(xyz);
        }

        /*
        if (cloud->resizeTheRGBTable(true)){

            for (unsigned int i = 0; i < cloud->size(); ++ i){

                ccColor::Rgb rgb = ccColor::Rgb(0,255,0);
                cloud->setPointColor(i, rgb);
            }
        }
        */
        cloud->setColor(ccColor::red);
        cloud->showColors(true);


        _dec.callback = [&](std::vector<ldrcali>& v1){
            Demo(v1);
            emit ManualUpdate();
        };

        std::vector<std::string> pcaps;
        pcaps.push_back("D:/testdir/pcap/K01/10011105180318133056.pcap");
        //pcaps.push_back("D:/testdir/pcap/K01/10011105180318133756.pcap");
        _dec.singleresolve(pcaps);
    });
    pThread->detach();
}


SimpleGlWidget::~SimpleGlWidget()
{
    delete ui;
}

void SimpleGlWidget::onCaliChange(){
    static std::chrono::steady_clock::time_point tmstart = std::chrono::steady_clock::now();
    static std::chrono::duration<double, std::milli> elapsed = std::chrono::steady_clock::now() - tmstart;

    elapsed = std::chrono::steady_clock::now() - tmstart;
    if (elapsed.count() < 50)
        return;

    tmstart = std::chrono::steady_clock::now();

    double pr[] = { ui->doubleSpinBox->value(),ui->doubleSpinBox_2->value(),ui->doubleSpinBox_3->value()};
    double pt[] = { ui->doubleSpinBox_4->value(),ui->doubleSpinBox_5->value(),ui->doubleSpinBox_6->value()};
    _dec.update_cali(pr, pt);
}

void SimpleGlWidget::OnTimerTick(){
    //m_glWindow->redraw(true, false);
}

void SimpleGlWidget::Demo(std::vector<ldrcali>& v){

    ccCone* cone = ccHObjectCaster::ToCone(pCone);
    cone->setDrawingPrecision(4);
    cone->setHeight(10);
    cone->setBottomRadius(3);
    cone->setTopRadius(0);
    cone->setTempColor(ccColor::red);

    ccPointCloud* cloud = ccHObjectCaster::ToPointCloud(pCloud);    
    if (true){
        cloud->reset();

        CCVector3 xyz, org;
        for (unsigned int i = 0; i < v.size(); ++ i){

            xyz.x = v[i].enu[0] - global_offset.x;
            xyz.y = v[i].enu[1] - global_offset.y;
            xyz.z = v[i].enu[2] - global_offset.z;
            cloud->addPoint(xyz);
        }
    }

    if (cloud->resizeTheRGBTable()){

#pragma omp parallel for
        for (int i = 0; i < cloud->size(); ++ i){
            cloud->setPointColor(i, _color[v[i].intensity]);
        }
    }

    //cloud->setTempColor(ccColor::green);
    cloud->showColors(true);

    static int nxx = 0;
    if (nxx == 0){
        nxx = 1;
        addToDB(pRoot);
    }

    //CCVector3 Cd = {0, 0, 0};
    //updateTrans(pCone, cone->getTopCenter(), CCVector3(-90,45,0), Cd);
}

void SimpleGlWidget::addToDB(ccHObject* entity)
{
    assert(entity && m_glWindow);

    entity->setDisplay_recursive(m_glWindow);

    ccHObject* currentRoot = m_glWindow->getSceneDB();
    if (currentRoot)
    {
        //already a pure 'root'
        if (currentRoot->isA(CC_TYPES::HIERARCHY_OBJECT))
        {
            currentRoot->addChild(entity);
        }
        else
        {
            ccHObject* root = new ccHObject("root");
            root->addChild(currentRoot);
            root->addChild(entity);
            m_glWindow->setSceneDB(root);
        }
    }
    else
    {
        m_glWindow->setSceneDB(entity);
    }
}

void SimpleGlWidget::updateTrans(ccHObject* obj, CCVector3 povit, CCVector3 r, CCVector3 t)
{
    if (!obj)
    {
        assert(false);
        return;
    }

    CCVector3 C = povit;

    //shall we transform (translate and / or rotate) the plane?
    ccGLMatrix trans;

    bool needToApplyRot = true;
    bool needToApplyTrans = true;

    if (needToApplyTrans)
    {
        trans.setTranslation(-C);
    }
    if (needToApplyRot)
    {
        static ccGLMatrix lastRot, rotation;
        static ccGLMatrix rotX, rotY, rotZ;
        static CCVector3 axis[3] = {CCVector3(1, 0, 0),CCVector3(0, 1, 0),CCVector3(0, 0, 1)};
        static CCVector3 t3D = CCVector3(0, 0, 0);

        rotX.initFromParameters( CCCoreLib::DegreesToRadians( r.x ), axis[0], t3D ); //plunge
        rotY.initFromParameters( CCCoreLib::DegreesToRadians( r.y ), axis[1], t3D ); //plunge
        rotZ.initFromParameters( CCCoreLib::DegreesToRadians( r.z ), axis[2], t3D ); //plunge

        rotation = rotZ * rotY * rotX;

        trans = lastRot.inverse() * rotation * trans;
        lastRot = rotation;
    }
    if (needToApplyTrans)
    {
        trans.setTranslation(trans.getTranslationAsVec3D() + t);
    }
    if (needToApplyRot || needToApplyTrans)
    {
        obj->applyGLTransformation_recursive(&trans);
    }
}

VelodyneHDL.hpp

#pragma once
#include "PacketDecoder.h"
#include "pcaploader.hpp"
#include "datatypes.hpp"
#include "datareader.h"

#include <iostream>

#include <QDir>
#include <QFileInfoList>
#include <QDebug>
#include <QMutex>

#include <Eigen/Dense>
#include <cmath>
#include <algorithm>
#include <omp.h>

#include <time.h>
#include <chrono>

namespace velodyne {
	namespace HDL {
		class HDLDecoder
		{
		public:
			HDLDecoder() {
				vlines = 32;
                memset(caliRot, 0, sizeof(double) * 3);
                memset(caliOffT, 0, sizeof(double) * 3);
				memset(veloxml, 0, sizeof(veloxml));

                caliRot[0] = -43.1128;
                caliRot[1] = 0.788177;
                caliRot[2] = 91.5099;

                caliOffT[0] = 0;
                caliOffT[1] = 0;
                caliOffT[2] = 0;

                /*
                qDebug() << omp_get_num_procs();
                qDebug() << "before get openMP max threads: " << omp_get_max_threads() << endl;
                qDebug() << "before set openMP threads: " << omp_get_num_threads() << endl;
                int set_thread = 10;
                omp_set_num_threads(8);
                qDebug() << "after set openMP threads: " << omp_get_num_threads() << endl;

                #pragma omp parallel
                {
                    qDebug() << "parallel:" << omp_get_thread_num() << endl;
                    #pragma omp for
                    for (int i = 0; i < 4 ; ++ i){
                        qDebug() << "Hello" << ", I am Thread " << omp_get_thread_num() << endl;
                    }
                }
                */

			}
            ~HDLDecoder(){

            }
		public:

            bool init(){
                datareader dr;
                dr.loadpos_v1("D:\\testdir\\pcap\\K01\\1001-1-105-180318.txt", posVec);
                if (posVec.size() < 10)
                    return false;
                return true;
            }

            void update_cali(double* r, double* t){

                std::chrono::steady_clock::time_point tmstart = std::chrono::steady_clock::now();



                for (int i = 0; i < 3; ++i) {
                    caliRot[i] = r[i];
                    caliOffT[i] = t[i];
                }

                Eigen::AngleAxisd rx_ldr,ry_ldr,rz_ldr;
                rx_ldr = Eigen::AngleAxisd(caliRot[0] / 180.0 * M_PI, Eigen::Vector3d::UnitX());
                ry_ldr = Eigen::AngleAxisd(caliRot[1] / 180.0 * M_PI, Eigen::Vector3d::UnitY());
                rz_ldr = Eigen::AngleAxisd(caliRot[2] / 180.0 * M_PI, Eigen::Vector3d::UnitZ());
                cali_R = rz_ldr * ry_ldr * rx_ldr;
                cali_T << caliOffT[0], caliOffT[1], caliOffT[2];

                #pragma omp parallel
                {
                    Eigen::AngleAxisd imuR;
                    Eigen::Vector3d imuT, ldrT, lasT, Axis;

                    #pragma omp for
                    for (int i = 0; i < ldrcalivec.size(); i++) {

                        Axis <<ldrcalivec[i].angleaxis[0],ldrcalivec[i].angleaxis[1],ldrcalivec[i].angleaxis[2];
                        imuR = Eigen::AngleAxisd(ldrcalivec[i].angleaxis[3], Axis);

                        imuT << ldrcalivec[i].imupos[0], ldrcalivec[i].imupos[1], ldrcalivec[i].imupos[2];
                        ldrT << ldrcalivec[i].xyz[0], ldrcalivec[i].xyz[1], ldrcalivec[i].xyz[2];

                        lasT = imuR * (cali_R.inverse() * ldrT + cali_T) + imuT;

                        ldrcalivec[i].enu[0] = lasT[0];
                        ldrcalivec[i].enu[1] = lasT[1];
                        ldrcalivec[i].enu[2] = lasT[2];

                        //std::cout << "Hello" << ", I am Thread " << omp_get_thread_num() << std::endl;
                    }
                }
                std::chrono::duration<double, std::milli> elapsed = std::chrono::steady_clock::now() - tmstart;

                char psz[521] = "";
                sprintf(psz, "(%s) time span %.3f/s", "calc cost", elapsed.count() * 0.001);
                qDebug() << QString::fromLocal8Bit(psz);

                tmstart = std::chrono::steady_clock::now();
                qDebug() << ldrcalivec.size();
                if (callback != nullptr)
                    callback(ldrcalivec);
                elapsed = std::chrono::steady_clock::now() - tmstart;
                sprintf(psz, "(%s) time span %.3f/s", "show cost", elapsed.count() * 0.001);
                qDebug() << QString::fromLocal8Bit(psz);
            }

            void nextframe(){
                waitlock = false;
            }

            bool singleresolve(std::vector<std::string> pszpcap) {

                int packets = 0, points = 0;
                double lasttime = 0, currenttime = 0;
				try
                {
					//包数据长度
					int dataLength = 0;

					//用于获取Velodyne 554包内激光时间
					char pszgprmc[256] = "";
					char pszhour[4] = "";
					int ngprmchour = -1;

					//PacketDecoder 参数
					std::deque<PacketDecoder::HDLFrame> frames;
					PacketDecoder::HDLFrame latest_frame;                    

                    //临时点
                    ldrcali _xyzcali;
                    PosTrack ppt;

                    Eigen::AngleAxisd rx,ry,rz,R;
                    Eigen::Vector3d ldrT, imuT, lasT;

					//解析包
					PacketDecoder pd;
					pd.velolines = vlines;
					pd.SetCorrectionsFile(veloxml);
                    pd.SetMaxNumberOfFrames(100);

                    for (int pcapid = 0; pcapid < pszpcap.size(); ++ pcapid){
                        pcaploader::pcappackets(pszpcap[pcapid].c_str(), [&](const unsigned char* p, unsigned int* n) {

                            if (*n == 1248 && ngprmchour >= 0) {

                                packets ++ ;
                                dataLength = 1206;
                                pd.DecodePacket((const char*)p + 42, &dataLength);

                                frames = pd.GetFrames();
                                if (/*pd.GetLatestFrame(&latest_frame)*/frames.size() > 0) {

                                    while (!frames.empty()) {
                                        latest_frame = frames.front();
                                        frames.pop_front();
                                        for (size_t i = 0; i < latest_frame.x.size(); i+=1)
                                        {
                                            points++;
                                            if (latest_frame.laser_id[i] == 15 && latest_frame.distance[i] > 0 && latest_frame.distance[i] < 110) {

                                                if (latest_frame.intensity[i] < 4)
                                                    continue;
                                                currenttime = ngprmchour * 3600 + 18 + latest_frame.ms_from_top_of_hour[i] * 1e-6;

                                                ppt.wsec = currenttime;
                                                long long idx = std::lower_bound(posVec.begin(), posVec.end(), ppt, [](const PosTrack& v1, const PosTrack& v2){
                                                    return v1.wsec <= v2.wsec;
                                                }) - posVec.begin();
                                                idx = (idx - 1) >= 0 ? (idx - 1) : 0;

                                                rx = Eigen::AngleAxisd(posVec[idx].p / 180.0 * M_PI, Eigen::Vector3d::UnitX());
                                                ry = Eigen::AngleAxisd(posVec[idx].r / 180.0 * M_PI, Eigen::Vector3d::UnitY());
                                                rz = Eigen::AngleAxisd(-posVec[idx].y / 180.0 * M_PI, Eigen::Vector3d::UnitZ());
                                                R = rz * rx * ry;

                                                _xyzcali.xyz[0] = latest_frame.x[i];
                                                _xyzcali.xyz[1] = latest_frame.y[i];
                                                _xyzcali.xyz[2] = latest_frame.z[i];
                                                _xyzcali.angleaxis[0] = R.axis()[0];
                                                _xyzcali.angleaxis[1] = R.axis()[1];
                                                _xyzcali.angleaxis[2] = R.axis()[2];
                                                _xyzcali.angleaxis[3] = R.angle();
                                                _xyzcali.imupos[0] = posVec[idx].e;
                                                _xyzcali.imupos[1] = posVec[idx].n;
                                                _xyzcali.imupos[2] = posVec[idx].u;
                                                _xyzcali.intensity = (latest_frame.intensity[i] * 2) % 255;
                                                _xyzcali.srcid = latest_frame.laser_id[i];
                                                ldrcalivec.emplace_back(std::move(_xyzcali));
                                            }
                                        }
                                        /*
                                        if ((currenttime - lasttime) > 18){
                                            if (lasttime > 1){
                                                update_cali(caliRot, caliOffT);

                                                waitlock = true;
                                                while (waitlock) {
                                                    Sleep(300);
                                                }

                                                ldrcalivec.clear();
                                                qDebug() << "ldrcalivec.clear()";
                                            }
                                            lasttime = currenttime;
                                        }
                                        */
                                    }

                                    pd.ClearFrames();
                                }
                                //pd.ClearFrames();
                            }
                            else if (*n == 554) {
                                memcpy(pszhour, p + 248 + 7, 2);
                                ngprmchour = atoi(pszhour);
                            }
                        });
                    }

                    update_cali(caliRot, caliOffT);
					return true;
				}
				catch (const std::exception&)
				{

				}				

				return false;
			}

        public:

            //点序列
            std::vector<ldrcali> ldrcalivec;

            std::function<void(std::vector<ldrcali>&)> callback;

            Eigen::AngleAxisd   cali_R;
            Eigen::Vector3d     cali_T;

            double caliRot[3];
            double caliOffT[3];

        public:
            std::vector<PosTrack> posVec;

		private:

			int vlines;
			char veloxml[MAX_PATH];

            bool waitlock;
		};
	}
}

丶看我会发光
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CloudCompare中CCCoreLib模块介绍
Z's Palace
06-10 63
是一个3D点云（和三角化网格）处理软件，它最初设计用于在两个3D点云之间（例如通过激光扫描仪获得的点云）或点云和三角化网格之间进行对比，它依赖于一个八叉树结构，该结构针对这个特定用例进行了高度优化，它还用于处理超大的点云（通常超过1000万个点，使用2GB内存最多可达1.2亿个点）。其核心的算法库CCLib库，这个库提供用于处理三维点云数据的数据结构和算法。它是存储库的一部分（称为“CCLib”），也就是源码中CC文件下的内容。
智慧城市与三维重建
wwh的博客
10-17 935
智慧城市与数字孪生，基于深度学习的多目三维重建，点云预处理，表面重建。
CloudCompare源码分析_显示渲染的程序架构
tanmx219的博客
06-17 2424
这一讲介绍一下CloudCompare的大致绘制流程或者说绘图框架的结构。根据前面一篇对CloudCompare读取PLY文件的介绍 ，很容易找出当cloudcompare读取到mesh文件（newGroup）后，会把这个文件通过addDB加载到根对象下面， 这个根对象，就是ccDBRoot， 其内部定义了一个ccHObject的指针，m_treeRoot，最终用来容纳子对像 当然，这些都不是重点。重点是：CloudCompare是如何完成3D渲染的，相关的OpenGL函数，或者是Qt的Open
cloudcompare 下载.zip
06-16
显示三维点云，支持多种格式文件的选择，本软件支持在windows下运行。支持格式pcd、asc、bin、csv等多种格式
点云显示工具
如有侵权，请联系作者删除
10-07 6336
（速腾聚创）附带的上位机软件进行显示，这些工业软件支持显示的格式挺多的，如果只是简单的显示，上述这些工具完全可以满足需要。点云，就需要用到一些程序模块。因为博主编程主要使用的是Python处理点云数据，所以这里总结了一些。现在只是介绍了点云显示的工具有哪些，后续会补全这些工具的用法。当然，如果我们自己编程处理点云数据，然后在程序中直接显示。除了上面描述的常用专业显示软件，我们也可以使用。用于显示3D点云的软件有很多，比如最常用的。当然，还有一些常用的专业显示工具，比如。系统话，其实也可以使用。
cloudCompare插件开发——保存点云颜色
农夫的博客
08-13 1807
一. 插件介绍 该插件用于保存用户选中的点云实体，导出为txt文件，仅记录点云的坐标以及颜色。 二. 主要代码 1. 获取点云对象 //获取选中的点云对象 ccHObject::Container container = m_app->getSelectedEntities(); ccHObject *entity= container[0]; if (!entity || !entity->isA(CC_TYPES::POINT_CLOUD)) { m_app->dispToC
QT6+CloudCompare显示3D点云
04-27
CloudCompare是一个三维点云（网格）编辑和处理软件。最初，它被设计用来对稠密的三维点云进行直接比较。它依赖于一种特定的八叉树结构，在进行点云对比这类任务时具有出色的性能。此外，由于大多数点云都是由地面...
3D点云CloudCompare工具
02-23
3D点云CloudCompare工具是一款专业且功能强大的三维点云数据处理软件，广泛应用于地质、建筑、测绘等领域。它能够帮助用户对大量的3D点云数据进行高效的分析、比较、编辑以及可视化操作。 CloudCompare的核心功能...
CloudCompare点云可视化软件
04-07
CloudCompare的核心功能就是处理和显示这些点云数据，提供精确的测量、比较、编辑和分析功能。 1. **界面与操作**：CloudCompare具有简洁的用户界面，打开`CloudCompare.exe`后，用户可以导入点云文件，如`.xyz`、`...
cloudcompare.2.11.3
03-27
CloudCompare是一款功能强大的3D点云处理软件，主要用于三维数据的比较、编辑、分析和可视化。版本号2.11.3表示这是该软件的一个稳定更新版本，可能包含了一些性能优化、新功能添加或者错误修复。 CloudCompare的...
CloudCompareStereo_v2.12.alpha_setup_x64.exe
03-26
CloudCompare win安装包 2.12
三维点云显示
01-24
三维点云显示，三维点云显示，数据转换 三维点云显示，三维点云显示，数据转换
cloudcompare汉化包
01-04
cloudcompare的汉化包，需要的可以自己下载。需说明的一点是，上传的是QLinguist的ts文件，不是发布版的qm文件，里面是部分翻译，下载后可以打开QLinguist自己翻译，然后发布即可。另一点需说明的是，cloudcompare只能从命令行加载其他语言的，启动命令CloudCompare.exe -lang tr/translation_chinese.qm，其中translation_chinese是翻译好的文件的发布版
三维点云（PointCloud）处理软件CloudCompare.zip
07-19
CloudCompare是一款三维点云（Point Cloud）处理软件，可以方便地使用计算法向量、优化法向量、泊松构网、滤波等功能。 标签：CloudCompare
CloudCompare用户手册及功能概要
09-18
本资源中的压缩文件包含CloudCompare开源软件的用户手册和功能概要，菜单功能说明等，适用于CloudCompare的初级用户。
CloudCompare中文
04-09
将文件夹【hpu】和文件【CloudCompare-Chinese.exe】复制到Cloudcompare安装根目录,如【D:\Program Files\CloudCompare】 双击CloudCompare-Chinese.exe打开
CloudCompare中PLC插件开发介绍
最新发布
jiugeshao的专栏
03-25 1425
前面博客介绍了CloudCompare的配置，我们它提供了现成的功能强大的UI界面，且也有各种点云算法，所以对于软件工程开发人员，点云算法处理人员来说，这都是值得去参考和复用的。可参考ExamplePlugin工程，如下是将该dll的输出路径修改为CloudCompare编译生成的目录下的plugins文件夹里，方便进行调试。实现小功能：只保留到重心距离满足一定范围内的点云，其它点云被去除掉了。注意后面会用到cc2DLabel类，这个类是在QCC_DB_LIB，为了调试，需要更改它的工程路径，修改为。
2017-12-26 C++基础(class修饰词、static_cast)
u010320855的博客
12-26 595
C++中类定义时，class与className之间的修饰词的作用例如在CloudCompare源码中，有这样的定义：class QCC_DB_LIB_API ccBBox { ... };QCC_DB_LIB_API这个宏定义可以起到 注释的作用。 编译器的拓展，比如： class _declspec(dllexport) A { ... };这里class A{};是指定义一个类

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值