Olá amigos!  Sou novo no Forum e até então nunca precisei tanto da ajuda de vocês. Meu problema é o seguinte: tenho três funções, e a principal delas (que chama as outras duas) deve dar como saída, um ponteiro (**CORRELA) que direciona para uma matriz principal contendo os elementos da correlação entre pontos de duas imagens diferentes.  O PROBLEMA É QUE Na hora de se inscrever os resultados dento de CORRELA, isto é,  CORRELA[]=X,  a atribuição não é realizada!!  Já quebrei a cabeça aqui e nada. Não achei ninguém com problema parecido. Eu usei a função 'Matriz' para criar outros ponteiros  duplos, e está funcionando corretamente, apenas neste caso que não está funcionando bem.  Aguardo ansioso pela a ajuda!! Agradeço desde já!  O código está abaixo.  para chamar a função eu faço:  ....
     float **CORRELA;
......
     CORRELA=Correlacao(Im,NonZeros,cont2,rPixel1,rPixel2);
float** Correlacao(float **Im, float **Vec, int sizeVec,int rPixel1, int rPixel2)
{
        int i,j,l,m,q,r,a;
        float u,v;
        float pho,raio,raio2;
        float ssd_temp,ssd1;
        float **CORRELA;
        CORRELA=Matriz(sizeVec,6);
        float *c1W = new  float [60];
        float *c2W = new  float [60];
        
        for (i=0;i<sizeVec;i++)
        {
                u=Vec[i][0]-rPixel2;
                v=Vec[i][1]-rPixel2;
                
                //Raio do ponto
                //u linha v coluna
                // Neste momento interessa poontos do lóbulo interno
                raio=sqrt(pow(u,2)+pow(v,2));
                
                //Calcula-se o quadrante do ponto 
                q=Quadrante(u,v);
                if (raio<=rPixel1)
                {
                        //Descobrindo a  direção da reta que passa por u , v e o centro O
                        
                        pho=u/v;
                        ssd1=9000000000000000000;
                        if(q==4 || q==1)
                        {
                                for(j=rPixel2;j<(rPixel2*2-1);j++)
                                {
                                        
                                        //percorrendo a reta que passa pelo ponto e pela origem
                                        l=j-rPixel2;
                                        m=(l*pho);
                                        raio2=sqrt(pow((float)l,2)+pow((float)m,2));
                                        if((raio2<=rPixel2)&&(raio2>rPixel1))
                                        {
                                                
                                                if(Im[l+rPixel2][m+rPixel2]==255)
                                                {
                                                        //calulando a janela circualr nos pontos candidatos serem correspondentes
                                                        c1W=cWindow(Im,u,v,rPixel2,60);
                                                        c2W=cWindow(Im,l,m,rPixel2,60);
                                                        //calcula relação ssd entre pontos candidatos
                                                        ssd_temp=SSD(c1W,c2W,60);
                                                        if (ssd_temp<ssd1)
                                                        {
                                                                //se ssd_temp for menor que ssd ele é o possivel ponto correspondente
                                                                ssd1=ssd_temp;
                                                                CORRELA[i][0]=u;
                                                                CORRELA[i][1]=v;
                                                                CORRELA[i][2]=(float)m;
                                                                CORRELA[i][3]=(float)l;
                                                                CORRELA[i][4]=pho;
                                                                CORRELA[i][5]=(float)q;
                                                        }
                                                }
                                        }
                                }
                        }
                        else if(q==2||q==3)
                        {
                                for(j=rPixel2;j>=0;j--)
                                {
                                        l=j-rPixel2;
                                        m=l*pho;
                                        raio2-sqrt(pow((float)l,2)+pow((float)m,2));
                                        if((raio2<=rPixel2)&&(raio2>rPixel1))
                                        {
                                                if(Im[l+rPixel2][m+rPixel2]==255)
                                                {
                                                        //calulando a janela circualr nos pontos candidatos serem correspondentes
                                                        c1W=cWindow(Im,u,v,rPixel2,60);
                                                        c2W=cWindow(Im,l,m,rPixel2,60);
                                                        //calcula relação ssd entre pontos candidatos
                                                        ssd_temp=SSD(c1W,c2W,60);
                                                        if (ssd_temp<ssd1)
                                                        {
                                                                //se ssd_temp for menor que ssd ele é o possivel ponto correspondente
                                                                ssd1=ssd_temp;
                                                                CORRELA[i][1]=u;
                                                                CORRELA[i][2]=v;
                                                                CORRELA[i][3]=m;
                                                                CORRELA[i][4]=l;
                                                                CORRELA[i][5]=pho;
                                                                CORRELA[i][6]=q;
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }
        //*CORRELA=&teste;
        return CORRELA;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
float SSD(float *c1W, float *c2W,int w)
{
        int i;
        float ssd=0;
        for (i=0;i<w;i++)
        {
                ssd=ssd+pow(c1W[i]-c2W[i],2);
        }
        return ssd;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
loat* cWindow(float** Im, int u , int v, int rpixel, int w)
{
        /*Função responsável por retornar os valores dos pixeis que
    compõem a janela circular de tamanho 2pi/epslon (e) do pixel 
    'pix', na posição u,v em uma imagem de tamanho rpixel^2
        u,v estarão escalados para as coordenadas do plano cartesiano
        com origem no centro da imagem omnidirecional*/
        int j,l,m;
        float i,raio,e;
        float* CIRCULO = new  float [w];
        //Escalando as coordenadas do pixel para a origem no
        //canto superior esquerdo da imagem
        l=u;
        m=v;
        e=2*PI/w;
        raio=sqrt(pow((float)l,2)+pow((float)m,2));
        j=1;
        CIRCULO[0]=Im[l+rpixel][m+rpixel];
        for (i=0+e;i<2*PI;i=i+e)
        {
                
                l=raio*cos(i);
                m=raio*sin(i);
                CIRCULO[j]=Im[l+rpixel][m+rpixel];
                j++;
        }
        return CIRCULO;
        
}
float** Matriz(int L, int C)
{
        int i;  
        float **matriz = new  float*[L];
        for (i=0;i<L;i++)
        {
                 matriz[i]=(float*)calloc(C, sizeof(float));
        }
        return matriz;
}