final

ora5/proj1/m2

@@ -0,0 +1,45 @@
+#include "histo.h"
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+#include <vector>
+
+using namespace cv;
+
+int main(){
+    Mat img = imread("../madar.jpg", IMREAD_COLOR);
+    imshow("img", img);
+
+    Histo::showHisto(img, "histo", 1);
+
+    std::vector<Mat> chs;
+    split(img, chs);
+
+    /*imshow("r", chs[2]);
+    imshow("g", chs[1]);
+    imshow("b", chs[0]);*/
+
+
+    Mat dest1, dest2, dest3, dest4, mask;
+
+    //dest1 = img > 100;
+    //threshold(img, dest2, 100, 255, THRESH_BINARY);
+    //threshold(img, dest3, 100, 255, THRESH_OTSU);
+    //threshold(img, dest4, 100, 255, THRESH_TRIANGLE);
+    
+    //medianBlur(dest1, dest1, 3);
+
+    threshold(chs[0], mask, 120, 255, THRESH_BINARY|cv::THRESH_OTSU);
+
+    img.copyTo(dest2, mask);
+
+
+    //imshow("dest1", dest1);
+    imshow("dest2", dest2);
+    //imshow("dest3", dest3);
+    //imshow("dest4", dest4);
+
+    while(waitKey(3) != 'q');
+    return 0;
+}

ora5/proj1/main.cpp

@@ -1,45 +1,75 @@
-#include "histo.h"
+#include <iostream>
+#include <vector>
 #include <opencv2/core.hpp>
 #include <opencv2/highgui.hpp>
 #include <opencv2/imgproc.hpp>
-#include <iostream>
-#include <vector>
 
+using namespace std;
 using namespace cv;
 
+void kordetektalo1(const Mat& gray, vector<Vec3f>& circles) {
+
+	int cannyTh = 60;  
+	int minPoints = 30; 
+	int minR = 22;  //K1: allitsd be
+	int maxR = 26;  //K1: allitsd be
+	int d = 2; 
+	int minDist = 10; 
+	
+	cv::HoughCircles(gray, circles, cv::HOUGH_GRADIENT, d, minDist, cannyTh, minPoints, minR, maxR);
+}
+
 int main(){
-    Mat img = imread("../madar.jpg", IMREAD_COLOR);
+	Mat img = imread("past.jpg", IMREAD_COLOR);
-    imshow("img", img);
+	if(img.empty()){
+	    return 1;
+	}
 	
-    Histo::showHisto(img, "histo", 1);
+    // 1. Konvertáld szürkeskálássá az img képet
-
+	Mat gray;
-    std::vector<Mat> chs;
+	cvtColor(img, gray, COLOR_BGR2GRAY);
-    split(img, chs);
+	imwrite("gray_stud.png", gray);
-
-    /*imshow("r", chs[2]);
-    imshow("g", chs[1]);
-    imshow("b", chs[0]);*/
 	
 	
-    Mat dest1, dest2, dest3, dest4, mask;
+	vector<Vec3f> circles; 
+	kordetektalo1(gray, circles);
 
-    //dest1 = img > 100;
+    // 2. Végezz mediánszűrés 11x11-es ablakmérettel.
-    //threshold(img, dest2, 100, 255, THRESH_BINARY);
+    Mat mb2;
-    //threshold(img, dest3, 100, 255, THRESH_OTSU);
+    medianBlur(img, mb2, 11);
-    //threshold(img, dest4, 100, 255, THRESH_TRIANGLE);
+    imwrite("filtered_stud.png", mb2);
 
-    //medianBlur(dest1, dest1, 3);
+	// 3. rajzold ki a detektált köröket az eredeti képre
+	// sugár: 6, szín: tiszta piros, vonalvastagság: FILLED
+    int radius = 6;
     
-    threshold(chs[0], mask, 120, 255, THRESH_BINARY|cv::THRESH_OTSU);
+    for (auto c : circles) {
+		int x = c[0];
+		int y = c[1];
+		circle(img, Point(x,y), radius, Scalar(0, 100, 100), 2, cv::LineTypes::FILLED);
+	}
     
-    img.copyTo(dest2, mask);
+    imwrite("result_stud.png", img);
 	
 
-    //imshow("dest1", dest1);
+	// 4. Határozd meg a körök középpontja alá eső pixelek 
-    imshow("dest2", dest2);
+	// KÉK komponensének átlagát a SZŰRT képen.  
-    //imshow("dest3", dest3);
+	double mean_v = 0;
-    //imshow("dest4", dest4);
+	vector<Mat> chs;
+	split(circles, chs); //bgr
+	int count = 0;
+	for(auto c : circles){
+	    int x = c[0];
+		int y = c[1];
+	    mean_v += img.at<uchar>(y,x);
+	}
+	mean_v /= circles.size();
+	
+	
+	// Jelenitsd meg az atlagot a standard kimeneten.
+	// cout << mean_v << endl;
+	
+	waitKey();
 
-    while(waitKey(3) != 'q');
     return 0;	
 }

