gige工业相机突破（二，c++实现）

调试通过别人的代码，gige 500万工业相机海康。

如果你下载了open gige vision 代码，你可以参考我下面的代码（可以打开相机并取像显示）：

  /* if(argc != 3)
      throw std::runtime_error(str(boost::format("Usage: %1% <ip> <port>") % argv[0]));*/

    GigEVision vis;

     //char ip[16];   
  //  wcstombs(ip, _T(argv[1]), sizeof(ip));
     //char port[16];   
  //  wcstombs(port, _T(argv[2]), sizeof(port));
      vis.Gvcp().Connect("192.168.20.54", "3956");//192.168.20.48本地客户端，链接相机192.168.20.54服务器端
    //  vis.Gvcp().Connect("169.254.0.2", "12221");//192.168.20.48本地，相机192.168.20.54服务器端
  //  vis.Gvcp().Connect(argv[1], argv[2]);
      std::string hello=vis.Gvcp().FindCam().to_string();//返回的是远端设备gige相机地址202403081043//
  //  std::cout << "Cam Addr: " << vis.Gvcp().FindCam().to_string() << std::endl;

     

    vis.GenICam().ReadXmlFile();
    vis.GenICam().PrintNodes();

    // format bool values as strings，通过字符串格式布尔值，这些字符串是通过读xml得到的，这里的字符串相当于命令，很像当年vc6.0打开关闭光驱的情形。202403111002
    std::cout.setf (std::ios::boolalpha);

以上代码最关键是，标红的，其他不重要。再看接下来：

//读相机width
    boost::array<uint8_t, 16> buff = {0x42, 0x01, 0x00, 0x80, 0x00, 0x04,
        0x00, 0x91, 0x00, 0x03, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf;
  boost::asio::ip::udp::endpoint sender_endpoint;
  if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf), sender_endpoint) == 12)
  {
       recv_buf[0] == 0x00;
        recv_buf[1] == 0x00;
         recv_buf[2] == 0x00;
          recv_buf[3] == 0x81;
           recv_buf[4] == 0x00;
            recv_buf[5] == 0x04;
       recv_buf[6] == 0x00;
       recv_buf[7] == 0x91;
        recv_buf[8] == 0x00;
         recv_buf[9] == 0x00;
          recv_buf[10] == 0x0a;
           recv_buf[11] == 0x20;
           //r如果返回如此，width=2592=registervalue=0x0a20
  }
  //读相机height
    boost::array<uint8_t, 16>
        buff1 = {0x42, 0x01, 0x00, 0x80, 0x00, 0x04,
        0x00, 0x92, 0x00, 0x03, 0x03, 0xa0, 0x00, 0x00, 0x00, 0x00};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff1), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf2;
 // boost::asio::ip::udp::endpoint sender_endpoint;
  if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf2), sender_endpoint) == 12)
  {
     
          recv_buf2[10] == 0x07;
           recv_buf2[11] == 0x98;
           //如果返回如此，width=1944=registervalue=0x0798
  }
   //读相机canshu offsetx?
    boost::array<uint8_t, 16>
        buff3 = {0x42, 0x01, 0x00, 0x80, 0x00, 0x04,
        0x00, 0x93, 0x00, 0x03, 0x03, 0x0e0, 0x00, 0x00, 0x00, 0x00};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff3), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf3;
//  boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf3), sender_endpoint) == 12)
  {
         recv_buf3[11] == 0;
           recv_buf3[10] == 0;
           //如果返回如此，offsetx=0=registervalue=0x00
    }
      //读相机canshu offsety?
    boost::array<uint8_t, 16>
        buff4 = {0x42, 0x01, 0x00, 0x80, 0x00, 0x04,
        0x00, 0x94, 0x00, 0x03, 0x04, 0x20, 0x00, 0x00, 0x00, 0x00};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff4), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf4;
