【目标跟踪】光流跟踪（python、c++代码）

文章目录

    • 前言
    • 一、代码流程与思路
    • 二、python 代码
      • 2.1 代码详解
      • 2.2 完整代码
    • 三、c++ 代码
    • 四、结果展示

前言

  1. 光流利用图像序列中像素在时间域上的变化以及相邻帧之间的相关性来找到上一帧跟当前帧之间存在的对应关系，从而计算出相邻帧之间物体的运动信息的一种方法。
  2. 本文主要展示代码以及代码解释，对于相对应的原理，以后有机会再写（下次一定）。
  3. 本文所用数据源于网上开源数据。找不到数据的小伙伴可以私我拿数据。
  4. 文章提供 python、c++ 代码。python 代码可以直接跑通。c++ 代码集成一个 class ，可以在自己工程中使用。
  5. 效果图：
    在这里插入图片描述

一、代码流程与思路

  1. 输入：上一帧图片、preImage 上一帧图片检测框、image 当前帧图片。 输出：当前帧光流预测框
  2. 特征点提取。对上一帧图片 preImage 提取目标框里的特征点，这里采取的是 fast 角点检测。
  3. preImage、image 光流跟踪、在 image 中找出对应的特征点。
  4. 由特征点对应关系可以得出当前帧的目标框。

二、python 代码

2.1 代码详解

(1) fast 角点检测

fast = cv2.FastFeatureDetector_create(threshold=9, nonmaxSuppression=True, type=cv2.FastFeatureDetector_TYPE_9_16)
  1. threshold：边缘轨迹点和中心点的差值阈值。
  2. nonmaxSuppression：是否进行非极大值抑制
  3. type：提供轨迹范围。我们这里是从圆周轨迹16个点，当9个满足条件，此判定圆心像素点为特征点

我们这里只对检测框里的像素做特征点检测

def SelectPointByBox(img, det):
    top_x, top_y, bottom_x, bottom_y = [int(_) for _ in det[:4]]
    cutimg = img[max(0, top_y - 2):min(bottom_y + 2, 1080), max(0, top_x - 2):min(1920, bottom_x + 2)]
    fast = cv2.FastFeatureDetector_create(threshold=9, nonmaxSuppression=True, type=cv2.FastFeatureDetector_TYPE_9_16)
    kps = fast.detect(cutimg, 10)  # Ip-t < Ip < Ip+t
    kp = []
    for p in kps:
        t = []
        t.append(np.float32(p.pt[0] + top_x))
        t.append(np.float32(p.pt[1] + top_y))
        kp.append(np.array(t).reshape(1, 2))
    return np.array(kp)

(2) 追踪稀疏特征点

cv2.calcOpticalFlowPyrLK(preImgGray, gray, prePt, pt, **lkParms)
  1. preImgGray：前一帧图片灰度图。
  2. gray：当前帧图片灰度图
  3. prePt：前一帧图片的特征点
  4. pt：None
lkParms = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
  1. winSize: 每个金字塔级别上搜索窗口的大小
  2. maxLevel: 最大金字塔层数
  3. criteria：指定迭代搜索算法的终止条件，在指定的最大迭代次数 10 之后或搜索窗口移动小于 0.03
def OpticalFlowLk(preImg, curImg, prePt, pt):
    lkParms = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
    gray = cv2.cvtColor(curImg, cv2.COLOR_BGR2GRAY)
    preImgGray = cv2.cvtColor(preImg, cv2.COLOR_BGR2GRAY)
    # nextPts:前一帧图像的特征点跟踪后的点  st：特征点是否找到，找到状态为1，否则为0  err：每个特征点的误差，即前一帧和当前帧中特征点的位置差异
    nextPts, st, err = cv2.calcOpticalFlowPyrLK(preImgGray, gray, prePt, pt, **lkParms)
    # print("p1", nextPts, "st", st, "err", err)
    goodNewPt = nextPts[st == 1]  # 光流跟踪后特征点
    goodOldPt = prePt[st == 1]  # 上一帧特征点
    return goodOldPt, goodNewPt

