Unhandled exception with C++ class function

Question

I am writing a program which will preform texture synthesis. I have been away from C++ for a while and am having trouble figuring out what I am doing wrong in my class. When I run the program, I get an unhandled exception in the copyToSample function when it tries to access the arrays. It is being called from the bestSampleSearch function when the unhandled exception occurs. The function has been called before and works just fine, but later on in the program it is called a second time and fails. Any ideas? Let me know if anyone needs to see more code. Thanks!

Edit1: Added the bestSampleSearch function and the compareMetaPic function
Edit2: Added a copy constructor
Edit3: Added main()
Edit4: I have gotten the program to work. However there is now a memory leak of some kind or I am running out of memory when I run the program. It seems in the double for loop in main which starts "// while output picture is unfilled" is the problem. If I comment this portion out the program finishes in a timely manner but only one small square is output. Something must be wrong with my bestSampleSearch function.

MetaPic.h

#pragma once
#include <pic.h>
#include <stdlib.h>
#include <cmath>

class MetaPic
{
    public:
        Pic* source;
        Pixel1*** meta;
        int x;
        int y;
        int z;
        MetaPic();
        MetaPic(Pic*);
        MetaPic(const MetaPic&);
        MetaPic& operator=(const MetaPic&);
        ~MetaPic();
        void allocateMetaPic();
        void copyPixelData();
        void copyToOutput(Pic*&);
        void copyToMetaOutput(MetaPic&, int, int);
        void copyToSample(MetaPic&, int, int);
        void freeMetaPic();

};

MetaPic.cpp

#include "MetaPic.h"

MetaPic::MetaPic()
{
    source = NULL;
    meta = NULL;
    x = 0;
    y = 0;
    z = 0;
}

MetaPic::MetaPic(Pic* pic)
{
    source = pic;
    x = pic->nx;
    y = pic->ny;
    z = pic->bpp;
    allocateMetaPic();
    copyPixelData();
}

MetaPic::MetaPic(const MetaPic& mp)
{
    source = mp.source;
    x = mp.x;
    y = mp.y;
    z = mp.z;
    allocateMetaPic();
    copyPixelData();
}

MetaPic::~MetaPic()
{
    freeMetaPic();
}

// create a 3 dimensional array from the original one dimensional array
void MetaPic::allocateMetaPic()
{
    meta = (Pixel1***)calloc(x, sizeof(Pixel1**));

    for(int i = 0; i < x; i++)
    {
        meta[i] = (Pixel1**)calloc(y, sizeof(Pixel1*));
        for(int j = 0; j < y; j++)
        {
            meta[i][j] = (Pixel1*)calloc(z, sizeof(Pixel1));
        }
    }
}

void MetaPic::copyPixelData()
{
    for(int j = 0; j < y; j++)
    {
        for(int i = 0; i < x; i++)
        {
            for(int k = 0; k < z; k++)
                meta[i][j][k] = source->pix[(j*z*x)+(i*z)+k];
        }
    }
}

void MetaPic::copyToOutput(Pic* &output)
{
    for(int j = 0; j < y; j++)
    {
        for(int i = 0; i < x; i++)
        {
            for(int k = 0; k < z; k++)
                output->pix[(j*z*x)+(i*z)+k] = meta[i][j][k];
        }
    }
}

// copy the meta data to the final  pic output starting at the top left of the picture     and mapped to 'a' and 'b' coordinates in the output
void MetaPic::copyToMetaOutput(MetaPic &output, int a, int b)
{
    for(int j = 0; (j < y) && ((j+b) < output.y); j++)
    {
        for(int i = 0; (i < x) && ((i+a) < output.x); i++)
        {
            for(int k = 0; k < z; k++)
                output.meta[i+a][j+b][k] = meta[i][j][k];
        }
    }
}

// copies from a source image to a smaller sample image
// *** Must make sure that the x and y coordinates have enough buffer space ***
void MetaPic::copyToSample(MetaPic &sample, int a, int b)
{
    for(int j = 0; (j < sample.y) && ((b+j) < y); j++)
    {
        for(int i = 0; i < (sample.x) && ((a+i) < x); i++)
        {
            for(int k = 0; k < sample.z; k++)
            {
                    **sample.meta[i][j][k] = meta[i+a][j+b][k];**
            }
        }
    }
}

// free the meta pic data (MetaPic.meta)
// *** Not to be used outside of class declaration ***
void MetaPic::freeMetaPic()
{
    for(int j = 0; j < y; j++)
    {
        for(int i = 0; i < z; i++)
            free(meta[i][j]);
    }
    for(int i = 0; i < x; i++)
        free(meta[i]);

    free(meta);
}

MetaPic MetaPic::operator=(MetaPic mp)
{
    MetaPic newMP(mp.source);

    return newMP;
}

main.cpp

#ifdef WIN32
// For VC++ you need to include this file as glut.h and gl.h refer to it
#include <windows.h>
// disable the warning for the use of strdup and friends
#pragma warning(disable:4996) 
#endif
#include <stdio.h>     // Standard Header For Most Programs
#include <stdlib.h>    // Additional standard Functions (exit() for example)
#include <iostream>
// Interface to libpicio, provides functions to load/save jpeg files
#include <pic.h>
#include <string.h>
#include <time.h>
#include <cmath>

#include "MetaPic.h"

using namespace std;

MetaPic bestSampleSearch(MetaPic, MetaPic);
double compareMetaPics(MetaPic, MetaPic);

#define SAMPLE_SIZE 23
#define OVERLAP 9

