一个基于Qt的用cvAdaptiveThreshold二值化图像的程序

最新推荐文章于 2024-04-19 00:19:11 发布
最新推荐文章于 2024-04-19 00:19:11 发布
阅读量3.3k 收藏 2
点赞数 1
文章标签： qt signal image processing float layout
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C_arm/article/details/6926962
版权 
//AdaptiveThreshold.h
#ifndef ADAPTIVETHRESHOLD_H	 
#define ADAPTIVETHRESHOLD_H

#include "cv.h"
#include "highgui.h"

#include <QtCore/QObject>
#include <QtGui/QDialog>
#include <QtGui/QWidget>
#include <QtGui/QHBoxLayout>
#include <QtGui/QVBoxLayout>
#include <QtGui/QSlider>
#include <QtGui/QLabel>
#include <QtGui/QImage>
#include <QtGui/QPixmap>
#include <QtGui/QGroupBox>
#include <QtGui/QRadioButton>
#include <QtGui/QLineEdit>
#include <QtGui/QPushButton>
#include <QtGui/QFileDialog>
#include <QtGui/QComboBox>

class AdaptiveThreshold:public QDialog{
      Q_OBJECT
      public:
		  AdaptiveThreshold(IplImage* imgRGB,QWidget* parent=0,Qt::WindowFlags f=0);
		  ~AdaptiveThreshold();
		  static void Ipl2QImageRGB32(IplImage* iplImage,QImage* qImage);
	  private Q_SLOTS:
		  void setBlockSizeValue();
		  void setParam1Value();
		  void meanThresholding();
		  void gaussianThresholding();
		  void doThresholding();
		  void saveThresholdedImage();
		  void exitDialog();
      private:
		  //data
		  IplImage* m_imgRGB;
		  IplImage* m_imgGray;
		  IplImage* m_imgTresholding;
		  bool m_meanThresholdingFlag;
		  bool m_gaussianThresholdingFlag;
		  /*
		   ** gui
		   */
		  //main horizontal layout
          QHBoxLayout* m_mainLayout;
		  //left vertical layout
          QVBoxLayout* m_leftLayout;
		  //blockSizeSlider
		  QHBoxLayout* m_blockSizeSliderLayout;
		  QLabel* m_blockSizeSliderName;
          QSlider* m_blockSizeSlider;
		  //param1ValueSlider
		  QHBoxLayout* m_param1ValueSliderLayout;
		  QLabel* m_param1ValueSliderName;
		  QSlider* m_param1ValueSlider;
		  //label for image
		  QLabel* m_imageLabel;
		  //right vertical layout
		  QVBoxLayout* m_rightLayout;
		  //thresholding type
          QGroupBox* m_thresholdingType;
		  QVBoxLayout* m_thresholdingTypeLayout;
          QRadioButton* m_meanTypeButton;
		  QRadioButton* m_gaussianTypeButton;
		  //parameter values
		  //block size
		  QHBoxLayout* m_blockSizeValueLayout;
		  QLabel* m_blockSizeValueName;
		  QLineEdit* m_blockSizeValue;
          //param1
		  QHBoxLayout* m_param1ValueLayout;
		  QLabel* m_param1ValueName;
		  QLineEdit* m_param1Value;

		  //morphological processing
		  QComboBox* m_morphologicalType;
		  QSlider* m_morphologicalSlider;

		  //save the thresholded image
		  QPushButton* m_saveThresholdedImageButton;

		  //exit button
		  QPushButton* m_exitButton;
};

#endif


//AdaptiveThreshold.cpp
#include "AdaptiveThreshold.h"

