osgEarth中绘制单箭头

已于 2025-03-19 10:07:22 修改
阅读量117 收藏
点赞数 3
分类专栏： osgEarth 文章标签： c++ qt5
于 2025-03-19 09:43:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43183044/article/details/146361020
版权

osgEarth3.2+qt5.14+osg3.6.5

#ifndef STRAIGHTARROWDRAWER_H
#define STRAIGHTARROWDRAWER_H

#include <osgEarth/MapNode>
#include <osgEarth/Geometry>
#include <osgEarth/GeoMath>
#include <osgEarth/Style>
#include<osgEarth/Feature>
#include<osgEarth/FeatureNode>

#include<osg/Vec2>
#include <osgViewer/Viewer>
#include <osgGA/GUIEventHandler>

class StraightArrowDrawer:public osgGA::GUIEventHandler
{
public:
    StraightArrowDrawer(osg::ref_ptr<osgEarth::MapNode> mapNode);
    ~StraightArrowDrawer();

    void beginDraw(const osg::Vec3d& lla);
    void moveDraw(const osg::Vec3d& lla);
    void endDraw(const osg::Vec3d& lla);
    void resetDraw();

    //删除选中的多边形
    void removeSelectStraightArrow(osg::ref_ptr<osg::Node> node);

    //删除最后创建的多边形
    void removeStraightArrow();

    //删除所以多边形
    void removeAllStraightArrows();

    void setIsDrawStraightArrow(bool isDrawStraightArrow);


   // 只有两个控制点时
    std::vector<osg::Vec2> calculateTwoPoints(const std::vector<osg::Vec2>& ctrlPts);
    //有三个或三个以上的控制点时
    std::vector<osg::Vec2> calculateMorePoints(const std::vector<osg::Vec2>& ctrlPts);

    //事件处理
    bool handle(const osgGA::GUIEventAdapter &ea,osgGA::GUIActionAdapter &aa);
private:
    osg::ref_ptr<osgEarth::MapNode> _mapNode;
    osg::NodePath   nodePaths;
    osgEarth::Style _straightArrowStyle;
    bool _isDrawStraightArrow=false;
    osg::ref_ptr<osgEarth::FeatureNode> _straightArrowFeatureNode;
    float _ratio;
    std::vector<osg::Vec2> _controlPoints; // 存储点击的点
    std::vector<osg::Vec2> _drawParts;     //存储绘制点

    std::vector<osg::ref_ptr<osgEarth::FeatureNode>> _straightArrowNodes; // 保存所有绘制直箭头
};

#endif // STRAIGHTARROWDRAWER_H



#include "StraightArrowDrawer.h"
#include"DrawerMath.h"
#include<QDebug>
StraightArrowDrawer::StraightArrowDrawer(osg::ref_ptr<osgEarth::MapNode> mapNode)
    :_mapNode(mapNode)
    ,_straightArrowFeatureNode(nullptr)
    ,_ratio(6.0)
    ,_isDrawStraightArrow(false)
{
    nodePaths.push_back(_mapNode);
    _straightArrowStyle.getOrCreate<osgEarth::PolygonSymbol>()->fill()->color()= osgEarth::Color(osgEarth::Color::Yellow, 0.45);  // RGBA 方式

    osgEarth::LineSymbol* ls = _straightArrowStyle.getOrCreate<osgEarth::LineSymbol>();
    ls->stroke()->color() = osgEarth::Color::Yellow;
    ls->stroke()->width() = 2.0f;
    ls->stroke()->widthUnits() = osgEarth::Units::PIXELS;

    _straightArrowStyle.getOrCreate<osgEarth::AltitudeSymbol>()->clamping()= osgEarth::AltitudeSymbol::CLAMP_ABSOLUTE;
    _straightArrowStyle.getOrCreate<osgEarth::AltitudeSymbol>()->technique()= osgEarth::AltitudeSymbol::TECHNIQUE_GPU;
    _straightArrowStyle.getOrCreate<osgEarth::AltitudeSymbol>()->verticalOffset()= 0.1;
}
StraightArrowDrawer::~StraightArrowDrawer()
{

}
void StraightArrowDrawer::beginDraw(const osg::Vec3d &lla)
{
    _controlPoints.push_back(osg::Vec2(lla.x(), lla.y()));
    if (_controlPoints.empty() || _controlPoints.size() < 2)
        return;
    if (_controlPoints.size() == 2 && _controlPoints[0]==_controlPoints[1])
        return;
     _drawParts.clear();
     if (_controlPoints.size() == 2)
         _drawParts = calculateTwoPoints(_controlPoints);
     else
         _drawParts = calculateMorePoints(_controlPoints);

     if (_straightArrowFeatureNode==nullptr) {
        osgEarth::Feature* feature = new osgEarth::Feature(new osgEarth::Polygon, osgEarth::SpatialReference::get("wgs84"),_straightArrowStyle);
        _straightArrowFeatureNode = new osgEarth::FeatureNode(feature,_straightArrowStyle);
        _mapNode->addChild(_straightArrowFeatureNode);

     }
     _straightArrowFeatureNode->setName("StraightArrow");
     _straightArrowNodes.push_back(_straightArrowFeatureNode);
     osgEarth::Geometry* geom = _straightArrowFeatureNode->getFeature()->getGeometry();
     geom->clear();
     for (auto& n : _drawParts) {
         geom->push_back(osg::Vec3(n.x(), n.y(), 0));
     }
     _straightArrowFeatureNode->dirty();
}

void StraightArrowDrawer::moveDraw(const osg::Vec3d &lla)
{
    if (_controlPoints.empty())
           return;
       if (!_straightArrowFeatureNode.valid()) {
            osgEarth::Feature* feature = new osgEarth::Feature(new osgEarth::Polygon, osgEarth::SpatialReference::get("wgs84"), _straightArrowStyle);
           _straightArrowFeatureNode = new osgEarth::FeatureNode(feature,_straightArrowStyle);
           _mapNode->addChild(_straightArrowFeatureNode);
       }

       if (_straightArrowFeatureNode.valid()) {
           std::vector<osg::Vec2> ctrlPts = _controlPoints;
           std::vector<osg::Vec2> drawPts;
           ctrlPts.push_back(osg::Vec2(lla.x(), lla.y()));

           if (ctrlPts.size() == 2)
               drawPts = calculateTwoPoints(ctrlPts);
           else
               drawPts = calculateMorePoints(ctrlPts);

           osgEarth::Geometry* geom = _straightArrowFeatureNode->getFeature()->getGeometry();
           geom->clear();
           for (auto& n : drawPts) {
               geom->push_back(osg::Vec3(n.x(), n.y(), 0));
           }
           _straightArrowFeatureNode->dirty();
       }
}

void StraightArrowDrawer::endDraw(const osg::Vec3d &lla)
{

}

void StraightArrowDrawer::resetDraw()
{
    _controlPoints.clear();

    _straightArrowFeatureNode = NULL;
}

void StraightArrowDrawer::removeSelectStraightArrow(osg::ref_ptr<osg::Node> node)
{
    _mapNode->removeChild(node);
}

void StraightArrowDrawer::removeStraightArrow()
{
    if (!_straightArrowNodes.empty()) {
        osg::ref_ptr<osgEarth::FeatureNode> lastNode = _straightArrowNodes.back();
        _mapNode->removeChild(lastNode); // 从地图中移除
        _straightArrowNodes.pop_back();     // 从列表中移除
    }
}

void StraightArrowDrawer::removeAllStraightArrows()
{
    for (auto& node : _straightArrowNodes) {
       _mapNode->removeChild(node); // 从地图中移除
    }
    _straightArrowNodes.clear(); // 清空列表
}

void StraightArrowDrawer::setIsDrawStraightArrow(bool isDrawStraightArrow)
{
    _isDrawStraightArrow=isDrawStraightArrow;
}

std::vector<osg::Vec2> StraightArrowDrawer::calculateTwoPoints(const std::vector<osg::Vec2> &ctrlPts)
{
    //取出首尾两个点
        osg::Vec2 pointS = ctrlPts[0];
        osg::Vec2 pointE = ctrlPts[1];
        //计算箭头总长度
        float l = sqrtf((pointE.y()-pointS.y())*(pointE.y()-pointS.y())+(pointE.x()-pointS.x())*(pointE.x()-pointS.x()));
        //计算直箭头的宽
        float w = l/_ratio;

        //计算三角形的底边中心点坐标
        float x_ = pointS.x() + (pointE.x() - pointS.x())*(_ratio-1)/_ratio;
        float y_ = pointS.y() + (pointE.y() - pointS.y())*(_ratio-1)/_ratio;
        osg::Vec2 point_o(x_, y_);

        //计算
        std::vector<osg::Vec2> v_lr_ = DrawMath::calculateVector(osg::Vec2(pointE.x()-pointS.x(), pointE.y()-pointS.y()), osg::PI/2, w/2);
        //获取左边尾部向量
        osg::Vec2 v_l_ = v_lr_[0];
        //获取右边尾部向量
        osg::Vec2 v_r_ = v_lr_[1];
        //获取左边尾部点
        osg::Vec2 point_l(v_l_.x()+pointS.x(), v_l_.y()+pointS.y());
        //获取右边尾部点
        osg::Vec2 point_r(v_r_.x()+pointS.x(), v_r_.y()+pointS.y());

        osg::Vec2 point_h_l(v_l_.x()/_ratio+x_, v_l_.y()/_ratio+y_);
        osg::Vec2 point_h_r(v_r_.x()/_ratio+x_, v_r_.y()/_ratio+y_);

        //计算三角形左边点
        osg::Vec2 point_a_l((point_h_l.x()*2-point_h_r.x()), point_h_l.y()*2-point_h_r.y());
        //计算三角形右边点
        osg::Vec2 point_a_r(point_h_r.x()*2-point_h_l.x(), point_h_r.y()*2-point_h_l.y());
        return std::vector<osg::Vec2>{point_l,point_h_l,point_a_l,pointE,point_a_r,point_h_r,point_r};
}