(3) 预测当前帧目标检测框

  1. 现在我们获取到了 prePt curPt pre_detect_box
  2. 由像素对应关系，我们可以求出 cur_detect_box
def CalculateShift(prePt, curPt):
    x = curPt[:, 0] - prePt[:, 0]
    y = curPt[:, 1] - prePt[:, 1]
    avgX = np.mean(x)
    avgY = np.mean(y)
    return avgX, avgY


def get_box(ditection, prePt, curPt):
    d_x, d_y = CalculateShift(prePt, curPt)  # 计算偏移量
    box = [0] * 4
    box[0], box[2], box[1], box[3] = ditection[0] + d_x, ditection[2] + d_x, ditection[1] + d_y, ditection[3] + d_y
    return box

2.2 完整代码

代码可直接跑通

import cv2
import os
import numpy as np


def GetImg(path, num):
    fn = os.path.join(path, 'img', '%06d.jpg' % (num))
    im = cv2.imread(fn)
    return im


def GetDetFrameRes(seq_dets, frame):
    detects = seq_dets[seq_dets[:, 0] == frame, 2:7]
    detects[:, 2:4] += detects[:, 0:2]  # convert to [x1,y1,w,h] to [x1,y1,x2,y2]
    return detects


def SelectPointByBox(img, det):
    top_x, top_y, bottom_x, bottom_y = [int(_) for _ in det[:4]]
    cutimg = img[max(0, top_y - 2):min(bottom_y + 2, 1080), max(0, top_x - 2):min(1920, bottom_x + 2)]
    fast = cv2.FastFeatureDetector_create(threshold=9, nonmaxSuppression=True, type=cv2.FastFeatureDetector_TYPE_9_16)
    kps = fast.detect(cutimg, 10)  # Ip-t < Ip < Ip+t
    kp = []
    for p in kps:
        t = []
        t.append(np.float32(p.pt[0] + top_x))
        t.append(np.float32(p.pt[1] + top_y))
        kp.append(np.array(t).reshape(1, 2))
    return np.array(kp)


def OpticalFlowLk(preImg, curImg, prePt, pt):
    lkParms = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
    gray = cv2.cvtColor(curImg, cv2.COLOR_BGR2GRAY)
    preImgGray = cv2.cvtColor(preImg, cv2.COLOR_BGR2GRAY)
    # nextPts:前一帧图像的特征点跟踪后的点    st：特征点是否找到，找到状态为1，否则为0     err：每个特征点的误差，即前一帧和当前帧中特征点的位置差异
    nextPts, st, err = cv2.calcOpticalFlowPyrLK(preImgGray, gray, prePt, pt, **lkParms)
    # print("p1", nextPts, "st", st, "err", err)
    goodNewPt = nextPts[st == 1]  # 光流跟踪后特征点
    goodOldPt = prePt[st == 1]  # 上一帧特征点
    return goodOldPt, goodNewPt


def CalculateShift(prePt, curPt):
    x = curPt[:, 0] - prePt[:, 0]
    y = curPt[:, 1] - prePt[:, 1]
    avgX = np.mean(x)
    avgY = np.mean(y)
    return avgX, avgY


def get_box(ditection, prePt, curPt):
    d_x, d_y = CalculateShift(prePt, curPt)  # 计算偏移量
    box = [0] * 4
    box[0], box[2], box[1], box[3] = ditection[0] + d_x, ditection[2] + d_x, ditection[1] + d_y, ditection[3] + d_y
    return box


def Test():
    pathroot = ".\\"
    resPath = pathroot + "det.txt"
    video_path = pathroot + "video.mp4"
    video = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc('m', 'p', '4', 'v'), 10, (1920, 1080))
    detRes = np.loadtxt(resPath, delimiter=',')
    preImg = GetImg(pathroot, 1)  # 初始化为000001.jpg   preImg:上一帧图片
    for num in range(2, int(max(detRes[:, 0]))):
        print(num)
        img = GetImg(pathroot, num)  # img:当前帧图片
        dets = GetDetFrameRes(detRes, num - 1)  # 上一帧图片的检测框
        drawImg = img.copy()
        for i in range(len(dets)):
            detect = dets[i]  # 上一帧图片的单个框
            boxKeyPt = SelectPointByBox(preImg, detect)  # 找在框里的关键点
            if (len(boxKeyPt) < 3):
                continue  # 框里关键点少于3 不做跟踪
            prePt, curPt = OpticalFlowLk(preImg, img, boxKeyPt, None)
            bbox = get_box(detect, prePt, curPt)
            if np.isnan(bbox[0]): continue
            for i in range(curPt.shape[0] - 1, -1, -1):
                c, d = curPt[i].ravel()
                if not (max(0, bbox[0] - 2) <= c <= min(1920, bbox[2] + 2) and
                        max(0, bbox[1] - 2) <= d <= min(1080, bbox[3] + 2)):
                    prePt = np.delete(prePt, i, 0)
                    curPt = np.delete(curPt, i, 0)
            new_b = get_box(detect, prePt, curPt)  # 最终框
            if np.isnan(new_b[0]): continue
            cv2.rectangle(drawImg, (int(new_b[0]), int(new_b[1])), (int(new_b[2]), int(new_b[3])), (96, 48, 176), 2)
            mask = np.zeros_like(preImg)
            color = np.random.randint(0, 255, (20000, 3))
            for i, (new, old) in enumerate(zip(prePt, curPt)):
                a, b = new.ravel()
                c, d = old.ravel()
                mask = cv2.line(mask, (int(a), int(b)), (int(c), int(d)), color[i].tolist(), 2)
                drawImg = cv2.circle(drawImg, (int(a), int(b)), 1, color[i].tolist(), -1)
            drawImg = cv2.add(drawImg, mask)

        cv2.imshow("img", drawImg)
        cv2.waitKey(10)
        preImg = img.copy()
        video.write(drawImg)
    video.release()


if __name__ == "__main__":
    Test()

三、c++ 代码

  1. Optical(std::vector<cv::Rect_> boxes, cv::Mat preImg, cv::Mat curImg) 构造函数
  2. void OpticalDeal(); 处理计算
  3. std::vector<cv::Rect_> GetBoxResult(); 获取结果

Optical.h 文件

#include <vector>
#include "opencv2/opencv.hpp"
#include "opencv2/features2d.hpp"


class Optical
{
public:
    Optical(std::vector<cv::Rect_<float>> boxes, cv::Mat preImg, cv::Mat curImg)
    {
        mBoxes = boxes;
        mCurImg = curImg;
        mPreImg = preImg;
    }   
    void OpticalDeal();                                     // 计算
    std::vector<cv::Rect_<float>> GetBoxResult();           // 获取光流跟踪后得到的结果框 

private:
    std::vector<cv::Point2f> GetCornorPoint();              // fast检测关键点坐标
    cv::Rect_<float> GetExpBox(cv::Rect_<float> box);       // 获取比检测框大pixeParam像素的框
    void OpticalFlowLk(std::vector<cv::Point2f> prePt);     // 光流跟踪
    cv::Rect_<float> GetUpdateBox(cv::Rect_<float> box, std::vector<cv::Point2f> prePoints, std::vector<cv::Point2f> curPoints);    // 修正框
    void SelectPt(cv::Rect_<float> box, std::vector<cv::Point2f> &prePoints, std::vector<cv::Point2f> &curPoints);                  // 选取合适的关键点 过滤一部分关键点
    cv::Rect_<float> CorrectBox(cv::Rect_<float> box); 

private:
    int pixeParam = 2;                      // 关键点选取像素参数 多截取pixeParam像素
    int fastFeatureDetectParam = 10;        // fast关键点检测参数，参数越小，关键点检测越多
    int keyPointCountParam = 3;             // 检测框里关键点较少就不进行光流跟踪
    std::vector<int> mIndex = {0};          // 光流跟踪每个框关键点的索引位置 
    std::vector<cv::Rect_<float>> mBoxes;   // 检测框
    cv::Mat mPreImg;                        // 上一帧图
    cv::Mat mCurImg;                        // 当前图片
};

