Include

[Barassa]

Boas , tou aqui com um prob deve tar a escapar-me qualquer coisa que eu fiz include dos modulos mas mm assim diz-me que as funcoes nao estao definidas ... alguem sabe qual pode ser o problema ? os nomes tao iguais ..

[Triton]

Show us the code.

[Barassa]

Entretanto ja resolvi o problema agora :

Diz que rectangle * quadrantes[] = divide®; "Is an invalid initializer"

Alguem me explica pq?

int intersects (rectangle *r, rectangle *t) {

rectangle * quadrantes[] = divide(r);

rectangle *divide (rectangle *r) {

rectangle *quadrantes[4];

quadrantes[0].x = r->x;
quadrantes[0].y = r->y;
quadrantes[0].w = (r->w)/2;
quadrantes[0].h = (r->h)/2;

quadrantes[1].x = r->x;
quadrantes[1].y = (r->y)+((r->h)/2)
quadrantes[1].w = (r->w)/2;
quadrantes[1].h = (r->h)/2;

quadrantes[2].x = (r->x)+((r->w)/2)
quadrantes[2].y = (r->y)+((r->h)/2)
quadrantes[2].w = (r->w)/2;
quadrantes[2].h = (r->h)/2;

quadrantes[3].x = (r->x)+((r->w)/2)
quadrantes[3].y = r->y;
quadrantes[3].w = (r->w)/2;
quadrantes[3].h = (r->h)/2;

return quadrantes;

}

Obrigado

[Ferreira]

Porque aquilo o left-value (aquilo a que estás a tentar atribuir um valor) não é uma variável.

O que estás a tentar fazer nessa linha?

[pedrosorio]

Eu não estou a perceber como é que essa função divide compila. Tu dás-lhe tipo de retorno rectangle* mas estás a devolver quadrantes que teoricamente é rectangle**

[Barassa]

queria passar os rectangulos devolvidos pelo divide para verificar se intersectam

como devo fazer entao ?

[Barassa]

.... alguem ..?

[pedrosorio]

A tua função divide não está a dar erros na compilação? Tens rectangle *quadrantes[4]; que é um array de apontadores. Depois fazes: quadrantes[0].x = r->x;

quadrantes[0].x ? quadrantes[0] supostamente é um apontador para rectangle. Quanto muito seria quadrantes[0]->x.

Depois estás a tentar declarar um array e atribuir-lhe um array criado numa função. Impossível.

Aquilo que é possível fazer é devolver apontadores, mas como tu crias quadrantes dentro da função divide, quando fazes return toda a memória desse array é libertada. A única forma de fazeres isso é alocares memória dinamicamente (malloc) e alterares essa memória, devolvendo depois o apontador e atribuindo-o ao apontador declarado cá fora. Ou seja, no intersect terias:

rectangle **quadrantes = divide®;

E depois

rectangle **divide(rectangle *r) {

rectangle **quadrantes=(rectangle**) malloc(4*sizeof(rectangle*));

etc. etc.

return quadrantes;

}

Atenção que terias que ter cuidado para libertar a memória alocada (apesar de não ser muita).

[Barassa]

Sim ... Muito obrigado .. Acho que fica assim ...

#include <math.h>
#include "rectangle.h"
#include "quadtree.h"





/*Verifica se o rectangulo apontado por t colide mais do que 1 vez com

um dos quadrantes do rectangulo apontado por r*/

int intersects (rectangle *r, rectangle *t) {



int count = 0;

rectangle **quadrantes = divide(r);


printf("Dentro do Intersect:\nQuadrante 0 \nX: %d Y: %d W: %d H: %d\n", quadrantes[0]->x , quadrantes[0]->y , quadrantes[0]->w , quadrantes[0]->h);

if (colide(quadrantes[0], t) == 1) // Colide com o 1 quadrante
{ 
count++;
}

if (colide(quadrantes[1], t) == 1) //Colide com o 2 quadrante
{
count++;
}

if (colide(quadrantes[2], t) == 1) //Colide com o 3 quadrante
{
count++;
}

if (colide(quadrantes[3], t) == 1) //Colide com o 4 quadrante
{
count++;

}


if (count > 1) // Se colidir com mais de 1 quadrante nao se pode dividir devolve 1
{
    return 1; 
}


return 0; // senao devolve 0



}



/*Divide o rectangulo apontado por r em 4 quadrantes, e retorna estes

num vector de rectangulos*/

rectangle **divide (rectangle *r) {

rectangle **quadrantes=(rectangle**) malloc(4*sizeof(rectangle*));

//printf("Rectangulo A dividir \nX: %d Y: %d W: %d H: %d\n", r->x , r->y , r->w , r->h);

rectangle um;

um.x = r->x;

um.y = r->y;

um.w = (r->w)/2;

um.h = (r->h)/2;
//printf("Rectangulo 1 da divisao X: %d Y: %d W: %d H: %d\n", um.x , um.y , um.w , um.h);


rectangle dois;

dois.x = r->x;

dois.y = (r->y)+((r->h)/2);

dois.w = (r->w)/2;

dois.h = (r->h)/2;


rectangle tres;

tres.x = (r->x)+((r->w)/2);

tres.y = (r->y)+((r->h)/2);

tres.w = (r->w)/2;

tres.h = (r->h)/2;


rectangle quatro;

quatro.x = (r->x)+((r->w)/2);

quatro.y = r->y;

quatro.w = (r->w)/2;

quatro.h = (r->h)/2;

quadrantes[0] = &um;
quadrantes[1] = &dois;
quadrantes[2] = &tres;
quadrantes[3] = &quatro;


return quadrantes;



}


/* Verifica se 2 rectângulos colidem, se sim retorna 1.*/
int colide ( rectangle *r1 , rectangle *r2)
{

int u1 = r1->x + r1->w;
int v1 = r1->y + r1->h;
int u2 = r2->x + r2->w;
int v2 = r2->y + r2->h;

printf("\nRectangulo 1 \nX: %d Y: %d U: %d V: %d", r1->x , r1->y , u1 , v1);
printf("\nRectangulo 2 \nX: %d Y: %d U: %d V: %d", r2->x , r2->y , u2 , v2);

if((r1->x <= u2) && (u1 >= r2->x) && (r1->y <= v2) && (v1 >= r2->y))
{
return 1;
}
return 0;
}

Bem supostamente eu na função intersect tou a passar mal o argumento quadrante porque tao-me a dar numeros gigantescos para o rectangulo quando faço print na função colide. Como se passa como deve ser ?

[Barassa]

void organize (rectangle quad [], Quadtree * tree, Quadtree_Node * node, rectangle * r, rectangle * t) {
if (node == NULL) //Se o node onde se quer inserir nao existe
{
	node = create_node(tree, node); //Cria o node
}

/*Verifica se o rectângulo pertence a este node, se sim adiciona, se não executa esta função para um dos
quatro quadrantes do rectângulo onde se queria inserir.*/
if (intersects(quad, r, t)==1) // Se na proxima divisao que vem o rectangulo nao se pode dividir
{
	printf("Adicionado ao node o rectanglo com coordenadas X:%d Y:%d\n", t->x , t->y);
	addToNode(node, t); // Adiciona o rectangulo ao node
	printf("\nAdicionado\n");
}
else
	printf("Rectangulo Grande \nX: %d Y: %d W: %d H: %d\n",r->x , r->y , r->w , r->h);

divide(quad , r);
if (colide(&quad[0], t) == 1)
{
	printf("Colisao no 1 quadrante");
	organize(quad , node->rect[0], node, &quad[0], t);
}

//exit(0);

if (colide(&quad[1], t) == 1)
{
	printf("Colisao no 2 quadrante");   
	organize(quad , node->rect[1], node, &quad[1], t);
}


if (colide(&quad[2], t) == 1)
{
	printf("Colisao no 3 quadrante");
	organize(quad, node->rect[2], node, &quad[2], t);
}


if (colide(&quad[3], t) == 1)
{
	printf("Colisao no 4 quadrante");
	organize(quad , node->rect[3], node, &quad[3], t);
}
}

Supostamente se executa o if não faz o else né? Mas ele ta a entrar no if do intersect e adicionar ao node e depois ainda vai testar as outras condições. 😉

[pedrosorio]

Tens que pôr {} a seguir ao else

[TheDark]

Se indentares o código torna-se mais fácil ver o erro apontado pelo pedrosorio.