openh264 中背景检测功能源码分析

文件位置

  • openh264/codec/processing/src/BackgroundDetection.cpp

代码流程

在这里插入图片描述

  • 核心函数
    • 从代码流程可以看到实现背景检测的核心功能主要是CBackgroundDetection类中ForegroundBackgroundDivision函数和ForegroundDilationAndBackgroundErosion函数。

原理

  • 参数开关控制：(bool)bEnableBackgroundDetection

ForegroundBackgroundDivision 函数

  1. 功能：前景和背景粗略区分
  2. 原理过程：
  • 计算以宏块为单位的图像宽iPicWidthInOU和高iPicHeightInOU；
  • 计算每行的宏块个数iPicWidthInMb；
  • 声明并初始化指向Background OU数组的指针，该数组内部是宏块级OU 的数据信息；
  • 双层for 循环遍历所有宏块级 OU单元；
    • 调用GetOUParameters函数获取 OU 参数，主要是iSD、iSAD、ISD、iMAD、iMinSubMad、iMaxDiffSubSd；
    • 当前 OU背景标志iBackgroundFlag赋值 0；
    • 如果当前OU的平均绝对偏差（Mean Absolute Difference,MAD）大于63，则跳过当前OU；移动到下一个 OU；
    • 如果当前 OU 的iMaxDiffSubSd小于等于iSAD / 8或者iMaxDiffSubSd小于等于16x8，且iSAD小于2x16x16x2；
      • 如果iSAD小于16*8，则当前OU背景标志iBackgroundFlag 赋值 1；
      • 否则，当前OU背景标志iBackgroundFlag 的计算公式如下：
        • 如果当前 OU 的iSAD 小于2x16x16，判断当前 OU 的iSD是否小于iSADx3 / 4，将大小关系结果赋值给iBackgroundFlag；
        • 否则，判断当前 OU 的iSDx2 是否小于当前 OU 的iSAD，将大小关系结果赋值给iBackgroundFlag；
    • 移动到下一个宏块级OU；
  1. 原理图：
    在这里插入图片描述
  2. 相关源码：
  • ForegroundBackgroundDivision函数
void CBackgroundDetection::ForegroundBackgroundDivision (vBGDParam* pBgdParam) {
  int32_t iPicWidthInOU         = pBgdParam->iBgdWidth  >> LOG2_BGD_OU_SIZE;
  int32_t iPicHeightInOU        = pBgdParam->iBgdHeight >> LOG2_BGD_OU_SIZE;
  int32_t iPicWidthInMb         = (15 + pBgdParam->iBgdWidth) >> 4;

  SBackgroundOU* pBackgroundOU = pBgdParam->pOU_array;

  for (int32_t j = 0; j < iPicHeightInOU; j ++) {
    for (int32_t i = 0; i < iPicWidthInOU; i++) {
      GetOUParameters (pBgdParam->pCalcRes, (j * iPicWidthInMb + i) << (LOG2_BGD_OU_SIZE - LOG2_MB_SIZE), iPicWidthInMb,
                       pBackgroundOU);

      pBackgroundOU->iBackgroundFlag = 0;
      if (pBackgroundOU->iMAD > 63) {
        pBackgroundOU++;
        continue;
      }
      if ((pBackgroundOU->iMaxDiffSubSd <= pBackgroundOU->iSAD >> 3
           || pBackgroundOU->iMaxDiffSubSd <= (BGD_OU_SIZE * Q_FACTOR))
          && pBackgroundOU->iSAD < (BGD_THD_SAD << 1)) { //BGD_OU_SIZE*BGD_OU_SIZE>>2
        if (pBackgroundOU->iSAD <= BGD_OU_SIZE * Q_FACTOR) {
          pBackgroundOU->iBackgroundFlag = 1;
        } else {
          pBackgroundOU->iBackgroundFlag = pBackgroundOU->iSAD < BGD_THD_SAD ?
                                           (pBackgroundOU->iSD < (pBackgroundOU->iSAD * 3) >> 2) :
                                           (pBackgroundOU->iSD << 1 < pBackgroundOU->iSAD);
        }
      }
      pBackgroundOU++;
    }
  }
}
  • GetOUParameters函数