AdaptiveThreshold::AdaptiveThreshold(IplImage *imgRGB, QWidget *parent, Qt::WindowFlags f):QDialog(parent,f){
	m_imgRGB=cvCreateImage(cvSize(imgRGB->width,imgRGB->height),imgRGB->depth,imgRGB->nChannels);
	cvCopy(imgRGB,m_imgRGB);
	m_imgGray=cvCreateImage(cvSize(imgRGB->width,imgRGB->height),imgRGB->depth,1);
	cvCvtColor(m_imgRGB,m_imgGray,CV_RGB2GRAY);
	cvSmooth(m_imgGray,m_imgGray,CV_GAUSSIAN,3,3);
	m_imgTresholding=cvCreateImage(cvSize(m_imgGray->width,m_imgGray->height),m_imgGray->depth,m_imgGray->nChannels);
    m_meanThresholdingFlag=false;
	m_gaussianThresholdingFlag=false;
	//gui
	//main horizontal layout
	m_mainLayout=new QHBoxLayout();
    //left layout
	m_leftLayout=new QVBoxLayout();
	//blockSizeSlider
    m_blockSizeSliderLayout=new QHBoxLayout();
    m_blockSizeSliderName=new QLabel(tr("Block Size"));
	m_blockSizeSlider=new QSlider(Qt::Horizontal);
	m_blockSizeSlider->setMinimum(0);
	m_blockSizeSlider->setMaximum(20);
	m_blockSizeSlider->setSingleStep(1);
	m_blockSizeSlider->setPageStep(1);
	m_blockSizeSlider->setValue(0);
	m_blockSizeSlider->setEnabled(false);
	QObject::connect(m_blockSizeSlider,SIGNAL(valueChanged(int)),this,SLOT(setBlockSizeValue()));
    QObject::connect(m_blockSizeSlider,SIGNAL(valueChanged(int)),this,SLOT(doThresholding()));
	m_blockSizeSliderName->setBuddy(m_blockSizeSlider);
	m_blockSizeSliderLayout->addWidget(m_blockSizeSliderName);
	m_blockSizeSliderLayout->addWidget(m_blockSizeSlider);
	m_leftLayout->addLayout(m_blockSizeSliderLayout);
    //param1ValueSlider
    m_param1ValueSliderLayout=new QHBoxLayout();
    m_param1ValueSliderName=new QLabel(tr("Param1 Value"));
    m_param1ValueSlider=new QSlider(Qt::Horizontal);
	m_param1ValueSlider->setMaximum(1000);
	m_param1ValueSlider->setMinimum(-1000);
	m_param1ValueSlider->setSingleStep(1);
	m_param1ValueSlider->setValue(0);
	m_param1ValueSlider->setPageStep(1);
	m_param1ValueSlider->setEnabled(false);
	QObject::connect(m_param1ValueSlider,SIGNAL(valueChanged(int)),this,SLOT(setParam1Value()));
	QObject::connect(m_param1ValueSlider,SIGNAL(valueChanged(int)),this,SLOT(doThresholding()));
	m_param1ValueSliderName->setBuddy(m_param1ValueSlider);
	m_param1ValueSliderLayout->addWidget(m_param1ValueSliderName);
	m_param1ValueSliderLayout->addWidget(m_param1ValueSlider);
    m_leftLayout->addLayout(m_param1ValueSliderLayout);
	//label for image
	m_imageLabel=new QLabel();
	QImage* qImage=new QImage(m_imgRGB->width,m_imgRGB->height,QImage::Format_RGB32);
	Ipl2QImageRGB32(m_imgRGB,qImage);
	QPixmap* pixmapImage=new QPixmap();
	m_imageLabel->setPixmap(pixmapImage->fromImage(*qImage));
	m_leftLayout->addWidget(m_imageLabel);
	//right layout
	m_rightLayout=new QVBoxLayout();
	m_thresholdingType=new QGroupBox(tr("types of thresholding"));
	m_thresholdingTypeLayout=new QVBoxLayout();
	m_meanTypeButton=new QRadioButton(tr("mean"),m_thresholdingType);
	m_thresholdingTypeLayout->addWidget(m_meanTypeButton);
	QObject::connect(m_meanTypeButton,SIGNAL(clicked()),this,SLOT(meanThresholding()));

	m_gaussianTypeButton=new QRadioButton(tr("gaussian"),m_thresholdingType);
	m_thresholdingTypeLayout->addWidget(m_gaussianTypeButton);
	QObject::connect(m_gaussianTypeButton,SIGNAL(clicked()),this,SLOT(gaussianThresholding()));

	m_thresholdingType->setLayout(m_thresholdingTypeLayout);

	m_rightLayout->addWidget(m_thresholdingType);

	//parameter values
    //block size
    m_blockSizeValueLayout=new QHBoxLayout();
    m_blockSizeValueName=new QLabel(tr("Block Size"));
    m_blockSizeValue=new QLineEdit();
	m_blockSizeValueName->setBuddy(m_blockSizeValue);
	m_blockSizeValue->setText(QString::number((double)(m_blockSizeSlider->value()*2+3)));
	m_blockSizeValueLayout->addWidget(m_blockSizeValueName);
	m_blockSizeValueLayout->addWidget(m_blockSizeValue);

	m_rightLayout->addLayout(m_blockSizeValueLayout);

    //param1
    m_param1ValueLayout= new QHBoxLayout();
    m_param1ValueName=new QLabel("Param1 value");
    m_param1Value= new QLineEdit();
	m_param1ValueName->setBuddy(m_param1Value);
	m_param1Value->setText(QString::number((double)m_param1ValueSlider->value()));

	m_param1ValueLayout->addWidget(m_param1ValueName);
	m_param1ValueLayout->addWidget(m_param1Value);

	m_rightLayout->addLayout(m_param1ValueLayout);
    //morphological processing
	m_morphologicalType=new QComboBox();
	m_morphologicalType->addItem(QString("Open"));
	m_morphologicalType->addItem(QString("Close"));
	m_rightLayout->addWidget(m_morphologicalType);

	m_morphologicalSlider=new QSlider(Qt::Horizontal);
	m_morphologicalSlider->setMinimum(0);
	m_morphologicalSlider->setMaximum(7);
	m_morphologicalSlider->setSingleStep(1);
	m_morphologicalSlider->setPageStep(1);
	m_morphologicalSlider->setValue(0);
	m_morphologicalSlider->setEnabled(false);
	m_rightLayout->addWidget(m_morphologicalSlider);
	QObject::connect(m_morphologicalSlider,SIGNAL(valueChanged(int)),this,SLOT(doThresholding()));


	//save the thresholded image
	m_saveThresholdedImageButton=new QPushButton(tr("&Save Thresholded Image"));
	m_rightLayout->addWidget(m_saveThresholdedImageButton);
	QObject::connect(m_saveThresholdedImageButton,SIGNAL(clicked()),this,SLOT(saveThresholdedImage()));

	//exit button
	m_exitButton=new QPushButton(tr("&Exit"));
	m_rightLayout->addWidget(m_exitButton);
	QObject::connect(m_exitButton,SIGNAL(clicked()),this,SLOT(exitDialog()));

	m_mainLayout->addLayout(m_leftLayout);
    m_mainLayout->addLayout(m_rightLayout);
	this->setLayout(m_mainLayout);
}