ora7/.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-I/usr/include/opencv4, -std=c++17]

ora7/Makefile

@@ -0,0 +1,18 @@
+CXX = g++
+CXXFLAGS = -Wall -O2 `pkg-config --cflags opencv4`
+LIBS = `pkg-config --libs opencv4`
+
+SRC = $(wildcard *.cpp)
+OBJ = $(SRC:.cpp=.o)
+TARGET = main
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CXX) $(OBJ) -o $@ $(LIBS)
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(OBJ) $(TARGET)

ora7/main.cpp

@@ -0,0 +1,26 @@
+#include "histo.h"
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+
+using namespace cv;
+
+int main(){
+    Mat img = imread("dark_img.jpg", IMREAD_GRAYSCALE);
+    imshow("img", img);
+    Histo::showHisto(img);
+
+    double ah, fh;
+    minMaxLoc(img, &ah, &fh);
+
+    fh = 30;
+
+    Mat dest = (ah == fh) ? img.clone() : (img-ah) * 255 / (fh-ah);
+
+    imshow("dest", dest);
+    Histo::showHisto(dest, "eredmeny");
+
+    waitKey();
+    return 0;
+}

ora7/proj1/.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-I/usr/include/opencv4, -std=c++17]

ora7/proj1/Makefile

@@ -0,0 +1,18 @@
+CXX = g++
+CXXFLAGS = -Wall -O2 `pkg-config --cflags opencv4`
+LIBS = `pkg-config --libs opencv4`
+
+SRC = $(wildcard *.cpp)
+OBJ = $(SRC:.cpp=.o)
+TARGET = main
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CXX) $(OBJ) -o $@ $(LIBS)
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(OBJ) $(TARGET)

ora7/proj1/histo.cpp

@@ -0,0 +1,126 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+*/
+
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include "histo.h"
+
+using namespace std;
+using namespace cv;
+
+void Histo::calcHistoC1(const cv::Mat img, cv::Mat& histo) {
+	assert(img.type() == CV_8UC1);
+
+	// CV_32U nem letezik, ha de CV_16U-t (ushort) hasznalhatsz, ha akarsz.
+	histo = Mat::zeros(256, 1, CV_32S);
+	for (int i = 0; i < img.rows; i++)
+		for (int j = 0; j < img.cols; j++)
+			histo.at<int>(img.at<uchar>(i, j))++;
+}
+
+
+void Histo::calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo_vect) {
+	assert(img.type() == CV_8UC3);
+
+	vector<Mat> chs;
+	split(img.clone(), chs);
+
+	Mat h0, h1, h2;
+	Histo::calcHistoC1(chs[0], h0);
+	Histo::calcHistoC1(chs[1], h1);
+	Histo::calcHistoC1(chs[2], h2);
+
+	histo_vect.clear();
+	histo_vect.push_back(h0);
+	histo_vect.push_back(h1);
+	histo_vect.push_back(h2);
+}
+
+
+
+void Histo::drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel) {
+	assert(histo.type() == CV_32S);
+
+	int pad = 10;
+	canvas = Mat::zeros(200 + 2 * pad, 256 + 2 * pad, CV_8UC3);
+	
+	// a hisztogram alatti szurke sav rajzolasa 
+	for (int i = 0; i < 10; ++i) {  // 10 pixel vastag lesz, hogy jol latszodjon
+		for (int j = 0; j < 256; ++j) {
+			if (0 <= channel && channel <= 2) {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad)[channel] = j;
+			}
+			else {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad) = Vec3b(j, j, j);
+			}
+		}
+	}
+	
+
+	Vec3b color(255, 255, 255);
+	if (0 <= channel && channel <= 2) {
+		color = Vec3b(0, 0, 0);
+		color[channel] = 255;
+	}
+
+
+	double minv, maxv;
+	minMaxLoc(histo, &minv, &maxv);
+	
+	double scale = 200 / maxv;  // az ablak magassagahoz igazitom a hisztogram magassagat
+
+	// a hisztogram rajzolasa
+	for (int i = 0; i < 256; ++i) {
+		// egy oszlop magassage (a line(Point(0, 0), Point(0, 1)) 2 pixelt rajzolna, ezert a -1)
+		int v = int(histo.at<int>(i) * scale) - 1; 
+		// canvas.rows-2-pad oldja meg, hogy a szurke sav felett kezdjuk a rajzolast
+		if (v >= 0)
+			line(canvas, Point(pad + i, canvas.rows - 2 - v - pad), Point(pad + i, canvas.rows - 2 - pad), color);
+	}
+}
+
+
+void Histo::drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases) {
+	assert(histos.size() == 3 && 
+		   histos[0].type() == CV_32S && histos[1].type() == CV_32S && histos[2].type() == CV_32S);
+
+	canvases.clear();
+	for (int i = 0; i <= 2; ++i) {
+		Mat canvas;
+		Histo::drawHistoC1(histos[i], canvas, i);
+		canvases.push_back(canvas.clone());
+	}
+}
+
+
+void Histo::showHisto(Mat img, string title, int wait) {
+	assert(img.type() == CV_8UC1 || img.type() == CV_8UC3);
+
+	if (img.type() == CV_8UC1) {
+		Mat histo;
+		Histo::calcHistoC1(img, histo);
+
+		// az ertekek konzolra iratasa
+		//cout << histo << endl;
+
+		Mat canvas;
+		Histo::drawHistoC1(histo, canvas);
+		imshow(title, canvas);
+	}
+	else if (img.type() == CV_8UC3) {
+		vector<Mat> histos;
+		Histo::calcHistoC3(img, histos);
+
+		vector<Mat> canvases;
+		Histo::drawHistoC3(histos, canvases);
+
+		string str = "BGR";
+		for (int i = 0; i <= 2; ++i) {
+			imshow(title + "-" + str[i], canvases[i]);
+		}
+	}
+	waitKey(wait);
+}

