基于opencv的c++画图程序

最新推荐文章于 2022-10-02 22:53:52 发布
最新推荐文章于 2022-10-02 22:53:52 发布
阅读量1.4k 收藏 12
点赞数
分类专栏： # opencv实战 文章标签： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44088559/article/details/104405452
版权

文章目录

程序特点

  1. 可以根据数据的大小，自动调整坐标轴的刻度
  2. 根据刻度数字的长度自动调整边框的大小以及横坐标的刻度宽度
  3. 支持动态显示
  4. 支持改变颜色
  5. 暂不支持中文显示

重要函数介绍

//--构造函数
/*
*功能：打点画图工作初始化
*参数：window_height：画图区域高度（像素点个数）
*     window_width:画图区域宽度
*     border_size：画图区域边框宽度
*	  backgroud_color：画图区域背景色
*     border_color:边框颜色
*	  axis_color：坐标轴颜色
*	  text_color：坐标刻度数颜色
*返回值：无
*/
CPlot::CPlot(double window_height,double window_width,int border_size,Scalar backgroud_color,Scalar border_color,Scalar axis_color,Scalar text_color)

//--析构函数
/*
*功能：释放内存
*参数：无
*返回值：无
*/
CPlot::~CPlot()

/******************************************************
 * 功能：将传入的坐标点加入到坐标链表里面，并添加对应点的颜色数据到线类型链表里面
 *      然后调用打点程序依次打点
 * 参数：x：x轴坐标数据
 *      y:y轴坐标数据
 *      Cnt:坐标点个数
 *      coler： 打点的颜色
 *      type：点形状：
 *                 l   直线	
 *                 *   星 
 *                 .   点 
 *                 o   圈 
 *                 x   叉 
 *                 +   十字 
 *                 s   方块 
 *      is_need_lined：点与点之间是否需要连线：true or false
 * 
 * 
 ********************************************************/
//范型设计
template<typename T>
void CPlot::plot(T *X, T *Y, size_t Cnt, Scalar color, char type,bool is_need_lined)

/******************************************************
 * 功能：将传入的坐标点加入到坐标链表里面，并添加对应点的颜色数据到线类型链表里面
 *      然后调用打点程序依次打点
 * 参数：x：无X轴数据传入，默认从0开始向坐标轴正方向+1
 *      y:y轴坐标数据
 *      Cnt:坐标点个数
 *      coler： 打点的颜色
 *      type：点形状：
 *                 l   直线	
 *                 *   星 
 *                 .   点 
 *                 o   圈 
 *                 x   叉 
 *                 +   十字 
 *                 s   方块 
 *      is_need_lined：点与点之间是否需要连线：true or false
 * 
 * 
 ********************************************************/
template<class T>
void CPlot::plot(T *Y, size_t Cnt, Scalar color, char type,bool is_need_lined)

注意：下面这个功能暂时不支持，后续完善

/******************************************************
 * 功能：传入一个坐标就打一个点，并且把改点进行存储
 * 参数：x：x轴坐标数据
 *      y:y轴坐标数据
 *      coler： 打点的颜色
 *      type：点形状：
 *                 l   直线	
 *                 *   星 
 *                 .   点 
 *                 o   圈 
 *                 x   叉 
 *                 +   十字 
 *                 s   方块 
 *      is_need_lined：点与点之间是否需要连线：true or false
 * 
 * 
 ********************************************************/
//范型设计
template<typename T>
void CPlot::plot(T X, T Y, Scalar color, char type,bool is_need_lined)

/--画坐标轴
void CPlot::DrawAxis (Mat image)

//添加对线型的支持
//TODO线型未补充完整
//标记		线型
//l          直线	
//*          星 
//.          点 
//o          圈 
//x          叉 
//+          十字 
//s          方块 
void CPlot::DrawData (Mat image)

效果展示，这是一组惯导定位坐标点

在这里插入图片描述

代码里面注释很详细

plot.cpp

#include "plot.h"
#include "csv.h"

int main(int argc,char ** argv)
{
int Cnt = 0;
vector<double> x;
vector<double> y;

CPlot plot(800,800,80,Scalar(0,0,0),Scalar(205,116,24),Scalar(255,255,255),Scalar(255,255,255));
CSV csv;

csv.open_csv();//--打开文件
while(csv.infile.peek()!=EOF){//--判断文件结束//--此处必须用peek进行预判文件是否结尾，使用别的会重复读取最后一行
      //--.csv文件用“,”作为分隔符
    csv.vector_clear();//--清空字符串向量
    csv.read_csv();//--读取一行文件
   x.push_back(strtod(csv.fields[0].c_str(),NULL));//--c_str():将char*转为string。strtod（）：将string转为double
   y.push_back(strtod(csv.fields[1].c_str(),NULL));
   
   ++Cnt;
     }
  csv.infile.close();//--关闭所有打开的文件

        namedWindow("xiaoyu",1);//--创建一个窗口
	plot.x_max = x[0]; //可以设定横纵坐标的最大，最小值
	plot.x_min = x[0];
	plot.y_max = y[0];
	plot.y_min = y[0];
	//plot.axis_color = Scalar(0,255,0);
	//plot.text_color = Scalar(255,0,255);

	plot.plot(&x[0],&y[0], Cnt, Scalar(0, 0, 255),'s'); //可以只传入Y值 X默认从0开始 //--vector转数组 只需要传入首位数据地址就可以
	plot.title("xiaoyuer"); //可以设定标题 只能是英文 中文会乱码 有解决方案，但是很麻烦
	plot.xlabel("this X",Scalar(255,255,0));
	plot.ylabel("this Y",Scalar(255,255,0));
	imshow("xiaoyu", plot.Figure);
	waitKey(0);
    imwrite("1.jpg",plot.Figure);


	plot.clear();//清出前面的存储的数据

return 0;
}