AdaptiveThreshold::~AdaptiveThreshold(){
    cvReleaseImage(&m_imgRGB);
	cvReleaseImage(&m_imgGray);
	cvReleaseImage(&m_imgTresholding);
}

void AdaptiveThreshold::setBlockSizeValue(){
	 m_blockSizeValue->setText(QString::number((double)(m_blockSizeSlider->value()*2+3)));
} 

void AdaptiveThreshold::setParam1Value(){
	 m_param1Value->setText(QString::number(((double)m_param1ValueSlider->value())/10.0));
}

void AdaptiveThreshold::meanThresholding(){
	 if(!m_blockSizeSlider->isEnabled()){
	     m_blockSizeSlider->setEnabled(true);
	 }
	 if(!m_param1ValueSlider->isEnabled()){
		 m_param1ValueSlider->setEnabled(true);
	 }
	 if(!m_morphologicalSlider->isEnabled()){
		 m_morphologicalSlider->setEnabled(true);
	 }
	 m_meanThresholdingFlag=true;
	 m_gaussianThresholdingFlag=false;
	 doThresholding();
}

void AdaptiveThreshold::gaussianThresholding(){
     if(!m_blockSizeSlider->isEnabled()){
	     m_blockSizeSlider->setEnabled(true);
	 }
	 if(!m_param1ValueSlider->isEnabled()){
		 m_param1ValueSlider->setEnabled(true);
	 }
	 if(!m_morphologicalSlider->isEnabled()){
		 m_morphologicalSlider->setEnabled(true);
	 }
	 m_meanThresholdingFlag=false;
	 m_gaussianThresholdingFlag=true;
	 doThresholding();
}