std::vector<osg::Vec2> StraightArrowDrawer::calculateMorePoints(const std::vector<osg::Vec2> &ctrlPts)
{
    //计算箭头总长度
       float l = 0;
       //计算直箭头的宽
       float w = 0;
       for (int i = 0; i < ctrlPts.size()-1; i++) {
           //取出首尾两个点
           osg::Vec2 pointS = ctrlPts[i];
           osg::Vec2 pointE = ctrlPts[i+1];
           l += sqrtf((pointE.y()-pointS.y())*(pointE.y()-pointS.y())+(pointE.x()-pointS.x())*(pointE.x()-pointS.x()));
       }
       w = l/_ratio;
       float a = atanf(w/(2.0*l));

       //定义左右控制点集合
       std::vector<osg::Vec2> points_C_l;
       std::vector<osg::Vec2> points_C_r;
       //定义尾部左右的起始点
       osg::Vec2 point_t_l;
       osg::Vec2 point_t_r;

       //计算中间的所有交点
       for (int j=0; j < ctrlPts.size()-2; j++) {
           osg::Vec2 pointU_1 = ctrlPts[j]; //第一个用户传入的点
           osg::Vec2 pointU_2 = ctrlPts[j+1]; //第二个用户传入的点
           osg::Vec2 pointU_3 = ctrlPts[j+2]; //第三个用户传入的点

           //计算向量
           osg::Vec2 v_U_1_2(pointU_2.x()-pointU_1.x(), pointU_2.y()-pointU_1.y());
           osg::Vec2 v_U_2_3(pointU_3.x()-pointU_2.x(), pointU_3.y()-pointU_2.y());

           //定义左边第一个控制点
           osg::Vec2 point_l_1;
           //定义右边第一个控制点
           osg::Vec2 point_r_1;
           //如果j=0时，左右第一个控制点需要计算
           if (j == 0) {
               std::vector<osg::Vec2> v_lr_= DrawMath::calculateVector(v_U_1_2, osg::PI_2, w/2);
               //获取左边尾部点
               osg::Vec2 v_l_ = v_lr_[0];
               //获取右边尾部点
               osg::Vec2 v_r_ = v_lr_[1];
               //获取左边尾部点
               point_t_l = point_l_1 = osg::Vec2(v_l_.x()+pointU_1.x(), v_l_.y()+pointU_1.y());
               //获取右边尾部点
               point_t_r = point_r_1 = osg::Vec2(v_r_.x()+pointU_1.x(), v_r_.y()+pointU_1.y());
           } else { //否则获取上一次的记录
               point_l_1 = points_C_l[points_C_l.size()-1];
               point_r_1 = points_C_r[points_C_r.size()-1];
           }

           std::vector<osg::Vec2> v_lr = DrawMath::calculateVector(v_U_1_2, a, 1);
           //这里的向量需要反过来
           //获取左边向量
           osg::Vec2 v_l = v_lr[1];
           //获取右边向量
           osg::Vec2 v_r = v_lr[0];
           //定义角平分线向量
           osg::Vec2 v_angularBisector = DrawMath::calculateAngularBisector(osg::Vec2(-v_U_1_2.x(), -v_U_1_2.y()), v_U_2_3);
           //求交点
           //计算左边第二个控制点
           osg::Vec2 point_l_2 = DrawMath::calculateIntersection(v_l, v_angularBisector, point_l_1, pointU_2);
           osg::Vec2 point_r_2 = DrawMath::calculateIntersection(v_r, v_angularBisector, point_r_1, pointU_2);

           //添加后面的拐角控制点
           points_C_l.push_back(osg::Vec2((point_l_1.x()+point_l_2.x())/2, (point_l_1.y()+point_l_2.y())/2));
           points_C_l.push_back(point_l_2);
           points_C_r.push_back(osg::Vec2((point_r_1.x()+point_r_2.x())/2, (point_r_1.y()+point_r_2.y())/2));
           points_C_r.push_back(point_r_2);
       }
       //进入计算头部
       //计算一下头部的长度
       osg::Vec2 pointU_E2 = ctrlPts[ctrlPts.size()-2];//倒数第二个用户点
       osg::Vec2 pointU_E1 = ctrlPts[ctrlPts.size()-1];//最后一个用户点
       float head_d = sqrtf((pointU_E2.x()-pointU_E1.x())*(pointU_E2.x()-pointU_E1.x()) + (pointU_E2.y()-pointU_E1.y())*(pointU_E2.y()-pointU_E1.y()));
       //定义头部的左右两结束点
       osg::Vec2 point_h_l, point_h_r;
       //三角形左右两点数组
       std::vector<osg::Vec2> point_lr_t;
       //定义曲线最后一个控制点，也就是头部结束点和最后一个拐角点的中点
       osg::Vec2 point_C_l_e, point_C_r_e;
       //定义三角形的左右两个点
       osg::Vec2 point_triangle_l, point_triangle_r;

       //获取当前的最后的控制点，也就是之前计算的拐角点
       osg::Vec2 point_C_l_eq = points_C_l[points_C_l.size()-1];
       osg::Vec2 point_C_r_eq = points_C_r[points_C_r.size()-1];
       //申明三角形的两边向量
       osg::Vec2 v_l_t, v_r_t;
       //三角的高度都不够
       if (head_d <= w) {
           point_lr_t = DrawMath::calculateVector(osg::Vec2(pointU_E1.x()-pointU_E2.x(), pointU_E1.y()-pointU_E2.y()), osg::PI_2, w/2);
           //获取三角形左右两个向量
           v_l_t = point_lr_t[0];
           v_r_t = point_lr_t[1];
           point_h_l = osg::Vec2(v_l_t.x()/_ratio+pointU_E2.x(), v_l_t.y()/_ratio+pointU_E2.y());
           point_h_r = osg::Vec2(v_r_t.x()/_ratio+pointU_E2.x(), v_r_t.y()/_ratio+pointU_E2.y());
           //计算三角形的左右两点
           point_triangle_l = osg::Vec2(point_h_l.x()*2-point_h_r.x(), point_h_l.y()*2-point_h_r.y());
           point_triangle_r = osg::Vec2(point_h_r.x()*2-point_h_l.x(), point_h_r.y()*2-point_h_l.y());

           //计算最后的控制点
           point_C_l_e = osg::Vec2((point_C_l_eq.x()+point_h_l.x())/2, (point_C_l_eq.y()+point_h_l.y())/2);
           point_C_r_e = osg::Vec2((point_C_r_eq.x()+point_h_r.x())/2, (point_C_r_eq.y()+point_h_r.y())/2);

           //添加最后的控制点（中心点）
           points_C_l.push_back(point_C_l_e);
           points_C_r.push_back(point_C_r_e);
       } else { //足够三角的高度
           //由于够了三角的高度，所以首先去掉三角的高度
           //计算向量
           osg::Vec2 v_E2_E1(pointU_E1.x()-pointU_E2.x(), pointU_E1.y()-pointU_E2.y());
           //取模
           float v_E2_E1_d = sqrtf(v_E2_E1.x()*v_E2_E1.x()+v_E2_E1.y()*v_E2_E1.y());
           //首先需要计算三角形的底部中心点
           osg::Vec2 point_c(pointU_E1.x()-v_E2_E1.x()*w/v_E2_E1_d, pointU_E1.y()-v_E2_E1.y()*w/v_E2_E1_d);

           //计算出在三角形上底边上头部结束点
           point_lr_t = DrawMath::calculateVector(osg::Vec2(pointU_E1.x()-point_c.x(), pointU_E1.y()-point_c.y()), osg::PI_2, w/2);
           //获取三角形左右两个向量
           v_l_t = point_lr_t[0];
           v_r_t = point_lr_t[1];

           point_h_l = osg::Vec2(v_l_t.x()/_ratio+point_c.x(), v_l_t.y()/_ratio+point_c.y());
           point_h_r = osg::Vec2(v_r_t.x()/_ratio+point_c.x(), v_r_t.y()/_ratio+point_c.y());

           //计算三角形的左右两点
           point_triangle_l = osg::Vec2(point_h_l.x()*2-point_h_r.x(), point_h_l.y()*2-point_h_r.y());
           point_triangle_r = osg::Vec2(point_h_r.x()*2-point_h_l.x(), point_h_r.y()*2-point_h_l.y());

           //计算最后的控制点
           point_C_l_e = osg::Vec2((point_C_l_eq.x()+point_h_l.x())/2,(point_C_l_eq.y()+point_h_l.y())/2);
           point_C_r_e = osg::Vec2((point_C_r_eq.x()+point_h_r.x())/2,(point_C_r_eq.y()+point_h_r.y())/2);
           //添加最后的控制点（中心点）
           points_C_l.push_back(point_C_l_e);
           points_C_r.push_back(point_C_r_e);
       }
       //使用控制点计算差值
       //计算贝塞尔的控制点
       std::vector<osg::Vec2> points_BC_l = DrawMath::createBezier2(points_C_l);
       std::vector<osg::Vec2> points_BC_r = DrawMath::createBezier2(points_C_r);
       //组合左右点集和三角形三个点
       std::vector<osg::Vec2> pointsR{point_t_l};
       //首先连接左边的差值曲线
       pointsR.insert(pointsR.end(), points_BC_l.begin(), points_BC_l.end());
       //添加左边头部结束点
       pointsR.push_back(point_h_l);
       //添加三角形左边点
       pointsR.push_back(point_triangle_l);
       //添加三角形顶点
       pointsR.push_back(pointU_E1);
       //添加三角形右边点
       pointsR.push_back(point_triangle_r);
       //添加右边头部结束点
       pointsR.push_back(point_h_r);
       //合并右边的所有点
       for (int k = points_BC_r.size()-1; k >= 0; k--) {
           pointsR.push_back(points_BC_r[k]);
       }
       //添加右边尾部起始点
       pointsR.push_back(point_t_r);
       return pointsR;
}