//  boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf4), sender_endpoint) == 12)
  {
         recv_buf4[11] == 0;
           recv_buf4[10] == 0;
           //如果返回如此，offsety=0=registervalue=0x00
    }

      //读相机canshu pixformat?
    boost::array<uint8_t, 16>
        buff5 = {0x42, 0x01, 0x00, 0x80, 0x00, 0x04,
        0x00, 0x95, 0x00, 0x03, 0x06, 0x10, 0x00, 0x00, 0x00, 0x00};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff5), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf5;
 // boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf5), sender_endpoint) == 12)
  {
        recv_buf5[11] == 0x01;
           recv_buf5[10] == 0x00;
         recv_buf5[9] == 0x08;
           recv_buf5[8] == 0x01;
           //如果返回如此，pixformat=17301505=registervalue="mono8"=01080001
    }
    //初始化接受数组202403141044
    // rawBytes = new byte[Width * Height * bytesPerPixel];
    //xmlisloaded=true;IsStreaming=false;准备打开流通道,先要控制

     //开始控制，向寄存器写入
    boost::array<uint8_t, 16>
        buff6= {0x42, 0x01, 0x00, 0x80, 0x00, 0x04,
        0x01, 0x28, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff6), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf6;
 // boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf6), sender_endpoint) == 12)
  {
        recv_buf6[11] == 0x00;
           recv_buf6[10] == 0x00;
         recv_buf6[9] == 0x00;
           recv_buf6[8] == 0x00;
           //如果返回如此，its free can be control
    }

         //开始控制，向寄存器写入
    boost::array<uint8_t, 16>
        buff7= {0x42, 0x01, 0x00, 0x82, 0x00, 0x08,
        0x01, 0x29, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x02};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff7), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf7;
 // boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf7), sender_endpoint) == 12)
  {
        recv_buf7[11] == 0x01;
           recv_buf7[10] == 0x00;
         recv_buf7[9] == 0x00;
           recv_buf7[8] == 0x00;
           //如果返回如此， recv_buf7[11] == 0x01;开始设置心跳，循环5次，如果拒绝，进入心跳线程
    }

for(int i=0;i<5;i++)//怎样判断gvcpReply.status==success？如果在5次内设置成功了，就要跳出来
    {
        uint8_t hello=0x2d;
        boost::array<uint8_t, 16>
        buff8= {0x42, 0x01, 0x00, 0x82, 0x00, 0x08,
        0x01, hello, 0x00, 0x00, 0x09, 0x38, 0x00, 0x00, 0x27, 0x10};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff8), *vis.Gvcp().m_it);

      boost::array<uint8_t, 12> recv_buf8;
      vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf8), sender_endpoint);

      hello++;

      if(recv_buf8[11]==1)
      {
          //成功了？
          i=5;
          break;
      }
    }


    vis.Gvcp().StartHeartbeat();
      Sleep(10);

讲解：这些代码中和gige相机的互动最为关键，像极了一问一答。特别是心跳的正常运转（以前工程中与电控通信，老是觉得plc的心跳不重要，有怠慢，在此已经意识到，请包涵我的无知），继续代码：

    int iFd;//套接字
        //以下用winsock绑定套接字udp多播是ok的，暂时不用，注释
    struct sockaddr_in Addr;