void AdaptiveThreshold::doThresholding(){
	 //thresholding
	 if(m_meanThresholdingFlag){
		cvAdaptiveThreshold(m_imgGray,m_imgTresholding,255.0,CV_ADAPTIVE_THRESH_MEAN_C,CV_THRESH_BINARY,m_blockSizeSlider->value()*2+3,((double)m_param1ValueSlider->value())/10.0);
	 }
	 else if(m_gaussianThresholdingFlag){
	    cvAdaptiveThreshold(m_imgGray,m_imgTresholding,255.0,CV_ADAPTIVE_THRESH_GAUSSIAN_C,CV_THRESH_BINARY,m_blockSizeSlider->value()*2+3,((double)m_param1ValueSlider->value())/10.0);
	 }
     //morphological processing
	 IplConvKernel* crossKernel=cvCreateStructuringElementEx(m_morphologicalSlider->value()*2+3,m_morphologicalSlider->value()*2+3,m_morphologicalSlider->value()+1,m_morphologicalSlider->value()+1,CV_SHAPE_CROSS);
	 if(m_morphologicalType->currentText().compare(QString("Open"))==0){
	    cvMorphologyEx(m_imgTresholding,m_imgTresholding,0,crossKernel,CV_MOP_OPEN);
	 }
	 else if(m_morphologicalType->currentText().compare(QString("Close"))==0){
	    cvMorphologyEx(m_imgTresholding,m_imgTresholding,0,crossKernel,CV_MOP_CLOSE);
	 }
	 QImage* qImage=new QImage(m_imgTresholding->width,m_imgTresholding->height,QImage::Format_RGB32);
     Ipl2QImageRGB32(m_imgTresholding,qImage);
	 QPixmap* pixmapImage=new QPixmap();
	 m_imageLabel->setPixmap(pixmapImage->fromImage(*qImage));
}

void AdaptiveThreshold::saveThresholdedImage(){
	 QString imgName=QFileDialog::getSaveFileName(0,tr("Save Thresholded Image Name"),"thresholdedImage.jpg",tr("Image (*.jpg)"));
	 cvSaveImage(imgName.toLatin1().data(),m_imgTresholding);
}
void AdaptiveThreshold::exitDialog(){
	 this->done(1);
}

void AdaptiveThreshold::Ipl2QImageRGB32(IplImage* iplImage,QImage* qImage){
     unsigned char* ptrQImage=qImage->bits();
	 switch(iplImage->depth){
		   case IPL_DEPTH_8U:
			    if(iplImage->nChannels==1){
					for(int row=0;row<iplImage->height;row++){
						unsigned char* ptr=(unsigned char*)(iplImage->imageData+row*iplImage->widthStep);
						for(int col=0;col<iplImage->width;col++){
						    *(ptrQImage)=*(ptr+col);
                            *(ptrQImage+1)=*(ptr+col);
							*(ptrQImage+2)=*(ptr+col);
							*(ptrQImage+3)=0;
							ptrQImage+=4;
						}
					}
			    }
				else if(iplImage->nChannels==3){
				    for(int row=0;row<iplImage->height;row++){
						unsigned char* ptr=(unsigned char*)(iplImage->imageData+row*iplImage->widthStep);
						for(int col=0;col<iplImage->width;col++){
						    *(ptrQImage)=*(ptr+col*3);
                            *(ptrQImage+1)=*(ptr+col*3+1);
							*(ptrQImage+2)=*(ptr+col*3+2);
							*(ptrQImage+3)=0;
							ptrQImage+=4;
						}
					}
				}
			    break;
		   case IPL_DEPTH_32F:
			    if(iplImage->nChannels==1){
					for(int row=0;row<iplImage->height;row++){
						float* ptr=(float*)(iplImage->imageData+row*iplImage->widthStep);
						for(int col=0;col<iplImage->width;col++){
						    *(ptrQImage)=(unsigned char)(*(ptr+col)*255.0);
                            *(ptrQImage+1)=(unsigned char)(*(ptr+col)*255.0);
							*(ptrQImage+2)=(unsigned char)(*(ptr+col)*255.0);
							*(ptrQImage+3)=0;
							ptrQImage+=4;
						}
					}
			    }
				else if(iplImage->nChannels==3){
				    for(int row=0;row<iplImage->height;row++){
						float* ptr=(float*)(iplImage->imageData+row*iplImage->widthStep);
						for(int col=0;col<iplImage->width;col++){
						    *(ptrQImage)=(unsigned char)(*(ptr+col*3)*255.0);
                            *(ptrQImage+1)=(unsigned char)(*(ptr+col*3+1)*255.0);
							*(ptrQImage+2)=(unsigned char)(*(ptr+col*3+2)*255.0);
							*(ptrQImage+3)=0;
							ptrQImage+=4;
						}
					}
				}
			    break;
		   case IPL_DEPTH_64F:
			    if(iplImage->nChannels==1){
					for(int row=0;row<iplImage->height;row++){
						double* ptr=(double*)(iplImage->imageData+row*iplImage->widthStep);
						for(int col=0;col<iplImage->width;col++){
						    *(ptrQImage)=(unsigned char)(*(ptr+col)*255.0);
                            *(ptrQImage+1)=(unsigned char)(*(ptr+col)*255.0);
							*(ptrQImage+2)=(unsigned char)(*(ptr+col)*255.0);
							*(ptrQImage+3)=0;
							ptrQImage+=4;
						}
					}
			    }
				else if(iplImage->nChannels==3){
				    for(int row=0;row<iplImage->height;row++){
						double* ptr=(double*)(iplImage->imageData+row*iplImage->widthStep);
						for(int col=0;col<iplImage->width;col++){
						    *(ptrQImage)=(unsigned char)(*(ptr+col*3)*255.0);
                            *(ptrQImage+1)=(unsigned char)(*(ptr+col*3+1)*255.0);
							*(ptrQImage+2)=(unsigned char)(*(ptr+col*3+2)*255.0);
							*(ptrQImage+3)=0;
							ptrQImage+=4;
						}
					}
				}
			    break;
		   default:
			    printf("The type of the IplImage should be IPL_DEPTH_8U,IPL_DEPTH_32F or IPL_DEPTH_64F");
	 }
}