void CBackgroundDetection::GetOUParameters (SVAACalcResult* sVaaCalcInfo, int32_t iMbIndex, int32_t iMbWidth,
    SBackgroundOU* pBgdOU) {
  int32_t       iSubSD[4];
  uint8_t       iSubMAD[4];
  int32_t       iSubSAD[4];

  uint8_t (*pMad8x8)[4];
  int32_t (*pSad8x8)[4];
  int32_t (*pSd8x8)[4];

  pSad8x8 = sVaaCalcInfo->pSad8x8;
  pMad8x8 = sVaaCalcInfo->pMad8x8;
  pSd8x8  = sVaaCalcInfo->pSumOfDiff8x8;

  iSubSAD[0] = pSad8x8[iMbIndex][0];
  iSubSAD[1] = pSad8x8[iMbIndex][1];
  iSubSAD[2] = pSad8x8[iMbIndex][2];
  iSubSAD[3] = pSad8x8[iMbIndex][3];

  iSubSD[0] = pSd8x8[iMbIndex][0];
  iSubSD[1] = pSd8x8[iMbIndex][1];
  iSubSD[2] = pSd8x8[iMbIndex][2];
  iSubSD[3] = pSd8x8[iMbIndex][3];

  iSubMAD[0] = pMad8x8[iMbIndex][0];
  iSubMAD[1] = pMad8x8[iMbIndex][1];
  iSubMAD[2] = pMad8x8[iMbIndex][2];
  iSubMAD[3] = pMad8x8[iMbIndex][3];

  pBgdOU->iSD   = iSubSD[0] + iSubSD[1] + iSubSD[2] + iSubSD[3];
  pBgdOU->iSAD  = iSubSAD[0] + iSubSAD[1] + iSubSAD[2] + iSubSAD[3];
  pBgdOU->iSD   = WELS_ABS (pBgdOU->iSD);

  // get the max absolute difference (MAD) of OU and min value of the MAD of sub-blocks of OU
  pBgdOU->iMAD = WELS_MAX (WELS_MAX (iSubMAD[0], iSubMAD[1]), WELS_MAX (iSubMAD[2], iSubMAD[3]));
  pBgdOU->iMinSubMad = WELS_MIN (WELS_MIN (iSubMAD[0], iSubMAD[1]), WELS_MIN (iSubMAD[2], iSubMAD[3]));

  // get difference between the max and min SD of the SDs of sub-blocks of OU
  pBgdOU->iMaxDiffSubSd = WELS_MAX (WELS_MAX (iSubSD[0], iSubSD[1]), WELS_MAX (iSubSD[2], iSubSD[3])) -
                          WELS_MIN (WELS_MIN (iSubSD[0], iSubSD[1]), WELS_MIN (iSubSD[2], iSubSD[3]));
}