ora7/proj1/histo.h

@@ -0,0 +1,32 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+   1 es 3 csatornas, csatornankent 8 bites kepekre:
+   Histo::showHisto(img);
+*/
+#ifndef HISTO_H_
+#define HISTO_H_
+
+#include <vector>
+#include <opencv2/core.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace Histo {
+	void calcHistoC1(const cv::Mat img, cv::Mat& histo);
+	void calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo);
+
+	void drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel = -1);
+	void drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases);
+
+	/// <summary>
+	/// Egy kep hisztogramjanak megjelenitese. 
+	/// </summary>
+	/// <param name="img">1 vagy 3 csatornas input kep</param>
+	/// <param name="title">ablaknev</param>
+	/// <param name="wait">varakoztatas</param>
+	void showHisto(Mat img, string title = "histo", int wait = 0);
+};
+
+
+#endif HISTO_H_

ora7/proj1/main.cpp

@@ -0,0 +1,30 @@
+#include "histo.h"
+#include "opencv2/core/types.hpp"
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+
+using namespace cv;
+
+int main(){
+    Mat img = imread("../sajt.png", IMREAD_COLOR);
+    Mat gray, mask;
+    cvtColor(img, gray, COLOR_BGR2GRAY);
+    threshold(gray, mask, 250, 255, THRESH_BINARY_INV);
+    medianBlur(mask, mask, 3);
+
+    std::vector<std::vector<Point>> contours;
+    findContours(mask, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);
+
+    for(int i = 0; i < contours.size(); i++){
+        drawContours(img, contours, i, Scalar(0,0,255), 2);
+        imshow("img", img);
+        waitKey();
+    }
+
+    imshow("mask", mask);
+
+    while(waitKey(3) != 'q');
+    return 0;
+}

ora7/proj2/.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-I/usr/include/opencv4, -std=c++17]

ora7/proj2/Makefile

@@ -0,0 +1,18 @@
+CXX = g++
+CXXFLAGS = -Wall -O2 `pkg-config --cflags opencv4`
+LIBS = `pkg-config --libs opencv4`
+
+SRC = $(wildcard *.cpp)
+OBJ = $(SRC:.cpp=.o)
+TARGET = main
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CXX) $(OBJ) -o $@ $(LIBS)
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(OBJ) $(TARGET)

ora7/proj2/histo.cpp

@@ -0,0 +1,126 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+*/
+
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include "histo.h"
+
+using namespace std;
+using namespace cv;
+
+void Histo::calcHistoC1(const cv::Mat img, cv::Mat& histo) {
+	assert(img.type() == CV_8UC1);
+
+	// CV_32U nem letezik, ha de CV_16U-t (ushort) hasznalhatsz, ha akarsz.
+	histo = Mat::zeros(256, 1, CV_32S);
+	for (int i = 0; i < img.rows; i++)
+		for (int j = 0; j < img.cols; j++)
+			histo.at<int>(img.at<uchar>(i, j))++;
+}
+
+
+void Histo::calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo_vect) {
+	assert(img.type() == CV_8UC3);
+
+	vector<Mat> chs;
+	split(img.clone(), chs);
+
+	Mat h0, h1, h2;
+	Histo::calcHistoC1(chs[0], h0);
+	Histo::calcHistoC1(chs[1], h1);
+	Histo::calcHistoC1(chs[2], h2);
+
+	histo_vect.clear();
+	histo_vect.push_back(h0);
+	histo_vect.push_back(h1);
+	histo_vect.push_back(h2);
+}
+
+
+
+void Histo::drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel) {
+	assert(histo.type() == CV_32S);
+
+	int pad = 10;
+	canvas = Mat::zeros(200 + 2 * pad, 256 + 2 * pad, CV_8UC3);
+	
+	// a hisztogram alatti szurke sav rajzolasa 
+	for (int i = 0; i < 10; ++i) {  // 10 pixel vastag lesz, hogy jol latszodjon
+		for (int j = 0; j < 256; ++j) {
+			if (0 <= channel && channel <= 2) {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad)[channel] = j;
+			}
+			else {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad) = Vec3b(j, j, j);
+			}
+		}
+	}
+	
+
+	Vec3b color(255, 255, 255);
+	if (0 <= channel && channel <= 2) {
+		color = Vec3b(0, 0, 0);
+		color[channel] = 255;
+	}
+
+
+	double minv, maxv;
+	minMaxLoc(histo, &minv, &maxv);
+	
+	double scale = 200 / maxv;  // az ablak magassagahoz igazitom a hisztogram magassagat
+
+	// a hisztogram rajzolasa
+	for (int i = 0; i < 256; ++i) {
+		// egy oszlop magassage (a line(Point(0, 0), Point(0, 1)) 2 pixelt rajzolna, ezert a -1)
+		int v = int(histo.at<int>(i) * scale) - 1; 
+		// canvas.rows-2-pad oldja meg, hogy a szurke sav felett kezdjuk a rajzolast
+		if (v >= 0)
+			line(canvas, Point(pad + i, canvas.rows - 2 - v - pad), Point(pad + i, canvas.rows - 2 - pad), color);
+	}
+}
+
+
+void Histo::drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases) {
+	assert(histos.size() == 3 && 
+		   histos[0].type() == CV_32S && histos[1].type() == CV_32S && histos[2].type() == CV_32S);
+
+	canvases.clear();
+	for (int i = 0; i <= 2; ++i) {
+		Mat canvas;
+		Histo::drawHistoC1(histos[i], canvas, i);
+		canvases.push_back(canvas.clone());
+	}
+}
+
+
+void Histo::showHisto(Mat img, string title, int wait) {
+	assert(img.type() == CV_8UC1 || img.type() == CV_8UC3);
+
+	if (img.type() == CV_8UC1) {
+		Mat histo;
+		Histo::calcHistoC1(img, histo);
+
+		// az ertekek konzolra iratasa
+		//cout << histo << endl;
+
+		Mat canvas;
+		Histo::drawHistoC1(histo, canvas);
+		imshow(title, canvas);
+	}
+	else if (img.type() == CV_8UC3) {
+		vector<Mat> histos;
+		Histo::calcHistoC3(img, histos);
+
+		vector<Mat> canvases;
+		Histo::drawHistoC3(histos, canvases);
+
+		string str = "BGR";
+		for (int i = 0; i <= 2; ++i) {
+			imshow(title + "-" + str[i], canvases[i]);
+		}
+	}
+	waitKey(wait);
+}

ora7/proj2/histo.h

@@ -0,0 +1,32 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+   1 es 3 csatornas, csatornankent 8 bites kepekre:
+   Histo::showHisto(img);
+*/
+#ifndef HISTO_H_
+#define HISTO_H_
+
+#include <vector>
+#include <opencv2/core.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace Histo {
+	void calcHistoC1(const cv::Mat img, cv::Mat& histo);
+	void calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo);
+
+	void drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel = -1);
+	void drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases);
+
+	/// <summary>
+	/// Egy kep hisztogramjanak megjelenitese. 
+	/// </summary>
+	/// <param name="img">1 vagy 3 csatornas input kep</param>
+	/// <param name="title">ablaknev</param>
+	/// <param name="wait">varakoztatas</param>
+	void showHisto(Mat img, string title = "histo", int wait = 0);
+};
+
+
+#endif HISTO_H_

ora7/proj2/main.cpp

@@ -0,0 +1,30 @@
+#include "histo.h"
+#include "opencv2/core/types.hpp"
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+
+using namespace cv;
+
+int main(){
+    Mat img = imread("../dog.jpg", IMREAD_COLOR);
+    Mat gray, mask;
+    cvtColor(img, gray, COLOR_BGR2GRAY);
+    threshold(gray, mask, 120, 255, THRESH_BINARY);
+
+    std::vector<std::vector<Point>> contours;
+    findContours(mask, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);
+
+    for(int i = 0; i < contours.size(); i++){
+        if(contours[i].size() > 500){
+            drawContours(img, contours, i, Scalar(0,0,255), 2);
+        }
+        waitKey();
+    }
+
+    imshow("img", img);
+
+    while(waitKey(3) != 'q');
+    return 0;
+}

ora7/proj3/.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-I/usr/include/opencv4, -std=c++17]

ora7/proj3/Makefile

@@ -0,0 +1,18 @@
+CXX = g++
+CXXFLAGS = -Wall -O2 `pkg-config --cflags opencv4`
+LIBS = `pkg-config --libs opencv4`
+
+SRC = $(wildcard *.cpp)
+OBJ = $(SRC:.cpp=.o)
+TARGET = main
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CXX) $(OBJ) -o $@ $(LIBS)
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(OBJ) $(TARGET)

ora7/proj3/histo.cpp

