February 1, 2019 | 15:12

openCV & openGL

前言

环境：Clion + OpenGL + OpenCV

按照书中代码进行复现或改造，如果有错误，为保证即时性，请在博客文章下方留言，会及时更正。

Edited by Aris. Last edited on July 6, 2019

OpenGL

T3

题目：请使用 OpenGL 和 GLUT 编写一个简单的图形程序，用于显示一个填充的白色矩形。其中矩形规定为(-0.8, -0.8)～(0.8, 0.8)，程序窗口的大小为(200, 200)，标题为“白色矩形”。

#include <GL/glu.h>
#include <GL/glut.h>

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT);// 初始化颜色缓冲区
    // glColor3f(1, 0, 0); // 设置颜色为红色
    glRectf(-0.8, -0.8, 0.8, 0.8);
    glFlush();
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("白色矩形"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T4

题目：请使用 OpenGL 和 GLUT 编写一个简单的图形程序，用于显示一个填充的红色三角形。其中三角形的顶点分别是(-0.8, -0.8)、(0.8, -0.8)和(0, 0.8)，程序窗口大小为(200, 200)，标题为“红色三角形”

#include <GL/glu.h>
#include <GL/glut.h>

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区
    glColor3f(1, 0, 0); // 设置颜色为红色 (R, G, B)
    glBegin(GL_TRIANGLES); // 三角形
    glVertex2d(-0.8, -0.8); // 顺时针方向指定三顶点坐标，连线
    glVertex2d(0.8, -0.8);
    glVertex2d(0, 0.8);
    glEnd(); // 三角形定义结束
    glFlush();// 线段定义结束
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("红色三角形"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T5

题目：请使用OpenGL和GLUT编写一个简单的图形程序，用于显示一个填充的蓝色平行四边形。其中平行四边形的4个顶点分别是(-0.9, -0.4)、(0.4, -0.4)、(0.9, 0.4)和(-0.4, 0.4)，程序窗口的大小为(300, 300)，标题为“蓝色平行四边形”

#include <GL/glu.h>
#include <GL/glut.h>

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区
    glColor3f(0, 0, 1); // 设置颜色为蓝色 (R, G, B)
    glBegin(GL_QUADS); // 四边形
    glVertex2d(-0.9, -0.4); // 顺时针方向指定四顶点坐标，连线
    glVertex2d(0.4, -0.4);
    glVertex2d(0.9, 0.4);
    glVertex2d(-0.4, 0.4);
    glEnd(); // 定义结束
    glFlush();
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("蓝色平行四边形"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T6

题目：请使用OpenGL和GLUT编写一个简单的图形程序，用于显示一个填充的紫色梯形。其中梯形的4个顶点分别是(-0.9, -0.4)、(0.4, -0.4)、(0.4, 0.4)和(-0.4, 0.4)，程序窗口的大小为(300, 300)，标题为“紫色梯形”。

#include <GL/glu.h>
#include <GL/glut.h>

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区
    glColor3f(1, 0, 1); // 设置颜色为紫色 (R, G, B)
    glBegin(GL_QUADS); // 四边形
    glVertex2d(-0.9, -0.4); // 顺时针方向指定四顶点坐标，连线
    glVertex2d(0.4, -0.4);
    glVertex2d(0.4, 0.4);
    glVertex2d(-0.4, 0.4);
    glEnd(); // 定义结束
    glFlush();
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("紫色梯形"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T29

题目：请使用 OpenGL、GLU 和 GLUT 编写一个显示线框立方体的程序。其中立方体的半径为 1.5 单位，并首先绕(0, 0, 0)~(1, 1, 0)旋转 30 度，然后远移 6.5 单位；观察体规定为：视场角=30 度，宽高比=1，近=1，远=100；程序窗口的大小为(200, 200)，标题为“线框立方体”

#include <GL/glu.h>
#include <GL/glut.h>

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区

    glLoadIdentity(); // 初始化矩阵
    gluPerspective(30, 1, 1, 100); // 视角

    // 按照题意顺序写的，实际情况下面两行调换才能看到立方体
    glRotated(30, 1, 1, 0); // 绕(0, 0, 0)~(1, 1, 0)旋转 30 度
    glTranslated(0, 0, -6.5); // 远移 6.5 单位

    glutWireCube(1.5); //线框体，半径为 1.5 单位
    glFlush();
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("线框立方体"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T30

题目：请使用 OpenGL、GLU 和 GLUT 编写一个三维犹他茶壶程序。其中茶壶的半径为 1 单位，并远移 6.5 单位；观察体规定为：视场角=30 度，宽高比=1，近=1，远=100；程序窗口的大小为(200, 200)，标题为“尤他茶壶”

#include <GL/glu.h>
#include <GL/glut.h>

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区

    glLoadIdentity(); // 初始化矩阵
    gluPerspective(30, 1, 1, 100); // 视角
    glTranslated(0, 0, -6.5); // 远移 6.5 单位
    glutSolidTeapot(1); // 尤他茶壶，半径为 1 单位
    glFlush();
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("尤他茶壶"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T31

题目：请使用 OpenGL 和 GLUT 编写一个显示线框球体的简单图形程序。其中球体的半径为 0.8，经线数为 24，纬线数为 12，并绕 x 轴旋转 30 度，程序窗口的大小为(200, 200)，标题为“线框球”

#include <GL/glu.h>
#include <GL/glut.h>

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区
    glLoadIdentity(); // 初始化矩阵
    glRotated(30, 1, 0, 0); // 旋转
    glutWireSphere(0.8, 24, 12); // 线框球(半径、经线、纬线)
    glFlush();
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("线框球"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T32

题目：请使用 OpenGL 和 GLUT 编写一个显示线框椭球体的简单图形程序。其中椭球体的两极方向为上下方向，左右方向的半径为 0.98，上下方向的半径为 0.49，前后方向的半径为 0.6，经线数为 48，纬线数为 24，使用正投影，裁剪窗口为(-1, -0.5)~(1, 0.5)，程序窗口的大小为(400, 200)，标题为“线框椭球”

#include <GL/glu.h>
#include <GL/glut.h>

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区
    glLoadIdentity(); // 初始化矩阵
    glRotated(-90, 1, 0, 0); // 两级为上下方向
    glScaled(0.98, 0.49, 0.6); // 缩放（左右、上下、前后）
    gluOrtho2D(-1, 1, -0.5, 0.5); // 裁剪窗口

    glutWireSphere(1, 48, 24); // 线框球(半径、经线、纬线)
    glFlush();
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(400, 200); // 程序窗口大小
    glutCreateWindow("线框椭球"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T33

题目：请使用 OpenGL、GLU 和 GLUT 编写一个三维犹他茶壶程序。其中茶壶的半径为 1 单位，并远移 6.5 单位；观察体规定为：视场角=30 度，宽高比=1，近=1，远=100；程序窗口的大小为(200, 200)，标题为“旋转的尤他茶壶”。茶壶绕 z 轴不断旋转，旋转的时间间隔为 25 毫秒，角度间隔为 2 度。注意旋转角度必须限定在 0～360 度以内。

#include <GL/glu.h>
#include <GL/glut.h>

int rot = 0; // 旋转角度

// 思路参考 P89
void Timer(int millis){
    rot = (rot + 2) % 360;
    glutPostRedisplay(); // 场景描绘函数
    glutTimerFunc(millis, Timer, millis); // (间隔毫秒数、函数名、参数值)
}

void Paint(){
    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区

    glLoadIdentity(); // 初始化矩阵
    glRotatef(rot, 0, 0, 1); // 绕 z 轴旋转rot
    glColor3f(1, 1, 1);

    gluPerspective(30, 1, 1, 100); // 视角
    glTranslated(0, 0, -6.5); // 远移 6.5 单位
    glutWireTeapot(1); // 3D茶壶，半径为 1 单位
    glFlush();

}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("旋转的尤他茶壶"); // 窗口标题

    glutTimerFunc(25, Timer, 25);
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}
T35

题目：请使用 OpenGL、GLU 和 GLUT 编写一个简单的多视口演示程序。要求：在屏幕窗口左下角的 1⁄4 部分显示一个红色的填充正三角形；在屏幕窗口右上角的 1⁄4 部分显示一个绿色的填充正方形；三角形和正方形的左下角顶点坐标值均为(0, 0)，右下角顶点坐标值均为(1, 0)；裁剪窗口均为(-0.1, -0.1)～(1.1, 1.1)；程序窗口的大小为(200, 200)，标题为“多视口演示”

#include <GL/glu.h>
#include <GL/glut.h>

// 思路参考 P29
void Triangle(){
    glBegin(GL_TRIANGLES);
    glVertex2d(0, 0);
    glVertex2d(1, 0);
    glVertex2d(0.5, 0.8660);
    glEnd();
}

void Rectangle(){ // 矩形
    glRectf(0, 0, 1, 1); // 对角的坐标 (0，0) & (1, 1)
}

void Paint(){
    int w = glutGet(GLUT_WINDOW_WIDTH);
    int h = glutGet(GLUT_WINDOW_HEIGHT);
    glLoadIdentity(); // 初始化矩阵
    gluOrtho2D(-0.1, 1.1, -0.1, 1.1); // 裁剪窗口

    glClear(GL_COLOR_BUFFER_BIT); // 初始化颜色缓冲区

    glViewport(0, 0, w/2, h/2); // 左下
    glColor3f(1, 0, 0);
    Triangle();

    glViewport(w/2, h/2, w/2, h/2); // 右上
    glColor3f(0, 1, 0);
    Rectangle();

    glFlush();
}

int main(int argc, char **argv){
    glutInit(&argc, argv); // 做题不写
    glutInitWindowSize(200, 200); // 程序窗口大小
    glutCreateWindow("多视口演示"); // 窗口标题
    glutDisplayFunc(Paint); // 执行场景绘制函数
    glutMainLoop(); // 开始循环执行 OpenGL 命令
}

OpenCV

T35

请使用 OpenCV 编写一个简单的程序，用于从当前目录读入并显示一幅彩色图像（例如当前目录中的 lena.jpg）。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    IplImage *im = cvLoadImage("075.jpg", 1); // 声明 IplImage 指针，载入彩色图像。0是灰色

    if(im == 0) return -1;

    cvShowImage("OpenCV_T35", im); // 显示图像

    while (cvWaitKey(0) != 27){} // 等待Esc

    cvReleaseImage(&im); // 释放图像
    cvDestroyWindow("OpenCV_T35"); // 销毁窗口
}
T36

请使用 OpenCV 编写一个简单的程序，用于从当前目录读入并显示一幅灰度图像（例如当前目录中的 lena.jpg）。

int main() {
    CvMat *mat = cvLoadImageM("075.jpg", 0); // 声明灰度图像
    
    if(mat == 0) return -1;
    
    cvShowImage("OpenCV_T36", mat); // 创建窗口显示图像
	
    while (cvWaitKey(0) != 27) {} // 等待Esc
	
    cvReleaseMat(&mat);
    cvDestroyAllWindows(); // 销毁所有窗口
}
T37

请使用 OpenCV 编写一个简单的程序，该程序首先读入一幅彩色图像（例如当前目录中的 lena.jpg），然 后将这幅彩色图像的 3 个通道分离出来，得到 3 幅灰度图像，最后显示这 3 幅灰度图像。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    IplImage *img = cvLoadImage("075.jpg", 1); // 载入彩色图像，参数为0载入的是灰色

    if(img == 0) return -1;

    IplImage *redImage = cvCreateImage(cvGetSize(img),IPL_DEPTH_8U,1);
    IplImage *greenImage = cvCreateImage(cvGetSize(img),IPL_DEPTH_8U,1);
    IplImage *blueImage = cvCreateImage(cvGetSize(img),IPL_DEPTH_8U,1);

    // OpenCV采用的色彩模式是 BGR
    cvSplit(img, blueImage, greenImage, redImage, 0);

    cvShowImage("main", img);
    cvShowImage("blue", blueImage);
    cvShowImage("green", greenImage);
    cvShowImage("red", redImage);

    while (cvWaitKey(0) != 27) {}

    cvReleaseImage(&img);
    cvReleaseImage(&redImage);
    cvReleaseImage(&greenImage);
    cvReleaseImage(&blueImage);
    cvDestroyAllWindows();
}
T38

请使用 OpenCV 编写一个简单的程序，该程序从 1 幅彩色图像（使用当前目录中的 lena.jpg）中分离出蓝 色通道，得到 1 幅灰度图像。要求显示源图像和结果图像。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    IplImage *img = cvLoadImage("075.jpg", 1); // 载入彩色图像

    if(img == 0) return -1;

    IplImage *blueImage = cvCreateImage(cvGetSize(img),IPL_DEPTH_8U,1);

    // OpenCV采用的色彩模式是BGR
    cvSplit(img, blueImage, 0, 0, 0);

    cvShowImage("main", img);
    cvShowImage("blue", blueImage);

    while (cvWaitKey(0) != 27) {}

    cvReleaseImage(&img);
    cvReleaseImage(&blueImage);
	cvDestroyAllWindows();
}

#####T39

请使用 OpenCV 编写一个简单的程序，该程序首先从一幅真彩色图像（使用当前目录中的 lena.jpg）中选 取一个矩形子集，并用蓝色填充该矩形子集，然后显示图像。其中矩形子集的起始位置为(64, 96)，大小为(96, 48)。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *img = cvLoadImageM("075.jpg", 1); // 载入彩色图像
    if(img == 0) return -1;
    CvRect R = {64, 69, 96, 48}; // 起始位置和大小
    CvMat head; // 结果矩阵头
    CvMat *Y = cvGetSubRect(img, &head, R); // 选取矩形子集
    cvSet(Y, CV_RGB(0, 0, 255), NULL); // 矩形子集改为 蓝色：CV_RGB(0, 0, 255)

    cvShowImage("main", img);
    while (cvWaitKey(0) != 27) {}
    cvReleaseMat(&img);
    cvDestroyAllWindows();
}

#####T40

使用 OpenCV 装入一幅大小至少为 512*512 的真彩色图像，并显示该图像（使用当前目录中的 lena.jpg）。 然后在源图像中指定一个矩形区域（左上顶点和宽高值分别为(128, 256)和(256, 128)的矩形），并在结果图像窗口中显示源图像中被选取的部分。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *img = cvLoadImageM("075.jpg", 1); // 载入彩色图像
    if(img == 0) return -1;
    CvRect R = {128, 256, 256, 128}; // 起始位置和大小
    CvMat head; // 结果矩阵头
    CvMat *Y = cvGetSubRect(img, &head, R); // 选取矩形子集

    cvShowImage("main", Y);// 这里是显示 Y 区域
    while (cvWaitKey(0) != 27) {}
    cvReleaseMat(&img);
    cvDestroyAllWindows();
}
T41 – 没太理解

使用 OpenCV 编写一个程序，该程序将一幅灰度图像（使用当前目录中的 lena.jpg）的灰度值线性地变换 到范围[0, 255]。要求分别显示源图像和结果图像。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *X = cvLoadImageM("075.jpg", 0); // 载入灰度图像

    // 定义结果图像，与源图像大小相同的双精度矩阵
    CvMat *Y = cvCreateMat(X->rows, X->cols, CV_64F);
    cvScale(X, Y, 1, 0);   // Y(i) = 1 * X + 0 
    cvNormalize(Y, Y, 0, 255, CV_MINMAX, 0);

    cvShowImage("Main", X);
    cvShowImage("Scale", Y);

    while (cvWaitKey(0) != 27) {}

    cvReleaseMat(&X);
    cvReleaseMat(&Y);
    cvDestroyAllWindows();
}
T42

随机生成一幅浮点数灰度图像（大小和亮度都是随机的，大小值位于区间[128, 639]），然后将该图像变 换成亮度是 0~1 的浮点数图像，最后变换成字节图像并显示该图像。

一脸懵逼：opencv随机生成点图像

T46

使用 OpenCV 编写一个演示傅立叶变换和逆变换的程序。该程序首先装入一幅灰度图像并显示该图像（例 如当前目录中的 lena.jpg），然后对该图像进行傅立叶正变换，对得到的结果进行傅立叶逆变换，显示得到的结果以便与原图像进行比对。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *X = cvLoadImageM("075.jpg", 0); // 载入灰度图像

    // 定义结果图像，与源图像大小相同的双精度矩阵
    CvMat *Y = cvCreateMat(X->rows, X->cols, CV_64F);
    cvScale(X, Y, (double)1 / 255, 0);

    cvDFT(Y, Y, CV_DXT_FORWARD, 0);
    cvDFT(Y, Y, CV_DXT_INVERSE_SCALE, 0);

    cvShowImage("Main", X);
    cvShowImage("Dst", Y);

    while (cvWaitKey(0) != 27) {}

    cvReleaseMat(&X);
    cvReleaseMat(&Y);
    cvDestroyAllWindows();
}
T49（复现课本，编译出错）

