示例#1
0
void ObjWidget::setData(const std::vector<cv::KeyPoint> & keypoints,
		const cv::Mat & descriptors,
		const cv::Mat & image,
		const QString & detectorType,
		const QString & descriptorType)
{
	keypoints_ = keypoints;
	descriptors_ = descriptors;
	kptColors_ = QVector<QColor>(keypoints.size(), defaultColor());
	keypointItems_.clear();
	rectItems_.clear();
	graphicsView_->scene()->clear();
	graphicsViewInitialized_ = false;
	detectorType_ = detectorType;
	descriptorType_ = descriptorType;
	mouseCurrentPos_ = mousePressedPos_; // this will reset roi selection

	cvImage_ = image.clone();
	pixmap_ = QPixmap::fromImage(cvtCvMat2QImage(cvImage_));
	//this->setMinimumSize(image_.size());

	if(graphicsViewMode_->isChecked())
	{
		this->setupGraphicsView();
	}
	label_->setVisible(image.empty());
}
示例#2
0
void ObjWidget::setData(
        const cv::Mat & image)
{



    rectItems_.clear();
    graphicsView_->scene()->clear();
    graphicsViewInitialized_ = false;



    cvImage_ = image.clone();
    pixmap_ = QPixmap::fromImage(cvtCvMat2QImage(cvImage_));
    //this->setMinimumSize(image_.size());

    if(graphicsViewMode_->isChecked())
    {
        this->setupGraphicsView();
    }
    label_->setVisible(image.empty());
}
示例#3
0
void QNode::rawImgReceivedCallback(const sensor_msgs::ImageConstPtr & img)
{
        if(img->data.size())
        {
                cv_bridge::CvImageConstPtr ptr = cv_bridge::toCvShare(img);

                //ROS_INFO("Received an image size=(%d,%d)", ptr->image.cols, ptr->image.rows);

  /*              if(imagesSaved)
                {
                        std::string path = "./imagesSaved";
                        if(!UDirectory::exists(path))
                        {
                                if(!UDirectory::makeDir(path))
                                {
                                        ROS_ERROR("Cannot make dir %s", path.c_str());
                                }
                        }
                        path.append("/");
                        path.append(uNumber2Str(i++));
                        path.append(".bmp");
                        if(!cv::imwrite(path.c_str(), ptr->image))
                        {
                                ROS_ERROR("Cannot save image to %s", path.c_str());
                        }
                        else
                        {
                                ROS_INFO("Saved image %s", path.c_str());
                        }
                }
                else if(view && view->isVisible())
                {
                        view->setPixmap(QPixmap::fromImage(cvtCvMat2QImage(ptr->image)));
                }

*/
                emit rawImageUpdated(QPixmap::fromImage(cvtCvMat2QImage(ptr->image)));
        }
}
示例#4
0
void Listener::chatterCallback(const sensor_msgs::ImageConstPtr& msg){

//(const std_msgs::String::ConstPtr &msg) {
//	ROS_INFO("I heard: [%s]", msg->data.c_str());
	cv_bridge::CvImagePtr cv_ptr;
	  try
	    {
	      cv_ptr = cv_bridge::toCvCopy(msg, sensor_msgs::image_encodings::BGR8);

	    }
	    catch (cv_bridge::Exception& e)
	    {
	      ROS_ERROR("cv_bridge exception: %s", e.what());
	      return;
	    }
	    px = QPixmap::fromImage(cvtCvMat2QImage(cv_ptr->image));
	logging.insertRows(0,1);
	std::stringstream logging_msg;
	logging_msg << "[ INFO] [" << ros::Time::now() << "]: I heard: " << "camera";
	QVariant new_row(QString(logging_msg.str().c_str()));
	logging.setData(logging.index(0),new_row);
	Q_EMIT Update_Image(&px);
}
/**
 * @brief GridWidget::initGrid              Рисует шахматку на экране с установленными параметрами
 * @param dispWidth                         Реальная ширина монитора
 * @param dispHeight                        Реальная высота монитора
 * @param cameraWidth
 * @param cameraHeight
 */
void GridWidget::initGrid(int dispWidth,int dispHeight,int cameraWidth,int cameraHeight,std::vector<cv::Point2f> &framePoints){

    dispWidth_ = dispWidth;
    dispHeight_ = dispHeight;
    cameraWidth_ = cameraWidth; //camera width
    cameraHeight_ = cameraHeight; //camera height

    ui->gridLabel->setFixedSize(dispWidth_,dispHeight_);
    ui->gridLabel->move(0,0);
    this->setFixedSize(dispWidth_,dispHeight_);

    screenPts_.push_back(cv::Point2f(0, 0));
    screenPts_.push_back(cv::Point2f((float)dispWidth_-1, 0));
    screenPts_.push_back(cv::Point2f((float)dispWidth_-1,(float) dispHeight_-1));
    screenPts_.push_back(cv::Point2f(0, (float)dispHeight_-1));



    cv::Mat gridBW;
    cv::Mat gridLaplace; // Преобразование Лапласа для более контрастных границ клеток
    cv::Mat bilateralMat;
    cv::Mat gaussianMat;

        cv::Mat grid(cameraHeight,cameraWidth,CV_8UC1);
        cv::Mat gridScreen(cameraHeight,cameraWidth,CV_8UC1);

             for (int y=0; y<cameraHeight; y++) {

                   for (int x=0; x<cameraWidth; x++) {
                       if (( x + y ) % 2){

                            cv::rectangle(grid,cv::Rect(x,y,1,1),cv::Scalar(0,0,0),1);

                       }
                       else {

                             cv::rectangle(grid,cv::Rect(x,y,1,1),cv::Scalar(255,255,255),1);
                       }

                   }
             }

//        /* Немного увеличить контрастность */
        Mat kernel = (Mat_<float>(3,3) <<
                 -1, -1, -1,
                 -1, 8,-1,
                 -1,  -1,-1 );
//         cvtColor(grid,grid,CV_BGR2GRAY);
         cv::GaussianBlur(grid,gaussianMat,cv::Size(21,21),99);

//         cv::addWeighted(grid, 9.5, gaussianMat, -0.5, 0, gaussianMat);
          grid = gaussianMat - grid;

        cv::Mat transmtx = cv::getPerspectiveTransform(framePoints, screenPts_);

        cv::warpPerspective(grid,gridScreen, transmtx,Size(dispWidth_,dispHeight_));
        cv::equalizeHist(gridScreen,gridScreen);
//        cv::normalize(gridScreen,gridScreen,1,0,NORM_L2,-1);

       QImage img = cvtCvMat2QImage(gridScreen);

    pixmap_ = QPixmap::fromImage(img);


    ui->gridLabel->setPixmap(pixmap_);
    ui->gridLabel->show();

    gridShown = true;

}