@@ -0,0 +1,126 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+*/
+
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include "histo.h"
+
+using namespace std;
+using namespace cv;
+
+void Histo::calcHistoC1(const cv::Mat img, cv::Mat& histo) {
+	assert(img.type() == CV_8UC1);
+
+	// CV_32U nem letezik, ha de CV_16U-t (ushort) hasznalhatsz, ha akarsz.
+	histo = Mat::zeros(256, 1, CV_32S);
+	for (int i = 0; i < img.rows; i++)
+		for (int j = 0; j < img.cols; j++)
+			histo.at<int>(img.at<uchar>(i, j))++;
+}
+
+
+void Histo::calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo_vect) {
+	assert(img.type() == CV_8UC3);
+
+	vector<Mat> chs;
+	split(img.clone(), chs);
+
+	Mat h0, h1, h2;
+	Histo::calcHistoC1(chs[0], h0);
+	Histo::calcHistoC1(chs[1], h1);
+	Histo::calcHistoC1(chs[2], h2);
+
+	histo_vect.clear();
+	histo_vect.push_back(h0);
+	histo_vect.push_back(h1);
+	histo_vect.push_back(h2);
+}
+
+
+
+void Histo::drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel) {
+	assert(histo.type() == CV_32S);
+
+	int pad = 10;
+	canvas = Mat::zeros(200 + 2 * pad, 256 + 2 * pad, CV_8UC3);
+	
+	// a hisztogram alatti szurke sav rajzolasa 
+	for (int i = 0; i < 10; ++i) {  // 10 pixel vastag lesz, hogy jol latszodjon
+		for (int j = 0; j < 256; ++j) {
+			if (0 <= channel && channel <= 2) {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad)[channel] = j;
+			}
+			else {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad) = Vec3b(j, j, j);
+			}
+		}
+	}
+	
+
+	Vec3b color(255, 255, 255);
+	if (0 <= channel && channel <= 2) {
+		color = Vec3b(0, 0, 0);
+		color[channel] = 255;
+	}
+
+
+	double minv, maxv;
+	minMaxLoc(histo, &minv, &maxv);
+	
+	double scale = 200 / maxv;  // az ablak magassagahoz igazitom a hisztogram magassagat
+
+	// a hisztogram rajzolasa
+	for (int i = 0; i < 256; ++i) {
+		// egy oszlop magassage (a line(Point(0, 0), Point(0, 1)) 2 pixelt rajzolna, ezert a -1)
+		int v = int(histo.at<int>(i) * scale) - 1; 
+		// canvas.rows-2-pad oldja meg, hogy a szurke sav felett kezdjuk a rajzolast
+		if (v >= 0)
+			line(canvas, Point(pad + i, canvas.rows - 2 - v - pad), Point(pad + i, canvas.rows - 2 - pad), color);
+	}
+}
+
+
+void Histo::drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases) {
+	assert(histos.size() == 3 && 
+		   histos[0].type() == CV_32S && histos[1].type() == CV_32S && histos[2].type() == CV_32S);
+
+	canvases.clear();
+	for (int i = 0; i <= 2; ++i) {
+		Mat canvas;
+		Histo::drawHistoC1(histos[i], canvas, i);
+		canvases.push_back(canvas.clone());
+	}
+}
+
+
+void Histo::showHisto(Mat img, string title, int wait) {
+	assert(img.type() == CV_8UC1 || img.type() == CV_8UC3);
+
+	if (img.type() == CV_8UC1) {
+		Mat histo;
+		Histo::calcHistoC1(img, histo);
+
+		// az ertekek konzolra iratasa
+		//cout << histo << endl;
+
+		Mat canvas;
+		Histo::drawHistoC1(histo, canvas);
+		imshow(title, canvas);
+	}
+	else if (img.type() == CV_8UC3) {
+		vector<Mat> histos;
+		Histo::calcHistoC3(img, histos);
+
+		vector<Mat> canvases;
+		Histo::drawHistoC3(histos, canvases);
+
+		string str = "BGR";
+		for (int i = 0; i <= 2; ++i) {
+			imshow(title + "-" + str[i], canvases[i]);
+		}
+	}
+	waitKey(wait);
+}

ora7/proj3/histo.h

@@ -0,0 +1,32 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+   1 es 3 csatornas, csatornankent 8 bites kepekre:
+   Histo::showHisto(img);
+*/
+#ifndef HISTO_H_
+#define HISTO_H_
+
+#include <vector>
+#include <opencv2/core.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace Histo {
+	void calcHistoC1(const cv::Mat img, cv::Mat& histo);
+	void calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo);
+
+	void drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel = -1);
+	void drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases);
+
+	/// <summary>
+	/// Egy kep hisztogramjanak megjelenitese. 
+	/// </summary>
+	/// <param name="img">1 vagy 3 csatornas input kep</param>
+	/// <param name="title">ablaknev</param>
+	/// <param name="wait">varakoztatas</param>
+	void showHisto(Mat img, string title = "histo", int wait = 0);
+};
+
+
+#endif HISTO_H_

ora7/proj3/main.cpp

