on the given image on the question it seems there is a big closed contour and open contours around it. like this image as a solution i tried to find edges of open contours and nearest points of closed contour and connect them. as result image :

althougt it is not perfect i tested your image and it seems desired result is OK.

i hope it will be useful for you.

```
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
using namespace cv;
using namespace std;
/// Global Variables
Point pt0,pt1;
int shift=0; // optional value for drawing scaled
Scalar color = Scalar(0,0,0);
// calculates distance between two points
static double distanceBtwPoints(const cv::Point a, const cv::Point b)
{
double xDiff = a.x - b.x;
double yDiff = a.y - b.y;
return std::sqrt((xDiff * xDiff) + (yDiff * yDiff));
}
static int findNearestPointIndex(const cv::Point pt, const vector<Point> points)
{
int nearestpointindex = 0;
double distance;
double mindistance = 1e+9;
for ( size_t i = 0; i < points.size(); i++)
{
distance = distanceBtwPoints(pt,points[i]);
if( distance < mindistance )
{
mindistance = distance;
nearestpointindex = i;
}
}
return nearestpointindex;
}
// draws point vector on given image
int static drawPoints( vector<Point> source_points,int start_index,int end_index, Mat m )
{
vector<Point> result;
int c = start_index;
start_index = min( start_index , end_index );
end_index = max( end_index, c );
for ( int i = start_index; i < end_index; i++)
{
result.push_back(source_points[i]);
}
if( start_index == 0 || result.size() < source_points.size()/2)
{
polylines(m,result,false,color,1,LINE_8,shift);
}
else
{
result.clear();
for ( int i = 0; i < start_index; i++)
result.push_back(source_points[i]);
polylines(m,result,false,color,1,LINE_8,shift);
result.clear();
for ( int i = end_index; i < source_points.size(); i++)
{
result.push_back(source_points[i]);
polylines(m,result,false,color,1,LINE_8,shift);
}
}
return 0;
}
bool testPoints(vector<Point> pts)
{
Point pt = pts[0];
for ( size_t i = 1; i < pts.size(); i++)
if( pts[i] == pt ) return false;
return true;
}
int main( int argc, char** argv )
{
char* filename = argc >= 2 ? argv[1] : (char*)"test.png";
Mat img = imread(filename);
if (img.empty())
return -1;
Mat src = img;
Mat bw;
cvtColor( src, bw, COLOR_BGR2GRAY );
bw = bw < 127;
// Find contours
vector<vector<Point> > contours;
vector<Point> contour;
findContours( bw, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE );
// assuming the closed contour have biggest area
contour = contours[0];
for ( size_t i = 0; i < contours.size(); i++)
{
if( contourArea(contour) < contourArea(contours[i]) )
contour = contours[i];
}
src = Scalar(255,255,255); // clears source image to redraw
for ( size_t i = 0; i < contours.size(); i++)
{
if( contour != contours[i] && contours[i].size() > 10 )
{
pt0 = contours[i][0];
int ptscount=0;
for ( size_t j = 0; j < contours[i].size(); j++)
if( contours[i][j] == contours[i][j-2] )
{
ptscount++;
pt1 = pt0;
pt0 = contours[i][j-1];
}
if(testPoints(contours[i]) && ptscount > 1 )
pt0 = contours[i][0];
// find nearest points of closed contour
int nearestpointindex_start = findNearestPointIndex(pt0,contour);
int nearestpointindex_end = findNearestPointIndex(pt1,contour);
// redrawing
line(src,pt1,contour[nearestpointindex_end],color,1,LINE_8,shift);
line(src,pt0,contour[nearestpointindex_start],color,1,LINE_8,shift);
drawPoints(contours[i],0,contours[i].size(),src);
drawPoints(contour,nearestpointindex_start,nearestpointindex_end ...
```

(more)
The image doesn't seems to be binary... So I'll suggest you to do

This is a start, I have no ideas what to do next, maybe come back with some results

I've wrote this image from a binary one, so I have the "original binary image". I'll try the dilate operation.

@LBerger could you help ? It is similar of my previous problem, but I was able to get a much clear image