Optical.cpp 文件

#include "Optical.h"

std::vector<cv::Rect_<float>> Optical::GetBoxResult()
{
    return mBoxes;
}

void Optical::OpticalDeal()
{
    std::vector<cv::Point2f> fastKeyPoint = GetCornorPoint();   // fast检测的角点
    OpticalFlowLk(fastKeyPoint);                                // 光流跟踪 获取点与点匹配
}

std::vector<cv::Point2f> Optical::GetCornorPoint()
{   
    std::vector<cv::Point2f> res;
    cv::Ptr<cv::FastFeatureDetector> detector = cv::FastFeatureDetector::create(fastFeatureDetectParam);
    int num = 0;                                            // 计数多少个关键点 
    for (int i = 0; i < mBoxes.size(); ++i) {
        std::vector<cv::KeyPoint> keyPoints;
        cv::Rect_<float> newBox = GetExpBox(mBoxes[i]);
        cv::Mat image = mPreImg(newBox);                    // 截取检测框检测的图片
        detector->detect(image, keyPoints);
        num = num + keyPoints.size();
        mIndex.push_back(num);
        for (auto points:keyPoints) {
            points.pt = points.pt + cv::Point_<float>(newBox.x, newBox.y);
            res.push_back(points.pt);
        }
    }
    return res;
}

void Optical::OpticalFlowLk(std::vector<cv::Point2f> prePt)
{
    cv::Mat curImgGray, preImgGray;
    std::vector<uchar> status;
	std::vector<float> err;
    cv::cvtColor(mCurImg, curImgGray, cv::COLOR_RGBA2GRAY);     // 当前图片灰度
    cv::cvtColor(mPreImg, preImgGray, cv::COLOR_RGBA2GRAY);     // 上一帧图片灰度
    std::vector<cv::Point2f> pt;
    cv::calcOpticalFlowPyrLK(preImgGray, curImgGray, prePt, pt, status, err); 
    for (int i = 0; i < mIndex.size() - 1; ++i) {
        int leftIndex = mIndex[i], rightIndex = mIndex[i + 1];
        // 关键点太少不进行光流跟踪(1)
        if (rightIndex - leftIndex >= keyPointCountParam) {
            std::vector<cv::Point2f> preIndexPt(prePt.begin() + leftIndex, prePt.begin() + rightIndex);
            std::vector<cv::Point2f> indexPt(pt.begin() + leftIndex, pt.begin()+rightIndex);
            std::vector<uchar> indexStatus(status.begin() + leftIndex, status.begin()+rightIndex);
            int length = preIndexPt.size(); 
            for (int j = length - 1 ; j > -1; --j) {
                if (status[j] != 1) {
                    indexPt.erase(indexPt.begin() + i);
                    preIndexPt.erase(preIndexPt.begin() + j);
                }
            }
            // 跟踪到的关键点少不进行光流跟踪(2)
            if (preIndexPt.size() > keyPointCountParam) {
                cv::Rect_<float> newBox = GetUpdateBox(mBoxes[i], preIndexPt, indexPt);
                SelectPt(newBox, preIndexPt, indexPt);
                if (preIndexPt.size() > keyPointCountParam) {
                    mBoxes[i] = GetUpdateBox(mBoxes[i], preIndexPt, indexPt);
                }
            }
        }
    }
}

// expend pixeParam bounding box to optical track
cv::Rect_<float> Optical::GetExpBox(cv::Rect_<float> box) 
{
    cv::Rect_<float> newBox = box + cv::Point_<float>(-pixeParam, -pixeParam) + cv::Size_<float>(2 * pixeParam, 2 * pixeParam);
    return CorrectBox(newBox);
}

cv::Rect_<float> Optical::GetUpdateBox(cv::Rect_<float> box, std::vector<cv::Point2f> prePoints, std::vector<cv::Point2f> curPoints)
{
    float avgX = 0, avgY = 0;
    int length = prePoints.size();
    for (int i = 0; i < length; ++i) {
        avgX += curPoints[i].x - prePoints[i].x;
        avgY += curPoints[i].y - prePoints[i].y;
    }
    avgX = avgX / length;
    avgY = avgY / length;
    cv::Rect_<float> resBox = box + cv::Point_<float>(avgX, avgY);
    return CorrectBox(resBox);
}

void Optical::SelectPt(cv::Rect_<float> box, std::vector<cv::Point2f> &prePoints, std::vector<cv::Point2f> &curPoints)
{
    int length = prePoints.size();
    for (int i = length - 1 ; i >= 0; --i) {
        float x = curPoints[i].x, y = curPoints[i].y;
        if (x < (box.x - pixeParam) || x > (box.x + box.width + pixeParam) || y < (box.y - pixeParam) || y > (box.y + box.height + pixeParam)) {
            curPoints.erase(curPoints.begin() + i);
            prePoints.erase(prePoints.begin() + i);
        }
    }
}

// correct box when box beyond border
cv::Rect_<float> Optical::CorrectBox(cv::Rect_<float> box)
{
    int w = mPreImg.cols, h = mPreImg.rows;
    box.x = (box.x <= 0) ? 0 : box.x;
    box.y = (box.y <= 0) ? 0 : box.y;
    box.width = ((box.width + box.x) >= w - 1) ? w - box.x - 1 : box.width;
    box.height = ((box.height + box.y) >= h - 1) ? h - box.y - 1 : box.height;
    return box;
}

四、结果展示

在这里插入图片描述

由于上传限制，只上传 gif 压缩结果

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

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

相关文章

初探HarmonyOS路由跳转

初探HarmonyOS路由跳转

最近的鸿蒙新闻也是很大声势&#xff0c;鸿蒙的纯血版一出&#xff0c;各大互联网大厂都坐不住了&#xff0c;纷纷加入其中。这意味鸿蒙将来会取代大部分Android用户&#xff0c;这也是程序员的一篇大好前程。如今的Android开发行业已经夕阳西下了。 网上有关HarmonyOS的资料几…
阅读更多...
雷达公式实现（matlab）

雷达公式实现（matlab）

雷达公式实现 代码来源&#xff1a;《雷达系统分析与设计(MATLAB版)(第三版)》 function [snr] radar_eq(pt,freq,g,sigma,b,nf,loss,range) % This program implements Eq.(1.63) %% Inputs:% pt——峰值功率&#xff0c;W% freq——雷达中心频率&#xff0c;Hz% g——天线…
阅读更多...
Linux 启动过程

Linux 启动过程

linux启动步骤&#xff1a; <1>加电 <2>加载bios设置 <3>加载grup <4>加载内核系统到内存中 <5>加载配置文件 <6>加载内核模块 <7>完成相应的初始化工作和启动相应的服务 <8>启动系统进程 <9>出现登录界面 &l…
阅读更多...
【傻瓜级JS-DLL-WINCC-PLC交互】6.​向PLC里面装载数据变量

【傻瓜级JS-DLL-WINCC-PLC交互】6.​向PLC里面装载数据变量

思路 JS-DLL-WINCC-PLC之间进行交互&#xff0c;思路&#xff0c;先用Visual Studio创建一个C#的DLL控件&#xff0c;然后这个控件里面嵌入浏览器组件&#xff0c;实现JS与DLL通信&#xff0c;然后DLL放入到WINCC里面的图形编辑器中&#xff0c;实现DLL与WINCC的通信。然后PLC与…
阅读更多...
低代码（Low Code）多项目开发平台核心能力解析

