OpenCV图像处理——C++实现亚像素尺寸标定板边缘轮廓提取

前言

标定模板（Calibration Target）在机器视觉、图像测量、摄影测量以及三维重建等应用中起着重要的作用。它被用于校正相机的畸变，确定物理尺寸和像素之间的换算关系，并建立相机成像的几何模型。通过使用相机拍摄带有固定间距图案阵列的平板，并经过标定算法的计算，我们能够得到相机的几何参数，从而获得高精度的测量和重建结果。

这种标定模板通常具有固定间距的图案阵列，例如棋盘格、圆点阵列等。这些图案提供了已知尺寸的参考点，使得可以精确地计算相机的内参（内部参数）和外参（外部参数）。内参包括焦距、主点等相机内部的属性，而外参包括相机的位置和方向等外部属性。

通过对标定模板进行拍摄和相应的标定过程，可以消除图像中的畸变效应，实现对物体三维几何位置与其在图像中对应点之间的精确关联。这为各种应用场景提供了可靠的基础，包括计算机视觉任务、图像测量、摄影测量以及三维重建等。标定模板的使用有助于提高测量和重建的准确性，并确保获得可靠的结果。
这是使用的标定板是49个圆点的尺寸标定板，为是更好的演示亚像素，所拍的图像大小为320240pix，标定板的大小为130130pix。

在这里插入图片描述

边缘检测

在计算机视觉和机器视觉领域，广泛应用图像分割，这是将数字图像细分为多个子区域的过程。图像分割的目标是简化或改变图像的表示形式，使其更易于理解和分析。这通常包括定位图像中的物体和边界，生成图像子区域或轮廓线的集合。图像分割方法主要涵盖阈值处理（二值化）、聚类法、边缘检测和区域生长等。解决图像分割问题时，通常需要结合领域知识，因为没有统一的范式可以适用于所有情境。

边缘检测是一种基于灰度变化的常见图像分割方法，其核心是提取图像中不连续部分的特征。常见的边缘检测算子包括差分算子、Roberts算子、Sobel算子、Prewitt算子、Log算子以及Canny算子等。其中，Canny算子由计算机科学家John F. Canny于1986年提出，被认为是目前理论上相对最完善的边缘检测算法。
这里面使用了Canny来进行边缘检测，Canny边缘检测是一种经典的图像处理技术，用于检测图像中的边缘。这个算法由约翰·Canny于1986年提出，被广泛应用于计算机视觉和图像处理领域。以下是Canny边缘检测的基本原理和步骤：

  1. 噪声抑制： 使用高斯滤波器对图像进行平滑处理，以减少噪声的影响。这有助于提高后续边缘检测步骤的准确性。

  2. 计算梯度幅值和方向： 利用Sobel等算子计算图像中每个像素点的梯度幅值和方向。梯度表示图像中的变化率，有助于确定潜在的边缘位置。

  3. 非极大值抑制： 在图像的每个像素点上，仅保留梯度幅值最大的方向，从而细化边缘。

  4. 双阈值检测： 将梯度幅值分为高阈值和低阈值两部分。高于高阈值的像素点被认为是强边缘，低于低阈值的像素点被排除。介于两者之间的像素点被标记为弱边缘。

  5. 边缘连接： 通过强边缘的连接，将弱边缘与强边缘关联起来，形成连续的边缘。

Canny边缘检测的优势在于其高准确性、低误差率和对边缘的单一定位。

	cv::Mat cv_gray;
    if (cv_src.channels() > 1)
    {
        cv::cvtColor(cv_src, cv_gray, cv::COLOR_BGR2GRAY);
    }
    else
    {
        cv_gray = cv_src.clone();
    }
    cv::Mat cv_edge;

    //1.边缘检测
    cv::Canny(cv_gray, cv_edge, 180, 200);

    cv::imshow("edge", cv_edge);
    cv::waitKey();

canny的结果：
在这里插入图片描述

轮廓提取

