基本图形绘制

目录

• 目标
• OpenCV 理论
  • 点
  • 标量
• OpenCV 理论
  • 点
  • 标量
• 代码
• 说明
• 结果

下一教程： 使用 OpenCV 的随机生成器和文本

原作者	Ana Huamán
兼容性	OpenCV >= 3.0

目标

在本教程中你将学习如何

• 使用 OpenCV 函数 line() 绘制一条直线
• 使用 OpenCV 函数 ellipse() 绘制一个椭圆
• 使用 OpenCV 函数 rectangle() 绘制一个矩形
• 使用 OpenCV 函数 circle() 绘制一个圆
• 使用 OpenCV 函数 fillPoly() 绘制一个填充多边形

C++

OpenCV 理论

对于本教程，我们将大量使用两种结构： cv::Point 和 cv::Scalar

点

它表示一个由其图像坐标 \(x\) 和 \(y\) 指定的 2D 点。我们可以将其定义为

Point pt;
pt.x = 10;
pt.y = 8;

或

Point pt = Point(10, 8);

标量

• 表示一个有 4 个元素的向量。Scalar 类型广泛用于 OpenCV，用于传递像素值。
• 在本教程中，我们将广泛使用它来表示 BGR 颜色值（3 个参数）。如果要使用最后一个参数，没有必要定义它。
• 让我们看一个示例，如果要求我们提供颜色参数，并且我们给出

  Scalar( a, b, c )

  我们将定义如下 BGR 颜色：蓝色 = a、绿色 = b 和红色 = c

Java

OpenCV 理论

对于本教程，我们将大量使用两种结构： cv::Point 和 cv::Scalar

点

它表示一个由其图像坐标 \(x\) 和 \(y\) 指定的 2D 点。我们可以将其定义为

Point pt = new Point();
pt.x = 10;
pt.y = 8;

或

Point pt = new Point(10, 8);

标量

• 表示一个有 4 个元素的向量。Scalar 类型广泛用于 OpenCV，用于传递像素值。
• 在本教程中，我们将广泛使用它来表示 BGR 颜色值（3 个参数）。如果要使用最后一个参数，没有必要定义它。
• 让我们看一个示例，如果要求我们提供颜色参数，并且我们给出

  Scalar( a, b, c )

  我们将定义如下 BGR 颜色：蓝色 = a、绿色 = b 和红色 = c

代码

C++

• 此代码位于你的 OpenCV 样例文件夹中。否则，你可以从 此处 获取它

   
  #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),
           标量( 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 线形 = 8；
   
  椭圆形( img，
         点( w/2, w/2 )，
         尺寸( w/4, w/16 )，
  角度，
         0,
         360,
         标量( 255, 0, 0 ),
  厚度，
  线条类型)；
  }
   
  void 填充圆形( 矩阵 img, 点 中心 )
  {
  圆形( img，
  中心，
  w/32，
        标量( 0, 0, 255 ),
  FILLED,
  LINE_8 );
  }
   
  void 多边形( 矩阵 img )
  {
    int 线条类型 = LINE_8；
   
    点 rook_points[1][20]；
  rook_points[0][0] = 点( w/4, 7*w/8 )；
  rook_points[0][1] = 点( 3*w/4, 7*w/8 )；
  rook_points[0][2] = 点( 3*w/4, 13*w/16 )；
  rook_points[0][3] = 点( 11*w/16, 13*w/16 )；
  rook_points[0][4] = 点( 19*w/32, 3*w/8 )；
  rook_points[0][5] = 点( 3*w/4, 3*w/8 )；
  rook_points[0][6] = 点( 3*w/4, w/8 )；
  rook_points[0][7] = 点( 26*w/40, w/8 )；
  rook_points[0][8] = 点( 26*w/40, w/4 )；
  rook_points[0][9] = 点( 22*w/40, w/4 )；
  rook_points[0][10] = 点( 22*w/40, w/8 )；
  rook_points[0][11] = 点( 18*w/40, w/8 )；
  rook_points[0][12] = 点( 18*w/40, w/4 )；
  rook_points[0][13] = 点( 14*w/40, w/4 )；
  rook_points[0][14] = 点( 14*w/40, w/8 )；
  rook_points[0][15] = 点( w/4, w/8 )；
  rook_points[0][16] = 点( w/4, 3*w/8 )；
  rook_points[0][17] = 点( 13*w/32, 3*w/8 )；
  rook_points[0][18] = 点( 5*w/16, 13*w/16 )；
  rook_points[0][19] = 点( w/4, 13*w/16 )；
   
    const 点 * ppt[1] = { rook_points[0] }；
    int npt[] = { 20 }；
   
    填充多边形( img，
  ppt，
  npt,
          1,
          标量( 255, 255, 255 ),
  线条类型)；
  }
   
  void MyLine( Mat img, Point start, Point end )
  {
    int thickness = 2;
    int lineType = LINE_8;
   
    line( img,
  start,
  end,
      标量( 0, 0, 0 ),
  厚度，
  线条类型)；
  }