if ((iFd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
        {
            printf("socket fail\n");
            //return -1;
        }

memset(&Addr, 0, sizeof(struct sockaddr_in));
    Addr.sin_family = AF_INET;

Addr.sin_addr.s_addr = inet_addr("192.168.20.48");//本地地址192.168.20.48
        Addr.sin_port = htons(63378);//多播的端口，端口用63378

 if (bind(iFd, (struct sockaddr *)&Addr, sizeof(Addr)) == -1)//绑定
    {
        printf("bind failed!\n");
    }
    else
    {
        printf("bind ok\n");
    }

 //开始控制，向寄存器写入GevSCPHostPort
    boost::array<uint8_t, 16>
        buff9= {0x42, 0x01, 0x00, 0x82, 0x00, 0x08,
        0x01, 0x2e, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0f7, 0x92};//写入端口port=63378
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff9), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf9;
 // boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf9), sender_endpoint) == 12)
  {
        recv_buf9[11] == 0x01;
         
           //如果返回如此， recv_buf9[11] == 0x01;GevSCPHostPort写入ok
    }

     //开始控制，向寄存器写入GevSCDA
    boost::array<uint8_t, 16>
        buff10= {0x42, 0x01, 0x00, 0x82, 0x00, 0x08,
        //0x01, 0x2f, 0x00, 0x00, 0x0d, 24, 239, 192, 11, 12};//使用多播地址
            0x01, 0x2f, 0x00, 0x00, 0x0d, 24, 192, 168, 20, 48};//多播地址？
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff10), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf10;
 // boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf10), sender_endpoint) == 12)
  {
        recv_buf10[11] == 0x01;
         
           //如果返回如此， recv_buf10[11] == 0x01;GevSCDA写入ok
    }

    /*  <Integer Name="ExposureTime_RegAddr">
    <Value>
      0x00030b04
    </Value>*/


boost::array<uint8_t, 16>
        buffex= {0x42, 0x01, 0x00, 0x82, 0x00, 0x08,
        0x03, 0x2f, 0x00, 0x03, 0x0b, 0x04,0,0,0x61,0x0a8};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buffex), *vis.Gvcp().m_it);

      boost::array<uint8_t, 12> recv_bufex;

       if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_bufex), sender_endpoint) == 12)
  {
        recv_bufex[11] == 0x01;
        //  if( recv_bufex[11] ==136&& recv_bufex[10] == 19)    //如果曝光值是5000，设置为25000=0x61，0x0a8      
        //  {
        //boost::array<uint8_t, 16>      buffex25000= {0x42, 0x01, 0x00, 0x80, 0x00, 0x04,
        //0x01, 0x30, 0x00, 0x03, 0x0b, 0x04,64,0,0x61,0x0a8};
     //vis.Gvcp().m_sock.send_to(boost::asio::buffer(buffex25000), *vis.Gvcp().m_it);
        //  }
       }


    bool mtu1500=false;
    //开始控制，向寄存器写入 var gevSCPSPacketSize = (await Gvcp.GetRegister(nameof(GvcpRegister.GevSCPSPacketSize))).pValue;//地址0x0d04
    boost::array<uint8_t, 16>
        buff11= {0x42, 0x01, 0x00, 0x80, 0x00, 0x04,
        0x01, 0x30, 0x00, 0x00, 0x0d, 0x04};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff11), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf11;
 // boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf11), sender_endpoint) == 12)
  {
        recv_buf11[11] == 220;//0x0dc
           recv_buf11[10] == 5;//代表mtu=1500,这是读到寄存器gevSCPSPacketSize的值
           //如果返回如此， recv_buf11[10] == 0x1f(31); recv_buf11[11] == 0xe4(228);代表mtu=8164,gevSCPSPacketSize 这是读到寄存器gevSCPSPacketSize的值

           if( recv_buf11[11] == 220&& recv_buf11[10] == 5)
           {
               mtu1500=true;
           }
    }

    if(mtu1500)
    {
                boost::array<uint8_t, 16>
            //buff8136= {0x42, 0x01, 0x00, 0x82, 0x00, 0x08,
            //0x01, 0x31, 0x00, 0x00, 0x0d,  0x04, 64, 0, 0x1f, 0x0c8};//8136
            buff8136= {0x42, 0x01, 0x00, 0x82, 0x00, 0x08,
            0x01, 0x31, 0x00, 0x00, 0x0d,  0x04, 64, 0, 0x1f, 0x0e4};//8164
                vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff8136), *vis.Gvcp().m_it);

    }