//main.cpp
#include "AdaptiveThreshold.h"
#include <QtGui/QApplication>

int main(int argc,char** argv){
	QApplication app(argc,argv);
	IplImage* img=cvLoadImage("data/videoImage.jpg",1);
	AdaptiveThreshold testDialog(img);
	int ret=testDialog.exec();
	return app.exec();
}


C_arm
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Qt 实现 图片 二值化 灰度化代码
07-18
Qt实现图片的二值化，灰度化并保存图片及显示图片。 Qt实现图片的二值化，灰度化并保存图片及显示图片。
图像处理之常见二值化方法汇总
fu18946764506的博客
12-18 1万+
图像处理之常见二值化方法汇总 图像二值化是图像分析与处理中最常见最重要的处理手段，二值处理方法也非常多。越 精准的方法计算量也越大。本文主要介绍四种常见的二值处理方法，通常情况下可以满 足大多数图像处理的需要。主要本文讨论的方法仅针对RGB色彩空间。   方法一： 该方法非常简单，对RGB彩色图像灰度化以后，扫描图像的每个像素值，值小于127的 将像素值设为0(黑色)，值大于等于12...
【OpenCV3】阈值化操作——cv::threshold()与cv::adaptiveThreshold()详解
热门推荐
guduruyu的专栏
03-29 5万+
阈值化操作在图像处理中是一种常用的算法，比如图像的二值化就是一种最常见的一种阈值化操作。opencv2和opencv3中提供了两种阈值化操作接口，即cv::thread()与cv::adaptiveThreshold()，这里将对这两个接口进行介绍和对比。
Qt图像处理技术四:图像二值化
depend的博客
09-09 3107
Qt图像处理，图像二值化，原理及可直接使用代码
【QT课程设计】三：图片的灰度化、二值化(阈值可调)、3×3均值滤波
weixin_43035795的博客
11-22 4570
上一章我们姑且完成了图像打开的功能，这一章开始将开始对图像处理环节开始进行制作。
Qt对图像的二值化处理
永远的魔术1号
05-20 9009
    学习一下图像处理的基础算法，写下来总结一下：1. 灰度图像    二值化图像的第一步是先将彩色图片转变为灰度图像，灰度图像算法如下：我们可以通过下面几种方法，将其转换为灰度：1.浮点算法：Gray=R*0.3+G*0.59+B*0.112.整数方法：Gray=(R*30+G*59+B*11)/1003.移位方法：Gray =(R*76+G*151+B*28)&gt;&gt;8;4.平均值法...