轮廓是由一系列相连的像素点组成的曲线，反映了物体的基本外形特征。常常用于形状分析以及物体的检测和识别任务。
边缘检测通过检测灰度的突变来寻找图像边界，但通常检测到的边缘是零散的片段，没有形成完整的整体。为了从背景中分离目标，需要将这些边缘像素连接起来形成轮廓。换句话说，轮廓是一种连续的曲线，而边缘未必都是连续的。边缘主要被用作图像的特征，而轮廓则更多地用于分析物体的整体形态。
cv::findContours 是OpenCV库中用于查找图像中轮廓的函数。它的基本用法是在二进制图像中找到对象的轮廓，返回一个包含轮廓点集合的列表。
然而，在使用cv::findContours时，会产生内外两个轮廓，为了减少内部，要对获取的轮廓进行进一步的处理：

**
 * @brief 在二值化边缘图像中检测和分离内部和外部轮廓。
 *
 * @param cv_edge 二值化边缘图像。
 * @param inner_contours 用于存储内部轮廓的向量。
 */
void contour(cv::Mat& cv_edge, std::vector<std::vector<cv::Point>>& inner_contours)
{
    // 存储所有检测到的轮廓的向量
    std::vector<std::vector<cv::Point>> contours;
    // 存储轮廓之间层次关系的层次向量
    std::vector<cv::Vec4i> hierarchy;

    // 在二值化边缘图像中查找轮廓
    cv::findContours(cv_edge, contours, hierarchy, cv::RETR_CCOMP, cv::CHAIN_APPROX_NONE);

    // 存储有效轮廓和被排除轮廓的索引的向量
    std::vector<int> valids;
    std::vector<int> excludes;

    // 根据层次关系减少内部轮廓
    edge_contour_valids(hierarchy, valids, excludes);

    // 调整 inner_contours 向量的大小以容纳有效轮廓
    inner_contours.resize(valids.size());

    // 将有效轮廓的索引映射到相应的轮廓，并存储在 inner_contours 中
    std::transform(std::execution::par,
        valids.begin(),
        valids.end(),
        inner_contours.begin(),
        [contours](int i) { return contours[i]; }
    );

    // 存储外部轮廓的向量
    std::vector<std::vector<cv::Point>> external_contours(excludes.size());

    // 将被排除轮廓的索引映射到相应的轮廓，并存储在 external_contours 中
    std::transform(std::execution::par,
        excludes.begin(),
        excludes.end(),
        external_contours.begin(),
        [contours](int i) { return contours[i]; }
    );
}

得到轮廓之后，要获取标定板圆前先获取轮廓的矩：

/**
 * @brief 计算轮廓的属性并进行阈值化，筛选符合条件的轮廓。
 *
 * @param inner_contours 存储内部轮廓的向量。
 * @param cv_cont_and 存储轮廓属性的阈值化结果。
 * @param cont_center 存储轮廓中心点的向量。
 * @param RADIUS_MAX 最大半径阈值。
 */
void contours_attribute(std::vector<cv::Point> &cont_center, std::vector<std::vector<cv::Point>> &inner_contours,
    cv::Mat & cv_cont_and,double RADIUS_MAX)
{
    // 获取轮廓的长度
    std::vector<double> cont_lengths;
    contour_length(inner_contours, cont_lengths);

    // 存储轮廓的半径和纵横比
    std::vector<double> cont_ra, cont_aspect_ratio;
    cv::Mat_<double> cont_length_mat(cont_lengths);

    // 计算轮廓中心点和其他属性
    for (const auto& c : inner_contours)
    {
        auto M = cv::moments(c);

        double area = M.m00;
        auto centerX = int(M.m10 / area);
        auto centerY = int(M.m01 / area);
        double m20 = M.mu20 / area;
        double m02 = M.mu02 / area;
        double m11 = M.mu11 / area;
        double c1 = m20 - m02;
        double c2 = c1 * c1;
        double c3 = 4 * m11 * m11;

        cont_center.emplace_back(centerX, centerY);

        auto ra = sqrt(2.0 * (m20 + m02 + sqrt(c2 + c3)));
        auto rb = sqrt(2.0 * (m20 + m02 - sqrt(c2 + c3)));
        cont_ra.emplace_back(ra);
        cont_aspect_ratio.emplace_back(ra / rb);
    }

    // 将属性向量转为 OpenCV 的 Mat 类型
    cv::Mat_<double> cv_cont_radius(cont_ra);
    cv::Mat_<double> cv_cont_aspect_ratio(cont_aspect_ratio);

    // 定义阈值和计算最大轮廓长度
    cv::Mat cv_aspect_ratio, cv_radius, cv_cont_length;
    const double CONT_LENGTH_MAX = 2 * M_PI * RADIUS_MAX;

    // 对纵横比、半径和轮廓长度进行阈值化
    cv::threshold(cv_cont_aspect_ratio, cv_aspect_ratio, 0.8, 1.0, cv::ThresholdTypes::THRESH_BINARY);
    cv::threshold(cv_cont_radius, cv_radius, RADIUS_MAX, 1.0, cv::ThresholdTypes::THRESH_BINARY_INV);
    cv::threshold(cont_length_mat, cv_cont_length, CONT_LENGTH_MAX, 1.0, cv::ThresholdTypes::THRESH_BINARY_INV);

    // 将阈值结果按位与，存储在 cv_cont_and 中
    cv::Mat and1;
    cv::bitwise_and(cv_aspect_ratio, cv_radius, and1);
    cv::bitwise_and(and1, cv_cont_length, cv_cont_and);
}

在这里插入图片描述

亚像素轮廓提取

使用亚像素插值，获得轮廓的亚像素级坐标：

/**
 * @brief 对图像进行亚像素插值，获得轮廓的亚像素级坐标。
 *
 * @param image_gray 灰度图像。
 * @param filteredCont 过滤后的轮廓向量。
 * @param contSubPixFull 存储亚像素级坐标的向量的向量。
 */
void sub_pix_contour(const cv::Mat& image_gray,
    const std::vector<std::vector<cv::Point>>& filteredCont,
    std::vector<std::shared_ptr<std::vector<std::shared_ptr<cv::Point2d>>>>& contSubPixFull)
{
    // 定义用于插值的系数
    std::vector<double> p_vec{ 0.004711,  0.069321,  0.245410,  0.361117,  0.245410,  0.069321,  0.004711 };
    std::vector<double> d1_vec{ -0.018708,  -0.125376,  -0.193091,  0.000000, 0.193091, 0.125376, 0.018708 };
    std::vector<double> d2_vec{ 0.055336,  0.137778, -0.056554, -0.273118, -0.056554,  0.137778,  0.055336 };

    // 将系数转为 Mat 类型
    auto p = cv::Mat_<double>(p_vec);
    auto d1 = cv::Mat_<double>(d1_vec);
    auto d2 = cv::Mat_<double>(d2_vec);

    // 计算图像梯度
    cv::Mat dx, dy, grad;
    cv::sepFilter2D(image_gray, dy, CV_64F, p, d1);
    cv::sepFilter2D(image_gray, dx, CV_64F, d1, p);
    cv::pow(dy.mul(dy, 1.0) + dx.mul(dx, 1.0), 0.5, grad);

    // 计算更高阶导数
    cv::Mat gy, gx, gyy, gxx, gxy;
    cv::sepFilter2D(grad, gy, CV_64F, p, d1);
    cv::sepFilter2D(grad, gx, CV_64F, d1, p);
    cv::sepFilter2D(grad, gyy, CV_64F, p, d2);
    cv::sepFilter2D(grad, gxx, CV_64F, d2, p);
    cv::sepFilter2D(grad, gxy, CV_64F, d1, d1);

    // 对每个轮廓进行亚像素插值
    contSubPixFull.resize(filteredCont.size());
    std::transform(std::execution::par,
        filteredCont.cbegin(),
        filteredCont.cend(),
        contSubPixFull.begin(),
        [&gy, &gx, &gyy, &gxx, &gxy](const std::vector<cv::Point>& cont)
        {
            return sub_pix_single(gy, gx, gyy, gxx, gxy, cont);
        }
    );
}

把亚像素轮廓坐标显示：