低代码（Low Code）多项目开发平台核心能力解析

随着信息化的发展&#xff0c;企业基于互联网的业务不断得到扩展&#xff0c;作为业务协调的基础&#xff0c;企业信息系统的复杂程度也在不断提高。系统复杂了&#xff0c;就容易出问题&#xff0c;这就对系统的性能、可用性、可靠性和安全性都提出了新的要求&#xff0c;因此…
阅读更多...
流程控制翻转学习

流程控制翻转学习

&#x1f4d1;前言 本文主要是【Python】——Python流程控制翻转学习的文章&#xff0c;如果有什么需要改进的地方还请大佬指出⛺️ &#x1f3ac;作者简介&#xff1a;大家好&#xff0c;我是听风与他&#x1f947; ☁️博客首页&#xff1a;CSDN主页听风与他 &#x1f304;每…
阅读更多...
【Python基础】协程（迭代器、生成器、协程、gevent介绍）

【Python基础】协程（迭代器、生成器、协程、gevent介绍）

&#x1f308;欢迎来到Python专栏 &#x1f64b;&#x1f3fe;‍♀️作者介绍&#xff1a;前PLA队员 目前是一名普通本科大三的软件工程专业学生 &#x1f30f;IP坐标&#xff1a;湖北武汉 &#x1f349; 目前技术栈&#xff1a;C/C、Linux系统编程、计算机网络、数据结构、Mys…
阅读更多...
完美滤波器

完美滤波器

完美滤波器 如下图所示&#xff0c;第 j j j级为输入图像&#xff0c;其中第 j − 1 j-1 j−1级为第 j j j级的尺寸减半的存在&#xff0c;直至为 1 1 1\times 1 11 的大小&#xff0c;这样的模式被称为图像金字塔 设原图像像素点个数为 N 2 N^2 N2&#xff0c;则图像金字塔的…
阅读更多...
华清远见嵌入式学习——C++——作业一

华清远见嵌入式学习——C++——作业一

作业要求&#xff1a; 代码&#xff1a; #include <iostream>using namespace std;int main() {string str;cout << "请输入一个字符串&#xff1a;" << endl;getline(cin,str);int dx0,xx0,sz0,kg0,qt0;int len str.size() 1;for(int i0;i<l…
阅读更多...
互联网程序设计HTML+CSS+JS

互联网程序设计HTML+CSS+JS

一、HTML基础 HTML超文本标记语言。 超文本&#xff1a;链接&#xff1b; 标记&#xff1a;标签&#xff0c;带尖括号的文本。 1、标签结构 标签要成对出现&#xff0c;中间包裹内容&#xff1b; <>里面放英文字母&#xff08;标签名&#xff09;&#xff1b; 结束…
阅读更多...
铝合金轮毂金属部件全自动三维精密测量工业光学3d智能检测仪器-CASAIM-IS（2ND）

铝合金轮毂金属部件全自动三维精密测量工业光学3d智能检测仪器-CASAIM-IS（2ND）

一、背景介绍 汽车轮毂是汽车零部件的重要组成部分。对于汽车而言&#xff0c;轮毂等同于腿对人的重要性。车辆将在行驶过程中产生横向和纵向载荷&#xff0c;车轮也将承受车辆和货物的所有载荷。随着汽车的速度越来越快&#xff0c;对车轮的动态稳定性和可靠性的要求也越来越…
阅读更多...
phtoshop获取签字，并且设置背景透明的办法

phtoshop获取签字，并且设置背景透明的办法

目的&#xff1a;获取背景透明的“座山雕”签名 1.打开图片&#xff08;任意格式图片文件&#xff09;&#xff0c;&#xff0c;保存记得是*.png格式(这种格式可以保存背景透明的格式) 2.魔术棒点“白色”的空白地方&#xff08;快速选择除“座山雕”外的地方&#xff0c;目的…
阅读更多...
C语言基础程序设计题

C语言基础程序设计题

1.个人所得税计算 应纳税款的计算公式如下&#xff1a;收入<&#xff1d;1000元部分税率为0&#xff05;&#xff0c;2000元>&#xff1d;收入>1000元的部分税率为5&#xff05;&#xff0c;3000元>&#xff1d;收入>2000元的部分税率为10&#xff05;&#xf…
阅读更多...
MySQL触发器-使用示例

MySQL触发器-使用示例

一、什么是触发器 触发器是与表有关的数据库对象&#xff0c;在满足定义条件时触发&#xff0c;并执行触发器中定义的SQL语句 举个例子&#xff1a;有两个表&#xff0c;员工表和部门表。当一个员工入职时&#xff1a; 员工表需要insert一行员工详细信息&#xff08;id,empl…
阅读更多...
supermap-iserver激活教程（linux）

supermap-iserver激活教程（linux）

本篇只介绍linux临时许可激活教程&#xff0c;windows的原理一摸一样不做赘述。 1.下载许可中心&#xff08;web版&#xff09; SuperMap技术资源中心|为您提供全面的在线技术服务 2.解压 supermap-bslicense-server-3.0.24-linux-x64.tar.gz tar -zxvf supermap-bslicense…
阅读更多...
WebGL技术框架及功能

WebGL技术框架及功能

WebGL&#xff08;Web Graphics Library&#xff09;是一种用于在Web浏览器中渲染交互式3D和2D图形的JavaScript API。它允许在不需要插件的情况下&#xff0c;在支持WebGL的浏览器中直接运行高性能的图形渲染。WebGL没有一个固定的技术框架&#xff0c;而是基于JavaScript API…
阅读更多...
最佳实践| 一文读懂《MongoDB 使用规范及最佳实践》原理

最佳实践| 一文读懂《MongoDB 使用规范及最佳实践》原理

最佳实践| 一文读懂《MongoDB 使用规范及最佳实践》原理 一、MongoDB 使用规范与限制 MongoDB 灵活文档的优势 灵活库/集合命名及字段增减同一字段可存储不同类型数据Json 文档可多层次嵌套文档对于开发而言最自然的表达 MongoDB 灵活文档的烦恼 数据库集合字段名千奇百怪…
阅读更多...
基于YOLOv8的道路缺陷检测：自研模块 MSAM 注意力 PK CBAM注意力，实现暴力涨点

基于YOLOv8的道路缺陷检测：自研模块 MSAM 注意力 PK CBAM注意力，实现暴力涨点

&#x1f4a1;&#x1f4a1;&#x1f4a1;本文自研创新改进&#xff1a;MSAM&#xff08;CBAM升级版&#xff09;&#xff1a;通道注意力具备多尺度性能&#xff0c;多分支深度卷积更好的提取多尺度特征&#xff0c;最后高效结合空间注意力 1&#xff09;作为注意力MSAM使用&am…
阅读更多...
【前端首屏加载速度优化(一) ：nginx 开启gzip压缩】

【前端首屏加载速度优化(一) ：nginx 开启gzip压缩】

开启gzip压缩前后对比&#xff1a; nginx.conf具体配置&#xff1a; server {# 启动后的端口listen 8882;# 开启gzip压缩gzip on;gzip_min_length 1k; gzip_buffers 4 16k; gzip_http_version 1.1; gzip_comp_level 6; gzip_types text/plain application/x-javascript…
阅读更多...
多种卫星遥感数据反演黑龙江省蒸腾与蒸散（ET）数据服务

多种卫星遥感数据反演黑龙江省蒸腾与蒸散（ET）数据服务

引言 多种卫星遥感数据反演黑龙江省地表蒸腾与蒸散率&#xff08;ET&#xff09;产品是地理遥感生态网平台推出的生态环境类数据产品之一&#xff0c;产品包括1981-2023年数据&#xff0c;&#xff0c;数据类型为8bit整型。该产品经过数据搜集—模型模拟—质量检查—地表蒸腾与…
阅读更多...
最新文章

Copyright @ 2022~2023