chamerMatching malloc error

edit

I have had a similar issue that might be related to yours. I was trying to run the sample Chmafer matching code from OpenCV (/trunk/opencv/samples/cpp/chamfer.cpp) and I would get the following error:

* glibc detected :double free or corruption (!prev): 0x0000000000745bb0 **

The reason is that in function chamerMatching(img, tpl, results, costs) a template is created and then a reference to it is added inside matcher_ object:

ChamferMatcher::Template template_(templ, (float)templScale);
ChamferMatcher::Matches match_instances = matcher_.matching(template_, img);

As a result when the function returns template_ is destroyed first and then when matcher_ is destroyed it tries to destroy the same template again hence you gen an error.

A quick fix to it is to modify the destructor of Matching() and to comment out the line that deletes templates.

    ~Matching()
    {
        for (size_t i = 0; i<templates.size(); i++) {
            //delete templates[i];
        }
    }

Note, however, that this solution is just a hack that I used to get the demo working. There might be other ways templates can be added to Matching object and those need to be deleted otherwise you will get memory leak.

I found that the Template ownership and lifetime issues get quite complicated. At the heart of the problem is the ChamferMatcher::Template::rescale function, which can either return "this" or a new-allocated Template object. A template can also hold scaled templates in an internal vector. Template pointers can also be copied to Matching, etc.

If one is willing to use the modern C++11 standard library, the problems can be resolved with std::shared_ptr, which does reference counting and only destroys an object when the last pointer to it is destroyed.

std::shared_ptr<ChamferMatcher::Template> ChamferMatcher::Template::rescale(float new_scale)
{

if (fabs(scale - new_scale) < 1e-6) return shared_from_this();

for (size_t i=0;i<scaled_templates.size();++i) {
    if (fabs(scaled_templates[i]->scale-new_scale)<1e-6) {
        return scaled_templates[i];
    }
}

float scale_factor = new_scale/scale;

auto tpl = std::make_shared<Template>();
tpl->scale = new_scale;

tpl->center.x = int(center.x*scale_factor+0.5);
tpl->center.y = int(center.y*scale_factor+0.5);

tpl->size.width = int(size.width*scale_factor+0.5);
tpl->size.height = int(size.height*scale_factor+0.5);

tpl->coords.resize(coords.size());
tpl->orientations.resize(orientations.size());
for (size_t i=0;i<coords.size();++i) {
    tpl->coords[i].first = int(coords[i].first*scale_factor+0.5);
    tpl->coords[i].second = int(coords[i].second*scale_factor+0.5);
    tpl->orientations[i] = orientations[i];
}
scaled_templates.push_back(tpl);

return tpl;

}

All uses of Template* should be replaced with std::shared_ptr<Template> and all uses of const Template * with std::shared_ptr< const Template >. Then all the raw delete operations are not necessary, and the matches can be used safely.