plot.h

/******************************************
 * 版权：小鱼儿飞丫飞
 * 作者：小鱼儿飞丫飞
 * 日期：2020-3-24
 * 描述：基于opencv的C++打点画图程序
 * ***************************************/
#ifndef __PLOT_H__
#define __PLOT_H__

#include <opencv2/opencv.hpp>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <ctime>
#include <unistd.h> 
#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 800
#define data_size 0.30//--坐标点尺寸
#define text_size 0.45//--文字尺寸
using namespace cv;
using namespace std;
//--线类型
struct LineType
{
 char type;  //--点类型
 bool is_need_lined;//--两点之间是否需要连线
 Scalar color;//--点颜色
}; 
//--打点画图类
class CPlot
{
public:
     void DrawAxis (Mat image);//--画坐标轴
     void DrawData (Mat image);//--画点
public:
     int window_height;
     int window_width;
                
      vector<vector<Point2d>>dataset;//--点集合(二维数组)
      vector<LineType>linetypeset;//--线类型集合
  
      Scalar backgroud_color;//--图片背景色
      Scalar axis_color;//--坐标轴颜色
      Scalar text_color;//--标签颜色
      Scalar border_color;//--边框颜色
      Mat Figure;//--图片
     //--画图范围
      double y_max;//--y轴最大值
      double y_min;//--y轴最小值
      double y_scale;//--y轴刻度值，两个刻度之间间隔了几个像素点

      double x_max;//--x轴最大值
      double x_min;//--x轴最小值
      double x_scale;//--x轴刻度值

      int border_size;//--边框宽度，两个刻度之间间隔了几个像素点

public:
      //--打点模板
      template<class T>
      void plot(T *y,size_t Cnt,Scalar color,char type = '*',bool is_need_lined = true);//--一组数据打点
      template<typename T>
      void plot(T* x,T* y,size_t Cnt,Scalar color,char type = '*',bool is_need_lined = true);//--一组数据打点
	  template<typename T>
      void plot(T X, T Y, Scalar color, char type,bool is_need_lined);//--单个数据打点

      void xlabel(string xlabel_name,Scalar label_color);//--x轴添加标签
      void ylabel(string ylabel_name,Scalar label_color);//--y轴添加标签
       
      void clear();//--清空图片数据
      void title(string title_name,Scalar title_color);//--给图片添加标题
public:
      CPlot(double window_height,double window_width,int border_size,Scalar backgroud_color,Scalar border_color,Scalar axis_color,Scalar text_color);//--构造函数
      ~CPlot();//--析构函数 

};

//下面所有的函数采用范型设计，因此将实现部分和声明部分放在一个文件中


//--构造函数
/*
*功能：打点画图工作初始化
*参数：window_height：画图区域高度（像素点个数）
*     window_width:画图区域宽度
*     border_size：画图区域边框宽度
*	  backgroud_color：画图区域背景色
*     border_color:边框颜色
*	  axis_color：坐标轴颜色
*	  text_color：坐标刻度数颜色
*返回值：无
*/
CPlot::CPlot(double window_height,double window_width,int border_size,Scalar backgroud_color,Scalar border_color,Scalar axis_color,Scalar text_color)
{
	this->border_size = border_size; //图外围边界
	this->window_height = window_height;//--窗口大小
	this->window_width = window_width;
    this->backgroud_color = backgroud_color; //背景颜色
	this->border_color = border_color;//--边框颜色
	this->axis_color = axis_color;//坐标轴颜色
	this->text_color = text_color; //文字红色
	this->x_min = 0;
	this->x_max = 0;
	this->y_min = 0;
	this->y_max = 0;

	this->Figure = Mat(this->window_height, //--图片高度
                           this->window_width,//--图片宽度
                           CV_8UC3, //--3通道
                           this->border_color//--整个图片颜色为边框色
                           );
	//--修改打印区域像素颜色					   
	for(int i=this->border_size;i<(this->window_height-this->border_size);i++)
	  {
        for(int j=this->border_size;j<(this->window_width-this->border_size);j++)
		    {
            this->Figure.at<Vec3b>(i,j)[0] = this->backgroud_color[0];
			this->Figure.at<Vec3b>(i,j)[1] = this->backgroud_color[1];
			this->Figure.at<Vec3b>(i,j)[2] = this->backgroud_color[2];
			}
		   
	  }
}
//--析构函数
/*
*功能：释放内存
*参数：无
*返回值：无
*/
CPlot::~CPlot()
{
	this->clear();//--删除容器元素
	this->Figure.release();//--释放图片
}
/*
*功能：释放内存
*参数：无
*返回值：无
*/
void CPlot::clear()//--
{ //--clear():从容器中删除所有元素
	this->dataset.clear();
	this->linetypeset.clear();
}
/******************************************************
 * 功能：将传入的坐标点加入到坐标链表里面，并添加对应点的颜色数据到线类型链表里面
 *      然后调用打点程序依次打点
 * 参数：x：x轴坐标数据
 *      y:y轴坐标数据
 *      Cnt:坐标点个数
 *      coler： 打点的颜色
 *      type：点形状：
 *                 l   直线	
 *                 *   星 
 *                 .   点 
 *                 o   圈 
 *                 x   叉 
 *                 +   十字 
 *                 s   方块 
 *      is_need_lined：点与点之间是否需要连线：true or false
 * 
 * 
 ********************************************************/