阈值化OTSU算法cvAdaptiveThreshold 函数
09-22
阈值化OTSU算法cvAdaptiveThreshold 函数解析与示例。
find contours by adaptive threshold
09-12
use cvfindcontours and cvadaptivethreshold to get contours
Qt 之图像处理（六） 二值化处理
desian
08-21 2363
二值化处理 void MainWindow::Threshold_pro(QImage *inputImage,QImage &outputImage,BYTE bThres) { BYTE bt; QColor oldColor; for(int i = 0; i<inputImage->height(); i++) { fo...
QT实现图片的二值化与灰度化
12-03
QT实现图片的二值化，与灰度化。 执行程序后，可以选择图片。两个按钮可以转换二值化和灰度化并且保存。
Qt实现二值细胞图像区域上色
12-27
本程序是我学校里数据结构课程设计的一道题目，水平有限还请见谅！
基于Qt的二值化图像的连通域标记软件
06-16
本软件需要在安装有Qt4.0以上版本的Windows下运行，使用的是Eclipse编辑的，主要的图像处理程序在imge_process.cpp里，打家可以参考，本程序已有界面，实现了一幅图像的连通域分割！
Qt+opencv二值化
spw_1201的博客
09-24 2253
我用的是Qt5.6.0+opencv3.2，套件是MinGW，关于在Qt中如何配置的问题，可以参考这篇文章， http://blog.csdn.net/gufeiyunshi/article/details/50967440 打开图像做个二值化处理，以证明配置没有问题。 在ui界面放一个label和一个pushButton，比较喜欢使用Qt做界面开发，它融合了C#和C++两种语言的好处。
二值化图片数据解码显示(Grayscale8、Grayscale16、RGB888)————附带Qt版完整代码
韩江雪de 小屋
06-05 7039
文章目录1 效果2 思路3 实现代码4 扩展5 实验数据 1 效果 显示效果： 二值化后的图片数据： 原始数据信息： \x00\x1F\x8F\xFF\xFF\xFF\xFF\xFF\xE0\x00\x01\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xF0\x00\x0F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xF0\x00?\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xF0\x00?\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\x
【QT+VTK 学习笔记】09:图像运算、二值化
qq_37373742的博客
03-15 365
前言 “VTK图形图像开发进阶_张晓东_罗火灵”的学习笔记。 东灵工作室 教程系列导航：http://blog.csdn.net/www_doling_net/article/details/8763686 学习资料 VTK官网学习地址：https://vtk.org/doc/nightly/html/ 学习笔记 图像运算 数学运算 vtklmageMathematics提供了基本的一元和二元数学操作。 该示例先生成一幅图像，图像中绘制了一个暗红色矩形；然后定义vtklmageMathematics 对象，
Qt-OpenCV学习笔记--自适应阈值--adaptiveThreshold()
ssismm的博客
11-08 532
adaptiveThreshold是threshold的进阶版本。threshold只是简单的把图像像素根据阈值区分，这样的二值区分比较粗糙。可能会导致图像的信息与特征完全无法提取，或者漏掉一些关键的信息。
图像二值化
草莓夹心的博客
10-22 616
1、简单阈值 这种方法是二值化中比较简单的一种方法，可以理解为为图像指定一个阈值，高于这个值的像素为其赋一个新值，否则我们给他赋另一个值，例如我们可以将高于这个阈值的像素设为白色，低于这个阈值的像素设为黑色，我们要用的的函数是cv2.threshold（），这个函数有四个主要的参数：第一个是要操作的原图，注意，这里的原图必须为灰度图，第二个参数就是我们进行分类要设定的那个值，第三个参数是当某像素
【OpenGL实践08】现代渲染管线在GLUT和Pygame和Qt.QOpenGLWidget上各自的实现代码
最新发布
gongdiwudu的专栏
04-19 881
据说QOpenGLWidget是用来取代QGLWidget的继承者，我们试图将GLUT上的旧代码改成QOpenGLWidget，本以为差别不大，轻易搞定，经实践发现要付出极大努力才能完成。经多次实验发现GLUT窗口、Pygame窗口、Qt.QOpenGLWidget上的实现方法无法兼容，甚至GL方法都不同，经好多天的百度查询，终于总结出各自的实现方法。作文以记录。
用c写一个判断图片是否有数字
04-23
接下来，我们可以使用cvAdaptiveThreshold函数对图像进行自适应阈值分割，将数字区域分离出来。然后，我们可以使用cvFindContours函数查找图像中的轮廓。如果轮廓的面积大于500，则认为这是一个数字。最后，我们可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值