How to effectively combine two overlapping contours into one large contour?

Question

I have a huge image (about 63000 x 63000 pixels = 3969 megapixels) that I have done so far, I decided to make "tiles" (1024 x 1024) and perform my calculations based on these fragments, resulting in a grid with an image of 62 x 62! (this works very well and has the advantage that the image can be viewed with zooming in and out, for example, only the size of the players is reduced) But now I need the contours of a huge image!

• I use the OpenCV function "findContours" to detect outlines on each one of the tiles.
• I added some overlap to the tiles to get overlapping contours (overlap 1 pixel)
• I used the "findContours" offset parameter to move the outlines to the correct position
  in the "virtual full image"

Here is a screenshot taken from a demo application

I want this:

Now my questions are:

• Is it possible to stitch outlines, my worst case is an outline that covers the overall image ... is there any library that can do this?
• Is there a library that works with a compressed version of a shared image (e.g. rle).
• Is there a way to make opencv findcontours work on 1-bit binary images?

Here is the code used by findcontours:

    // Surf2DTiledData ...a gobject based class used for 2d tile management and viewing.. 
Surf2DTiledData* td = (Surf2DTiledData*)in_td;

int nr_hor_tiles = surf2_d_tiled_data_get_nr_hor_tiles(td);
int nr_ver_tiles = surf2_d_tiled_data_get_nr_ver_tiles(td);
int tile_size_x = surf2_d_tiled_data_get_tile_width(td);
int tile_size_y = surf2_d_tiled_data_get_tile_height(td);

contouring_data_obj = surf2_d_tiled_data_get_ContouringData(td);
p_contours = contouring_data_obj->p_contours;
p_border_contours = contouring_data_obj->p_border_contours;

g_return_if_fail(p_border_contours != NULL);
g_return_if_fail(p_contours != NULL);


for (y = 0; y < nr_ver_tiles; y++){
    int x;
    for (x = 0; x < nr_hor_tiles; x++){
        int idx = x + y*nr_hor_tiles;
        CvMemStorage *mem = contouring_data_obj->contour_storage[idx];
        CvMat _src;
        CvSeq *contours = NULL;
        uchar* dataBuffer = (uchar*)p_data[x][y];

        // the idea is to have some extra space available for the overlap
        // detection of contours!
        // the extra space is needed for the algorithm to check for
        // overlaps of contours later on!
#define VIRT_BORDER_EXTEND 2
        int virtual_x = x * tile_size_x - VIRT_BORDER_EXTEND;
        int virtual_y = y * tile_size_y - VIRT_BORDER_EXTEND;

        int virtual_width = tile_size_x + VIRT_BORDER_EXTEND * 2;
        int virtual_height = tile_size_y + VIRT_BORDER_EXTEND * 2;
        int x_off = -VIRT_BORDER_EXTEND;
        int y_off = -VIRT_BORDER_EXTEND;
        if (virtual_x < 0) {
            virtual_width += virtual_x;
            virtual_x = 0;
            x_off = 0;
        }

        if (virtual_y < 0) {
            virtual_height += virtual_y;
            virtual_y = 0;
            y_off = 0;
        }

        if ((virtual_x + virtual_width) > (nr_hor_tiles*tile_size_x)) {
            virtual_width = nr_hor_tiles*tile_size_x - virtual_x;
        }

        if ((virtual_y + virtual_height) > (nr_ver_tiles*tile_size_y)) {
            virtual_height = nr_ver_tiles*tile_size_y - virtual_y;
        }

        CvMat* _roi_mat = get_roi_mat(td,
                           virtual_x, virtual_y,
                           virtual_width, virtual_height);

        // Use either this:
        //mem = cvCreateMemStorage(0);

        if (_roi_mat){
            // CV_LINK_RUNS => different algorithm!!!!
            int tile_off_x = tile_size_x * x;
            int tile_off_y = tile_size_y * y;

            CvPoint contour_shift = cvPoint(x_off + tile_off_x, y_off + tile_off_y);

            int n = cvFindContours(_roi_mat, mem, &contours, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, contour_shift);

            cvReleaseMat(&_roi_mat);

            p_contours[x][y] = contours;
        }

        //cvReleaseMemStorage(&mem);
    }
}

opengl, , ! opencv , , ... opengl..