bool StraightArrowDrawer::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa)
{
    if (!_mapNode)
      return false;

    osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>(&aa);
    if (!viewer)
      return false;

    if (!_isDrawStraightArrow)
        return false;
    // 使用 switch 结构更清晰地区分事件类型
    switch (ea.getEventType())
    {
        case osgGA::GUIEventAdapter::PUSH:
        {
                switch (ea.getButton())
                {
                case osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON:
                {
                    osgUtil::LineSegmentIntersector::Intersections intersections;
                    if (viewer->computeIntersections(ea.getX(), ea.getY(), nodePaths, intersections))
                    {
                        const osgUtil::LineSegmentIntersector::Intersection& intersection = *intersections.begin();
                        osg::Vec3d worldPoint = intersection.getWorldIntersectPoint();

                        // 坐标转换：世界坐标 -> 地理坐标（WGS84）
                        const osgEarth::SpatialReference* mapSRS = _mapNode->getMapSRS();
                        const osgEarth::SpatialReference* geoSRS = osgEarth::SpatialReference::get("wgs84");
                        if (!geoSRS)
                        {
                            std::cerr << "[Error] geoSRS is null!" << std::endl;
                            return false;
                        }

                        osgEarth::GeoPoint geoPoint;
                        geoPoint.fromWorld(mapSRS, worldPoint);
                        osgEarth::GeoPoint wgs84Point;
                        geoPoint.transform(geoSRS, wgs84Point);

                        double lon = wgs84Point.x();
                        double lat = wgs84Point.y();
                        double height = wgs84Point.z();
                        height=44;//固定高度防止闪烁，渲染优先级不冲突
                        // 调用 beginDraw 添加点击点
                        beginDraw(osg::Vec3d(lon, lat, height));
                    }
                    break;
                }

                case osgGA::GUIEventAdapter::RIGHT_MOUSE_BUTTON:
                {
                    resetDraw();
                    osg::ref_ptr<osg::Node> StraightArrowNode = NULL;
                    osgUtil::LineSegmentIntersector::Intersections intersections;
                    if (viewer->computeIntersections(ea.getX(), ea.getY(), nodePaths, intersections))
                    {
                        for (const auto& intersection : intersections)
                        {
                            for (auto i : intersection.nodePath)
                            {
                                std::string nodeName = i->getName();
                                std::cout << "拾取到的节点：" << nodeName << std::endl;
                                if (nodeName == "StraightArrow")
                                {

                                    StraightArrowNode = i;  // 记录 Polygon
                                }
                            }
                        }
                    }
                    // 先删除 Polygon
                    if (StraightArrowNode)
                    {
                        removeSelectStraightArrow(StraightArrowNode);
                    }
                    break;
                }

                default:
                    break;
                }
                break;
            }


        case osgGA::GUIEventAdapter::MOVE:
          {
              osgUtil::LineSegmentIntersector::Intersections intersections;
              if (viewer->computeIntersections(ea.getX(), ea.getY(), nodePaths, intersections))
              {
                  const osgUtil::LineSegmentIntersector::Intersection& intersection = *intersections.begin();
                  osg::Vec3d worldPoint = intersection.getWorldIntersectPoint();
                  const osgEarth::SpatialReference* mapSRS = _mapNode->getMapSRS();
                  const osgEarth::SpatialReference* geoSRS = osgEarth::SpatialReference::get("wgs84");
                  osgEarth::GeoPoint geoPoint;
                  geoPoint.fromWorld(mapSRS, worldPoint);
                  osgEarth::GeoPoint wgs84Point;
                  geoPoint.transform(geoSRS, wgs84Point);
                  double lon = wgs84Point.x();
                  double lat = wgs84Point.y();
                  double height = wgs84Point.z();
                  // 调试输出，确认MOVE事件
                  // 鼠标移动时更新绘制状态（动态提示线）
                  height=44;//固定高度防止闪烁，渲染优先级不冲突
                  moveDraw(osg::Vec3d(lon, lat, height));
              }
          }
          break;
        case osgGA::GUIEventAdapter::KEYDOWN:
        {
            switch(ea.getKey())
              {
              case osgGA::GUIEventAdapter::KEY_Delete:
                  qDebug() << "Delete key pressed";
                  removeStraightArrow(); // 按下 Delete 键删除刚刚创建的矩形
                  break;
              case osgGA::GUIEventAdapter::KEY_BackSpace:
                    qDebug() << "BackSpace key pressed";
                    removeAllStraightArrows(); // 按下 BackSpace 键删除所有矩形
                  break;
              default:
                  break;
            }
        }
        break;

        default:
          break;
        }
    return false;
}