@@ -0,0 +1,34 @@
+#include "histo.h"
+#include "opencv2/core/types.hpp"
+#include <cassert>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+
+using namespace cv;
+
+int main(){
+    Mat img = imread("../kincseslada.png", IMREAD_COLOR);
+    Mat gray, mask;
+    cvtColor(img, gray, COLOR_BGR2GRAY);
+    threshold(gray, mask, 230, 255, THRESH_BINARY_INV);
+    medianBlur(mask, mask, 5);
+
+
+    std::vector<std::vector<Point>> contours;
+    findContours(mask, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);
+
+    assert(contours.size() == 2);
+
+    if(contours[0].size() > contours[1].size()){
+        drawContours(img, contours, 0, Scalar(0,0,255), 2);
+    }else{
+        drawContours(img, contours, 1, Scalar(0,0,255), 2);
+    }
+
+    imshow("img", img);
+
+    while(waitKey(3) != 'q');
+    return 0;
+}

ora7/proj4/.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-I/usr/include/opencv4, -std=c++17]

ora7/proj4/Makefile

@@ -0,0 +1,18 @@
+CXX = g++
+CXXFLAGS = -Wall -O2 `pkg-config --cflags opencv4`
+LIBS = `pkg-config --libs opencv4`
+
+SRC = $(wildcard *.cpp)
+OBJ = $(SRC:.cpp=.o)
+TARGET = main
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CXX) $(OBJ) -o $@ $(LIBS)
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(OBJ) $(TARGET)

ora7/proj4/histo.cpp

@@ -0,0 +1,126 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+*/
+
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include "histo.h"
+
+using namespace std;
+using namespace cv;
+
+void Histo::calcHistoC1(const cv::Mat img, cv::Mat& histo) {
+	assert(img.type() == CV_8UC1);
+
+	// CV_32U nem letezik, ha de CV_16U-t (ushort) hasznalhatsz, ha akarsz.
+	histo = Mat::zeros(256, 1, CV_32S);
+	for (int i = 0; i < img.rows; i++)
+		for (int j = 0; j < img.cols; j++)
+			histo.at<int>(img.at<uchar>(i, j))++;
+}
+
+
+void Histo::calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo_vect) {
+	assert(img.type() == CV_8UC3);
+
+	vector<Mat> chs;
+	split(img.clone(), chs);
+
+	Mat h0, h1, h2;
+	Histo::calcHistoC1(chs[0], h0);
+	Histo::calcHistoC1(chs[1], h1);
+	Histo::calcHistoC1(chs[2], h2);
+
+	histo_vect.clear();
+	histo_vect.push_back(h0);
+	histo_vect.push_back(h1);
+	histo_vect.push_back(h2);
+}
+
+
+
+void Histo::drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel) {
+	assert(histo.type() == CV_32S);
+
+	int pad = 10;
+	canvas = Mat::zeros(200 + 2 * pad, 256 + 2 * pad, CV_8UC3);
+	
+	// a hisztogram alatti szurke sav rajzolasa 
+	for (int i = 0; i < 10; ++i) {  // 10 pixel vastag lesz, hogy jol latszodjon
+		for (int j = 0; j < 256; ++j) {
+			if (0 <= channel && channel <= 2) {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad)[channel] = j;
+			}
+			else {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad) = Vec3b(j, j, j);
+			}
+		}
+	}
+	
+
+	Vec3b color(255, 255, 255);
+	if (0 <= channel && channel <= 2) {
+		color = Vec3b(0, 0, 0);
+		color[channel] = 255;
+	}
+
+
+	double minv, maxv;
+	minMaxLoc(histo, &minv, &maxv);
+	
+	double scale = 200 / maxv;  // az ablak magassagahoz igazitom a hisztogram magassagat
+
+	// a hisztogram rajzolasa
+	for (int i = 0; i < 256; ++i) {
+		// egy oszlop magassage (a line(Point(0, 0), Point(0, 1)) 2 pixelt rajzolna, ezert a -1)
+		int v = int(histo.at<int>(i) * scale) - 1; 
+		// canvas.rows-2-pad oldja meg, hogy a szurke sav felett kezdjuk a rajzolast
+		if (v >= 0)
+			line(canvas, Point(pad + i, canvas.rows - 2 - v - pad), Point(pad + i, canvas.rows - 2 - pad), color);
+	}
+}
+
+
+void Histo::drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases) {
+	assert(histos.size() == 3 && 
+		   histos[0].type() == CV_32S && histos[1].type() == CV_32S && histos[2].type() == CV_32S);
+
+	canvases.clear();
+	for (int i = 0; i <= 2; ++i) {
+		Mat canvas;
+		Histo::drawHistoC1(histos[i], canvas, i);
+		canvases.push_back(canvas.clone());
+	}
+}
+
+
+void Histo::showHisto(Mat img, string title, int wait) {
+	assert(img.type() == CV_8UC1 || img.type() == CV_8UC3);
+
+	if (img.type() == CV_8UC1) {
+		Mat histo;
+		Histo::calcHistoC1(img, histo);
+
+		// az ertekek konzolra iratasa
+		//cout << histo << endl;
+
+		Mat canvas;
+		Histo::drawHistoC1(histo, canvas);
+		imshow(title, canvas);
+	}
+	else if (img.type() == CV_8UC3) {
+		vector<Mat> histos;
+		Histo::calcHistoC3(img, histos);
+
+		vector<Mat> canvases;
+		Histo::drawHistoC3(histos, canvases);
+
+		string str = "BGR";
+		for (int i = 0; i <= 2; ++i) {
+			imshow(title + "-" + str[i], canvases[i]);
+		}
+	}
+	waitKey(wait);
+}

ora7/proj4/histo.h

@@ -0,0 +1,32 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+   1 es 3 csatornas, csatornankent 8 bites kepekre:
+   Histo::showHisto(img);
+*/
+#ifndef HISTO_H_
+#define HISTO_H_
+
+#include <vector>
+#include <opencv2/core.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace Histo {
+	void calcHistoC1(const cv::Mat img, cv::Mat& histo);
+	void calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo);
+
+	void drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel = -1);
+	void drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases);
+
+	/// <summary>
+	/// Egy kep hisztogramjanak megjelenitese. 
+	/// </summary>
+	/// <param name="img">1 vagy 3 csatornas input kep</param>
+	/// <param name="title">ablaknev</param>
+	/// <param name="wait">varakoztatas</param>
+	void showHisto(Mat img, string title = "histo", int wait = 0);
+};
+
+
+#endif HISTO_H_

ora7/proj4/main.cpp

@@ -0,0 +1,42 @@
+#include "histo.h"
+#include "opencv2/core/types.hpp"
+#include <cassert>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace cv;
+
+int main(){
+    Mat img = imread("../some_objects.png", IMREAD_COLOR);
+    Mat gray, mask;
+    cvtColor(img, gray, COLOR_BGR2GRAY);
+    threshold(gray, mask, 230, 255, THRESH_BINARY);
+
+    std::vector<std::vector<Point>> contours;
+    findContours(mask, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);
+
+    for(int i = 0; i < contours.size(); i++){
+        Mat canvas = img.clone();
+        for(int j = 0; j < i; j++){
+            double d = matchShapes(contours[i], contours[j], CONTOURS_MATCH_I2, 0);
+        
+            std::string s = to_string(d);
+
+            drawContours(canvas, contours, i, Scalar(0,0,255), 2);
+            drawContours(canvas, contours, j, Scalar(0,0,255), 2);
+
+            line(canvas, contours[i][0], contours[j][0], Scalar(100,100,100), 2);
+        
+            putText(canvas, s, contours[j][0], FONT_HERSHEY_PLAIN, 1.5, Scalar(255, 255, 255));
+        }
+    }
+
+    imshow("img", img);
+
+    while(waitKey(3) != 'q');
+    return 0;
+}

ora7/proj5/.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-I/usr/include/opencv4, -std=c++17]

ora7/proj5/Makefile

@@ -0,0 +1,18 @@
+CXX = g++
+CXXFLAGS = -Wall -O2 `pkg-config --cflags opencv4`
+LIBS = `pkg-config --libs opencv4`
+
+SRC = $(wildcard *.cpp)
+OBJ = $(SRC:.cpp=.o)
+TARGET = main
+
+all: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CXX) $(OBJ) -o $@ $(LIBS)
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(OBJ) $(TARGET)

ora7/proj5/histo.cpp