ForegroundDilationAndBackgroundErosion 函数

  1. 功能：前景膨胀和背景腐蚀
  2. 函数关系图：
    在这里插入图片描述
  3. 过程：
  • 定义iPicStrideUV变量存储 图像UV 分量步长；
  • 计算宏块级OU 的宽iPicWidthInOU和高iPicHeightInOU；
  • 计算宏块级OU 的 UV 步长iOUStrideUV；
  • 计算每行宏块个数iPicWidthInMb；
  • 定义了一个指向SBackgroundOU结构体的指针pBackgroundOU，用来访问背景检测单元数组；
  • 定义了一个指向int8_t的指针pVaaBackgroundMbFlag，用来访问背景宏块标志数组；
  • 定义了一个长度为4的指针数组pOUNeighbours，用来存储当前OU的四个邻居OU的指针；
  • 将pOUNeighbours[2]（即顶部OU）初始化为pBackgroundOU；
  • 外层 for 循环 遍历每一列宏块级OU；
    • 初始化pRowSkipFlag指针，指向当前行的宏块标志；
    • 初始化 pOUNeighbours[0] （左OU） 为pBackgroundOU；
    • 计算pOUNeighbours[3]（底OU）；
    • 内存 for 循环遍历每一行宏块级OU；
      • 计算pOUNeighbours[1]（即右OU）;
      • 如果当前 OU pBackgroundOU的iBackgroundFlag为真；
        • 调用ForegroundDilation函数进行前景膨胀；
      • 否则；
        • 调用BackgroundErosion函数进行背景腐蚀；
      • 调用UpperOUForegroundCheck函数检测上方 OU是否为前景；
      • 调用SetBackgroundMbFlag函数设置背景宏块标志；
      • 更新pRowSkipFlag，pOUNeighbours、pBackgroundOU为下一个 宏块级OU 做准备；
    • 更新pOUNeighbours[2]和pVaaBackgroundMbFlag指针，为下一行OU的处理做准备。
  1. 原理图：
    在这里插入图片描述
  2. 相关源码：
  • ForegroundDilationAndBackgroundErosion函数
void CBackgroundDetection::ForegroundDilationAndBackgroundErosion (vBGDParam* pBgdParam) {
  int32_t iPicStrideUV          = pBgdParam->iStride[1];
  int32_t iPicWidthInOU         = pBgdParam->iBgdWidth  >> LOG2_BGD_OU_SIZE;
  int32_t iPicHeightInOU        = pBgdParam->iBgdHeight >> LOG2_BGD_OU_SIZE;
  int32_t iOUStrideUV           = iPicStrideUV << (LOG2_BGD_OU_SIZE - 1);
  int32_t iPicWidthInMb         = (15 + pBgdParam->iBgdWidth) >> 4;

  SBackgroundOU* pBackgroundOU = pBgdParam->pOU_array;
  int8_t*        pVaaBackgroundMbFlag = (int8_t*)pBgdParam->pBackgroundMbFlag;
  SBackgroundOU* pOUNeighbours[4];//0: left; 1: right; 2: top; 3: bottom

  pOUNeighbours[2]      = pBackgroundOU;//top OU
  for (int32_t j = 0; j < iPicHeightInOU; j ++) {
    int8_t* pRowSkipFlag = pVaaBackgroundMbFlag;
    pOUNeighbours[0]    = pBackgroundOU;//left OU
    pOUNeighbours[3]    = pBackgroundOU + (iPicWidthInOU & ((j == iPicHeightInOU - 1) - 1)); //bottom OU
    for (int32_t i = 0; i < iPicWidthInOU; i++) {
      pOUNeighbours[1] = pBackgroundOU + (i < iPicWidthInOU - 1); //right OU

      if (pBackgroundOU->iBackgroundFlag)
        ForegroundDilation (pBackgroundOU, pOUNeighbours, pBgdParam, j * iOUStrideUV + (i << LOG2_BGD_OU_SIZE_UV));
      else
        BackgroundErosion (pBackgroundOU, pOUNeighbours);

      // check the up OU
      if (j > 1 && i > 0 && i < iPicWidthInOU - 1 && pOUNeighbours[2]->iBackgroundFlag == 1) {
        UpperOUForegroundCheck (pOUNeighbours[2], pRowSkipFlag - OU_SIZE_IN_MB * iPicWidthInMb, iPicWidthInOU, iPicWidthInMb);
      }

      SetBackgroundMbFlag (pRowSkipFlag, iPicWidthInMb, pBackgroundOU->iBackgroundFlag);

      // preparation for the next OU
      pRowSkipFlag += OU_SIZE_IN_MB;
      pOUNeighbours[0] = pBackgroundOU;
      pOUNeighbours[2]++;
      pOUNeighbours[3]++;
      pBackgroundOU++;
    }
    pOUNeighbours[2]      = pBackgroundOU - iPicWidthInOU;
    pVaaBackgroundMbFlag += OU_SIZE_IN_MB * iPicWidthInMb;
  }
}
  • ForegroundDilation函数