参考代码链接
#include"DrawerMath.h"
DrawerMath.cpp

OSG三维渲染引擎编程学习之三十六：“第四章：OSG几何体绘制” 之 “4.1 OSG基础绘图类”
LuckyHanMo的博客
01-27 812
OSG三维渲染引擎编程学习；第四章：OSG几何体绘制”；4.1 OSG基础绘图类
osgearth绘制线
ljjjjjjjjjjj的博客
11-06 1871
一、代码 #include <osgViewer/Viewer> #include <osg/Math> #include <osgDB/ReadFile> #include <osg/NodeCallback> #include <osg/MatrixTransform> #include<osg/PositionAttitudeTransform> //键盘事件 #include<osgViewer/ViewerEv
绘制带箭头的直线
mtc1256的专栏
08-14 2511
从vc移植到objective-c.感觉不错.分享之.. -(void)drawInContext:(CGContextRef)context{      CGContextSetRGBStrokeColor(context,1.0, 0.0,0.0, 1.0);
OSG漫游：实现按键控制的操作器
kestiny的专栏
08-03 5863
OSG提供了几种manipulator(操作器)，已经能胜任很多场合了。但玩过射击类游戏的都比较熟悉使用按键的方式控制人物角色的移动，自己也想来实现一个，于是参考了OSG程序设计 一书，进行实现。功能： W或者↑箭头：前进 S或者↓箭头：后退 A或者←箭头：向左 D或者→箭头：向右 Q：左旋转 E：右旋转 鼠标左键拖动：左右视角 鼠标右键拖动：上下视角 鼠标中键：放大或者缩小 +：加速移动 -：减速
C++绘制箭头—原理和代码
weixin_30722589的博客
06-29 946
1、原理 2、代码 void calcVertexes(double start_x, double start_y, double end_x, double end_y, double& x1, double& y1, double& x2, double& y2){ double angle = atan2 (end_y - start_y,...
osgEarth中绘制双箭头
最新发布
weixin_43183044的博客
03-19 115
【代码】osgEarth中绘制双箭头。
OsgEarth - 地球、飞机、航点、航线、飞行、漫游等特效完整代码
05-19
本资源包含完整的Vs+Qt+OSG+OsgEarth代码。 资源介绍：https://blog.youkuaiyun.com/automoblie0/article/details/130773795 资源视频介绍：...
OsgEarth3绘制基础3D图元
07-26
1. 封装基于Osg+OsgEarth3实现的3D基础图元类，每个类提供各个图元的基础参数设置。 2. 封装的图元类：PolygonCubeObject3D（立方体）、CylinderObject3D（圆柱）、SphereObject3D（球体）、ConeObject3D（圆锥）、...
osgEarth基于callback更新绘制的图形(附带：osgEarth绘制多边形方法）
cchangcs
06-10 2940
本文主要介绍在osgEarth中基于callback实现实时更新绘制的图形。 绘制图形和调用callback的代码： void drawLakes() { //初始化绘图参数 const osgEarth::SpatialReference* geoSRS = mapNode->getMapSRS()->getGeographicSRS(); //湖面 osgEarth::Sy...
使用Qt+osgEarth绘制标牌
07-20
在"使用Qt+osgEarth绘制标牌"的场景中，Qt可能是用来设计和实现与用户交互的控制面板，如设置标牌的位置、大小、颜色等属性，以及显示和管理3D场景的视图。 osgEarth则是这个项目的核心部分，它利用OpenSceneGraph...
osg空间扇形绘制源码.docx
05-12
osg空间旋转扇形绘制，将基本图元在空间绕任意轴旋转得到其三维图形，采用自绘点的方式进行编程，增加了绘制的灵活性。
iOS绘制圆角箭头视图
石头哥的博客
04-14 589
类似聊天内容框背景图
[osg]源码分析：OSG中的智能指针osg::ref_ptr
06-14 4806
探究一下osg中的智能指针：osg::ref_ptr。 一、首先注意，智能指针是个模板类（不要以为理解了这句话）。比如这样一个定义： osg::ref_ptr pArray = new osg::Vec3Array; 这里，pArray本质上是一个ref_ptr对象（并非是指针），而之所以可以将new返回的指针赋给他是因为osg::ref_ptr重写了赋值操作符（关于赋值操作符的
osg基本绘制-线
wb175208的专栏
03-14 8528
osg绘制图形需要定义最基本的顶点坐标数组。 绘制几何图形需要osg::Geometry这个类，他就是负责几何体的绘制。 void create4Geo() { osg::ref_ptr&lt;osg::Group&gt; root = new osg::Group; osg::ref_ptr&lt;osg::Geode&gt; geode = new osg::Geode; root-&...
osg中模型零点的调整方法
wuchalilun的专栏
12-29 2292
osg中加载一个模型，模型自身的零点已经在3DMAX或者MAYA中设置好了，在模型自身，也有可能不在自身(距离一定位置的一个点)，一般加载一个地形，零点基本都在模型的左下角，加入到osg场景中，也就是这个点将和场景的零点重合，注意:OSG是左手坐标系（向右是X正方向，屏幕向里是Y正方向，向上是Z正方向）。但是，如果是OSG自绘的模型呢，它的零点在什么地方，比如：osg::ShapeDrawable(
细数OSG中的“神来之剪”
lavanana的博客
06-28 2632
“裁剪”就是从大量的事务中进行挑选、删除。 对一个庞大的三维体而言，往往存在着大量无助于最终渲染结果的对象；将它们从场景中剔除后，将剩余的场景对象发送到OpenGL管线中,即可完成一帧的绘制工作。 这类型的裁剪工作通常称为“可见性裁剪”，即只有真正能够被终端用户看到的对象才会被发送到渲染管线中。 常见de裁剪技术 一、背面裁剪 当我们观察一个不透明物体时，通常大约有一半的物体表面是看不到的，因此完...
C++绘制箭头原理
bpv_kiki的专栏
11-14 1364
原文（墙）：http://kapo-cpp.blogspot.com/2008/10/drawing-arrows-with-cairo.html   Drawing arrows with Cairo For my ggredit project I need to draw connectors between objects, connectors are simple lines t...
osgearth 2 绘制点线面 csdn
04-30
osgEarth 2 是一个开源的地理信息系统软件工具包，用于处理地图数据和地球表面的渲染。它使用 OpenSceneGraph 引擎和 OpenGL 技术，能够高效地显示地理信息数据，包括矢量数据、DEM（数字高程模型）和卫星图像等。 osgEarth 2 的绘制功能非常强大，可以绘制点、线、面等地理信息要素。其中，点的绘制主要通过添加节点来实现，在节点中添加位置信息和图形样式即可；线的绘制可以通过给节点添加连接关系，形成不同形态的线条；面的绘制则需要使用不同的图元类型，例如三角形、四边形等。在绘制这些要素时，osgEarth 2 还支持多种绘图模式，包括纹理贴图和图案填充等。 osgEarth 2 绘制点线面时，还支持坐标系转换和空间参考系统（SRS）的定义。用户可以将坐标系转换为不同的地图投影方式，如维度、经度、UTM 等；同时，还可以通过 SRS 定义地图的基准面和坐标系，让不同的地理数据在同一个坐标系下渲染，并能在不同的投影方式下进行转换。 在 优快云 上，osgEarth 2 的相关技术文章非常丰富，其中包括如何使用 osgEarth 2 进行点、线、面绘制的具体实现方法。开发者可以参考这些文章，了解更多关于osgEarth 2 点线面绘制的实践技巧和经验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值