Skip to content

Instantly share code, notes, and snippets.

@sidd607

sidd607/machinePreception1.cpp

Created February 7, 2016 10:40
Show Gist options
  • Save sidd607/ac5fef5157d830e039fb to your computer and use it in GitHub Desktop.
Save sidd607/ac5fef5157d830e039fb to your computer and use it in GitHub Desktop.
Download ZIP
Raw
machinePreception1.cpp
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
#include <vector>
using namespace std;
using namespace cv;
void question1(Mat image) {
if (image.channels() >= 3) {
vector <Mat> rgb(image.channels());
namedWindow("original");
imshow("original", image);
split(image, rgb);
namedWindow("b");
imshow("b", rgb[0]);
namedWindow("g");
imshow("g", rgb[1]);
namedWindow("r");
imshow("r", rgb[2]);
waitKey(0);
}
}
void question2(Mat image) {
if (image.channels() >= 3) {
Mat fin;
vector <Mat> hsv(image.channels());
cvtColor(image, fin, CV_BGR2HSV);
split(fin, hsv);
imshow("Hue Channel", hsv[0]);
imshow("Saturation Channel", hsv[1]);
imshow("Value Channel", hsv[2]);
waitKey(0);
}
}
void question3(Mat image) {
if (image.channels() >= 3) {
Mat fin;
vector <Mat> lab(image.channels());
cvtColor(image, fin, CV_BGR2Lab);
split(fin, lab);
imshow("L", lab[0]);
imshow("a", lab[1]);
imshow("b", lab[2]);
waitKey(0);
}
}
void question4(Mat image) {
if (image.channels() >= 3) {
Mat fin;
cvtColor(image, fin, CV_BGR2GRAY);
namedWindow("GreyScale");
imshow("GreyScale", fin);
waitKey(0);
}
}
void question7a(Mat image) {
if (image.empty()) {
cout << "Could not load image";
system("pause");
}
else {
Mat fin;
cvtColor(image, fin, CV_BGR2GRAY);
Mat hist;
equalizeHist(fin, hist);
namedWindow("original");
imshow("original", image);
namedWindow("grey");
imshow("grey", fin);
namedWindow("hist");
imshow("hist", hist);
waitKey(0);
}
}
void question5() {
Mat image;
image = imread("C:/Users/siddartha/Pictures/selfie.jpg");
if (image.empty()) {
cout << "Image could not be loaded";
system("pause");
return;
}
Mat skin;
blur(image, skin, Size(1, 1));
cvtColor(skin, skin, CV_BGR2HSV);
Mat bw;
inRange(skin, Scalar(0, 10, 60), Scalar(50, 250, 255), bw);
vector <Mat> hsv(skin.channels());
vector <Mat> bin(bw.channels());
split(bw, bin);
split(skin, hsv);
hsv[2] += bin[0] / 5;
vector <Mat> channelsFinal;
channelsFinal.push_back(hsv[0]);
channelsFinal.push_back(hsv[1]);
channelsFinal.push_back(hsv[2]);
Mat finalImage;
merge(channelsFinal, finalImage);
hsv[2] -= 2 * (bin[0] / 5);
vector<Mat> channelsDark;
channelsDark.push_back(hsv[0]);
channelsDark.push_back(hsv[1]);
channelsDark.push_back(hsv[2]);
Mat finalDark;
merge(channelsDark, finalDark);
cvtColor(finalDark, finalDark, CV_HSV2BGR);
cvtColor(finalImage, finalImage, CV_HSV2BGR);
imshow("fairer", finalImage);
imshow("darker", finalDark);
namedWindow("original");
imshow("original", image);
imshow("skin", bw);
waitKey(0);
}
void question7b(Mat image) {
Mat grey;
cvtColor(image, grey, CV_BGR2GRAY);
//imshow("GREY",grey);
Mat tmp(grey.rows, grey.cols, CV_16SC1);
Scalar mean, dev;
meanStdDev(grey, mean, dev);
for (int i = 0;i < grey.rows; i++) {
for (int j = 0; j < grey.cols; j++) {
//tmp.at<uchar>(i, j) = (grey.at<uchar>(i, j) - mean[0]) / dev[0];
}
}
cout << mean << dev;
//cout << grey;
//imshow("lightGrey", grey);
waitKey(0);
system("pause");
}
void question8(Mat image) {
//cvtColor(image, image, CV_BGR2GRAY);
int DELAY_CAPTION = 1500;
int DELAY_BLUR = 100;
int MAX_KERNEL_LENGTH = 15;
Mat gausBlur;
gausBlur = image.clone();
for (int i = 1; i < MAX_KERNEL_LENGTH; i += 2) {
GaussianBlur(image, gausBlur, Size(i, i), 0, 0);
}
imshow("original", image);
imshow("Gausian", gausBlur);
waitKey(0);
}
void question9a(Mat image) {
cvtColor(image, image, CV_BGR2GRAY);
int MAX_KERNEL_LENGTH = 6;
Mat noise;
noise = image.clone();
randn(noise, 20 , 10);
noise = noise + image;
Mat blur;
blur = noise.clone();
for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
medianBlur(noise, blur, i);
cout << "hello\n";
}
imshow("image", image);
imshow("Gausian", noise);
imshow("Median", blur);
waitKey(0);
}
void question9b(Mat image) {
cvtColor(image, image, CV_BGR2GRAY);
Mat saltPepper = image.clone();
randu(saltPepper, 0, 255);
Mat black = saltPepper < 30;
Mat white = saltPepper > 255;
Mat saltPepperImg = image.clone();
saltPepperImg.setTo(255, white);
saltPepperImg.setTo(0, black);
imshow("salt", saltPepperImg);
int MAX_KERNEL_LENGTH = 10;
Mat blur;
blur = saltPepperImg.clone();
for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
medianBlur(saltPepperImg, blur, i);
cout << "hello\n";
}
imshow("blurred", blur);
waitKey(0);
}
void question14() {
Mat image_bgr, image_gray, image_morph;
Mat grad_x, abs_grad_x, image_gauss, image_close, image_otsu;
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
image_bgr = imread("C:/Users/siddartha/Pictures/car11.jpg");
if (!image_bgr.data)
{
printf("No image data \n");
system("pause");
return;
}
namedWindow("Display Image", WINDOW_NORMAL);
imshow("Display Image", image_bgr);
waitKey(0);
cvtColor(image_bgr, image_gray, CV_BGR2GRAY);
namedWindow("Display Image2", WINDOW_NORMAL);
imshow("Display Image2", image_gray);
waitKey(0);
Sobel(image_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
convertScaleAbs(grad_x, abs_grad_x);
namedWindow("Display Image3", WINDOW_NORMAL);
imshow("Display Image3", abs_grad_x);
waitKey(0);
GaussianBlur(abs_grad_x, image_gauss, Size(5, 5), 0, 0);
namedWindow("Display Image4", WINDOW_NORMAL);
imshow("Display Image4", image_gauss);
waitKey(0);
Mat element = getStructuringElement(MORPH_RECT, Size(23, 2), Point(-1, -1));
morphologyEx(image_gauss, image_close, MORPH_CLOSE, element);
namedWindow("Display Image5", WINDOW_NORMAL);
imshow("Display Image5", image_close);
waitKey(0);
threshold(image_close, image_otsu, 0, 255, CV_THRESH_BINARY | CV_THRESH_OTSU);
namedWindow("Display Image6", WINDOW_NORMAL);
imshow("Display Image6", image_otsu);
waitKey(0);
findContours(image_otsu, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE, Point(0, 0));
vector<vector<Point> >::iterator itc = contours.begin();
Point2f vertices[4];
Scalar color = Scalar(0, 0, 255);
while (itc != contours.end())
{
RotatedRect mr = minAreaRect(Mat(*itc));
float width = mr.size.width;
float height = mr.size.height;
bool output = false;
if ((width != 0) & (height != 0))
{
if (((height / width>2) & (height>width)) | ((width / height>2) & (width>height)))
{
if ((height*width<10000) & (height*width>2000))
{
output = true;
Point2f rect_points[4];
mr.points(rect_points);
for (int j = 0; j < 4; j++)
line(image_bgr, rect_points[j], rect_points[(j + 1) % 4], color, 2, 8);
}
}
}
++itc;
}
namedWindow("Display Image7", WINDOW_NORMAL);
imshow("Display Image7", image_bgr);
waitKey(0);
return;
}
void test() {
Mat image = imread("C:/Users/siddartha/Pictures/car1.jpg");
cvtColor(image, image, CV_BGR2GRAY);
imshow("car", image);
int morph_size = 2;
Mat element = getStructuringElement(MORPH_RECT, Size(2 * morph_size + 1, 2 * morph_size + 1), Point(morph_size, morph_size));
/*
Mat dst;
for (int i = 1;i < 10;i++)
{
morphologyEx(image, dst, MORPH_TOPHAT, element, Point(-1, -1), i, BORDER_CONSTANT);
//morphologyEx( src, dst, MORPH_TOPHAT, element ); // here iteration=1
imshow("source", image);
imshow("result", dst);
waitKey(1000);
}
*/
Mat dil;
dilate(image, dil, Mat(), Point(-1, -1), 2, 1, 1);
imshow("dilation", dil);
Mat ero;
erode(dil, ero, Mat(), Point(-1, -1), 2, 1, 1);
imshow("erode", ero);
Mat sub;
sub = image - ero;
imshow("Subtraction", sub);
waitKey(0);
}
void question10(Mat image) {
Mat src, src_gray;
Mat grad;
char* window_name = "Sobel Demo - Simple Edge Detector";
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
int c;
/// Load an image
src = image;
if (!src.data)
{
return;
}
GaussianBlur(src, src, Size(3, 3), 0, 0, BORDER_DEFAULT);
/// Convert it to gray
cvtColor(src, src_gray, CV_BGR2GRAY);
/// Create window
namedWindow(window_name, CV_WINDOW_AUTOSIZE);
/// Generate grad_x and grad_y
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y;
/// Gradient X
//Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
Sobel(src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
convertScaleAbs(grad_x, abs_grad_x);
/// Gradient Y
//Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
Sobel(src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT);
convertScaleAbs(grad_y, abs_grad_y);
/// Total Gradient (approximate)
addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);
imshow(window_name, grad);
waitKey(0);
}
int xGradient(Mat image, int x, int y)
{
return image.at<uchar>(y - 1, x - 1) +
image.at<uchar>(y, x - 1) +
image.at<uchar>(y + 1, x - 1) -
image.at<uchar>(y - 1, x + 1) -
image.at<uchar>(y, x + 1) -
image.at<uchar>(y + 1, x + 1);
}
// Computes the y component of the gradient vector
// at a given point in a image
// returns gradient in the y direction
int yGradient(Mat image, int x, int y)
{
return image.at<uchar>(y - 1, x - 1) +
image.at<uchar>(y - 1, x) +
image.at<uchar>(y - 1, x + 1) -
image.at<uchar>(y + 1, x - 1) -
image.at<uchar>(y + 1, x) -
image.at<uchar>(y + 1, x + 1);
}
void prewitt(Mat image) {
Mat src, dst;
int gx, gy, sum;
cvtColor(image, image, CV_BGR2GRAY);
// Load an image
src = image;
dst = src.clone();
if (!src.data)
{
return ;
}
for (int y = 0; y < src.rows; y++)
for (int x = 0; x < src.cols; x++)
dst.at<uchar>(y, x) = 0.0;
for (int y = 1; y < src.rows - 1; y++) {
for (int x = 1; x < src.cols - 1; x++) {
gx = xGradient(src, x, y);
gy = yGradient(src, x, y);
sum = abs(gx) + abs(gy);
sum = sum > 255 ? 255 : sum;
sum = sum < 0 ? 0 : sum;
dst.at<uchar>(y, x) = sum;
}
}
namedWindow("final");
imshow("final", dst);
namedWindow("initial");
imshow("initial", src);
waitKey(0);
}
void question12(Mat image) {
Mat src, src_gray, dst;
int kernel_size = 3;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
char* window_name = "Laplace Demo";
int c;
/// Load an image
src = image;
if (!src.data)
{
return ;
}
/// Remove noise by blurring with a Gaussian filter
//GaussianBlur(src, src, Size(3, 3), 0, 0, BORDER_DEFAULT);
/// Convert the image to grayscale
cvtColor(src, src_gray, CV_BGR2GRAY);
/// Create window
namedWindow(window_name, CV_WINDOW_AUTOSIZE);
/// Apply Laplace function
Mat abs_dst;
Laplacian(src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT);
convertScaleAbs(dst, abs_dst);
cout << image.channels();
cout << "\t" << abs_dst.channels();
/// Show what you got
GaussianBlur(abs_dst, abs_dst, Size(3, 3), 0, 0, BORDER_DEFAULT);
imshow(window_name, abs_dst);
waitKey(0);
}
void main() {
Mat image;
image = imread("C:/Users/siddartha/Pictures/test2.jpg");
if (image.empty()) {
cout << "Cannot load image";
system("pause");
return;
}
else {
cout << image.size();
//namedWindow("original");
//imshow("original", image);
//question1(image);
//question2(image);
//question3(image);
//question4(image);
//question5();
//question7a(image);
//question7b(image);
//question8(image);
//question9a(image);
//question9b(image);
//question10(image);
//prewitt(image);
//question12(image);
question14();
//waitKey(0);
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment