cuda学习笔记（6） windows opencv安装及使用，常见图像处理操作的GPU实现

于 2024-08-15 19:36:55 发布
阅读量492 收藏 14
点赞数 9
分类专栏： cuda 文章标签： 学习 笔记 windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43528481/article/details/140360404
版权

1 openCV 简介及安装 + windows10 系统

在这里插入图片描述

  • opencv官网下载opencv包，下载的时候经尽量不要选择带*版本的，这些版本还在持续更新中，然后直接双击按照提示进行安装即可，记住安装的位置目录

  • 在这里插入图片描述

  • 环境变量-> Path->新建->将opencv安装目录下的bin文件所在路径复制到新建的环境变量里面，也就是对应的第4步，我的安装路径如下：F:\Opencv\opencv\build\x64\vc15\bin -》应用（选vc14还是15和你安装的版本有关系）
    在这里插入图片描述

  • 配置VS环境-》项目属性》

  • 包含目录：将两个路径添加进去F:\Opencv\opencv\build\include\opencv2 和 F:\Opencv\opencv\build\include

  • 库目录：在下面路径里面F:\Opencv\opencv\build\x64\vc15\lib添加到库目录里面

在这里插入图片描述
点黄色的地方就可以进行编辑
在这里插入图片描述

  • C/C++ ->链接期->t附加依赖项目-》将目录F:\Opencv\opencv\build\x64\vc15\lib下I的opencv_world410d,lib添加进入环境
    在这里插入图片描述

2 openCV使用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3 图像灰度化和边缘提取 cpu实现呵GPU实现


#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include <opencv2/opencv.hpp>
#include <iostream>
#include<vector>

using namespace std;
using namespace cv;

#define TILE 16
const int KERNEL_RADIUS = 1;	// 卷积核的半径



//stride_input输入图像的步长，stride_output：输出图像的步长
// 卷积核写入GPU常量内存中
__constant__ int KERNEL[2 * KERNEL_RADIUS + 1][2 * KERNEL_RADIUS + 1] =
{ 1, 1, 1,
1, -8, 1,
1, 1, 1 };

__global__ void edge_kernel(unsigned char* input, unsigned char* output, int width, int height, int stride_input, int stride_output)
{
/*	每个像素对应一个线程，获取对应线程的x,y坐标，映射到图像上刚好对应图像的索引
		每个像素对应一个线程，获取对应线程的x,y坐标，映射到图像上刚好对应图像的索引*/
	int x = blockDim.x * blockIdx.x + threadIdx.x;
	int y = blockDim.y * blockIdx.y + threadIdx.y;
	int maskSize = 3;

	int channel = stride_input / width; //如果等于1表示是灰度图，如果等于3是RGB图
	float temp = 0;
	if (x > 0 && x < width-1 && y > 0 && y < height-1 && channel == 1)
	{
		for (int i = 0; i < maskSize; i++) {
			for (int j = 0; j < maskSize; j++) {
				temp += input[(y+j)* width + x + i] * KERNEL[j][i];
			}
		}
		output[y * stride_output + x] = temp;
	}
}

int main()
{
	Mat frame = imread("I:\\ONE_grade\\SZ_code\\class\\CudaRuntime2\\bg.jpg");
	cout << frame.cols << "  " << frame.rows << "  " << frame.step << ",static_cast<int>(frame.step) = " << static_cast<int>(frame.step) << endl;

	Mat grey, edge_gpu(frame.rows, frame.cols, CV_8UC1); //8bite, 灰度图是1通道
	Mat Edge_pic;

	//**********************************  CPU掩膜实现边缘提取  **************************** 
	//灰度化
	cvtColor(frame, grey, COLOR_BGR2GRAY);

	clock_t time_start, time_end;
	time_start = clock();
	//边缘提取
	Mat mask = (Mat_<char>(3, 3) << -1, -1, -1, -1, 8, -1, -1, -1, -1);
	filter2D(grey, Edge_pic, grey.depth(), mask);
	time_end = clock();
	cout << " the cpu time = " << time_end - time_start << endl;

	//**************************** GPU掩膜实现边缘提取   **************************** 
		//分配GPU空间
	unsigned char* input, * output;
	cudaMalloc((void**)&input, static_cast<int>(grey.step) * grey.rows * sizeof(unsigned char));
	cudaMalloc((void**)&output, static_cast<int>(edge_gpu.step) * edge_gpu.rows * sizeof(unsigned char));

	//将数据从cpu拷贝到GPU
	cudaMemcpy(input, grey.data, static_cast<int>(grey.step) * grey.rows * sizeof(unsigned char), cudaMemcpyHostToDevice);

	time_start = clock();
	//gpu上处理数据
	dim3 blockdim(TILE, TILE);
	//下面是一种设置技巧，能刚好设置一个线程处理一个像素，尽可能减少浪费
	dim3 griddim((edge_gpu.cols + TILE - 1) / TILE, (edge_gpu.rows + TILE - 1) / TILE);
	edge_kernel << <griddim, blockdim >> > (input, output, grey.cols, grey.rows, static_cast<int>(grey.step), static_cast<int>(edge_gpu.step));

	//将GPU上处理完毕的数据从GPU拷贝到CPU
	cudaMemcpy(edge_gpu.data, output, static_cast<int>(edge_gpu.step) * edge_gpu.rows * sizeof(unsigned char), cudaMemcpyDeviceToHost);
	cudaDeviceSynchronize();
	time_end = clock();
	cout << " the GPU time = " << time_end - time_start << endl;

	namedWindow("grey", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("grey", grey);

	namedWindow("cpu result", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("cpu result", Edge_pic);

	namedWindow("edge_gpu", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("edge_gpu", edge_gpu);

	//如果想要实现按到ESC才退出，
	while (true)
	{
		int key = waitKey();
		if (key == 27)
			break;
	}
	return 0;
}

在这里插入图片描述

  • 灰度图和BGR图在openCVL里面的存储方式如下，BGR是连续3个点表示一个数据点的值，3个点分别是BGR
    在这里插入图片描述
  • 灰度图

在这里插入图片描述

  • RGB

  • 在这里插入图片描述

  • 一些特殊情况，补的哪些位置都是不记录任何信息的，他可以是任意值，但不会影响图像
    在这里插入图片描述
    在这里插入图片描述

4 图像直方图均衡化和图像增强

在这里插入图片描述

5 BGR图转灰度图

（1）常用的openCV处理图像的命令

在这里插入图片描述

  • 获取灰度图某点的像素值示例

在这里插入图片描述

（2）BGR图转灰度图,对比openCV自带库函数和GPU转换之间的速度

在这里插入图片描述


#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include <opencv2/opencv.hpp>
#include <iostream>
#include<vector>

using namespace std;
using namespace cv;

#define TILE 16

//stride_input输入图像的步长，stride_output：输出图像的步长
__global__ void bgr2grey_kernel(unsigned char *input, unsigned char *output, int width, int height, int stride_input, int stride_output)
{
	//每个像素对应一个线程，获取对应线程的x,y坐标，映射到图像上刚好对应图像的索引
	int x = blockDim.x * blockIdx.x + threadIdx.x;
	int y = blockDim.y * blockIdx.y + threadIdx.y;

	int channel = stride_input / width; //如果等于1表示是灰度图，如果等于3是RGB图
	if(x < width && y < height)
	{
		if (channel == 1)   output[y * width + x] = input[y * width + x];
		if (channel == 3)   output[y * stride_output + x] = input[y * stride_input + x*3+0] * 0.114 +
			                                        input[y * stride_input + x * 3 + 1] * 0.587 +
													input[y * stride_input + x * 3 + 2] * 0.299;
	}

}

int main()
{
	Mat frame = imread("I:\\ONE_grade\\SZ_code\\class\\CudaRuntime2\\bg.jpg");
	cout << frame.cols << "  " << frame.rows << "  " << frame.step << ",static_cast<int>(frame.step) = " << static_cast<int>(frame.step)<<endl;

//---------------------------------------------------
	clock_t time_start, time_end;
	time_start =  clock();
	Mat grey, grey_gpu(frame.rows, frame.cols, CV_8UC1); //8bite, 灰度图是1通道
	cvtColor(frame, grey, COLOR_BGR2GRAY);   //灰度化
	time_end = clock();
	cout << " the cpu time = " << time_end - time_start << endl;

//---------------------------------------------------
	//分配GPU空间
	unsigned char* input, * output;
	cudaMalloc((void**)&input, static_cast<int>(frame.step) * frame.rows * sizeof(unsigned char));
	cudaMalloc((void**)&output, static_cast<int>(grey_gpu.step) * grey_gpu.rows * sizeof(unsigned char));

	//将数据从cpu拷贝到GPU
	cudaMemcpy(input, frame.data, static_cast<int>(frame.step) * frame.rows * sizeof(unsigned char), cudaMemcpyHostToDevice);

	time_start = clock();
	//gpu上处理数据
	dim3 blockdim(TILE, TILE);
	//下面是一种设置技巧，能刚好设置一个线程处理一个像素，尽可能减少浪费
	dim3 griddim((grey_gpu.cols + TILE - 1) / TILE, (grey_gpu.rows + TILE - 1) / TILE);
	bgr2grey_kernel << <griddim, blockdim >> > (input, output, frame.cols, frame.rows, static_cast<int>(frame.step), static_cast<int>(grey_gpu.step));

	//将GPU上处理完毕的数据从GPU拷贝到CPU
	cudaMemcpy( grey_gpu.data, output, static_cast<int>(grey_gpu.step) * grey_gpu.rows * sizeof(unsigned char), cudaMemcpyDeviceToHost);
	cudaDeviceSynchronize();
	time_end = clock();
	cout << " the GPU time = " << time_end - time_start << endl;

	namedWindow("grey", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("grey", grey);

	namedWindow("grey_gpu", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("grey_gpu", grey_gpu);

	//如果想要实现按到ESC才退出，
	while (true)
	{
		int key = waitKey();
		if (key == 27)
			break;
	}
	return 0;
}

在这里插入图片描述

6 图片的resize

在这里插入图片描述

7 图像直方图增强

在这里插入图片描述

  • 有bug，待调试。。。。。。。！！！！！！！！！！！！！！！！！

#include "cuda_runtime.h"
#include "device_launch_parameters.h"


#include <stdio.h>
#include <opencv2/opencv.hpp>
#include <iostream>
#include<vector>


using namespace std;
using namespace cv;

#define TILE 16



//step1：统计各个通道的灰度直方图
__global__ void hist_cal_kernel(unsigned char* input, int* hist, int width, int height, int stride)
{
	//每个像素对应一个线程，获取对应线程的x,y坐标，映射到图像上刚好对应图像的索引
	int x = blockDim.x * blockIdx.x + threadIdx.x;
	int y = blockDim.y * blockIdx.y + threadIdx.y;
	int z = blockDim.z;
	int channels = stride / width; 

	extern __shared__ int hist_S[];

	//获取当前线程在线程块里面的ID，共享内存只能在block里面同步，16*16的一个线程块，刚好能存储长度为256的hist
	int tid = threadIdx.y * blockDim.x + threadIdx.x;
	hist_S[tid] = 0;  //初始化为0
	__syncthreads();

	if (x < width && y < height && z < channels)
	{
		int value = input[y * stride + x * channels + z];
		atomicAdd(&hist_S[value],1);
	}
	__syncthreads();

	//动态内存的大小是256*frame.channels()*sizeof(int) ，也就是总的有256*3个数据
	//红。绿，蓝的顺序，前256是红通道的数据，依次类推
	atomicAdd(&hist[z * 256 + tid], hist_S[tid]);
}

//step2:求出总点数
__global__ void hist_sum(int *hist)
{
	//这里相当于是一个block一个block的去完成各自的累加
	int tid = threadIdx.y * blockDim.x + threadIdx.x;
	//这里blockIdx.x相当于通道数，因为核函数调用的时候，对256*3个数设置的是3个256的一维的block,所以blockID相当于通道数
	int x = blockIdx.x;    
	 __shared__ int hist_S[256];//调用了共享内存但是没有调用动态内存

	hist_S[tid] = hist[256*x + tid];  //初始化为0
	__syncthreads();

	for (int s = 128; s > 0; s >> 1)
	{
		if (tid < s)
		{
			hist_S[tid] += hist[s + tid];
		}
		__syncthreads();
	}

	//计算Fi
	int total = hist_S[0];
	if (tid == 0)
	{
		int sum = 0;
		for (int i = 0; i < 256; i++)
		{
			sum += hist[x * 256 + i];
			hist[x * 256 + i] = (int)((float)255 * sum / total);
		}
	}
}


//step3:直方图均衡化
__global__ void hist_trans_kernel(unsigned char* input, unsigned char* output, int* hist, int width, int height, int stride)
{
	int x = blockDim.x * blockIdx.x + threadIdx.x;
	int y = blockDim.y * blockIdx.y + threadIdx.y;
	int z = blockDim.z;
	int channels = stride/ width;

	if (x < width && y < height && z < channels)
	{
		int value = input[y * stride + x * channels + z];
		int F_value = hist[z * 256 + value];
		output[y * stride + channels * x + z] = F_value;
	}
}

int main()
{
	Mat frame = imread("I:\\ONE_grade\\SZ_code\\class\\CudaRuntime2\\bg.jpg");
	cout << frame.cols << "  " << frame.rows << "  " << frame.step << ",static_cast<int>(frame.step) = " << static_cast<int>(frame.step)<<endl;


	// ******************************** 调用openCV对RGB图像做直方图均衡化  ********************************
	Mat frame_hist_cpu, feame_hist_gpu(frame.rows, frame.cols, CV_8UC3);

    clock_t time_start, time_end;
	time_start = clock();
	vector<Mat> bgr_channels;
	split(frame, bgr_channels); //调用openCV自带函数将图像的三个通道分开
	for (int i = 0; i < frame.channels(); i++)
	{
		equalizeHist(bgr_channels[i], bgr_channels[i]);
	}
	merge(bgr_channels, frame_hist_cpu);
	time_end = clock();
	cout << " the CPU time = " << time_end - time_start << endl;
	
	// ******************************** 调用GPU对RGB图像做直方图均衡化  ********************************
	//分配GPU空间
	unsigned char* input, * output;
	int* hist;
	cudaMalloc((void**)&input, static_cast<int>(frame.step) * frame.rows * sizeof(unsigned char));
	cudaMalloc((void**)&output, static_cast<int>(feame_hist_gpu.step) * feame_hist_gpu.rows * sizeof(unsigned char));
	cudaMalloc((void**)&hist, frame.channels()*256*sizeof(int));

	//将数据从cpu拷贝到GPU
	cudaMemcpy(input, frame.data, static_cast<int>(frame.step) * frame.rows * sizeof(unsigned char), cudaMemcpyHostToDevice);

	time_start = clock();
	//gpu上处理数据
	dim3 blockdim(TILE, TILE);
	//下面是一种设置技巧，能刚好设置一个线程处理一个像素，尽可能减少浪费
	dim3 griddim((feame_hist_gpu.cols + TILE - 1) / TILE, (feame_hist_gpu.rows + TILE - 1) / TILE, feame_hist_gpu.channels());
	//调用了共享内存，所以参数有3个
	hist_cal_kernel << <griddim, blockdim,256*frame.channels()*sizeof(int) >> > (input, hist, frame.cols, frame.rows, static_cast<int>(frame.step));
	hist_sum << <frame.channels(), 256>> > (hist);
	hist_trans_kernel << < griddim, blockdim >> > (input, output, hist, frame.cols, frame.rows, static_cast<int>(frame.step));


	将GPU上处理完毕的数据从GPU拷贝到CPU
	cudaMemcpy(feame_hist_gpu.data, output, static_cast<int>(feame_hist_gpu.step) * feame_hist_gpu.rows * sizeof(unsigned char), cudaMemcpyDeviceToHost);

	time_end = clock();
	cout << " the GPU time = " << time_end - time_start << endl;


	namedWindow("原图", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("原图", frame);

	namedWindow("CPU 直方图均衡化的图", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("CPU 直方图均衡化的图", frame_hist_cpu);

	namedWindow("GPU 直方图均衡化的图", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("GPU 直方图均衡化的图", feame_hist_gpu);


	//如果想要实现按到ESC才退出，
	while (true)
	{
		int key = waitKey();
		if (key == 27)
			break;
	}
	return 0;
}

8 BGR转换成RGB

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include <opencv2/opencv.hpp>
#include <iostream>
#include<vector>

using namespace std;
using namespace cv;

#define TILE 16

__global__ void bgrTOrgb_kernel(unsigned char* input, unsigned char* output, int width, int height, int stride_input, int stride_output)
{
/*	每个像素对应一个线程，获取对应线程的x,y坐标，映射到图像上刚好对应图像的索引
		每个像素对应一个线程，获取对应线程的x,y坐标，映射到图像上刚好对应图像的索引*/
	int x = blockDim.x * blockIdx.x + threadIdx.x;
	int y = blockDim.y * blockIdx.y + threadIdx.y;
	int z = blockDim.z;

	//int channels = stride_input / width; //如果等于1表示是灰度图，如果等于3是RGB图
	//
	//if (x < width && y < height && z < channels && channels == 3)
	//{
	//	int bgr_temp = input[y * stride_input + x * channels + z];
	//	output[y * stride_output + x * channels + (2- z)] = bgr_temp;
	//}
	int index_in = (y * width + x) * 3;
	int index_out = (y * width + x) * 3;

	if (x < width && y < height) {
		// BRG to RGB
		output[index_out] = input[index_in + 2]; // R
		output[index_out + 1] = input[index_in + 1]; // G
		output[index_out + 2] = input[index_in]; // B
	}
}

int main()
{
	Mat frame = imread("I:\\ONE_grade\\SZ_code\\class\\CudaRuntime2\\bg.jpg");
	cout << frame.cols << "  " << frame.rows << "  " << frame.step << ",static_cast<int>(frame.step) = " << static_cast<int>(frame.step) << endl;

	Mat pic_cpu, pic_gpu(frame.rows, frame.cols, CV_8UC3); //8bite, 灰度图是1通道

	//**********************************  CPU BGR转RGB  **************************** 

	clock_t time_start, time_end;
	time_start = clock();
	cvtColor(frame, pic_cpu, COLOR_BGR2RGB);
	time_end = clock();
	cout << " the cpu time = " << time_end - time_start << endl;

	**************************** GPU掩膜实现边缘提取   **************************** 
	//	//分配GPU空间
	unsigned char* input, * output;
	cudaMalloc((void**)&input, static_cast<int>(frame.step) * frame.rows * sizeof(unsigned char));
	cudaMalloc((void**)&output, static_cast<int>(pic_gpu.step) * pic_gpu.rows * sizeof(unsigned char));

	//将数据从cpu拷贝到GPU
	cudaMemcpy(input, frame.data, static_cast<int>(frame.step) * frame.rows * sizeof(unsigned char), cudaMemcpyHostToDevice);

	time_start = clock();
	//gpu上处理数据
	dim3 blockdim(TILE, TILE);
	//下面是一种设置技巧，能刚好设置一个线程处理一个像素，尽可能减少浪费
	dim3 griddim((pic_gpu.cols + TILE - 1) / TILE, (pic_gpu.rows + TILE - 1) / TILE);
	bgrTOrgb_kernel << <griddim, blockdim >> > (input, output, pic_gpu.cols, pic_gpu.rows, static_cast<int>(frame.step), static_cast<int>(pic_gpu.step));

	//将GPU上处理完毕的数据从GPU拷贝到CPU
	cudaMemcpy(pic_gpu.data, output, static_cast<int>(pic_gpu.step) * pic_gpu.rows * sizeof(unsigned char), cudaMemcpyDeviceToHost);
	cudaDeviceSynchronize();
	time_end = clock();
	cout << " the GPU time = " << time_end - time_start << endl;

	namedWindow("原图", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("原图", frame);

	namedWindow("cpu result", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("cpu result", pic_cpu);

	namedWindow("gpu result", WINDOW_NORMAL);  //给图片命名并设置可以随意调整大小
	imshow("gpu result", pic_gpu);

	//如果想要实现按到ESC才退出，
	while (true)
	{
		int key = waitKey();
		if (key == 27)
			break;
	}
	return 0;
}

在这里插入图片描述

我学习过程的思考

1. 为什么获取BGR图像的某个位置的像素索引要用 input[y * stride_input + x * channels + z];，而不是 y * stride_input + x，我画的下面这个图有什么问题吗

在这里插入图片描述

猪猪虾的业余生活
关注
  • 9
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NCCV：使用Numba + CUDA + OpenCV进行计算机视觉和图像处理的短期课程
02-05
3. **OpenCV与Numba/CUDA结合**：学习如何将OpenCV的图像处理函数与Numba和CUDA集成，实现GPU加速的图像处理操作，如滤波、边缘检测、色彩空间转换等。 4. **性能优化**：探讨如何通过调整参数和优化算法来最大化...
opencv学习笔记.zip
04-17
Opencv简介 Opencv是计算机视觉中经典的专用库，其支持多语言，跨平台，功能强大。Opencv-Python为Opencv提供了Python接口，使得使用者在Python中能够调用C/C++,在 ...基于CUDA和OpenCL的高速GPU操作的接口也在积
计算机视觉与深度学习基本环境安装
01-06
计算机视觉与深度学习基本环境安装1. Python的安装与使用1.1 Python简介1.2 Python下载与安装1.2.1 Anaconda的下载与安装1.2.2 Python编译器PyCharm的安装2. TensorFlow类库的下载与安装2.1 TensorFlow的特征2.2 ...
【vm10+ubuntu14.04 LTS+caffe+cuda6.5】安装笔记
05-12
本文将详细介绍如何在虚拟机环境下搭建基于Ubuntu 14.04 LTS的操作系统，并安装Caffe、CUDA等相关组件，以实现无GPU环境下的Caffe部署。 #### 二、环境准备 **1. 虚拟机配置** - **虚拟机软件**: VMware ...
基于C++实现的人工智笔记
04-27
9. 深度学习：深度学习是AI领域的热门话题，C++可以作为底层实现语言，结合CUDA进行GPU加速。了解卷积神经网络（CNN）、循环神经网络（RNN）以及现代的Transformer架构的原理和实现是必要的。 10. 自然语言处理...
Element学习（布局组件、案例操作）（4）
m0_74363339的博客
08-08 459
value：表示输入的值，提交表单后传给服务器的值——>"男"表示1，"女"表示2。定义数据模型时，对象要使用大括号。像这里searchForm: {....}3、这一步之后的效果展示（只是空有一个布局——>目前还没有任何的内容）2、找到这种布局对应的代码（复制——>粘贴到标签<div>中）5、 在主展示区域的上方添加"员工查询"的（且独占一行）表单。还有一个当点击"查询"按钮时，会触发一个方法，也要去声明。7、给表格增加一个边框——>加入border属性即可。6、日期选择器——>(官网中组件中找)
OrangePi AIpro学习5 —— 模型推理程序开发
HuanBianCheng27的博客
08-13 1066
本章讲解Resnet50模型如何运行在昇腾芯片上，如何对图片进行推理
【IC设计】昇腾910架构学习
VICI的博客
08-10 310
昇腾910是华为的AI训练卡，基于7nm EUV工艺，其中有16个基于ARMv8定制的CPU，32个Ascend-Max AI加速器，使用4*6的无缓存NoC Mesh进行互联，使用HBM（High Bandwidth Memory）进行存储，提供128通道的视频译码器。本文内容是参考华为公开资料形成的个人观点，无侵权行为，内容仅供学习！
VTK-vtkStructuredGrid学习
weixin_69505365的博客
08-14 287
可以理解为单元格顺序沿着坐标轴排列，但是每个单元格可以不一样。维度理解为X/Y/Z方向的点数，如草图所示分别是4，3，1。此时只提供了12个点，只能构造一层，5.点图、线图、面图如下，对应行的代码改一下出现不同效果图。7.增加Z方向维度，点也要增加，点序保持一致。6.点可以不在同一个平面，随机改变点Z数值。2.获取这些点信息，点顺序要严格按照图示。直接赋值第一层的12个点，改一下Z值。所以Z方向维度是1，不能是其他数据。1.使用CAD随意绘制个网格草图。4.将上面的网格显示出来。
多线程学习之ThreadLocal详细笔记
qq_40623672的博客
08-14 569
多线程学习之ThreadLocal详细笔记
Kubernetes（k3s）基础学习（三） -- Deployment、Service、Ingress
码农从0到1
08-10 334
通常来说，在编写yml 时，Pod与Deployment 成对出现。因为弹性伸缩的需要，Deployment 扮演着Pod 的监管者角色。仅仅通过Deployment配置文件就可以启动pod，所以不需要单独写pod的配置文件。执行完上述命令后，我们在输出终端也看到有一个Pod 被创建出来，IP地址为10.42.0.34。这个IP地址如所讲，只允许被Kubenetes 内部环境所访问，外网不能正常访问。怎样才能让外界能够访问容器呢？
【Python零基础学习】变量和简单数据类型
卓越之识论道，平常之识论事，狭隘之识论人
08-10 626
【Python零基础学习】变量和简单数据类型
C++基础编程的学习3
m0_56701519的博客
08-08 301
nullptr。
VBA学习(26)：引用单元格/单元格区域的方法
nianfen的博客
08-13 441
实际上也可以将这些属性组合在一起，例如要选择数据底部的下一个新行，可以使用Range(“A1”).End(xlDown).Offset(1,0)，首先转到A1，向下到数据的底部，然后将结果向下偏移一行，以选择下一个空白行。引用连续单元格区域中最底部的单元格（即该单元格下方的单元格为空）。引用目标单元格的所有相关单元格，包括相关单元格的相关单元格。引用目标单元格的所有从属单元格，包括从属单元格的从属单元格。在VBA中，可以通过多种不同的方式来引用工作表中的单元格/单元格区域。引用目标单元格的从属单元格。
CORS解决前端跨域案例学习
最新发布
weixin_42576837的博客
08-14 649
跨域的概念不再解释，直接演示下出现跨域的情况：</</</</</'click'=>fetchthenresponse=>jsonthendata=>'result'JSONstringify;;;</</</点击Fetch Data按钮，向请求数据${`);});打开浏览器直接输入回车，可以返回数据，而且没有任何错误。
MongoDB学习笔记（三）
2303_76234920的博客
08-08 260
使用Python操作MongoDB:使用管理员用户：
地热模拟软件opengeosys-OGS安装和学习1
weixin_45793544的博客
08-13 201
地热地埋管换热性能模拟软件OGS
16、电科院FTU检测标准学习笔记-基本性能2
sixtome
08-10 1098
作者简介：本人从事电力系统多年，岗位包含研发，测试，工程等，具有丰富的经验在配电自动化验收测试以及电科院测试中，本人全程参与，积累了不少现场的经验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值