Java

• 此代码位于 OpenCV 样本文件夹中。也可从 此处 获取。

  import org.opencv.core.*;
  import org.opencv.core.Point;
  import org.opencv.highgui.HighGui;
  import org.opencv.imgproc.Imgproc;
   
  import java.util.*;
  import java.util.List;
   
  class GeometricDrawingRun{
   
      private static final int W = 400;
   
      public void run(){
  String atom_window = "Drawing 1: Atom";
  String rook_window = "Drawing 2: Rook";
   
  Mat atom_image = Mat.zeros( W, W, CvType.CV_8UC3 );
  Mat rook_image = Mat.zeros( W, W, CvType.CV_8UC3 );
   
  MyEllipse( atom_image, 90.0 );
  MyEllipse( atom_image, 0.0 );
  MyEllipse( atom_image, 45.0 );
  MyEllipse( atom_image, -45.0 );
   
  MyFilledCircle( atom_image, new Point( W/2, W/2) );
   
  MyPolygon( rook_image );
   
  Imgproc.rectangle( rook_image,
                  new Point( 0, 7*W/8 ),
                  new Point( W, W),
                  new Scalar( 0, 255, 255 ),
                  -1,
                  8,
                  0 );
   
  MyLine( rook_image, new Point( 0, 15*W/16 ), new Point( W, 15*W/16 ) );
  MyLine( rook_image, new Point( W/4, 7*W/8 ), new Point( W/4, W ) );
  MyLine( rook_image, new Point( W/2, 7*W/8 ), new Point( W/2, W ) );
  MyLine( rook_image, new Point( 3*W/4, 7*W/8 ), new Point( 3*W/4, W ) );
   
  HighGui.imshow( atom_window, atom_image );
  HighGui.moveWindow( atom_window, 0, 200 );
  HighGui.imshow( rook_window, rook_image );
  HighGui.moveWindow( rook_window, W, 200 );
   
  HighGui.waitKey( 0 );
  System.exit(0);
      }
   
   
      private void MyEllipse( Mat img, double angle ) {
          int thickness = 2;
          int 线形 = 8；
          int shift = 0;
   
  Imgproc.ellipse( img,
                  new Point( W/2, W/2 ),
                  new Size( W/4, W/16 ),
  角度，
                  0.0,
                  360.0,
                  new Scalar( 255, 0, 0 ),
  厚度，
  lineType,
  shift );
      }
   
      private void MyFilledCircle( Mat img, Point center ) {
          int thickness = -1;
          int 线形 = 8；
          int shift = 0;
   
  Imgproc.circle( img,
  中心，
  W/32,
                  new Scalar( 0, 0, 255 ),
  厚度，
  lineType,
  shift );
      }
   
      private void MyPolygon( Mat img ) {
          int 线形 = 8；
          int shift = 0;
   
  Point[] rook_points = new Point[20];
  rook_points[0] = new Point( W/4, 7*W/8 );
  rook_points[1] = new Point( 3*W/4, 7*W/8 );
  rook_points[2] = new Point( 3*W/4, 13*W/16 );
  rook_points[3] = new Point( 11*W/16, 13*W/16 );
  rook_points[4] = new Point( 19*W/32, 3*W/8 );
  rook_points[5] = new Point( 3*W/4, 3*W/8 );
  rook_points[6] = new Point( 3*W/4, W/8 );
  rook_points[7] = new Point( 26*W/40, W/8 );
  rook_points[8] = new Point( 26*W/40, W/4 );
  rook_points[9] = new Point( 22*W/40, W/4 );
  rook_points[10] = new Point( 22*W/40, W/8 );
  rook_points[11] = new Point( 18*W/40, W/8 );
  rook_points[12] = new Point( 18*W/40, W/4 );
  rook_points[13] = new Point( 14*W/40, W/4 );
  rook_points[14] = new Point( 14*W/40, W/8 );
  rook_points[15] = new Point( W/4, W/8 );
  rook_points[16] = new Point( W/4, 3*W/8 );
  rook_points[17] = new Point( 13*W/32, 3*W/8 );
  rook_points[18] = new Point( 5*W/16, 13*W/16 );
  rook_points[19] = new Point( W/4, 13*W/16 );
   
  MatOfPoint matPt = new MatOfPoint();
  matPt.fromArray(rook_points);
   
  List<MatOfPoint> ppt = new ArrayList<MatOfPoint>();
  ppt.add(matPt);
   
  Imgproc.fillPoly(img,
  ppt，
                  new Scalar( 255, 255, 255 ),
  lineType,
  shift,
                  new Point(0,0) );
      }
   
      private void MyLine( Mat img, Point start, Point end ) {
          int thickness = 2;
          int 线形 = 8；
          int shift = 0;
   
  Imgproc.line( img,
  start,
  end,
                  new Scalar( 0, 0, 0 ),
  厚度，
  lineType,
  shift );
      }
  }
   
  public class BasicGeometricDrawing {
      public static void main(String[] args) {
          // 加载本机库。
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
          new GeometricDrawingRun().run();
      }
  }

Python

• 此代码位于您的 OpenCV 样例文件夹中。否则，您可以从 此处 获取。

  import cv2 as cv
  import numpy as np
   
  W = 400
   
  def my_ellipse(img, angle)
  thickness = 2
  line_type = 8
   
      cv.ellipse(img,
  (W // 2, W // 2),
  (W // 4, W // 16),
  角度，
                  0,
                  360,
                  (255, 0, 0),
  厚度，
  line_type)
   
  def my_filled_circle(img, center)
  thickness = -1
  line_type = 8
   
      cv.circle(img,
  中心，
  W // 32,
                 (0, 0, 255),
  厚度，
  line_type)
   
  def my_polygon(img)
  line_type = 8
   
      # 创建某些点
  ppt = np.array([[W / 4, 7 * W / 8], [3 * W / 4, 7 * W / 8],
  [3 * W / 4, 13 * W / 16], [11 * W / 16, 13 * W / 16],
  [19 * W / 32, 3 * W / 8], [3 * W / 4, 3 * W / 8],
  [3 * W / 4, W / 8], [26 * W / 40, W / 8],
  [26 * W / 40, W / 4], [22 * W / 40, W / 4],
  [22 * W / 40, W / 8], [18 * W / 40, W / 8],
  [18 * W / 40, W / 4], [14 * W / 40, W / 4],
  [14 * W / 40, W / 8], [W / 4, W / 8],
  [W / 4, 3 * W / 8], [13 * W / 32, 3 * W / 8],
  [5 * W / 16, 13 * W / 16], [W / 4, 13 * W / 16]], np.int32)
  ppt = ppt.reshape((-1, 1, 2))
      cv.fillPoly(img, [ppt], (255, 255, 255), line_type)
      # 仅绘制线条将是
      # cv.polylines(img, [ppt], True, (255, 0, 255), line_type)
   
  def my_line(img, start, end)
  thickness = 2
  line_type = 8
   
      cv.line(img,
  start,
  end,
               (0, 0, 0),
  厚度，
  line_type)
   
  原子窗口 = "绘图 1：原子"
  城堡窗口 = "绘图 2：城堡"
   
  # 设置全黑空图像
  大小 = 宽，宽， 3
  原子图像 = np.zeros(大小，类型=np.uint8)
  城堡图像 = np.zeros(大小，类型=np.uint8)
   
   
  # 1.a. 创建椭圆
  my_ellipse(原子图像，90)
  my_ellipse(原子图像，0)
  my_ellipse(原子图像，45)
  my_ellipse(原子图像，-45)
   
  # 1.b. 创建圆
  my_filled_circle(原子图像，(宽 // 2，宽 // 2))
   
   
  # 2. 绘制城堡
  # ------------------
  # 2.a. 创建凸多边形
  my_polygon(城堡图像)
   
  cv.rectangle(城堡图像,
  (0，7 * 宽 // 8)，
  (宽，宽)，
                (0, 255, 255),
                -1,
                8)
   
   
  # 2.c. 创建一些线
  my_line(城堡图像，(0，15 * 宽 // 16)，(宽，15 * 宽 // 16))
  my_line(城堡图像，(宽 // 4，7 * 宽 // 8)，(宽 // 4，宽))
  my_line(城堡图像，(宽 // 2，7 * 宽 // 8)，(宽 // 2，宽))
  my_line(城堡图像，(3 * 宽 // 4，7 * 宽 // 8)，(3 * 宽 // 4，宽))
   
  cv.imshow(原子窗口，原子图像)
  cv.moveWindow(原子窗口， 0，200)
  cv.imshow(城堡窗口，城堡图像)
  cv.moveWindow(城堡窗口，宽，200)
   
  cv.waitKey(0)
  cv.destroyAllWindows()

说明

由于我们计划绘制两个示例（一个原子和一个城堡），因此我们必须创建两个图像和两个窗口来显示它们。

C++

 
  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 );

Java

 
String atom_window = "Drawing 1: Atom";
String rook_window = "Drawing 2: Rook";
 
Mat atom_image = Mat.zeros( W, W, CvType.CV_8UC3 );
Mat rook_image = Mat.zeros( W, W, CvType.CV_8UC3 );

Python

# 窗口名称
原子窗口 = "绘图 1：原子"
城堡窗口 = "绘图 2：城堡"
 
# 设置全黑空图像
大小 = 宽，宽， 3
原子图像 = np.zeros(大小，类型=np.uint8)
城堡图像 = np.zeros(大小，类型=np.uint8)

我们创建了绘制不同几何形状的函数。例如，为了绘制原子，我们使用了MyEllipse和MyFilledCircle

C++

 
MyEllipse( atom_image, 90 );
MyEllipse( atom_image, 0 );
MyEllipse( atom_image, 45 );
MyEllipse( atom_image, -45 );
 
MyFilledCircle( atom_image, Point( w/2, w/2) );

Java

 
MyEllipse( atom_image, 90.0 );
MyEllipse( atom_image, 0.0 );
MyEllipse( atom_image, 45.0 );
MyEllipse( atom_image, -45.0 );
 
MyFilledCircle( atom_image, new Point( W/2, W/2) );

Python

# 1. 绘制一个简单的原子
# -----------------------
 
# 1.a. 创建椭圆
my_ellipse(原子图像，90)
my_ellipse(原子图像，0)
my_ellipse(原子图像，45)
my_ellipse(原子图像，-45)
 
# 1.b. 创建圆
my_filled_circle(原子图像，(宽 // 2，宽 // 2))

为了绘制城堡，我们使用了 MyLine、rectangle和 MyPolygon

C++

 
MyPolygon( rook_image );
 
rectangle( rook_image,
         Point( 0, 7*w/8 ),
         Point( w, w),
         标量( 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 ) );

Java

 
MyPolygon( rook_image );
 
Imgproc.rectangle( rook_image,
                new Point( 0, 7*W/8 ),
                new Point( W, W),
                new Scalar( 0, 255, 255 ),
                -1,
                8,
                0 );
 
MyLine( rook_image, new Point( 0, 15*W/16 ), new Point( W, 15*W/16 ) );
MyLine( rook_image, new Point( W/4, 7*W/8 ), new Point( W/4, W ) );
MyLine( rook_image, new Point( W/2, 7*W/8 ), new Point( W/2, W ) );
MyLine( rook_image, new Point( 3*W/4, 7*W/8 ), new Point( 3*W/4, W ) );

Python

 
# 2. 绘制城堡
# ------------------
# 2.a. 创建凸多边形
my_polygon(城堡图像)
 
cv.rectangle(城堡图像,
(0，7 * 宽 // 8)，
(宽，宽)，
              (0, 255, 255),
              -1,
              8)
 
 
# 2.c. 创建一些线
my_line(城堡图像，(0，15 * 宽 // 16)，(宽，15 * 宽 // 16))
my_line(城堡图像，(宽 // 4，7 * 宽 // 8)，(宽 // 4，宽))
my_line(城堡图像，(宽 // 2，7 * 宽 // 8)，(宽 // 2，宽))
my_line(城堡图像，(3 * 宽 // 4，7 * 宽 // 8)，(3 * 宽 // 4，宽))

我们来检查一下这些函数中都有什么

C++

MyLine

C++

void MyLine( Mat img, Point start, Point end )
{
  int thickness = 2;
  int 线条类型 = LINE_8；
 
line( img,
start,
end,
    标量( 0, 0, 0 ),
厚度，
线条类型)；
}

Java

    private void MyLine( Mat img, Point start, Point end ) {
        int thickness = 2;
        int 线形 = 8；
        int shift = 0;
 
Imgproc.line( img,
start,
end,
                new Scalar( 0, 0, 0 ),
厚度，
lineType,
shift );
    }

Python

def my_line(img, start, end)
thickness = 2
line_type = 8
 
    cv.line(img,
start,
end,
             (0, 0, 0),
厚度，
line_type)

• 正如我们所看到的，MyLine只调用了函数 line()，它做了如下工作
  • 从点 start到点 end绘制一条线
  • 该线显示在图像 img中
  • 线颜色由 ( 0, 0, 0 )定义，这是对应于 黑色的 RGB 值
  • 线粗设置为 thickness（本例中为 2）
  • 该线是 8 进制（lineType = 8）

MyEllipse

C++

void MyEllipse( Mat img, double angle )
{
  int thickness = 2;
  int 线形 = 8；
 
椭圆形( img，
       点( w/2, w/2 )，
       尺寸( w/4, w/16 )，
角度，
       0,
       360,
       标量( 255, 0, 0 ),
厚度，
线条类型)；
}

Java

    private void MyEllipse( Mat img, double angle ) {
        int thickness = 2;
        int 线形 = 8；
        int shift = 0;
 
Imgproc.ellipse( img,
                new Point( W/2, W/2 ),
                new Size( W/4, W/16 ),
角度，
                0.0,
                360.0,
                new Scalar( 255, 0, 0 ),
厚度，
lineType,
shift );
    }

Python

def my_ellipse(img, angle)
thickness = 2
line_type = 8
 
    cv.ellipse(img,
(W // 2, W // 2),
(W // 4, W // 16),
角度，
                0,
                360,
                (255, 0, 0),
厚度，
line_type)

• 从上面的代码中，我们可以观察到函数 ellipse()绘制一个椭圆，因此
  • 椭圆显示在图像 img中
  • 椭圆中心位于点 (w/2, w/2)，并被一个大小为 (w/4, w/16)的框包围
  • 椭圆旋转 angle 度
  • 椭圆在 0 和 360 度之间延伸出一个弧
  • 这个图形的颜色将是 ( 255, 0, 0 )，这意味着 BGR 值为蓝色。
  • 椭圆的 thickness为 2。

MyFilledCircle

C++

void 填充圆形( 矩阵 img, 点 中心 )
{
圆形( img，
中心，
w/32，
      标量( 0, 0, 255 ),
FILLED,
LINE_8 );
}

Java

    private void MyFilledCircle( Mat img, Point center ) {
        int thickness = -1;
        int 线形 = 8；
        int shift = 0;
 
Imgproc.circle( img,
中心，
W/32,
                new Scalar( 0, 0, 255 ),
厚度，
lineType,
shift );
    }

Python

def my_filled_circle(img, center)
thickness = -1
line_type = 8
 
    cv.circle(img,
中心，
W // 32,
               (0, 0, 255),
厚度，
line_type)

• 与椭圆函数类似，我们可以观察到 circle接收的参数为
  • 将显示圆的图像 (img)
  • 以点 center表示的圆心
  • 圆的半径：w/32
  • 圆的颜色：( 0, 0, 255 )，表示 BGR 中的红色
  • 由于 thickness = -1，圆将填充为实心。

MyPolygon

C++

void 多边形( 矩阵 img )
{
  int 线条类型 = LINE_8；
 
  点 rook_points[1][20]；
rook_points[0][0] = 点( w/4, 7*w/8 )；
rook_points[0][1] = 点( 3*w/4, 7*w/8 )；
rook_points[0][2] = 点( 3*w/4, 13*w/16 )；
rook_points[0][3] = 点( 11*w/16, 13*w/16 )；
rook_points[0][4] = 点( 19*w/32, 3*w/8 )；
rook_points[0][5] = 点( 3*w/4, 3*w/8 )；
rook_points[0][6] = 点( 3*w/4, w/8 )；
rook_points[0][7] = 点( 26*w/40, w/8 )；
rook_points[0][8] = 点( 26*w/40, w/4 )；
rook_points[0][9] = 点( 22*w/40, w/4 )；
rook_points[0][10] = 点( 22*w/40, w/8 )；
rook_points[0][11] = 点( 18*w/40, w/8 )；
rook_points[0][12] = 点( 18*w/40, w/4 )；
rook_points[0][13] = 点( 14*w/40, w/4 )；
rook_points[0][14] = 点( 14*w/40, w/8 )；
rook_points[0][15] = 点( w/4, w/8 )；
rook_points[0][16] = 点( w/4, 3*w/8 )；
rook_points[0][17] = 点( 13*w/32, 3*w/8 )；
rook_points[0][18] = 点( 5*w/16, 13*w/16 )；
rook_points[0][19] = 点( w/4, 13*w/16 )；
 
  const 点 * ppt[1] = { rook_points[0] }；
  int npt[] = { 20 }；
 
fillPoly( img,
ppt，
npt,
        1,
        标量( 255, 255, 255 ),
线条类型)；
}

Java

    private void MyPolygon( Mat img ) {
        int 线形 = 8；
        int shift = 0;
 
Point[] rook_points = new Point[20];
rook_points[0] = new Point( W/4, 7*W/8 );
rook_points[1] = new Point( 3*W/4, 7*W/8 );
rook_points[2] = new Point( 3*W/4, 13*W/16 );
rook_points[3] = new Point( 11*W/16, 13*W/16 );
rook_points[4] = new Point( 19*W/32, 3*W/8 );
rook_points[5] = new Point( 3*W/4, 3*W/8 );
rook_points[6] = new Point( 3*W/4, W/8 );
rook_points[7] = new Point( 26*W/40, W/8 );
rook_points[8] = new Point( 26*W/40, W/4 );
rook_points[9] = new Point( 22*W/40, W/4 );
rook_points[10] = new Point( 22*W/40, W/8 );
rook_points[11] = new Point( 18*W/40, W/8 );
rook_points[12] = new Point( 18*W/40, W/4 );
rook_points[13] = new Point( 14*W/40, W/4 );
rook_points[14] = new Point( 14*W/40, W/8 );
rook_points[15] = new Point( W/4, W/8 );
rook_points[16] = new Point( W/4, 3*W/8 );
rook_points[17] = new Point( 13*W/32, 3*W/8 );
rook_points[18] = new Point( 5*W/16, 13*W/16 );
rook_points[19] = new Point( W/4, 13*W/16 );
 
MatOfPoint matPt = new MatOfPoint();
matPt.fromArray(rook_points);
 
List<MatOfPoint> ppt = new ArrayList<MatOfPoint>();
ppt.add(matPt);
 
Imgproc.fillPoly(img,
ppt，
                new Scalar( 255, 255, 255 ),
lineType,
shift,
                new Point(0,0) );
    }

Python

def my_polygon(img)
line_type = 8
 
    # 创建某些点
ppt = np.array([[W / 4, 7 * W / 8], [3 * W / 4, 7 * W / 8],
[3 * W / 4, 13 * W / 16], [11 * W / 16, 13 * W / 16],
[19 * W / 32, 3 * W / 8], [3 * W / 4, 3 * W / 8],
[3 * W / 4, W / 8], [26 * W / 40, W / 8],
[26 * W / 40, W / 4], [22 * W / 40, W / 4],
[22 * W / 40, W / 8], [18 * W / 40, W / 8],
[18 * W / 40, W / 4], [14 * W / 40, W / 4],
[14 * W / 40, W / 8], [W / 4, W / 8],
[W / 4, 3 * W / 8], [13 * W / 32, 3 * W / 8],
[5 * W / 16, 13 * W / 16], [W / 4, 13 * W / 16]], np.int32)
ppt = ppt.reshape((-1, 1, 2))
    cv.fillPoly(img, [ppt], (255, 255, 255), line_type)
    # 仅绘制线条将是
    # cv.polylines(img, [ppt], True, (255, 0, 255), line_type)

• 为了绘制一个填充多边形，我们使用了函数 fillPoly()。我们注意到
  • 多边形将绘制在 img上
  • 多边形的顶点是 ppt 中的一组点
  • 多边形的颜色由 ( 255, 255, 255 ) 定义，这是白色的 BGR 值

rectangle

C++

 
rectangle( rook_image,
         Point( 0, 7*w/8 ),
         Point( w, w),
         标量( 0, 255, 255 ),
FILLED,
LINE_8 );

Java

 
Imgproc.rectangle( rook_image,
                new Point( 0, 7*W/8 ),
                new Point( W, W),
                new Scalar( 0, 255, 255 ),
                -1,
                8,
                0 );

Python

# 2.b. 创建矩形
cv.rectangle(城堡图像,
(0，7 * 宽 // 8)，
(宽，宽)，
              (0, 255, 255),
              -1,
              8)

• 最后，我们有 cv::rectangle 函数（我们没有为此家伙创建特殊函数）。我们注意到
  • 矩形将绘制在 rook_image上
  • 矩形的两个对角顶点由 ( 0, 7*w/8 )和 ( w, w )定义
  • 矩形颜色由 ( 0, 255, 255 )给出，这是黄色的 BGR 值
  • 由于厚度值由 FILLED (-1)给出，矩形将被填充为实心。

结果

编译并运行你的程序应该会给你这样的结果