Problemas com ponteiro duplo (**)

[Chello_Fera]

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;
}

[Marcelo Utikawa da Fonseca]

Bom dia!

Pelo que pude ver a alocação de CORRELA e seu retorno pelas funções estão corretos. Eu não consigo testar agora pois não estou no pc. Existe uma lógica complexa até a atribuição. Seu programa realmente atinge o ponto em que CORRELA é atribuído?

Outra coisa: há um erro no seu código e acredito que é o que está causando o problema: no segundo trecho de seu código em que é feita a atribuição em CORRELA inicia o vetor em 1 e vai até 6 quando o correto seria de 0 a 5.

Abraços,

Marcelo Utikawa da Fonseca

[Chello_MG]

Bom dia!

Pelo que pude ver a alocação de CORRELA e seu retorno pelas funções estão corretos. Eu não consigo testar agora pois não estou no pc. Existe uma lógica complexa até a atribuição. Seu programa realmente atinge o ponto em que CORRELA é atribuído?

Outra coisa: há um erro no seu código e acredito que é o que está causando o problema: no segundo trecho de seu código em que é feita a atribuição em CORRELA inicia o vetor em 1 e vai até 6 quando o correto seria de 0 a 5.

Abraços,

Marcelo Utikawa da Fonseca

Bem chará !!!

Este erro foi só do Ctrl+c, Ctrl+V. no sistema ele esta correto. Mas mesmo assim. O estranho, é que consigo escrever os resultados da atribuição em u arquivo txt, mas quando tento acessar o ponteiro CORRELA retornado pela função, todos os elementos estão como '0'.

Nunca vi isso. procurei e procurei, mas não consigo encontrar o erro. ou algum site que mostre alguém que já passou por isso!

[Marcelo Utikawa da Fonseca]

Olá!

Pode ter certeza que esse erro é na lógica. Não acredito que seja problema em compilador ou pc...

Se você disse que grava o txt, então a atribuição está correta.

Coloque aqui o código que você usa para exibir o conteúdo do CORRELA, provavelmente o erro está nele!

E eu já tive uns problemas bizarros com ponteiros e, no fim, era um erro em outro ponteiro (que estava apontando erroneamente para o endereço que eu estava tendo problema) que estava corrompendo os dados. Portanto avalie todo o código entre a geração do txt e o ponto em que o problema acontece...

Abraços,

Marcelo Utikawa da Fonseca

[Chello_MG]

Então cara.

Tudo que faz uso do CORRELA Está no código acima. Mas é tão estranho, que na hora que Debugo, não mostra-se o CORRELA[j] recebendo a atribuição, ele permanece com '0' nos 6 elementos de cada linha. Mas ai na hora de escrever, ele escreve direitinho!.

Para escrita eu uso:

if(File::Exists("Correla.txt")==0)
     {
        FileStream^ antigo=File::Open("Correla.txt", FileMode::Create);
        antigo->Close();
     }
        ofstream out("Correla.txt",std::ios_base::out|std::ios_base::trunc);
        for(i=0;i<sizeVec;i++)
        {
            q=CORRELA[i][5];
            if(q!=0)
            {
                u=CORRELA[i][0];
                v=CORRELA[i][1];
                m=CORRELA[i][2];
                l=CORRELA[i][3];
                pho=CORRELA[i][4];
                out<<u<<" "<<v<<" "<<m<<" "<<l<<" "<<pho<<" "<<q<<endl;
            }
        }
        out.close();

Este código por sua vez, está inserido dentro da função Correlação, logo após o fim do cálculo de CORRELA.

Se você quiser me passa seu e-mail, que te adiciono a minha pasta de acesso no dropbox. Lá você vai poder ver diretitinho do que estou falando!

Muito estranho!

[Chello_Fera]

Achei o Erro!!!!

Valeu meu chapa!

[Marcelo Utikawa da Fonseca]

Ótimo! :)

Mas seria bom se você pudesse explicar onde estava o erro pois assim se mais alguém passar por algo parecido saberá o que pode ser...

Abraços,

Marcelo Utikawa da Fonseca