题目：使用 OpenCV 编写一个演示离散余弦变换和逆变换的程序。该程序首先装入一幅灰度图像并显示该图像（例如当前目录中的 lena.jpg），然后对该图像进行离散余弦正变换，对得到的结果进行离散余弦逆变换，显示得到的结果以便与原图像进行比对。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *src = cvLoadImageM("075.jpg", 0); // 载入灰度图像

    CvMat *X = cvCreateMat(src->rows, src->cols, CV_64F);
    cvScale(src, X, (double)1/255, 0);

    cvDCT(X, X, CV_DXT_FORWARD);

    // 靠近原点的元素改为0
    for (int u = 0; u < src->cols; ++u)
        for (int v = 0; v < src->rows; ++v)
            cvmSet(src, v, u, 0);
    cvDCT(X, X, CV_DXT_INVERSE);

    cvShowImage("Source", src);
    cvShowImage("DCT", X);

    while (cvWaitKey(0) != 27) {}

    cvReleaseMat(&src);
    cvReleaseMat(&X);
    cvDestroyAllWindows();
}
T52、53、54

题目：使用 OpenCV 编写一个程序，该程序对一幅灰度图像（使用当前目录中的 lena-n.jpg）进行一次简单模糊、高斯模糊、中值模糊，要求分别显示源图像和结果图像。其中内核大小分别为 3×3、5x5、3x3。

注意，main函数第一行，和注释部分内核大小，请根据题意做出更改。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *src = cvLoadImageM("075.jpg", 1); // 载入彩色图像，0表示灰色图像
    cvShowImage("Source", src);

    // 结果图像
    CvMat *X = cvCreateMat(src->rows, src->cols, src->type);

    cvSmooth(src, X, CV_BLUR, 3, 3, 0, 0); // 简单，3*3模板
    cvShowImage("CV_BLUR", X);

//    cvSmooth(src, X, CV_GAUSSIAN, 5, 5, 0, 0);// 高斯，5*5模板
//    cvShowImage("CV_GAUSSIAN", X);
//
//    cvSmooth(src, X, CV_MEDIAN, 3, 3, 0, 0); // 中值，3*3模板
//    cvShowImage("CV_MEDIAN", X);

    while (cvWaitKey(0) != 27) {}

    cvReleaseMat(&src);
    cvReleaseMat(&X);
    cvDestroyAllWindows();
}

效果图：1562420178278.png

T55

题目：使用 OpenCV 编写一个程序，该程序对一幅灰度图像（例如当前目录中的 lena.jpg）进行 Sobel 锐化，要求显示（T56：显示原图像和）锐化以后的图像。其中内核大小为 3×3，x 和 y 方向均使用 1 阶差分（T56：使用 1 阶 x 差分，T57：使用Laplace，3*3内核）。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *src = cvLoadImageM("075.jpg", 0); // 载入图像
    if(src == 0)
        return -1;
    
	// cvShowImage("source", src); // T56
    CvMat *tmp = cvCreateMat(src->rows, src->cols, CV_32F);
    cvSobel(src, tmp, 1, 1, 3); // 使用Sober，x，y方向1阶差分，3*3内核
    // cvSobel(src, tmp, 1, 0, 3); // T56 使用Sober，x方向1阶差分，3*3内核
    // cvLaplace(src, tmp, 3); // T57，使用Laplace，3*3内核
    
    // 下三行也可直接 cvShowImage("Sober", tmp);
    CvMat *Y = cvCreateMat(src->rows, src->cols, CV_8U); // 字节图像
    cvConvert(tmp, Y); // 输出图像转化为字节图像
    cvShowImage("Sober", Y);

    while (cvWaitKey(0) != 27) {}

    cvReleaseMat(&Y);
    cvDestroyAllWindows();
}
T61