//范型设计
template<typename T>
void CPlot::plot(T *X, T *Y, size_t Cnt, Scalar color, char type,bool is_need_lined)
{
	//对数据进行存储
	T tempX, tempY;
	vector<Point2d>data;
	for(int i = 0; i < Cnt;i++)
	{
		tempX = X[i];
		tempY = Y[i];
		data.push_back( Point2d((double)tempX, (double)tempY) );
	}
	this->dataset.push_back(data);
	LineType LT;
	LT.type = type;
	LT.color = color;
	LT.is_need_lined = is_need_lined;
	this->linetypeset.push_back(LT);
	
	this->DrawData(this->Figure); //每次都是重新绘制
}
/******************************************************
 * 功能：将传入的坐标点加入到坐标链表里面，并添加对应点的颜色数据到线类型链表里面
 *      然后调用打点程序依次打点
 * 参数：x：无X轴数据传入，默认从0开始向坐标轴正方向+1
 *      y:y轴坐标数据
 *      Cnt:坐标点个数
 *      coler： 打点的颜色
 *      type：点形状：
 *                 l   直线	
 *                 *   星 
 *                 .   点 
 *                 o   圈 
 *                 x   叉 
 *                 +   十字 
 *                 s   方块 
 *      is_need_lined：点与点之间是否需要连线：true or false
 * 
 * 
 ********************************************************/
template<class T>
void CPlot::plot(T *Y, size_t Cnt, Scalar color, char type,bool is_need_lined)
{
	//对数据进行存储
	T tempX, tempY;
	vector<Point2d>data;
	for(int i = 0; i < Cnt;i++)
	{
		tempX = i;
		tempY = Y[i];
		data.push_back(Point2d((double)tempX, (double)tempY));
	}
	this->dataset.push_back(data);
	LineType LT;
	LT.type = type;
	LT.color = color;
	LT.is_need_lined = is_need_lined;
	this->linetypeset.push_back(LT);
	this->DrawData(this->Figure);
}
/******************************************************
 * 功能：传入一个坐标就打一个点，并且把改点进行存储
 * 参数：x：x轴坐标数据
 *      y:y轴坐标数据
 *      coler： 打点的颜色
 *      type：点形状：
 *                 l   直线	
 *                 *   星 
 *                 .   点 
 *                 o   圈 
 *                 x   叉 
 *                 +   十字 
 *                 s   方块 
 *      is_need_lined：点与点之间是否需要连线：true or false
 * 
 * 
 ********************************************************/