void SubPixEdge::draw_roi(cv::Mat& cv_src, std::vector<std::vector<cv::Point>>& filtered_cont,
    std::vector<std::shared_ptr<std::vector<std::shared_ptr<cv::Point2d>>>>& cont_sub_pix,bool show_roi)
{
    const int up_scale = 50;

    cv::Mat cv_temp = cv_src.clone();
    int src_up_w = up_scale * cv_temp.rows;
    int src_up_h = up_scale * cv_temp.cols;

    cv::Mat cv_src_up = cv::Mat::zeros(src_up_w, src_up_h, CV_8UC3);

    for (int i = 0; i < cv_temp.cols; ++i)
    {
        for (int j = 0; j < cv_temp.rows; ++j)
        {
            cv::Mat roi = cv_src_up(cv::Rect(i * up_scale, j * up_scale, up_scale, up_scale));
            roi = cv_temp.at<cv::Vec<uchar, 3>>(j, i);
        }
    }

    
    std::vector<std::vector<cv::Point>> cont;
    for (int i = 0; i < cont_sub_pix.size(); ++i)
    {
        std::vector<cv::Point> dis_cont;
        for (const auto& p : *cont_sub_pix[i])
        {
            //使用 floor() 函数向下取整
            int x = floor((p->x + 0.5) * up_scale);
            int y = floor((p->y + 0.5) * up_scale);
            cv::drawMarker(cv_src_up, cv::Point(x, y), cv::Scalar(0, 0, 255), cv::MARKER_TILTED_CROSS, 20, 5);
            dis_cont.emplace_back(x, y);
        }
        cont.emplace_back(dis_cont);
    }
    
    cv::drawContours(cv_src_up, cont, -1, cv::Scalar(255, 0, 0), 5);
    
    cv::drawContours(cv_src, filtered_cont, -1, cv::Scalar(255, 0, 0));
    
    if (show_roi)
    {
        for (int i = 0; i < filtered_cont.size(); ++i)
        {
            cv::Rect rect = cv::boundingRect(filtered_cont[i]);

            cv::Mat crop = cv_src(rect);
            if (crop.empty())
            {
                continue;
            }

            int up_w = up_scale * rect.width;
            int up_h = up_scale * rect.height;


            cv::Mat cv_up = cv::Mat::zeros(up_w, up_h, CV_8UC3);

            for (int i = 0; i < crop.cols; ++i)
            {
                for (int j = 0; j < crop.rows; ++j)
                {
                    cv::Mat roi = cv_up(cv::Rect(i * up_scale, j * up_scale, up_scale, up_scale));
                    roi = crop.at<cv::Vec<uchar, 3>>(j, i);
                }
            }


            std::vector<cv::Point> dis_cont;

            for (const auto& p : *cont_sub_pix[i])
            {
                //使用 floor() 函数向下取整
                int x = floor(((p->x - rect.x) + 0.5) * up_scale);
                int y = floor(((p->y - rect.y) + 0.5) * up_scale);
                cv::drawMarker(cv_up, cv::Point(x, y), cv::Scalar(0, 0, 255), cv::MARKER_TILTED_CROSS, 20, 3);
                dis_cont.emplace_back(x, y);
            }

            std::vector<std::vector<cv::Point>> display_contour_full{ dis_cont };
            cv::drawContours(cv_up, display_contour_full, 0, cv::Scalar(255.0, 0.0, 0.0), 3);

            cv::namedWindow("upScaled", 0);
            cv::imshow("upScaled", cv_up);
            cv::waitKey();
        }
    }

    cv::namedWindow("src", 0);
    cv::imshow("src", cv_src);
    cv::namedWindow("sub_pix_src", 0);
    cv::imshow("sub_pix_src", cv_src_up);
    cv::waitKey();
}

左边为像素级边缘轮廓，右边为亚像素边缘轮廓：
在这里插入图片描述

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

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

相关文章

JavaScript中的数据缓存与内存泄露：解密前端性能优化与代码健康

JavaScript中的数据缓存与内存泄露：解密前端性能优化与代码健康

​&#x1f308;个人主页&#xff1a;前端青山 &#x1f525;系列专栏&#xff1a;JavaScript篇 &#x1f516;人终将被年少不可得之物困其一生 依旧青山,本期给大家带来JavaScript篇专栏内容:JavaScript-数据缓存与内存泄露 目录 说说你对事件循环的理解 一、是什么 二、宏…
阅读更多...
Linux操作系统基础(7)：Linux的文件路径

Linux操作系统基础(7)：Linux的文件路径

1. Linux文件路径的介绍 在Linux系统中&#xff0c;文件路径是用来定位文件或目录在文件系统中位置的一种表示方法&#xff0c;它能够帮助用户快速、准确地定位文件或目录&#xff0c;并进行相应的操作。 文件路径可以分为 绝对路径 和 相对路径 两种类型&#xff1a; 绝对路…
阅读更多...
H266/VVC熵编码技术概述

