扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >C++ OpenCV绘制几何图形
  • 589

0
分享到

C++ OpenCV绘制几何图形

2024-04-02 19:04:59 589人浏览 泡泡鱼
摘要

本文实例为大家分享了c++ OpenCV绘制几何图形的具体代码，供大家参考，具体内容如下 绘制几何图形 直线 矩形 多边形 圆形 椭圆

本文实例为大家分享了c++ OpenCV绘制几何图形的具体代码，供大家参考，具体内容如下

绘制几何图形

  • 直线
  • 矩形
  • 多边形
  • 圆形
  • 椭圆
  • 文字

API

直线


CV_EXPORTS_W void line(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,
           int thickness = 1, int lineType = LINE_8, int shift = 0);

矩形


CV_EXPORTS_W void rectangle(InputOutputArray img, Point pt1, Point pt2,
             const Scalar& color, int thickness = 1,
              int lineType = LINE_8, int shift = 0);

上方函数通过两点确定矩形的位置和大小，下方函数则是通过矩形对象 Rect 来确定。


CV_EXPORTS_W void rectangle(InputOutputArray img, Rect rec,
            const Scalar& color, int thickness = 1,
            int lineType = LINE_8, int shift = 0);

多边形


CV_EXPORTS void polylines(InputOutputArray img, const Point* const* pts, const int* npts,
           int ncontours, bool isClosed, const Scalar& color,
            int thickness = 1, int lineType = LINE_8, int shift = 0 );

CV_EXPORTS_W void polylines(InputOutputArray img, InputArrayOfArrays pts,
              bool isClosed, const Scalar& color,
              int thickness = 1, int lineType = LINE_8, int shift = 0 );

圆形


CV_EXPORTS_W void circle(InputOutputArray img, Point center, int radius,
             const Scalar& color, int thickness = 1,
             int lineType = LINE_8, int shift = 0);

椭圆


CV_EXPORTS_W void ellipse(InputOutputArray img, const RotatedRect& box, const Scalar& color,
        int thickness = 1, int lineType = LINE_8);

CV_EXPORTS_W void ellipse(InputOutputArray img, Point center, Size axes,
                        double angle, double startAngle, double endAngle,
                        const Scalar& color, int thickness = 1,
                        int lineType = LINE_8, int shift = 0);

文字


CV_EXPORTS_W void putText( InputOutputArray img, const String& text, Point org,
                         int fontFace, double fontScale, Scalar color,
                         int thickness = 1, int lineType = LINE_8,
                         bool bottomLeftOrigin = false );

示例

官方示例一


