| OpenCV 5.0.0alpha Open Source Computer Vision

Loading...
Searching...
No Matches
Basic Drawing

Next Tutorial: Random generator and text with OpenCV

Original author | Ana Huamán
Compatibility | OpenCV >= 3.0

# Goals

In this tutorial you will learn how to:

- Draw a line by using the OpenCV function line()
- Draw an ellipse by using the OpenCV function ellipse()
- Draw a rectangle by using the OpenCV function rectangle()
- Draw a circle by using the OpenCV function circle()
- Draw a filled polygon by using the OpenCV function fillPoly()

# OpenCV Theory

C++

For this tutorial, we will heavily use two structures: cv::Point and cv::Scalar :

Java

For this tutorial, we will heavily use two structures: cv::Point and cv::Scalar :

Python

For this tutorial, we will heavily use tuples in Python instead of cv::Point and cv::Scalar :

## Point

It represents a 2D point, specified by its image coordinates \(x\) and \(y\). We can define it as:

C++
Point pt;
pt.x = 10;
pt.y = 8;
cv::Point_::x
_Tp x
x coordinate of the point
Definition types.hpp:201

or

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

or

Point pt = new Point(10, 8);
Python
pt = (10, 0) # x = 10, y = 0

## Scalar

- Represents a 4-element vector. The type Scalar is widely used in OpenCV for passing pixel values.
- In this tutorial, we will use it extensively to represent BGR color values (3 parameters). It is not necessary to define the last argument if it is not going to be used.
- Let's see an example, if we are asked for a color argument and we give:
  C++
  Scalar( a, b, c )
  Java
  Scalar( a, b, c )
  Python
  ( a, b, c )
  We would be defining a BGR color such as: Blue = a, Green = b and Red = c

# Code

C++

- This code is in your OpenCV sample folder. Otherwise you can grab it from here
  #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 );
  }
  cv::Mat
  n-dimensional dense array class
  Definition mat.hpp:951
  cv::Point_< int >
  cv::Scalar_< double >
  cv::Size_
  Template class for specifying the size of an image or rectangle.
  Definition types.hpp:338
  CV_8UC3
  #define CV_8UC3
  Definition interface.h:101
  cv::fillPoly
  void fillPoly(InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=LINE_8, int shift=0, Point offset=Point())
  Fills the area bounded by one or more polygons.
  cv::line
  void line(InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
  Draws a line segment connecting two points.
  cv::LINE_8
  @ LINE_8
  8-connected line
  Definition imgproc.hpp:896
  highgui.hpp
  main
  int main(int argc, char *argv[])
  Definition highgui_qt.cpp:3
  core.hpp
  imgproc.hpp
  cv
  Definition core.hpp:107

Java

- This code is in your OpenCV sample folder. Otherwise you can grab it from here
  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 lineType = 8;
  int shift = 0;
  Imgproc.ellipse( img,
  new Point( W/2, W/2 ),
  new Size( W/4, W/16 ),
  angle,
  0.0,
  360.0,
  new Scalar( 255, 0, 0 ),
  thickness,
  lineType,
  shift );
  }
  private void MyFilledCircle( Mat img, Point center ) {
  int thickness = -1;
  int lineType = 8;
  int shift = 0;
  Imgproc.circle( img,
  center,
  W/32,
  new Scalar( 0, 0, 255 ),
  thickness,
  lineType,
  shift );
  }
  private void MyPolygon( Mat img ) {
  int lineType = 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 lineType = 8;
  int shift = 0;
  Imgproc.line( img,
  start,
  end,
  new Scalar( 0, 0, 0 ),
  thickness,
  lineType,
  shift );
  }
  }
  public class BasicGeometricDrawing {
  public static void main(String[] args) {
  // Load the native library.
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
  new GeometricDrawingRun().run();
  }
  }
  cv::Scalar
  Scalar_< double > Scalar
  Definition types.hpp:712

Python