//开始控制，向寄存器写入  acquisitionStart.SetValueAsync(1).ConfigureAwait(false)) as GvcpReply
    boost::array<uint8_t, 16>
        buff12= {0x42, 0x01, 0x00, 0x82, 0x00, 0x08,
        0x01, 0x32, 0x00, 0x03, 0x08, 4, 0, 0, 0, 1};
     vis.Gvcp().m_sock.send_to(boost::asio::buffer(buff12), *vis.Gvcp().m_it);
      boost::array<uint8_t, 12> recv_buf12;
 // boost::asio::ip::udp::endpoint sender_endpoint;
    if(vis.Gvcp().m_sock.receive_from(boost::asio::buffer(recv_buf12), sender_endpoint) == 12)
  {//这个在c#范例中化的时间很长，写寄存器开始acquisitionStart
        recv_buf12[11] == 0x01;
         //0 0 0 131 0 4 1 50 0 0 0 1
           //如果返回如此， recv_buf12[11] == 0x01;acquisitionStart 写入ok
    }

到这里，程序已经成功了，后面是读出图像并显示的过程，linux的第三方gil包和socket未达到预期，全部注释掉了。全部使用windows的东东，在通信和显示图像上。

   // 接收数据
               char buffer[9000];
              int len = sizeof(buffer);
              sockaddr_in from;
              int fromlen = sizeof(from);

             //   recvfrom(iFd, buffer, len, 0, (SOCKADDR*)&from, &fromlen);//应该有接受异常保护机制，这里如果异常，要继续向下达成202403181431

      //  GvspInfo.IsDecodingAsVersion2 = ((buffer[4] & 0xF0) >> 4) == 8;
            

                struct gvspinfo stu;//方式

            /*    if( ((buffer[4] & 0xF0) >> 4) != 8)
                {*/
                    stu.      BlockIDIndex =  2;
                    stu.    BlockIDLength =  2;
                    stu.    PacketIDIndex =  6;
                    stu.    PayloadOffset =  8;
                    stu.    TimeStampIndex = 12;
                    stu.    DataIdentifier = 0x03;
                    stu.    DataEndIdentifier =  0x02;
                //}else
                //{
                //    // GvspInfo.SetDecodingTypeParameter();
                //    stu.      BlockIDIndex =  8 ;
                //    stu.    BlockIDLength =  8 ;
                //    stu.    PacketIDIndex =  18 ;
                //    stu.    PayloadOffset =  20 ;
                //    stu.    TimeStampIndex =  24 ;
                //    stu.    DataIdentifier = 0x83 ;
                //    stu.    DataEndIdentifier =  0x82 ;
                //}
int packetID=-1;


 int frame=1;
  int jishu=-1;
  uint16_t nPartOfFrame=0;//一帧有619个8136
 //  uint16_t ceshi=0;
  COPYDATASTRUCT cds;

   uint8_t** buffer2 = new uint8_t*[2];

 /*  buffer2[0] = new char[stu.RawImageSize];
 buffer2[1] = new char[stu.RawImageSize];*/
     buffer2[0] = new uint8_t[2592*1944];
 buffer2[1] = new uint8_t[5038848];

 int  jiou=1;


 vis.Gvsp(). m_img.recreate(2592, 1944);

 recvfrom(iFd, buffer, 9000, 0, (SOCKADDR*)&Addr, &fromlen);
 nPartOfFrame = ntohs(((uint16_t*)&buffer)[3]);
    if(0==nPartOfFrame)
for(;;)
    
{

    int changdu=    recvfrom(iFd, buffer, 9000, 0, (SOCKADDR*)&Addr, &fromlen);//1472要不要也写一个分支处理程序？202403210919

    if(changdu==8164)
    {
    nPartOfFrame = ntohs(((uint16_t*)&buffer)[3]);//不进来，说明虽然设置8164，但实质只有8136收到buffer20240323
    }

    if(changdu!=8136)
        {
            std::cout<< "\recvpacketlenth: " << changdu<< "\frame: " << nPartOfFrame   <<std::endl;

//没有看到0包，说明0包没用202403311428
    continue;
    }
    if (changdu==8136)
    {

 nPartOfFrame = ntohs(((uint16_t*)&buffer)[3]);

      jiou=    frame%2;

            int zhenshidenPartOfFrame= ( nPartOfFrame-1)%619;

            if(jiou==1)
            {
                /* std::copy(std::begin(buffer)+8, std::end(buffer),   buffer2[1]+ zhenshidenPartOfFrame*8128);*/
                 std::copy(std::begin(buffer)+8, std::begin(buffer)+8136,   buffer2[1]+ zhenshidenPartOfFrame*8128);
                // std::copy(std::begin(buffer)+8, std::end(buffer)+8136,    view(vis.Gvsp().m_img).begin()+ zhenshidenPartOfFrame*8128);//太慢，应该丢失太多
            //     std::copy(std::begin(buffer)+8, std::end(buffer)+8136,   vis.Gvsp(). m_buffBIG.begin()+ zhenshidenPartOfFrame*8128);//速度可以

                //还是copydata好202403201554
            }
            else
            {
                 std::copy(std::begin(buffer)+8, std::begin(buffer)+8136,   buffer2[0]+ zhenshidenPartOfFrame*8128);
                /* std::copy(std::begin(buffer)+8, std::end(buffer),   buffer2[0]+ zhenshidenPartOfFrame*8128);*/

            }

            if(618==zhenshidenPartOfFrame)
            {

                frame++;

    cds.dwData=0;
                cds.cbData=5038848;//一帧500万像素
                //cds.cbData=4096;//一帧500万像素


                cds.lpData= buffer2[1];//这样写可以吗？

                if(jiou==0)
                    {
                        cds.lpData= buffer2[0];
                }


                //    cds.lpData=(PVOID)hdr->lpData;
                //    ::SendMessage(hWnd,WM_COPYDATA,NULL,(LPARAM)&cds);
                HWND hWnd=    ::    FindWindow(NULL,L"arrimg");//(LPCSTR),可以利用收声音的c#程序，现成的
                //HWND hWnd=    ::FindWindow(NULL,(LPCSTR)"arrimg");
                ::SendMessage(hWnd,WM_COPYDATA,NULL,(LPARAM)&cds);
            }

    }
}

最后加红的代码，是用sendmessage把图像丢出去，使用windows的WM_COPYDATA消息。

这个方法简单，如果你能存储数据流，像gil的png方式，存几幅图也是可以的，我试了，也是ok的。

要搞定，沉下心来，持之以恒。我可能讲的东西容量太大，你不要指望很快掌握，我吃不好，睡不好，花了整整一个月时间研究，针对这件事情，这还是在有图可希冀的情况下。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/607085.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【ETAS CP AUTOSAR工具链】RTA-OS基本概念与开发流程

【ETAS CP AUTOSAR工具链】RTA-OS基本概念与开发流程

RTA-OS基于早期ETAS操作系统的成熟技术&#xff0c;迄今为止&#xff0c;已在全球超过3.5亿个ECU中使用。RTA-OS是一个可静态配置的抢占式实时操作系统(RTOS)&#xff0c;它常被用于资源受限但有着高性能要求的方案中。内核的实现不仅遵循了AUTOSAR R3.x、R4.0、R4.1、R4.2、R4…
阅读更多...
【stomp 实战】spring websocket 接收消息源码分析

【stomp 实战】spring websocket 接收消息源码分析

后台消息的发送过程&#xff0c;我们通过spring websocket用户消息发送源码分析已经了解了。我们再来分析一下后端接收消息的过程。这个过程和后端发送消息过程有点类似。 前端发送消息 前端发送消息给服务端的示例如下&#xff1a; 发送给目的/app/echo一个消息。 //主动发…
阅读更多...
英码科技推出昇腾系列AI加速卡：专为视频解析与模型推理场景打造，更具成本竞争力！

英码科技推出昇腾系列AI加速卡：专为视频解析与模型推理场景打造，更具成本竞争力！

