EDLines

opencv-example/.vscode/launch.json

@@ -29,6 +29,19 @@
             "console": "internalConsole"
             // "console": "externalTerminal"
         }
+        ,
+        {
+            "name": "kmeans",
+            "type": "cppvsdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/build/Debug/kmeans.exe",
+            "args": ["F:\\datas\\images\\Image_0052.bmp"],
+            "stopAtEntry": false,
+            "cwd": "${fileDirname}",
+            "environment": [],
+            "console": "internalConsole"
+            // "console": "externalTerminal"
+        }
 
     ]
 }
\ No newline at end of file

opencv-example/CMakeLists.txt

@@ -3,10 +3,13 @@ project(opencv_example)
 
 set(CMAKE_CXX_STANDARD 17)
 
-set(OpenCV_DIR "d:/dev/opencv/4.7.0-msvc")
+set(OpenCV_DIR "D:\\dev\\OpenCV\\4.7.0-msvc\\x64\\vc16\\lib")
 find_package(OpenCV)
 
 include_directories(${OpenCV_INCLUDE_DIRS})
+
+# message(---- ${OpenCV_INCLUDE_DIRS})
+
 add_executable(imageSegmentation imageSegmentation.cpp)
 target_link_libraries(imageSegmentation ${OpenCV_LIBRARIES})
 
@@ -22,3 +25,9 @@ add_executable(videotool videotool.cpp)
 target_link_libraries(videotool ${OpenCV_LIBRARIES})
 # target_link_libraries(videotool )
 
+# add_executable(kmeans kmeans.cpp)
+# target_link_libraries(kmeans ${OpenCV_LIBRARIES})
+
+add_subdirectory(opencv_EdgeDrawLines)
+
+

opencv-example/kmeans_rand.cpp

+#include "opencv2/highgui.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+
+int main( int argc, char** argv )
+{
+    const int MAX_CLUSTERS = 5;
+    Scalar colorTab[] =
+    {
+        Scalar(0, 0, 255),
+        Scalar(0,255,0),
+        Scalar(255,100,100),
+        Scalar(255,0,255),
+        Scalar(0,255,255)
+    };
+
+    Mat img(500, 500, CV_8UC3);
+    RNG rng(12345);
+
+    for(;;)
+    {
+        int k, clusterCount = rng.uniform(2, MAX_CLUSTERS+1);
+        int i, sampleCount = rng.uniform(1, 1001);
+        Mat points(sampleCount, 1, CV_32FC2), labels;
+
+        clusterCount = MIN(clusterCount, sampleCount);
+        std::vector<Point2f> centers;
+
+        /* generate random sample from multigaussian distribution */
+        for( k = 0; k < clusterCount; k++ )
+        {
+            Point center;
+            center.x = rng.uniform(0, img.cols);
+            center.y = rng.uniform(0, img.rows);
+            Mat pointChunk = points.rowRange(k*sampleCount/clusterCount,
+                                             k == clusterCount - 1 ? sampleCount :
+                                             (k+1)*sampleCount/clusterCount);
+            rng.fill(pointChunk, RNG::NORMAL, Scalar(center.x, center.y), Scalar(img.cols*0.05, img.rows*0.05));
+        }
+
+        randShuffle(points, 1, &rng);
+
+        double compactness = kmeans(points, clusterCount, labels,
+            TermCriteria( TermCriteria::EPS+TermCriteria::COUNT, 10, 1.0),
+               3, KMEANS_PP_CENTERS, centers);
+
+        img = Scalar::all(0);
+
+        for( i = 0; i < sampleCount; i++ )
+        {
+            int clusterIdx = labels.at<int>(i);
+            Point ipt = points.at<Point2f>(i);
+            circle( img, ipt, 2, colorTab[clusterIdx], FILLED, LINE_AA );
+        }
+        for (i = 0; i < (int)centers.size(); ++i)
+        {
+            Point2f c = centers[i];
+            circle( img, c, 40, colorTab[i], 1, LINE_AA );
+        }
+        cout << "Compactness: " << compactness << endl;
+
+        imshow("clusters", img);
+
+        char key = (char)waitKey();
+        if( key == 27 || key == 'q' || key == 'Q' ) // 'ESC'
+            break;
+    }
+
+    return 0;
+}