H266/VVC熵编码技术概述

熵编码 熵编码&#xff1a; 是指按信息熵原理进行的无损编码方式&#xff0c;无损熵编码也是有损视频编码中的一个关键模块&#xff0c;它处于视频压缩系统的最末端。熵编码把一列系用来表示视频序列的元素符号转变为一个用来传输或存储的压缩码流&#xff0c;输入的符号可能包…
阅读更多...
提高开发效率的必备！超实用的VSCode插件推荐

提高开发效率的必备！超实用的VSCode插件推荐

前言 作为一个前端程序猿&#xff0c;我经常使用 VSCode 代码编辑器&#xff0c;但是每个开发者都有自己独特的工作风格和偏好。为了满足不同开发者的需求&#xff0c;VSCode 提供了丰富的插件生态系统。在本文中&#xff0c;我将为大家推荐一些强大的 VSCode 插件&#xff0c;…
阅读更多...
Linux学习之系统编程3（进程及wait函数）

Linux学习之系统编程3（进程及wait函数）

写在前面&#xff1a; 我的Linux的学习之路非常坎坷。第一次学习Linux是在大一下的开学没多久&#xff0c;结果因为不会安装VMware就无疾而终了&#xff0c;可以说是没开始就失败了。第二次学习Linux是在大一下快放暑假&#xff08;那个时候刚刚过完考试周&#xff09;&#xf…
阅读更多...
SpringFrameWork

SpringFrameWork

SpringFrameWork简介 介绍springFrameWork框架 Spring Framework是一个为企业级应用程序开发提供全面基础设施支持的开源框架&#xff0c;通过集成IoC、DI和AOP等技术&#xff0c;使得应用程序的开发更加灵活、可维护和可扩展。Spring MVC、SpringBoot、Spring Cloud、Spring D…
阅读更多...
java实现大文件分片上传

java实现大文件分片上传

背景&#xff1a; 公司后台管理系统有个需求&#xff0c;需要上传体积比较大的文件&#xff1a;500M&#xff0d;1024M&#xff1b;此时普通的文件上传显然有些吃力了&#xff0c;加上我司服务器配置本就不高&#xff0c;带宽也不大&#xff0c;所以必须考虑多线程异步上传来提…
阅读更多...
数据结构与算法python版本之线性结构之队列Quene

数据结构与算法python版本之线性结构之队列Quene

什么是队列&#xff1f; 队列是一种有次序的数据集合&#xff0c;其特征是&#xff1a;新数据项的添加总发生在一端&#xff08;通常称为“尾rear”端&#xff09;&#xff0c;而现存数据项的移除总发生在另一端&#xff08;通常称为“首front”端&#xff09;&#xff1b;当数…
阅读更多...
缓存数据一致性策略如何分类？

缓存数据一致性策略如何分类？

一、概述 数据库与缓存数据一致性问题&#xff0c;一直以来都是大家比较关注的问题。针对一致性的解决方案也是非常多&#xff0c;以下主要针对方案的梳理与分类&#xff1a; 数据库数据与缓存数据一致性的方案&#xff0c;可以从不同的角度来分类&#xff0c;比如&#xff1…
阅读更多...
稳定币记录

稳定币记录

稳定币&#xff1a; 稳定币&#xff08;Stablecoin&#xff09;是一种加密货币&#xff0c;其设计目的是维持相对稳定的价值&#xff0c;通常与某种法定货币&#xff08;如美元、欧元&#xff09;或其他资产&#xff08;如黄金&#xff09;挂钩。稳定币通过将加密货币与相应的…
阅读更多...
Flink-【时间语义、窗口、水位线】

Flink-【时间语义、窗口、水位线】

1. 时间语义 1.1 事件时间&#xff1a;数据产生的事件&#xff08;机器时间&#xff09;&#xff1b; 1.2 处理时间&#xff1a;数据处理的时间&#xff08;系统时间&#xff09;。 &#x1f330;&#xff1a;可乐 可乐的生产日期 事件时间&#xff08;可乐产生的时间&…
阅读更多...
计算机毕业设计 SpringBoot的停车场管理系统 Javaweb项目 Java实战项目 前后端分离 文档报告 代码讲解 安装调试

