cv::Mat FSVision::subLaser(cv::Mat &laserOff, cv::Mat &laserOn, double threshold)
{
unsigned int cols = laserOff.cols;
unsigned int rows = laserOff.rows;
cv::Mat bwLaserOff( cols,rows,CV_8U,cv::Scalar(100) );
cv::Mat bwLaserOn( cols,rows,CV_8U,cv::Scalar(100) );
cv::Mat diffImage( cols,rows,CV_8U,cv::Scalar(100) );
cv::Mat treshImage( cols,rows,CV_8U,cv::Scalar(100) );
cv::Mat result( cols,rows,CV_8UC3,cv::Scalar(100) );
cv::cvtColor(laserOff, bwLaserOff, CV_RGB2GRAY); //convert to grayscale
cv::cvtColor(laserOn, bwLaserOn, CV_RGB2GRAY); //convert to grayscale
cv::subtract(bwLaserOn,bwLaserOff,diffImage); //subtract both grayscales
cv::GaussianBlur(diffImage,diffImage,cv::Size(5,5),3); //gaussian filter
cv::threshold(diffImage,treshImage,threshold,255,cv::THRESH_BINARY); //apply threshold
cv::Mat element5(3,3,CV_8U,cv::Scalar(1));
cv::morphologyEx(treshImage,treshImage,cv::MORPH_OPEN,element5);
cv::cvtColor(treshImage, result, CV_GRAY2RGB); //convert back ro rgb
/*cv::namedWindow("laserLine");
cv::imshow("laserLine", result);
cv::waitKey(0);
cv::destroyWindow("laserLine");*/
return result;
}
void main() {
CElement element1(123);
CElement element2(element1);
cout << "The value of the element is " << element2.getValue() << endl;
CFile<CElement> cfile("C:\\Development\\file.txt");
cout << "file size is " << cfile.size() << endl; // expected 0
cfile.write(element1);
cout << "After writing single element, file size is " << cfile.size() << endl; // expected 1
CElement element3 = cfile.read();
cout << "Reading the single element from file: " << element3.getValue() << endl;
CElement element4(456);
CElement element5(78);
CElement writeBuf[] = { element4, element5 };
cout << "writing one more element..." << endl;
CElement element6(1000091);
cfile.write(element6);
cout << "Trying to write two elements from buffer... " << endl;
cfile.write(writeBuf, 2);
cout << "After writing 4 elements, size is: " << cfile.size() << endl;
cout << "Trying to read 4 elems with buffer: " << endl;
CElement* readBuf;
int index = cfile.read(&readBuf, 4);
cout << "elements are: " << endl;
for (int i = 0; i < index; i++) {
cout << readBuf[i];
}
}
Mat myErode(Mat img){
//dummy variables for erode
Mat toodeldav = img.clone();
Mat sisend;
// Make structuring elements
Mat struktuur = getStructuringElement(MORPH_ELLIPSE, Size(7,7));
//dilate(img, toodeldav, struktuur);
//erode(toodeldav, toodeldav, struktuur);
// show image after eroding
//imshow("erode", toodeldav);
//"Close" the image
cv::Mat element5(10, 10 ,CV_8U,cv::Scalar(1));
cv::Mat closed;
cv::morphologyEx(toodeldav,closed,cv::MORPH_CLOSE,struktuur);
//imshow("closed", closed);
return closed;
}
void ImageSegmentation::SegmentByWaterShed(cv::Mat inputFrame_) {
cv::Mat inputFrame = inputFrame_.clone();
cv::Mat element5(5,5, CV_8U, cv::Scalar(1));
if(inputFrame.empty())
return;
cv::Mat cannyFrame = inputFrame.clone();
cv::blur(cannyFrame, cannyFrame, cv::Size(3,3));
//cv::morphologyEx(cannyFrame, cannyFrame, cv::MORPH_OPEN, element5);
// cv::morphologyEx(cannyFrame, cannyFrame, cv::MORPH_CLOSE, element5);
cv::Canny(cannyFrame, cannyFrame, 100, 200, 3);
cv::threshold(cannyFrame, cannyFrame, 150, 200, cv::THRESH_BINARY);
cv::imshow("cannyThresh", cannyFrame);
std::vector< std::vector < cv::Point> > contourPoints;
std::vector<cv::Vec4i> hierarchy;
cv::morphologyEx(cannyFrame, cannyFrame, cv::MORPH_CLOSE, element5);
//cv::morphologyEx(cannyFrame, cannyFrame, cv::MORPH_OPEN, element5);
cv::findContours(cannyFrame, contourPoints, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cv::Point(0,0));
cv::Mat contourImage = cv::Mat::zeros(cannyFrame.size(), CV_8UC1);
std::vector<std::vector<cv::Point> > hull;
hull.resize(contourPoints.size());
std::vector<std::vector<cv::Point> > hullContourPoints;
double maxarea = 0;
int whichhull = -1;
hullContourPoints.resize(contourPoints.size());
for(int i=0; i < contourPoints.size(); i++) {
cv::convexHull(cv::Mat(contourPoints[i]), hull[i], false);
cv::approxPolyDP(cv::Mat(hull[i]), hullContourPoints[i], 0.001, true);
double a = std::fabs(cv::contourArea(cv::Mat(hullContourPoints[i])));
std::cout << a << std::endl;
if(a > maxarea) {
maxarea = a;
whichhull = i;
}
}
cv::Rect boundingRect;
for(int i=0; i < contourPoints.size(); i++) {
cv::drawContours(contourImage, contourPoints, -1, cv::Scalar(255,0,0), -1, 8, hierarchy);
if(i == whichhull){
cv::drawContours(contourImage, hull, i, cv::Scalar(0,255,0), 2, 8, hierarchy);
break;
}
}
//cv::drawContours(contourImage, contourPoints, largestcontour, cv::Scalar(255,255,255), -1, 8, hierarchy);
//cv::rectangle(inputFrame, boundingRect, cv::Scalar(0,255,0), 1, 8, 0);
cv::imshow("contour Image", contourImage);
//imshow("bounding rect", inputFrame);
//ShowContourImage();
/*
cv::Mat segmentFrame = contourImage.clone();//inputFrame.clone();
cv::cvtColor(segmentFrame, segmentFrame, CV_BGR2GRAY);
cv::threshold(segmentFrame, segmentFrame, 100, 255, CV_THRESH_BINARY);
cv::imshow("threshold", segmentFrame);
cv::Mat segmentFrameNorm = segmentFrame.clone();
cv::normalize(segmentFrameNorm, segmentFrameNorm, 0, 255, cv::NORM_MINMAX);
cv::imshow("thresholdnorm", segmentFrameNorm);
cv::Mat distanceTransformFrame;
cv::distanceTransform(segmentFrame, distanceTransformFrame, CV_DIST_L2, 5);
cv::normalize(distanceTransformFrame, distanceTransformFrame, 0, 1, cv::NORM_MINMAX);
cv::imshow("distance transform", distanceTransformFrame);
cv::threshold(distanceTransformFrame, distanceTransformFrame, 0.5, 1.0, CV_THRESH_BINARY);
cv::imshow("distance transform 2", distanceTransformFrame);
cv::Mat distanceTransformFrame8U;
distanceTransformFrame.convertTo(distanceTransformFrame8U, CV_8U);
std::vector< std::vector <cv::Point> > contours;
cv::findContours(distanceTransformFrame8U, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
cv::Mat markers = cv::Mat::zeros(distanceTransformFrame.size(), CV_32SC1);
for(int i=0; i< contours.size(); i++)
cv::drawContours(markers, contours, i, cv::Scalar::all((i+1)), -1);
//cv::circle(markers, cv::Point(5,5), 3, CV_RGB(255,255,255), -1);
cv::imshow("markers", markers*10000);*/
/*cv::watershed(inputFrame, markers);
std::vector<cv::Vec3b> colors;
for (int i = 0; i < contours.size(); i++)
{
int b = cv::theRNG().uniform(0, 255);
int g = cv::theRNG().uniform(0, 255);
int r = cv::theRNG().uniform(0, 255);
colors.push_back(cv::Vec3b((uchar)b, (uchar)g, (uchar)r));
}
// Create the result image
cv::Mat dst = cv::Mat::zeros(markers.size(), CV_8UC3);
// Fill labeled objects with random colors
for (int i = 0; i < markers.rows; i++)
{
for (int j = 0; j < markers.cols; j++)
{
int index = markers.at<int>(i,j);
if (index > 0 && index <= contours.size())
dst.at<cv::Vec3b>(i,j) = colors[index-1];
else
dst.at<cv::Vec3b>(i,j) = cv::Vec3b(0,0,0);
}
}
cv::imshow("dst", dst);*/
//cv::waitKey(0);
/*int c = cvWaitKey(10);
if(c==27) //ESC key
break;
*/
//cv::destroyAllWindows();
//return 0;
}
int main()
{
// Read input image
cv::Mat image= cv::imread("binary.bmp");
if (!image.data)
return 0;
// Display the image
cv::namedWindow("Image");
cv::imshow("Image",image);
// Erode the image
cv::Mat eroded;
cv::erode(image,eroded,cv::Mat());
// Display the eroded image
cv::namedWindow("Eroded Image");
cv::imshow("Eroded Image",eroded);
// Dilate the image
cv::Mat dilated;
cv::dilate(image,dilated,cv::Mat());
// Display the dialted image
cv::namedWindow("Dilated Image");
cv::imshow("Dilated Image",dilated);
// Erode the image with a larger s.e.
cv::Mat element(7,7,CV_8U,cv::Scalar(1));
cv::erode(image,eroded,element);
// Display the eroded image
cv::namedWindow("Eroded Image (7x7)");
cv::imshow("Eroded Image (7x7)",eroded);
// Erode the image 3 times.
cv::erode(image,eroded,cv::Mat(),cv::Point(-1,-1),3);
// Display the eroded image
cv::namedWindow("Eroded Image (3 times)");
cv::imshow("Eroded Image (3 times)",eroded);
// Close the image
cv::Mat element5(5,5,CV_8U,cv::Scalar(1));
cv::Mat closed;
cv::morphologyEx(image,closed,cv::MORPH_CLOSE,element5);
// Display the opened image
cv::namedWindow("Closed Image");
cv::imshow("Closed Image",closed);
// Open the image
cv::Mat opened;
cv::morphologyEx(image,opened,cv::MORPH_OPEN,element5);
// Display the opened image
cv::namedWindow("Opened Image");
cv::imshow("Opened Image",opened);
// Close and Open the image
cv::morphologyEx(image,image,cv::MORPH_CLOSE,element5);
cv::morphologyEx(image,image,cv::MORPH_OPEN,element5);
// Display the close/opened image
cv::namedWindow("Closed and Opened Image");
cv::imshow("Closed and Opened Image",image);
cv::imwrite("binaryGroup.bmp",image);
// Read input image
image= cv::imread("binary.bmp");
// Open and Close the image
cv::morphologyEx(image,image,cv::MORPH_OPEN,element5);
cv::morphologyEx(image,image,cv::MORPH_CLOSE,element5);
// Display the close/opened image
cv::namedWindow("Opened and Closed Image");
cv::imshow("Opened and Closed Image",image);
cv::waitKey();
return 0;
}
void imageCb(const sensor_msgs::ImageConstPtr& msg)
{
cv_bridge::CvImagePtr cv_ptr;
try
{
cv_ptr = cv_bridge::toCvCopy(msg, enc::BGR8);
}
catch (cv_bridge::Exception& e)
{
ROS_ERROR("cv_bridge exception: %s", e.what());
return;
}
/* Add any OpenCV processing here */
/* Gray scale image */
cv::Mat filtered_image;
cv::cvtColor(cv_ptr->image,filtered_image,CV_BGR2GRAY);
// Image Filtering
cv::Mat element5(5,5,CV_8U,cv::Scalar(1));
cv::morphologyEx(filtered_image,filtered_image,cv::MORPH_CLOSE,element5);
cv::morphologyEx(filtered_image,filtered_image,cv::MORPH_OPEN,element5);
cv::blur(filtered_image,filtered_image,cv::Size(3,3));
// Show final filtered image
cv::namedWindow("Filtered Image");
cv::imshow("Filtered Image",filtered_image);
// Finding Contours
cv::Mat contoured_image;
cv::morphologyEx(filtered_image,contoured_image,cv::MORPH_GRADIENT,cv::Mat());
cv::namedWindow("MORPH_GRADIENT contours");
cv::imshow("MORPH_GRADIENT contours",contoured_image);
// threshold image
cv::Mat threshold_image;
cv::threshold(contoured_image,threshold_image,global_min_threshold,255,cv::THRESH_BINARY);
cv::namedWindow("Threshold Image");
cv::imshow("Threshold Image",threshold_image);
cv::createTrackbar("Min Threshold:","Threshold Image",&global_min_threshold,255,update_global_min_threshold);
update_global_min_threshold(global_min_threshold,0);
// Make bounding boxes:
//// detect edges using threshold image
std::vector<std::vector<cv::Point> > contours;
std::vector<cv::Vec4i> hierarchy;
cv::findContours(threshold_image,contours,hierarchy,CV_RETR_TREE,CV_CHAIN_APPROX_SIMPLE);
//// find the rotated rectangles
std::vector<cv::RotatedRect> minRect(contours.size());
cv::RotatedRect new_rectangle;
double length_side_a, length_side_b;
cv::Point2f new_rect_points[4];
for (int i=0; i<contours.size(); i++) {
// only keep track of rectangles that might be cubelets... needs work
new_rectangle=cv::minAreaRect(cv::Mat(contours[i]));
new_rectangle.points(new_rect_points);
std::cout<<"INFO:\t point.x = "<<new_rect_points[0].x<<std::endl;
length_side_a=pow(new_rect_points[0].x-new_rect_points[1].x,2)+
pow(new_rect_points[0].y-new_rect_points[1].y,2);
length_side_b=pow(new_rect_points[0].x-new_rect_points[3].x,2)+
pow(new_rect_points[0].y-new_rect_points[3].y,2);
std::cout<<"INFO:\tsize, l_a/l_b = "<<new_rectangle.size.area()<<" ,"<<length_side_a/length_side_b<<std::endl;
if (new_rectangle.size.area()>=500 && // minimum size requirement
length_side_a/length_side_b>(100.0-global_squareness_ratio)/100.0 && // minimum squareness
length_side_a/length_side_b<(100.0+global_squareness_ratio)/100.0) {
minRect[i]=new_rectangle;
}
}
//// Draw contours & rectangles
cv::Mat contour_output(threshold_image.size(),CV_8U,cv::Scalar(255));
cv::Mat bounding_boxes=cv::Mat::zeros(contour_output.size(),CV_8UC3);;
int i=0;
for (; i >=0; i=hierarchy[i][0]) {
cv::Point2f rect_points[4];
minRect[i].points(rect_points);
cv::drawContours(bounding_boxes,contours,i,cv::Scalar(255,255,255),1,8,hierarchy,0,cv::Point());
for (int j=0; j<4; j++) {
cv::line(bounding_boxes,rect_points[j],rect_points[(j+1)%4],cv::Scalar(255),2,8);
}
}
cv::namedWindow("bounding boxes");
cv::imshow("bounding boxes",bounding_boxes);
cv::createTrackbar("Out-of-square acceptance: ","bounding boxes",&global_squareness_ratio,100,update_global_squareness_ratio);
// end of processing
cv::imshow(WINDOW, cv_ptr->image);
cv::waitKey(3);
image_pub_.publish(cv_ptr->toImageMsg());
}
