Drawing Functions#
Detailed Description#
Drawing functions work with matrices/images of arbitrary depth. The boundaries of the shapes can be rendered with antialiasing (implemented only for 8-bit images for now). All the functions include the parameter color that uses an RGB value (that may be constructed with the Scalar constructor ) for color images and brightness for grayscale images. For color images, the channel ordering is normally Blue, Green, Red. This is what imshow, imread, and imwrite expect. So, if you form a color using the Scalar constructor, it should look like:
If you are using your own image rendering and I/O functions, you can use any channel ordering. The drawing functions process each channel independently and do not depend on the channel order or even on the used color space. The whole image can be converted from BGR to RGB or to a different color space using cvtColor .
If a drawn figure is partially or completely outside the image, the drawing functions clip it. Also, many drawing functions can handle pixel coordinates specified with sub-pixel accuracy. This means that the coordinates can be passed as fixed-point numbers encoded as integers. The number of fractional bits is specified by the shift parameter and the real point coordinates are calculated as \(\texttt{Point}(x,y)\rightarrow\texttt{Point2f}(x*2^{-shift},y*2^{-shift})\) . This feature is especially effective when rendering antialiased shapes.
Note
The functions do not support alpha-transparency when the target image is 4-channel. In this case, the color[3] is simply copied to the repainted pixels. Thus, if you want to paint semi-transparent shapes, you can paint them in a separate buffer and then blend it with the main image.
Classes#
Name |
Description |
|---|---|
|
Wrapper on top of a truetype/opentype/etc font, i.e. Freetype’s FT_Face. View details |
|
Class for iterating over all pixels on a raster line segment. View details |
Enumerations#
enum cv::HersheyFonts {
cv::FONT_HERSHEY_SIMPLEX = 0,
cv::FONT_HERSHEY_PLAIN = 1,
cv::FONT_HERSHEY_DUPLEX = 2,
cv::FONT_HERSHEY_COMPLEX = 3,
cv::FONT_HERSHEY_TRIPLEX = 4,
cv::FONT_HERSHEY_COMPLEX_SMALL = 5,
cv::FONT_HERSHEY_SCRIPT_SIMPLEX = 6,
cv::FONT_HERSHEY_SCRIPT_COMPLEX = 7,
cv::FONT_ITALIC = 16
}
enum cv::LineTypes {
cv::FILLED = -1,
cv::LINE_4 = 4,
cv::LINE_8 = 8,
cv::LINE_AA = 16
}
enum cv::MarkerTypes {
cv::MARKER_CROSS = 0,
cv::MARKER_TILTED_CROSS = 1,
cv::MARKER_STAR = 2,
cv::MARKER_DIAMOND = 3,
cv::MARKER_SQUARE = 4,
cv::MARKER_TRIANGLE_UP = 5,
cv::MARKER_TRIANGLE_DOWN = 6
}
enum cv::PutTextFlags {
cv::PUT_TEXT_ALIGN_LEFT =0,
cv::PUT_TEXT_ALIGN_CENTER =1,
cv::PUT_TEXT_ALIGN_RIGHT =2,
cv::PUT_TEXT_ALIGN_MASK =3,
cv::PUT_TEXT_ORIGIN_TL =0,
cv::PUT_TEXT_ORIGIN_BL =32,
cv::PUT_TEXT_WRAP =128
}Defines various put text flags. View details
Enumeration Type Documentation#
HersheyFonts#
enum cv::HersheyFonts
#include <opencv2/imgproc.hpp>
Only a subset of Hershey fonts https://en.wikipedia.org/wiki/Hershey_fonts are supported
Enumerator:
|
normal size sans-serif font |
|
small size sans-serif font |
|
normal size sans-serif font (more complex than FONT_HERSHEY_SIMPLEX) |
|
normal size serif font |
|
normal size serif font (more complex than FONT_HERSHEY_COMPLEX) |
|
smaller version of FONT_HERSHEY_COMPLEX |
|
hand-writing style font |
|
more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX |
|
flag for italic font |
LineTypes#
enum cv::LineTypes
#include <opencv2/imgproc.hpp>
types of line
Enumerator:
|
|
|
4-connected line |
|
8-connected line |
|
antialiased line |
MarkerTypes#
enum cv::MarkerTypes
#include <opencv2/imgproc.hpp>
Possible set of marker types used for the cv::drawMarker function
Enumerator:
|
A crosshair marker shape. |
|
A 45 degree tilted crosshair marker shape. |
|
A star marker shape, combination of cross and tilted cross. |
|
A diamond marker shape. |
|
A square marker shape. |
|
An upwards pointing triangle marker shape. |
|
A downwards pointing triangle marker shape. |
PutTextFlags#
enum cv::PutTextFlags
#include <opencv2/imgproc.hpp>
Defines various put text flags.
Enumerator:
|
|
|
|
|
|
|
Function Documentation#
arrowedLine()#
void cv::arrowedLine(
InputOutputArray img,
Point pt1,
Point pt2,
const Scalar & color,
int thickness = 1,
int line_type = 8,
int shift = 0,
double tipLength = 0.1 )
#include <opencv2/imgproc.hpp>
Python:
cv.arrowedLine(img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]]) -> img
Draws an arrow segment pointing from the first point to the second one.
The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also line.
Parameters
img— Image.pt1— The point the arrow starts from.pt2— The point the arrow points to.color— Line color.thickness— Line thickness.line_type— Type of the line. See LineTypesshift— Number of fractional bits in the point coordinates.tipLength— The length of the arrow tip in relation to the arrow length
circle()#
void cv::circle(
InputOutputArray img,
Point center,
int radius,
const Scalar & color,
int thickness = 1,
int lineType = LINE_8,
int shift = 0 )
#include <opencv2/imgproc.hpp>
Python:
cv.circle(img, center, radius, color[, thickness[, lineType[, shift]]]) -> img
Draws a circle.
The function cv::circle draws a simple or filled circle with a given center and radius.
Parameters
img— Image where the circle is drawn.center— Center of the circle.radius— Radius of the circle.color— Circle color.thickness— Thickness of the circle outline, if positive. Negative values, like FILLED, mean that a filled circle is to be drawn.lineType— Type of the circle boundary. See LineTypesshift— Number of fractional bits in the coordinates of the center and in the radius value.
clipLine()#
bool cv::clipLine(
Rect imgRect,
Point & pt1,
Point & pt2 )
#include <opencv2/imgproc.hpp>
Python:
cv.clipLine(imgRect, pt1, pt2) -> retval, pt1, pt2
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
Parameters
imgRect— Image rectangle.pt1— First line point.pt2— Second line point.
clipLine()#
bool cv::clipLine(
Size imgSize,
Point & pt1,
Point & pt2 )
#include <opencv2/imgproc.hpp>
Python:
cv.clipLine(imgRect, pt1, pt2) -> retval, pt1, pt2
Clips the line against the image rectangle.
The function cv::clipLine calculates a part of the line segment that is entirely within the specified rectangle. It returns false if the line segment is completely outside the rectangle. Otherwise, it returns true .
Parameters
imgSize— Image size. The image rectangle is Rect(0, 0, imgSize.width, imgSize.height) .pt1— First line point.pt2— Second line point.
clipLine()#
bool cv::clipLine(
Size2l imgSize,
Point2l & pt1,
Point2l & pt2 )
#include <opencv2/imgproc.hpp>
Python:
cv.clipLine(imgRect, pt1, pt2) -> retval, pt1, pt2
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
Parameters
imgSize— Image size. The image rectangle is Rect(0, 0, imgSize.width, imgSize.height) .pt1— First line point.pt2— Second line point.
drawContours()#
void cv::drawContours(
InputOutputArray image,
InputArrayOfArrays contours,
int contourIdx,
const Scalar & color,
int thickness = 1,
int lineType = LINE_8,
InputArray hierarchy = noArray(),
int maxLevel = INT_MAX,
Point offset = Point() )
#include <opencv2/imgproc.hpp>
Python:
cv.drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) -> image
Draws contours outlines or filled contours.
The function draws contour outlines in the image if \(\texttt{thickness} \ge 0\) or fills the area bounded by the contours if \(\texttt{thickness}<0\) . The example below shows how to retrieve connected components from the binary image and label them: :
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
using namespace cv;
using namespace std;
int main( int argc, char** argv )
{
Mat src;
// the first command-line parameter must be a filename of the binary
// (black-n-white) image
if( argc != 2 || !(src=imread(argv[1], IMREAD_GRAYSCALE)).data)
return -1;
Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);
src = src > 1;
namedWindow( "Source", 1 );
imshow( "Source", src );
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
findContours( src, contours, hierarchy,
RETR_CCOMP, CHAIN_APPROX_SIMPLE );
// iterate through all the top-level contours,
// draw each connected component with its own random color
int idx = 0;
for( ; idx >= 0; idx = hierarchy[idx][0] )
{
Scalar color( rand()&255, rand()&255, rand()&255 );
drawContours( dst, contours, idx, color, FILLED, 8, hierarchy );
}
namedWindow( "Components", 1 );
imshow( "Components", dst );
waitKey(0);
}
Note
When thickness=FILLED, the function is designed to handle connected components with holes correctly even when no hierarchy data is provided. This is done by analyzing all the outlines together using even-odd rule. This may give incorrect results if you have a joint collection of separately retrieved contours. In order to solve this problem, you need to call drawContours separately for each sub-group of contours, or iterate over the collection using contourIdx parameter.
Parameters
image— Destination image.contours— All the input contours. Each contour is stored as a point vector.contourIdx— Parameter indicating a contour to draw. If it is negative, all the contours are drawn.color— Color of the contours.thickness— Thickness of lines the contours are drawn with. If it is negative (for example, thickness=FILLED ), the contour interiors are drawn.lineType— Line connectivity. See LineTypeshierarchy— Optional information about hierarchy. It is only needed if you want to draw only some of the contours (see maxLevel ).maxLevel— Maximal level for drawn contours. If it is 0, only the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is hierarchy available.offset— Optional contour shift parameter. Shift all the drawn contours by the specified \(\texttt{offset}=(dx,dy)\) .
drawFrameAxes()#
void cv::drawFrameAxes(
InputOutputArray image,
InputArray cameraMatrix,
InputArray distCoeffs,
InputArray rvec,
InputArray tvec,
float length,
int thickness = 3 )
#include <opencv2/imgproc.hpp>
Python:
cv.drawFrameAxes(image, cameraMatrix, distCoeffs, rvec, tvec, length[, thickness]) -> image
Draw axes of the world/object coordinate system from pose estimation.
See also
This function draws the axes of the world/object coordinate system w.r.t. to the camera frame. OX is drawn in red, OY in green and OZ in blue.
Parameters
image— Input/output image. It must have 1 or 3 channels. The number of channels is not altered.cameraMatrix— Input 3x3 floating-point matrix of camera intrinsic parameters. \(\cameramatrix{A}\)distCoeffs— Input vector of distortion coefficients \(\distcoeffs\). If the vector is empty, the zero distortion coefficients are assumed.rvec— Rotation vector (see Rodrigues ) that, together with tvec, brings points from the model coordinate system to the camera coordinate system.tvec— Translation vector.length— Length of the painted axes in the same unit than tvec (usually in meters).thickness— Line thickness of the painted axes.
drawMarker()#
void cv::drawMarker(
InputOutputArray img,
Point position,
const Scalar & color,
int markerType = MARKER_CROSS,
int markerSize = 20,
int thickness = 1,
int line_type = 8 )
#include <opencv2/imgproc.hpp>
Python:
cv.drawMarker(img, position, color[, markerType[, markerSize[, thickness[, line_type]]]]) -> img
Draws a marker on a predefined position in an image.
The function cv::drawMarker draws a marker on a given position in the image. For the moment several marker types are supported, see MarkerTypes for more information.
Parameters
img— Image.position— The point where the crosshair is positioned.color— Line color.markerType— The specific type of marker you want to use, see MarkerTypesthickness— Line thickness.line_type— Type of the line, See LineTypesmarkerSize— The length of the marker axis [default = 20 pixels]
ellipse()#
void cv::ellipse(
InputOutputArray img,
const RotatedRect & box,
const Scalar & color,
int thickness = 1,
int lineType = LINE_8 )
#include <opencv2/imgproc.hpp>
Python:
cv.ellipse(img, center, axes, angle, startAngle, endAngle, color[, thickness[, lineType[, shift]]]) -> img
cv.ellipse(img, box, color[, thickness[, lineType]]) -> img
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
Parameters
img— Image.box— Alternative ellipse representation via RotatedRect. This means that the function draws an ellipse inscribed in the rotated rectangle.color— Ellipse color.thickness— Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.lineType— Type of the ellipse boundary. See LineTypes
ellipse()#
void cv::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 )
#include <opencv2/imgproc.hpp>
Python:
cv.ellipse(img, center, axes, angle, startAngle, endAngle, color[, thickness[, lineType[, shift]]]) -> img
cv.ellipse(img, box, color[, thickness[, lineType]]) -> img
Draws a simple or thick elliptic arc or fills an ellipse sector.
The function cv::ellipse with more parameters draws an ellipse outline, a filled ellipse, an elliptic arc, or a filled ellipse sector. The drawing code uses general parametric form. A piecewise-linear curve is used to approximate the elliptic arc boundary. If you need more control of the ellipse rendering, you can retrieve the curve using ellipse2Poly and then render it with polylines or fill it with fillPoly. If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass startAngle=0 and endAngle=360. If startAngle is greater than endAngle, they are swapped. The figure below explains the meaning of the parameters to draw the blue arc.
Parameters
img— Image.center— Center of the ellipse.axes— Half of the size of the ellipse main axes.angle— Ellipse rotation angle in degrees.startAngle— Starting angle of the elliptic arc in degrees.endAngle— Ending angle of the elliptic arc in degrees.color— Ellipse color.thickness— Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.lineType— Type of the ellipse boundary. See LineTypesshift— Number of fractional bits in the coordinates of the center and values of axes.
ellipse2Poly()#
void cv::ellipse2Poly(
Point center,
Size axes,
int angle,
int arcStart,
int arcEnd,
int delta,
std::vector< Point > & pts )
#include <opencv2/imgproc.hpp>
Python:
cv.ellipse2Poly(center, axes, angle, arcStart, arcEnd, delta) -> pts
Approximates an elliptic arc with a polyline.
The function ellipse2Poly computes the vertices of a polyline that approximates the specified elliptic arc. It is used by ellipse. If arcStart is greater than arcEnd, they are swapped.
Parameters
center— Center of the arc.axes— Half of the size of the ellipse main axes. See ellipse for details.angle— Rotation angle of the ellipse in degrees. See ellipse for details.arcStart— Starting angle of the elliptic arc in degrees.arcEnd— Ending angle of the elliptic arc in degrees.delta— Angle between the subsequent polyline vertices. It defines the approximation accuracy.pts— Output vector of polyline vertices.
ellipse2Poly()#
void cv::ellipse2Poly(
Point2d center,
Size2d axes,
int angle,
int arcStart,
int arcEnd,
int delta,
std::vector< Point2d > & pts )
#include <opencv2/imgproc.hpp>
Python:
cv.ellipse2Poly(center, axes, angle, arcStart, arcEnd, delta) -> pts
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
Parameters
center— Center of the arc.axes— Half of the size of the ellipse main axes. See ellipse for details.angle— Rotation angle of the ellipse in degrees. See ellipse for details.arcStart— Starting angle of the elliptic arc in degrees.arcEnd— Ending angle of the elliptic arc in degrees.delta— Angle between the subsequent polyline vertices. It defines the approximation accuracy.pts— Output vector of polyline vertices.
fillConvexPoly()#
void cv::fillConvexPoly(
InputOutputArray img,
const Point * pts,
int npts,
const Scalar & color,
int lineType = LINE_8,
int shift = 0 )
#include <opencv2/imgproc.hpp>
Python:
cv.fillConvexPoly(img, points, color[, lineType[, shift]]) -> img
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
fillConvexPoly()#
void cv::fillConvexPoly(
InputOutputArray img,
InputArray points,
const Scalar & color,
int lineType = LINE_8,
int shift = 0 )
#include <opencv2/imgproc.hpp>
Python:
cv.fillConvexPoly(img, points, color[, lineType[, shift]]) -> img
Fills a convex polygon.
The function cv::fillConvexPoly draws a filled convex polygon. This function is much faster than the function fillPoly . It can fill not only convex polygons but any monotonic polygon without self-intersections, that is, a polygon whose contour intersects every horizontal line (scan line) twice at the most (though, its top-most and/or the bottom edge could be horizontal).
Parameters
img— Image.points— Polygon vertices.color— Polygon color.lineType— Type of the polygon boundaries. See LineTypesshift— Number of fractional bits in the vertex coordinates.
fillPoly()#
void cv::fillPoly(
InputOutputArray img,
const Point ** pts,
const int * npts,
int ncontours,
const Scalar & color,
int lineType = LINE_8,
int shift = 0,
Point offset = Point() )
#include <opencv2/imgproc.hpp>
Python:
cv.fillPoly(img, pts, color[, lineType[, shift[, offset]]]) -> img
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
fillPoly()#
void cv::fillPoly(
InputOutputArray img,
InputArrayOfArrays pts,
const Scalar & color,
int lineType = LINE_8,
int shift = 0,
Point offset = Point() )
#include <opencv2/imgproc.hpp>
Python:
cv.fillPoly(img, pts, color[, lineType[, shift[, offset]]]) -> img
Fills the area bounded by one or more polygons.
The function cv::fillPoly fills an area bounded by several polygonal contours. The function can fill complex areas, for example, areas with holes, contours with self-intersections (some of their parts), and so forth.
Parameters
img— Image.pts— Array of polygons where each polygon is represented as an array of points.color— Polygon color.lineType— Type of the polygon boundaries. See LineTypesshift— Number of fractional bits in the vertex coordinates.offset— Optional offset of all points of the contours.
getFontScaleFromHeight()#
double cv::getFontScaleFromHeight(
const int fontFace,
const int pixelHeight,
const int thickness = 1 )
#include <opencv2/imgproc.hpp>
Python:
cv.getFontScaleFromHeight(fontFace, pixelHeight[, thickness]) -> retval
Calculates the font-specific size to use to achieve a given height in pixels.
See also
Parameters
fontFace— Font to use, see cv::HersheyFonts.pixelHeight— Pixel height to compute the fontScale forthickness— Thickness of lines used to render the text.See putText for details.
Returns
The fontSize to use for cv::putText
getTextSize()#
Size cv::getTextSize(
const String & text,
int fontFace,
double fontScale,
int thickness,
int * baseLine )
#include <opencv2/imgproc.hpp>
Python:
cv.getTextSize(text, fontFace, fontScale, thickness) -> retval, baseLine
cv.getTextSize(imgsize, text, org, fface, size[, weight[, flags[, wrap]]]) -> retval
Calculates the width and height of a text string.
The function cv::getTextSize calculates and returns the size of a box that contains the specified text. That is, the following code renders some text, the tight box surrounding it, and the baseline: :
String text = "Funny text inside the box";
int fontFace = FONT_HERSHEY_SCRIPT_SIMPLEX;
double fontScale = 2;
int thickness = 3;
Mat img(600, 800, CV_8UC3, Scalar::all(0));
int baseline=0;
Size textSize = getTextSize(text, fontFace,
fontScale, thickness, &baseline);
baseline += thickness;
// center the text
Point textOrg((img.cols - textSize.width)/2,
(img.rows + textSize.height)/2);
// draw the box
rectangle(img, textOrg + Point(0, baseline),
textOrg + Point(textSize.width, -textSize.height),
Scalar(0,0,255));
// ... and the baseline first
line(img, textOrg + Point(0, thickness),
textOrg + Point(textSize.width, thickness),
Scalar(0, 0, 255));
// then put the text itself
putText(img, text, textOrg, fontFace, fontScale,
Scalar::all(255), thickness, 8);
See also
Parameters
text— Input text string.fontFace— Font to use, see HersheyFonts.fontScale— Font scale factor that is multiplied by the font-specific base size.thickness— Thickness of lines used to render the text. See putText for details.baseLine— y-coordinate of the baseline relative to the bottom-most text point.
Returns
The size of a box that contains the specified text.
getTextSize()#
Rect cv::getTextSize(
Size imgsize,
const String & text,
Point org,
FontFace & fface,
int size,
int weight = 0,
PutTextFlags flags = PUT_TEXT_ALIGN_LEFT,
Range wrap = Range() )
#include <opencv2/imgproc.hpp>
Python:
cv.getTextSize(text, fontFace, fontScale, thickness) -> retval, baseLine
cv.getTextSize(imgsize, text, org, fface, size[, weight[, flags[, wrap]]]) -> retval
Calculates the bounding rect for the text.
The function cv::getTextSize calculates and returns the size of a box that contains the specified text. That is, the following code renders some text, the tight box surrounding it, and the baseline: :
Parameters
imgsize— Size of the target image, can be emptytext— Text string to be drawn.org— Bottom-left corner of the first character of the printed text (see PUT_TEXT_ALIGN_… though)fface— The font to use for the textsize— Font size in pixels (by default) or ptsweight— Font weight, 100..1000, where 100 is “thin” font, 400 is “regular”, 600 is “semibold”, 800 is “bold” and beyond that is “black”. The default weight means “400” for variable-weight fonts or whatever “default” weight the used font provides.flags— Various flags, see PUT_TEXT_…wrap— The optional text wrapping range; see putText.
line()#
void cv::line(
InputOutputArray img,
Point pt1,
Point pt2,
const Scalar & color,
int thickness = 1,
int lineType = LINE_8,
int shift = 0 )
#include <opencv2/imgproc.hpp>
Python:
cv.line(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> img
Draws a line segment connecting two points.
The function line draws the line segment between pt1 and pt2 points in the image. The line is clipped by the image boundaries. For non-antialiased lines with integer coordinates, the 8-connected or 4-connected Bresenham algorithm is used. Thick lines are drawn with rounding endings. Antialiased lines are drawn using Gaussian filtering.
Parameters
img— Image.pt1— First point of the line segment.pt2— Second point of the line segment.color— Line color.thickness— Line thickness.lineType— Type of the line. See LineTypes.shift— Number of fractional bits in the point coordinates.
polylines()#
void cv::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 )
#include <opencv2/imgproc.hpp>
Python:
cv.polylines(img, pts, isClosed, color[, thickness[, lineType[, shift]]]) -> img
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
polylines()#
void cv::polylines(
InputOutputArray img,
InputArrayOfArrays pts,
bool isClosed,
const Scalar & color,
int thickness = 1,
int lineType = LINE_8,
int shift = 0 )
#include <opencv2/imgproc.hpp>
Python:
cv.polylines(img, pts, isClosed, color[, thickness[, lineType[, shift]]]) -> img
Draws several polygonal curves.
The function cv::polylines draws one or more polygonal curves.
Parameters
img— Image.pts— Array of polygonal curves.isClosed— Flag indicating whether the drawn polylines are closed or not. If they are closed, the function draws a line from the last vertex of each curve to its first vertex.color— Polyline color.thickness— Thickness of the polyline edges.lineType— Type of the line segments. See LineTypesshift— Number of fractional bits in the vertex coordinates.
putText()#
void cv::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/imgproc.hpp>
Python:
cv.putText(img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]]) -> img
cv.putText(img, text, org, color, fface, size[, weight[, flags[, wrap]]]) -> retval, img
Draws a text string.
The function cv::putText renders the specified text string in the image. Symbols that cannot be rendered using the specified font are replaced by question marks. See getTextSize for a text rendering code example.
The fontScale parameter is a scale factor that is multiplied by the base font size:
When scale > 1, the text is magnified.
When 0 < scale < 1, the text is minimized.
When scale < 0, the text is mirrored or reversed.
Parameters
img— Image.text— Text string to be drawn.org— Bottom-left corner of the text string in the image.fontFace— Font type, see HersheyFonts.fontScale— Font scale factor that is multiplied by the font-specific base size.color— Text color.thickness— Thickness of the lines used to draw a text.lineType— Line type. See LineTypesbottomLeftOrigin— When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner.
putText()#
Point cv::putText(
InputOutputArray img,
const String & text,
Point org,
Scalar color,
FontFace & fface,
int size,
int weight = 0,
PutTextFlags flags = PUT_TEXT_ALIGN_LEFT,
Range wrap = Range() )
#include <opencv2/imgproc.hpp>
Python:
cv.putText(img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]]) -> img
cv.putText(img, text, org, color, fface, size[, weight[, flags[, wrap]]]) -> retval, img
Draws a text string using specified font.
The function cv::putText renders the specified text string in the image. Symbols that cannot be rendered using the specified font are replaced by question marks. See getTextSize for a text rendering code example. The function returns the coordinates in pixels from where the text can be continued.
Parameters
img— Image.text— Text string to be drawn.org— Bottom-left corner of the first character of the printed text (see PUT_TEXT_ALIGN_… though)color— Text color.fface— The font to use for the textsize— Font size in pixels (by default) or ptsweight— Font weight, 100..1000, where 100 is “thin” font, 400 is “regular”, 600 is “semibold”, 800 is “bold” and beyond that is “black”. The parameter is ignored if the font is not a variable font or if it does not provide variation along ‘wght’ axis. If the weight is 0, then the weight, currently set via setInstance(), is used.flags— Various flags, see PUT_TEXT_…wrap— The optional text wrapping range: In the case of left-to-right (LTR) text if the printed character would cross wrap.end boundary, the “cursor” is set to wrap.start. In the case of right-to-left (RTL) text it’s vice versa. If the parameters is not set, [org.x, img.cols] is used for LTR text and [0, org.x] is for RTL one.
rectangle()#
void cv::rectangle(
InputOutputArray img,
Point pt1,
Point pt2,
const Scalar & color,
int thickness = 1,
int lineType = LINE_8,
int shift = 0 )
#include <opencv2/imgproc.hpp>
Python:
cv.rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> img
cv.rectangle(img, rec, color[, thickness[, lineType[, shift]]]) -> img
Draws a simple, thick, or filled up-right rectangle.
The function cv::rectangle draws a rectangle outline or a filled rectangle whose two opposite corners are pt1 and pt2.
Parameters
img— Image.pt1— Vertex of the rectangle.pt2— Vertex of the rectangle opposite to pt1 .color— Rectangle color or brightness (grayscale image).thickness— Thickness of lines that make up the rectangle. Negative values, like FILLED, mean that the function has to draw a filled rectangle.lineType— Type of the line. See LineTypesshift— Number of fractional bits in the point coordinates.
rectangle()#
void cv::rectangle(
InputOutputArray img,
Rect rec,
const Scalar & color,
int thickness = 1,
int lineType = LINE_8,
int shift = 0 )
#include <opencv2/imgproc.hpp>
Python:
cv.rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> img
cv.rectangle(img, rec, color[, thickness[, lineType[, shift]]]) -> img
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
use rec parameter as alternative specification of the drawn rectangle: r.tl() and r.br()-Point(1,1) are opposite corners
Macro Definition Documentation#
CV_RGB#
#define CV_RGB(r, g, b)
#include <opencv2/imgproc.hpp>
Value:
cv::Scalar((b), (g), (r), 0)
OpenCV color channel order is BGR[A]