- This code is in your OpenCV sample folder. Otherwise you can grab it from here
  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),
  angle,
  0,
  360,
  (255, 0, 0),
  thickness,
  line_type)
  def my_filled_circle(img, center):
  thickness = -1
  line_type = 8
  cv.circle(img,
  center,
  W // 32,
  (0, 0, 255),
  thickness,
  line_type)
  def my_polygon(img):
  line_type = 8
  # Create some points
  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)
  # Only drawind the lines would be:
  # 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),
  thickness,
  line_type)
  atom_window = "Drawing 1: Atom"
  rook_window = "Drawing 2: Rook"
  # Create black empty images
  size = W, W, 3
  atom_image = np.zeros(size, dtype=np.uint8)
  rook_image = np.zeros(size, dtype=np.uint8)
  # 1.a. Creating ellipses
  my_ellipse(atom_image, 90)
  my_ellipse(atom_image, 0)
  my_ellipse(atom_image, 45)
  my_ellipse(atom_image, -45)
  # 1.b. Creating circles
  my_filled_circle(atom_image, (W // 2, W // 2))
  # 2. Draw a rook
  # ------------------
  # 2.a. Create a convex polygon
  my_polygon(rook_image)
  cv.rectangle(rook_image,
  (0, 7 * W // 8),
  (W, W),
  (0, 255, 255),
  -1,
  8)
  # 2.c. Create a few lines
  my_line(rook_image, (0, 15 * W // 16), (W, 15 * W // 16))
  my_line(rook_image, (W // 4, 7 * W // 8), (W // 4, W))
  my_line(rook_image, (W // 2, 7 * W // 8), (W // 2, W))
  my_line(rook_image, (3 * W // 4, 7 * W // 8), (3 * W // 4, W))
  cv.imshow(atom_window, atom_image)
  cv.moveWindow(atom_window, 0, 200)
  cv.imshow(rook_window, rook_image)
  cv.moveWindow(rook_window, W, 200)
  cv.waitKey(0)
  cv.destroyAllWindows()
  cv::imshow
  void imshow(const String &winname, InputArray mat)
  Displays an image in the specified window.
  cv::waitKey
  int waitKey(int delay=0)
  Waits for a pressed key.
  cv::destroyAllWindows
  void destroyAllWindows()
  Destroys all of the HighGUI windows.
  cv::moveWindow
  void moveWindow(const String &winname, int x, int y)
  Moves the window to the specified position.
  cv::rectangle
  void rectangle(InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
  Draws a simple, thick, or filled up-right rectangle.
  cv::ellipse
  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)
  Draws a simple or thick elliptic arc or fills an ellipse sector.
  cv::circle
  void circle(InputOutputArray img, Point center, int radius, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
  Draws a circle.

# Explanation

Since we plan to draw two examples (an atom and a rook), we have to create two images and two windows to display them.

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
atom_window = "Drawing 1: Atom"
rook_window = "Drawing 2: Rook"
# Create black empty images
size = W, W, 3
atom_image = np.zeros(size, dtype=np.uint8)
rook_image = np.zeros(size, dtype=np.uint8)

We created functions to draw different geometric shapes. For instance, to draw the atom we used MyEllipse and 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.a. Creating ellipses
my_ellipse(atom_image, 90)
my_ellipse(atom_image, 0)
my_ellipse(atom_image, 45)
my_ellipse(atom_image, -45)
# 1.b. Creating circles
my_filled_circle(atom_image, (W // 2, W // 2))

And to draw the rook we employed MyLine, rectangle and a MyPolygon:

C++
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 ) );
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. Draw a rook
# ------------------
# 2.a. Create a convex polygon
my_polygon(rook_image)
cv.rectangle(rook_image,
(0, 7 * W // 8),
(W, W),
(0, 255, 255),
-1,
8)
# 2.c. Create a few lines
my_line(rook_image, (0, 15 * W // 16), (W, 15 * W // 16))
my_line(rook_image, (W // 4, 7 * W // 8), (W // 4, W))
my_line(rook_image, (W // 2, 7 * W // 8), (W // 2, W))
my_line(rook_image, (3 * W // 4, 7 * W // 8), (3 * W // 4, W))

Let's check what is inside each of these functions:

C++

#### MyLine

C++
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 );
}
Java
private void MyLine( Mat img, Point start, Point end ) {
int thickness = 2;
int lineType = 8;
int shift = 0;
Imgproc.line( img,
start,
end,
new Scalar( 0, 0, 0 ),
thickness,
lineType,
shift );
}
Python
def my_line(img, start, end):
thickness = 2
line_type = 8
cv.line(img,
start,
end,
(0, 0, 0),
thickness,
line_type)

- As we can see, MyLine just call the function line() , which does the following:
  - Draw a line from Point start to Point end
  - The line is displayed in the image img
  - The line color is defined by ( 0, 0, 0 ) which is the RGB value correspondent to Black
  - The line thickness is set to thickness (in this case 2)
  - The line is a 8-connected one (lineType = 8)

#### MyEllipse

C++
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 );
}
Java
private void MyEllipse( Mat img, double angle ) {
int thickness = 2;
int lineType = 8;
int shift = 0;
Imgproc.ellipse( img,
new Point( W/2, W/2 ),
new Size( W/4, W/16 ),
angle,
0.0,
360.0,
new Scalar( 255, 0, 0 ),
thickness,
lineType,
shift );
}
Python
def my_ellipse(img, angle):
thickness = 2
line_type = 8
cv.ellipse(img,
(W // 2, W // 2),
(W // 4, W // 16),
angle,
0,
360,
(255, 0, 0),
thickness,
line_type)

- From the code above, we can observe that the function ellipse() draws an ellipse such that:
  - The ellipse is displayed in the image img
  - The ellipse center is located in the point (w/2, w/2) and is enclosed in a box of size (w/4, w/16)
  - The ellipse is rotated angle degrees
  - The ellipse extends an arc between 0 and 360 degrees
  - The color of the figure will be ( 255, 0, 0 ) which means blue in BGR value.
  - The ellipse's thickness is 2.

#### MyFilledCircle

C++
void MyFilledCircle( Mat img, Point center )
{
circle( img,
center,
w/32,
Scalar( 0, 0, 255 ),
FILLED,
LINE_8 );
}
Java
private void MyFilledCircle( Mat img, Point center ) {
int thickness = -1;
int lineType = 8;
int shift = 0;
Imgproc.circle( img,
center,
W/32,
new Scalar( 0, 0, 255 ),
thickness,
lineType,
shift );
}
Python
def my_filled_circle(img, center):
thickness = -1
line_type = 8
cv.circle(img,
center,
W // 32,
(0, 0, 255),
thickness,
line_type)

- Similar to the ellipse function, we can observe that circle receives as arguments:
  - The image where the circle will be displayed (img)
  - The center of the circle denoted as the point center
  - The radius of the circle: w/32
  - The color of the circle: ( 0, 0, 255 ) which means Red in BGR
  - Since thickness = -1, the circle will be drawn filled.

#### MyPolygon

C++
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 );
}
Java
private void MyPolygon( Mat img ) {
int lineType = 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
# Create some points
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)
# Only drawind the lines would be:
# cv.polylines(img, [ppt], True, (255, 0, 255), line_type)

- To draw a filled polygon we use the function fillPoly() . We note that:
  - The polygon will be drawn on img
  - The vertices of the polygon are the set of points in ppt
  - The color of the polygon is defined by ( 255, 255, 255 ), which is the BGR value for white

#### rectangle

C++
rectangle( rook_image,
Point( 0, 7*w/8 ),
Point( w, w),
Scalar( 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
cv.rectangle(rook_image,
(0, 7 * W // 8),
(W, W),
(0, 255, 255),
-1,
8)

- Finally we have the cv::rectangle function (we did not create a special function for this guy). We note that:
  - The rectangle will be drawn on rook_image
  - Two opposite vertices of the rectangle are defined by ( 0, 7*w/8 ) and ( w, w )
  - The color of the rectangle is given by ( 0, 255, 255 ) which is the BGR value for yellow
  - Since the thickness value is given by FILLED (-1), the rectangle will be filled.

# Result

Compiling and running your program should give you a result like this: