计算机视觉class5

最新推荐文章于 2022-09-08 20:06:04 发布
最新推荐文章于 2022-09-08 20:06:04 发布
阅读量494 收藏 4
点赞数
分类专栏： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29952277/article/details/78694197
版权

要点

1.边界线链码
2.链码的长度，区域面积
3.计算灰度共生矩阵，特征
4.SIFT特征

解释

1.边界线链码
简单来说就是利用一个八邻域去搜索图像的边界，这里自然指的是二值图像。
利用点的八邻域信息，选择下一个点作为边界点，这个算法需要选择一个开始点，可以选择图像上是目标点，在最上，最左的点。然后查看它的八邻域的点，从右下方45°的位置开始寻找，如果是目标点，将沿顺时针90°作为下一次寻找的方向，如果不是，则逆时针45°继续寻找，一旦找到重复上面的过程。

参考：CSDN

2.灰度共生矩阵
我自己还是不写了，大家看参考。
参考：CSDN

3.SIFT特征
原理网上一搜一大把。。
参考：CSDN

程序

1.边界线链码

#include <cv.h>  
#include <highgui.h>  
#include <iostream>  
#include <stack>  
using namespace std;



int main()
{
    IplImage * image, *image2, *image3;
    image = cvLoadImage("F:\\c_code\\week8_1\\week8_1\\1.png", 0);
    cvNamedWindow("image", 1);
    cvShowImage("image", image);

    image2 = cvCreateImage(cvSize(image->width, image->height), image->depth, 1);
    image3 = cvCreateImage(cvSize(image->width, image->height), image->depth, 1);
    cvZero(image2);//image2 赋值为0  
    cvZero(image3);
    //寻找区域的左上角点  
    CvPoint startPoint = cvPoint(0, 0);
    bool bFindStartpoint = false;
    int i, j;
    unsigned char * ptr, *dst;
    stack<int> board;//奇数位存储x坐标，偶数位存储y坐标  

    //当前扫描点  
    CvPoint currentPoint = cvPoint(0, 0);
    //邻域的8个点的方向  
    int directions[8][2] = { { 0, 1 }, { 1, 1 }, { 1, 0 }, { 1, -1 }, { 0, -1 }, { -1, -1 }, { -1, 0 }, { -1, 1 } };
    int beginDirection = 0;
    bool bFindBoardpoint = false;//寻找到邻域的边界点的判定  
    for (i = 0; i< image->height && bFindStartpoint == false; i++)
    {
        for (j = 0; j< image->width && bFindStartpoint == false; j++)
        {
            ptr = (unsigned char *)(image->imageData + i*image->widthStep + j);
            if (*ptr == 255)
            {
                startPoint.x = j;
                startPoint.y = i;
                bFindStartpoint = true;
                cout<<"x:  " << j <<" y :  " <<i <<endl;    
                cvWaitKey(0);
            }
        }
    }

    //进行边界跟踪 每次搜索8个方向的点 找到了即停止  
    currentPoint = startPoint;
    bFindStartpoint = false;
    beginDirection = 0;
    board.push(startPoint.x);
    board.push(startPoint.y);
    while (!bFindStartpoint)
    {
        bFindBoardpoint = false;
        //在8个方向寻找符合条件的边界点  
        while (!bFindBoardpoint)
        {
            //进行出界判定   
            ptr = (unsigned char *)(image->imageData + (currentPoint.y + directions[beginDirection][1])* image->widthStep + currentPoint.x + directions[beginDirection][0]);
            if (*ptr == 255)
            {
                bFindBoardpoint = true;
                currentPoint.x += directions[beginDirection][0];
                currentPoint.y += directions[beginDirection][1];
                /************************************************************************/
                /*  此处添加序列存储的代码                    */
                /************************************************************************/
                //一、将边界存储到图片中  
                dst = (unsigned char *)image2->imageData + currentPoint.y * image2->widthStep + currentPoint.x;
                *dst = 255;

                //二、将边界点的序列存储到一个堆栈中  
                board.push(currentPoint.x);
                board.push(currentPoint.y);

                if (currentPoint.x == startPoint.x  && currentPoint.y == startPoint.y)
                {
                    bFindStartpoint = true;
                }
                //改变下次首先开始扫描的方向  
                beginDirection -= 2;
                if (beginDirection < 0)
                {
                    beginDirection += 8;
                }



            }
            else
            {
                beginDirection++;
                beginDirection = beginDirection % 8;
            }
        }
        cout<<"currentPoint    "<<currentPoint.x <<"     "<< currentPoint.y<<endl;  
    }
    cvNamedWindow("image2", 1);
    cvShowImage("image2", image2); 

    int lianmaLength = (board.size() + 5) / 10;
    int* lianma = new int[lianmaLength];

    for (i = 0; i< lianmaLength && !board.empty(); i += 2)
    {
        lianma[i + 1] = board.top();
        board.pop();
        lianma[i] = board.top();
        board.pop();

        for (j = 0; j< 18 && !board.empty(); j++)
        {
            board.pop();
        }
    }
    //将数据在image3中显示  
    int t;
    for (t = 0; t < lianmaLength; t += 2)
    {
        i = lianma[t + 1];
        j = lianma[t];
        ptr = (unsigned char *)image3->imageData + i*image->widthStep + j;
        *ptr = 255;

    }
    cvNamedWindow("image3", 1);
    cvSaveImage("E:\\image\\bottle2lianma.bmp", image3);
    cvShowImage("image3", image3);


    cvWaitKey(0);
    return 0;
}

注：这里的代码在找到初始点后，进行了等待，此时按下任意键，程序继续执行。控制台输出点的位置。

结果：
这里写图片描述这里写图片描述这里写图片描述)这里写图片描述

2.链码的长度，区域面积

#include <opencv2\opencv.hpp>
#include <iostream>
using namespace cv;
using namespace std;
int main()
{
    Mat srcImage = imread("F:\\c_code\\week8_2\\week8_2\\1.png",0);
    for (int y = 0; y < srcImage.rows; y++)
    {
        uchar* data = srcImage.ptr<uchar>(y);
        for (int x = 0; x < srcImage.cols; x++)
        {
            if (data[x] < 100)
                data[x] = 0;
            else
                data[x] = 255;
        }
    }
    imshow("srcImage", srcImage);

    vector<vector<Point>> contours;
    vector<Vec4i> hier;
    double length,area;
    findContours(srcImage, contours,RETR_EXTERNAL,CHAIN_APPROX_NONE);
    for (int i = 0; i < (int)contours.size(); i++)
    {
        area = contourArea(contours[i]);
        length = arcLength(contours[i], true);
        cout << " area is " << area;
        cout << " length is " << length << endl;
    }
    waitKey(0);
    return 0;
}

这一段不解释了。

3.灰度共生矩阵

#include<iostream>
#include<opencv2/highgui.hpp>
#include<opencv2/core.hpp>
//#include<opencv2/imgcodecs.hpp>
#include<opencv2/opencv.hpp>
using namespace std;
using namespace cv;

const int gray_level = 16;

void getglcm_horison(Mat& input, Mat& dst)//0度灰度共生矩阵
{
    Mat src = input;
    CV_Assert(1 == src.channels());
    src.convertTo(src, CV_32S);
    int height = src.rows;
    int width = src.cols;
    int max_gray_level = 0;
    for (int j = 0; j < height; j++)//寻找像素灰度最大值
    {
        int* srcdata = src.ptr<int>(j);
        for (int i = 0; i < width; i++)
        {
            if (srcdata[i] > max_gray_level)
            {
                max_gray_level = srcdata[i];
            }
        }
    }
    max_gray_level++;//像素灰度最大值加1即为该矩阵所拥有的灰度级数
    if (max_gray_level > 16)//若灰度级数大于16，则将图像的灰度级缩小至16级，减小灰度共生矩阵的大小。
    {
        for (int i = 0; i < height; i++)
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width; j++)
            {
                srcdata[j] = (int)srcdata[j] / gray_level;
            }
        }

        dst.create(gray_level, gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height; i++)
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width - 1; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata[j + 1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
    else//若灰度级数小于16，则生成相应的灰度共生矩阵
    {
        dst.create(max_gray_level, max_gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height; i++)
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width - 1; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata[j + 1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
}


void getglcm_vertical(Mat& input, Mat& dst)//90度灰度共生矩阵
{
    Mat src = input;
    CV_Assert(1 == src.channels());
    src.convertTo(src, CV_32S);
    int height = src.rows;
    int width = src.cols;
    int max_gray_level = 0;
    for (int j = 0; j < height; j++)
    {
        int* srcdata = src.ptr<int>(j);
        for (int i = 0; i < width; i++)
        {
            if (srcdata[i] > max_gray_level)
            {
                max_gray_level = srcdata[i];
            }
        }
    }
    max_gray_level++;
    if (max_gray_level > 16)
    {
        for (int i = 0; i < height; i++)//将图像的灰度级缩小至16级，减小灰度共生矩阵的大小。
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width; j++)
            {
                srcdata[j] = (int)srcdata[j] / gray_level;
            }
        }

        dst.create(gray_level, gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 0; j < width; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
    else
    {
        dst.create(max_gray_level, max_gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 0; j < width; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
}


void getglcm_45(Mat& input, Mat& dst)//45度灰度共生矩阵
{
    Mat src = input;
    CV_Assert(1 == src.channels());
    src.convertTo(src, CV_32S);
    int height = src.rows;
    int width = src.cols;
    int max_gray_level = 0;
    for (int j = 0; j < height; j++)
    {
        int* srcdata = src.ptr<int>(j);
        for (int i = 0; i < width; i++)
        {
            if (srcdata[i] > max_gray_level)
            {
                max_gray_level = srcdata[i];
            }
        }
    }
    max_gray_level++;
    if (max_gray_level > 16)
    {
        for (int i = 0; i < height; i++)//将图像的灰度级缩小至16级，减小灰度共生矩阵的大小。
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width; j++)
            {
                srcdata[j] = (int)srcdata[j] / gray_level;
            }
        }

        dst.create(gray_level, gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 0; j < width - 1; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j + 1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
    else
    {
        dst.create(max_gray_level, max_gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 0; j < width - 1; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j + 1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
}


void getglcm_135(Mat& input, Mat& dst)//135度灰度共生矩阵
{
    Mat src = input;
    CV_Assert(1 == src.channels());
    src.convertTo(src, CV_32S);
    int height = src.rows;
    int width = src.cols;
    int max_gray_level = 0;
    for (int j = 0; j < height; j++)
    {
        int* srcdata = src.ptr<int>(j);
        for (int i = 0; i < width; i++)
        {
            if (srcdata[i] > max_gray_level)
            {
                max_gray_level = srcdata[i];
            }
        }
    }
    max_gray_level++;
    if (max_gray_level > 16)
    {
        for (int i = 0; i < height; i++)//将图像的灰度级缩小至16级，减小灰度共生矩阵的大小。
        {
            int*srcdata = src.ptr<int>(i);
            for (int j = 0; j < width; j++)
            {
                srcdata[j] = (int)srcdata[j] / gray_level;
            }
        }

        dst.create(gray_level, gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 1; j < width; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j - 1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
    else
    {
        dst.create(max_gray_level, max_gray_level, CV_32SC1);
        dst = Scalar::all(0);
        for (int i = 0; i < height - 1; i++)
        {
            int*srcdata = src.ptr<int>(i);
            int*srcdata1 = src.ptr<int>(i + 1);
            for (int j = 1; j < width; j++)
            {
                int rows = srcdata[j];
                int cols = srcdata1[j - 1];
                dst.ptr<int>(rows)[cols]++;
            }
        }
    }
}

void feature_computer(Mat&src, double& Asm, double& Eng, double& Con, double& Idm)//计算特征值
{
    int height = src.rows;
    int width = src.cols;
    int total = 0;
    for (int i = 0; i < height; i++)
    {
        int*srcdata = src.ptr<int>(i);
        for (int j = 0; j < width; j++)
        {
            total += srcdata[j];//求图像所有像素的灰度值的和
        }
    }

    Mat copy;
    copy.create(height, width, CV_64FC1);
    for (int i = 0; i < height; i++)
    {
        int*srcdata = src.ptr<int>(i);
        double*copydata = copy.ptr<double>(i);
        for (int j = 0; j < width; j++)
        {
            copydata[j] = (double)srcdata[j] / (double)total;//图像每一个像素的的值除以像素总和
        }
    }


    for (int i = 0; i < height; i++)
    {
        double*srcdata = copy.ptr<double>(i);
        for (int j = 0; j < width; j++)
        {
            Asm += srcdata[j] * srcdata[j];//能量
            if (srcdata[j]>0)
                Eng -= srcdata[j] * log(srcdata[j]);//熵             
            Con += (double)(i - j)*(double)(i - j)*srcdata[j];//对比度
            Idm += srcdata[j] / (1 + (double)(i - j)*(double)(i - j));//逆差矩
        }
    }
}

int main()
{
    Mat dst_horison, dst_vertical, dst_45, dst_135;

    Mat src = imread("F:\\c_code\\week8_3\\week8_3\\1.jpg");
    if (src.empty())
    {
        return -1;
    }
    Mat src_gray;
    cvtColor(src, src_gray, COLOR_BGR2GRAY);
    imshow("srcImage", src_gray);
    getglcm_horison(src_gray, dst_horison);
    getglcm_vertical(src_gray, dst_vertical);
    getglcm_45(src_gray, dst_45);
    getglcm_135(src_gray, dst_135);

    double eng_horison = 0, con_horison = 0, idm_horison = 0, asm_horison = 0;
    feature_computer(dst_horison, asm_horison, eng_horison, con_horison, idm_horison);

    cout << "能量:" << asm_horison << endl;
    cout << "熵:" << eng_horison << endl;
    cout << "对比度:" << con_horison << endl;
    cout << "逆差分矩:" << idm_horison << endl;
    cout << "------------------------------------------------------------------------" << endl;

      for (int i = 0; i < dst_horison.rows; i++)
    {
    int *data = dst_horison.ptr<int>(i);
    for (int j = 0; j < dst_horison.cols; j++)
    {
    cout << data[j] << " ";
    }
    cout << endl;
    }
    cout << endl;

    for (int i = 0; i < dst_vertical.rows; i++)
    {
    int *data = dst_vertical.ptr<int>(i);
    for (int j = 0; j < dst_vertical.cols; j++)
    {
    cout << data[j] << " ";
    }
    cout << endl;
    }
    cout << endl;

    for (int i = 0; i < dst_45.rows; i++)
    {
    int *data = dst_45.ptr<int>(i);
    for (int j = 0; j < dst_45.cols; j++)
    {
    cout << data[j] << " ";
    }
    cout << endl;
    }

    cout << endl;

    for (int i = 0; i < dst_135.rows; i++)
    {
    int *data = dst_135.ptr<int>(i);
    for (int j = 0; j < dst_135.cols; j++)
    {
    cout << data[j] << " ";
    }
    cout << endl;
    }
    waitKey(0);
    return 0;
}

结果：
这里写图片描述这里写图片描述

4.SIFT特征

#include <opencv2\opencv.hpp>
#include <opencv2\nonfree\features2d.hpp>
#include <iostream>
#include <opencv2\nonfree\\nonfree.hpp>
#include <opencv2\legacy\legacy.hpp>
using namespace cv;
using namespace std;

int main()
{
    Mat img_1 = imread("F:\\c_code\\week8_4\\week8_4\\1.png");

    Mat img_2 = imread("F:\\c_code\\week8_4\\week8_4\\2.png");
    Mat dstImage1, dstImage2;
    std::vector<KeyPoint> keyPoint1, keyPoint2;
    Mat descriptor1, descriptor2;
    SiftFeatureDetector sift1(500000000);
    SiftFeatureDetector sift2(500000000);
    SiftDescriptorExtractor siftdescriptor;
    sift1.detect(img_1, keyPoint1);
    sift2.detect(img_2, keyPoint2);
    drawKeypoints(img_1, keyPoint1, dstImage1, Scalar(0, 0, 255));
    drawKeypoints(img_2, keyPoint2, dstImage2, Scalar(0, 0, 255));
    siftdescriptor.compute(img_1, keyPoint1, descriptor1);
    siftdescriptor.compute(img_2, keyPoint2, descriptor2);

    vector<DMatch> matches;
    BruteForceMatcher<L2<float>> matcher;
    matcher.match(descriptor1, descriptor2, matches, Mat());
    Mat out;
    drawMatches(img_1, keyPoint1, img_2, keyPoint2, matches, out);
    imshow("dstImage1", dstImage1);
    imshow("dstImage2", dstImage2);
    imshow("result", out);

    double min = 100000, max = 0;
    for (int i = 0; i < descriptor1.rows; i++)
    {
        double dist = matches[i].distance;
        if (dist < min) min = dist;
        if (dist>max) max = dist;
    }

    std::vector<DMatch> good;
    for (int i = 0; i < descriptor1.rows; i++)
    {
        if (matches[i].distance <= std::max(2.6 * min, 30.0))
            good.push_back(matches[i]);
    }

    Mat goodMatch;
    drawMatches(img_1, keyPoint1, img_2, keyPoint2, good, goodMatch);
    imshow("after optimization", goodMatch);
    waitKey(0);
    return 0;
}

结果：
这里写图片描述这里写图片描述这里写图片描述这里写图片描述
关于怎么去滤掉一些误匹配的情况，还是有很多办法的，这里只用了最简单的一种。

最后

这是这个系列的最后一篇了，这门计算机视觉课也上完了（啥计算机视觉啊，明明是图像处理好嘛），Anyway，要画上句号了，接下来我会主要把精力集中在deep learning和图形学上面了，see you！

Steve_Xu123
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
计算机视觉（英文版）
07-20
5 ANALYTICAL IMAGE FEATURES 120 5.1 Elements of Analytical Euclidean Geometry 120 5.1.1 Coordinate Systems and Homogeneous Coordinates 121 5.1.2 Coordinate System Changes and Rigid Transformations 124...
计算机网络class5（分层结构、协议、接口、服务）
老黑的博客
09-24 836
分层结构、协议、接口、服务 1、为什么要分层 发送文件前要完成的工作： 发起通信的计算机必须将数据通信的通路进行激活 要告诉网络如何识别目的主机 发起通信的计算机要查明目的主机是否开机，并且与网络连接正常 发起通信的计算机要弄清楚，对方计算机中文件管理程序是否已经做好准备工作 确保差错和意外可以解决 … 2、怎么分层 分层的基础原则 各层之间相互独立，每层只实现一种相对独立的功能。 每层之间界面自然清晰，易于理解，相互交流尽可能少。 结构上可分隔开。每层都采用最合适的技术来实现。 保持下层对上层的独
class5——搭建网站
m0_58346385的博客
11-04 281
一、设置PyCharm环境 为了使下载在电脑上的包可以继续使用，需要在prefenrence里设置环境，我用的是anaconda的环境，注意此时选择的是system interpreter，在此选项下进行anaconda环境配置 二、阶段一：在main.py里输入代码 from flask import Flask app = Flask(__name__) @app.route('/') #路由器 def hello_world(): return 'Hello, ...
计算机视觉中transformer的理解
m0_46339652的博客
07-29 8416
目录一、Transformer原理模型思想1、(Encoder-Decoder，编码器-解码器)1.1、 Encoder1.2、 Decoder2、Transformer相比于CNN的优缺点3、总结二、transformer在CV的应用1、分类（backbone）2、目标检测(Detection Transformer)参考文献 Transformer 2017 年被提出，NLP中红极一时的 BERT、GPT-2 都采用了基于 Transformer 的架构。近年来，Transformer 成为深度学习领域
计算机视觉中的Transformer
weixin_43600140的博客
03-08 1786
计算机视觉中的Transformer 序 自从2017年Attention Is All You Need论文，Transformer热度持续升高，因为其解决的是"seqence to sequence"属性的问题，所以先是在自然语言处理中席卷各类问题，其代表性工作为BERT。BERT截至今天在Github已有27.2k⭐，火的我没词了… 就好比约5年前，循环神经网络（RNN）先火遍NLP，随后又入侵CV。现在，Transformer也是在席卷了NLP的各类问题后，正在席卷CV的各类问题。前几天连GANs
计算机视觉项目-实时目标追踪
m0_37623374的博客
09-08 8346
目标追踪技术对于民生、社会的发展以及国家军事能力的壮大都具有重要的意义。它不仅仅可以应用到体育赛事当中目标的捕捉，还可以应用到交通上，比如实时监测车辆是否超速等！对于国家的军事也具有一定的意义，比如说导弹识别目标等方向。所以说实时目标追踪技术对于整个社会来说都是非常重要的！目前被应用的比较多的，而且效果较好的是YOLO系列，目前已经更新到了YOLO7。原作者更新到了YOLO3之后就不再更新YOLO这个系列了，因为被一些不法人员应用到了军事上，给民众要造成了一定的伤害！但是依旧没有阻挡住YOLO的发展。
颜色分类leetcode-class.vision:SRU中的计算机视觉和深度学习
07-06
计算机视觉机器学习和深度学习简介，德黑兰沙希德拉贾伊大学（SRU）的课程，于 2018 年冬秋两季举办。 课程从使用python opencv实用方法介绍计算机视觉开始，然后继续介绍学习算法和神经网络。 在此之后，2012年以后...
imagenet-1k的classnames.txt
04-08
imagenet-1k的classnames.txt
计算机视觉之图像分割数据集：10种不同纹理下的缺陷分割数据集（二值图像分割）
01-23
数据共有十个子文件夹class1-class10，代表十种不同的纹理图案。每个类别下划分好了训练集和测试集，分别在Train和Test文件夹下 数据集介绍：分为训练集、测试集 训练集-train-：images图片目录+masks模板目录 测试...
计算机视觉实验LAB——照相机标定与位姿计算(上)
01-06
我们使用了一个名为GenericCamemra的virtual class类型来定义任何一种相机模型。这一点很重要，你可以品尝到编程的灵魂味道就在这里面: ) C++接口描述了类的行为和功能，而不需要完成类的特定实现。 C++接口是使用...
android手机应用源码Imsdroid语音视频通话源码.rar
05-20
android手机应用源码Imsdroid语音视频通话源码.rar
营销计划汇报PPT，市场品牌 推广渠道 产品 营销策略tbb.pptx
05-20
营销计划汇报PPT，市场品牌 推广渠道 产品 营销策略tbb.pptx
JavaScript_超过100种语言的纯Javascript OCR.zip
05-20
JavaScript
JavaScript_跨平台React UI包.zip
05-20
JavaScript
node-v16.17.0-headers.tar.xz
最新发布
05-20
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
520表白代码.rar
05-20
520表白html5爱心代码
一个简单的HTML5和CSS代码示例，用于创建一个动态的爱心形状，并在网页上展示一个类似520表白的消息 这个示例使用了CSS的
05-20
520表白html5爱心代码 一个简单的HTML5和CSS代码示例，用于创建一个动态的爱心形状，并在网页上展示一个类似520表白的消息。这个示例使用了CSS的动画效果和HTML的结构。
智慧养老社区方案.pdf
05-20
智慧养老社区方案.pdf
node-v14.11.0-headers.tar.xz
05-20
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
attention 计算机视觉
09-06
Attention在计算机视觉中指的是注意力机制，其基本思想是使系统能够学会注意力，即能够忽略无关信息而关注重点信息。 在计算机视觉中，类似于我们看一张图片时，我们的注意力往往会集中在图片中的某些特定区域，比如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值