Besoin d'aide pour mettre en œuvre un détecteur de bord spécial

Je suis en train de mettre en œuvre une approche d'un document de recherche. Une partie de l'approche appelle à un détecteur de bord majeur, que les auteurs décrivent comme suit:

1. Obtenez une image CC (effectivement Downsample par 8 pour la largeur et la hauteur) li>
2. Calculez le dégradé SOBEL de l'image DC LI>
3. Seuil Sobel Image gradient (utilisant T = 120) LI>
4. Opérations morphologiques pour nettoyer l'image de bord strong> li> ol>

   Notez que cette non forte> de la détection de bord de canny - ils ne se préoccupent pas avec des choses comme une suppression non maximale, etc. Je pouvais bien sûr faire cela avec une détection de bords de canneuse, mais Je veux mettre en œuvre des choses exactement comme ils sont exprimés dans le papier. P>

   Cette dernière étape est celle que je suis un peu coincé. P>

   Voici exactement ce que les auteurs disent IT: P>

   Après avoir obtenu le binaire carte de bord du processus de détection des bords, un morphologique binaire L'opération est utilisée pour éliminer les pixels de bord isolé, qui pourrait causer de fausses alarmes pendant la détection de bord p> blockQuote>

   Voici comment les choses sont censées ressembler à la fin de tout cela (les blocs de bord ont été remplis en noir): p>

   p>

   Voici ce que j'ai si je saute la dernière étape: p>

   p>

   Il semble être sur la bonne voie. Donc, voici ce qui se passe si je fais une érosion pour l'étape 4: p>

   p >

   J'ai essayé des combinaisons d'érosion et de dilatation pour obtenir le même résultat que possible, mais ne soyez nulle part près. Quelqu'un peut-il suggérer une combinaison d'opérateurs morphologiques qui me donnera le résultat souhaité? P>

   Voici la sortie de binarisation, au cas où n'importe qui veut jouer avec elle: p>

   p>

   et si vous êtes vraiment désolé, voici le code source (C ++): P >

   #include <cv.h>
   #include <highgui.h>
   #include <stdlib.h>
   #include <assert.h>
   
   using cv::Mat;
   using cv::Size;
   
   #include <stdio.h>
   
   #define DCTSIZE 8
   #define EDGE_PX 255
   
   /*
    * Display a matrix as an image on the screen.
    */
   void
   show_mat(char *heading, Mat const &m)
   {
       Mat clone = m.clone();
   
       Mat scaled(clone.size(), CV_8UC1);
       convertScaleAbs(clone, scaled);
   
       IplImage ipl = scaled;
   
       cvNamedWindow(heading, CV_WINDOW_AUTOSIZE); 
       cvShowImage(heading, &ipl);
       cvWaitKey(0);
   }
   
   /*
    * Get the DC components of the specified matrix as an image.
    */
   Mat
   get_dc(Mat const &m)
   {
       Size s = m.size();
       assert(s.width  % DCTSIZE == 0);
       assert(s.height % DCTSIZE == 0);
   
       Size dc_size = Size(s.height/DCTSIZE, s.width/DCTSIZE);
   
       Mat dc(dc_size, CV_32FC1);
       cv::resize(m, dc, dc_size, 0, 0, cv::INTER_AREA);
   
       return dc;
   }
   
   /*
    * Detect the edges:
    *
    * Sobel operator
    * Thresholding
    * Morphological operations
    */
   Mat
   detect_edges(Mat const &src, int T)
   {
       Mat sobelx    = Mat(src.size(), CV_32FC1);
       Mat sobely    = Mat(src.size(), CV_32FC1);
       Mat sobel_sum = Mat(src.size(), CV_32FC1);
   
       cv::Sobel(src, sobelx, CV_32F, 1, 0, 3, 0.5);
       cv::Sobel(src, sobely, CV_32F, 0, 1, 3, 0.5);
   
       cv::add(cv::abs(sobelx), cv::abs(sobely), sobel_sum);
   
       Mat binarized = src.clone();
       cv::threshold(sobel_sum, binarized, T, EDGE_PX, cv::THRESH_BINARY);
   
       cv::imwrite("binarized.png", binarized);
   
       //
       // TODO: this is the part I'm having problems with.
       //
   
   #if 0
       //
       // Try a 3x3 cross structuring element.
       //
       Mat elt(3,3, CV_8UC1);
       elt.at<uchar>(0, 1) = 0;
       elt.at<uchar>(1, 0) = 0;
       elt.at<uchar>(1, 1) = 0;
       elt.at<uchar>(1, 2) = 0;
       elt.at<uchar>(2, 1) = 0;
   #endif
   
       Mat dilated = binarized.clone();
       //cv::dilate(binarized, dilated, Mat());
   
       cv::imwrite("dilated.png", dilated);
   
       Mat eroded = dilated.clone();
       cv::erode(dilated, eroded, Mat());
   
       cv::imwrite("eroded.png", eroded);
   
       return eroded;
   }
   
   /*
    * Black out the blocks in the image that contain DC edges.
    */
   void
   censure_edge_blocks(Mat &orig, Mat const &edges)
   {
       Size s = edges.size();
       for (int i = 0; i < s.height; ++i)
       for (int j = 0; j < s.width;  ++j)
       {
           if (edges.at<float>(i, j) != EDGE_PX)
               continue;
   
           int row = i*DCTSIZE;
           int col = j*DCTSIZE;
   
           for (int m = 0; m < DCTSIZE; ++m)
           for (int n = 0; n < DCTSIZE; ++n)
               orig.at<uchar>(row + m, col + n) = 0;
       }
   }
   
   /*
    * Load the image and return the first channel.
    */
   Mat
   load_grayscale(char *filename)
   {
       Mat orig = cv::imread(filename);
       std::vector<Mat> channels(orig.channels());
       cv::split(orig, channels);
       Mat grey = channels[0];
       return grey;
   }
   
   int
   main(int argc, char **argv)
   {
       assert(argc == 3);
   
       int bin_thres = atoi(argv[2]);
   
       Mat orig = load_grayscale(argv[1]);
       //show_mat("orig", orig);
   
       Mat dc = get_dc(orig);
       cv::imwrite("dc.png", dc);
   
       Mat dc_edges = detect_edges(dc, bin_thres);
   
       cv::imwrite("dc_edges.png", dc_edges);
   
       censure_edge_blocks(orig, dc_edges);
       show_mat("censured", orig);
       cv::imwrite("censured.png", orig);
   
       return 0;
   }