题目：使用 OpenCV 编写一个程序，该程序对一幅灰度图像（例如当前目录中的 lena.jpg）进行直方图均衡化，要求分别显示源图像和均衡化以后的图像。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *src = cvLoadImageM("075.jpg", 0); // 载入图像
    if(src == 0)
        return -1;
    cvShowImage("source", src);
    cvEqualizeHist(src, src); // 应用直方图均衡化
    cvShowImage("EqualizeHist Image", src);

    while (cvWaitKey(0) != 27) {}
    cvReleaseMat(&src);
    cvDestroyAllWindows();
}
T62

题目：使用 OpenCV 编写一个程序，该程序对一幅灰度图像（例如当前目录中的 lena.jpg）进行二值化变换，要求分别显示源图像和二值化以后的图像。其中二值化阈值为 127，高亮度改为 255。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *X= cvLoadImageM("075.jpg", 0); // 载入图像
    if(X == 0)
        return -1;
    cvShowImage("Source", X);
    cvThreshold(X, X, 127, 255, CV_THRESH_BINARY); // 二值化
    cvShowImage("阈值（127），高度（255）", X);

    while (cvWaitKey(0) != 27) {}
    cvReleaseMat(&X);
    cvDestroyAllWindows();
}
T63

题目：使用 OpenCV 编写一个程序，该程序对一幅灰度图像（例如当前目录中的 lena.jpg）进行 Canny 边缘检测，要求分别显示源图像和检测到的边缘。其中小阈值为 50，大阈值为 150，内核大小为 3。

#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"

int main() {
    CvMat *X= cvLoadImageM("075.jpg", 0); // 载入图像
    if(X == 0)
        return -1;
    cvShowImage("Source", X);

    cvCanny(X, X, 50, 3 * 50, 3);
    cvShowImage("Canny: 50, 3 * 50", X);

    while (cvWaitKey(0) != 27) {}
    cvReleaseMat(&X);
    cvDestroyAllWindows();
}

© Aris 2020
鄂ICP备18010884号-1

Powered by Hugo & Kiss'Em.