inline void CBackgroundDetection::ForegroundDilation (SBackgroundOU* pBackgroundOU, SBackgroundOU* pOUNeighbours[],
    vBGDParam* pBgdParam, int32_t iChromaSampleStartPos) {
  int32_t iPicStrideUV = pBgdParam->iStride[1];
  int32_t iSumNeighBackgroundFlags = pOUNeighbours[0]->iBackgroundFlag + pOUNeighbours[1]->iBackgroundFlag +
                                      pOUNeighbours[2]->iBackgroundFlag + pOUNeighbours[3]->iBackgroundFlag;

  if (pBackgroundOU->iSAD > BGD_OU_SIZE * Q_FACTOR) {
    switch (iSumNeighBackgroundFlags) {
    case 0:
    case 1:
      pBackgroundOU->iBackgroundFlag = 0;
      break;
    case 2:
    case 3:
      pBackgroundOU->iBackgroundFlag = !ForegroundDilation23Luma (pBackgroundOU, pOUNeighbours);

      // chroma component check
      if (pBackgroundOU->iBackgroundFlag == 1) {
        int8_t iNeighbourForegroundFlags = (!pOUNeighbours[0]->iBackgroundFlag) | ((!pOUNeighbours[1]->iBackgroundFlag) << 1)
                                            | ((!pOUNeighbours[2]->iBackgroundFlag) << 2) | ((!pOUNeighbours[3]->iBackgroundFlag) << 3);
        pBackgroundOU->iBackgroundFlag = !ForegroundDilation23Chroma (iNeighbourForegroundFlags, iChromaSampleStartPos,
                                         iPicStrideUV, pBgdParam);
      }
      break;
    default:
      break;
    }
  }
}
  • BackgroundErosion函数
inline void CBackgroundDetection::BackgroundErosion (SBackgroundOU* pBackgroundOU, SBackgroundOU* pOUNeighbours[]) {
  if (pBackgroundOU->iMaxDiffSubSd <= (BGD_OU_SIZE * Q_FACTOR)) { //BGD_OU_SIZE*BGD_OU_SIZE>>2
    int32_t iSumNeighBackgroundFlags = pOUNeighbours[0]->iBackgroundFlag + pOUNeighbours[1]->iBackgroundFlag +
                                       pOUNeighbours[2]->iBackgroundFlag + pOUNeighbours[3]->iBackgroundFlag;
    int32_t sumNbrBGsad = (pOUNeighbours[0]->iSAD & (-pOUNeighbours[0]->iBackgroundFlag)) + (pOUNeighbours[2]->iSAD &
                          (-pOUNeighbours[2]->iBackgroundFlag))
                          + (pOUNeighbours[1]->iSAD & (-pOUNeighbours[1]->iBackgroundFlag)) + (pOUNeighbours[3]->iSAD &
                              (-pOUNeighbours[3]->iBackgroundFlag));
    if (pBackgroundOU->iSAD * iSumNeighBackgroundFlags <= (3 * sumNbrBGsad) >> 1) {
      if (iSumNeighBackgroundFlags == 4) {
        pBackgroundOU->iBackgroundFlag = 1;
      } else {
        if ((pOUNeighbours[0]->iBackgroundFlag & pOUNeighbours[1]->iBackgroundFlag)
            || (pOUNeighbours[2]->iBackgroundFlag & pOUNeighbours[3]->iBackgroundFlag)) {
          pBackgroundOU->iBackgroundFlag = !ForegroundDilation23Luma (pBackgroundOU, pOUNeighbours);
        }
      }
    }
  }
}
  • UpperOUForegroundCheck函数
