Juanjo Santolaya Blog

Ahí lo tenemos el profe de IA2 en el programa REDES de TVE , que espectáculo …

[youtube=http://www.youtube.com/watch?v=MEiTY8sXez8]

ShareThis

El otro día nos sacaron de excursión por la ETSE, a ver como estaba montada la red de datos. Algunas fotillos de los “armarios”, los switch y las conexiones… también el túnel que atraviesa la ETSE y toda la Autónoma bajo tierra con un montón de cableado de fibra óptica hacia el Servei d’Informàtica y al Punt d’Informació Científica.

ShareThis

Reflexiones sobre la asignatura Xarxes de Computadors II y sobre el proceso de Bolonia en general del compañero David González Roldán y publicado en el fórum de la asignatura:

Una mica d’humor (negre)

Bé, com ja es ben sabut per tots nosaltres Xarxes II és l’assignatura que disposa dels més avançats i sofisticats mètodes per impedir que els alumnes la cursin amb éxit, després de les ja abrumadores i terrorifiques wikis amb les seves entregues de problemes (que sinó el temible Scriptator ens treu els permissos!!), les malicioses ampliacions de temari (o com fer de professor per 0 euros) i el seu fatídic treball de camp (volta la feixa mandrós!! a treballar!), després de tot això arriba el desenllaç, els temibles examens.

Amb gairebé 7 kilos d’apunts probablement se’ns faci passar l’examen amb més contingut teòric de la carrera (disculpant els 10 kilos de fulls de Planificació de Sistemes, fulls que mai es llegiran no cal dir), doncs bé, esperem que després d’haver-nos “obligat” a anar a classe amb les “voluntàries” activitats (jo creia que si era voluntari no podia baixar nota!), aquestes classes magistrals ens permetin superar una prova que no serà test, òbviament perquè podria donar-se el cas de que algú aprovés per sort (jajajjajajaa).

Ara bé, això és tot? No, la màquina implacable de xarxes no descansa, nois, us toca validar les pràctiques. Recordeu les pràctiques? Com oblidar les caigudes dels sistemes, els errors en els fitxers proporcionats, les interminables hores per resoldre problemes que anaven apareixent a la que et descuidaves, les mil i una lectures de manuals, rfcs i més documentació addicional. Doncs bé, com ja sabeu ara toca avaluar la última pràctica, per què? Perquè no ens la van avaluar a classe.
Fins aqui bé, però sabent que hi ha moltes persones que no han contestat totes les preguntes, moltes d’elles òbviament perquè no es sabien fer (teacherrrrrrrrrrr), d’altres que dubten de si ho han fet bé i la resta que confia en que hagi estat així… com es pot fer un examen de validació de 4 preguntes tipus test i dir: Aquest alumne si, aquest no, si, si, no, no, no,… Això és com intentar abarcar l’espectre de colors en el blanc i el negre. Per què no es penjen les solucions? Si, entenc la preocupació, podria ser que algú aprovés sense haver fet les pràctiques, d’acord…sempre és millor que suspenguin gent que tingui mala sort en el moment de l’examen però porti tot el curs treballant.
M’encanta la bolonyesa, especialment per no ser del pla de bolonya i viure-hi (o morir-hi).

En conclusió, s’hauria de plantejar pujar la càrrega de crèdits de l’assignatura, més que res per afrontar la crua realitat. A ningú se li escapa que és l’assignatura que més feina dona i no som superhomes ( o superdones).

Salut i bona sort a tothom. La necessitareu.

P.D.: No pretenc ofendre a ningú, simplement em prenc amb clau d’humor la meva percepció de l’assignatura.

ShareThis

Microsoft, gracias a un programa de ayuda a los estudiantes o algo parecido; nos ofrece su software gratis. Cuando hablo de que nos ofrece su software gratis, me refiero a nosotros, los estudiantes de la ETSE de la UAB. Su producto estrella del año: Windows Vista en su versión Business también. Cómo no, nos sale la curiosidad de por qué no probarlo y empezamos su descarga. Ahí ya viene la primera dificultad: son 4 cd’s que se bajan uno a uno a través de un ejecutable que primero te descargas a tu disco duro y de ahí te descarga el cd. Las velocidades de transferencias son lentísimas, da igual que tengas una conexión rápida. Además, a parte de tener que estar identificado en la red de la UAB (ya sea por VPN o porque estés aquí) para descargar el “exe”, tienes que seguir enchufado a ella hasta descargar los 4 discos. Ah! Como pierdas la conexión y ejecutes el “exe” varias veces quizás te peta y tendrás que solicitar a Microsoft que te deje volver a descargarlo otra vez. Esto me ocurrió en una ocasión e hice un apaño ya que aún estoy esperando que Microsoft me responda.

Una vez los descargo, los grabo …etc, me dispongo a instalar el nuevo sistema operativo de Microsoft. Más de 2 horas de instalación!!! Le cuesta mucho arrancar pero al final lo consigue. Es evidente que aunque lo tenga en una partición diferente de mi Ubuntu. te borra el sistema GRUB de arranque (claro, quiero ser tu único sistema operativo). Por defecto te dice que las opciones de visualización se adaptarán al rendimiento de tu equipo, pero eso es falso ya que vienen todos los efectos Aero activados y eso ralentiza un montón el ordenador. Estuve más de 30 minutos para poder descubrir dónde se esconden las opciones para modificar esos parámetros… y es que eso sí , es un sistema operativo en que el usuario administrador parece no tener control total sobre él, es decir que él ya se ocupa de pensar y decidir por tó lo que es mejor y lo que quieres.

Sobre las conexiones de red en este Windows Vista también hay algo que decir, como antes comentaba, tampoco tienes control total sobre ellas, muchos parámetros como la ip o las puertas de enlace y otras informaciones de la red te son ocultados y para descubrirlos parece que tengas que hacer una instancia. La seguridad parece que tampoco es tan buena como en Ubuntu y además aunque te conectes a la misma red pero desde un punto de acceso diferente, el sistema operativo no lo sabe y le tienes que decir que la guarde y o sé que más historias como si estás en casa o en el trabajo… que en el fondo no sirve de nada ya que te tocará un montón de parámetros que seguramente no los querrás así.

Y por último, otro dia seguiré con más cosas si no lo elimino para siempre de mi disco duro, es la lentitud extrema a la hora de copiar archivos a y desde el disco duro a otra parte del disco duro, a un dispositivo flash o incluso eliminarlos. Une gestión de ficheros pésima.

No os lo instaléis!

ShareThis

En los comentarios de este post todos a poner su opinión sobre la gran asignatura (irónico) de 4 horas de examen y 0.5 de media de nota en la clase.

“No té més”

ShareThis

Segundo Parcial ETSE UAB

Sobre el ejercicio 1, la Memoria Principal se organiza con bloques de 2 palabras.

Para el apartado a) donde se pide la secuencia de referencias a bloque que se producen en la ejecución del programa, la cosa es tan simple como:

