mirror of https://github.com/opencv/opencv.git
tribta
8 years ago
parent
d99ced6ec8
commit
9a2317e063
8 changed files with 419 additions and 159 deletions
|
After Width: | Height: | Size: 66 KiB |
|
After Width: | Height: | Size: 61 KiB |
@ -1,77 +0,0 @@ |
||||
#include "opencv2/imgcodecs.hpp" |
||||
#include "opencv2/highgui.hpp" |
||||
#include "opencv2/imgproc.hpp" |
||||
|
||||
#include <iostream> |
||||
|
||||
using namespace cv; |
||||
using namespace std; |
||||
|
||||
static void help() |
||||
{ |
||||
cout << "\nThis program demonstrates line finding with the Hough transform.\n" |
||||
"Usage:\n" |
||||
"./houghlines <image_name>, Default is ../data/pic1.png\n" << endl; |
||||
} |
||||
|
||||
int main(int argc, char** argv) |
||||
{ |
||||
cv::CommandLineParser parser(argc, argv, |
||||
"{help h||}{@image|../data/pic1.png|}" |
||||
); |
||||
if (parser.has("help")) |
||||
{ |
||||
help(); |
||||
return 0; |
||||
} |
||||
string filename = parser.get<string>("@image"); |
||||
if (filename.empty()) |
||||
{ |
||||
help(); |
||||
cout << "no image_name provided" << endl; |
||||
return -1; |
||||
} |
||||
Mat src = imread(filename, 0); |
||||
if(src.empty()) |
||||
{ |
||||
help(); |
||||
cout << "can not open " << filename << endl; |
||||
return -1; |
||||
} |
||||
|
||||
Mat dst, cdst; |
||||
Canny(src, dst, 50, 200, 3); |
||||
cvtColor(dst, cdst, COLOR_GRAY2BGR); |
||||
|
||||
#if 0 |
||||
vector<Vec2f> lines; |
||||
HoughLines(dst, lines, 1, CV_PI/180, 100, 0, 0 ); |
||||
|
||||
for( size_t i = 0; i < lines.size(); i++ ) |
||||
{ |
||||
float rho = lines[i][0], theta = lines[i][1]; |
||||
Point pt1, pt2; |
||||
double a = cos(theta), b = sin(theta); |
||||
double x0 = a*rho, y0 = b*rho; |
||||
pt1.x = cvRound(x0 + 1000*(-b)); |
||||
pt1.y = cvRound(y0 + 1000*(a)); |
||||
pt2.x = cvRound(x0 - 1000*(-b)); |
||||
pt2.y = cvRound(y0 - 1000*(a)); |
||||
line( cdst, pt1, pt2, Scalar(0,0,255), 3, CV_AA); |
||||
} |
||||
#else |
||||
vector<Vec4i> lines; |
||||
HoughLinesP(dst, lines, 1, CV_PI/180, 50, 50, 10 ); |
||||
for( size_t i = 0; i < lines.size(); i++ ) |
||||
{ |
||||
Vec4i l = lines[i]; |
||||
line( cdst, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0,0,255), 3, LINE_AA); |
||||
} |
||||
#endif |
||||
imshow("source", src); |
||||
imshow("detected lines", cdst); |
||||
|
||||
waitKey(); |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,89 @@ |
||||
/**
|
||||
* @file houghclines.cpp |
||||
* @brief This program demonstrates line finding with the Hough transform |
||||
*/ |
||||
|
||||
#include "opencv2/imgcodecs.hpp" |
||||
#include "opencv2/highgui.hpp" |
||||
#include "opencv2/imgproc.hpp" |
||||
|
||||
using namespace cv; |
||||
using namespace std; |
||||
|
||||
int main(int argc, char** argv) |
||||
{ |
||||
// Declare the output variables
|
||||
Mat dst, cdst, cdstP; |
||||
|
||||
//![load]
|
||||
const char* default_file = "../../../data/sudoku.png"; |
||||
const char* filename = argc >=2 ? argv[1] : default_file; |
||||
|
||||
// Loads an image
|
||||
Mat src = imread( filename, IMREAD_GRAYSCALE ); |
||||
|
||||
// Check if image is loaded fine
|
||||
if(src.empty()){ |
||||
printf(" Error opening image\n"); |
||||
printf(" Program Arguments: [image_name -- default %s] \n", default_file); |
||||
return -1; |
||||
} |
||||
//![load]
|
||||
|
||||
//![edge_detection]
|
||||
// Edge detection
|
||||
Canny(src, dst, 50, 200, 3); |
||||
//![edge_detection]
|
||||
|
||||
// Copy edges to the images that will display the results in BGR
|
||||
cvtColor(dst, cdst, COLOR_GRAY2BGR); |
||||
cdstP = cdst.clone(); |
||||
|
||||
//![hough_lines]
|
||||
// Standard Hough Line Transform
|
||||
vector<Vec2f> lines; // will hold the results of the detection
|
||||
HoughLines(dst, lines, 1, CV_PI/180, 150, 0, 0 ); // runs the actual detection
|
||||
//![hough_lines]
|
||||
//![draw_lines]
|
||||
// Draw the lines
|
||||
for( size_t i = 0; i < lines.size(); i++ ) |
||||
{ |
||||
float rho = lines[i][0], theta = lines[i][1]; |
||||
Point pt1, pt2; |
||||
double a = cos(theta), b = sin(theta); |
||||
double x0 = a*rho, y0 = b*rho; |
||||
pt1.x = cvRound(x0 + 1000*(-b)); |
||||
pt1.y = cvRound(y0 + 1000*(a)); |
||||
pt2.x = cvRound(x0 - 1000*(-b)); |
||||
pt2.y = cvRound(y0 - 1000*(a)); |
||||
line( cdst, pt1, pt2, Scalar(0,0,255), 3, CV_AA); |
||||
} |
||||
//![draw_lines]
|
||||
|
||||
//![hough_lines_p]
|
||||
// Probabilistic Line Transform
|
||||
vector<Vec4i> linesP; // will hold the results of the detection
|
||||
HoughLinesP(dst, linesP, 1, CV_PI/180, 50, 50, 10 ); // runs the actual detection
|
||||
//![hough_lines_p]
|
||||
//![draw_lines_p]
|
||||
// Draw the lines
|
||||
for( size_t i = 0; i < linesP.size(); i++ ) |
||||
{ |
||||
Vec4i l = linesP[i]; |
||||
line( cdstP, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0,0,255), 3, LINE_AA); |
||||
} |
||||
//![draw_lines_p]
|
||||
|
||||
//![imshow]
|
||||
// Show results
|
||||
imshow("Source", src); |
||||
imshow("Detected Lines (in red) - Standard Hough Line Transform", cdst); |
||||
imshow("Detected Lines (in red) - Probabilistic Line Transform", cdstP); |
||||
//![imshow]
|
||||
|
||||
//![exit]
|
||||
// Wait and Exit
|
||||
waitKey(); |
||||
return 0; |
||||
//![exit]
|
||||
} |
||||
@ -0,0 +1,96 @@ |
||||
/** |
||||
* @file HoughLines.java |
||||
* @brief This program demonstrates line finding with the Hough transform |
||||
*/ |
||||
|
||||
import org.opencv.core.*; |
||||
import org.opencv.core.Point; |
||||
import org.opencv.highgui.HighGui; |
||||
import org.opencv.imgcodecs.Imgcodecs; |
||||
import org.opencv.imgproc.Imgproc; |
||||
|
||||
class HoughLinesRun { |
||||
|
||||
public void run(String[] args) { |
||||
// Declare the output variables
|
||||
Mat dst = new Mat(), cdst = new Mat(), cdstP; |
||||
|
||||
//! [load]
|
||||
String default_file = "../../../../data/sudoku.png"; |
||||
String filename = ((args.length > 0) ? args[0] : default_file); |
||||
|
||||
// Load an image
|
||||
Mat src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE); |
||||
|
||||
// Check if image is loaded fine
|
||||
if( src.empty() ) { |
||||
System.out.println("Error opening image!"); |
||||
System.out.println("Program Arguments: [image_name -- default " |
||||
+ default_file +"] \n"); |
||||
System.exit(-1); |
||||
} |
||||
//! [load]
|
||||
|
||||
//! [edge_detection]
|
||||
// Edge detection
|
||||
Imgproc.Canny(src, dst, 50, 200, 3, false); |
||||
//! [edge_detection]
|
||||
|
||||
// Copy edges to the images that will display the results in BGR
|
||||
Imgproc.cvtColor(dst, cdst, Imgproc.COLOR_GRAY2BGR); |
||||
cdstP = cdst.clone(); |
||||
|
||||
//! [hough_lines]
|
||||
// Standard Hough Line Transform
|
||||
Mat lines = new Mat(); // will hold the results of the detection
|
||||
Imgproc.HoughLines(dst, lines, 1, Math.PI/180, 150); // runs the actual detection
|
||||
//! [hough_lines]
|
||||
//! [draw_lines]
|
||||
// Draw the lines
|
||||
for (int x = 0; x < lines.rows(); x++) { |
||||
double rho = lines.get(x, 0)[0], |
||||
theta = lines.get(x, 0)[1]; |
||||
|
||||
double a = Math.cos(theta), b = Math.sin(theta); |
||||
double x0 = a*rho, y0 = b*rho; |
||||
Point pt1 = new Point(Math.round(x0 + 1000*(-b)), Math.round(y0 + 1000*(a))); |
||||
Point pt2 = new Point(Math.round(x0 - 1000*(-b)), Math.round(y0 - 1000*(a))); |
||||
Imgproc.line(cdst, pt1, pt2, new Scalar(0, 0, 255), 3, Imgproc.LINE_AA, 0); |
||||
} |
||||
//! [draw_lines]
|
||||
|
||||
//! [hough_lines_p]
|
||||
// Probabilistic Line Transform
|
||||
Mat linesP = new Mat(); // will hold the results of the detection
|
||||
Imgproc.HoughLinesP(dst, linesP, 1, Math.PI/180, 50, 50, 10); // runs the actual detection
|
||||
//! [hough_lines_p]
|
||||
//! [draw_lines_p]
|
||||
// Draw the lines
|
||||
for (int x = 0; x < linesP.rows(); x++) { |
||||
double[] l = linesP.get(x, 0); |
||||
Imgproc.line(cdstP, new Point(l[0], l[1]), new Point(l[2], l[3]), new Scalar(0, 0, 255), 3, Imgproc.LINE_AA, 0); |
||||
} |
||||
//! [draw_lines_p]
|
||||
|
||||
//! [imshow]
|
||||
// Show results
|
||||
HighGui.imshow("Source", src); |
||||
HighGui.imshow("Detected Lines (in red) - Standard Hough Line Transform", cdst); |
||||
HighGui.imshow("Detected Lines (in red) - Probabilistic Line Transform", cdstP); |
||||
//! [imshow]
|
||||
|
||||
//! [exit]
|
||||
// Wait and Exit
|
||||
HighGui.waitKey(); |
||||
System.exit(0); |
||||
//! [exit]
|
||||
} |
||||
} |
||||
|
||||
public class HoughLines { |
||||
public static void main(String[] args) { |
||||
// Load the native library.
|
||||
System.loadLibrary(Core.NATIVE_LIBRARY_NAME); |
||||
new HoughLinesRun().run(args); |
||||
} |
||||
} |
||||
@ -0,0 +1,79 @@ |
||||
""" |
||||
@file hough_lines.py |
||||
@brief This program demonstrates line finding with the Hough transform |
||||
""" |
||||
import sys |
||||
import math |
||||
import cv2 |
||||
import numpy as np |
||||
|
||||
|
||||
def main(argv): |
||||
## [load] |
||||
default_file = "../../../../data/sudoku.png" |
||||
filename = argv[0] if len(argv) > 0 else default_file |
||||
|
||||
# Loads an image |
||||
src = cv2.imread(filename, cv2.IMREAD_GRAYSCALE) |
||||
|
||||
# Check if image is loaded fine |
||||
if src is None: |
||||
print ('Error opening image!') |
||||
print ('Usage: hough_lines.py [image_name -- default ' + default_file + '] \n') |
||||
return -1 |
||||
## [load] |
||||
|
||||
## [edge_detection] |
||||
# Edge detection |
||||
dst = cv2.Canny(src, 50, 200, None, 3) |
||||
## [edge_detection] |
||||
|
||||
# Copy edges to the images that will display the results in BGR |
||||
cdst = cv2.cvtColor(dst, cv2.COLOR_GRAY2BGR) |
||||
cdstP = np.copy(cdst) |
||||
|
||||
## [hough_lines] |
||||
# Standard Hough Line Transform |
||||
lines = cv2.HoughLines(dst, 1, np.pi / 180, 150, None, 0, 0) |
||||
## [hough_lines] |
||||
## [draw_lines] |
||||
# Draw the lines |
||||
if lines is not None: |
||||
for i in range(0, len(lines)): |
||||
rho = lines[i][0][0] |
||||
theta = lines[i][0][1] |
||||
a = math.cos(theta) |
||||
b = math.sin(theta) |
||||
x0 = a * rho |
||||
y0 = b * rho |
||||
pt1 = (int(x0 + 1000*(-b)), int(y0 + 1000*(a))) |
||||
pt2 = (int(x0 - 1000*(-b)), int(y0 - 1000*(a))) |
||||
|
||||
cv2.line(cdst, pt1, pt2, (0,0,255), 3, cv2.LINE_AA) |
||||
## [draw_lines] |
||||
|
||||
## [hough_lines_p] |
||||
# Probabilistic Line Transform |
||||
linesP = cv2.HoughLinesP(dst, 1, np.pi / 180, 50, None, 50, 10) |
||||
## [hough_lines_p] |
||||
## [draw_lines_p] |
||||
# Draw the lines |
||||
if linesP is not None: |
||||
for i in range(0, len(linesP)): |
||||
l = linesP[i][0] |
||||
cv2.line(cdstP, (l[0], l[1]), (l[2], l[3]), (0,0,255), 3, cv2.LINE_AA) |
||||
## [draw_lines_p] |
||||
## [imshow] |
||||
# Show results |
||||
cv2.imshow("Source", src) |
||||
cv2.imshow("Detected Lines (in red) - Standard Hough Line Transform", cdst) |
||||
cv2.imshow("Detected Lines (in red) - Probabilistic Line Transform", cdstP) |
||||
## [imshow] |
||||
## [exit] |
||||
# Wait and Exit |
||||
cv2.waitKey() |
||||
return 0 |
||||
## [exit] |
||||
|
||||
if __name__ == "__main__": |
||||
main(sys.argv[1:]) |
||||
Loading…
Reference in new issue