inline void CBackgroundDetection::UpperOUForegroundCheck (SBackgroundOU* pCurOU, int8_t* pBackgroundMbFlag,
    int32_t iPicWidthInOU, int32_t iPicWidthInMb) {
  if (pCurOU->iSAD > BGD_OU_SIZE * Q_FACTOR) {
    SBackgroundOU* pOU_L = pCurOU - 1;
    SBackgroundOU* pOU_R = pCurOU + 1;
    SBackgroundOU* pOU_U = pCurOU - iPicWidthInOU;
    SBackgroundOU* pOU_D = pCurOU + iPicWidthInOU;
    if (pOU_L->iBackgroundFlag + pOU_R->iBackgroundFlag + pOU_U->iBackgroundFlag + pOU_D->iBackgroundFlag <= 1) {
      SetBackgroundMbFlag (pBackgroundMbFlag, iPicWidthInMb, 0);
      pCurOU->iBackgroundFlag = 0;
    }
  }
}
  • ForegroundDilation23Luma函数
inline bool CBackgroundDetection::ForegroundDilation23Luma (SBackgroundOU* pBackgroundOU,
    SBackgroundOU* pOUNeighbours[]) {
  SBackgroundOU* pOU_L = pOUNeighbours[0];
  SBackgroundOU* pOU_R = pOUNeighbours[1];
  SBackgroundOU* pOU_U = pOUNeighbours[2];
  SBackgroundOU* pOU_D = pOUNeighbours[3];

  if (pBackgroundOU->iMAD > pBackgroundOU->iMinSubMad << 1) {
    int32_t iMaxNbrForegroundMad;
    int32_t iMaxNbrBackgroundMad;
    int32_t aBackgroundMad[4];
    int32_t aForegroundMad[4];

    aForegroundMad[0] = (pOU_L->iBackgroundFlag - 1) & pOU_L->iMAD;
    aForegroundMad[1] = (pOU_R->iBackgroundFlag - 1) & pOU_R->iMAD;
    aForegroundMad[2] = (pOU_U->iBackgroundFlag - 1) & pOU_U->iMAD;
    aForegroundMad[3] = (pOU_D->iBackgroundFlag - 1) & pOU_D->iMAD;
    iMaxNbrForegroundMad = WELS_MAX (WELS_MAX (aForegroundMad[0], aForegroundMad[1]), WELS_MAX (aForegroundMad[2],
                                     aForegroundMad[3]));

    aBackgroundMad[0] = ((!pOU_L->iBackgroundFlag) - 1) & pOU_L->iMAD;
    aBackgroundMad[1] = ((!pOU_R->iBackgroundFlag) - 1) & pOU_R->iMAD;
    aBackgroundMad[2] = ((!pOU_U->iBackgroundFlag) - 1) & pOU_U->iMAD;
    aBackgroundMad[3] = ((!pOU_D->iBackgroundFlag) - 1) & pOU_D->iMAD;
    iMaxNbrBackgroundMad = WELS_MAX (WELS_MAX (aBackgroundMad[0], aBackgroundMad[1]), WELS_MAX (aBackgroundMad[2],
                                     aBackgroundMad[3]));

    return ((iMaxNbrForegroundMad > pBackgroundOU->iMinSubMad << 2) || (pBackgroundOU->iMAD > iMaxNbrBackgroundMad << 1
            && pBackgroundOU->iMAD <= (iMaxNbrForegroundMad * 3) >> 1));
  }
  return 0;
}
  • ForegroundDilation23Chroma函数