//范型设计
template<typename T>
void CPlot::plot(T X, T Y, Scalar color, char type,bool is_need_lined)
{
	//对数据进行存储
	T tempX, tempY;
	vector<Point2d>data;

		tempX = X;
		tempY = Y;
		data.push_back( Point2d((double)tempX, (double)tempY) );

	this->dataset.push_back(data);
	LineType LT;
	LT.type = type;
	LT.color = color;
	LT.is_need_lined = is_need_lined;
	this->linetypeset.push_back(LT);
	
	this->DrawData(this->Figure); //每次都是重新绘制
}
/*
*功能：显示图片标题
*参数：title_name：标题名字
*     title_color：标题颜色
*返回值：无
*/
void CPlot::title(string title_name,Scalar title_color = Scalar(0,0,0))
{
	Mat image = this->Figure;
	int baseline = 0;//--文字最底部y坐标,
	Size textSize = getTextSize(title_name,FONT_HERSHEY_COMPLEX,text_size,1,&baseline);//--获取文字的长和宽像素值
	int x = (this->window_width - 2 * this->border_size ) / 2 + this->border_size - textSize.width/2.0; 
	int y = this->border_size / 2;
        putText (image,
                 title_name.c_str(),
                 Point( x, y),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 text_size,//--字体缩放因子
		 title_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);		

}
/*
*功能：显示X轴标签
*参数：xlabel_name：标签名字
*     label_color：标签颜色
*返回值：无
*/
void CPlot::xlabel(string xlabel_name, Scalar label_color = Scalar(0,0,0))
{
	//--允许xy轴穿过0点
	double y_ref = this->y_min;
	if ( (this->y_max > 0 ) && ( this->y_min <= 0 ) )
	{
		y_ref = 0;
	}//--round()四舍五入函数

	int baseline = 0;//--文字最底部y坐标,
	Size textSize = getTextSize(xlabel_name,FONT_HERSHEY_COMPLEX,text_size,1,&baseline);//--获取文字的长和宽像素值

	int x_axis_pos = this->window_height - this->border_size - round((y_ref - this->y_min) * this->y_scale);
	int x = this->window_width - this->border_size - textSize.width;
	int y = x_axis_pos + 25;
	 putText (this->Figure,
                 xlabel_name.c_str(),
                 Point( x, y),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 text_size,//--字体缩放因子
		 label_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);		
}
/*
*功能：显示y轴标签
*参数：ylabel_name：标签名字
*     label_color：标签颜色
*返回值：无
*/
void CPlot::ylabel(string ylabel_name, Scalar label_color = Scalar(0,0,0))
{

	int x = this->border_size;
	int y = this->border_size-5;
        putText (this->Figure,
                 ylabel_name.c_str(),
                 Point( x, y),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 text_size,//--字体缩放因子
		 label_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);		
}
//--画坐标轴
void CPlot::DrawAxis (Mat image)
{

	//Scalar axis_color = this->axis_color;
	
	int bs = this->border_size;		
	int h = this->window_height;
	int w = this->window_width;

	// 坐标系尺寸
	int gh = h - bs * 2;
	int gw = w - bs * 2;

	// 画水平和竖直轴
	// 如何可能的画，轴可以穿过0点
	double y_ref = this->y_min;//--保存Y轴0点或者最小点（如果Y轴有负半轴的话）
	if ( (this->y_max > 0 ) && ( this->y_min <= 0 ) )//--如果y轴数据越过0点，
	{
		y_ref = 0;//---则y轴参考点为0
	}
       //--计算X轴水平位置，也是y轴0点位置纵坐标
	int x_axis_pos = h - bs - round((y_ref - this->y_min) * this->y_scale);
	//画X 轴
	line(image, 
             Point(bs,x_axis_pos), 		          
             Point(w - bs, x_axis_pos),
            this->axis_color);
	//画Y 轴
	line(image, 
             Point(bs, h - bs), 
             Point(bs, h - bs - gh),
             this->axis_color);


	int chw = 15, chh = 10; 
	char text[16];

	// 显示y轴最大值
	if ( (this->y_max - y_ref) > 0.05 * (this->y_max - this->y_min) )
	{
		snprintf(text, sizeof(text)-1, "%.3f", this->y_max);

	    int baseline = 0;//--文字最底部y坐标,
	    Size textSize = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline);//--获取文字的长和宽像素值

        putText (image,
                 text,
                 Point(bs-textSize.width, bs-textSize.height),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 data_size,//--字体缩放因子
		 this->text_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);		
	}
	// y min
	if ( (y_ref - this->y_min) > 0.05 * (this->y_max - this->y_min) )
	{
		snprintf(text, sizeof(text)-1, "%.3f", this->y_min);
		int baseline = 0;//--文字最底部y坐标,
	    Size textSize = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline);//--获取文字的长和宽像素值


        putText (image,
                 text,
                 Point(bs-textSize.width, h - bs +textSize.height+5),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 data_size,//--字体缩放因子
		 this->text_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);

	}

	//画Y轴的刻度 每隔 scale_pixes 个像素
	//Y正半轴
	double y_scale_pixes = chh * 4;
	for (int i = 0; i < floor( (x_axis_pos - bs) / y_scale_pixes ) + 1; i++)//--ceil 向上取整 floor 向下取整
	{
		snprintf(text, sizeof(text)-1, "%.3f", this->y_min+i * y_scale_pixes / this->y_scale );

		int baseline = 0;//--文字最底部y坐标,
	    Size textSize = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline);//--获取文字的长和宽像素值

        putText (image,
                 text,
                 Point(bs-textSize.width, x_axis_pos - i * y_scale_pixes+textSize.height/2),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 data_size,//--字体缩放因子
		 this->axis_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);
      line(image, Point(bs, x_axis_pos - i * y_scale_pixes), Point(bs+10, x_axis_pos - i * y_scale_pixes), this->axis_color, 1, LINE_AA);//--画刻度线
	}
	//Y负半轴
	for (int i = 1; i < floor(( h - x_axis_pos - bs ) / y_scale_pixes ) + 1; i++)
	{
		snprintf(text, sizeof(text)-1, "%.3f", -i * y_scale_pixes / this->y_scale );

		int baseline = 0;//--文字最底部y坐标,
	    Size textSize = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline);//--获取文字的长和宽像素值

        putText (image,
                 text,
                 Point(bs-textSize.width, x_axis_pos + i * y_scale_pixes + textSize.height/2),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 data_size,//--字体缩放因子
		 this->axis_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);
      line(image, Point(bs, x_axis_pos + i * y_scale_pixes), Point(bs+10, x_axis_pos + i * y_scale_pixes), this->axis_color, 1, LINE_AA);//--画刻度线

	}

	// x_max
	snprintf(text, sizeof(text)-1, "%.3f", this->x_max );

	int baseline_xmax = 0;//--文字最底部y坐标,
	Size textSize_xmax = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline_xmax);//--获取文字的长和宽像素值

    putText (image,
            text,
            Point(w - bs - textSize_xmax.width/2, x_axis_pos-10),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 data_size,//--字体缩放因子
		 this->text_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);

	// x min
	snprintf(text, sizeof(text)-1, "%.3f", this->x_min );

	int baseline_xmin = 0;//--文字最底部y坐标,
	Size textSize_xmin = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline_xmin);//--获取文字的长和宽像素值

        putText (image,
                 text,
                 Point(bs+5, x_axis_pos-10),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 data_size,//--字体缩放因子
		 this->text_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);

	//画X轴的刻度 每隔 scale_pixes 个像素
	//--根据X轴最大的数的长度来自动决定刻度宽度
	 snprintf(text, sizeof(text)-1, "%.3f", this->x_max);
	 int baseline = 0;//--文字最底部y坐标,
	 Size textSize = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline);//--获取文字的长和宽像素值
	 double x_scale_pixes = textSize.width+10;

	for (int i = 1; i < floor( gw / x_scale_pixes ) + 1; i++)
	{
		snprintf(text, sizeof(text)-1, "%.3f", this->x_min + i * x_scale_pixes / this->x_scale );

	    int baseline = 0;//--文字最底部y坐标,
	    Size textSize = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline);//--获取文字的长和宽像素值
        
        putText (image,
                 text,
                 Point(bs + i * x_scale_pixes - textSize.width/2, x_axis_pos + textSize.height+5),
		 FONT_HERSHEY_COMPLEX,//--字体类型
		 data_size,//--字体缩放因子
		 this->axis_color,//--颜色
		 1,//--线条粗细
		 LINE_8//--线条类型
	);
 line(image, Point(bs + i * x_scale_pixes ,x_axis_pos), Point(bs + i * x_scale_pixes ,x_axis_pos-10), this->axis_color, 1, LINE_AA);//--画刻度线

	}

}
//添加对线型的支持
//TODO线型未补充完整
//标记		线型
//l          直线	
//*          星 
//.          点 
//o          圈 
//x          叉 
//+          十字 
//s          方块 
void CPlot::DrawData (Mat image)
{
	
	//this->x_min = this->x_max = this->dataset[0][0].x;
	//this->y_min = this->y_max = this->dataset[0][0].y;
	

//--找出最大值和最小值
	for(size_t i = 0; i < this->dataset.size(); i++)//--遍历所有行
	{
		for(size_t j = 0; j < this->dataset[i].size(); j++)//--遍历每行所有列
		{
			if(this->dataset[i][j].x < this->x_min)
			{
				this->x_min = this->dataset[i][j].x;
			}else if(this->dataset[i][j].x > this->x_max)
			{
				this->x_max = this->dataset[i][j].x;
			}
		
			if(this->dataset[i][j].y < this->y_min)
			{
				this->y_min = this->dataset[i][j].y;
			}else if(this->dataset[i][j].y > this->y_max)
			{
				this->y_max = this->dataset[i][j].y;
			}
		}
	}

//--根据最大值自动调整边框的宽度

char text[16];
int x_max_temp,y_max_temp;
snprintf(text, sizeof(text)-1, "%.3f", this->x_max);
int baseline = 0;//--文字最底部y坐标,
Size textSize = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline);//--获取文字的长和宽像素值
 x_max_temp = textSize.width/2;//--X轴刻度只有一般长度在边框里面
snprintf(text, sizeof(text)-1, "%.3f", this->y_max);
baseline = 0;//--文字最底部y坐标,
textSize = getTextSize(text,FONT_HERSHEY_COMPLEX,data_size,1,&baseline);//--获取文字的长和宽像素值
 y_max_temp = textSize.width;
if( x_max_temp>=y_max_temp)
   this->border_size = x_max_temp+10;
else
   this->border_size = y_max_temp+10;
	int bs = this->border_size;

//--计算x轴和y轴最大值和最小值范围 并计算出刻度大小，两点之间的像素个数
	double x_range = this->x_max - this->x_min;
	double y_range = this->y_max - this->y_min;
	this->x_scale = (image.cols - bs*2)/ x_range;//--cols图片宽度
	this->y_scale = (image.rows- bs*2)/ y_range;//--rows 图片高度
	
	
	//清屏,设置屏幕颜色为灰色
	//memset(image.data, 105, sizeof(unsigned char)*Figure.step*Figure.rows);
		for(int i=0;i<this->window_height;i++)
	  {
        for(int j=0;j<this->window_width;j++)
		    {
            this->Figure.at<Vec3b>(i,j)[0] = this->border_color[0];
			this->Figure.at<Vec3b>(i,j)[1] = this->border_color[1];
			this->Figure.at<Vec3b>(i,j)[2] = this->border_color[2];
			}
		   
	  }
	//--修改打印区域像素颜色					   
	for(int i=this->border_size;i<(this->window_height-this->border_size);i++)
	  {
        for(int j=this->border_size;j<(this->window_width-this->border_size);j++)
		    {
            this->Figure.at<Vec3b>(i,j)[0] = this->backgroud_color[0];
			this->Figure.at<Vec3b>(i,j)[1] = this->backgroud_color[1];
			this->Figure.at<Vec3b>(i,j)[2] = this->backgroud_color[2];
			}
		   
	  }
	this->DrawAxis(image);
	
	//printf("x_range: %f y_range: %f\n", x_range, y_range);
	//绘制点
	double tempX, tempY;
	Point prev_point, current_point;
	int radius = 3;
	int slope_radius = (int)( radius * 1.414 / 2 + 0.5);
	for(size_t i = 0; i < this->dataset.size(); i++)//-遍历每一行数据
	{
		for(size_t j = 0; j < this->dataset[i].size(); j++)//--遍历当前行所有列数据
		{
			tempX = (int)((this->dataset[i][j].x - this->x_min)*this->x_scale);//--计算出改点对应图片上坐标点
			tempY = (int)((this->dataset[i][j].y - this->y_min)*this->y_scale);
			current_point = Point(bs + tempX, image.rows - (tempY + bs));//--考虑边框尺寸，获取实际的坐标点
			
			if(this->linetypeset[i].type == 'l')
			{
				// draw a line between two points
				if (j >= 1)
				{
					line(image, prev_point, current_point, linetypeset[i].color, 1, LINE_AA);
				}		
				prev_point = current_point;
			}else if(this->linetypeset[i].type == '.')
			{
				circle(image, current_point, 1, linetypeset[i].color, -1, 8);
				if (linetypeset[i].is_need_lined == true)
				{
					if (j >= 1)
					{
						line(image, prev_point, current_point, linetypeset[i].color, 1, LINE_AA);
					}		
					prev_point = current_point;
				}
			}else if(this->linetypeset[i].type == '*')
			{
				//画*
				line(image, Point(current_point.x - slope_radius, current_point.y - slope_radius), 
			    Point(current_point.x + slope_radius, current_point.y + slope_radius), linetypeset[i].color, 1, 8);
					   
				line(image, Point(current_point.x - slope_radius, current_point.y + slope_radius), 
			    Point(current_point.x + slope_radius, current_point.y - slope_radius), linetypeset[i].color, 1, 8);

				line(image, Point(current_point.x - radius, current_point.y), 
				Point(current_point.x + radius, current_point.y), linetypeset[i].color, 1, 8);
					   
				line(image,Point(current_point.x, current_point.y - radius), 
			    Point(current_point.x, current_point.y + radius), linetypeset[i].color, 1, 8);	 
				if (linetypeset[i].is_need_lined == true)
				{
					if (j >= 1)
					{
						line(image, prev_point, current_point, linetypeset[i].color, 1, LINE_AA);
					}		
					prev_point = current_point;
				}
				
			}else if(this->linetypeset[i].type == 'o')
			{
				circle(image, current_point, radius, this->text_color, 1, LINE_AA);
				if (linetypeset[i].is_need_lined == true)
				{
					if (j >= 1)
					{
						line(image, prev_point, current_point, linetypeset[i].color, 1, LINE_AA);
					}		
					prev_point = current_point;
				}
			}else if(this->linetypeset[i].type == 'x')
			{
				line(image, Point(current_point.x - slope_radius, current_point.y - slope_radius), 
			    Point(current_point.x + slope_radius, current_point.y + slope_radius), linetypeset[i].color, 1, 8);
					   
				line(image, Point(current_point.x - slope_radius, current_point.y + slope_radius), 
			    Point(current_point.x + slope_radius, current_point.y - slope_radius), linetypeset[i].color, 1, 8);
				if (linetypeset[i].is_need_lined == true)
				{
					if (j >= 1)
					{
						line(image, prev_point, current_point, linetypeset[i].color, 1, LINE_AA);
					}		
					prev_point = current_point;
				}
			}else if(this->linetypeset[i].type == '+')
			{
				line(image, Point(current_point.x - radius, current_point.y), 
				Point(current_point.x + radius, current_point.y), linetypeset[i].color, 1, 8);
					   
				line(image, Point(current_point.x, current_point.y - radius), 
			    Point(current_point.x, current_point.y + radius), linetypeset[i].color, 1, 8);
				if (linetypeset[i].is_need_lined == true)
				{
					if (j >= 1)
					{
						line(image, prev_point, current_point, linetypeset[i].color, 1, LINE_AA);
					}		
					prev_point = current_point;
				}
			}else if(this->linetypeset[i].type == 's')
			{
				rectangle(image, Point(current_point.x - slope_radius, current_point.y - slope_radius), 
			    Point(current_point.x + slope_radius, current_point.y + slope_radius), linetypeset[i].color, 1, 8);
				if (linetypeset[i].is_need_lined == true)
				{
					if (j >= 1)
					{
						line(image, prev_point, current_point, linetypeset[i].color, 1, LINE_AA);
					}		
					prev_point = current_point;
				}
			}
			//--如果想动态显示，可以吧下面两句代码打开
             //imshow("xiaoyu", this->Figure);
            // waitKey(1);
		}
	}	
}

#endif

流程图

在这里插入图片描述

小鱼儿飞呀飞
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
openCV给图片加坐标轴
qq_41361834的博客
05-24 1万+
     为了给一张图片加坐标轴，调用openCV，用了两天的时间写了个简化版的版本，直到我看到了这个：点击打开链接 以及这个：http://answers.opencv.org/question/73233/how-do-you-plot-graphs-in-opencv-projects/好吧，两天写的其实没什么用。     为了给一张伪彩图上面加坐标轴，我首先参考了：https://blog...
opencv 绘制坐标曲线_【OpenCV学习】绘制贝赛尔曲线
weixin_39689394的博客
01-13 421
// TrainingTools.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include #include #include #include #include #include using namespace std;const int WW_MAX_MARK_COUNT = 40; //最大40个控制点int mark_count =4;int co...
opencv绘制点与坐标系
08-10
将一组点用opencv绘制并连线，绘制相应的坐标系与刻度
opencv C++实现极坐标
weixin_41463944的博客
09-14 682
#include <iostream> #include<opencv2/core/core.hpp> #include<opencv2/highgui/highgui.hpp> #include<opencv2/imgproc/imgproc.hpp> #include<opencv.hpp> #include <iostream...
OpenCV坐标体系的初步认识
热门推荐
liulina603的专栏
07-19 2万+
实验基础 　　本次实验通过一个简短的例子，主要来说明下面4个问题： 　　1. 坐标体系中的零点坐标为图片的左上角，X轴为图像矩形的上面那条水平线；Y轴为图像矩形左边的那条垂直线。该坐标体系在诸如结构体Mat,Rect,Point中都是适用的。（虽然网上有学着说OpenCV中有些数据结构的坐标原点是在图片的左下角，但是我暂时还没碰到过）。 　　2. 在使用image.at(x1, x2)来访问
opencv绘制点及XY坐标
gwpscut的博客
01-09 4520
直接给出代码 #include<opencv2\imgcodecs.hpp> #include<opencv2\core.hpp> #include<opencv2\highgui.hpp> #include<opencv2\imgproc.hpp> #include<vector> #include<time.h> us...
基于opencv 的画图显示类
03-09
首先，"基于opencv的画图显示类"通常是指一个自定义的C++类，该类扩展了OpenCV的功能，以便在MFC应用程序中创建和管理图像显示窗口。MFC是微软提供的一套C++类库，用于构建Windows桌面应用程序。它简化了Windows API...
C++Opencv手指画图.rar
06-12
【标题】"C++ OpenCV 手指画图" 是一个使用OpenCV库在C++环境中实现的手势识别与绘图项目。这个项目基于OpenCV 2.4.9版本，它展示了如何利用计算机视觉技术来捕捉并识别手指在摄像头前的动作，进而用这些手势在屏幕...
基于Opencv的鼠标画图
05-15
在本项目中，我们探索的是一个基于OpenCV库的C++程序，该程序允许用户使用鼠标进行绘画，并具有颜色选择和形状绘制的功能。OpenCV（Open Source Computer Vision Library）是一个强大的计算机视觉库，广泛用于图像...
aa.zip_画图程序
09-24
标题中的"aa.zip_画图程序"表明这是一个包含C++实现的画图程序的压缩文件。这个程序可能是一个用户友好的图形界面应用，允许用户绘制各种形状、线条和图案，或者进行图像处理操作。在C++中实现这样的功能通常会涉及...
vc++ 绘制坐标系
04-13
vc 绘制坐标系在用VC绘图的时候，需要自定义坐标系，即改变坐标的映射模式，在网上查找了很多相关的知识，也还是很糊涂，天极网上有一篇文章(有位Hier也转载了这篇文章，或者也许他就是作者)，图文并貌，稍微详细一些，但也只是侧重讲解了固定比例映射模式，而可变比例模式只是一带而过了。后来自己写了程序进行测试，终于明白了可变比例映射模式，与大家分享。
Qt+OpenCV+C++
10-29
在本项目中，我们结合了Qt、OpenCV和C++三种强大的工具，旨在实现一系列计算机视觉功能，包括目标框选、目标识别以及二维路径的图形化显示。Qt是一个跨平台的开发框架，常用于创建用户界面，而OpenCV则是一个开源的...
【OpenCV 4开发详解】图像极坐标变换
小白学视觉
01-14 2045
本文首发于“小白学视觉”微信公众号，欢迎关注公众号 本文作者为小白，版权归人民邮电出版社发行所有，禁止转载，侵权必究！ 经过几个月的努力，小白终于完成了市面上第一本OpenCV 4入门书籍《OpenCV 4开发详解》。为了更让小伙伴更早的了解最新版的OpenCV 4，小白与出版社沟通，提前在公众号上连载部分内容，请持续关注小白。 极坐标变换就是将图像在直角坐标系与极坐标系中互相变换，形式如...
Opencv给Mat加坐标轴
weixin_42156097的博客
03-10 2268
需求描述 最近在编写一个工具，其中有一个子功能，需要给cv::Mat格式的图片加上坐标轴 有一个格式为cv::Mat image的图片，这个image有可能是图片，也有可能是一些二维的点画在了image上。假设他们有坐标的话，怎么画出一个带坐标轴的图 opencv官网其实提供了一个添加坐标轴的类，Plot2d，我看了一下效果不太满意，以后有机会再分析一下。 代码 更倾向于自己写一个好用的。好用的，...
ch01 OpenCV图像坐标系
风吴痕的博客
10-19 593
参考： 1、http://docs.opencv.org/3.3.0/  官方文档api 2、http://docs.opencv.org/3.3.0/d6/d00/tutorial_py_root.html 官方英文教程 3、https://github.com/makelove/OpenCV-Python-Tutorial 4、https://opencv-python-tut
基于OpenCV的在图片上画刻度尺坐标、分划版、侧微尺、十字双边带刻度
hgaohr1021的博客
04-09 1745
1、开发环境及语言 win10 VS2019的C++语言，基于OpenCV 2、解决问题 在一张图片上画刻度尺坐标、分划版、侧微尺、十字双边带刻度 3、效果展示 3.1 、原图 3.2 效果展示 3.3 效果展示 下载地址： https://download.csdn.net/download/hgaohr1021/16590936 ...
＜LearnOpenCV(7) C++＞矩形、圆形等基本图像绘制
m0_56838271的博客
10-02 354
简单记录OpenCV库提供的圆形、椭圆、线段等基础图象绘制API，顺便记录下TXT绘制。
使用opencv 绘制数据图
zhyh1435589631的专栏
11-20 1万+
1. 前言去北京的高铁上， 老板估计是看我们看视频不太爽， 于是让我们写一个用opencv处理数据并绘制相应图形的小程序， 使用matlab非常简单， 可以用opencv 真就呵呵了。百度之后，找到一个现成的版本， 效果不错， 不过有些小bug 参考： http://blog.csdn.net/xiaoxiaodongshige/article/details/481348952. 显示效果3.
在Ubuntu环境下对opencv的使用
wlzany的博客
10-29 647
在Ubuntu环境下对opencv的使用一、在Ubuntu安装opencv-3.4.11、在官网下载Sources版本opencv-3.4.12、将下载文件复制到home目录下，进行解压配置三级目录 一、在Ubuntu安装opencv-3.4.1 下载我是在Windows系统上下载的，然后再拷贝到Linux系统中 1、在官网下载Sources版本opencv-3.4.1 官网地址：下载点击 下载完成后打开下载的文件夹，记住该路径 2、将下载文件复制到home目录下，进行解压配置 将刚刚下载好的压缩包拷贝到L
基于OpenCV红色圆形检测c++程序
最新发布
06-11
下面是基于OpenCV的红色圆形检测C++程序： ```cpp #include <opencv2/opencv.hpp> using namespace cv; int main() { // 读取图像 Mat img = imread("image.jpg", IMREAD_COLOR); // 将图像转成HSV颜色空间 Mat hsv; cvtColor(img, hsv, COLOR_BGR2HSV); // 设定红色的HSV范围 Scalar lower_red = Scalar(0, 70, 50); Scalar upper_red = Scalar(10, 255, 255); Scalar lower_red2 = Scalar(170, 70, 50); Scalar upper_red2 = Scalar(180, 255, 255); // 提取红色区域 Mat mask1, mask2, mask; inRange(hsv, lower_red, upper_red, mask1); inRange(hsv, lower_red2, upper_red2, mask2); bitwise_or(mask1, mask2, mask); // 霍夫圆变换检测圆形 std::vector<Vec3f> circles; HoughCircles(mask, circles, HOUGH_GRADIENT, 1, mask.rows / 8, 200, 100, 0, 0); // 绘制圆形 for (size_t i = 0; i < circles.size(); i++) { Point center(cvRound(circles[i][0]), cvRound(circles[i][1])); int radius = cvRound(circles[i][2]); circle(img, center, radius, Scalar(0, 0, 255), 2, LINE_AA); } // 显示结果 imshow("result", img); waitKey(0); return 0; } ``` 这个程序的大致流程如下： 1. 读入图像，将图像转换为HSV颜色空间； 2. 设定红色的HSV范围，提取红色区域； 3. 使用霍夫圆变换检测圆形； 4. 绘制检测到的圆形； 5. 显示结果。 需要注意的是，这个程序默认红色为H值在0-10和170-180之间的颜色，S和V值在一定范围内。如果需要检测其他颜色，需要根据实际情况进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值