#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#define w 400
using namespace cv;
void MyEllipse( Mat img, double angle );
void MyFilledCircle( Mat img, Point center );
void MyPolyGon( Mat img );
void MyLine( Mat img, Point start, Point end );
int main( void ){
    char atom_window[] = "Drawing 1: Atom";
    char rook_window[] = "Drawing 2: Rook";
    Mat atom_image = Mat::zeros( w, w, CV_8UC3 );
    Mat rook_image = Mat::zeros( w, w, CV_8UC3 );
    MyEllipse( atom_image, 90 );
    MyEllipse( atom_image, 0 );
    MyEllipse( atom_image, 45 );
    MyEllipse( atom_image, -45 );
    MyFilledCircle( atom_image, Point( w/2, w/2) );
    MyPolygon( rook_image );
    rectangle( rook_image,
               Point( 0, 7*w/8 ),
               Point( w, w),
               Scalar( 0, 255, 255 ),
               FILLED,
               LINE_8 );
    MyLine( rook_image, Point( 0, 15*w/16 ), Point( w, 15*w/16 ) );
    MyLine( rook_image, Point( w/4, 7*w/8 ), Point( w/4, w ) );
    MyLine( rook_image, Point( w/2, 7*w/8 ), Point( w/2, w ) );
    MyLine( rook_image, Point( 3*w/4, 7*w/8 ), Point( 3*w/4, w ) );
    imshow( atom_window, atom_image );
    moveWindow( atom_window, 0, 200 );
    imshow( rook_window, rook_image );
    moveWindow( rook_window, w, 200 );
    waiTKEy( 0 );
    return(0);
}
void MyEllipse( Mat img, double angle )
{
    int thickness = 2;
    int lineType = 8;
    ellipse( img,
             Point( w/2, w/2 ),
             Size( w/4, w/16 ),
             angle,
             0,
             360,
             Scalar( 255, 0, 0 ),
             thickness,
             lineType );
}
void MyFilledCircle( Mat img, Point center )
{
    circle( img,
            center,
            w/32,
            Scalar( 0, 0, 255 ),
            FILLED,
            LINE_8 );
}
void MyPolygon( Mat img )
{
    int lineType = LINE_8;
    Point rook_points[1][20];
    rook_points[0][0]  = Point(    w/4,   7*w/8 );
    rook_points[0][1]  = Point(  3*w/4,   7*w/8 );
    rook_points[0][2]  = Point(  3*w/4,  13*w/16 );
    rook_points[0][3]  = Point( 11*w/16, 13*w/16 );
    rook_points[0][4]  = Point( 19*w/32,  3*w/8 );
    rook_points[0][5]  = Point(  3*w/4,   3*w/8 );
    rook_points[0][6]  = Point(  3*w/4,     w/8 );
    rook_points[0][7]  = Point( 26*w/40,    w/8 );
    rook_points[0][8]  = Point( 26*w/40,    w/4 );
    rook_points[0][9]  = Point( 22*w/40,    w/4 );
    rook_points[0][10] = Point( 22*w/40,    w/8 );
    rook_points[0][11] = Point( 18*w/40,    w/8 );
    rook_points[0][12] = Point( 18*w/40,    w/4 );
    rook_points[0][13] = Point( 14*w/40,    w/4 );
    rook_points[0][14] = Point( 14*w/40,    w/8 );
    rook_points[0][15] = Point(    w/4,     w/8 );
    rook_points[0][16] = Point(    w/4,   3*w/8 );
    rook_points[0][17] = Point( 13*w/32,  3*w/8 );
    rook_points[0][18] = Point(  5*w/16, 13*w/16 );
    rook_points[0][19] = Point(    w/4,  13*w/16 );
    const Point* ppt[1] = { rook_points[0] };
    int npt[] = { 20 };
    fillPoly( img,
              ppt,
              npt,
              1,
              Scalar( 255, 255, 255 ),
              lineType );
}
void MyLine( Mat img, Point start, Point end )
{
    int thickness = 2;
    int lineType = LINE_8;
    line( img,
          start,
          end,
          Scalar( 0, 0, 0 ),
          thickness,
          lineType );
}

官方示例二


#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <iOStream>
#include <stdio.h>
using namespace cv;
const int NUMBER = 100;
const int DELAY = 5;
const int window_width = 900;
const int window_height = 600;
int x_1 = -window_width/2;
int x_2 = window_width*3/2;
int y_1 = -window_width/2;
int y_2 = window_width*3/2;
static Scalar randomColor( RNG& rng );
int Drawing_Random_Lines( Mat image, char* window_name, RNG rng );
int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng );
int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng );
int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng );
int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng );
int Drawing_Random_Circles( Mat image, char* window_name, RNG rng );
int Displaying_Random_Text( Mat image, char* window_name, RNG rng );
int Displaying_Big_End( Mat image, char* window_name, RNG rng );
int main( void )
{
    int c;
    char window_name[] = "Drawing_2 Tutorial";
    RNG rng( 0xFFFFFFFF );
    Mat image = Mat::zeros( window_height, window_width, CV_8UC3 );
    imshow( window_name, image );
    waitKey( DELAY );
    c = Drawing_Random_Lines(image, window_name, rng);
    if( c != 0 ) return 0;
    c = Drawing_Random_Rectangles(image, window_name, rng);
    if( c != 0 ) return 0;
    c = Drawing_Random_Ellipses( image, window_name, rng );
    if( c != 0 ) return 0;
    c = Drawing_Random_Polylines( image, window_name, rng );
    if( c != 0 ) return 0;
    c = Drawing_Random_Filled_Polygons( image, window_name, rng );
    if( c != 0 ) return 0;
    c = Drawing_Random_Circles( image, window_name, rng );
    if( c != 0 ) return 0;
    c = Displaying_Random_Text( image, window_name, rng );
    if( c != 0 ) return 0;
    c = Displaying_Big_End( image, window_name, rng );
    if( c != 0 ) return 0;
    waitKey(0);
    return 0;
}
static Scalar randomColor( RNG& rng )
{
    int icolor = (unsigned) rng;
    return Scalar( icolor&255, (icolor>>8)&255, (icolor>>16)&255 );
}
int Drawing_Random_Lines( Mat image, char* window_name, RNG rng )
{
    Point pt1, pt2;
    for( int i = 0; i < NUMBER; i++ )
    {
        pt1.x = rng.unifORM( x_1, x_2 );
        pt1.y = rng.uniform( y_1, y_2 );
        pt2.x = rng.uniform( x_1, x_2 );
        pt2.y = rng.uniform( y_1, y_2 );
        line( image, pt1, pt2, randomColor(rng), rng.uniform(1, 10), 8 );
        imshow( window_name, image );
        if( waitKey( DELAY ) >= 0 )
        { return -1; }
    }
    return 0;
}
int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng )
{
    Point pt1, pt2;
    int lineType = 8;
    int thickness = rng.uniform( -3, 10 );
    for( int i = 0; i < NUMBER; i++ )
    {
        pt1.x = rng.uniform( x_1, x_2 );
        pt1.y = rng.uniform( y_1, y_2 );
        pt2.x = rng.uniform( x_1, x_2 );
        pt2.y = rng.uniform( y_1, y_2 );
        rectangle( image, pt1, pt2, randomColor(rng), MAX( thickness, -1 ), lineType );
        imshow( window_name, image );
        if( waitKey( DELAY ) >= 0 )
        { return -1; }
    }
    return 0;
}
int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng )
{
    int lineType = 8;
    for ( int i = 0; i < NUMBER; i++ )
    {
        Point center;
        center.x = rng.uniform(x_1, x_2);
        center.y = rng.uniform(y_1, y_2);
        Size axes;
        axes.width = rng.uniform(0, 200);
        axes.height = rng.uniform(0, 200);
        double angle = rng.uniform(0, 180);
        ellipse( image, center, axes, angle, angle - 100, angle + 200,
                 randomColor(rng), rng.uniform(-1,9), lineType );
        imshow( window_name, image );
        if( waitKey(DELAY) >= 0 )
        { return -1; }
    }
    return 0;
}
int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng )
{
    int lineType = 8;
    for( int i = 0; i< NUMBER; i++ )
    {
        Point pt[2][3];
        pt[0][0].x = rng.uniform(x_1, x_2);
        pt[0][0].y = rng.uniform(y_1, y_2);
        pt[0][1].x = rng.uniform(x_1, x_2);
        pt[0][1].y = rng.uniform(y_1, y_2);
        pt[0][2].x = rng.uniform(x_1, x_2);
        pt[0][2].y = rng.uniform(y_1, y_2);
        pt[1][0].x = rng.uniform(x_1, x_2);
        pt[1][0].y = rng.uniform(y_1, y_2);
        pt[1][1].x = rng.uniform(x_1, x_2);
        pt[1][1].y = rng.uniform(y_1, y_2);
        pt[1][2].x = rng.uniform(x_1, x_2);
        pt[1][2].y = rng.uniform(y_1, y_2);
        const Point* ppt[2] = {pt[0], pt[1]};
        int npt[] = {3, 3};
        polylines(image, ppt, npt, 2, true, randomColor(rng), rng.uniform(1,10), lineType);
        imshow( window_name, image );
        if( waitKey(DELAY) >= 0 )
        { return -1; }
    }
    return 0;
}
int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng )
{
    int lineType = 8;
    for ( int i = 0; i < NUMBER; i++ )
    {
        Point pt[2][3];
        pt[0][0].x = rng.uniform(x_1, x_2);
        pt[0][0].y = rng.uniform(y_1, y_2);
        pt[0][1].x = rng.uniform(x_1, x_2);
        pt[0][1].y = rng.uniform(y_1, y_2);
        pt[0][2].x = rng.uniform(x_1, x_2);
        pt[0][2].y = rng.uniform(y_1, y_2);
        pt[1][0].x = rng.uniform(x_1, x_2);
        pt[1][0].y = rng.uniform(y_1, y_2);
        pt[1][1].x = rng.uniform(x_1, x_2);
        pt[1][1].y = rng.uniform(y_1, y_2);
        pt[1][2].x = rng.uniform(x_1, x_2);
        pt[1][2].y = rng.uniform(y_1, y_2);
        const Point* ppt[2] = {pt[0], pt[1]};
        int npt[] = {3, 3};
        fillPoly( image, ppt, npt, 2, randomColor(rng), lineType );
        imshow( window_name, image );
        if( waitKey(DELAY) >= 0 )
        { return -1; }
    }
    return 0;
}
int Drawing_Random_Circles( Mat image, char* window_name, RNG rng )
{
    int lineType = 8;
    for (int i = 0; i < NUMBER; i++)
    {
        Point center;
        center.x = rng.uniform(x_1, x_2);
        center.y = rng.uniform(y_1, y_2);
        circle( image, center, rng.uniform(0, 300), randomColor(rng),
                rng.uniform(-1, 9), lineType );
        imshow( window_name, image );
        if( waitKey(DELAY) >= 0 )
        { return -1; }
    }
    return 0;
}
int Displaying_Random_Text( Mat image, char* window_name, RNG rng )
{
    int lineType = 8;
    for ( int i = 1; i < NUMBER; i++ )
    {
        Point org;
        org.x = rng.uniform(x_1, x_2);
        org.y = rng.uniform(y_1, y_2);
        putText( image, "Testing text rendering", org, rng.uniform(0,8),
                 rng.uniform(0,100)*0.05+0.1, randomColor(rng), rng.uniform(1, 10), lineType);
        imshow( window_name, image );
        if( waitKey(DELAY) >= 0 )
        { return -1; }
    }
    return 0;
}
int Displaying_Big_End( Mat image, char* window_name, RNG )
{
    Size textsize = getTextSize("OpenCV forever!", FONT_HERSHEY_COMPLEX, 3, 5, 0);
    Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
    int lineType = 8;
    Mat image2;
    for( int i = 0; i < 255; i += 2 )
    {
        image2 = image - Scalar::all(i);
        putText( image2, "OpenCV forever!", org, FONT_HERSHEY_COMPLEX, 3,
                 Scalar(i, i, 255), 5, lineType );
        imshow( window_name, image2 );
        if( waitKey(DELAY) >= 0 )
        { return -1; }
    }
    return 0;
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程网。

--结束END--

本文标题: C++ OpenCV绘制几何图形

本文链接: https://lsjlt.com/news/155930.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • C++ OpenCV绘制几何图形
    本文实例为大家分享了C++ OpenCV绘制几何图形的具体代码，供大家参考，具体内容如下 绘制几何图形 直线 矩形 多边形 圆形 椭圆 ...
    99+
    2024-04-02
  • C++ opencv实现几何图形绘制
    目录1.矩形 rectangle（）2. 圆 circle（）3.椭圆 elliple（）在学习过程中，我们可以在图像中绘制一些几何图形，比如矩形，椭圆，线段，填充多边形等，这些函数...
    99+
    2024-04-02
  • 怎么用C++ OpenCV绘制几何图形
    本篇内容介绍了“怎么用C++ OpenCV绘制几何图形”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！具体内容如下绘制几何图形直线矩形多边形圆...
    99+
    2023-06-25
  • C++ opencv如何实现几何图形绘制
    这篇“C++ opencv如何实现几何图形绘制”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“C++ op...
    99+
    2023-06-30
  • Python OpenCV如何绘制各类几何图形
    这篇文章将为大家详细讲解有关Python OpenCV如何绘制各类几何图形，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。一.绘制直线在OpenCV中，绘制直线需要获取直线的起点和终点坐标，调用c...
    99+
    2023-06-29
  • OpenCV绘制图形功能
    本文实例为大家分享了OpenCV绘制图形功能的具体代码，供大家参考，具体内容如下 1、绘制直线 绘制直线函数是cv::line，函数完整形式如下 void line(InputOut...
    99+
    2024-04-02
  • 使用c++实现OpenCV绘制旋转矩形图形
    目录功能函数测试代码测试效果  功能函数 // 绘制旋转矩形 void DrawRotatedRect(cv::Mat mask,const cv::RotatedRe...
    99+
    2024-04-02
  • Python OpenCV中如何进行图形绘制
    这篇文章将为大家详细讲解有关Python OpenCV中如何进行图形绘制，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。背景使用OpenCV进行图形绘制是一种必备的技能，在图像的任务...
    99+
    2023-06-22
  • python基于turtle绘制几何图形
    目录1. 什么是turtle2. turtle例子3. 其他turtle功能4. 更多的例子5. 总结6. 参考资料1. 什么是turtle turtle模拟了人在画布前画画的过程：给你一支笔（Pen）， 下笔（pe...
    99+
    2022-06-02
    python turtle python 绘图
  • WPF使用Geometry绘制几何图形
    在WPF的DrawingContext对象中，提供了基本的绘制椭圆和矩形的API：DrawEllipse和DrawRectangle。但是，这些是远远不够用的，我们在日常应用中，更多...
    99+
    2024-04-02
  • Python OpenCV实现基本图形绘制
    1.导入模块 import cv2 as cv import numpy as np 2.OpenCV绘图大致步骤 OpenCV 图形绘制步骤 （1）先定义基础画布canv...
    99+
    2024-04-02
  • 怎么用OpenCV绘制图形功能
    这篇文章主要介绍“怎么用OpenCV绘制图形功能”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“怎么用OpenCV绘制图形功能”文章能帮助大家解决问题。1、绘制直线绘制直线函数是cv::line，函数...
    99+
    2023-06-26
  • PythonOpenCV绘制各类几何图形详解
    目录一.绘制直线二.绘制矩形三.绘制圆形四.绘制椭圆五.绘制多边形六.绘制文字七.总结一.绘制直线 在OpenCV中，绘制直线需要获取直线的起点和终点坐标，调用cv2.line()函...
    99+
    2024-04-02
  • OpenCV 基本图形绘制函数详解
    用于绘制直线的line函数； 用于绘制椭圆的ellipse函数； 用于绘制矩形的rectangle函数； 用于绘制圆的circle函数； 用...
    99+
    2024-04-02
  • C#Chart绘制简单图形波形
    本文实例为大家分享了C# Chart绘制简单图形波形的具体代码，供大家参考，具体内容如下 此次用C#绘制波形使用的是Chart控件 1、将Chart控件拖进主界面，然后设置属性。 ...
    99+
    2024-04-02
  • Python+OpenCV如何实现在图像上绘制矩形
    小编给大家分享一下Python+OpenCV如何实现在图像上绘制矩形，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！代码import copyimport cv2import numpy&nbs...
    99+
    2023-06-29
  • Python+OpenCV实现在图像上绘制矩形
    话不多说，直接上代码 import copy import cv2 import numpy as np WIN_NAME = 'draw_rect' class Rec...
    99+
    2024-04-02
  • 怎么在python中使用opencv绘制图形
    这篇文章给大家介绍怎么在python中使用opencv绘制图形，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。实现方法1）画线段 cv.line在图片中绘制一段直线# 绘制线段# 参数1：图片#&nb...
    99+
    2023-06-14
  • OpenCV基本图形绘制函数有哪些
    本篇内容主要讲解“OpenCV基本图形绘制函数有哪些”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“OpenCV基本图形绘制函数有哪些”吧!用于绘制直线的line函数；用于绘制椭圆的ellipse...
    99+
    2023-06-25
  • 使用c++实现OpenCV绘制圆端矩形
    功能函数 // 绘制圆端矩形（药丸状，pill） void DrawPill(cv::Mat mask, const cv::RotatedRect &rotatedre...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作