精华内容
下载资源
问答
  • 奥比中光3D体感摄像头 windows平台下的sdk和开发手册 ,深圳奥比中光科技有限公司。 支持win32 和 x64
  • 说明书 奥比中光 RGBD传感器摄像头 大白 ORBBEC DaBai Datasheet _v1.4
  • (在使用之前必须要去官网下载你这个摄像头的驱动并安装:下载地址:https://orbbec3d.com/develop/) niviewer:下载地址:https://download.csdn.net/download/fly_higher/9759883 我下载的时候需要1个积分。...

     

    首先,可以直接使用niviewer这个exe来实现可视化:

    (在使用之前必须要去官网下载你这个摄像头的驱动并安装:下载地址:https://orbbec3d.com/develop/

    niviewer:下载地址:https://download.csdn.net/download/fly_higher/9759883

    我下载的时候需要1个积分。。。

    然后解压:

    然后点击NiViewer(应用程序即可)

    点击之后效果图为:(马赛克是我自己加的)

    这里说一下你可以右键:

    点图示的按钮:

    出现的命令,大家可以自行体验一下,然后注意的是你按c的时候他就会自动的把深度图和rgb图保存在之前你解压的文件夹中::

    可以看出这都是raw文件,我们想要看这样子的文件还需要下载一个工具imageJ

    下载地址为:http://imagej.net/Fiji/Downloads(来源于博客:https://blog.csdn.net/sheldonxxd/article/details/80371444

    然后下载之后依然解压:

    运行图示软件即可:

    !!!!下面是最重要的,为了能够完整的显示你的深度图和彩色图:

    首先你需要导入图像(raw文件):

    下面这些参数必须要配置对:

    对于彩色图:

     

    对于深度图:

    宽度和高度必须设置如图所示:要不然出来结果不对

    如果想要保存为其他格式,直接点解file saveas即可

    其最终结果为:

    展开全文
  • 奥比中光深度摄像头实现follow

    千次阅读 2018-12-20 20:34:20
    Github地址:https://github.com/robotBing/skeleton_follow ... 奥比中光摄像头是有ros驱动的,最开始的点云颜色跟随就是直接调用奥比提供的astra_launch包,但是骨骼跟随自己需要做的工作就多得多了...

    Github地址:https://github.com/robotBing/skeleton_follow

    演示视频地址:http://blog.jiutucao.com:9000/upload/2018/07/skeleton_follow.mp4

      奥比中光摄像头是有ros驱动的,最开始的点云颜色跟随就是直接调用奥比提供的astra_launch包,但是骨骼跟随自己需要做的工作就多得多了。不得不说过程很艰难,使用一门不是最擅长的语言,没有ide,只能用记事本进行代码编写,调试全靠打印信息。时间又紧,只能做出来一个半成品。

      下面说一下开发时的心路历程,先到astra的官网上下载奥比中光的sdk,这个sdk是可以进行骨骼识别的,但是和ros无关,我要做的就是根据提供demo代码,筛选出我需要的数据,对数据进行处理,映射成为ros需要的速度数据,最后将速度数据发布到cmd_vel话题上。最烦的就是没有ide,调用哪个方法要一点一点的试,全靠手打。

      Sdk提供的骨骼识别有19个关节信息,核心程序的思路就是提取身体最中心的关节坐标,映射为速度信息,提取手臂各个关节的坐标,对人的动作进行判断,让机器人在等待15s,开始跟随,停止跟随几个状态转换。程序有两个可以完善的地方1.程序没有使用多线程,等待15s过程中,整个线程停止,导致整个程序停止.2.动作的判断不够全面,受环境干扰太大。两个问题都是致命的,但是修改起来很简单,我就不做改进了,希望学弟们能把程序完善。

    sdk下载地址:https://orbbec3d.com/develop

    sdk中的demo编译需要sfml支持,下载sfml:

    sudo apt-get install libsfml-dev

     

    sfml官网教程地址:https://www.sfml-dev.org/tutorials/2.0/start-linux.php

    下载sdk后编译例子步骤:

    1. 进入SDK下的samples目录下,新建一个build目录,在终端中进入到build目录下。

    cd SDK路径/samples/

    mkdir build

    cd build

     

    1. 用cmake编译并转到bin目录下,运行测试程序。

    cmake ..

    make

    编译后的可执行文件在build目录下的bin目录里

      下面是核心代码:

    #include <SFML/Graphics.hpp>

    #include <astra/astra.hpp>

    #include <iostream>

    #include <cstring>

    #include "ros/ros.h"

    #include "std_msgs/String.h"

    #include <geometry_msgs/Twist.h>

    #include <string>

    #include <ctime>

    #include <sstream>

    class sfLine : public sf::Drawable

    {

    public:

        sfLine(const sf::Vector2f& point1, const sf::Vector2f& point2, sf::Color color, float thickness)

            : color_(color)

        {

            const sf::Vector2f direction = point2 - point1;

            const sf::Vector2f unitDirection = direction / std::sqrt(direction.x*direction.x + direction.y*direction.y);

            const sf::Vector2f normal(-unitDirection.y, unitDirection.x);

            const sf::Vector2f offset = (thickness / 2.f) * normal;

            vertices_[0].position = point1 + offset;

            vertices_[1].position = point2 + offset;

            vertices_[2].position = point2 - offset;

            vertices_[3].position = point1 - offset;

     

            for (int i = 0; i<4; ++i)

                vertices_[i].color = color;

        }

     

        void draw(sf::RenderTarget &target, sf::RenderStates states) const

        {

            target.draw(vertices_, 4, sf::Quads, states);

        }

    private:

        sf::Vertex vertices_[4];

        sf::Color color_;

    };

    class BodyVisualizer : public astra::FrameListener

    {

    public:

          float line = 0;

          float angle = 0;

          ros::Publisher pub;

          ros::Publisher pubVoice;

          astra::Vector3f shoulderSpinePosition;

          astra::Vector3f leftHandPosition;

          astra::Vector3f rightHandPosition;

          int state = 0 ;

          int timeState = 1;

          virtual void onInit()

          {

          ros::NodeHandle n ;

          pub = n.advertise<geometry_msgs::Twist>("cmd_vel",1);

          pubVoice = n.advertise<std_msgs::String>("speak_string",1);

          }

        static sf::Color get_body_color(std::uint8_t bodyId)

        {

            if (bodyId == 0)

            {

                return sf::Color(0x00, 0x00, 0x00, 0x00);

            }

            // Case 0 below could mean bodyId == 25 or

            // above due to the "% 24".

            switch (bodyId % 24) {

            case 0:

                return sf::Color(0x00, 0x88, 0x00, 0xFF);

            case 1:

                return sf::Color(0x00, 0x00, 0xFF, 0xFF);

            case 2:

                return sf::Color(0x88, 0x00, 0x00, 0xFF);

            case 3:

                return sf::Color(0x00, 0xFF, 0x00, 0xFF);

            case 4:

                return sf::Color(0x00, 0x00, 0x88, 0xFF);

            case 5:

                return sf::Color(0xFF, 0x00, 0x00, 0xFF);

     

            case 6:

                return sf::Color(0xFF, 0x88, 0x00, 0xFF);

            case 7:

                return sf::Color(0xFF, 0x00, 0xFF, 0xFF);

            case 8:

                return sf::Color(0x88, 0x00, 0xFF, 0xFF);

            case 9:

                return sf::Color(0x00, 0xFF, 0xFF, 0xFF);

            case 10:

                return sf::Color(0x00, 0xFF, 0x88, 0xFF);

            case 11:

                return sf::Color(0xFF, 0xFF, 0x00, 0xFF);

     

            case 12:

                return sf::Color(0x00, 0x88, 0x88, 0xFF);

            case 13:

                return sf::Color(0x00, 0x88, 0xFF, 0xFF);

            case 14:

                return sf::Color(0x88, 0x88, 0x00, 0xFF);

            case 15:

                return sf::Color(0x88, 0xFF, 0x00, 0xFF);

            case 16:

                return sf::Color(0x88, 0x00, 0x88, 0xFF);

            case 17:

                return sf::Color(0xFF, 0x00, 0x88, 0xFF);

     

            case 18:

                return sf::Color(0xFF, 0x88, 0x88, 0xFF);

            case 19:

                return sf::Color(0xFF, 0x88, 0xFF, 0xFF);

            case 20:

                return sf::Color(0x88, 0x88, 0xFF, 0xFF);

            case 21:

                return sf::Color(0x88, 0xFF, 0xFF, 0xFF);

            case 22:

                return sf::Color(0x88, 0xFF, 0x88, 0xFF);

            case 23:

                return sf::Color(0xFF, 0xFF, 0x88, 0xFF);

            default:

                return sf::Color(0xAA, 0xAA, 0xAA, 0xFF);

            }

        }

        void init_depth_texture(int width, int height)

        {

            if (displayBuffer_ == nullptr || width != depthWidth_ || height != depthHeight_)

            {

                depthWidth_ = width;

                depthHeight_ = height;

                int byteLength = depthWidth_ * depthHeight_ * 4;

                displayBuffer_ = BufferPtr(new uint8_t[byteLength]);

                std::memset(displayBuffer_.get(), 0, byteLength);

                texture_.create(depthWidth_, depthHeight_);

                sprite_.setTexture(texture_, true);

                sprite_.setPosition(0, 0);

            }

        }

        void init_overlay_texture(int width, int height)

        {

            if (overlayBuffer_ == nullptr || width != overlayWidth_ || height != overlayHeight_)

            {

                overlayWidth_ = width;

                overlayHeight_ = height;

                int byteLength = overlayWidth_ * overlayHeight_ * 4;

                overlayBuffer_ = BufferPtr(new uint8_t[byteLength]);

                std::fill(&overlayBuffer_[0], &overlayBuffer_[0] + byteLength, 0);

                overlayTexture_.create(overlayWidth_, overlayHeight_);

                overlaySprite_.setTexture(overlayTexture_, true);

                overlaySprite_.setPosition(0, 0);

            }

        }

        void check_fps()

        {

            double fpsFactor = 0.02;

            std::clock_t newTimepoint= std::clock();

            long double frameDuration = (newTimepoint - lastTimepoint_) / static_cast<long double>(CLOCKS_PER_SEC);

            frameDuration_ = frameDuration * fpsFactor + frameDuration_ * (1 - fpsFactor);

            lastTimepoint_ = newTimepoint;

            double fps = 1.0 / frameDuration_;

     

           // printf("FPS: %3.1f (%3.4Lf ms)\n", fps, frameDuration_ * 1000);

        }

        void processDepth(astra::Frame& frame)

        {

            const astra::DepthFrame depthFrame = frame.get<astra::DepthFrame>();

            if (!depthFrame.is_valid()) { return; }

            int width = depthFrame.width();

            int height = depthFrame.height();

            init_depth_texture(width, height);

            const int16_t* depthPtr = depthFrame.data();

            for(int y = 0; y < height; y++)

            {

                for(int x = 0; x < width; x++)

                {

                    int index = (x + y * width);

                    int index4 = index * 4;

                    int16_t depth = depthPtr[index];

                    uint8_t value = depth % 255;

                    displayBuffer_[index4] = value;

                    displayBuffer_[index4 + 1] = value;

                    displayBuffer_[index4 + 2] = value;

                    displayBuffer_[index4 + 3] = 255;

                }

            }

            texture_.update(displayBuffer_.get());

        }

        void processBodies(astra::Frame& frame)

        {

            astra::BodyFrame bodyFrame = frame.get<astra::BodyFrame>();

            jointPositions_.clear();

            circles_.clear();

            circleShadows_.clear();

            boneLines_.clear();

            boneShadows_.clear();

            if (!bodyFrame.is_valid() || bodyFrame.info().width() == 0 || bodyFrame.info().height() == 0)

            {

                clear_overlay();

                return;

            }

            const float jointScale = bodyFrame.info().width() / 120.f;

           const auto& bodies = bodyFrame.bodies();

            for (auto& body : bodies)

            {

                 //   bodyFrame.frame_index(), body.id(), unsigned(body.hand_poses().left_hand()));

                for(auto& joint : body.joints())

                {

                     onInit();

     

                     astra::JointType jointType = joint.type();

     

                     if(jointType == astra::JointType::ShoulderSpine)

                     {

                         shoulderSpinePosition = joint.world_position();

                        

     

                     }

                     if(jointType == astra::JointType::LeftHand)

                     {

                         leftHandPosition = joint.world_position();

                        

                     }

                     if(jointType == astra::JointType::RightHand)

                     {

                         rightHandPosition = joint.world_position();

                     }

                    

                      //set state

                     if(leftHandPosition.y - shoulderSpinePosition.y > 300)

                      {

                         timeState++;

                         std_msgs::String msg;

     

                         std::string ss;

                         ss = "状态变为一,开始跟随" ;

                         msg.data = ss;                                 

                                pubVoice.publish(msg);

                         

                           state = 1 ;

                      }

                     if(rightHandPosition.y - shoulderSpinePosition.y > 300)

                      {

                         timeState++ ;

                         std_msgs::String msg;

     

                         std::string ss;

                         ss = "状态变为二,等待十五秒" ;

                         msg.data = ss;

                         pubVoice.publish(msg);               

                         state = 2 ;

                      }

                     if(leftHandPosition.y>-100 && leftHandPosition.y<100 && rightHandPosition.y<100 && rightHandPosition.y>-100)

                      {

                         timeState++ ;

                         std_msgs::String msg;

     

                         std::string ss;

                         ss = "状态变为零,停止跟随" ;

                         msg.data = ss;

                        

                        if(timeState % 100 == 0)

                           {

                                pubVoice.publish(msg);

                                state = 0 ;

                           }  

                      }

     

                     if(jointType == astra::JointType::MidSpine)

                     {

                        auto worldPosition = joint.world_position();

                        if(worldPosition.x / 500.f>0.2 || worldPosition.x / 500.f<-0.2)

                       {

                          if(worldPosition.x / 500.f>0.3)

                              {

                                angle = 0.3;

                              }else if(worldPosition.x / 500.f<-0.3)

                              {

                                angle = -0.3;

                              }else

                              {

                                angle = worldPosition.x / 500.f ;

                              }

                         

                       } else

                       {

                           if(worldPosition.x / 1000.f>0.3)

                              {

                                angle = 0.3;

                              }else if(worldPosition.x / 1000.f<-0.3)

                              {

                                angle = -0.3;

                              }else

                              {

                                angle = worldPosition.x / 1000.f ;

                              }

                       }

                      if((worldPosition.z - 1500.f) / 500.f > 0.2 ||  (worldPosition.z - 1500.f) / 500.f<-0.2)

                       {

                           if((worldPosition.z -1500.f) / 500.f>0.3)

                              {

                                line = 0.3;

                              }else if((worldPosition.z -1500.f) / 500.f<-0.3)

                              {

                                line = -0.3;

                              }else

                              {

                                line = (worldPosition.z -1500.f) / 500.f ;

                              }

                       }else

                       {

                           if((worldPosition.z -1500.f) / 1000.f>0.3)

                              {

                                line = 0.3;

                              }else if((worldPosition.z -1500.f) / 1000.f<-0.3)

                              {

                                line = -0.3;

                              }else

                              {

                                line = (worldPosition.z -1500.f) / 1000.f ;

                              }

                       }

     

                        publishCmdVel();

                        printf("z:%d\n",state);

                     }

                    jointPositions_.push_back(joint.depth_position());

                }

     

                update_body(body, jointScale);

            }

     

            const auto& floor = bodyFrame.floor_info(); //floor

            if (floor.floor_detected())

            {

                const auto& p = floor.floor_plane();

                std::cout << "Floor plane: ["

                    << p.a() << ", " << p.b() << ", " << p.c() << ", " << p.d()

                    << "]" << std::endl;

     

            }

     

            const auto& bodyMask = bodyFrame.body_mask();

            const auto& floorMask = floor.floor_mask();

     

            update_overlay(bodyMask, floorMask);

        }

     

        void update_body(astra::Body body,

                         const float jointScale)

        {

            const auto& joints = body.joints();

     

            if (joints.empty())

            {

                return;

            }

     

            for (const auto& joint : joints)

            {

                astra::JointType type = joint.type();

                const auto& pos = joint.depth_position();

     

                if (joint.status() == astra::JointStatus::NotTracked)

                {

                    continue;

                }

     

                auto radius = jointRadius_ * jointScale; // pixels

                sf::Color circleShadowColor(0, 0, 0, 255);

     

                 auto color = sf::Color(0x00, 0xFF, 0x00, 0xFF);

     

                if ((type == astra::JointType::LeftHand && astra::HandPose::Grip==body.hand_poses().left_hand()) ||

                    (type == astra::JointType::RightHand &&  astra::HandPose::Grip==body.hand_poses().right_hand()))

                {

                    radius *= 1.5f;

                    circleShadowColor = sf::Color(255, 255, 255, 255);

                    color = sf::Color(0x00, 0xAA, 0xFF, 0xFF);

                }

     

                const auto shadowRadius = radius + shadowRadius_ * jointScale;

                const auto radiusDelta = shadowRadius - radius;

     

                sf::CircleShape circle(radius);

     

                circle.setFillColor(sf::Color(color.r, color.g, color.b, 255));

                circle.setPosition(pos.x - radius, pos.y - radius);

                circles_.push_back(circle);

     

                sf::CircleShape shadow(shadowRadius);

                shadow.setFillColor(circleShadowColor);

                shadow.setPosition(circle.getPosition() - sf::Vector2f(radiusDelta, radiusDelta));

                circleShadows_.push_back(shadow);

            }

     

            update_bone(joints, jointScale, astra::JointType::Head, astra::JointType::ShoulderSpine);

     

            update_bone(joints, jointScale, astra::JointType::ShoulderSpine, astra::JointType::LeftShoulder);

            update_bone(joints, jointScale, astra::JointType::LeftShoulder, astra::JointType::LeftElbow);

            update_bone(joints, jointScale, astra::JointType::LeftElbow, astra::JointType::LeftHand);

     

            update_bone(joints, jointScale, astra::JointType::ShoulderSpine, astra::JointType::RightShoulder);

            update_bone(joints, jointScale, astra::JointType::RightShoulder, astra::JointType::RightElbow);

            update_bone(joints, jointScale, astra::JointType::RightElbow, astra::JointType::RightHand);

     

            update_bone(joints, jointScale, astra::JointType::ShoulderSpine, astra::JointType::MidSpine);

            update_bone(joints, jointScale, astra::JointType::MidSpine, astra::JointType::BaseSpine);

     

            update_bone(joints, jointScale, astra::JointType::BaseSpine, astra::JointType::LeftHip);

            update_bone(joints, jointScale, astra::JointType::LeftHip, astra::JointType::LeftKnee);

            update_bone(joints, jointScale, astra::JointType::LeftKnee, astra::JointType::LeftFoot);

     

            update_bone(joints, jointScale, astra::JointType::BaseSpine, astra::JointType::RightHip);

            update_bone(joints, jointScale, astra::JointType::RightHip, astra::JointType::RightKnee);

            update_bone(joints, jointScale, astra::JointType::RightKnee, astra::JointType::RightFoot);

        }

     

        void update_bone(const astra::JointList& joints,

                         const float jointScale,astra::JointType j1,

                         astra::JointType j2)

        {

            const auto& joint1 = joints[int(j1)];

            const auto& joint2 = joints[int(j2)];

     

            if (joint1.status() == astra::JointStatus::NotTracked ||

                joint2.status() == astra::JointStatus::NotTracked)

            {

                return;

            }

            const auto& jp1 = joint1.depth_position();

            const auto& jp2 = joint2.depth_position();

     

            auto p1 = sf::Vector2f(jp1.x, jp1.y);

            auto p2 = sf::Vector2f(jp2.x, jp2.y);

     

            sf::Color color(255, 255, 255, 255);

            float thickness = lineThickness_ * jointScale;

            if (joint1.status() == astra::JointStatus::LowConfidence ||

                joint2.status() == astra::JointStatus::LowConfidence)

            {

                color = sf::Color(128, 128, 128, 255);

                thickness *= 0.5f;

            }

     

            boneLines_.push_back(sfLine(p1,

                p2,

                color,

                thickness));

            const float shadowLineThickness = thickness + shadowRadius_ * jointScale * 2.f;

            boneShadows_.push_back(sfLine(p1,

                p2,

                sf::Color(0, 0, 0, 255),

                shadowLineThickness));

        }

     

        void update_overlay(const astra::BodyMask& bodyMask,

                            const astra::FloorMask& floorMask)

        {

            const auto* bodyData = bodyMask.data();

            const auto* floorData = floorMask.data();

            const int width = bodyMask.width();

            const int height = bodyMask.height();

     

            init_overlay_texture(width, height);

     

            const int length = width * height;

     

            for (int i = 0; i < length; i++)

            {

                const auto bodyId = bodyData[i];

                const auto isFloor = floorData[i];

     

                sf::Color color(0x0, 0x0, 0x0, 0x0);

     

                if (bodyId != 0)

                {

                    color = get_body_color(bodyId);

                }

                else if (isFloor != 0)

                {

                    color = sf::Color(0x0, 0x0, 0xFF, 0x88);

                }

     

                const int rgbaOffset = i * 4;

                overlayBuffer_[rgbaOffset] = color.r;

                overlayBuffer_[rgbaOffset + 1] = color.g;

                overlayBuffer_[rgbaOffset + 2] = color.b;

                overlayBuffer_[rgbaOffset + 3] = color.a;

            }

     

            overlayTexture_.update(overlayBuffer_.get());

        }

     

        void clear_overlay()

        {

            int byteLength = overlayWidth_ * overlayHeight_ * 4;

            std::fill(&overlayBuffer_[0], &overlayBuffer_[0] + byteLength, 0);

     

            overlayTexture_.update(overlayBuffer_.get());

        }

     

        virtual void on_frame_ready(astra::StreamReader& reader,

                                    astra::Frame& frame) override

        {

            processDepth(frame);

            processBodies(frame);

     

            check_fps();

        }

     

        void draw_bodies(sf::RenderWindow& window)

        {

            const float scaleX = window.getView().getSize().x / overlayWidth_;

            const float scaleY = window.getView().getSize().y / overlayHeight_;

     

            sf::RenderStates states;

            sf::Transform transform;

            transform.scale(scaleX, scaleY);

            states.transform *= transform;

     

            for (const auto& bone : boneShadows_)

                window.draw(bone, states);

     

            for (const auto& c : circleShadows_)

                window.draw(c, states);

     

            for (const auto& bone : boneLines_)

                window.draw(bone, states);

     

            for (auto& c : circles_)

                window.draw(c, states);

     

        }

     

        void draw_to(sf::RenderWindow& window)

        {

            if (displayBuffer_ != nullptr)

            {

                const float scaleX = window.getView().getSize().x / depthWidth_;

                const float scaleY = window.getView().getSize().y / depthHeight_;

                sprite_.setScale(scaleX, scaleY);

     

                window.draw(sprite_); // depth

            }

     

            if (overlayBuffer_ != nullptr)

            {

                const float scaleX = window.getView().getSize().x / overlayWidth_;

                const float scaleY = window.getView().getSize().y / overlayHeight_;

                overlaySprite_.setScale(scaleX, scaleY);

                window.draw(overlaySprite_); //bodymask and floormask

            }

     

            draw_bodies(window);

        }

        void publishCmdVel()

       {

         geometry_msgs::Twist twist;

         if(state == 1)

         {

         twist.linear.x = line;

     

         twist.angular.z = angle;

         pub.publish(twist);

         } else if(state == 2)

         {

            twist.linear.x = 0;

            twist.angular.z = 0;

            pub.publish(twist);

           clock_t delay;

           delay = 90 * 100000 ;

           clock_t start = clock();

           while(clock()-start < delay){

                    state = 1;

                  }

                        std_msgs::String msg;

     

                         std::string ss;

                         ss = "状态变为一,开始跟随" ;

                         msg.data = ss;

                       

                         pubVoice.publish(msg);

                       

          

         }else

         {

          twist.linear.x = 0;

         twist.angular.z = 0;

         pub.publish(twist);

         }

     

     

        

       }

     

    private:

        long double frameDuration_{ 0 };

        std::clock_t lastTimepoint_ { 0 };

        sf::Texture texture_;

        sf::Sprite sprite_;

        using BufferPtr = std::unique_ptr < uint8_t[] >;

        BufferPtr displayBuffer_{ nullptr };

        std::vector<astra::Vector2f> jointPositions_;

        int depthWidth_{0};

        int depthHeight_{0};

        int overlayWidth_{0};

        int overlayHeight_{0};

        std::vector<sfLine> boneLines_;

        std::vector<sfLine> boneShadows_;

        std::vector<sf::CircleShape> circles_;

        std::vector<sf::CircleShape> circleShadows_;

        float lineThickness_{ 0.5f }; // pixels

        float jointRadius_{ 1.0f };   // pixels

        float shadowRadius_{ 0.5f };  // pixels

        BufferPtr overlayBuffer_{ nullptr };

        sf::Texture overlayTexture_;

        sf::Sprite overlaySprite_;

     

    };

     

    astra::DepthStream configure_depth(astra::StreamReader& reader)

    {

        auto depthStream = reader.stream<astra::DepthStream>();

        astra::ImageStreamMode depthMode;

        depthMode.set_width(640);

        depthMode.set_height(480);

        depthMode.set_pixel_format(astra_pixel_formats::ASTRA_PIXEL_FORMAT_DEPTH_MM);

        depthMode.set_fps(30);

        depthStream.set_mode(depthMode);

        return depthStream;

    }

     

    int main(int argc, char** argv)

    {

         ros::init(argc , argv ,"skeleton_follow");

        astra::initialize();

        const char* licenseString = "<INSERT LICENSE KEY HERE>";

        orbbec_body_tracking_set_license(licenseString);

        sf::RenderWindow window(sf::VideoMode(1280, 960), "Simple Body Viewer");

    #ifdef _WIN32

        auto fullscreenStyle = sf::Style::None;

    #else

        auto fullscreenStyle = sf::Style::Fullscreen;

    #endif

     

        const sf::VideoMode fullScreenMode = sf::VideoMode::getFullscreenModes()[0];

        const sf::VideoMode windowedMode(1280, 960);

        bool isFullScreen = false;

     

        astra::StreamSet sensor;

        astra::StreamReader reader = sensor.create_reader();

        BodyVisualizer listener;

        auto depthStream = configure_depth(reader);

        depthStream.start();

        reader.stream<astra::BodyStream>().start();

        reader.add_listener(listener);

        BodyVisualizer bv ;

     

        while (window.isOpen())

        {

            astra_update();

     

            sf::Event event;

     

            while (window.pollEvent(event))

            {

                switch (event.type)

                {

                case sf::Event::Closed:

                    window.close();

                    break;

                case sf::Event::KeyPressed:

                {

                    if (event.key.code == sf::Keyboard::C && event.key.control)

                    {

                        window.close();

                    }

                    switch (event.key.code)

                    {

                    case sf::Keyboard::Escape:

                        window.close();

                        break;

                    case sf::Keyboard::F:

                        if (isFullScreen)

                        {

                            window.create(windowedMode, "Simple Body Viewer", sf::Style::Default);

                        }

                        else

                        {

                            window.create(fullScreenMode, "Simple Body Viewer", fullscreenStyle);

                        }

                        isFullScreen = !isFullScreen;

                        break;

                    case sf::Keyboard::R:

                        depthStream.enable_registration(!depthStream.registration_enabled());

                        break;

                    case sf::Keyboard::M:

                        depthStream.enable_mirroring(!depthStream.mirroring_enabled());

                        break;

                    default:

                        break;

                    }

                    break;

                }

                default:

                    break;

                }

            }

            // clear the window with black color

            window.clear(sf::Color::Black);

            listener.draw_to(window);

            window.display();

        }

        astra::terminate();

        return 0;

    }

    展开全文
  • 1:开发环境 使用的是vs2013 下载路径:https://download.my.visualstudio.com/sg/cn_visual_studio_ultimate_2013_with_update_5_x86_dvd_6816649.iso?t=66fdc216-0bbf-4de5-959f-d379dd88c51a&e=1622371619&...

    1:开发环境
    使用的是vs2013
    下载路径:https://download.my.visualstudio.com/sg/cn_visual_studio_ultimate_2013_with_update_5_x86_dvd_6816649.iso?t=66fdc216-0bbf-4de5-959f-d379dd88c51a&e=1622371619&h=cad3e83ef9c72432589032df358aeedb&su=1
    但是官网路径下载太慢
    链接: https://pan.baidu.com/s/1OjPUzreBecX3ZOPbyDifhg 提取码: xbd9 复制这段内容后打开百度网盘手机App,操作更方便哦

    下载完成后,正常安装就行,激活码随便网上搜下就行。

    2:cmake环境
    安装cmake的目的是为了重新生成下载sdk里面sample工程,里面的一些相对路径有问题。

    进入官网:https://cmake.org/download/

    找到自己的对应的版本下载即可
    在这里插入图片描述
    3:SDK安装
    https://developer.orbbec.com.cn/download.html?id=56
    按照自己的vs版本下载就行,我下载的是vs2013 64位版本的

    运行官方示例sample步骤
    解压下载好的sdk,解压到任意目录,例如D:盘,如下:
    在这里插入图片描述
    新建一个要重新生成的vs项目的目录:
    例如:D:\ASTRA\mybuild

    在这里插入图片描述
    启动cmake,重新生成项目
    在这里插入图片描述
    配置项目
    在这里插入图片描述
    然后点击 Finish。
    成功后,可以“Ganerate”,就可以生成项目了。
    成功后,点击open Project,可以打开相应的项目。

    在这里插入图片描述
    至此,项目可正常打开了,点击“重新生成解决方案”也能正常生成,但是debug的时候会提示,xxx.dll丢失

    在这里插入图片描述
    4:debug项目 - 修复dll 丢失问题
    按照官方文档,把相应的 “附加包含目录”,“附加目录库”,“附加依赖项”都加进去了,还是不行。

    进入“属性”菜单:
    在这里插入图片描述
    1:添加包含目录:
    在“ C / C ++”部分的常规配置项下,找到“附加包含目录”并加入“ $(ASTRA_HOME)\ include文件名称
    在这里插入图片描述
    2:添加附加目录库
    在链接器的常规配置项下,找到“附加库目录”并加入“ $(ASTRAHOME)\ lib”,“ $(ASTRAHOME)\ lib \ Plugins” 文件名称。
    在这里插入图片描述
    3:在链接器的输入配置项下,找到“附加依赖项”,然后加入 astra.lib、astracore.lib、astracore_api.lib 文件库名称。
    在这里插入图片描述
    4:在debug目录,手动添加上所有的dll文件
    复制bin目录和Plugins目录下的所有dll文件,到debug目录
    在这里插入图片描述
    复制到重构工程的bin\debug目录下,就正常debug了。
    在这里插入图片描述
    因为整个sample是一个大的解决方案,如果要debug的话要选一个启动项:
    选择一个启动项
    在这里插入图片描述
    选择一个自己喜欢的项目启动就行
    在这里插入图片描述
    最后,直接debug就行

    备注:
    点击下面链接,进入奥比中光开发者社区,了解更多3D视觉技术信息:https://developer.orbbec.com.cn/
    或扫描下方二维码,进入奥比中光开发者社区:
    在这里插入图片描述

    展开全文
  • 2.奥比中光摄像头(astra )一个 3.注意这里是astra款式的相机,不是astro pro 4.淘宝买的那个便宜的是astro pro的,如下为官方文件说明 5.分界线之前都自己亲自测试过 二.ROS-Astra-SDK 获取方式 1.在 ...

    一.使用前要求:

    1.ubuntu16.04系统安装Ros系统kinetic版本(安装教程看我上一篇博文)
    2.奥比中光摄像头(astra )一个
    3.注意这里是astra款式的相机,不是astro pro
    4.淘宝买的那个便宜的是astro pro的,如下为官方文件说明
    5.分界线之前都自己亲自测试过
    在这里插入图片描述

    二.ROS-Astra-SDK 获取方式

    1.在 Ubuntu Indigo 及其以上版本可以直接通过 apt 的方式安装
    本文用的是ubuntu kinetic版本
    $ sudo apt-get install ros-kinetic-astra-camera
    $ sudo apt-get install ros-kinetic-astra-launch
    (如果是其他版本只需要把对应的kinetic换成其他版本即可)

    三.ROS-Astra-SDK 基本结构
    在这里插入图片描述
    四.ROS-Astra-SDK 运行及数据获取方式

    1.Astra 运行
      通过 roslaunch 方式 即可启动 Astra 相机
      在终端输入: $ roslaunch astra_launch astra.launch
      在这里插入图片描述看到SUMMARY表示运行正确
      
    2.获取数据

    1).通过 rostopic 的方式查看发布数据是否正常
       通过快捷键ctrl+alt+T再打开一个终端输入:
       $ rostopic list
    在这里插入图片描述上述发布的除了 image_raw 部分由 Astra 驱动直接发布,大部分都是通过
    rgbd_launch 进行修改后发布。如果仅仅需要获取原始摄像头信息,主要关注下面 3
    个 topic。
    /camera/rgb/image_raw
    /camera/depth/image_raw
    /camera/ir/image_raw
    请注意由于 openni2 的限制,rgb 和 ir 无法同时输出。
    如果需要获取点云数据,访问下面两个 topic
    /camera/depth/points
    /camera/depth_registered/points

    2).查看相机信息

    在当前终端中输入:
    $ rostopic echo /camera/depth/camera_info
    在这里插入图片描述3).查看话题发布频率

    $ rostopic hz /camera/depth/image_raw
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20191227100653622.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzAyMDk3,size_16,color_FFFFFF,t_704)查看深度数据

    $ rostopic echo /camera/depth/image_raw
    在这里插入图片描述查看rgb和ir数据只需将上面的命令中的depth换成rgb或是ir即可
    $ rostopic echo /camera/rgb/image_raw
    $ rostopic echo /camera/ir/image_raw
    但是由于上面提到的OpenNI暂时只能显示深度信息,后文会继续讲解

    五.Image_view 显示深度数据

    通过安装 image_view 工具直观查看摄像头发布的数据
    $ sudo apt-get install ros-kinectic-image-view

    1. 查看深度图
      $rosrun image_view image_view image:=/camera/depth/image_raw
      在这里插入图片描述以下两个暂时无法显示,后文继续讲解

    2. 查看彩色图
      $rosrun image_view image_view image:=/camera/rgb/image_raw

    3. 查看 IR 图
      $rosrun image_view image_view image:=/camera/ir/image

    ******这是美丽的分割线*********
    目前按照官方教程只能走下来只能显示到深度图,通过查找资料和查看的博文(https://blog.csdn.net/dddxxxx/article/details/78510532)
    需要安装OPenNI,由于自己买的是淘宝的astro pro版本的,下面没有测试过.
    1.安装依赖:

    sudo apt-get install build-essential freeglut3 freeglut3-dev

    2.检查udev版本,需要libudev.so.1,如果没有则添加

    $ldconfig -p | grep libudev.so.1
    $cd /lib/x86_64-linux-gnu
    $sudo ln -s libudev.so.x.x.x libudev.so.1

    3.下载OpenNI驱动(去奥比中光官网下载)

    $ cd OpenNI-Linux-x64-2.3.0.63

    4.安装

    $ sudo chmod a+x install.sh
    $ sudo ./install.sh

    5.重插设备

    6.加入环境

    $ source OpenNIDevEnvironment

    7.编译例子

    $ cd Samples/SimpleViewer
    $ make

    8.连接设备,执行例子

    $ cd Bin/x64-Release
    $ ./SimpleViewer
    无没有问题,则显示正常视图

    展开全文
  • 一.使用说明: 1.由于和astro版本不同,因此不能用OpenNI来显示 2.参考官网给的安装教程 ...二....1.安装依赖项 $ sudo apt install ros-$ROS_DISTRO-rgbd-launch ros-$ROS_DISTRO-libuvc ros-$ROS_DISTRO-libu...
  • 具体摄像头型号为 乐视三合一体感摄像头LeTMC-520 基本就是奥比中光 Orbbec Astra Pro 的换皮版 就连插在电脑上显示的设备名称都是 Astra Pro 2020年底 奥比中光宣布了与Opencv的合作 OpenCV增加对Astra
  • 奥比中光网络深度摄像头——人脸活体检测

    千次阅读 热门讨论 2018-08-09 17:40:52
    最近一直在研发一个新的项目:基于深度摄像头的人脸活体识别,采用的是奥比中光的Astra Pro相机。 基于奥比中光的官方SDK进行开发 得到如下文件 1.第一步,在彩色图中添加OpenCV人脸检测代码,得到人脸框的位置...
  • Astra pro深度相机是乐视与奥比中光合作的体感相机,对标微软Kinect,可用于三维重建,SLAM学习,也可以作为免驱UVC摄像头体感摄像头使用。 相机参数 二,Windows下直接使用OBNiViewer.exe这个exe来实现可视化 ...
  • 奥比中光深度感应器工作原理

    千次阅读 2017-03-09 14:24:26
    奥比中光深度感应器工作原理 Astra设备中3D深度感应模块所使用的技术称为光编码技术(Light Coding),这是一种 光学式技术。其本质就是产生一张红外激光编码图(IR Light Coding Image),透过红外线投影机打到...
  • 这款摄像头使用uvc输入彩色信息,需要libuvc和libuvc_ros这样才能在ROS正常使用彩色功能。 请在下面网址,分别下载对应包: 1、https://github.com/ktossell 2、https://orbbec3d.com/develop/ 也可以直接下载...
  • 搭建奥比中光3D摄像头运行环境1. 开发环境搭建2. Cmake环境3. SDK安装4. Debug项目4.1 进入“属性”菜单:4.2 添加包含目录:4.3 添加附加目录库4.4 添加附加依赖项4.5 添加DLL4.6 运行 因为导师的手部动态姿态项目...
  • USB3.0),第二个是乐视LeTV Pro Xtion(参数规格:深度有效距离:0.8m 至 3.5m,USB2.0),第三个是Orbbec Astr(参数规格:分辨率720p,深度有效距离:0.5 至 8m,USB2.0/USB3.0)这个s三个都是远距离的体感摄像头。...
  • ros与深度相机入门教程-在ROS使用奥比中光Orbbec Astra Pro ros与深度相机入门教程-在ROS使用奥比中光Orbbec Astra Pro 说明: 介绍如何在ros安装和使用奥比中光Orbbec Astra Pro OrbbecAstra介绍 ...
  • 这是一个新的方向,但是我还是理好思路再深入比较好...陆续都下载看了,还是按照以前的学习新的东西的方法,先试用,再Demo,再开发实现自己的需求。 试用 试用就是完全不写代码,使用调试工具之类的小软件来直...
  • Orbbec Astra Pro传感器在ROS(indigo和kinetic)使用说明 rgb depth同时显示这款摄像头使用uvc输入彩色信息,需要libuvc和libuvc_ros这样才能在ROS正常使用彩色功能。请在下面网址,分别下载对应包:1 ...
  • 其中,奥比中光为18 Pro提供了ToF一站式量产方案,通过软硬件相融合,辅助摄像头实现精准的深感对焦,让图像与视频呈现出渐进式的自然虚化效果,并使18 Pro成为一系列手机AR交互应用的“集大成者”。 △ 魅族发布5G...
  • PrimeSense是Kinect一代的芯片供应商,位于以色列,也是开源体感开发包OpenNI 的维护者。自从被 Apple 收购后,销声匿迹,OpenNI 也停止更新。现在可以从网站http://structure.io/openni下载到OpenNI 2 SDK和文档。 ...
  • 奥比中光(orbbec)更新了 中文3D视觉开发者社区 !前言 前言 笔者最近几天在使用乐视的体感摄像头,找到的官方网站都是这个:orbbec3d: https://orbbec3d.com/develop/,然后就通过这个网站上的 AstraSDK_Doc_en: ...
  • 该方案基于奥比中光高性能3D结构光摄像头模组与恩智浦高性能、低功耗MCU i.MX RT117F设计,可实现安全、可靠、高效的3D结构光人脸识别解锁。 基于新方案,智能门锁与其他门禁系统的开发人员可快速、轻松地在智慧...
  • 在3D传感芯片快速优化迭代的同时,奥比中光也加快了3D传感技术的商用落地步伐,如今,奥比中光Astra 3D摄像头已大规模应用于智能手机、新零售、智慧客厅等领域。例如,支付宝近日正式商用的刷脸支付设备采用的正是...
  • 奥比中光以“真3D智生活”为主题参展,带来一系列真3D结构光刷脸门锁解决方案;二十余家采用奥比中光方案的锁企门企也集体亮相,“霸屏”智能门锁主展区。 在建博会现场,奥比中光与智能门行业领军品牌德盾签约,...
  • 4月27日,3D视觉感知领域独角兽奥比中光在广东发布新品U2。 U2是什么?不是侦察机,而是一款小型化的3D刷脸模组,专门针对智能锁产品开发。从卡密锁、指纹锁到智能锁,门锁的解锁姿势在不断刷新技术高度。在追求极致...
  • 1. 开发环境 win10 Visual Studio 2019 2. 下载驱动与SDK Orbbec开发者中心 驱动下载 OpenNI2 SDK 3. 环境配置 3.1 OpenNI2 SDK压缩包结构 Samples - 例程 SDK - 软件开发工具包 tools - 一些可视化工具 3.2 ...
  • 从2D成像到3D视觉感知,机器获取的信息只增加了一个维度,但应用场景的想象空间,...奥比中光于2015年定制开发了公司第一代用于结构光3D视觉传感器的深度引擎芯片MX400,并于2017年、2018年推出了第二、第三代深度引擎芯片M
  • 3D 深度摄像头开发

    2016-01-08 16:34:22
    3D 深度摄像头开发
  • 近日,奥比中光在VALSE 2021(视觉与学习青年学者研讨会)上首次展示了公司自研的3D智能抠图算法。该算法专门为直播带货、视频会议等场景研发,可清晰地抠取杂乱背景下的3D人像与物品,吸引了众多青年学者与学子驻足...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 162
精华内容 64
关键字:

奥比中光摄像头开发