@@ -0,0 +1,126 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+*/
+
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include "histo.h"
+
+using namespace std;
+using namespace cv;
+
+void Histo::calcHistoC1(const cv::Mat img, cv::Mat& histo) {
+	assert(img.type() == CV_8UC1);
+
+	// CV_32U nem letezik, ha de CV_16U-t (ushort) hasznalhatsz, ha akarsz.
+	histo = Mat::zeros(256, 1, CV_32S);
+	for (int i = 0; i < img.rows; i++)
+		for (int j = 0; j < img.cols; j++)
+			histo.at<int>(img.at<uchar>(i, j))++;
+}
+
+
+void Histo::calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo_vect) {
+	assert(img.type() == CV_8UC3);
+
+	vector<Mat> chs;
+	split(img.clone(), chs);
+
+	Mat h0, h1, h2;
+	Histo::calcHistoC1(chs[0], h0);
+	Histo::calcHistoC1(chs[1], h1);
+	Histo::calcHistoC1(chs[2], h2);
+
+	histo_vect.clear();
+	histo_vect.push_back(h0);
+	histo_vect.push_back(h1);
+	histo_vect.push_back(h2);
+}
+
+
+
+void Histo::drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel) {
+	assert(histo.type() == CV_32S);
+
+	int pad = 10;
+	canvas = Mat::zeros(200 + 2 * pad, 256 + 2 * pad, CV_8UC3);
+	
+	// a hisztogram alatti szurke sav rajzolasa 
+	for (int i = 0; i < 10; ++i) {  // 10 pixel vastag lesz, hogy jol latszodjon
+		for (int j = 0; j < 256; ++j) {
+			if (0 <= channel && channel <= 2) {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad)[channel] = j;
+			}
+			else {
+				canvas.at<Vec3b>(canvas.rows - 1 - i, j + pad) = Vec3b(j, j, j);
+			}
+		}
+	}
+	
+
+	Vec3b color(255, 255, 255);
+	if (0 <= channel && channel <= 2) {
+		color = Vec3b(0, 0, 0);
+		color[channel] = 255;
+	}
+
+
+	double minv, maxv;
+	minMaxLoc(histo, &minv, &maxv);
+	
+	double scale = 200 / maxv;  // az ablak magassagahoz igazitom a hisztogram magassagat
+
+	// a hisztogram rajzolasa
+	for (int i = 0; i < 256; ++i) {
+		// egy oszlop magassage (a line(Point(0, 0), Point(0, 1)) 2 pixelt rajzolna, ezert a -1)
+		int v = int(histo.at<int>(i) * scale) - 1; 
+		// canvas.rows-2-pad oldja meg, hogy a szurke sav felett kezdjuk a rajzolast
+		if (v >= 0)
+			line(canvas, Point(pad + i, canvas.rows - 2 - v - pad), Point(pad + i, canvas.rows - 2 - pad), color);
+	}
+}
+
+
+void Histo::drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases) {
+	assert(histos.size() == 3 && 
+		   histos[0].type() == CV_32S && histos[1].type() == CV_32S && histos[2].type() == CV_32S);
+
+	canvases.clear();
+	for (int i = 0; i <= 2; ++i) {
+		Mat canvas;
+		Histo::drawHistoC1(histos[i], canvas, i);
+		canvases.push_back(canvas.clone());
+	}
+}
+
+
+void Histo::showHisto(Mat img, string title, int wait) {
+	assert(img.type() == CV_8UC1 || img.type() == CV_8UC3);
+
+	if (img.type() == CV_8UC1) {
+		Mat histo;
+		Histo::calcHistoC1(img, histo);
+
+		// az ertekek konzolra iratasa
+		//cout << histo << endl;
+
+		Mat canvas;
+		Histo::drawHistoC1(histo, canvas);
+		imshow(title, canvas);
+	}
+	else if (img.type() == CV_8UC3) {
+		vector<Mat> histos;
+		Histo::calcHistoC3(img, histos);
+
+		vector<Mat> canvases;
+		Histo::drawHistoC3(histos, canvases);
+
+		string str = "BGR";
+		for (int i = 0; i <= 2; ++i) {
+			imshow(title + "-" + str[i], canvases[i]);
+		}
+	}
+	waitKey(wait);
+}

ora7/proj5/histo.h

@@ -0,0 +1,32 @@
+/*
+Kepfeld. gyak. - nehany segedfuggveny az orai anyag konnyebb szemleltetesehez.
+   1 es 3 csatornas, csatornankent 8 bites kepekre:
+   Histo::showHisto(img);
+*/
+#ifndef HISTO_H_
+#define HISTO_H_
+
+#include <vector>
+#include <opencv2/core.hpp>
+
+using namespace std;
+using namespace cv;
+
+namespace Histo {
+	void calcHistoC1(const cv::Mat img, cv::Mat& histo);
+	void calcHistoC3(const cv::Mat img, vector<cv::Mat>& histo);
+
+	void drawHistoC1(const cv::Mat histo, cv::Mat& canvas, int channel = -1);
+	void drawHistoC3(const vector<cv::Mat> histos, vector<cv::Mat>& canvases);
+
+	/// <summary>
+	/// Egy kep hisztogramjanak megjelenitese. 
+	/// </summary>
+	/// <param name="img">1 vagy 3 csatornas input kep</param>
+	/// <param name="title">ablaknev</param>
+	/// <param name="wait">varakoztatas</param>
+	void showHisto(Mat img, string title = "histo", int wait = 0);
+};
+
+
+#endif HISTO_H_

ora7/proj5/main.cpp

@@ -0,0 +1,42 @@
+#include "histo.h"
+#include "opencv2/core/types.hpp"
+#include <cassert>
+#include <opencv2/core.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+#include <string>
+#include <vector>
+
+using namespace cv;
+
+int main(){
+    Mat img = imread("../some_objects.png", IMREAD_COLOR);
+    Mat gray, mask;
+    cvtColor(img, gray, COLOR_BGR2GRAY);
+    threshold(gray, mask, 230, 255, THRESH_BINARY);
+
+    std::vector<std::vector<Point>> contours;
+    findContours(mask, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);
+
+    for(int i = 0; i < contours.size(); i++){
+        Mat canvas = img.clone();
+        for(int j = 0; j < i; j++){
+            double d = matchShapes(contours[i], contours[j], CONTOURS_MATCH_I2, 0);
+        
+            std::string s = to_string(d);
+
+            drawContours(canvas, contours, i, Scalar(0,0,255), 2);
+            drawContours(canvas, contours, j, Scalar(0,0,255), 2);
+
+            line(canvas, contours[i][0], contours[j][0], Scalar(100,100,100), 2);
+        
+            putText(canvas, s, contours[j][0], FONT_HERSHEY_PLAIN, 1.5, Scalar(255, 255, 255));
+        }
+    }
+
+    imshow("img", img);
+
+    while(waitKey(3) != 'q');
+    return 0;
+}