mirror of
https://github.com/opencv/opencv.git
synced 2026-07-29 23:33:05 +04:00
Merge remote-tracking branch 'upstream/3.4' into merge-3.4
This commit is contained in:
Alexander Alekhin
@@ -20,29 +20,32 @@ using namespace cv;
|
||||
*/
|
||||
int main( int argc, char** argv )
|
||||
{
|
||||
//! [basic-linear-transform-parameters]
|
||||
double alpha = 1.0; /*< Simple contrast control */
|
||||
int beta = 0; /*< Simple brightness control */
|
||||
//! [basic-linear-transform-parameters]
|
||||
|
||||
/// Read image given by user
|
||||
//! [basic-linear-transform-load]
|
||||
String imageName("../data/lena.jpg"); // by default
|
||||
if (argc > 1)
|
||||
CommandLineParser parser( argc, argv, "{@input | ../data/lena.jpg | input image}" );
|
||||
Mat image = imread( parser.get<String>( "@input" ) );
|
||||
if( image.empty() )
|
||||
{
|
||||
imageName = argv[1];
|
||||
cout << "Could not open or find the image!\n" << endl;
|
||||
cout << "Usage: " << argv[0] << " <Input image>" << endl;
|
||||
return -1;
|
||||
}
|
||||
Mat image = imread( imageName );
|
||||
//! [basic-linear-transform-load]
|
||||
|
||||
//! [basic-linear-transform-output]
|
||||
Mat new_image = Mat::zeros( image.size(), image.type() );
|
||||
//! [basic-linear-transform-output]
|
||||
|
||||
//! [basic-linear-transform-parameters]
|
||||
double alpha = 1.0; /*< Simple contrast control */
|
||||
int beta = 0; /*< Simple brightness control */
|
||||
|
||||
/// Initialize values
|
||||
cout << " Basic Linear Transforms " << endl;
|
||||
cout << "-------------------------" << endl;
|
||||
cout << "* Enter the alpha value [1.0-3.0]: "; cin >> alpha;
|
||||
cout << "* Enter the beta value [0-100]: "; cin >> beta;
|
||||
//! [basic-linear-transform-parameters]
|
||||
|
||||
/// Do the operation new_image(i,j) = alpha*image(i,j) + beta
|
||||
/// Instead of these 'for' loops we could have used simply:
|
||||
@@ -51,19 +54,15 @@ int main( int argc, char** argv )
|
||||
//! [basic-linear-transform-operation]
|
||||
for( int y = 0; y < image.rows; y++ ) {
|
||||
for( int x = 0; x < image.cols; x++ ) {
|
||||
for( int c = 0; c < 3; c++ ) {
|
||||
for( int c = 0; c < image.channels(); c++ ) {
|
||||
new_image.at<Vec3b>(y,x)[c] =
|
||||
saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
|
||||
saturate_cast<uchar>( alpha*image.at<Vec3b>(y,x)[c] + beta );
|
||||
}
|
||||
}
|
||||
}
|
||||
//! [basic-linear-transform-operation]
|
||||
|
||||
//! [basic-linear-transform-display]
|
||||
/// Create Windows
|
||||
namedWindow("Original Image", WINDOW_AUTOSIZE);
|
||||
namedWindow("New Image", WINDOW_AUTOSIZE);
|
||||
|
||||
/// Show stuff
|
||||
imshow("Original Image", image);
|
||||
imshow("New Image", new_image);
|
||||
|
||||
+17
-17
@@ -3,6 +3,8 @@
|
||||
#include "opencv2/highgui.hpp"
|
||||
|
||||
// we're NOT "using namespace std;" here, to avoid collisions between the beta variable and std::beta in c++17
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using namespace cv;
|
||||
|
||||
namespace
|
||||
@@ -19,12 +21,13 @@ void basicLinearTransform(const Mat &img, const double alpha_, const int beta_)
|
||||
img.convertTo(res, -1, alpha_, beta_);
|
||||
|
||||
hconcat(img, res, img_corrected);
|
||||
imshow("Brightness and contrast adjustments", img_corrected);
|
||||
}
|
||||
|
||||
void gammaCorrection(const Mat &img, const double gamma_)
|
||||
{
|
||||
CV_Assert(gamma_ >= 0);
|
||||
//![changing-contrast-brightness-gamma-correction]
|
||||
//! [changing-contrast-brightness-gamma-correction]
|
||||
Mat lookUpTable(1, 256, CV_8U);
|
||||
uchar* p = lookUpTable.ptr();
|
||||
for( int i = 0; i < 256; ++i)
|
||||
@@ -32,9 +35,10 @@ void gammaCorrection(const Mat &img, const double gamma_)
|
||||
|
||||
Mat res = img.clone();
|
||||
LUT(img, lookUpTable, res);
|
||||
//![changing-contrast-brightness-gamma-correction]
|
||||
//! [changing-contrast-brightness-gamma-correction]
|
||||
|
||||
hconcat(img, res, img_gamma_corrected);
|
||||
imshow("Gamma correction", img_gamma_corrected);
|
||||
}
|
||||
|
||||
void on_linear_transform_alpha_trackbar(int, void *)
|
||||
@@ -60,36 +64,32 @@ void on_gamma_correction_trackbar(int, void *)
|
||||
|
||||
int main( int argc, char** argv )
|
||||
{
|
||||
|
||||
String imageName("../data/lena.jpg"); // by default
|
||||
if (argc > 1)
|
||||
CommandLineParser parser( argc, argv, "{@input | ../data/lena.jpg | input image}" );
|
||||
img_original = imread( parser.get<String>( "@input" ) );
|
||||
if( img_original.empty() )
|
||||
{
|
||||
imageName = argv[1];
|
||||
cout << "Could not open or find the image!\n" << endl;
|
||||
cout << "Usage: " << argv[0] << " <Input image>" << endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
img_original = imread( imageName );
|
||||
img_corrected = Mat(img_original.rows, img_original.cols*2, img_original.type());
|
||||
img_gamma_corrected = Mat(img_original.rows, img_original.cols*2, img_original.type());
|
||||
|
||||
hconcat(img_original, img_original, img_corrected);
|
||||
hconcat(img_original, img_original, img_gamma_corrected);
|
||||
|
||||
namedWindow("Brightness and contrast adjustments", WINDOW_AUTOSIZE);
|
||||
namedWindow("Gamma correction", WINDOW_AUTOSIZE);
|
||||
namedWindow("Brightness and contrast adjustments");
|
||||
namedWindow("Gamma correction");
|
||||
|
||||
createTrackbar("Alpha gain (contrast)", "Brightness and contrast adjustments", &alpha, 500, on_linear_transform_alpha_trackbar);
|
||||
createTrackbar("Beta bias (brightness)", "Brightness and contrast adjustments", &beta, 200, on_linear_transform_beta_trackbar);
|
||||
createTrackbar("Gamma correction", "Gamma correction", &gamma_cor, 200, on_gamma_correction_trackbar);
|
||||
|
||||
while (true)
|
||||
{
|
||||
imshow("Brightness and contrast adjustments", img_corrected);
|
||||
imshow("Gamma correction", img_gamma_corrected);
|
||||
on_linear_transform_alpha_trackbar(0, 0);
|
||||
on_gamma_correction_trackbar(0, 0);
|
||||
|
||||
int c = waitKey(30);
|
||||
if (c == 27)
|
||||
break;
|
||||
}
|
||||
waitKey();
|
||||
|
||||
imwrite("linear_transform_correction.png", img_corrected);
|
||||
imwrite("gamma_correction.png", img_gamma_corrected);
|
||||
|
||||
@@ -0,0 +1,180 @@
|
||||
/* Snippet code for Operations with images tutorial (not intended to be run but should built successfully) */
|
||||
|
||||
#include "opencv2/core.hpp"
|
||||
#include "opencv2/core/core_c.h"
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include "opencv2/imgproc.hpp"
|
||||
#include "opencv2/highgui.hpp"
|
||||
#include <iostream>
|
||||
|
||||
using namespace cv;
|
||||
using namespace std;
|
||||
|
||||
int main(int,char**)
|
||||
{
|
||||
std::string filename = "";
|
||||
// Input/Output
|
||||
{
|
||||
//! [Load an image from a file]
|
||||
Mat img = imread(filename);
|
||||
//! [Load an image from a file]
|
||||
CV_UNUSED(img);
|
||||
}
|
||||
{
|
||||
//! [Load an image from a file in grayscale]
|
||||
Mat img = imread(filename, IMREAD_GRAYSCALE);
|
||||
//! [Load an image from a file in grayscale]
|
||||
CV_UNUSED(img);
|
||||
}
|
||||
{
|
||||
Mat img(4,4,CV_8U);
|
||||
//! [Save image]
|
||||
imwrite(filename, img);
|
||||
//! [Save image]
|
||||
}
|
||||
// Accessing pixel intensity values
|
||||
{
|
||||
Mat img(4,4,CV_8U);
|
||||
int y = 0, x = 0;
|
||||
{
|
||||
//! [Pixel access 1]
|
||||
Scalar intensity = img.at<uchar>(y, x);
|
||||
//! [Pixel access 1]
|
||||
CV_UNUSED(intensity);
|
||||
}
|
||||
{
|
||||
//! [Pixel access 2]
|
||||
Scalar intensity = img.at<uchar>(Point(x, y));
|
||||
//! [Pixel access 2]
|
||||
CV_UNUSED(intensity);
|
||||
}
|
||||
{
|
||||
//! [Pixel access 3]
|
||||
Vec3b intensity = img.at<Vec3b>(y, x);
|
||||
uchar blue = intensity.val[0];
|
||||
uchar green = intensity.val[1];
|
||||
uchar red = intensity.val[2];
|
||||
//! [Pixel access 3]
|
||||
CV_UNUSED(blue);
|
||||
CV_UNUSED(green);
|
||||
CV_UNUSED(red);
|
||||
}
|
||||
{
|
||||
//! [Pixel access 4]
|
||||
Vec3f intensity = img.at<Vec3f>(y, x);
|
||||
float blue = intensity.val[0];
|
||||
float green = intensity.val[1];
|
||||
float red = intensity.val[2];
|
||||
//! [Pixel access 4]
|
||||
CV_UNUSED(blue);
|
||||
CV_UNUSED(green);
|
||||
CV_UNUSED(red);
|
||||
}
|
||||
{
|
||||
//! [Pixel access 5]
|
||||
img.at<uchar>(y, x) = 128;
|
||||
//! [Pixel access 5]
|
||||
}
|
||||
{
|
||||
int i = 0;
|
||||
//! [Mat from points vector]
|
||||
vector<Point2f> points;
|
||||
//... fill the array
|
||||
Mat pointsMat = Mat(points);
|
||||
//! [Mat from points vector]
|
||||
|
||||
//! [Point access]
|
||||
Point2f point = pointsMat.at<Point2f>(i, 0);
|
||||
//! [Point access]
|
||||
CV_UNUSED(point);
|
||||
}
|
||||
}
|
||||
// Memory management and reference counting
|
||||
{
|
||||
//! [Reference counting 1]
|
||||
std::vector<Point3f> points;
|
||||
// .. fill the array
|
||||
Mat pointsMat = Mat(points).reshape(1);
|
||||
//! [Reference counting 1]
|
||||
CV_UNUSED(pointsMat);
|
||||
}
|
||||
{
|
||||
//! [Reference counting 2]
|
||||
Mat img = imread("image.jpg");
|
||||
Mat img1 = img.clone();
|
||||
//! [Reference counting 2]
|
||||
CV_UNUSED(img1);
|
||||
}
|
||||
{
|
||||
//! [Reference counting 3]
|
||||
Mat img = imread("image.jpg");
|
||||
Mat sobelx;
|
||||
Sobel(img, sobelx, CV_32F, 1, 0);
|
||||
//! [Reference counting 3]
|
||||
}
|
||||
// Primitive operations
|
||||
{
|
||||
Mat img;
|
||||
{
|
||||
//! [Set image to black]
|
||||
img = Scalar(0);
|
||||
//! [Set image to black]
|
||||
}
|
||||
{
|
||||
//! [Select ROI]
|
||||
Rect r(10, 10, 100, 100);
|
||||
Mat smallImg = img(r);
|
||||
//! [Select ROI]
|
||||
CV_UNUSED(smallImg);
|
||||
}
|
||||
}
|
||||
{
|
||||
//! [C-API conversion]
|
||||
Mat img = imread("image.jpg");
|
||||
IplImage img1 = img;
|
||||
CvMat m = img;
|
||||
//! [C-API conversion]
|
||||
CV_UNUSED(img1);
|
||||
CV_UNUSED(m);
|
||||
}
|
||||
{
|
||||
//! [BGR to Gray]
|
||||
Mat img = imread("image.jpg"); // loading a 8UC3 image
|
||||
Mat grey;
|
||||
cvtColor(img, grey, COLOR_BGR2GRAY);
|
||||
//! [BGR to Gray]
|
||||
}
|
||||
{
|
||||
Mat dst, src;
|
||||
//! [Convert to CV_32F]
|
||||
src.convertTo(dst, CV_32F);
|
||||
//! [Convert to CV_32F]
|
||||
}
|
||||
// Visualizing images
|
||||
{
|
||||
//! [imshow 1]
|
||||
Mat img = imread("image.jpg");
|
||||
namedWindow("image", WINDOW_AUTOSIZE);
|
||||
imshow("image", img);
|
||||
waitKey();
|
||||
//! [imshow 1]
|
||||
}
|
||||
{
|
||||
//! [imshow 2]
|
||||
Mat img = imread("image.jpg");
|
||||
Mat grey;
|
||||
cvtColor(img, grey, COLOR_BGR2GRAY);
|
||||
Mat sobelx;
|
||||
Sobel(grey, sobelx, CV_32F, 1, 0);
|
||||
double minVal, maxVal;
|
||||
minMaxLoc(sobelx, &minVal, &maxVal); //find minimum and maximum intensities
|
||||
Mat draw;
|
||||
sobelx.convertTo(draw, CV_8U, 255.0/(maxVal - minVal), -minVal * 255.0/(maxVal - minVal));
|
||||
namedWindow("image", WINDOW_AUTOSIZE);
|
||||
imshow("image", draw);
|
||||
waitKey();
|
||||
//! [imshow 2]
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -21,13 +21,9 @@ double getOrientation(const vector<Point> &, Mat&);
|
||||
*/
|
||||
void drawAxis(Mat& img, Point p, Point q, Scalar colour, const float scale = 0.2)
|
||||
{
|
||||
//! [visualization1]
|
||||
double angle;
|
||||
double hypotenuse;
|
||||
angle = atan2( (double) p.y - q.y, (double) p.x - q.x ); // angle in radians
|
||||
hypotenuse = sqrt( (double) (p.y - q.y) * (p.y - q.y) + (p.x - q.x) * (p.x - q.x));
|
||||
// double degrees = angle * 180 / CV_PI; // convert radians to degrees (0-180 range)
|
||||
// cout << "Degrees: " << abs(degrees - 180) << endl; // angle in 0-360 degrees range
|
||||
//! [visualization1]
|
||||
double angle = atan2( (double) p.y - q.y, (double) p.x - q.x ); // angle in radians
|
||||
double hypotenuse = sqrt( (double) (p.y - q.y) * (p.y - q.y) + (p.x - q.x) * (p.x - q.x));
|
||||
|
||||
// Here we lengthen the arrow by a factor of scale
|
||||
q.x = (int) (p.x - scale * hypotenuse * cos(angle));
|
||||
@@ -42,7 +38,7 @@ void drawAxis(Mat& img, Point p, Point q, Scalar colour, const float scale = 0.2
|
||||
p.x = (int) (q.x + 9 * cos(angle - CV_PI / 4));
|
||||
p.y = (int) (q.y + 9 * sin(angle - CV_PI / 4));
|
||||
line(img, p, q, colour, 1, LINE_AA);
|
||||
//! [visualization1]
|
||||
//! [visualization1]
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -50,11 +46,11 @@ void drawAxis(Mat& img, Point p, Point q, Scalar colour, const float scale = 0.2
|
||||
*/
|
||||
double getOrientation(const vector<Point> &pts, Mat &img)
|
||||
{
|
||||
//! [pca]
|
||||
//! [pca]
|
||||
//Construct a buffer used by the pca analysis
|
||||
int sz = static_cast<int>(pts.size());
|
||||
Mat data_pts = Mat(sz, 2, CV_64FC1);
|
||||
for (int i = 0; i < data_pts.rows; ++i)
|
||||
Mat data_pts = Mat(sz, 2, CV_64F);
|
||||
for (int i = 0; i < data_pts.rows; i++)
|
||||
{
|
||||
data_pts.at<double>(i, 0) = pts[i].x;
|
||||
data_pts.at<double>(i, 1) = pts[i].y;
|
||||
@@ -70,16 +66,16 @@ double getOrientation(const vector<Point> &pts, Mat &img)
|
||||
//Store the eigenvalues and eigenvectors
|
||||
vector<Point2d> eigen_vecs(2);
|
||||
vector<double> eigen_val(2);
|
||||
for (int i = 0; i < 2; ++i)
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
eigen_vecs[i] = Point2d(pca_analysis.eigenvectors.at<double>(i, 0),
|
||||
pca_analysis.eigenvectors.at<double>(i, 1));
|
||||
|
||||
eigen_val[i] = pca_analysis.eigenvalues.at<double>(i);
|
||||
}
|
||||
//! [pca]
|
||||
|
||||
//! [pca]
|
||||
//! [visualization]
|
||||
//! [visualization]
|
||||
// Draw the principal components
|
||||
circle(img, cntr, 3, Scalar(255, 0, 255), 2);
|
||||
Point p1 = cntr + 0.02 * Point(static_cast<int>(eigen_vecs[0].x * eigen_val[0]), static_cast<int>(eigen_vecs[0].y * eigen_val[0]));
|
||||
@@ -88,7 +84,7 @@ double getOrientation(const vector<Point> &pts, Mat &img)
|
||||
drawAxis(img, cntr, p2, Scalar(255, 255, 0), 5);
|
||||
|
||||
double angle = atan2(eigen_vecs[0].y, eigen_vecs[0].x); // orientation in radians
|
||||
//! [visualization]
|
||||
//! [visualization]
|
||||
|
||||
return angle;
|
||||
}
|
||||
@@ -98,10 +94,10 @@ double getOrientation(const vector<Point> &pts, Mat &img)
|
||||
*/
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
//! [pre-process]
|
||||
//! [pre-process]
|
||||
// Load image
|
||||
CommandLineParser parser(argc, argv, "{@input | ../data/pca_test1.jpg | input image}");
|
||||
parser.about( "This program demonstrates how to use OpenCV PCA to extract the orienation of an object.\n" );
|
||||
parser.about( "This program demonstrates how to use OpenCV PCA to extract the orientation of an object.\n" );
|
||||
parser.printMessage();
|
||||
|
||||
Mat src = imread(parser.get<String>("@input"));
|
||||
@@ -122,14 +118,14 @@ int main(int argc, char** argv)
|
||||
// Convert image to binary
|
||||
Mat bw;
|
||||
threshold(gray, bw, 50, 255, THRESH_BINARY | THRESH_OTSU);
|
||||
//! [pre-process]
|
||||
//! [pre-process]
|
||||
|
||||
//! [contours]
|
||||
//! [contours]
|
||||
// Find all the contours in the thresholded image
|
||||
vector<vector<Point> > contours;
|
||||
findContours(bw, contours, RETR_LIST, CHAIN_APPROX_NONE);
|
||||
|
||||
for (size_t i = 0; i < contours.size(); ++i)
|
||||
for (size_t i = 0; i < contours.size(); i++)
|
||||
{
|
||||
// Calculate the area of each contour
|
||||
double area = contourArea(contours[i]);
|
||||
@@ -137,14 +133,14 @@ int main(int argc, char** argv)
|
||||
if (area < 1e2 || 1e5 < area) continue;
|
||||
|
||||
// Draw each contour only for visualisation purposes
|
||||
drawContours(src, contours, static_cast<int>(i), Scalar(0, 0, 255), 2, LINE_8);
|
||||
drawContours(src, contours, static_cast<int>(i), Scalar(0, 0, 255), 2);
|
||||
// Find the orientation of each shape
|
||||
getOrientation(contours[i], src);
|
||||
}
|
||||
//! [contours]
|
||||
//! [contours]
|
||||
|
||||
imshow("output", src);
|
||||
|
||||
waitKey(0);
|
||||
waitKey();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#include <opencv2/core.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include <opencv2/imgcodecs.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/ml.hpp>
|
||||
|
||||
@@ -9,21 +9,16 @@ using namespace cv::ml;
|
||||
|
||||
int main(int, char**)
|
||||
{
|
||||
// Data for visual representation
|
||||
int width = 512, height = 512;
|
||||
Mat image = Mat::zeros(height, width, CV_8UC3);
|
||||
|
||||
// Set up training data
|
||||
//! [setup1]
|
||||
int labels[4] = {1, -1, -1, -1};
|
||||
float trainingData[4][2] = { {501, 10}, {255, 10}, {501, 255}, {10, 501} };
|
||||
//! [setup1]
|
||||
//! [setup2]
|
||||
Mat trainingDataMat(4, 2, CV_32FC1, trainingData);
|
||||
Mat trainingDataMat(4, 2, CV_32F, trainingData);
|
||||
Mat labelsMat(4, 1, CV_32SC1, labels);
|
||||
//! [setup2]
|
||||
|
||||
|
||||
// Train the SVM
|
||||
//! [init]
|
||||
Ptr<SVM> svm = SVM::create();
|
||||
@@ -35,11 +30,16 @@ int main(int, char**)
|
||||
svm->train(trainingDataMat, ROW_SAMPLE, labelsMat);
|
||||
//! [train]
|
||||
|
||||
// Data for visual representation
|
||||
int width = 512, height = 512;
|
||||
Mat image = Mat::zeros(height, width, CV_8UC3);
|
||||
|
||||
// Show the decision regions given by the SVM
|
||||
//! [show]
|
||||
Vec3b green(0,255,0), blue (255,0,0);
|
||||
for (int i = 0; i < image.rows; ++i)
|
||||
for (int j = 0; j < image.cols; ++j)
|
||||
Vec3b green(0,255,0), blue(255,0,0);
|
||||
for (int i = 0; i < image.rows; i++)
|
||||
{
|
||||
for (int j = 0; j < image.cols; j++)
|
||||
{
|
||||
Mat sampleMat = (Mat_<float>(1,2) << j,i);
|
||||
float response = svm->predict(sampleMat);
|
||||
@@ -49,34 +49,33 @@ int main(int, char**)
|
||||
else if (response == -1)
|
||||
image.at<Vec3b>(i,j) = blue;
|
||||
}
|
||||
}
|
||||
//! [show]
|
||||
|
||||
// Show the training data
|
||||
//! [show_data]
|
||||
int thickness = -1;
|
||||
int lineType = 8;
|
||||
circle( image, Point(501, 10), 5, Scalar( 0, 0, 0), thickness, lineType );
|
||||
circle( image, Point(255, 10), 5, Scalar(255, 255, 255), thickness, lineType );
|
||||
circle( image, Point(501, 255), 5, Scalar(255, 255, 255), thickness, lineType );
|
||||
circle( image, Point( 10, 501), 5, Scalar(255, 255, 255), thickness, lineType );
|
||||
circle( image, Point(501, 10), 5, Scalar( 0, 0, 0), thickness );
|
||||
circle( image, Point(255, 10), 5, Scalar(255, 255, 255), thickness );
|
||||
circle( image, Point(501, 255), 5, Scalar(255, 255, 255), thickness );
|
||||
circle( image, Point( 10, 501), 5, Scalar(255, 255, 255), thickness );
|
||||
//! [show_data]
|
||||
|
||||
// Show support vectors
|
||||
//! [show_vectors]
|
||||
thickness = 2;
|
||||
lineType = 8;
|
||||
Mat sv = svm->getUncompressedSupportVectors();
|
||||
|
||||
for (int i = 0; i < sv.rows; ++i)
|
||||
for (int i = 0; i < sv.rows; i++)
|
||||
{
|
||||
const float* v = sv.ptr<float>(i);
|
||||
circle( image, Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thickness, lineType);
|
||||
circle(image, Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thickness);
|
||||
}
|
||||
//! [show_vectors]
|
||||
|
||||
imwrite("result.png", image); // save the image
|
||||
|
||||
imshow("SVM Simple Example", image); // show it to the user
|
||||
waitKey(0);
|
||||
|
||||
waitKey();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -5,9 +5,6 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/ml.hpp>
|
||||
|
||||
#define NTRAINING_SAMPLES 100 // Number of training samples per class
|
||||
#define FRAC_LINEAR_SEP 0.9f // Fraction of samples which compose the linear separable part
|
||||
|
||||
using namespace cv;
|
||||
using namespace cv::ml;
|
||||
using namespace std;
|
||||
@@ -16,8 +13,6 @@ static void help()
|
||||
{
|
||||
cout<< "\n--------------------------------------------------------------------------" << endl
|
||||
<< "This program shows Support Vector Machines for Non-Linearly Separable Data. " << endl
|
||||
<< "Usage:" << endl
|
||||
<< "./non_linear_svms" << endl
|
||||
<< "--------------------------------------------------------------------------" << endl
|
||||
<< endl;
|
||||
}
|
||||
@@ -26,13 +21,16 @@ int main()
|
||||
{
|
||||
help();
|
||||
|
||||
const int NTRAINING_SAMPLES = 100; // Number of training samples per class
|
||||
const float FRAC_LINEAR_SEP = 0.9f; // Fraction of samples which compose the linear separable part
|
||||
|
||||
// Data for visual representation
|
||||
const int WIDTH = 512, HEIGHT = 512;
|
||||
Mat I = Mat::zeros(HEIGHT, WIDTH, CV_8UC3);
|
||||
|
||||
//--------------------- 1. Set up training data randomly ---------------------------------------
|
||||
Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32FC1);
|
||||
Mat labels (2*NTRAINING_SAMPLES, 1, CV_32SC1);
|
||||
Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32F);
|
||||
Mat labels (2*NTRAINING_SAMPLES, 1, CV_32S);
|
||||
|
||||
RNG rng(100); // Random value generation class
|
||||
|
||||
@@ -44,10 +42,10 @@ int main()
|
||||
Mat trainClass = trainData.rowRange(0, nLinearSamples);
|
||||
// The x coordinate of the points is in [0, 0.4)
|
||||
Mat c = trainClass.colRange(0, 1);
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(0.4 * WIDTH));
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(0.4 * WIDTH));
|
||||
// The y coordinate of the points is in [0, 1)
|
||||
c = trainClass.colRange(1,2);
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
|
||||
|
||||
// Generate random points for the class 2
|
||||
trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
|
||||
@@ -56,26 +54,26 @@ int main()
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
|
||||
// The y coordinate of the points is in [0, 1)
|
||||
c = trainClass.colRange(1,2);
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
|
||||
//! [setup1]
|
||||
|
||||
//------------------ Set up the non-linearly separable part of the training data ---------------
|
||||
//! [setup2]
|
||||
// Generate random points for the classes 1 and 2
|
||||
trainClass = trainData.rowRange( nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
|
||||
trainClass = trainData.rowRange(nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
|
||||
// The x coordinate of the points is in [0.4, 0.6)
|
||||
c = trainClass.colRange(0,1);
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH));
|
||||
// The y coordinate of the points is in [0, 1)
|
||||
c = trainClass.colRange(1,2);
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(1), Scalar(HEIGHT));
|
||||
rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
|
||||
//! [setup2]
|
||||
|
||||
//------------------------- Set up the labels for the classes ---------------------------------
|
||||
labels.rowRange( 0, NTRAINING_SAMPLES).setTo(1); // Class 1
|
||||
labels.rowRange(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES).setTo(2); // Class 2
|
||||
|
||||
//------------------------ 2. Set up the support vector machines parameters --------------------
|
||||
//------------------------ 3. Train the svm ----------------------------------------------------
|
||||
cout << "Starting training process" << endl;
|
||||
//! [init]
|
||||
Ptr<SVM> svm = SVM::create();
|
||||
@@ -84,6 +82,8 @@ int main()
|
||||
svm->setKernel(SVM::LINEAR);
|
||||
svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, (int)1e7, 1e-6));
|
||||
//! [init]
|
||||
|
||||
//------------------------ 3. Train the svm ----------------------------------------------------
|
||||
//! [train]
|
||||
svm->train(trainData, ROW_SAMPLE, labels);
|
||||
//! [train]
|
||||
@@ -91,53 +91,54 @@ int main()
|
||||
|
||||
//------------------------ 4. Show the decision regions ----------------------------------------
|
||||
//! [show]
|
||||
Vec3b green(0,100,0), blue (100,0,0);
|
||||
for (int i = 0; i < I.rows; ++i)
|
||||
for (int j = 0; j < I.cols; ++j)
|
||||
Vec3b green(0,100,0), blue(100,0,0);
|
||||
for (int i = 0; i < I.rows; i++)
|
||||
{
|
||||
for (int j = 0; j < I.cols; j++)
|
||||
{
|
||||
Mat sampleMat = (Mat_<float>(1,2) << i, j);
|
||||
Mat sampleMat = (Mat_<float>(1,2) << j, i);
|
||||
float response = svm->predict(sampleMat);
|
||||
|
||||
if (response == 1) I.at<Vec3b>(j, i) = green;
|
||||
else if (response == 2) I.at<Vec3b>(j, i) = blue;
|
||||
if (response == 1) I.at<Vec3b>(i,j) = green;
|
||||
else if (response == 2) I.at<Vec3b>(i,j) = blue;
|
||||
}
|
||||
}
|
||||
//! [show]
|
||||
|
||||
//----------------------- 5. Show the training data --------------------------------------------
|
||||
//! [show_data]
|
||||
int thick = -1;
|
||||
int lineType = 8;
|
||||
float px, py;
|
||||
// Class 1
|
||||
for (int i = 0; i < NTRAINING_SAMPLES; ++i)
|
||||
for (int i = 0; i < NTRAINING_SAMPLES; i++)
|
||||
{
|
||||
px = trainData.at<float>(i,0);
|
||||
py = trainData.at<float>(i,1);
|
||||
circle(I, Point( (int) px, (int) py ), 3, Scalar(0, 255, 0), thick, lineType);
|
||||
circle(I, Point( (int) px, (int) py ), 3, Scalar(0, 255, 0), thick);
|
||||
}
|
||||
// Class 2
|
||||
for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; ++i)
|
||||
for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; i++)
|
||||
{
|
||||
px = trainData.at<float>(i,0);
|
||||
py = trainData.at<float>(i,1);
|
||||
circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick, lineType);
|
||||
circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick);
|
||||
}
|
||||
//! [show_data]
|
||||
|
||||
//------------------------- 6. Show support vectors --------------------------------------------
|
||||
//! [show_vectors]
|
||||
thick = 2;
|
||||
lineType = 8;
|
||||
Mat sv = svm->getUncompressedSupportVectors();
|
||||
|
||||
for (int i = 0; i < sv.rows; ++i)
|
||||
for (int i = 0; i < sv.rows; i++)
|
||||
{
|
||||
const float* v = sv.ptr<float>(i);
|
||||
circle( I, Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick, lineType);
|
||||
circle(I, Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick);
|
||||
}
|
||||
//! [show_vectors]
|
||||
|
||||
imwrite("result.png", I); // save the Image
|
||||
imwrite("result.png", I); // save the Image
|
||||
imshow("SVM for Non-Linear Training Data", I); // show it to the user
|
||||
waitKey(0);
|
||||
waitKey();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -22,7 +22,7 @@ const char* keys =
|
||||
"{ height | -1 | Preprocess input image by resizing to a specific height. }"
|
||||
"{ rgb | | Indicate that model works with RGB input images instead BGR ones. }"
|
||||
"{ thr | .5 | Confidence threshold. }"
|
||||
"{ thr | .4 | Non-maximum suppression threshold. }"
|
||||
"{ nms | .4 | Non-maximum suppression threshold. }"
|
||||
"{ backend | 0 | Choose one of computation backends: "
|
||||
"0: automatically (by default), "
|
||||
"1: Halide language (http://halide-lang.org/), "
|
||||
|
||||
+86
@@ -0,0 +1,86 @@
|
||||
import java.util.Scanner;
|
||||
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.highgui.HighGui;
|
||||
import org.opencv.imgcodecs.Imgcodecs;
|
||||
|
||||
class BasicLinearTransforms {
|
||||
private byte saturate(double val) {
|
||||
int iVal = (int) Math.round(val);
|
||||
iVal = iVal > 255 ? 255 : (iVal < 0 ? 0 : iVal);
|
||||
return (byte) iVal;
|
||||
}
|
||||
|
||||
public void run(String[] args) {
|
||||
/// Read image given by user
|
||||
//! [basic-linear-transform-load]
|
||||
String imagePath = args.length > 0 ? args[0] : "../data/lena.jpg";
|
||||
Mat image = Imgcodecs.imread(imagePath);
|
||||
if (image.empty()) {
|
||||
System.out.println("Empty image: " + imagePath);
|
||||
System.exit(0);
|
||||
}
|
||||
//! [basic-linear-transform-load]
|
||||
|
||||
//! [basic-linear-transform-output]
|
||||
Mat newImage = Mat.zeros(image.size(), image.type());
|
||||
//! [basic-linear-transform-output]
|
||||
|
||||
//! [basic-linear-transform-parameters]
|
||||
double alpha = 1.0; /*< Simple contrast control */
|
||||
int beta = 0; /*< Simple brightness control */
|
||||
|
||||
/// Initialize values
|
||||
System.out.println(" Basic Linear Transforms ");
|
||||
System.out.println("-------------------------");
|
||||
try (Scanner scanner = new Scanner(System.in)) {
|
||||
System.out.print("* Enter the alpha value [1.0-3.0]: ");
|
||||
alpha = scanner.nextDouble();
|
||||
System.out.print("* Enter the beta value [0-100]: ");
|
||||
beta = scanner.nextInt();
|
||||
}
|
||||
//! [basic-linear-transform-parameters]
|
||||
|
||||
/// Do the operation newImage(i,j) = alpha*image(i,j) + beta
|
||||
/// Instead of these 'for' loops we could have used simply:
|
||||
/// image.convertTo(newImage, -1, alpha, beta);
|
||||
/// but we wanted to show you how to access the pixels :)
|
||||
//! [basic-linear-transform-operation]
|
||||
byte[] imageData = new byte[(int) (image.total()*image.channels())];
|
||||
image.get(0, 0, imageData);
|
||||
byte[] newImageData = new byte[(int) (newImage.total()*newImage.channels())];
|
||||
for (int y = 0; y < image.rows(); y++) {
|
||||
for (int x = 0; x < image.cols(); x++) {
|
||||
for (int c = 0; c < image.channels(); c++) {
|
||||
double pixelValue = imageData[(y * image.cols() + x) * image.channels() + c];
|
||||
/// Java byte range is [-128, 127]
|
||||
pixelValue = pixelValue < 0 ? pixelValue + 256 : pixelValue;
|
||||
newImageData[(y * image.cols() + x) * image.channels() + c]
|
||||
= saturate(alpha * pixelValue + beta);
|
||||
}
|
||||
}
|
||||
}
|
||||
newImage.put(0, 0, newImageData);
|
||||
//! [basic-linear-transform-operation]
|
||||
|
||||
//! [basic-linear-transform-display]
|
||||
/// Show stuff
|
||||
HighGui.imshow("Original Image", image);
|
||||
HighGui.imshow("New Image", newImage);
|
||||
|
||||
/// Wait until user press some key
|
||||
HighGui.waitKey();
|
||||
//! [basic-linear-transform-display]
|
||||
System.exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
public class BasicLinearTransformsDemo {
|
||||
public static void main(String[] args) {
|
||||
// Load the native OpenCV library
|
||||
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
|
||||
|
||||
new BasicLinearTransforms().run(args);
|
||||
}
|
||||
}
|
||||
+202
@@ -0,0 +1,202 @@
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.Container;
|
||||
import java.awt.Image;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.ActionListener;
|
||||
|
||||
import javax.swing.BoxLayout;
|
||||
import javax.swing.ImageIcon;
|
||||
import javax.swing.JCheckBox;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JLabel;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JSlider;
|
||||
import javax.swing.event.ChangeEvent;
|
||||
import javax.swing.event.ChangeListener;
|
||||
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.highgui.HighGui;
|
||||
import org.opencv.imgcodecs.Imgcodecs;
|
||||
|
||||
class ChangingContrastBrightnessImage {
|
||||
private static int MAX_VALUE_ALPHA = 500;
|
||||
private static int MAX_VALUE_BETA_GAMMA = 200;
|
||||
private static final String WINDOW_NAME = "Changing the contrast and brightness of an image demo";
|
||||
private static final String ALPHA_NAME = "Alpha gain (contrast)";
|
||||
private static final String BETA_NAME = "Beta bias (brightness)";
|
||||
private static final String GAMMA_NAME = "Gamma correction";
|
||||
private JFrame frame;
|
||||
private Mat matImgSrc = new Mat();
|
||||
private JLabel imgSrcLabel;
|
||||
private JLabel imgModifLabel;
|
||||
private JPanel controlPanel;
|
||||
private JPanel alphaBetaPanel;
|
||||
private JPanel gammaPanel;
|
||||
private double alphaValue = 1.0;
|
||||
private double betaValue = 0.0;
|
||||
private double gammaValue = 1.0;
|
||||
private JCheckBox methodCheckBox;
|
||||
private JSlider sliderAlpha;
|
||||
private JSlider sliderBeta;
|
||||
private JSlider sliderGamma;
|
||||
|
||||
public ChangingContrastBrightnessImage(String[] args) {
|
||||
String imagePath = args.length > 0 ? args[0] : "../data/lena.jpg";
|
||||
matImgSrc = Imgcodecs.imread(imagePath);
|
||||
if (matImgSrc.empty()) {
|
||||
System.out.println("Empty image: " + imagePath);
|
||||
System.exit(0);
|
||||
}
|
||||
|
||||
// Create and set up the window.
|
||||
frame = new JFrame(WINDOW_NAME);
|
||||
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
||||
// Set up the content pane.
|
||||
Image img = HighGui.toBufferedImage(matImgSrc);
|
||||
addComponentsToPane(frame.getContentPane(), img);
|
||||
// Use the content pane's default BorderLayout. No need for
|
||||
// setLayout(new BorderLayout());
|
||||
// Display the window.
|
||||
frame.pack();
|
||||
frame.setVisible(true);
|
||||
}
|
||||
|
||||
private void addComponentsToPane(Container pane, Image img) {
|
||||
if (!(pane.getLayout() instanceof BorderLayout)) {
|
||||
pane.add(new JLabel("Container doesn't use BorderLayout!"));
|
||||
return;
|
||||
}
|
||||
|
||||
controlPanel = new JPanel();
|
||||
controlPanel.setLayout(new BoxLayout(controlPanel, BoxLayout.PAGE_AXIS));
|
||||
|
||||
methodCheckBox = new JCheckBox("Do gamma correction");
|
||||
methodCheckBox.addActionListener(new ActionListener() {
|
||||
@Override
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
JCheckBox cb = (JCheckBox) e.getSource();
|
||||
if (cb.isSelected()) {
|
||||
controlPanel.remove(alphaBetaPanel);
|
||||
controlPanel.add(gammaPanel);
|
||||
performGammaCorrection();
|
||||
frame.revalidate();
|
||||
frame.repaint();
|
||||
frame.pack();
|
||||
} else {
|
||||
controlPanel.remove(gammaPanel);
|
||||
controlPanel.add(alphaBetaPanel);
|
||||
performLinearTransformation();
|
||||
frame.revalidate();
|
||||
frame.repaint();
|
||||
frame.pack();
|
||||
}
|
||||
}
|
||||
});
|
||||
controlPanel.add(methodCheckBox);
|
||||
|
||||
alphaBetaPanel = new JPanel();
|
||||
alphaBetaPanel.setLayout(new BoxLayout(alphaBetaPanel, BoxLayout.PAGE_AXIS));
|
||||
alphaBetaPanel.add(new JLabel(ALPHA_NAME));
|
||||
sliderAlpha = new JSlider(0, MAX_VALUE_ALPHA, 100);
|
||||
sliderAlpha.setMajorTickSpacing(50);
|
||||
sliderAlpha.setMinorTickSpacing(10);
|
||||
sliderAlpha.setPaintTicks(true);
|
||||
sliderAlpha.setPaintLabels(true);
|
||||
sliderAlpha.addChangeListener(new ChangeListener() {
|
||||
@Override
|
||||
public void stateChanged(ChangeEvent e) {
|
||||
alphaValue = sliderAlpha.getValue() / 100.0;
|
||||
performLinearTransformation();
|
||||
}
|
||||
});
|
||||
alphaBetaPanel.add(sliderAlpha);
|
||||
|
||||
alphaBetaPanel.add(new JLabel(BETA_NAME));
|
||||
sliderBeta = new JSlider(0, MAX_VALUE_BETA_GAMMA, 100);
|
||||
sliderBeta.setMajorTickSpacing(20);
|
||||
sliderBeta.setMinorTickSpacing(5);
|
||||
sliderBeta.setPaintTicks(true);
|
||||
sliderBeta.setPaintLabels(true);
|
||||
sliderBeta.addChangeListener(new ChangeListener() {
|
||||
@Override
|
||||
public void stateChanged(ChangeEvent e) {
|
||||
betaValue = sliderBeta.getValue() - 100;
|
||||
performLinearTransformation();
|
||||
}
|
||||
});
|
||||
alphaBetaPanel.add(sliderBeta);
|
||||
controlPanel.add(alphaBetaPanel);
|
||||
|
||||
gammaPanel = new JPanel();
|
||||
gammaPanel.setLayout(new BoxLayout(gammaPanel, BoxLayout.PAGE_AXIS));
|
||||
gammaPanel.add(new JLabel(GAMMA_NAME));
|
||||
sliderGamma = new JSlider(0, MAX_VALUE_BETA_GAMMA, 100);
|
||||
sliderGamma.setMajorTickSpacing(20);
|
||||
sliderGamma.setMinorTickSpacing(5);
|
||||
sliderGamma.setPaintTicks(true);
|
||||
sliderGamma.setPaintLabels(true);
|
||||
sliderGamma.addChangeListener(new ChangeListener() {
|
||||
@Override
|
||||
public void stateChanged(ChangeEvent e) {
|
||||
gammaValue = sliderGamma.getValue() / 100.0;
|
||||
performGammaCorrection();
|
||||
}
|
||||
});
|
||||
gammaPanel.add(sliderGamma);
|
||||
|
||||
pane.add(controlPanel, BorderLayout.PAGE_START);
|
||||
JPanel framePanel = new JPanel();
|
||||
imgSrcLabel = new JLabel(new ImageIcon(img));
|
||||
framePanel.add(imgSrcLabel);
|
||||
imgModifLabel = new JLabel(new ImageIcon(img));
|
||||
framePanel.add(imgModifLabel);
|
||||
pane.add(framePanel, BorderLayout.CENTER);
|
||||
}
|
||||
|
||||
private void performLinearTransformation() {
|
||||
Mat img = new Mat();
|
||||
matImgSrc.convertTo(img, -1, alphaValue, betaValue);
|
||||
imgModifLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(img)));
|
||||
frame.repaint();
|
||||
}
|
||||
|
||||
private byte saturate(double val) {
|
||||
int iVal = (int) Math.round(val);
|
||||
iVal = iVal > 255 ? 255 : (iVal < 0 ? 0 : iVal);
|
||||
return (byte) iVal;
|
||||
}
|
||||
|
||||
private void performGammaCorrection() {
|
||||
//! [changing-contrast-brightness-gamma-correction]
|
||||
Mat lookUpTable = new Mat(1, 256, CvType.CV_8U);
|
||||
byte[] lookUpTableData = new byte[(int) (lookUpTable.total()*lookUpTable.channels())];
|
||||
for (int i = 0; i < lookUpTable.cols(); i++) {
|
||||
lookUpTableData[i] = saturate(Math.pow(i / 255.0, gammaValue) * 255.0);
|
||||
}
|
||||
lookUpTable.put(0, 0, lookUpTableData);
|
||||
Mat img = new Mat();
|
||||
Core.LUT(matImgSrc, lookUpTable, img);
|
||||
//! [changing-contrast-brightness-gamma-correction]
|
||||
|
||||
imgModifLabel.setIcon(new ImageIcon(HighGui.toBufferedImage(img)));
|
||||
frame.repaint();
|
||||
}
|
||||
}
|
||||
|
||||
public class ChangingContrastBrightnessImageDemo {
|
||||
public static void main(String[] args) {
|
||||
// Load the native OpenCV library
|
||||
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
|
||||
|
||||
// Schedule a job for the event dispatch thread:
|
||||
// creating and showing this application's GUI.
|
||||
javax.swing.SwingUtilities.invokeLater(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
new ChangingContrastBrightnessImage(args);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
import java.util.Arrays;
|
||||
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.Core.MinMaxLocResult;
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.Rect;
|
||||
import org.opencv.highgui.HighGui;
|
||||
import org.opencv.imgcodecs.Imgcodecs;
|
||||
import org.opencv.imgproc.Imgproc;
|
||||
|
||||
public class MatOperations {
|
||||
@SuppressWarnings("unused")
|
||||
public static void main(String[] args) {
|
||||
/* Snippet code for Operations with images tutorial (not intended to be run) */
|
||||
|
||||
// Load the native OpenCV library
|
||||
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
|
||||
|
||||
String filename = "";
|
||||
// Input/Output
|
||||
{
|
||||
//! [Load an image from a file]
|
||||
Mat img = Imgcodecs.imread(filename);
|
||||
//! [Load an image from a file]
|
||||
}
|
||||
{
|
||||
//! [Load an image from a file in grayscale]
|
||||
Mat img = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
|
||||
//! [Load an image from a file in grayscale]
|
||||
}
|
||||
{
|
||||
Mat img = new Mat(4, 4, CvType.CV_8U);
|
||||
//! [Save image]
|
||||
Imgcodecs.imwrite(filename, img);
|
||||
//! [Save image]
|
||||
}
|
||||
// Accessing pixel intensity values
|
||||
{
|
||||
Mat img = new Mat(4, 4, CvType.CV_8U);
|
||||
int y = 0, x = 0;
|
||||
{
|
||||
//! [Pixel access 1]
|
||||
byte[] imgData = new byte[(int) (img.total() * img.channels())];
|
||||
img.get(0, 0, imgData);
|
||||
byte intensity = imgData[y * img.cols() + x];
|
||||
//! [Pixel access 1]
|
||||
}
|
||||
{
|
||||
//! [Pixel access 5]
|
||||
byte[] imgData = new byte[(int) (img.total() * img.channels())];
|
||||
imgData[y * img.cols() + x] = (byte) 128;
|
||||
img.put(0, 0, imgData);
|
||||
//! [Pixel access 5]
|
||||
}
|
||||
|
||||
}
|
||||
// Memory management and reference counting
|
||||
{
|
||||
//! [Reference counting 2]
|
||||
Mat img = Imgcodecs.imread("image.jpg");
|
||||
Mat img1 = img.clone();
|
||||
//! [Reference counting 2]
|
||||
}
|
||||
{
|
||||
//! [Reference counting 3]
|
||||
Mat img = Imgcodecs.imread("image.jpg");
|
||||
Mat sobelx = new Mat();
|
||||
Imgproc.Sobel(img, sobelx, CvType.CV_32F, 1, 0);
|
||||
//! [Reference counting 3]
|
||||
}
|
||||
// Primitive operations
|
||||
{
|
||||
Mat img = new Mat(400, 400, CvType.CV_8UC3);
|
||||
{
|
||||
//! [Set image to black]
|
||||
byte[] imgData = new byte[(int) (img.total() * img.channels())];
|
||||
Arrays.fill(imgData, (byte) 0);
|
||||
img.put(0, 0, imgData);
|
||||
//! [Set image to black]
|
||||
}
|
||||
{
|
||||
//! [Select ROI]
|
||||
Rect r = new Rect(10, 10, 100, 100);
|
||||
Mat smallImg = img.submat(r);
|
||||
//! [Select ROI]
|
||||
}
|
||||
}
|
||||
{
|
||||
//! [BGR to Gray]
|
||||
Mat img = Imgcodecs.imread("image.jpg"); // loading a 8UC3 image
|
||||
Mat grey = new Mat();
|
||||
Imgproc.cvtColor(img, grey, Imgproc.COLOR_BGR2GRAY);
|
||||
//! [BGR to Gray]
|
||||
}
|
||||
{
|
||||
Mat dst = new Mat(), src = new Mat();
|
||||
//! [Convert to CV_32F]
|
||||
src.convertTo(dst, CvType.CV_32F);
|
||||
//! [Convert to CV_32F]
|
||||
}
|
||||
// Visualizing images
|
||||
{
|
||||
//! [imshow 1]
|
||||
Mat img = Imgcodecs.imread("image.jpg");
|
||||
HighGui.namedWindow("image", HighGui.WINDOW_AUTOSIZE);
|
||||
HighGui.imshow("image", img);
|
||||
HighGui.waitKey();
|
||||
//! [imshow 1]
|
||||
}
|
||||
{
|
||||
//! [imshow 2]
|
||||
Mat img = Imgcodecs.imread("image.jpg");
|
||||
Mat grey = new Mat();
|
||||
Imgproc.cvtColor(img, grey, Imgproc.COLOR_BGR2GRAY);
|
||||
Mat sobelx = new Mat();
|
||||
Imgproc.Sobel(grey, sobelx, CvType.CV_32F, 1, 0);
|
||||
MinMaxLocResult res = Core.minMaxLoc(sobelx); // find minimum and maximum intensities
|
||||
Mat draw = new Mat();
|
||||
double maxVal = res.maxVal, minVal = res.minVal;
|
||||
sobelx.convertTo(draw, CvType.CV_8U, 255.0 / (maxVal - minVal), -minVal * 255.0 / (maxVal - minVal));
|
||||
HighGui.namedWindow("image", HighGui.WINDOW_AUTOSIZE);
|
||||
HighGui.imshow("image", draw);
|
||||
HighGui.waitKey();
|
||||
//! [imshow 2]
|
||||
}
|
||||
System.exit(0);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.MatOfPoint;
|
||||
import org.opencv.core.Point;
|
||||
import org.opencv.core.Scalar;
|
||||
import org.opencv.highgui.HighGui;
|
||||
import org.opencv.imgcodecs.Imgcodecs;
|
||||
import org.opencv.imgproc.Imgproc;
|
||||
|
||||
//This program demonstrates how to use OpenCV PCA to extract the orientation of an object.
|
||||
class IntroductionToPCA {
|
||||
private void drawAxis(Mat img, Point p_, Point q_, Scalar colour, float scale) {
|
||||
Point p = new Point(p_.x, p_.y);
|
||||
Point q = new Point(q_.x, q_.y);
|
||||
//! [visualization1]
|
||||
double angle = Math.atan2(p.y - q.y, p.x - q.x); // angle in radians
|
||||
double hypotenuse = Math.sqrt((p.y - q.y) * (p.y - q.y) + (p.x - q.x) * (p.x - q.x));
|
||||
|
||||
// Here we lengthen the arrow by a factor of scale
|
||||
q.x = (int) (p.x - scale * hypotenuse * Math.cos(angle));
|
||||
q.y = (int) (p.y - scale * hypotenuse * Math.sin(angle));
|
||||
Imgproc.line(img, p, q, colour, 1, Core.LINE_AA, 0);
|
||||
|
||||
// create the arrow hooks
|
||||
p.x = (int) (q.x + 9 * Math.cos(angle + Math.PI / 4));
|
||||
p.y = (int) (q.y + 9 * Math.sin(angle + Math.PI / 4));
|
||||
Imgproc.line(img, p, q, colour, 1, Core.LINE_AA, 0);
|
||||
|
||||
p.x = (int) (q.x + 9 * Math.cos(angle - Math.PI / 4));
|
||||
p.y = (int) (q.y + 9 * Math.sin(angle - Math.PI / 4));
|
||||
Imgproc.line(img, p, q, colour, 1, Core.LINE_AA, 0);
|
||||
//! [visualization1]
|
||||
}
|
||||
|
||||
private double getOrientation(MatOfPoint ptsMat, Mat img) {
|
||||
List<Point> pts = ptsMat.toList();
|
||||
//! [pca]
|
||||
// Construct a buffer used by the pca analysis
|
||||
int sz = pts.size();
|
||||
Mat dataPts = new Mat(sz, 2, CvType.CV_64F);
|
||||
double[] dataPtsData = new double[(int) (dataPts.total() * dataPts.channels())];
|
||||
for (int i = 0; i < dataPts.rows(); i++) {
|
||||
dataPtsData[i * dataPts.cols()] = pts.get(i).x;
|
||||
dataPtsData[i * dataPts.cols() + 1] = pts.get(i).y;
|
||||
}
|
||||
dataPts.put(0, 0, dataPtsData);
|
||||
|
||||
// Perform PCA analysis
|
||||
Mat mean = new Mat();
|
||||
Mat eigenvectors = new Mat();
|
||||
Mat eigenvalues = new Mat();
|
||||
Core.PCACompute2(dataPts, mean, eigenvectors, eigenvalues);
|
||||
double[] meanData = new double[(int) (mean.total() * mean.channels())];
|
||||
mean.get(0, 0, meanData);
|
||||
|
||||
// Store the center of the object
|
||||
Point cntr = new Point(meanData[0], meanData[1]);
|
||||
|
||||
// Store the eigenvalues and eigenvectors
|
||||
double[] eigenvectorsData = new double[(int) (eigenvectors.total() * eigenvectors.channels())];
|
||||
double[] eigenvaluesData = new double[(int) (eigenvalues.total() * eigenvalues.channels())];
|
||||
eigenvectors.get(0, 0, eigenvectorsData);
|
||||
eigenvalues.get(0, 0, eigenvaluesData);
|
||||
//! [pca]
|
||||
|
||||
//! [visualization]
|
||||
// Draw the principal components
|
||||
Imgproc.circle(img, cntr, 3, new Scalar(255, 0, 255), 2);
|
||||
Point p1 = new Point(cntr.x + 0.02 * eigenvectorsData[0] * eigenvaluesData[0],
|
||||
cntr.y + 0.02 * eigenvectorsData[1] * eigenvaluesData[0]);
|
||||
Point p2 = new Point(cntr.x - 0.02 * eigenvectorsData[2] * eigenvaluesData[1],
|
||||
cntr.y - 0.02 * eigenvectorsData[3] * eigenvaluesData[1]);
|
||||
drawAxis(img, cntr, p1, new Scalar(0, 255, 0), 1);
|
||||
drawAxis(img, cntr, p2, new Scalar(255, 255, 0), 5);
|
||||
|
||||
double angle = Math.atan2(eigenvectorsData[1], eigenvectorsData[0]); // orientation in radians
|
||||
//! [visualization]
|
||||
|
||||
return angle;
|
||||
}
|
||||
|
||||
public void run(String[] args) {
|
||||
//! [pre-process]
|
||||
// Load image
|
||||
String filename = args.length > 0 ? args[0] : "../data/pca_test1.jpg";
|
||||
Mat src = Imgcodecs.imread(filename);
|
||||
|
||||
// Check if image is loaded successfully
|
||||
if (src.empty()) {
|
||||
System.err.println("Cannot read image: " + filename);
|
||||
System.exit(0);
|
||||
}
|
||||
|
||||
Mat srcOriginal = src.clone();
|
||||
HighGui.imshow("src", srcOriginal);
|
||||
|
||||
// Convert image to grayscale
|
||||
Mat gray = new Mat();
|
||||
Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);
|
||||
|
||||
// Convert image to binary
|
||||
Mat bw = new Mat();
|
||||
Imgproc.threshold(gray, bw, 50, 255, Imgproc.THRESH_BINARY | Imgproc.THRESH_OTSU);
|
||||
//! [pre-process]
|
||||
|
||||
//! [contours]
|
||||
// Find all the contours in the thresholded image
|
||||
List<MatOfPoint> contours = new ArrayList<>();
|
||||
Mat hierarchy = new Mat();
|
||||
Imgproc.findContours(bw, contours, hierarchy, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_NONE);
|
||||
|
||||
for (int i = 0; i < contours.size(); i++) {
|
||||
// Calculate the area of each contour
|
||||
double area = Imgproc.contourArea(contours.get(i));
|
||||
// Ignore contours that are too small or too large
|
||||
if (area < 1e2 || 1e5 < area)
|
||||
continue;
|
||||
|
||||
// Draw each contour only for visualisation purposes
|
||||
Imgproc.drawContours(src, contours, i, new Scalar(0, 0, 255), 2);
|
||||
// Find the orientation of each shape
|
||||
getOrientation(contours.get(i), src);
|
||||
}
|
||||
//! [contours]
|
||||
|
||||
HighGui.imshow("output", src);
|
||||
|
||||
HighGui.waitKey();
|
||||
System.exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
public class IntroductionToPCADemo {
|
||||
public static void main(String[] args) {
|
||||
// Load the native OpenCV library
|
||||
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
|
||||
|
||||
new IntroductionToPCA().run(args);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.Point;
|
||||
import org.opencv.core.Scalar;
|
||||
import org.opencv.core.TermCriteria;
|
||||
import org.opencv.highgui.HighGui;
|
||||
import org.opencv.imgcodecs.Imgcodecs;
|
||||
import org.opencv.imgproc.Imgproc;
|
||||
import org.opencv.ml.Ml;
|
||||
import org.opencv.ml.SVM;
|
||||
|
||||
public class IntroductionToSVMDemo {
|
||||
public static void main(String[] args) {
|
||||
// Load the native OpenCV library
|
||||
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
|
||||
|
||||
// Set up training data
|
||||
//! [setup1]
|
||||
int[] labels = { 1, -1, -1, -1 };
|
||||
float[] trainingData = { 501, 10, 255, 10, 501, 255, 10, 501 };
|
||||
//! [setup1]
|
||||
//! [setup2]
|
||||
Mat trainingDataMat = new Mat(4, 2, CvType.CV_32FC1);
|
||||
trainingDataMat.put(0, 0, trainingData);
|
||||
Mat labelsMat = new Mat(4, 1, CvType.CV_32SC1);
|
||||
labelsMat.put(0, 0, labels);
|
||||
//! [setup2]
|
||||
|
||||
// Train the SVM
|
||||
//! [init]
|
||||
SVM svm = SVM.create();
|
||||
svm.setType(SVM.C_SVC);
|
||||
svm.setKernel(SVM.LINEAR);
|
||||
svm.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER, 100, 1e-6));
|
||||
//! [init]
|
||||
//! [train]
|
||||
svm.train(trainingDataMat, Ml.ROW_SAMPLE, labelsMat);
|
||||
//! [train]
|
||||
|
||||
// Data for visual representation
|
||||
int width = 512, height = 512;
|
||||
Mat image = Mat.zeros(height, width, CvType.CV_8UC3);
|
||||
|
||||
// Show the decision regions given by the SVM
|
||||
//! [show]
|
||||
byte[] imageData = new byte[(int) (image.total() * image.channels())];
|
||||
Mat sampleMat = new Mat(1, 2, CvType.CV_32F);
|
||||
float[] sampleMatData = new float[(int) (sampleMat.total() * sampleMat.channels())];
|
||||
for (int i = 0; i < image.rows(); i++) {
|
||||
for (int j = 0; j < image.cols(); j++) {
|
||||
sampleMatData[0] = j;
|
||||
sampleMatData[1] = i;
|
||||
sampleMat.put(0, 0, sampleMatData);
|
||||
float response = svm.predict(sampleMat);
|
||||
|
||||
if (response == 1) {
|
||||
imageData[(i * image.cols() + j) * image.channels()] = 0;
|
||||
imageData[(i * image.cols() + j) * image.channels() + 1] = (byte) 255;
|
||||
imageData[(i * image.cols() + j) * image.channels() + 2] = 0;
|
||||
} else if (response == -1) {
|
||||
imageData[(i * image.cols() + j) * image.channels()] = (byte) 255;
|
||||
imageData[(i * image.cols() + j) * image.channels() + 1] = 0;
|
||||
imageData[(i * image.cols() + j) * image.channels() + 2] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
image.put(0, 0, imageData);
|
||||
//! [show]
|
||||
|
||||
// Show the training data
|
||||
//! [show_data]
|
||||
int thickness = -1;
|
||||
int lineType = Core.LINE_8;
|
||||
Imgproc.circle(image, new Point(501, 10), 5, new Scalar(0, 0, 0), thickness, lineType, 0);
|
||||
Imgproc.circle(image, new Point(255, 10), 5, new Scalar(255, 255, 255), thickness, lineType, 0);
|
||||
Imgproc.circle(image, new Point(501, 255), 5, new Scalar(255, 255, 255), thickness, lineType, 0);
|
||||
Imgproc.circle(image, new Point(10, 501), 5, new Scalar(255, 255, 255), thickness, lineType, 0);
|
||||
//! [show_data]
|
||||
|
||||
// Show support vectors
|
||||
//! [show_vectors]
|
||||
thickness = 2;
|
||||
Mat sv = svm.getUncompressedSupportVectors();
|
||||
float[] svData = new float[(int) (sv.total() * sv.channels())];
|
||||
sv.get(0, 0, svData);
|
||||
for (int i = 0; i < sv.rows(); ++i) {
|
||||
Imgproc.circle(image, new Point(svData[i * sv.cols()], svData[i * sv.cols() + 1]), 6,
|
||||
new Scalar(128, 128, 128), thickness, lineType, 0);
|
||||
}
|
||||
//! [show_vectors]
|
||||
|
||||
Imgcodecs.imwrite("result.png", image); // save the image
|
||||
|
||||
HighGui.imshow("SVM Simple Example", image); // show it to the user
|
||||
HighGui.waitKey();
|
||||
System.exit(0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
import java.util.Random;
|
||||
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.Point;
|
||||
import org.opencv.core.Scalar;
|
||||
import org.opencv.core.TermCriteria;
|
||||
import org.opencv.highgui.HighGui;
|
||||
import org.opencv.imgcodecs.Imgcodecs;
|
||||
import org.opencv.imgproc.Imgproc;
|
||||
import org.opencv.ml.Ml;
|
||||
import org.opencv.ml.SVM;
|
||||
|
||||
public class NonLinearSVMsDemo {
|
||||
public static final int NTRAINING_SAMPLES = 100;
|
||||
public static final float FRAC_LINEAR_SEP = 0.9f;
|
||||
|
||||
public static void main(String[] args) {
|
||||
// Load the native OpenCV library
|
||||
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
|
||||
|
||||
System.out.println("\n--------------------------------------------------------------------------");
|
||||
System.out.println("This program shows Support Vector Machines for Non-Linearly Separable Data. ");
|
||||
System.out.println("--------------------------------------------------------------------------\n");
|
||||
|
||||
// Data for visual representation
|
||||
int width = 512, height = 512;
|
||||
Mat I = Mat.zeros(height, width, CvType.CV_8UC3);
|
||||
|
||||
// --------------------- 1. Set up training data randomly---------------------------------------
|
||||
Mat trainData = new Mat(2 * NTRAINING_SAMPLES, 2, CvType.CV_32F);
|
||||
Mat labels = new Mat(2 * NTRAINING_SAMPLES, 1, CvType.CV_32S);
|
||||
|
||||
Random rng = new Random(100); // Random value generation class
|
||||
|
||||
// Set up the linearly separable part of the training data
|
||||
int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);
|
||||
|
||||
//! [setup1]
|
||||
// Generate random points for the class 1
|
||||
Mat trainClass = trainData.rowRange(0, nLinearSamples);
|
||||
// The x coordinate of the points is in [0, 0.4)
|
||||
Mat c = trainClass.colRange(0, 1);
|
||||
float[] cData = new float[(int) (c.total() * c.channels())];
|
||||
double[] cDataDbl = rng.doubles(cData.length, 0, 0.4f * width).toArray();
|
||||
for (int i = 0; i < cData.length; i++) {
|
||||
cData[i] = (float) cDataDbl[i];
|
||||
}
|
||||
c.put(0, 0, cData);
|
||||
// The y coordinate of the points is in [0, 1)
|
||||
c = trainClass.colRange(1, 2);
|
||||
cData = new float[(int) (c.total() * c.channels())];
|
||||
cDataDbl = rng.doubles(cData.length, 0, height).toArray();
|
||||
for (int i = 0; i < cData.length; i++) {
|
||||
cData[i] = (float) cDataDbl[i];
|
||||
}
|
||||
c.put(0, 0, cData);
|
||||
|
||||
// Generate random points for the class 2
|
||||
trainClass = trainData.rowRange(2 * NTRAINING_SAMPLES - nLinearSamples, 2 * NTRAINING_SAMPLES);
|
||||
// The x coordinate of the points is in [0.6, 1]
|
||||
c = trainClass.colRange(0, 1);
|
||||
cData = new float[(int) (c.total() * c.channels())];
|
||||
cDataDbl = rng.doubles(cData.length, 0.6 * width, width).toArray();
|
||||
for (int i = 0; i < cData.length; i++) {
|
||||
cData[i] = (float) cDataDbl[i];
|
||||
}
|
||||
c.put(0, 0, cData);
|
||||
// The y coordinate of the points is in [0, 1)
|
||||
c = trainClass.colRange(1, 2);
|
||||
cData = new float[(int) (c.total() * c.channels())];
|
||||
cDataDbl = rng.doubles(cData.length, 0, height).toArray();
|
||||
for (int i = 0; i < cData.length; i++) {
|
||||
cData[i] = (float) cDataDbl[i];
|
||||
}
|
||||
c.put(0, 0, cData);
|
||||
//! [setup1]
|
||||
|
||||
// ------------------ Set up the non-linearly separable part of the training data ---------------
|
||||
//! [setup2]
|
||||
// Generate random points for the classes 1 and 2
|
||||
trainClass = trainData.rowRange(nLinearSamples, 2 * NTRAINING_SAMPLES - nLinearSamples);
|
||||
// The x coordinate of the points is in [0.4, 0.6)
|
||||
c = trainClass.colRange(0, 1);
|
||||
cData = new float[(int) (c.total() * c.channels())];
|
||||
cDataDbl = rng.doubles(cData.length, 0.4 * width, 0.6 * width).toArray();
|
||||
for (int i = 0; i < cData.length; i++) {
|
||||
cData[i] = (float) cDataDbl[i];
|
||||
}
|
||||
c.put(0, 0, cData);
|
||||
// The y coordinate of the points is in [0, 1)
|
||||
c = trainClass.colRange(1, 2);
|
||||
cData = new float[(int) (c.total() * c.channels())];
|
||||
cDataDbl = rng.doubles(cData.length, 0, height).toArray();
|
||||
for (int i = 0; i < cData.length; i++) {
|
||||
cData[i] = (float) cDataDbl[i];
|
||||
}
|
||||
c.put(0, 0, cData);
|
||||
//! [setup2]
|
||||
|
||||
// ------------------------- Set up the labels for the classes---------------------------------
|
||||
labels.rowRange(0, NTRAINING_SAMPLES).setTo(new Scalar(1)); // Class 1
|
||||
labels.rowRange(NTRAINING_SAMPLES, 2 * NTRAINING_SAMPLES).setTo(new Scalar(2)); // Class 2
|
||||
|
||||
// ------------------------ 2. Set up the support vector machines parameters--------------------
|
||||
System.out.println("Starting training process");
|
||||
//! [init]
|
||||
SVM svm = SVM.create();
|
||||
svm.setType(SVM.C_SVC);
|
||||
svm.setC(0.1);
|
||||
svm.setKernel(SVM.LINEAR);
|
||||
svm.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER, (int) 1e7, 1e-6));
|
||||
//! [init]
|
||||
|
||||
// ------------------------ 3. Train the svm----------------------------------------------------
|
||||
//! [train]
|
||||
svm.train(trainData, Ml.ROW_SAMPLE, labels);
|
||||
//! [train]
|
||||
System.out.println("Finished training process");
|
||||
|
||||
// ------------------------ 4. Show the decision regions----------------------------------------
|
||||
//! [show]
|
||||
byte[] IData = new byte[(int) (I.total() * I.channels())];
|
||||
Mat sampleMat = new Mat(1, 2, CvType.CV_32F);
|
||||
float[] sampleMatData = new float[(int) (sampleMat.total() * sampleMat.channels())];
|
||||
for (int i = 0; i < I.rows(); i++) {
|
||||
for (int j = 0; j < I.cols(); j++) {
|
||||
sampleMatData[0] = j;
|
||||
sampleMatData[1] = i;
|
||||
sampleMat.put(0, 0, sampleMatData);
|
||||
float response = svm.predict(sampleMat);
|
||||
|
||||
if (response == 1) {
|
||||
IData[(i * I.cols() + j) * I.channels()] = 0;
|
||||
IData[(i * I.cols() + j) * I.channels() + 1] = 100;
|
||||
IData[(i * I.cols() + j) * I.channels() + 2] = 0;
|
||||
} else if (response == 2) {
|
||||
IData[(i * I.cols() + j) * I.channels()] = 100;
|
||||
IData[(i * I.cols() + j) * I.channels() + 1] = 0;
|
||||
IData[(i * I.cols() + j) * I.channels() + 2] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
I.put(0, 0, IData);
|
||||
//! [show]
|
||||
|
||||
// ----------------------- 5. Show the training data--------------------------------------------
|
||||
//! [show_data]
|
||||
int thick = -1;
|
||||
int lineType = Core.LINE_8;
|
||||
float px, py;
|
||||
// Class 1
|
||||
float[] trainDataData = new float[(int) (trainData.total() * trainData.channels())];
|
||||
trainData.get(0, 0, trainDataData);
|
||||
for (int i = 0; i < NTRAINING_SAMPLES; i++) {
|
||||
px = trainDataData[i * trainData.cols()];
|
||||
py = trainDataData[i * trainData.cols() + 1];
|
||||
Imgproc.circle(I, new Point(px, py), 3, new Scalar(0, 255, 0), thick, lineType, 0);
|
||||
}
|
||||
// Class 2
|
||||
for (int i = NTRAINING_SAMPLES; i < 2 * NTRAINING_SAMPLES; ++i) {
|
||||
px = trainDataData[i * trainData.cols()];
|
||||
py = trainDataData[i * trainData.cols() + 1];
|
||||
Imgproc.circle(I, new Point(px, py), 3, new Scalar(255, 0, 0), thick, lineType, 0);
|
||||
}
|
||||
//! [show_data]
|
||||
|
||||
// ------------------------- 6. Show support vectors--------------------------------------------
|
||||
//! [show_vectors]
|
||||
thick = 2;
|
||||
Mat sv = svm.getUncompressedSupportVectors();
|
||||
float[] svData = new float[(int) (sv.total() * sv.channels())];
|
||||
sv.get(0, 0, svData);
|
||||
for (int i = 0; i < sv.rows(); i++) {
|
||||
Imgproc.circle(I, new Point(svData[i * sv.cols()], svData[i * sv.cols() + 1]), 6, new Scalar(128, 128, 128),
|
||||
thick, lineType, 0);
|
||||
}
|
||||
//! [show_vectors]
|
||||
|
||||
Imgcodecs.imwrite("result.png", I); // save the Image
|
||||
HighGui.imshow("SVM for Non-Linear Training Data", I); // show it to the user
|
||||
HighGui.waitKey();
|
||||
System.exit(0);
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -25,8 +25,8 @@ def thresh_callback(val):
|
||||
boundRect = [None]*len(contours)
|
||||
centers = [None]*len(contours)
|
||||
radius = [None]*len(contours)
|
||||
for i in range(len(contours)):
|
||||
contours_poly[i] = cv.approxPolyDP(contours[i], 3, True)
|
||||
for i, c in enumerate(contours):
|
||||
contours_poly[i] = cv.approxPolyDP(c, 3, True)
|
||||
boundRect[i] = cv.boundingRect(contours_poly[i])
|
||||
centers[i], radius[i] = cv.minEnclosingCircle(contours_poly[i])
|
||||
## [allthework]
|
||||
|
||||
+6
-6
@@ -22,22 +22,22 @@ def thresh_callback(val):
|
||||
# Find the rotated rectangles and ellipses for each contour
|
||||
minRect = [None]*len(contours)
|
||||
minEllipse = [None]*len(contours)
|
||||
for i in range(len(contours)):
|
||||
minRect[i] = cv.minAreaRect(contours[i])
|
||||
if contours[i].shape[0] > 5:
|
||||
minEllipse[i] = cv.fitEllipse(contours[i])
|
||||
for i, c in enumerate(contours):
|
||||
minRect[i] = cv.minAreaRect(c)
|
||||
if c.shape[0] > 5:
|
||||
minEllipse[i] = cv.fitEllipse(c)
|
||||
|
||||
# Draw contours + rotated rects + ellipses
|
||||
## [zeroMat]
|
||||
drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
|
||||
## [zeroMat]
|
||||
## [forContour]
|
||||
for i in range(len(contours)):
|
||||
for i, c in enumerate(contours):
|
||||
color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
|
||||
# contour
|
||||
cv.drawContours(drawing, contours, i, color)
|
||||
# ellipse
|
||||
if contours[i].shape[0] > 5:
|
||||
if c.shape[0] > 5:
|
||||
cv.ellipse(drawing, minEllipse[i], color, 2)
|
||||
# rotated rectangle
|
||||
box = cv.boxPoints(minRect[i])
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
from __future__ import division
|
||||
import cv2 as cv
|
||||
import numpy as np
|
||||
|
||||
# Snippet code for Operations with images tutorial (not intended to be run)
|
||||
|
||||
def load():
|
||||
# Input/Output
|
||||
filename = 'img.jpg'
|
||||
## [Load an image from a file]
|
||||
img = cv.imread(filename)
|
||||
## [Load an image from a file]
|
||||
|
||||
## [Load an image from a file in grayscale]
|
||||
img = cv.imread(filename, cv.IMREAD_GRAYSCALE)
|
||||
## [Load an image from a file in grayscale]
|
||||
|
||||
## [Save image]
|
||||
cv.imwrite(filename, img)
|
||||
## [Save image]
|
||||
|
||||
def access_pixel():
|
||||
# Accessing pixel intensity values
|
||||
img = np.empty((4,4,3), np.uint8)
|
||||
y = 0
|
||||
x = 0
|
||||
## [Pixel access 1]
|
||||
intensity = img[y,x]
|
||||
## [Pixel access 1]
|
||||
|
||||
## [Pixel access 3]
|
||||
blue = img[y,x,0]
|
||||
green = img[y,x,1]
|
||||
red = img[y,x,2]
|
||||
## [Pixel access 3]
|
||||
|
||||
## [Pixel access 5]
|
||||
img[y,x] = 128
|
||||
## [Pixel access 5]
|
||||
|
||||
def reference_counting():
|
||||
# Memory management and reference counting
|
||||
## [Reference counting 2]
|
||||
img = cv.imread('image.jpg')
|
||||
img1 = np.copy(img)
|
||||
## [Reference counting 2]
|
||||
|
||||
## [Reference counting 3]
|
||||
img = cv.imread('image.jpg')
|
||||
sobelx = cv.Sobel(img, cv.CV_32F, 1, 0);
|
||||
## [Reference counting 3]
|
||||
|
||||
def primitive_operations():
|
||||
img = np.empty((4,4,3), np.uint8)
|
||||
## [Set image to black]
|
||||
img[:] = 0
|
||||
## [Set image to black]
|
||||
|
||||
## [Select ROI]
|
||||
smallImg = img[10:110,10:110]
|
||||
## [Select ROI]
|
||||
|
||||
## [BGR to Gray]
|
||||
img = cv.imread('image.jpg')
|
||||
grey = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
|
||||
## [BGR to Gray]
|
||||
|
||||
src = np.ones((4,4), np.uint8)
|
||||
## [Convert to CV_32F]
|
||||
dst = src.astype(np.float32)
|
||||
## [Convert to CV_32F]
|
||||
|
||||
def visualize_images():
|
||||
## [imshow 1]
|
||||
img = cv.imread('image.jpg')
|
||||
cv.namedWindow('image', cv.WINDOW_AUTOSIZE)
|
||||
cv.imshow('image', img)
|
||||
cv.waitKey()
|
||||
## [imshow 1]
|
||||
|
||||
## [imshow 2]
|
||||
img = cv.imread('image.jpg')
|
||||
grey = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
|
||||
sobelx = cv.Sobel(grey, cv.CV_32F, 1, 0)
|
||||
# find minimum and maximum intensities
|
||||
minVal = np.amin(sobelx)
|
||||
maxVal = np.amax(sobelx)
|
||||
draw = cv.convertScaleAbs(sobelx, alpha=255.0/(maxVal - minVal), beta=-minVal * 255.0/(maxVal - minVal))
|
||||
cv.namedWindow('image', cv.WINDOW_AUTOSIZE)
|
||||
cv.imshow('image', draw)
|
||||
cv.waitKey()
|
||||
## [imshow 2]
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
from __future__ import print_function
|
||||
from builtins import input
|
||||
import cv2 as cv
|
||||
import numpy as np
|
||||
import argparse
|
||||
|
||||
# Read image given by user
|
||||
## [basic-linear-transform-load]
|
||||
parser = argparse.ArgumentParser(description='Code for Changing the contrast and brightness of an image! tutorial.')
|
||||
parser.add_argument('--input', help='Path to input image.', default='../data/lena.jpg')
|
||||
args = parser.parse_args()
|
||||
|
||||
image = cv.imread(args.input)
|
||||
if image is None:
|
||||
print('Could not open or find the image: ', args.input)
|
||||
exit(0)
|
||||
## [basic-linear-transform-load]
|
||||
|
||||
## [basic-linear-transform-output]
|
||||
new_image = np.zeros(image.shape, image.dtype)
|
||||
## [basic-linear-transform-output]
|
||||
|
||||
## [basic-linear-transform-parameters]
|
||||
alpha = 1.0 # Simple contrast control
|
||||
beta = 0 # Simple brightness control
|
||||
|
||||
# Initialize values
|
||||
print(' Basic Linear Transforms ')
|
||||
print('-------------------------')
|
||||
try:
|
||||
alpha = float(input('* Enter the alpha value [1.0-3.0]: '))
|
||||
beta = int(input('* Enter the beta value [0-100]: '))
|
||||
except ValueError:
|
||||
print('Error, not a number')
|
||||
## [basic-linear-transform-parameters]
|
||||
|
||||
# Do the operation new_image(i,j) = alpha*image(i,j) + beta
|
||||
# Instead of these 'for' loops we could have used simply:
|
||||
# new_image = cv.convertScaleAbs(image, alpha=alpha, beta=beta)
|
||||
# but we wanted to show you how to access the pixels :)
|
||||
## [basic-linear-transform-operation]
|
||||
for y in range(image.shape[0]):
|
||||
for x in range(image.shape[1]):
|
||||
for c in range(image.shape[2]):
|
||||
new_image[y,x,c] = np.clip(alpha*image[y,x,c] + beta, 0, 255)
|
||||
## [basic-linear-transform-operation]
|
||||
|
||||
## [basic-linear-transform-display]
|
||||
# Show stuff
|
||||
cv.imshow('Original Image', image)
|
||||
cv.imshow('New Image', new_image)
|
||||
|
||||
# Wait until user press some key
|
||||
cv.waitKey()
|
||||
## [basic-linear-transform-display]
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
from __future__ import print_function
|
||||
from __future__ import division
|
||||
import cv2 as cv
|
||||
import numpy as np
|
||||
import argparse
|
||||
|
||||
alpha = 1.0
|
||||
alpha_max = 500
|
||||
beta = 0
|
||||
beta_max = 200
|
||||
gamma = 1.0
|
||||
gamma_max = 200
|
||||
|
||||
def basicLinearTransform():
|
||||
res = cv.convertScaleAbs(img_original, alpha=alpha, beta=beta)
|
||||
img_corrected = cv.hconcat([img_original, res])
|
||||
cv.imshow("Brightness and contrast adjustments", img_corrected)
|
||||
|
||||
def gammaCorrection():
|
||||
## [changing-contrast-brightness-gamma-correction]
|
||||
lookUpTable = np.empty((1,256), np.uint8)
|
||||
for i in range(256):
|
||||
lookUpTable[0,i] = np.clip(pow(i / 255.0, gamma) * 255.0, 0, 255)
|
||||
|
||||
res = cv.LUT(img_original, lookUpTable)
|
||||
## [changing-contrast-brightness-gamma-correction]
|
||||
|
||||
img_gamma_corrected = cv.hconcat([img_original, res]);
|
||||
cv.imshow("Gamma correction", img_gamma_corrected);
|
||||
|
||||
def on_linear_transform_alpha_trackbar(val):
|
||||
global alpha
|
||||
alpha = val / 100
|
||||
basicLinearTransform()
|
||||
|
||||
def on_linear_transform_beta_trackbar(val):
|
||||
global beta
|
||||
beta = val - 100
|
||||
basicLinearTransform()
|
||||
|
||||
def on_gamma_correction_trackbar(val):
|
||||
global gamma
|
||||
gamma = val / 100
|
||||
gammaCorrection()
|
||||
|
||||
parser = argparse.ArgumentParser(description='Code for Changing the contrast and brightness of an image! tutorial.')
|
||||
parser.add_argument('--input', help='Path to input image.', default='../data/lena.jpg')
|
||||
args = parser.parse_args()
|
||||
|
||||
img_original = cv.imread(args.input)
|
||||
if img_original is None:
|
||||
print('Could not open or find the image: ', args.input)
|
||||
exit(0)
|
||||
|
||||
img_corrected = np.empty((img_original.shape[0], img_original.shape[1]*2, img_original.shape[2]), img_original.dtype)
|
||||
img_gamma_corrected = np.empty((img_original.shape[0], img_original.shape[1]*2, img_original.shape[2]), img_original.dtype)
|
||||
|
||||
img_corrected = cv.hconcat([img_original, img_original])
|
||||
img_gamma_corrected = cv.hconcat([img_original, img_original])
|
||||
|
||||
cv.namedWindow('Brightness and contrast adjustments')
|
||||
cv.namedWindow('Gamma correction')
|
||||
|
||||
alpha_init = int(alpha *100)
|
||||
cv.createTrackbar('Alpha gain (contrast)', 'Brightness and contrast adjustments', alpha_init, alpha_max, on_linear_transform_alpha_trackbar)
|
||||
beta_init = beta + 100
|
||||
cv.createTrackbar('Beta bias (brightness)', 'Brightness and contrast adjustments', beta_init, beta_max, on_linear_transform_beta_trackbar)
|
||||
gamma_init = int(gamma * 100)
|
||||
cv.createTrackbar('Gamma correction', 'Gamma correction', gamma_init, gamma_max, on_gamma_correction_trackbar)
|
||||
|
||||
on_linear_transform_alpha_trackbar(alpha_init)
|
||||
on_gamma_correction_trackbar(gamma_init)
|
||||
|
||||
cv.waitKey()
|
||||
@@ -0,0 +1,100 @@
|
||||
from __future__ import print_function
|
||||
from __future__ import division
|
||||
import cv2 as cv
|
||||
import numpy as np
|
||||
import argparse
|
||||
from math import atan2, cos, sin, sqrt, pi
|
||||
|
||||
def drawAxis(img, p_, q_, colour, scale):
|
||||
p = list(p_)
|
||||
q = list(q_)
|
||||
## [visualization1]
|
||||
angle = atan2(p[1] - q[1], p[0] - q[0]) # angle in radians
|
||||
hypotenuse = sqrt((p[1] - q[1]) * (p[1] - q[1]) + (p[0] - q[0]) * (p[0] - q[0]))
|
||||
|
||||
# Here we lengthen the arrow by a factor of scale
|
||||
q[0] = p[0] - scale * hypotenuse * cos(angle)
|
||||
q[1] = p[1] - scale * hypotenuse * sin(angle)
|
||||
cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
|
||||
|
||||
# create the arrow hooks
|
||||
p[0] = q[0] + 9 * cos(angle + pi / 4)
|
||||
p[1] = q[1] + 9 * sin(angle + pi / 4)
|
||||
cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
|
||||
|
||||
p[0] = q[0] + 9 * cos(angle - pi / 4)
|
||||
p[1] = q[1] + 9 * sin(angle - pi / 4)
|
||||
cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
|
||||
## [visualization1]
|
||||
|
||||
def getOrientation(pts, img):
|
||||
## [pca]
|
||||
# Construct a buffer used by the pca analysis
|
||||
sz = len(pts)
|
||||
data_pts = np.empty((sz, 2), dtype=np.float64)
|
||||
for i in range(data_pts.shape[0]):
|
||||
data_pts[i,0] = pts[i,0,0]
|
||||
data_pts[i,1] = pts[i,0,1]
|
||||
|
||||
# Perform PCA analysis
|
||||
mean = np.empty((0))
|
||||
mean, eigenvectors, eigenvalues = cv.PCACompute2(data_pts, mean)
|
||||
|
||||
# Store the center of the object
|
||||
cntr = (int(mean[0,0]), int(mean[0,1]))
|
||||
## [pca]
|
||||
|
||||
## [visualization]
|
||||
# Draw the principal components
|
||||
cv.circle(img, cntr, 3, (255, 0, 255), 2)
|
||||
p1 = (cntr[0] + 0.02 * eigenvectors[0,0] * eigenvalues[0,0], cntr[1] + 0.02 * eigenvectors[0,1] * eigenvalues[0,0])
|
||||
p2 = (cntr[0] - 0.02 * eigenvectors[1,0] * eigenvalues[1,0], cntr[1] - 0.02 * eigenvectors[1,1] * eigenvalues[1,0])
|
||||
drawAxis(img, cntr, p1, (0, 255, 0), 1)
|
||||
drawAxis(img, cntr, p2, (255, 255, 0), 5)
|
||||
|
||||
angle = atan2(eigenvectors[0,1], eigenvectors[0,0]) # orientation in radians
|
||||
## [visualization]
|
||||
|
||||
return angle
|
||||
|
||||
## [pre-process]
|
||||
# Load image
|
||||
parser = argparse.ArgumentParser(description='Code for Introduction to Principal Component Analysis (PCA) tutorial.\
|
||||
This program demonstrates how to use OpenCV PCA to extract the orientation of an object.')
|
||||
parser.add_argument('--input', help='Path to input image.', default='../data/pca_test1.jpg')
|
||||
args = parser.parse_args()
|
||||
|
||||
src = cv.imread(args.input)
|
||||
# Check if image is loaded successfully
|
||||
if src is None:
|
||||
print('Could not open or find the image: ', args.input)
|
||||
exit(0)
|
||||
|
||||
cv.imshow('src', src)
|
||||
|
||||
# Convert image to grayscale
|
||||
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
|
||||
|
||||
# Convert image to binary
|
||||
_, bw = cv.threshold(gray, 50, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
|
||||
## [pre-process]
|
||||
|
||||
## [contours]
|
||||
# Find all the contours in the thresholded image
|
||||
_, contours, _ = cv.findContours(bw, cv.RETR_LIST, cv.CHAIN_APPROX_NONE)
|
||||
|
||||
for i, c in enumerate(contours):
|
||||
# Calculate the area of each contour
|
||||
area = cv.contourArea(c);
|
||||
# Ignore contours that are too small or too large
|
||||
if area < 1e2 or 1e5 < area:
|
||||
continue
|
||||
|
||||
# Draw each contour only for visualisation purposes
|
||||
cv.drawContours(src, contours, i, (0, 0, 255), 2);
|
||||
# Find the orientation of each shape
|
||||
getOrientation(c, src)
|
||||
## [contours]
|
||||
|
||||
cv.imshow('output', src)
|
||||
cv.waitKey()
|
||||
@@ -0,0 +1,62 @@
|
||||
import cv2 as cv
|
||||
import numpy as np
|
||||
|
||||
# Set up training data
|
||||
## [setup1]
|
||||
labels = np.array([1, -1, -1, -1])
|
||||
trainingData = np.matrix([[501, 10], [255, 10], [501, 255], [10, 501]], dtype=np.float32)
|
||||
## [setup1]
|
||||
|
||||
# Train the SVM
|
||||
## [init]
|
||||
svm = cv.ml.SVM_create()
|
||||
svm.setType(cv.ml.SVM_C_SVC)
|
||||
svm.setKernel(cv.ml.SVM_LINEAR)
|
||||
svm.setTermCriteria((cv.TERM_CRITERIA_MAX_ITER, 100, 1e-6))
|
||||
## [init]
|
||||
## [train]
|
||||
svm.train(trainingData, cv.ml.ROW_SAMPLE, labels)
|
||||
## [train]
|
||||
|
||||
# Data for visual representation
|
||||
width = 512
|
||||
height = 512
|
||||
image = np.zeros((height, width, 3), dtype=np.uint8)
|
||||
|
||||
# Show the decision regions given by the SVM
|
||||
## [show]
|
||||
green = (0,255,0)
|
||||
blue = (255,0,0)
|
||||
for i in range(image.shape[0]):
|
||||
for j in range(image.shape[1]):
|
||||
sampleMat = np.matrix([[j,i]], dtype=np.float32)
|
||||
response = svm.predict(sampleMat)[1]
|
||||
|
||||
if response == 1:
|
||||
image[i,j] = green
|
||||
elif response == -1:
|
||||
image[i,j] = blue
|
||||
## [show]
|
||||
|
||||
# Show the training data
|
||||
## [show_data]
|
||||
thickness = -1
|
||||
cv.circle(image, (501, 10), 5, ( 0, 0, 0), thickness)
|
||||
cv.circle(image, (255, 10), 5, (255, 255, 255), thickness)
|
||||
cv.circle(image, (501, 255), 5, (255, 255, 255), thickness)
|
||||
cv.circle(image, ( 10, 501), 5, (255, 255, 255), thickness)
|
||||
## [show_data]
|
||||
|
||||
# Show support vectors
|
||||
## [show_vectors]
|
||||
thickness = 2
|
||||
sv = svm.getUncompressedSupportVectors()
|
||||
|
||||
for i in range(sv.shape[0]):
|
||||
cv.circle(image, (sv[i,0], sv[i,1]), 6, (128, 128, 128), thickness)
|
||||
## [show_vectors]
|
||||
|
||||
cv.imwrite('result.png', image) # save the image
|
||||
|
||||
cv.imshow('SVM Simple Example', image) # show it to the user
|
||||
cv.waitKey()
|
||||
@@ -0,0 +1,117 @@
|
||||
from __future__ import print_function
|
||||
import cv2 as cv
|
||||
import numpy as np
|
||||
import random as rng
|
||||
|
||||
NTRAINING_SAMPLES = 100 # Number of training samples per class
|
||||
FRAC_LINEAR_SEP = 0.9 # Fraction of samples which compose the linear separable part
|
||||
|
||||
# Data for visual representation
|
||||
WIDTH = 512
|
||||
HEIGHT = 512
|
||||
I = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
|
||||
|
||||
# --------------------- 1. Set up training data randomly ---------------------------------------
|
||||
trainData = np.empty((2*NTRAINING_SAMPLES, 2), dtype=np.float32)
|
||||
labels = np.empty((2*NTRAINING_SAMPLES, 1), dtype=np.int32)
|
||||
|
||||
rng.seed(100) # Random value generation class
|
||||
|
||||
# Set up the linearly separable part of the training data
|
||||
nLinearSamples = int(FRAC_LINEAR_SEP * NTRAINING_SAMPLES)
|
||||
|
||||
## [setup1]
|
||||
# Generate random points for the class 1
|
||||
trainClass = trainData[0:nLinearSamples,:]
|
||||
# The x coordinate of the points is in [0, 0.4)
|
||||
c = trainClass[:,0:1]
|
||||
c[:] = np.random.uniform(0.0, 0.4 * WIDTH, c.shape)
|
||||
# The y coordinate of the points is in [0, 1)
|
||||
c = trainClass[:,1:2]
|
||||
c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
|
||||
|
||||
# Generate random points for the class 2
|
||||
trainClass = trainData[2*NTRAINING_SAMPLES-nLinearSamples:2*NTRAINING_SAMPLES,:]
|
||||
# The x coordinate of the points is in [0.6, 1]
|
||||
c = trainClass[:,0:1]
|
||||
c[:] = np.random.uniform(0.6*WIDTH, WIDTH, c.shape)
|
||||
# The y coordinate of the points is in [0, 1)
|
||||
c = trainClass[:,1:2]
|
||||
c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
|
||||
## [setup1]
|
||||
|
||||
#------------------ Set up the non-linearly separable part of the training data ---------------
|
||||
## [setup2]
|
||||
# Generate random points for the classes 1 and 2
|
||||
trainClass = trainData[nLinearSamples:2*NTRAINING_SAMPLES-nLinearSamples,:]
|
||||
# The x coordinate of the points is in [0.4, 0.6)
|
||||
c = trainClass[:,0:1]
|
||||
c[:] = np.random.uniform(0.4*WIDTH, 0.6*WIDTH, c.shape)
|
||||
# The y coordinate of the points is in [0, 1)
|
||||
c = trainClass[:,1:2]
|
||||
c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
|
||||
## [setup2]
|
||||
|
||||
#------------------------- Set up the labels for the classes ---------------------------------
|
||||
labels[0:NTRAINING_SAMPLES,:] = 1 # Class 1
|
||||
labels[NTRAINING_SAMPLES:2*NTRAINING_SAMPLES,:] = 2 # Class 2
|
||||
|
||||
#------------------------ 2. Set up the support vector machines parameters --------------------
|
||||
print('Starting training process')
|
||||
## [init]
|
||||
svm = cv.ml.SVM_create()
|
||||
svm.setType(cv.ml.SVM_C_SVC)
|
||||
svm.setC(0.1)
|
||||
svm.setKernel(cv.ml.SVM_LINEAR)
|
||||
svm.setTermCriteria((cv.TERM_CRITERIA_MAX_ITER, int(1e7), 1e-6))
|
||||
## [init]
|
||||
|
||||
#------------------------ 3. Train the svm ----------------------------------------------------
|
||||
## [train]
|
||||
svm.train(trainData, cv.ml.ROW_SAMPLE, labels)
|
||||
## [train]
|
||||
print('Finished training process')
|
||||
|
||||
#------------------------ 4. Show the decision regions ----------------------------------------
|
||||
## [show]
|
||||
green = (0,100,0)
|
||||
blue = (100,0,0)
|
||||
for i in range(I.shape[0]):
|
||||
for j in range(I.shape[1]):
|
||||
sampleMat = np.matrix([[j,i]], dtype=np.float32)
|
||||
response = svm.predict(sampleMat)[1]
|
||||
|
||||
if response == 1:
|
||||
I[i,j] = green
|
||||
elif response == 2:
|
||||
I[i,j] = blue
|
||||
## [show]
|
||||
|
||||
#----------------------- 5. Show the training data --------------------------------------------
|
||||
## [show_data]
|
||||
thick = -1
|
||||
# Class 1
|
||||
for i in range(NTRAINING_SAMPLES):
|
||||
px = trainData[i,0]
|
||||
py = trainData[i,1]
|
||||
cv.circle(I, (px, py), 3, (0, 255, 0), thick)
|
||||
|
||||
# Class 2
|
||||
for i in range(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES):
|
||||
px = trainData[i,0]
|
||||
py = trainData[i,1]
|
||||
cv.circle(I, (px, py), 3, (255, 0, 0), thick)
|
||||
## [show_data]
|
||||
|
||||
#------------------------- 6. Show support vectors --------------------------------------------
|
||||
## [show_vectors]
|
||||
thick = 2
|
||||
sv = svm.getUncompressedSupportVectors()
|
||||
|
||||
for i in range(sv.shape[0]):
|
||||
cv.circle(I, (sv[i,0], sv[i,1]), 6, (128, 128, 128), thick)
|
||||
## [show_vectors]
|
||||
|
||||
cv.imwrite('result.png', I) # save the Image
|
||||
cv.imshow('SVM for Non-Linear Training Data', I) # show it to the user
|
||||
cv.waitKey()
|
||||
Reference in New Issue
Block a user