// Texture source image (pic.h uses the Pic* data structure)
Pic *sourceImage;
Pic *outputImage;
int main(int argc, char* argv[])
{
    char* pictureName = "reg1.jpg";
    int outputWidth = 0;
    int outputHeight = 0;

    // attempt to read in the file name
    sourceImage = pic_read(pictureName, NULL);
    if(sourceImage == NULL)
    {
        cout << "Couldn't read the file" << endl;
        system("pause");
        exit(EXIT_FAILURE);
    }

    // *** For now set the output image to 3 times the original height and width ***
    outputWidth = sourceImage->nx*3;
    outputHeight = sourceImage->ny*3;

    // allocate the output image
    outputImage = pic_alloc(outputWidth, outputHeight, sourceImage->bpp, NULL);
    Pic* currentImage = pic_alloc(SAMPLE_SIZE, SAMPLE_SIZE, sourceImage->bpp, NULL);

    MetaPic metaSource(sourceImage);
    MetaPic metaOutput(outputImage);
    MetaPic metaCurrent(currentImage);

    // seed the output image    
    int x = 0;
    int y = 0;
    int xupperbound = metaSource.x - SAMPLE_SIZE;
    int yupperbound = metaSource.y - SAMPLE_SIZE;
    int xlowerbound = 0;
    int ylowerbound = 0;

    // find random coordinates
    srand(time(NULL));
    while((x >= xupperbound) || (x <= xlowerbound))
        x = rand() % metaSource.x;
    while((y >= yupperbound) || (y <= ylowerbound))
        y = rand() % metaSource.y;

    // copy a random sample from the source to the metasample
    metaSource.copyToSample(metaCurrent, x, y);
    // copy the seed to the metaoutput
    metaCurrent.copyToMetaOutput(metaOutput, 0, 0);


    int currentOutputX = 0;
    int currentOutputY = 0;

    // while the output picture is unfilled...
    for(int j = 0; j < yupperbound; j+=(SAMPLE_SIZE-OVERLAP))
    {
        for(int i = 0; i < xupperbound; i+=(SAMPLE_SIZE-OVERLAP))
        {
            // move the sample to correct overlap
            metaSource.copyToSample(metaCurrent, i, j);
            // find the best match for the sample
            metaCurrent = bestSampleSearch(metaSource, metaCurrent);
            // write the best match to the metaoutput
            metaCurrent.copyToMetaOutput(metaOutput, i, j);
            // update the values
        }
    }


    // copy the metaOutput to the output
    metaOutput.copyToOutput(outputImage);

    // output the image
    pic_write("reg1_output.jpg", outputImage, PIC_JPEG_FILE);


    // clean up
    pic_free(sourceImage);
    pic_free(outputImage);
    pic_free(currentImage);

    // return success
    cout << "Done!" << endl;
    system("pause");
    // return success
    return 0;
}

// finds the best sample to insert into the image
// *** best must be the sample which consists of the overlap ***
MetaPic bestSampleSearch(MetaPic source, MetaPic best)
{
    MetaPic metaSample(best);

    double bestScore = 999999.0;
    double currentScore = 0.0;

    for(int j = 0; j < source.y; j++)
    {
        for(int i = 0; i < source.x; i++)
        {
            // copy the image starting at the top left of the source image
            source.copyToSample(metaSample, i, j);
            // compare the sample with the overlap
            currentScore = compareMetaPics(best, metaSample);
            // if best score is greater than current score then copy the         better sample to best and continue searching
            if( bestScore > currentScore)
            {
                metaSample.copyToSample(best, 0, 0);
                bestScore = currentScore;
            }
            // otherwise, the score is less than current score then do nothing     (a better sample has not been found)

        }
    }

    return best;
}

// find the comparison score for the two MetaPics based on their rgb values
// *** Both of the meta pics should be the same size ***
double compareMetaPics(MetaPic pic1, MetaPic pic2)
{
    float r1 = 0.0;
    float g1 = 0.0;
    float b1 = 0.0;
    float r2 = 0.0;
    float g2 = 0.0;
    float b2 = 0.0;
    float r = 0.0;
    float g = 0.0;
    float b = 0.0;

    float sum = 0.0;

    // take the sum of the (sqrt((r1-r2)^2 + ((g1-g2)^2 + ((b1-b2)^2))
    for(int j = 0; (j < pic1.y) && (j < pic2.y); j++)
    {
        for(int i = 0; (i < pic1.x) && (i < pic2.x); i++)
        {
            r1 = PIC_PIXEL(pic1.source, i, j, 0);
            r2 = PIC_PIXEL(pic2.source, i, j, 0);
            g1 = PIC_PIXEL(pic1.source, i, j, 1);
            g2 = PIC_PIXEL(pic2.source, i, j, 1);
            b1 = PIC_PIXEL(pic1.source, i, j, 2);
            b2 = PIC_PIXEL(pic2.source, i, j, 2);

            r = r1 - r2;
            g = g1 - g2;
            b = b1 - b2;

            sum += sqrt((r*r) + (g*g) + (b*b));
        }
    }

    return sum;
}

Answer 1

I'm not sure if this is the root cause of the problem, but your assignment operator does not actually assign anything:

MetaPic MetaPic::operator=(MetaPic mp)
{
    MetaPic newMP(mp.source);

    return newMP;
}

This should probably look something like the following (based off of the code in your copy constructor):

edit: with credit to Alf P. Steinbach

MetaPic& MetaPic::operator=(MetaPic mp)
{
    mp.swap(*this);
    return *this;
}

Answer 2

It turns out that the deallocate function is incorrect. It should be freeing in the same manner that it was allocating.

void MetaPic::freeMetaPic()

{

    for(int j = 0; j < y; j++)

    {

        for(int i = 0; i < z; i++)

            free(meta[i][j]);

    }

    for(int i = 0; i < x; i++)

        free(meta[i]);



    free(meta);

}