inline bool CBackgroundDetection::ForegroundDilation23Chroma (int8_t iNeighbourForegroundFlags,
    int32_t iStartSamplePos, int32_t iPicStrideUV, vBGDParam* pBgdParam) {
  static const int8_t kaOUPos[4]        = {OU_LEFT, OU_RIGHT, OU_TOP, OU_BOTTOM};
  int32_t       aEdgeOffset[4]          = {0, BGD_OU_SIZE_UV - 1, 0, iPicStrideUV* (BGD_OU_SIZE_UV - 1)};
  int32_t       iStride[4]              = {iPicStrideUV, iPicStrideUV, 1, 1};

  // V component first, high probability because V stands for red color and human skin colors have more weight on this component
  for (int32_t i = 0; i < 4; i++) {
    if (iNeighbourForegroundFlags & kaOUPos[i]) {
      uint8_t* pRefC = pBgdParam->pRef[2] + iStartSamplePos + aEdgeOffset[i];
      uint8_t* pCurC = pBgdParam->pCur[2] + iStartSamplePos + aEdgeOffset[i];
      if (CalculateAsdChromaEdge (pRefC, pCurC, iStride[i]) > BGD_THD_ASD_UV) {
        return 1;
      }
    }
  }
  // U component, which stands for blue color, low probability
  for (int32_t i = 0; i < 4; i++) {
    if (iNeighbourForegroundFlags & kaOUPos[i]) {
      uint8_t* pRefC = pBgdParam->pRef[1] + iStartSamplePos + aEdgeOffset[i];
      uint8_t* pCurC = pBgdParam->pCur[1] + iStartSamplePos + aEdgeOffset[i];
      if (CalculateAsdChromaEdge (pRefC, pCurC, iStride[i]) > BGD_THD_ASD_UV) {
        return 1;
      }
    }
  }

  return 0;
}
  • CalculateAsdChromaEdge函数
inline int32_t CBackgroundDetection::CalculateAsdChromaEdge (uint8_t* pOriRef, uint8_t* pOriCur, int32_t iStride) {
  int32_t ASD = 0;
  int32_t idx;
  for (idx = 0; idx < BGD_OU_SIZE_UV; idx++) {
    ASD += *pOriCur - *pOriRef;
    pOriRef += iStride;
    pOriCur += iStride;
  }
  return WELS_ABS (ASD);
}

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

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

相关文章

【WRF理论第二期】运行模型的基础知识

【WRF理论第二期】运行模型的基础知识

WRF理论第二期&#xff1a;运行模型的基础知识 1 Basics for Running the Model2 Geogrid程序2.1 Geogrid2.2 Terrestrial Input Data 3 Ungrid程序3.1 Ungrid3.2 Intermediate Files3.3 Required Fields 4 Metgrid程序参考 官方介绍-Basics for Running the Model 本博客主要…
阅读更多...
调试线上资源文件失效问题

调试线上资源文件失效问题

之前的老项目&#xff0c;突然报红&#xff0c;为了定位问题&#xff0c;使用注入和文件替换的方式进行问题定位&#xff01; 1.使用注入 但是刷新后就没有了&#xff0c;不是特别好用&#xff01; const jqScript document.createElement(script); jqScript.src https://…
阅读更多...
【记录贴：分布式系列文章】

【记录贴：分布式系列文章】

分布式系列文章目录 文章目录 分布式系列文章目录前言一、Redisq1.怎么判断是否命中缓存1. MySQL数据库如何检查询查缓存是否命中链接2.如何判断redis是否命中缓存链接 q2.Redis缓存穿透、雪崩、击穿以及分布式锁和本地锁 二、分布式q1.分布式订单号生成策略q2.接口幂等性,防止…
阅读更多...
使用Kimi月之暗面快速完成学术论文【全流程】

使用Kimi月之暗面快速完成学术论文【全流程】

学境思源&#xff0c;一键生成论文初稿&#xff1a; AcademicIdeas - 学境思源AI论文写作 国内大型互联网公司如阿里、腾讯、360纷纷开始免费提供长文本生成服务&#xff0c;体验了一把国产级的模型Kimi&#xff0c;小编只有一个感觉&#xff1a;国产AI模型只能说越来越牛逼了…
阅读更多...
【微服务】使用kubekey部署k8s多节点及kubesphere

【微服务】使用kubekey部署k8s多节点及kubesphere