opencv-example/opencv_EdgeDrawLines/CMakeLists.txt

+
+add_executable(EDLines EDLines.cpp main.cpp)
+target_link_libraries(EDLines ${OpenCV_LIBRARIES})
\ No newline at end of file

opencv-example/opencv_EdgeDrawLines/EDLines.h

+#include <opencv2/opencv.hpp>
+
+#define SS 0
+#define SE 1
+#define ES 2
+#define EE 3
+
+#define EDGE_VERTICAL   1
+#define EDGE_HORIZONTAL 2
+
+#define ANCHOR_PIXEL  254
+#define EDGE_PIXEL    255
+
+#define LEFT  1
+#define RIGHT 2
+#define UP    3
+#define DOWN  4
+
+enum GradientOperator { PREWITT_OPERATOR = 101, SOBEL_OPERATOR = 102, SCHARR_OPERATOR = 103 };
+
+struct StackNode {
+	int r, c;   // начальный пиксел
+	int parent; // родитель (-1 если нету)
+	int dir;    // направление
+};
+
+// для соединения граней
+struct Chain {
+
+	int dir;                   // направление цепочки
+	int len;                   // кол-во пикселей в цепи
+	int parent;                // родитель (-1 если нету)
+	int children[2];           // дети (-1 если нету)
+	cv::Point *pixels;         // указатель на начало массива пикселей
+};
+
+
+
+
+struct LS {
+    cv::Point2d start;
+    cv::Point2d end;
+    
+    LS(cv::Point2d _start, cv::Point2d _end)
+    {
+        start = _start;
+        end = _end;
+    }
+};
+
+
+struct LineSegment {
+    double a, b;     
+    int invert;
+    
+    double sx, sy;        // начало
+    double ex, ey;        // конец
+    
+    int segmentNo;        // сегмент которому принадлежит отрезок
+    int firstPixelIndex;  // индекс первого пикселя в сегменте
+    int len;              // длина в пикселях
+    
+    LineSegment(double _a, double _b, int _invert, double _sx, double _sy, double _ex, double _ey, int _segmentNo, int _firstPixelIndex, int _len) {
+        a = _a;
+        b = _b;
+        invert = _invert;
+        sx = _sx;
+        sy = _sy;
+        ex = _ex;
+        ey = _ey;
+        segmentNo = _segmentNo;
+        firstPixelIndex = _firstPixelIndex;
+        len = _len;
+    }
+};
+
+class EDLines {
+							
+public:
+	EDLines(cv::Mat _srcImage, GradientOperator _op = PREWITT_OPERATOR, int _gradThresh = 20, int _anchorThresh = 0, int _scanInterval = 1, int _minPathLen = 10, double _sigma = 1.5, bool _sumFlag = true, double _line_error = 1.0, int _min_line_len = -1, double _max_distance_between_two_lines = 6.0, double _max_error = 1.3);
+
+	cv::Mat getEdgeImage();
+	cv::Mat getAnchorImage();
+	cv::Mat getSmoothImage();
+	cv::Mat getGradImage();
+    cv::Mat getLineImage();
+    cv::Mat drawOnImage();
+	
+	int getSegmentNo();
+	int getAnchorNo();
+	
+	std::vector<cv::Point> getAnchorPoints();
+	std::vector<std::vector<cv::Point>> getSegments();
+	std::vector<std::vector<cv::Point>> getSortedSegments();
+	
+	cv::Mat drawParticularSegments(std::vector<int> list);
+    
+    std::vector<LS> getLines();
+    int getLinesNo();
+
+protected:
+	int width; // ширина исходного изображения
+	int height; // высота исходного изображения
+	uchar *srcImg; 
+	std::vector<std::vector< cv::Point> > segmentPoints;
+	double sigma; // сигма Гаусса
+	cv::Mat smoothImage;
+	uchar *edgeImg;
+	uchar *smoothImg; 
+	int segmentNos;
+	int minPathLen;
+	cv::Mat srcImage;
+
+private:
+	void ComputeGradient();
+	void ComputeAnchorPoints();
+	void JoinAnchorPointsUsingSortedAnchors(); 
+	int* sortAnchorsByGradValue1();
+
+	static int LongestChain(Chain *chains, int root);
+	static int RetrieveChainNos(Chain *chains, int root, int chainNos[]);
+
+	int anchorNos;
+	std::vector<cv::Point> anchorPoints;
+	std::vector<cv::Point> edgePoints;
+
+	cv::Mat edgeImage;
+	cv::Mat gradImage;
+    cv::Mat threshImage;
+
+	uchar *dirImg; // указатель на направление градиента пикселя
+	short *gradImg; // указатель на градиет пикселя
+
+	GradientOperator gradOperator; // оператор градиента
+	int gradThresh;
+	int anchorThresh;
+	int scanInterval;
+	bool sumFlag;
+    
+    std::vector<LineSegment> lines;
+    std::vector<LineSegment> invalidLines;
+    std::vector<LS> linePoints;
+    int linesNo;
+    int min_line_len;
+    double line_error;
+    double max_distance_between_two_lines;
+    double max_error;
+    double prec;
+    
+    
+    int ComputeMinLineLength();
+    void SplitSegment2Lines(double *x, double *y, int noPixels, int segmentNo);
+    void JoinCollinearLines();
+    
+    bool TryToJoinTwoLineSegments(LineSegment *ls1, LineSegment *ls2, int changeIndex);
+    
+    static double ComputeMinDistance(double x1, double y1, double a, double b, int invert);
+    static void ComputeClosestPoint(double x1, double y1, double a, double b, int invert, double &xOut, double &yOut);
+    static void LineFit(double *x, double *y, int count, double &a, double &b, int invert);
+    static void LineFit(double *x, double *y, int count, double &a, double &b, double &e, int &invert);
+    static double ComputeMinDistanceBetweenTwoLines(LineSegment *ls1, LineSegment *ls2, int *pwhich);
+    static void UpdateLineParameters(LineSegment *ls);
+    static void EnumerateRectPoints(double sx, double sy, double ex, double ey,int ptsx[], int ptsy[], int *pNoPoints);
+
+};
+
+

opencv-example/opencv_EdgeDrawLines/main.cpp

+#include <iostream>
+
+#include "opencv2/opencv.hpp"
+#include "EDLines.h"
+
+#define WAIT_TIME 4000
+
+using namespace cv;
+constexpr int width = 3690;
+constexpr int height = 313;
+int main(int argc, const char * argv[])
+{
+    // Mat imageRGB = imread(argv[1]);
+    Mat image = imread(argv[1], 0);
+    EDLines lineHandler = EDLines(image);
+    Mat outputImage;
+    Mat showImage;
+    
+    // imshow("INPUT IMAGE", imageRGB);
+    waitKey(WAIT_TIME);
+    outputImage = lineHandler.getSmoothImage();
+    resize(outputImage, showImage, cv::Size(width, height));
+    imshow("SMOOTHING", showImage);
+    waitKey(WAIT_TIME);
+    outputImage = lineHandler.getGradImage();
+    resize(outputImage, showImage, cv::Size(width, height));
+    imshow("GRADIENT AND THRESHOLDING", showImage);
+    waitKey(WAIT_TIME);
+    outputImage = lineHandler.getAnchorImage();
+    resize(outputImage, showImage, cv::Size(width, height));
+    imshow("ANCHORING AND CONNECTING THEM", showImage);
+    waitKey(WAIT_TIME);
+    outputImage = lineHandler.getEdgeImage();
+    resize(outputImage, showImage, cv::Size(width, height));
+    imshow("EDGES", showImage);
+    waitKey(WAIT_TIME);
+    outputImage = lineHandler.getLineImage();
+    resize(outputImage, showImage, cv::Size(width, height));
+    imshow("ED LINES", showImage);
+    waitKey(WAIT_TIME);
+    outputImage = lineHandler.drawOnImage();
+    resize(outputImage, showImage, cv::Size(width, height));
+    imshow("ED LINES OVER SOURCE IMAGE", showImage);
+    waitKey(0);
+    return 0;
+}

opencv-example/videotool.cpp

@@ -61,7 +61,7 @@ int main(int argc, char* argv[]){
         // show live and wait for a key with timeout long enough to show images
         imshow(fileName.string(), frame);
         int key = waitKey(t);
-        // printf("key = %d, t = %d\n", key, t);
+        printf("frame = %d key = %d, t = %d\n", currFrame , key, t);
         if (key == 27 || key == 113){
             break;
         }