当前&#xff0c;人工智能的发展已进入加速渗透千行百业的阶段&#xff0c;算力已然成为数字化转型关键的新质生产力。随着国际挑战的加剧&#xff0c;国产算力的发展趋势愈发明显&#xff0c;市场需求也呈现出激增的态势。在这一大背景下&#xff0c;华为昇腾以其强大的技术实…
阅读更多...
GaussianBody：基于3D高斯散射的服装人体重建

GaussianBody：基于3D高斯散射的服装人体重建

GaussianBody: Clothed Human Reconstruction via 3d Gaussian Splatting GaussianBody&#xff1a;基于3D高斯散射的服装人体重建 Mengtian Li1,2,3, Shengxiang Yao1, Zhifeng Xie1,3,2, Keyu Chen4,2, Yu-Gang Jiang2 李梦田 1,2,3 、姚胜祥 1 、谢志峰 1,3, 2 、陈科宇 4, …
阅读更多...
谷歌开源！用 js 编写 Shell 脚本！ | 开源日报 No.247

谷歌开源！用 js 编写 Shell 脚本！ | 开源日报 No.247

google/zx Stars: 41.4k License: Apache-2.0 zx 是一个用于编写更好脚本的工具。 提供有用的包装器&#xff0c;简化了对 child_process 的操作转义参数并提供合理的默认值使用 JavaScript 编写复杂脚本时比 Bash 更方便可以直接使用 npm 安装 dani-garcia/vaultwarden St…
阅读更多...
长难句打卡5.9

长难句打卡5.9

For example, the Long Now Foundation has as its flagship project a mechanical clock that is designed to still be marking time thousands of years hence. 例如,今日永存资金会将机械钟表视为旗舰项目,因此该钟表旨在为未来几千年保持计时。 Foundation n.基金会flag…
阅读更多...
数据库（MySQL）—— 索引

数据库（MySQL）—— 索引

数据库&#xff08;MySQL&#xff09;—— 索引 什么是索引创建索引使用 CREATE INDEX 语句使用 ALTER TABLE 语句在创建表时定义索引特殊类型索引注意事项 举个例子无索引的情况有索引的情况为什么索引快索引的结构 今天我们来看看MySQL中的索引&#xff1a; 什么是索引 MyS…
阅读更多...
unity基础(一)

unity基础(一)

内容概要&#xff1a; 生命周期函数vector3 位置 方向 缩放旋转等信息Vector3欧拉角和Quaternion四元素unity脚本执行顺序设置 一 生命周期函数 方法说明Awake最早调用,所以一般可以再此实现单例模式OnEnable组件激活后调用,在Awake后会调用一次Start在Update之前调用一次&a…
阅读更多...
硬件知识积累 音频插座的了解，看音频插座的原理图来了解音频插座的引脚。

硬件知识积累 音频插座的了解，看音频插座的原理图来了解音频插座的引脚。

1. 音频接口 音频插座是一种用于连接音频信号线路的电子元件&#xff0c;常见于音频设备&#xff08;如音响、耳机、话筒等&#xff09;中。它的主要作用是将电子信号转化为声音信号&#xff0c;以满足人们对于音乐、电影、游戏等方面的需求。 根据插头形状的不同&#xff0c;音…
阅读更多...
和comate一起，用JavaScript实现一个简易版五子棋小游戏

和comate一起，用JavaScript实现一个简易版五子棋小游戏

前言 五子棋起源于中国&#xff0c;是全国智力运动会竞技项目之一&#xff0c;是一种两人对弈的纯策略型棋类游戏。双方分别使用黑白两色的棋子&#xff0c;下在棋盘直线与横线的交叉点上&#xff0c;先形成五子连珠者获胜。 这次和Baidu Comate智能代码助手共同完成这个小游戏…
阅读更多...
[华为OD] C卷 田忌赛马 DFS 200

[华为OD] C卷 田忌赛马 DFS 200

题目&#xff1a; 给定两个只包含数字的数组a, b,调整数组a里面数字的顺序&#xff0c;使得尽可能多的a[i] >b[i]。 数组a和b中的数字各不相同。 输出所有可以达到最优结果的a数组的数量 输入描述 输入的第一行是数组a中的数字&#xff0c;其中只包含数字&#xff0c;每…
阅读更多...
LVS DR模式部署

LVS DR模式部署

一、LVS 简介 LVS的三种工作模式 NAT 地址转换 调度器会作为所有节点服务器的默认网关&#xff0c;也是客户端的访问入口和节点服务器返回响应消息的出口&#xff0c;所以调度器会承载双向流量的负载压力&#xff0c;可能会为整个群集的性能瓶颈。由于节点服务器都会处于内网…
阅读更多...
AcWing 4993 FEB

AcWing 4993 FEB

4993. FEB - AcWing题库 大佬亲笔 将原串分成三段&#xff1a; FFF|E.....B|FFF 先合并中间段&#xff0c;再合并两边的段 #include <iostream> #include <cstring> #include <algorithm> #include <string> #include <queue&g…
阅读更多...
Eclipse下载安装教程（包含JDK安装）【保姆级教学】【2023.10月最新版】

Eclipse下载安装教程（包含JDK安装）【保姆级教学】【2023.10月最新版】

目录 文章最后附下载链接 第一步&#xff1a;下载Eclipse&#xff0c;并安装 第二步&#xff1a;下载JDK&#xff0c;并安装 第三步&#xff1a;Java运行环境配置 安装Eclipse必须同时安装JDK &#xff01;&#xff01;&#xff01; 文章最后附下载链接 第一步&#xf…
阅读更多...
ES:聚合查询语法

ES:聚合查询语法

基础查询结构&#xff1a; GET http://ip:prot/textbook/_search { "query" : { ...query子句... }, "aggs" : { "agg_name":{ "agg_type": { "agg_arg": agg_arg_value } } }, "sort" : { ..sor…
阅读更多...
快速学习Python：新手入门指南

快速学习Python：新手入门指南

一、确定学习目标 首先&#xff0c;你需要明确自己学习Python的目标。是希望成为一名Python开发人员&#xff0c;还是仅仅想在数据分析、数据可视化等领域使用Python。不同的目标需要不同的学习路径和资源。 二、选择合适的教材和课程 Python的学习资源非常丰富&#xff0c;…
阅读更多...
vscode 使用正则搜索

vscode 使用正则搜索

ctrl c 复制&#xff0c;内容如下&#xff1a; Vue3简介创建Vue3工程Vue3核心语法路由pinia组件通信其它 APIVue3新组件
阅读更多...
HDLbits 刷题 -- Exams/m2014 q3

HDLbits 刷题 -- Exams/m2014 q3

Consider the function f shown in the Karnaugh map below. Implement this function. d is dont-care, which means you may choose to output whatever value is convenient. 译&#xff1a;考虑下面卡诺图中显示的函数f。 实现这个函数。D是dont-care&#xff0c;这意味着…
阅读更多...
别再观望！2024年必做的项目：视频号无货源

别再观望！2024年必做的项目：视频号无货源

大家好&#xff0c;我是电商花花。 现在做项目&#xff0c;更喜欢的是一个能稳定出单&#xff0c;稳定发展的一个创业项目&#xff0c;一个好的项目就是能长期稳定的发展&#xff0c;如果只追求短平快收益的项目&#xff0c;这样的项目也并不适合我们。 对于越来越火爆的视频…
阅读更多...
MoviePy（Python音视频开发）

MoviePy（Python音视频开发）

音视频基础帧率、码率、分辨率视频格式H.264和H.265视频压缩算法 Moviepy常见剪辑类VideoFlieClipImageFlieClipColorClipTextClipCompositeVideoClipAudioFlieClipCompositeAudioClip 常见操作音视频的读入与导出截取音视频 音视频基础 帧率、码率、分辨率 体积&#xff08;V…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站