Object detection and splitting, clustering?

edit

Edit2:

Your second test image:

is not suitable for my code. The receipts are too close each other to correctly clusterise the contours:

It is maybe a little bit better when binarising the image instead of using the Canny edge detection:

As you are working on a specific application, if you choose a clustering approach (either the DBSCAN or Euclidean Cluster Extraction algotihms, wich are pretty similar), you have to place the receipts with some spaces between them. For example after erasing some parts:

Another option I see is to use simple rules when scanning the receipts. For example, the receipts are placed on a regular grid and upright. So you could locate your receipts by finding for example the blank space between them (similar to this question):

To sum up, I you can control the conditions when scanning the receipts, I would:

• place the receipts upright on a regular grid with some space between them
• clusterise and detect the blank spaces to merge the different clusters and for better robustness.

Otherwise I am afraid that it will be difficult to write an algorithm that will successfully split the receipts in most of the case without tuning or tweaking the parameters for each situation.

Edit:

I decided to speed-up the computation as it was really too slow (due to the complexity for the calculation of the contour distances) by:

• approximating the contour distance with the 16 distances between the bounding box of the two considered contours
• and or using the FLANN library to perform a radius search.

I also added the code to use the Otsu threshold in order to be able to automatically get the threshold for the Canny method (does not work every time).

Now the computation time is pretty good (speed-up ~ x30 vs my previous code). The input variables are the Canny threshold if the Otsu threshold does not produce good contours, the minimum distance between two contours to be considered as the same cluster and the minimum number of neighbors for a contour to be considered as relevant (not noise).

Another result: the test image, the Canny image and the result image:

Nice code @sturkmen !

There are often many different ways to solve a problem. My approach is to clusterize the different contours:

• the code is a direct implementation of the algorithm Euclidean Cluster Extraction
• the result is not bad but not ideal
• the code is not optimized at all, the complexity increases with the number of contours / number of contour points
• some morphology operations could be applied to eliminate noise contours or using the contour area

With a modified image:

The code:

#include <opencv2/opencv.hpp>

cv::RNG rng(12345);

//@url: http://answers.opencv.org/question/75649/object-detection-and-splitting-clustering/
typedef struct contour_t {
  std::vector<cv::Point> contour_pts;
  int idx;
  int unique_id;
  cv::Rect bounding_box;

  contour_t() :
      contour_pts(), idx(-1), unique_id(-1), bounding_box() {
  }

  contour_t(const contour_t &copy) {
    contour_pts = copy.contour_pts;
    idx = copy.idx;
    unique_id = copy.unique_id;
    bounding_box = copy.bounding_box;
  }

  contour_t(const std::vector<cv::Point> &c, const int ...