计算机毕业设计 SpringBoot的停车场管理系统 Javaweb项目 Java实战项目 前后端分离 文档报告 代码讲解 安装调试

&#x1f34a;作者&#xff1a;计算机编程-吉哥 &#x1f34a;简介&#xff1a;专业从事JavaWeb程序开发&#xff0c;微信小程序开发&#xff0c;定制化项目、 源码、代码讲解、文档撰写、ppt制作。做自己喜欢的事&#xff0c;生活就是快乐的。 &#x1f34a;心愿&#xff1a;点…
阅读更多...
逻辑回归算法到底能做什么

逻辑回归算法到底能做什么

逻辑回归&#xff08;Logistic Regression&#xff09;是一种广义的线性回归分析模型&#xff0c;常用于数据挖掘、疾病自动诊断、经济预测等领域。它根据给定的自变量数据集来估计事件的发生概率。变量的范围在0和1之间&#xff0c;通常用于二分类问题&#xff0c;最终输出的预…
阅读更多...
Opencv(C++)学习之cv::calcHist 任意bin数量进行直方图计算

Opencv(C++)学习之cv::calcHist 任意bin数量进行直方图计算

**背景&#xff1a;**当前网上常见的直方图使用方法都是默认使用256的范围&#xff0c;而对于使用特定范围的直方图方法讲的不够清楚。仔细研究后总结如下&#xff1a; 1、常见使用方法&#xff0c;直接对灰度图按256个Bin进行计算。 Mat mHistUn; int channels[1] { 0 }; {…
阅读更多...
键盘数字键打不出来怎么解锁？收藏好这4个简单方法！

键盘数字键打不出来怎么解锁？收藏好这4个简单方法！

“我在使用电脑进行办公时&#xff0c;突然发现我电脑键盘的数字键无法输入&#xff0c;这该怎么办呢&#xff1f;我应该如何解锁呢&#xff1f;请给我出出主意吧&#xff01;” 在日常使用电脑时&#xff0c;很多用户都需要使用键盘输入文字。但有时候部分用户也会遇到键盘数字…
阅读更多...
你知道vue中key的原理吗？说说你对它的理解

你知道vue中key的原理吗？说说你对它的理解

一、Key是什么 开始之前&#xff0c;我们先还原两个实际工作场景 当我们在使用v-for时&#xff0c;需要给单元加上key <ul><li v-for"item in items" :key"item.id">...</li> </ul>用new Date()生成的时间戳作为key&#xff0c…
阅读更多...
Docker 网络管理

Docker 网络管理

一、Docker网络简介 Docker网络是容器化应用程序的重要组成部分&#xff0c;它使得容器之间可以互相通信和连接&#xff0c;同时也提供了容器与外部环境之间的隔离和连接。 二、Docker网络网络模式 Docker 提供了多种网络模式&#xff0c;可以通过docker network ls 命令查看…
阅读更多...
springboot实现ChatGPT式调用（一次调用，持续返回）

springboot实现ChatGPT式调用（一次调用，持续返回）

下边实现了一个持续返回100以内随机数的接口&#xff0c;在接口超时之前会每隔1秒返回一个随机数 GetMapping(value "/getRandomNum", produces MediaType.TEXT_EVENT_STREAM_VALUE) public SseEmitter getRandomNum() {SseEmitter emitter new SseEmitter();Th…
阅读更多...
五、Spring AOP面向切面编程（基于注解方式实现和细节）

五、Spring AOP面向切面编程（基于注解方式实现和细节）

本章概要 Spring AOP底层技术组成初步实现获取通知细节信息切点表达式语法重用&#xff08;提取&#xff09;切点表达式环绕通知切面优先级设置CGLib动态代理生效注解实现小结 5.5.1 Spring AOP 底层技术组成 动态代理&#xff08;InvocationHandler&#xff09;&#xff1a;…
阅读更多...
SQL Server 权限管理

SQL Server 权限管理

CSDN 成就一亿技术人&#xff01; 2024年 第一篇 难度指数&#xff1a;* * CSDN 成就一亿技术人&#xff01; 目录 1. 权限管理 什么是权限管理&#xff1f; SQL server的安全机制 服务器级角色 数据库级角色 对象级角色 2. 创建用户 赋予权限 最重要的一步骤 1. 权限…
阅读更多...
最新文章

Copyright @ 2022~2023

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