kubesphere官方部署文档 https://github.com/kubesphere/kubesphere/blob/master/README_zh.md kubuctl命令文档 https://kubernetes.io/zh-cn/docs/reference/kubectl/ k8s资源类型 https://kubernetes.io/zh-cn/docs/reference/kubectl/#%E8%B5%84%E6%BA%90%E7%B1%BB%E5%9E…
阅读更多...
人大金仓数据库大小写敏感查看

人大金仓数据库大小写敏感查看

V8R3版本检查方法&#xff1a; 执行语句 show case_sensitive; 返回结果 on&#xff1a;表示大小写敏感&#xff1b; 返回结果 off&#xff1a;表示大小写不敏感。 V8R6版本检查方法&#xff1a; 执行语句 show enable_ci; 返回结果 on&#xff1a;表示大小写不敏感&#x…
阅读更多...
docker 停止重启容器命令start/stop/restart详解(容器生命周期管理教程-2)

docker 停止重启容器命令start/stop/restart详解(容器生命周期管理教程-2)

Docker 提供了多个命令来管理容器的生命周期&#xff0c; 其中start、stop 和 restart。这些命令允许用户控制容器的运行状态。 1. docker start 命令格式&#xff1a; docker start [OPTIONS] CONTAINER [CONTAINER...]功能&#xff1a; 启动一个或多个已经停止的 Docker …
阅读更多...
Modbus TCP转CanOpen网关携手FANUC机器人助力新能源汽车

Modbus TCP转CanOpen网关携手FANUC机器人助力新能源汽车

Modbus TCP转CanOpen网关与FANUC机器手臂的现场应用可以实现FANUC机器手臂与其他设备之间的数据交换和通信。CANopen是一种常见的网络协议&#xff0c;用于处理机器和设备之间的通信&#xff0c;并广泛应用于自动化领域。而Modbus TCP是一种基于TCP/IP协议的通信协议&#xff0…
阅读更多...
ABB机器人手动模式切换自动模式时，程序指针会自动PP移至Main的解决办法

ABB机器人手动模式切换自动模式时，程序指针会自动PP移至Main的解决办法

ABB机器人手动模式切换自动模式时，程序指针会自动PP移至Main的解决办法 如下图所示，手动切换到自动模式时，程序指针会自动PP移至Main，即程序指针会自动移动到主程序的第一行， 如何取消这个功能？ 解决办法可参考以下内容： 如下图所示，打开菜单—控制面板， 如下图所示，…
阅读更多...
探索通信技术的未来：2024中国通信技术和智能装备产业博览会

探索通信技术的未来：2024中国通信技术和智能装备产业博览会

探索通信技术的未来&#xff1a;2024通信技术产业专场 随着信息技术的飞速发展&#xff0c;通信技术已成为现代社会不可或缺的基础设施。2024年10月11日至13日&#xff0c;青岛将迎来一场通信技术的盛会——2024中国军民两用智能装备与通信技术产业博览会。本次博览会不仅将展…
阅读更多...
vs中C++项目中没有QT(.pro)文件怎么生成翻译ts文件

vs中C++项目中没有QT(.pro)文件怎么生成翻译ts文件

目录 使用 CMake 生成翻译文件 1.创建 CMakeLists.txt 文件 2.添加翻译生成规则 3.运行 CMake 4.生成翻译文件 使用命令行工具生成翻译文件 1.运行 lupdate 2.编辑 .ts 文件 3.运行 lrelease 网络上说的情况都是一个qt程序在VS中打开&#xff0c;拥有.pro文件的情况&a…
阅读更多...
方案设计｜汽车轮胎数显胎压计方案

方案设计｜汽车轮胎数显胎压计方案

一、引言 数显轮胎胎压计是一个专门测量车辆轮胎气压的工具&#xff0c;它具有高精度测量的功能&#xff0c;能够帮助快速准确获取轮胎气压正确数值&#xff0c;保证轮胎使用安全。本文将对数显轮胎胎压计的方案技术进行分析&#xff0c;包括其基本原理、硬件构成、软件设计等方…
阅读更多...
想入门学习AIGC，自己却对此毫无基础，该怎么办，看这篇零基础入门教学AI绘画。