1- Ir siguiendo el código ensamblador
2- Anotar en el diagrama de secuencias la posición de memoria donde está esa instrucción
3- Si en la instrucción de memoria se hace referencia a una variable de vector como bvec o avec, hay que indicar su posición de memoria seguidamente.
4- Después del loop la variable se incrementará y entonces también la posición de memoria donde iremos a buscar los vectores, esto pasará a partir de la tercera iteración.

ShareThis

Ovación

[youtube=http://www.youtube.com/watch?v=4GlXdkZVlcs">

El profe invitando a los alumnos

ShareThis

Ahora nos intentan vender la moto de que nos tenemos que adaptar al EEES (Espacio Europeo de Educación Superior). Todo esa parafernalia de que tenemos que ser iguales que Europa, de que todo tiene que ser compatible y sin ningún problema. En primer lugar, 2+2 serán siempre 4 y una transformada de Fourier o de Laplace será lo mismo aquí y en Grecia. Pues bien, en nuestra ETSE de la UAB los estudiantes de ingeniería informática tenemos que ir superando obstáculos peldaño a peldaño y ojo no te caigas en uno que como ahora los métodos son tan “modernos” y “continuados” no hay segundas convocatorias.

Al principio todo parece perfecto, mucho trabajillo en caasa, se valorará las horas de estudio del alumno, etc. Esto en principio es bueno, el problema es que para hacer un seguimiento de ese trabajo, el profesor tiene que trabajar el doble. Aquí debemos ser en cuarto curso unos 100 y pico alumnos por clase y hay dos grupos
así que perfectamente podríamos llegar hasta casi 300. El gran invento de los profes es unir a todo el mundo en grupitos de … tachán: 5 y 6 personas!!! de esta forma corrigen mucho menos .. tan facil como hacer la cuenta de la vieja 300 / 6 . Es un follón todo esto! Nunca podemos quedar todos juntos, millones de informes que no sirven para nada y que dudo que todos los profes se lean … Ah! y como necesites trabajar durante el curso para sacarte la carrera, olvídate porque te harán firmar al entrar en algunas aulas y muy pocos profes son flexibles con estas cosas.

Luego vienen los exámenes parciales … en principio la idea es buena ya que vas recortándote materia … pero también es una trampa porque como caigas en uno de ellos no podrás recuperarlo hasta lo que entendiamos la convocatoria ordinaria de febrero (siempre la primera) … pero gracias al plan Bolonia la convocatoria de febrero se convierte en la segunda si tropiezas en un obstáculo … es decir que si la mitad de la asignatura no te la sacas, en febrero te examinas de todo (lo que era lo normal) pero para la segunda mitad de la asignatura solamente tienes una oportunidad de superarla.

Todo esto es lo que sucede en general, en las asignaturas de la ETSE UAB en 4º curso de ingeniería informática.

Salut

ShareThis

A ver pimponacos de la ETSE! ya han salido las notas de Enginyeria del Software … lo publico por si miráis antes esta cosa (mi blog) que la página del cvc.

Las notas están en la página esta:

(PDF) http://www.cvc.uab.es/shared/teach/a20363/es1blln06.pdf

ShareThis

Lo tenía por ahí y antes de que se heche a perder…

#include
#include
#include
#include
#include
#include
#include
#include

/***********************************************/
/* Deficinicio de les estructures del programa */
/***********************************************/
typedef struct Punt { int x,y; } Punt;
typedef struct Poligon { int n,color; Punt *p; } Poligon;
typedef struct Xwindow { int x0,x1,y0,y1; } Xwindow;

typedef struct Pila
{ Punt *p;
struct Pila *anterior;
} Pila;

typedef struct Costat
{ float x, dx;
int ymax;
struct Costat *seg;
} Costat;
/***********************************************/

int llegir_poligon (char *, Poligon *);
void alliberar_poligon(Poligon *);
void llegir_comandes(char *, char *);
void inicialitzar(void);
void finalitzar(void);
int cls(void);

int mode_grafic(void);
int mode_texte(void);

/********************************************************************/
/* PROTOTIPUS DE LES FUNCIONS */
/********************************************************************/

/* Prototipus del retall Sutherland-Hogman */
void retall_SH(int,int,int,int,Poligon *);
void interseccio(Punt *,Punt *,Xwindow *,int);
int dintre(int,int,Xwindow *,int);

/* Llavor millorada (iterativament i amb una pila dinamica) */
void llavor_millorat(int,int,Poligon *,int);
void vei(int *,int,int,int);
void lineas_adjacents(int,int,int,Pila **,int);
Poligon* intercambiar(Poligon** pol);

void Finestra(Xwindow *,int);
void DibuixaPoligon(Poligon *,int);
float pendent(int,int,int,int);

/* Prototipus per a la pila que sutilitza en la llavor millorada */
Pila* Crear_node();
void Push(Pila **,Punt);
Punt Pop(Pila **);

/* Prototipus del algorisme Y-X */

void emplenat_Y_X(Poligon *);
void Y_max_min(int *max,int *min,Poligon *pol);
Costat** crear_TC(Poligon *pol,int max,int min);
void iniciar_a_null(Costat **tabla,unsigned int valor);
Costat* crear_lado(Poligon *pol,unsigned int *vertice,unsigned int *min,long
int *dy);
void guardar_TC(Costat** TC, Costat* lado,unsigned int y_min);
int alliberar_TC(Costat **taula);
void afegir_costats_LCA(Costat* lista,Costat** LCA);
Costat *ordenar_LCA(Costat* llista);
Costat* mezclar_listas(Costat* lista1,Costat* lista2);
int eliminar_lados_LCA(Costat** llista,int y_actual);
void actualizar_LCA(Costat** llista);
void pintar(Costat* lista,int posicion_y);

/* —————————————————————–*/

/*************************************************/
/* M A I N */
/*************************************************/

void main(int argc,char *argv[])
{
if(argc!=3)
{
printf(”Us: prac \n”);
exit(0);
}

inicialitzar();
llegir_comandes(argv[1],argv[2]);
finalitzar();
}

void llegir_comandes(char *nom_fitxer,char *nom_poligon){

FILE *fp;
Poligon pol;
char comanda[256], comentari[256];
int x0, y0, x1, y1, color;

if ((fp=fopen(nom_fitxer,”rt”))==NULL)
{
printf(”Error en obrir el fitxer de comandes\n”);
getch();
finalitzar();
exit(0);
}

if (strcmp(nom_poligon,”"))
{ if (!llegir_poligon(nom_poligon,&pol))
{ printf(”Error en obrir el poligon \n”);
getch();
finalitzar();
exit(0);
}
}

while (fscanf(fp,”%s”,comanda)!=EOF)
{ /* COMANDES GENERALS */

if (strcmp(comanda,”REM”)==0) fgets(comentari,256,fp);
else if (strcmp(comanda,”CLS”)==0) {cls();}
else if (strcmp(comanda,”PAUSA”)==0) {getch();}
else if (strcmp(comanda,”RETALLA”)==0)
{ fscanf(fp,”%d”,&x0);
fscanf(fp,”%d”,&y0);
fscanf(fp,”%d”,&x1);
fscanf(fp,”%d”,&y1);
retall_SH(x0,y0,x1,y1,&pol);
}

else if (strcmp(comanda,”OMPLE”)==0)
{ emplenat_Y_X(&pol);
getch();
cls();
DibuixaPoligon(&pol,4);
}

else if (strcmp(comanda,”LLAVOR”)==0)
{ fscanf(fp,”%d”,&x0);
fscanf(fp,”%d”,&y0);
fscanf(fp,”%d”,&color);
llavor_millorat(x0,y0,&pol,color);
getch();
}

/* COMANDO NO RECONOCIDO */
else {printf(”comanda: %s no reconeguda\n”,comanda);}
} if (strcmp(nom_poligon,”")!=0) alliberar_poligon(&pol);
}

void inicialitzar()
{ if(mode_grafic()==0)
{ printf(”Error en inicialitzar”);
exit(0);}
}

void finalitzar()
{ if(mode_texte()==0)
{ printf(”Error en finalitzar”);
exit(0);}
}

int llegir_poligon(char *nom_fitxer, Poligon *pol){

FILE *fitx_in;
int i;

pol->n=0;
pol->color=0;
pol->p=NULL;

fitx_in=fopen(nom_fitxer,”rt”);
if(!fitx_in) return 0; /* No s’ha pogut obrir */

if(fscanf(fitx_in,”%d”,&pol->n)!=1){
pol->n=0;
fclose(fitx_in);
return 0;
} /* No pot llegir */

/*Reserva de memoria pels punts del poligon*/
pol->p=(Punt *)malloc(sizeof(Punt)*pol->n);

if(!pol->p){

pol->n=0;
fclose(fitx_in);
return 0;
} /* No es pot aconseguir memoria */

for(i=0;in;i++) {
if(fscanf(fitx_in,”%d %d”,&(pol->p[i].x),&(pol->p[i].y))!=2){
pol->n=0;
free(pol->p);
pol->p=NULL;
fclose(fitx_in);
return 0;
}
}
return 1;
}

void alliberar_poligon(Poligon *pol)
{

if( (pol->p) != NULL )
{
free(pol->p);
pol->p=NULL;
pol->color=NULL;
pol->n=0;
}
}

int cls()
{ cleardevice();
return 1;
}

int mode_grafic()
{ int gdriver=DETECT,gmode,errorcode;

initgraph(&gdriver,&gmode,”h:\\”);
errorcode=graphresult();
if (errorcode!=grOk)
{ printf(”Error: %s\n”,grapherrormsg(errorcode));
printf(”Prem una tecla per continuar”);
getch();
return 0;
}
return 1;
}

int mode_texte(){
closegraph();
return 1;
}

/*********************************************************/
/* Nomes incloure codi a partir d’aquest punt */
/*********************************************************/

void retall_SH(int x0,int y0,int x1,int y1,Poligon *pol)
{
int vertex,recta,anterior,actual,last,i;
Poligon tmp;
Xwindow window1;
Punt s;

if (pol->n==0){/*Es por si nos pasa un poligono vacio*/
printf(”Poligon inexistent”);
exit(1);
}
tmp.p=(Punt *)malloc( sizeof(Punt) * 2 * (pol->n) );
if( (tmp.p) == NULL) {printf(”RAM1 out”);exit(0);}
tmp.n=0;
tmp.color=0;

window1.x0 = x0;
window1.x1 = x1;
window1.y0 = y0;
window1.y1 = y1;

DibuixaPoligon(pol,6);
Finestra(&window1,2);

for(recta=0;recta<4;recta++)
{
last=0;
s=(pol->p[(pol->n)-1]);
for(vertex=0;vertexn;vertex++)
{
anterior=dintre(s.x,s.y,&window1,recta);
actual=dintre(pol->p[vertex].x,pol->p[vertex].y,&window1,recta);

if (anterior==1 && actual==1) /*s i p a dintre => fikar p a tmp*/
{
tmp.p[last].x=pol->p[vertex].x;
tmp.p[last].y=pol->p[vertex].y;
last++;
}

else if(anterior==1 && actual==0) /*s->adintre i p->afora => interseccio
a tmp*/
{ interseccio(&s,&pol->p[vertex],&window1,recta);
tmp.p[last].x=s.x;
tmp.p[last].y=s.y;
last++;
}

else if(anterior==0 && actual==1) /*s->afora i p->adintre =>
interseccion i p a tmp*/
{
interseccio(&s,&pol->p[vertex],&window1,recta);
tmp.p[last].x=s.x;
tmp.p[last].y=s.y;
last++;
tmp.p[last].x=pol->p[vertex].x;
tmp.p[last].y=pol->p[vertex].y;
last++;
}
s=(pol->p[vertex]);
}
alliberar_poligon(pol);
if (last==0){/*Es por si al recortar da un poligono vacio*/
printf(”Poligon inexistent”);
exit(1);
}
pol->p=(Punt *)malloc(sizeof(Punt)*(last) );
if(pol->p==NULL) {printf(”RAM2 out”);exit(0);}
pol->n=last;
pol->color=tmp.color;
for(i=0;in;i++)
{ pol->p[i].x=tmp.p[i].x;
pol->p[i].y=tmp.p[i].y;
}

}
alliberar_poligon(&tmp);
DibuixaPoligon(pol,4);
getch();
cleardevice();
DibuixaPoligon(pol,4);
getch();
}

float pendent(int s0,int s1,int p0,int p1)
{
if(s0==p0) return(0);
else return( (float)(s1-p1) / (float)(s0-p0) );
}

void llavor_millorat(int x0,int y0,Poligon * pol,int color)
{
int cont_e,cont_d,color_ini;
Punt *s=NULL;
Pila *stack=NULL;

s=(Punt *)malloc(sizeof(Punt));
s->x=x0;
s->y=y0;

color_ini=getpixel(x0,y0);
DibuixaPoligon(pol,4);
setcolor(color);
Push(&stack,*s);

while(stack!=NULL)
{ *s=Pop(&stack);
cont_e=s->x; cont_d=s->x;

vei(&cont_e,s->y,color_ini,-1);
vei(&cont_d,s->y,color_ini,1);
line(cont_e,s->y,cont_d,s->y);
if( (s->y>=0) && (s->y<=getmaxy()) ){
lineas_adjacents(cont_e,cont_d,(s->y)-1,&stack,color_ini);
lineas_adjacents(cont_e,cont_d,(s->y)+1,&stack,color_ini);
}
}
free(s);
}

void lineas_adjacents(int xe,int xd,int y,Pila **stack,int color)
{
int out,axx,ayy;
Punt tmp;

out=xe;
while(out<=xd)
{ getpixel(out,y);
if( getpixel(out,y)==color )
{ vei(&out,y,color,1);
tmp.x = out;
tmp.y = y;
Push(&(*stack),tmp);
out++;
} else out++;
}
}

void Finestra(Xwindow *wind,int color)
{
setcolor(color);
rectangle(wind->x0,wind->y0,wind->x1,wind->y1);
}

void DibuixaPoligon(Poligon *poli,int color)
{
int tmp,tmp2;

tmp2=getcolor();
setcolor(color);
for(tmp=0;tmpn)-1;tmp++)
line(poli->p[tmp].x,poli->p[tmp].y,poli->p[tmp+1].x,poli->p[tmp+1].y);
line(
poli->p[(poli->n)-1].x,poli->p[(poli->n)-1].y,poli->p[0].x,poli->p[0].y);
setcolor(tmp2);
}

int dintre (int x0,int y0,Xwindow *fines,int codig)
{ /* 0=arriba 1=derecha 2=abajo 3=izquierda */

if(codig==0)
{ if ( (y0) > (fines->y0) ) return 1;
else return 0;}

if(codig==1)
{ if ( (x0) x1) ) return 1;
else return 0;}

if(codig==2)
{ if ( (y0) y1) ) return 1;
else return 0;}

if(codig==3)
{ if ( (x0) > (fines->x0) ) return 1;
else return 0;}
return 0;
}

Pila* Crear_node()
{
Pila *aux=(Pila *)malloc(sizeof(Pila));
if(aux==NULL)
{ printf(”No hi ha memoria RAM lliure disponible…\n”);
getche();
exit(1);
}
return aux;
}

void Push(Pila **cab,Punt s)
{
Pila *aux=Crear_node();
aux->p->x=s.x;
aux->p->y=s.y;

if(cab==NULL) aux->anterior=NULL;
else
{ aux->anterior=*cab;
*cab=aux;}
}

Punt Pop(Pila **cab)
{
Pila *aux;
Punt s;
//s=(Punt *)malloc(sizeof(Punt));

if(*cab==NULL)
printf(”Error: pila buida\n”);
else
{ aux=*cab;
*cab=(*cab)->anterior;
s.x=aux->p->x;
s.y=aux->p->y;
free(aux);
}

return s;
}

void interseccio(Punt *s, Punt *p, Xwindow *wind,int recta)
{
float x_one=0, y_one=0;
Punt *intersec;

if(recta==0)
//calcula_int();
{ if(s->x==p->x)
{ x_one = p->x;
y_one = wind->y0;
}
else
{ x_one = p->x + (float)(wind->y0 - p->y) * pendent(s->y,s->x,p->y,p->x);
y_one = wind->y0;
}
}

if(recta==1)
{ y_one = p->y + (float)(wind->x1 - p->x) * pendent(s->x,s->y,p->x,p->y);
x_one = wind->x1;
}

if(recta==2)
{ if(s->x==p->x)
{ x_one = p->x;
y_one = wind->y1;
}
else
{ x_one = p->x + (float)(wind->y1 - p->y) * pendent(s->y,s->x,p->y,p->x);
y_one = wind->y1;
}
}

if(recta==3)
{ y_one = p->y + (float)(wind->x0 - p->x) * pendent(s->x,s->y,p->x,p->y);
x_one = wind->x0;
}

s->x=(int)(x_one+0.5);
s->y=(int)(y_one+0.5);

}

void vei(int *x,int y,int color_a,int suma)
{ while( (getpixel(*x,y)==color_a)&&((*x)=0) )
{ (*x)=(*x)+suma; }
(*x)=(*x)-suma;
}

void emplenat_Y_X(Poligon * pol){
Costat **TC,*LCA=NULL,*aux;
int y_max=0,y_min=getmaxy(),i,out=0;

DibuixaPoligon(pol,1);
setcolor(14);
Y_max_min(&y_max, &y_min, pol);
TC=crear_TC(pol,y_max,y_min);
for(i=0;i<y_max-y_min;i++) /*Recorremos toda la TC*/
{
if(TC[i])
afegir_costats_LCA(TC[i],&LCA);
/* if((i)==190){
aux=LCA;
while(aux){
printf(” %f %f %d\n”,aux->x,aux->dx,aux->ymax);
aux=aux->seg;
}
printf(”\n”);
}*/
LCA=ordenar_LCA(LCA);
/* if((i)==190){
aux=LCA;
while(aux){
printf(” %f %f %d\n”,aux->x,aux->dx,aux->ymax);
aux=aux->seg;
}
printf(”\n”);
}*/
pintar(LCA,i+y_min);
do{
out=eliminar_lados_LCA(&LCA,i+y_min);
}while(out);
/* if((i)==189){
aux=LCA;
while(aux){
printf(” %f %f %d\n”,aux->x,aux->dx,aux->ymax);
aux=aux->seg;
}
printf(”\n”);
}*/
actualizar_LCA(&LCA);
}
if(!alliberar_TC(TC))
printf(”Error al liberar la TC”);
}

void afegir_costats_LCA(Costat* lista,Costat** LCA){
Costat *auxiliar=*LCA;

if(*LCA){/*La LCA tiene como minimo un campo*/
while(auxiliar->seg) auxiliar=auxiliar->seg;
auxiliar->seg=lista;
}else/*La LCA esta a vacia*/
*LCA=lista;

}

Costat *ordenar_LCA(Costat *llista){
Costat *llista1, *llista2;

if (!(llista->seg) || !(llista))
return llista;
llista1 = llista;
llista2 = llista1->seg->seg;
while (llista2 && llista2->seg ) {
llista1 = llista1->seg;
llista2 = llista2->seg->seg;
}
llista2 = llista1->seg;
llista1->seg = NULL;
llista1 =ordenar_LCA(llista);
llista2 =ordenar_LCA(llista2);
llista = mezclar_listas(llista1, llista2);
return llista;
}

Costat* mezclar_listas(Costat* lista1,Costat* lista2){
Costat *lista, *auxiliar;

if (lista1->x > lista2->x){
lista= lista2;
lista2 = lista2->seg;
}else{
lista = lista1;
lista1 = lista1->seg;
}
auxiliar = lista;
while (lista1 && lista2) {
if (lista1->x > lista2->x) {
auxiliar->seg = lista2;
lista2 = lista2->seg;
}else {
auxiliar->seg = lista1;
lista1 = lista1->seg;
}
auxiliar = auxiliar->seg;
}
if (lista1)
auxiliar->seg = lista1;
else if (lista2)
auxiliar->seg = lista2;

return lista;
}

int eliminar_lados_LCA(Costat** llista,int y_actual){
Costat* auxiliar=*llista,*temporal;
int salida=0;

if(auxiliar->ymax<=y_actual){
temporal=*llista;
(*llista)=(*llista)->seg;
free(temporal);
salida=1;
}else{
while(auxiliar){
if(auxiliar->seg->ymax<=y_actual){
temporal=auxiliar->seg;
if(auxiliar->seg->seg)
auxiliar->seg=auxiliar->seg->seg;
else
auxiliar->seg=NULL;
free(temporal);
salida=1;
}
auxiliar=auxiliar->seg;
}
}
return(salida);
}
void actualizar_LCA(Costat** llista){
Costat *auxiliar=*llista;

while(auxiliar){
auxiliar->x+=auxiliar->dx;
auxiliar=auxiliar->seg;
}
}

void pintar(Costat* lista,int posicion_y){
Costat *auxiliar=lista;
while(auxiliar){
line((int)(auxiliar->x+0.5),(int)(posicion_y+0.5),(int)(auxiliar->seg->x+0.5),(int)(posicion_y+0.5));
auxiliar=auxiliar->seg->seg;
}
}

void Y_max_min(int *max,int *min,Poligon *pol){
int cont;

*max=0;
*min=getmaxy();

for(cont=0;contn;cont++){
if( *max p[cont].y){/*Saca la y maxima del poligon*/
*max=pol->p[cont].y;
}
if(*min>pol->p[cont].y){/*Saca la y minima del poligon*/
*min=pol->p[cont].y;
}
}
}

Costat** crear_TC(Poligon *pol,int max,int min){
Costat **taula;
Costat *A,*B,*inicio;
unsigned int y_min_lado,vertex=1;
long int dyA,dyB,dyI;

taula= (Costat**) malloc(sizeof(Costat*) * (max-min));
iniciar_a_null(taula,max-min);
A=crear_lado(pol, &vertex, &y_min_lado, &dyA);
inicio=crear_lado(pol, &vertex, &y_min_lado, &dyI);
guardar_TC(taula, A, y_min_lado-min);
vertex++;
while((vertexn) && (B=crear_lado(pol, &vertex, &y_min_lado, &dyB))){
if(dyB * dyA>=0){/*Mismo signo, sacamos un punto a B*/
if(dyB>0){/*Baja*/
y_min_lado++;
(B->x)+=(B->dx);
}else{/*Sube*/
(B->ymax)–;
}
}
if(vertex==pol->n){
if(dyB * dyI>=0){/*Mismo signo, sacamos un punto a B*/
if(dyI>0){/*Baja*/
(B->ymax)–;
}else{/*Sube*/
y_min_lado++;
(B->x)+=(B->dx);
}
}
}
guardar_TC(taula,B,y_min_lado-min);
dyA=dyB;
A=B;
vertex++;
}
if (inicio)
free(inicio);
return(taula);
}
void iniciar_a_null(Costat **tabla,unsigned int valor)
{ unsigned int cont=0;
for(cont=0;cont<valor;cont++) tabla[cont]=NULL;
/*Recorremos toda la TC poniendo sus punteros a NULL*/

}

Costat* crear_lado(Poligon *pol,unsigned int *vertice,unsigned int *min,long
int *dy){

Costat *lado;
float m;

if(*verticen){/*Del 1er vertice al penultimo*/
m=pendent(pol->p[*vertice].x,pol->p[*vertice].y,pol->p[*vertice-1].x,pol->p[*vertice-1].y);
if(pol->p[*vertice-1].y!=pol->p[*vertice].y){/*Mira si es horizontal*/
lado=(Costat*) malloc(sizeof(Costat));
lado->seg=NULL;
if(m==0)
lado->dx=0;
else
lado->dx=1.0/m;
if(pol->p[*vertice-1].yp[*vertice].y){/*Baja*/
lado->x=pol->p[*vertice-1].x;
lado->ymax=pol->p[*vertice].y;
*min=pol->p[*vertice-1].y;
}else{/*Sube*/
lado->x=pol->p[*vertice].x;
lado->ymax=pol->p[*vertice-1].y;
*min=pol->p[*vertice].y;
}
*dy=(pol->p[*vertice].y)-(pol->p[*vertice-1].y);
}else{/*Es horizontal*/
(*vertice)++;
lado=crear_lado(pol,vertice,min,dy);

}

}else{/*El ultimo vertice es pasado de parametro*/
m=pendent(pol->p[0].x,pol->p[0].y,pol->p[*vertice-1].x,pol->p[*vertice-1].y);
if(pol->p[*vertice-1].y!=pol->p[0].y){/*Para saber si es horizontal*/
lado=(Costat*) malloc(sizeof(Costat));
lado->seg=NULL;
if(m==0)
lado->dx=0;
else
lado->dx=1.0/m;
if(pol->p[*vertice-1].yp[0].y){/*Baja*/
lado->x=pol->p[*vertice-1].x;
lado->ymax=pol->p[0].y;
*min=pol->p[*vertice-1].y;
}else{/*Sube*/
lado->x=pol->p[0].x;
lado->ymax=pol->p[*vertice-1].y;
*min=pol->p[0].y;
}
*dy=(pol->p[0].y)-(pol->p[*vertice-1].y);
}else lado=NULL; /*Es horizontal y es el ultimo lado*/

}
return(lado);
}

void guardar_TC(Costat** TC, Costat* lado,unsigned int y_min){
Costat* aux=NULL;
if(!(TC[y_min])){/*La lista de este punto esta vacia*/
TC[y_min]=lado;
}else{/*La lista de este punto tiene como minimo un lado*/
aux=TC[y_min];
while(aux->seg){
aux=aux->seg;
}
aux->seg=lado;
}
}
int alliberar_TC(Costat ** taula){
if (taula)
free(taula);
return(1);
}

ShareThis