想入门学习AIGC，自己却对此毫无基础，该怎么办，看这篇零基础入门教学AI绘画。

“最先掌握AI的人&#xff0c;将会比较晚掌握AI的人有竞争优势”。 这句话&#xff0c;放在计算机、互联网、移动互联网的开局时期&#xff0c;都是一样的道理。 不需要把Ai绘画想的很复杂&#xff0c;抛去复杂的应用&#xff0c; 使用现成简单的工具&#xff0c;只需要学会提…
阅读更多...
1.6T模块与DSP技术的演进

1.6T模块与DSP技术的演进

近日&#xff0c;光通信行业市场机构LightCounting在市场报告中指出&#xff0c;去年的模块供应商已经展示了首批1.6T光学模块的风采&#xff0c;而今年&#xff0c;DSP供应商更是着眼于第二代1.6T模块设计的未来。这些前沿技术的突破&#xff0c;不仅代表了数据传输速度的飞跃…
阅读更多...
产品专员跳槽产品经理，考PMP还是NPDP?

产品专员跳槽产品经理，考PMP还是NPDP?

我建议你考取NPDP证书&#xff0c;因为这是产品经理非常适合的证书。大多数招聘产品经理的公司都要求有这个证书。如果你已经拥有NPDP证书&#xff0c;我建议你再考取PMP证书&#xff0c;以提升自己的专业水平。 首先&#xff0c;让我们看看NPDP证书的优势&#xff1a; 一. N…
阅读更多...
Python round函数详解

Python round函数详解

大家好&#xff0c;在 Python 编程中&#xff0c;经常需要对数字进行舍入操作。无论是在金融领域的货币计算&#xff0c;还是科学计算中的数据处理&#xff0c;都可能需要使用到四舍五入功能。为了满足这一需求&#xff0c;Python 提供了一个内置函数 round()&#xff0c;它能够…
阅读更多...
【必会面试题】快照读的原理

【必会面试题】快照读的原理

目录 前言知识点一个例子 前言 快照读&#xff08;Snapshot Read&#xff09;是数据库管理系统中一种特殊的读取机制&#xff0c;主要用于实现多版本并发控制&#xff08;MVCC, Multi-Version Concurrency Control&#xff09;策略&#xff0c;尤其是在MySQL的InnoDB存储引擎中…
阅读更多...
水泥超低排平台改造全攻略！

水泥超低排平台改造全攻略！

在环保政策日益严格的背景下&#xff0c;水泥行业作为高污染、高能耗的行业之一&#xff0c;面临着巨大的改造压力。水泥超低排平台的改造不仅是响应国家环保号召的举措&#xff0c;更是企业实现绿色生产、可持续发展的必经之路。本文将详细解读水泥超低排平台改造的要点和策略…
阅读更多...
Sketch语言设置指南：将英文版改成中文版的教程

Sketch语言设置指南：将英文版改成中文版的教程

Sketch版本的转换一直是困扰大家的关键问题。如今UI设计领域的UI设计软件很多&#xff0c;但大部分都是英文版。对于国内英语基础差的设计师来说&#xff0c;使用这样的软件无形中增加了工作量&#xff0c;往往需要在设计编辑的同时查阅翻译。即时设计详细介绍了Sketch英文版如…
阅读更多...
C++容器之概览

C++容器之概览

目录 1 概述2 分类2.1 前向迭代器容器2.2 双向迭代器容器2.3 随机访问迭代器容器2.4 容器适配器2.5 位集 1 概述 在C标准库中容器是通过模板实现的数据结构&#xff0c;多数可以通过迭代器统一访问&#xff0c;包括&#xff1a; array 数组是固定大小的序列容器&#xff1a;它…
阅读更多...
最新文章

Copyright @ 2022~2023