#include "stdafx.h"
#ifdef OLIVIA_COMPILA
//olivia
#include "olv_geom.h"
#include "olv.h"
#include "olv_limp.h"
#include "math.h"
//otros
#include "olv_tasks_def.h"
#include "dir_manager.h"
#include "StrArray.h"
/**
*	@file olv_geom.h
*	Archivo de definiciones de clase de varias utilidades geométricas del programa Olivia.
*/

//*************************************************************************************
//Funciones de las estructuras Dijkstra
/**
 * Función para la estructura del algoritmo Dijkstra, para iniciar el nodo
 */
void Djkt_nodo::inicia()
{
	dis = (float)MAYUSCULO;
	id_padre = -1;
	visto = FALSE;
	ids_ady.nady=-1;
	ids_ady.angs=NULL;
	ids_ady.i_conjs=NULL;
	ids_ady.ids_padre=NULL;
};
//*************************************************************************************
BOOL Djkt_nodo::inicia_ex( Djkt_ang_ady *ang )
{
	inicia();

	ids_ady=*ang;
	ids_ady.angs=NULL;

	if(!ids_ady.inicia_ids())
		return FALSE;

	
	return TRUE;
};
//*************************************************************************************
void Djkt_nodo::libera( )
{
	ids_ady.libera_ex();
};
//*************************************************************************************
/**
 * Función para la estructura del algoritmo Dijkstra, para iniciar la cola
 */
void Djkt_cola::inicia(Djkt_nodo *n)
{
	elem = NULL;
	nodos = n;
	nn=0;
};
//*************************************************************************************
/**
 * Función para la estructura del algoritmo Dijkstra, para poner en la cola
 */
BOOL Djkt_cola::pon(int i)
{
	return pon(i,-1);
};
//*************************************************************************************
/**
 * Función para la estructura del algoritmo Dijkstra, para poner en la cola
 */
BOOL Djkt_cola::pon(int i,int i_inci)
{
	int nv=200;
	Djkt_elem_cola *aux = new Djkt_elem_cola();
	Djkt_elem_cola *aux1 = elem;
	Djkt_elem_cola *aux2=NULL;
	while(!aux && nv>0)
	{

		nv--;
		Sleep(1);
		aux = new Djkt_elem_cola();
	}
	if(!aux)
		return FALSE;
	nn++;
	aux->id = i;
	aux->id_inci=i_inci;
	aux->sig = NULL;
	while (true)
	{
		if (!aux1)
		{
			elem = aux;
			break;
		}
		if (nodos[aux1->id].dis >= nodos[aux->id].dis)
		{
			aux->sig = aux1;
			if(aux2)
				aux2->sig=aux;
			if (aux1 == elem)
				elem = aux;
			break;
		}
		if (!aux1->sig)
		{
			aux1->sig = aux;
			break;
		}
		aux2=aux1;
		aux1 = aux1->sig;
	}
	return TRUE;
};
//*************************************************************************************
/**
 * Función para la estructura del algoritmo Dijkstra, para obtener de la cola
 */
int Djkt_cola::dame()
{
	return dame(NULL);
};
//*************************************************************************************
/**
 * Función para la estructura del algoritmo Dijkstra, para obtener de la cola
 */
int Djkt_cola::dame(int *id_inci)
{
	if (!elem)
		return -1;
	if(nn<=0)
	{
		elem=NULL;
		return -1;
	}
	nn--;
	Djkt_elem_cola *aux = elem;
	int res = aux->id;
	elem = elem->sig;
	if(id_inci)
		*id_inci=aux->id_inci;
	delete(aux);
	return res;
};
//*************************************************************************************
/**
 * Función constructor para la estructura de nodos adyacentes para los ángulos
 */
Djkt_ang_ady::Djkt_ang_ady()
{
	nady=0;
	i_conjs=0;
	angs=0;
	ids_padre=NULL;
}
//*************************************************************************************
/**
 * Función destructor para la estructura de nodos adyacentes para los ángulos
 */
void Djkt_ang_ady::libera()
{
	if(i_conjs)
		free(i_conjs);
	i_conjs=NULL;
	if(angs)
	{
		for(int i=0;i<nady;i++)
		{
			if(angs[i])
				free(angs[i]);
			angs[i]=NULL;
		}
		free(angs);
	}
	angs=NULL;
	if(ids_padre)
		free(ids_padre);
	ids_padre=NULL;
}
//*************************************************************************************
/**
 * Función destructor para la estructura de nodos adyacentes para los ángulos
 */
void Djkt_ang_ady::libera_ex()
{
	i_conjs=NULL;
	if(angs)
	{
		for(int i=0;i<nady;i++)
		{
			if(angs[i])
				free(angs[i]);
			angs[i]=NULL;
		}
		free(angs);
	}
	angs=NULL;
	if(ids_padre)
		free(ids_padre);
	ids_padre=NULL;
}
//*************************************************************************************
/**
 * Función de inicio de variables para la estructura de nodos adyacentes para los ángulos
 */
BOOL Djkt_ang_ady::inicia(int n, BOOL no_angs)
{
	int i;
	nady=n;
	if(nady>16)
	{
		nady=nady;
	}
	//malloc
	i_conjs=(int*)malloc(nady*sizeof(int));
	if(!i_conjs)
		return FALSE;
	for(i=0;i<nady;i++)
	{
		i_conjs[i]=-1;
	}
	if(no_angs)
	{
		angs=NULL;
		return TRUE;
	}
	angs=(BYTE**)malloc(nady*sizeof(BYTE*));
	if(!angs)
		return FALSE;
	for(i=0;i<nady;i++)
	{
		angs[i]=(BYTE*)malloc(nady*sizeof(BYTE));
		if(!angs[i])
			return FALSE;
		memset(angs[i],0,nady*sizeof(BYTE));
	}
	return TRUE;
}
//*************************************************************************************
/**
 * Función de inicio de variables para la estructura de nodos adyacentes para los ángulos
 */
BOOL Djkt_ang_ady::inicia_ids()
{
	ids_padre=(Djkt_ids_pdr*)malloc(nady*sizeof(Djkt_ids_pdr));
	if(!ids_padre)
		return FALSE;
	for(int i=0;i<nady;i++)
	{
		ids_padre[i].id=-1;
		ids_padre[i].dis=(float)MAYUSCULO;
	}
	return TRUE;

};		
//*************************************************************************************
/**
 * Para la estructura de nodos adyacentes para los ángulos,
 * devuelve las posiciones relativas a la conjunción de las
 * conjunciones i y j, tanto si tienen que añadirse o buscarse
 */
BOOL Djkt_ang_ady::dame_ii_jj(int i, int j, int *ii_,int *jj_)
{		
	int ii,jj;

	*ii_=-1;
	if(jj_)
		*jj_=-1;
	ii=jj=-1;

	for(ii=0;ii<nady;ii++)
		if((i_conjs[ii]==-1) || (i_conjs[ii]==i))
			break;
	if(i==j)
		jj=ii;
	else if(j!=-1)
	{	
		for(jj=0;jj<nady;jj++)
			if(((jj>ii) && (i_conjs[jj]==-1)) || (i_conjs[jj]==j))
				break;
	}
	if(ii>=nady || jj>=nady)
		return FALSE;

	*ii_=ii;
	if(jj_)
		*jj_=jj;

	return TRUE;
}
//*************************************************************************************
/**
 * Para la estructura de nodos adyacentes para los ángulos,
 * pone el ángulo de la conj, entre las adyacentes i y j
 */
BOOL Djkt_ang_ady::pon_ang_i_j(int i,int j, BYTE ang)
{
	int ii,jj;

	if(!dame_ii_jj(i,j,&ii,&jj))
		return FALSE;

	i_conjs[ii]=i;
	i_conjs[jj]=j;
	angs[ii][jj]=ang;

	return TRUE;
};
//*************************************************************************************
/**
 * Para la estructura de nodos adyacentes para los ángulos,
 * devuelve el ángulo de la conj, entre las adyacentes i y j
 */
BOOL Djkt_ang_ady::dame_ang_i_j(int i,int j, BYTE *ang, BOOL inds_abs)
{
	int ii,jj;

	if(inds_abs)
	{	
		if(!dame_ii_jj(i,j,&ii,&jj))
			return FALSE;
	}
	else
	{
		ii=i;
		jj=j;
	}

	*ang=angs[ii][jj];
	return TRUE;
}
//*************************************************************************************
/**
 * Para la estructura de nodos adyacentes para los ángulos,
 * pone que para llegar al nodo actual desde i_orig, el padre es j_padre
 */
BOOL Djkt_ang_ady::pon_padre(int i_orig,int j_padre, double dis, BOOL inds_abs)
{
	int ii,jj;

	if(inds_abs)
	{	
		if(!dame_ii_jj(i_orig,j_padre,&ii,&jj))
			return FALSE;
	}
	else
	{
		ii=i_orig;
		jj=j_padre;
	}

	ids_padre[ii].id=jj;
	ids_padre[ii].dis=(float)dis;

	return TRUE;
};
//*************************************************************************************
/**
 * Para la estructura de nodos adyacentes para los ángulos,
 * devuelve que el padre es j_padre para ir al nodo actual desde i_orig
 */
BOOL Djkt_ang_ady::dame_padre(int i_orig,int *j_padre, double *dis, BOOL inds_abs)
{
	int ii,jj;

	if(inds_abs)
	{	
		if(!dame_ii_jj(i_orig,-1,&ii,&jj))
			return FALSE;
	}
	else
	{
		ii=i_orig;
		jj=-1;
	}

	*j_padre = i_conjs[ids_padre[ii].id];
	*dis = ids_padre[ii].dis;

	return TRUE;
};
//*************************************************************************************
/*
 * Guarda a disco
 */
BOOL Djkt_ang_ady::guarda(HeadCostAng hd, int ic, char *path , char *ext)
{
	HANDLE hfile = INVALID_HANDLE_VALUE;
	int nb, i;
	char file[MAX_PATH];

	sprintf_s(file,MAX_PATH,"%s%06d.%s",path,ic,ext);

	//crea archivo-----------------------------------
	hfile = CreateFile(file,  GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
	if (hfile == INVALID_HANDLE_VALUE)
	{
		i=GetLastError();
		return FALSE;
	}

	//graba cabecera------------		
	nb = sizeof(hd);
	//calcula el nb
	hd.n=nady; //* BYTE
	if (nb != _lwrite((int)hfile, (LPCCH)&hd, nb))
	{
		goto va_mal;
	}
	
	//guarda la matriz de conjs ady
	nb=sizeof(int)*nady;
	if (nb != _lwrite((int)hfile, (LPCCH) i_conjs, nb))
	{
		goto va_mal;
	}
	//guarda la matriz de ángulos
	nb=nady;
	for(i=0;i<nady;i++)
	{	
		if (nb != _lwrite((int)hfile, (LPCCH) angs[i], nb))
		{
			break;
		}	
	}
	if(i<nady)
		goto va_mal;

	CloseHandle(hfile);
	return TRUE;

va_mal:
	CloseHandle(hfile);
	return FALSE;
}
//*************************************************************************************
/*
 * Lee de disco
 */
BOOL Djkt_ang_ady::lee(int ic, char *path , char *ext)
{
	HANDLE hfile = INVALID_HANDLE_VALUE;
	int nb, i;
	char file[MAX_PATH];
	HeadCostAng hd;

	sprintf_s(file,MAX_PATH,"%s%06d.%s",path,ic,ext);

	//crea archivo-----------------------------------
	hfile = CreateFile(file,  GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
	if (hfile == INVALID_HANDLE_VALUE)
	{
		i=GetLastError();
		return FALSE;
	}

	//lee cabecera------------	
	memset(&hd,0,sizeof(HeadCostAng));
	nb = sizeof(hd);
	if (nb != _lread((int)hfile,&hd, nb))
	{
		goto va_mal;
	}
	//calcula el nady
	nady=hd.n;	
	
	//lee la matriz de conjs ady, pidiendo memoria antes
	nb=sizeof(int)*nady;
	i_conjs=(int*)malloc(nb);
	if(!i_conjs)
		goto va_mal;
	if (nb != _lread((int)hfile,  i_conjs, nb))
	{
		goto va_mal;
	}

	angs=(BYTE**)malloc(nady*sizeof(BYTE*));
	if(!angs)
		goto va_mal;
	nb=nady;
	for(i=0;i<nady;i++)
	{
		angs[i]=(BYTE*)malloc(nady*sizeof(BYTE));
		if(!angs[i])
			break;
		if (nb != _lread((int)hfile,  angs[i], nb))
			break;
	}
	if(i<nady)
		goto va_mal;

	CloseHandle(hfile);
	return TRUE;

va_mal:
	CloseHandle(hfile);
	return FALSE;
}
//*************************************************************************************
//*************************************************************************************
//*************************************************************************************
//*************************************************************************************
Cdijkstra_arch::Cdijkstra_arch()
{
	memset(&hd, 0, sizeof(hd));
	path[0]=0;
	dis=NULL;
	ia=NULL;
	salta_ids_padres=FALSE;
}
//*************************************************************************************
Cdijkstra_arch::~Cdijkstra_arch()
{
	if(dis)
		free(dis);
}
//*************************************************************************************
BOOL Cdijkstra_arch::inicia( char* path_arch, BOOL nuevo/*=FALSE*/, int n_nod/*=0*/, int max_conex)
{
	strcpy_s(path,MAX_PATH, path_arch);
	char st[1024];
	salta_ids_padres=FALSE;
	if(nuevo)
	{
		hd.version=VERSION_DJ_ARCHI;
		hd.nn=n_nod;
		hd.nb=0;

		hd.max_conex=max_conex;
		sizn=sizeof(Djkt_nodo)+hd.max_conex*(sizeof(Djkt_ids_pdr)+sizeof(int)+sizeof(BYTE)*hd.max_conex);
		//borra archivos ndj--------------------------------------
		strcpy_s(st,1024,path_arch);
		//pilla archivos-----------------
		Cdir_manager::borra_archivos(Cdir_manager::dir_anterior(st),EXT_ARCH_DIJ_DEFAULT);		
		
		return hd.nn>0;
	}
	HANDLE hfile = INVALID_HANDLE_VALUE;
	int nb;
	char p[MAX_PATH];
	sprintf_s(p,MAX_PATH, "%s_%ld.%s",path, 0,EXT_ARCH_DIJ_DEFAULT);
	hfile = CreateFile(p,  GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
	if (hfile == INVALID_HANDLE_VALUE)
		return FALSE;
	nb = sizeof(hd);
	if (nb != _lread((int)hfile,&hd, nb))
	{
		goto va_mal;
	}
	if(hfile != INVALID_HANDLE_VALUE)
		CloseHandle(hfile);
	sizn=sizeof(Djkt_nodo)+hd.max_conex*(sizeof(Djkt_ids_pdr)+sizeof(int)+sizeof(BYTE)*hd.max_conex);
	return (hd.version== VERSION_DJ_ARCHI &&  hd.max_conex>0 && hd.nn>0 && sizn>0);

va_mal:
	if(hfile != INVALID_HANDLE_VALUE)
		CloseHandle(hfile);
	return FALSE;
		

}
//*************************************************************************************
BOOL Cdijkstra_arch::add_b( Djkt_nodo* blq, int iref, int inod, BOOL pon_inf )
{
	HANDLE hfile = INVALID_HANDLE_VALUE;
	int nb, i, nbt, j;
	char p[MAX_PATH];
	sprintf_s(p,MAX_PATH,"%s_%ld.%s",path,iref,EXT_ARCH_DIJ_DEFAULT);
	Head_dj_arch hdl;
	//abre archivo-----------------------------------
	hfile = CreateFile(p,  GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
	if (hfile == INVALID_HANDLE_VALUE)
	{
		hfile = CreateFile(p,  GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);

		
		if (hfile == INVALID_HANDLE_VALUE)
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error no se puede abrir archivo: %s", p);

			i=GetLastError();
			return FALSE;
		}
		//graba cabecera------------
		hdl=hd;
		hdl.nb=0;
		nb =  sizeof(hdl);
		if (nb != _lwrite((int)hfile, (LPCCH)&hdl, nb))
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error no se puede grabar cabecera  de archivo: %s", p);
			goto va_mal;
		}
	}
	else
	{
		//lee cabecera-------------
		nb =  sizeof(hdl);
		if (nb != _lread((int)hfile, &hdl, nb))
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error no se puede leer cabecera de archivo: %s", p);

			goto va_mal;
		}
	}
	//va a lo ultimo---------------------------------
	if ( SetFilePointer(hfile, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
	{
		olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error no se puede ir al final del archivo: %s", p);

		goto va_mal;
	}
	//guarda bloque---------------------------------
	for (i=0; i<hdl.nn; i++)
	{
		nbt=0;
		//guarda nodo------------------------
		nb =  sizeof(Djkt_nodo);
		if (nb != _lwrite((int)hfile, (LPCCH)&blq[i], nb))
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error al escribir nodo, archivo: %s", p);

			goto va_mal;
		}
		nbt+=nb;

		if(!blq[i].ids_ady.ids_padre || salta_ids_padres)
		{
			blq[i].ids_ady.nady=0;
			salta_ids_padres=TRUE;
			goto guarda_bas;
		}
		nb=blq[i].ids_ady.nady*sizeof(Djkt_ids_pdr);
		if (nb != _lwrite((int)hfile, (LPCCH)blq[i].ids_ady.ids_padre, nb))
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error al escribir idpadres, archivo: %s", p);

			goto va_mal;
		}
		nbt+=nb;
		nb=blq[i].ids_ady.nady*sizeof(int);
		if (nb != _lwrite((int)hfile, (LPCCH)blq[i].ids_ady.i_conjs, nb))
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error al escribir i_conjs, archivo: %s", p);

			goto va_mal;
		}
		nbt+=nb;
		
		if(blq[i].ids_ady.angs)
		{
			nb=blq[i].ids_ady.nady*sizeof(BYTE);
			for(j=0; j<blq[i].ids_ady.nady; j++)
			{
				
				if (nb != _lwrite((int)hfile, (LPCCH)blq[i].ids_ady.angs[j], nb))
				{
					olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error al escribir angs, archivo: %s", p);

					goto va_mal;
				}
				nbt+=nb;
			}
		}
guarda_bas:
		//guarda basura resto de bytes que quedan libres-------------
		while(nbt<sizn)
		{
			nb=min((sizn-nbt),(int)((sizeof(Djkt_nodo)*hd.nn)));
			if (nb != _lwrite((int)hfile, (LPCCH)blq, nb))
			{
				olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error al escribir relleno, archivo: %s", p);

				goto va_mal;
			}
			nbt+=nb;
		}
	}
	inod=hdl.nb++;
	//graba cabecera------------------------------------
	if ( SetFilePointer(hfile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
	{
		olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error ir a inicio, archivo: %s", p);

		goto va_mal;
	}
	nb=sizeof(Head_dj_arch);
	if (nb != _lwrite((int)hfile, (LPCCH)&hdl, nb))
	{
		olvlog(LOG_TODO,"Cdijkstra_arch::add_b","Error al escrivir cabecera, archivo: %s", p);

		goto va_mal;
	}
	CloseHandle(hfile);
	if(pon_inf)
	{
		pon_info_amb(blq, iref, inod);
	}


	return TRUE;
	

va_mal:
	if(hfile != INVALID_HANDLE_VALUE)
		CloseHandle(hfile);
	return FALSE;
}
//*************************************************************************************
void Cdijkstra_arch::libera_buf(Djkt_nodo* buf )
{
	if(!buf)
		return;
	for (int i=0; i<hd.nn; i++)
	{
		buf[i].ids_ady.libera();
	}
	free(buf);
}
//*************************************************************************************
Djkt_nodo* Cdijkstra_arch::dame_buf_nodos(BOOL angulos )
{
	Djkt_nodo*buf_res=(Djkt_nodo*)malloc(sizeof(Djkt_nodo)*hd.nn);
	if(!buf_res)
	{
		return buf_res;
	}
	memset(buf_res,0, sizeof(Djkt_nodo)*hd.nn);
	for (int i=0; i<hd.nn; i++)
	{
		if(!buf_res[i].ids_ady.inicia(hd.max_conex, !angulos)||!buf_res[i].ids_ady.inicia_ids())
		{
			for (int ii=0; ii<=i; ii++)
			{
				buf_res[ii].ids_ady.libera();
				free(buf_res);
				return NULL;
			}
		}
	}


	return buf_res;
}
//*************************************************************************************
//por ahora hecha solo pidiendo memoria
Djkt_nodo* Cdijkstra_arch::get_b( int iref, int ibloq, Djkt_nodo* buf/*=NULL*/)
{
	HANDLE hfile = INVALID_HANDLE_VALUE;
	int nb, i, nbt, j;
	char p[MAX_PATH];
	void *pun[3];
	Djkt_nodo* buf_res=NULL;
	BOOL no_ang;
	sprintf_s(p,MAX_PATH,"%s_%ld.%s",path,iref,EXT_ARCH_DIJ_DEFAULT);
	if(nod_amb<=ibloq)
		ibloq=0;
	if(ibloq<0 || iref<0)
		return NULL;
	Head_dj_arch hdl;
	//abre archivo-------------------------------------------------
	hfile = CreateFile(p,  GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
	if (hfile == INVALID_HANDLE_VALUE)
	{
		olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error al abrir archivo: %s", p);
		goto va_mal;
	}
	//lee cabecera-------------------------------------------------
	nb=sizeof(hdl);
	if (nb != _lread((int)hfile,&hdl, nb))
	{
		olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error al leer cabecera archivo: %s", p);

		goto va_mal;
	}
	if(hdl.nb<ibloq)
	{
		olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error bloque %ld  (cab.nb %ld)no existe en  archivo: %s",ibloq,hdl.nb,  p);

		goto va_mal;
	}
	if(!buf)
	{
		//pide memoria-------------------------------------------------
		buf_res=(Djkt_nodo*)malloc(sizeof(Djkt_nodo)*hdl.nn);
		if(!buf_res)
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error sin memo para buffer archivo: %s", p);

			goto va_mal;
		}
		memset(buf_res,0,sizeof(Djkt_nodo)*hd.nn);

	}
	else
		buf_res=buf;
	//va al bloque correspondiente---------------------------------
	nb=sizn*hdl.nn*ibloq;
	if ( SetFilePointer(hfile, nb, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
		goto va_mal;
	for (i=0; i<hdl.nn; i++)
	{
		//guarda punteros de memo--------------
		if(buf)
		{
			pun[0]=buf_res[i].ids_ady.ids_padre;
			pun[1]=buf_res[i].ids_ady.i_conjs;
			pun[2]=buf_res[i].ids_ady.angs;
		}
		nbt=nb=sizeof(Djkt_nodo);
		if (nb != _lread((int)hfile,&buf_res[i], nb))
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error al leer nodo %ld archivo: %s",i, p);

			goto va_mal;
		}
		no_ang=!buf_res[i].ids_ady.angs;
		if(!buf)
		{
			buf_res[i].ids_ady.i_conjs=NULL;
			buf_res[i].ids_ady.angs=NULL;
			buf_res[i].ids_ady.ids_padre=NULL;
			//pide memoria para resto punteros------------------------
			if(!buf_res[i].ids_ady.inicia(buf_res[i].ids_ady.nady, no_ang) ||!buf_res[i].ids_ady.inicia_ids())
			{
				olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error al iniciar memoria nodo %ld archivo: %s",i, p);

				goto va_mal;
			}
		}
		else
		{	
			buf_res[i].ids_ady.ids_padre=(Djkt_ids_pdr*)pun[0];
			buf_res[i].ids_ady.i_conjs=(int*)pun[1];
			buf_res[i].ids_ady.angs=(BYTE**)pun[2];
			
			no_ang=no_ang || (buf_res[i].ids_ady.angs==NULL);
		}
		if(buf_res[i].ids_ady.nady<=0 || salta_ids_padres)
		{
			buf_res[i].ids_ady.nady=0;
			
			goto sigue;
		}
		
		nb=buf_res[i].ids_ady.nady*sizeof(Djkt_ids_pdr);
		if (nb != _lread((int)hfile, buf_res[i].ids_ady.ids_padre, nb))
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error al leer ids_padre en nodo %ld archivo: %s", i, p);

			goto va_mal;
		}
		nbt+=nb;
		nb=buf_res[i].ids_ady.nady*sizeof(int);
		
		if (nb != _lread((int)hfile, buf_res[i].ids_ady.i_conjs, nb))
		{
			olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error al leer i_conjs en nodo %ld archivo: %s", i, p);

			goto va_mal;
		}
		nbt+=nb;
		if(!no_ang)
		{
			nb=buf_res[i].ids_ady.nady*sizeof(BYTE);
			for (j=0; j<buf_res[i].ids_ady.nady; j++)
			{
				if (nb != _lread((int)hfile,buf_res[i].ids_ady.angs[j], nb))
				{
					olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error al leer angs %ld en nodo %ld archivo: %s", j, i, p);

					goto va_mal;
				}
				nbt+=nb;
			}
		}
sigue:
		//salta al siguiente------------------
		nb=sizn-nbt;
		if(nb>0)
		{
			if ( SetFilePointer(hfile, nb, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
			{
				olvlog(LOG_TODO,"Cdijkstra_arch::get_b","Error al ir al siguiente nodo, en nodo %ld archivo: %s", i, p);

				goto va_mal;
			}
		}
	}
	if(hfile != INVALID_HANDLE_VALUE)
		CloseHandle(hfile);
	return buf_res;
va_mal:
	if(hfile != INVALID_HANDLE_VALUE)
		CloseHandle(hfile);
	if(buf_res && !buf)
	{
		for (i=0; i<hd.nn; i++)
			buf_res[i].libera();
		free(buf_res);
	}
	return NULL;
}
//*************************************************************************************
BOOL Cdijkstra_arch::inicia_inf_amb( std::map<int,Info_aso2> *ina, int namb, int tip_amb, int idinstal/*=-1*/, int idplan/*=-1*/ )
{
	float *buf;
	int i;
	ia=ina;
	nnod=namb;
	nod_amb=tip_amb;
	nnod=nnod*nod_amb;
	nambi=namb;
	nod_instal=idinstal;
	nod_plan=idplan;

	if(idplan>=0)
	{
		nnod++;
		id_plan=namb++;
		
	}
	if(idinstal>=0)
	{
		nnod++;
		id_instal=namb;
	}
	
	//pide memoria
	buf=(float*)realloc(dis,nnod*nnod*sizeof(float) );
	if(!buf)
	{
		ia=NULL;
		return FALSE;//sin memoria
	}
	dis=buf;
	for(i=nnod*nnod-1; i>=0; i--)
	{
		dis[i]=(float)MAYUSCULO;
	}
	return TRUE;

}
//*************************************************************************************
void Cdijkstra_arch::pon_info_amb( Djkt_nodo* nodos, int iref,int ib )
{
	int i, j, k;
	if(!ia)
		return;
	//calcula fila---
	j=(iref*nod_amb+ib)*nnod;
	
	for (i=0; i<nambi; i++)
	{
		for(k=0; k<nod_amb; k++)
		{
			dis[j+i*nod_amb+k]=nodos[(*ia)[i].inod[k]].dis;
			if(nodos[(*ia)[i].inod[k]].dis<0)
				nodos[(*ia)[i].inod[k]].dis=nodos[(*ia)[i].inod[k]].dis;
		}
	}
	if(nod_instal>=0)
	{
		dis[j+nambi*nod_amb+id_instal-nambi]=nodos[nod_instal].dis;
		if(nodos[nod_instal].dis<0)
			nodos[nod_instal].dis=nodos[nod_instal].dis;
	}
	if(nod_plan>=0)
	{
		dis[j+nambi*nod_amb+id_plan-nambi]=nodos[nod_plan].dis;
		if(nodos[nod_plan].dis<0)
			nodos[nod_plan].dis=nodos[nod_plan].dis;
	}
}
//*************************************************************************************
float Cdijkstra_arch::dame_dis( int aorig,int norig, int ades, int n_des )
{
	int i=aorig-nambi;
	if(nod_amb<=norig)
		norig=0;
	if(nod_amb<=n_des)
		n_des=0;
	if(i<0)
		i=0;
	aorig-=i;
	return dis[(ades*nod_amb+n_des)*nnod + aorig*nod_amb+norig+i];
}

BOOL Cdijkstra_arch::graba_dis(int id)
{
	Cgarray<float> buf;
	char p[MAX_PATH];
	sprintf(p,"%s_%ld.%s", path, id,TASKS_EXT_DIS);
	Cb_file f;
	if(!f.abre(p,2,TRUE))
		return FALSE;
	buf.ptr=dis;
	buf.n =nnod*nnod;
	BOOL res =buf.graba(&f);
	buf.ptr=NULL;
	buf.n =0;
	return res;
	
}
//*************************************************************************************
BOOL Cdijkstra_arch::lee_dis()
{
	Cb_file f;
	StrArray files;
	char sext[MAX_PATH];
	strcpy(sext, path);
	Cgarray<float> buf;
	//pilla archivos-----------------------
	if(!Cdir_manager::listar(Cdir_manager::dir_anterior(sext), &files))
		return FALSE;
	char *file;
	for (int i = 0; i<files.size(); i++)
	{
		file=files.get(i);

		if(strcmp(Cdir_manager::extension_archivo(file),TASKS_EXT_DIS))	
			continue;
		//leer
		if(!f.abre(file,1,FALSE))
			return FALSE;
		buf.n=0;
		if(!buf.leer(&f))
			return FALSE;
		f.cierra();
		if(buf.n!= nnod*nnod)
			return FALSE;
		//mix---------------------------------------------
		for(int ii = 0; ii<buf.n; ii++)
			dis[ii]=min(dis[ii],buf[ii]);
	}		
	return TRUE;
}
//*************************************************************************************
//*************************************************************************************
//*************************************************************************************
//Funciones de la clase geom
Colv_geom::Colv_geom(void)
{

}

Colv_geom::~Colv_geom(void)
{
}
//**************************************************************************************************************************
/*
* Devuelve el ángulo entre v1 y v2
*/
double Colv_geom::ang_vect(double v1[2], double v2[2])
{
	double res = sqrt(v1[0] * v1[0] + v1[1] * v1[1]) *
		sqrt(v2[0] * v2[0] + v2[1] * v2[1]);
	if(res==0)
		return 0;
	res = (v1[0] * v2[0] + v1[1] * v2[1]) / res;
	if (res > 1)
		res = 1;
	if (res < -1)
		res = -1;
	return acos(res);
}
//*************************************************************************************
/**
 * Devuelve true si los puntos son iguales, false si no
 */
BOOL Colv_geom::pto_equals(double pt1[3], double pt2[3], BOOL d3 /*=false*/)
{
	BOOL c3;
	if(d3)
		c3=(fabs(pt1[2]-pt2[2])<OLV_DIF_MAX_MISMA_COOR);
	else
		c3=TRUE;

	return ((fabs(pt1[0]-pt2[0])<OLV_DIF_MAX_MISMA_COOR) && 
		(fabs(pt1[1]-pt2[1])<OLV_DIF_MAX_MISMA_COOR) && c3);
}
//*************************************************************************************
/**
 * Dado un lineal, genera uno paralelo a una distancia dis dada, a la derecha si es d>0 o a la izquierda si d<0
 */
BOOL Colv_geom::haz_paralela(double (*ptos_orig)[3],int _np,double dis,double (**ptos_par)[3])
{
	if(dis==0)
	{
		ptos_par=&ptos_orig;
		return TRUE;
	}

	double (*v_unitario)[][3];
	double (*ptos_salida)[][3];
	double (*ptos)[][3];
	int np,i;
	double c,s,l,a1,a2,b1,b2,c1,c2,det,x,y;

	np=_np;

	ptos_salida=(double (*)[][3])malloc(sizeof(double)*3*np);
	if(!ptos_salida)
		return FALSE;
	memset(ptos_salida,0,sizeof(double)*3*np);
	
	ptos=(double (*)[][3])malloc(sizeof(double)*3*np);
	if(!ptos)
		return FALSE;
	memcpy(ptos,ptos_orig,sizeof(double)*3*np);

	v_unitario=(double (*)[][3])malloc(sizeof(double)*3*(np-1));
	if(!v_unitario)
		return FALSE;
	
	//d distancia, positivo -> paralela a la izquierda , negativo a la derecha
	//el array (*v_unitario) tiene los vectores unitarios de cada direccion

	for (i=0;i<=(np-2);i++)
	{
		c= (*ptos)[i+1][0]-(*ptos)[i][0] ;
		s = (*ptos)[i+1][1]-(*ptos)[i][1];
		l = sqrt(c*c+s*s);
		if(l==0)
			l=1;		
		(*v_unitario)[i][0]= c/l;
		(*v_unitario)[i][1]=s/l;
	}

	// calculamos la normal para el primer punto
	(*ptos_salida)[0][0]=(*ptos)[0][0]-dis*(*v_unitario)[0][1];
	(*ptos_salida)[0][1]=(*ptos)[0][1]+dis*(*v_unitario)[0][0];

	// desde 1 hasta np-1 calculamos la interseccion de las lineas
	for (i=1;i<=(np-2);i++)
	{
		l = dis/(1+(*v_unitario)[i][0]*(*v_unitario)[i-1][0]
		+(*v_unitario)[i][1]*(*v_unitario)[i-1][1]) ;
		(*ptos_salida)[i][0]=(*ptos)[i][0] 
		- l*((*v_unitario)[i][1]+(*v_unitario)[i-1][1]);
		(*ptos_salida)[i][1]=(*ptos)[i][1] 
		+ l*((*v_unitario)[i][0]+(*v_unitario)[i-1][0] );

	}

	// usamos la normal para el ultimo punto
	(*ptos_salida)[np-1][0]= (*ptos)[np-1][0]- dis*(*v_unitario)[np-2][1];
	(*ptos_salida)[np-1][1]= (*ptos)[np-1][1] + dis*(*v_unitario)[np-2][0];

	//si el ultimo punto tiene las mismas coordenadas que el primero es un superficial
	//en los superficiales se une el primero con el último
	if ((*ptos)[np-1][0]==(*ptos)[0][0] &&(*ptos)[np-1][1]==(*ptos)[0][1])
	{
		// el punto inicial y final se intersectan. Solucion ideal para superficiales
		a1 = (*ptos_salida)[np-1][1]-(*ptos_salida)[np-2][1];
		b1 = (*ptos_salida)[np-2][0]-(*ptos_salida)[np-1][0];
		c1 = a1*(*ptos_salida)[np-2][0]+b1*(*ptos_salida)[np-2][1];
		a2 = (*ptos_salida)[0][1]-(*ptos_salida)[1][1];
		b2 = (*ptos_salida)[1][0]-(*ptos_salida)[0][0];
		c2 = a2*(*ptos_salida)[1][0]+b2*(*ptos_salida)[1][1];

		det = a1*b2 - a2*b1;
		x = (b2*c1 - b1*c2)/det;
		y = (a1*c2 - a2*c1)/det;
		(*ptos_salida)[np-1][0]=x;
		(*ptos_salida)[np-1][1]=y;
		(*ptos_salida)[0][0]=x;
		(*ptos_salida)[0][1]=y;
	}

	free(v_unitario);
	free(ptos);	

	///Fin de los arcos intermedios
	*ptos_par=(double(*)[3]) ptos_salida;
	return TRUE;
}
//*************************************************************************************
/**
 * Algoritmo Dijkstra de cálculo de camino de menor coste para ir de los 'n' nodos de una red al nodo 'fin'.
 * 'nodos' es el array de tamaño n que contiene la información de costes, es de salida
 * 'costes' es la matriz de nxn que contiene los costes de ir de todos a todos los nodos
*/
BOOL Colv_geom::dijkstra_ang_inv_ok(CmapMatFloat &costes, Djkt_ang_ady *angs, int n, int fin, Djkt_nodo **nodos, BYTE **visto_ang_)
{
	int i, sig,sigr;
	Djkt_cola q;
	BOOL res=FALSE;
	Djkt_nodo *distancias;
	double d;
	BOOL ang_ok;
	//BYTE ang;
	int id_inci;
	BYTE *visto_ang=NULL;
	int ii,jj;

	q.inicia(NULL);
	distancias = *nodos;
	if(!distancias)
		distancias = (Djkt_nodo*)malloc(sizeof(Djkt_nodo)*n);
	if (!distancias)
		goto va_mal;
	if(visto_ang_)
		visto_ang=*visto_ang_;
	if(!visto_ang)
		visto_ang = (BYTE*)malloc(n*n*sizeof(BYTE));
	if(!visto_ang)
		goto va_mal;
	memset(visto_ang,0,n*n*sizeof(BYTE));

	
	if(angs)
	{
		ang_ok=TRUE;
		for (i=0; i<n; i++)
		{			
			if(!distancias[i].inicia_ex(&angs[i]))
				ang_ok=FALSE;			
		}
		
		if(!ang_ok)
			goto va_mal;
		for(i=0; i<distancias[fin].ids_ady.nady; i++)
		{
			distancias[fin].ids_ady.ids_padre[i].dis=0;
			distancias[fin].ids_ady.ids_padre[i].id=-1;
		}
	}
	else
	{
		for (i=0; i<n; i++)
		{
			distancias[i].inicia();
		}
	}
	distancias[fin].id_padre = -1;
	distancias[fin].dis = 0;
	q.inicia(distancias);
	if (!q.pon(fin,fin))
		goto va_mal;

	int j=1;
	while (TRUE)
	{
		sig = q.dame(&id_inci);
		if(sig<0)
			break;//terminado
		if (visto_ang[id_inci*n+sig])
			continue;
		visto_ang[id_inci*n+sig]=1;
		//se revisa cada nodo 
		for (i = 0; i < n; i++)
		{
			if (costes[i][sig] >= MAYUSCULO)
				continue;	
			if (visto_ang[sig*n+i])//si visto se pasa de el
				continue;
			if(angs)
			{	
				if(!angs[sig].dame_ii_jj(i,-1,&ii,NULL))
					continue;

				if(distancias[sig].ids_ady.ids_padre[ii].id!=-1)
				{								
					if(!angs[sig].dame_ii_jj(distancias[sig].ids_ady.ids_padre[ii].id,-1,&jj,NULL))
						continue;

					if(!angs[sig].angs[ii][jj])
						continue;

				}
				d=distancias[sig].ids_ady.ids_padre[ii].dis + costes[i][sig];

				if (distancias[i].dis > d)//se actualiza distancia si procede
				{
					if(d<0)
						d=d;
					distancias[i].dis = (float)d;
					distancias[i].id_padre = sig;
					visto_ang[sig*n+i]=0;
					if (!q.pon(i,sig))
						goto va_mal;
				}

				if(!angs[i].dame_ii_jj(sig,-1,&sigr,NULL))
					continue;

				for(jj=0;jj<distancias[i].ids_ady.nady;jj++)
				{
					if((jj==sigr) && (distancias[i].ids_ady.nady>1))
						continue;
					if(!angs[i].angs[jj][sigr])
						continue;

					if (distancias[i].ids_ady.ids_padre[jj].dis > d)//se actualiza distancia si procede
					{
						distancias[i].ids_ady.ids_padre[jj].dis = (float)d;
						distancias[i].ids_ady.ids_padre[jj].id = sig;
						visto_ang[sig*n+i]=0;
						if (!q.pon(i,sig))
							goto va_mal;
					}
				}	
			}
			else
			{
				//encontrado adyacente se hace la relajacion----------------
				d = distancias[sig].dis + costes[i][sig];
				if (distancias[i].dis > d)//se actualiza distancia si procede
				{
					distancias[i].dis = (float)d;
					distancias[i].id_padre = sig;
					if (!q.pon(i,sig))
						goto va_mal;
				}
			}
			
			
		}
	}
	res = TRUE;
	
	if (nodos)
	{
		*nodos = distancias;
		distancias = NULL;
	}
	
va_mal:
	if (distancias)
		free(distancias);
	if(visto_ang_)
	{
		*visto_ang_=visto_ang;
		visto_ang=NULL;
	}
	if (visto_ang)
		free(visto_ang);
	while (q.dame() >= 0);

	return res;
}
//*************************************************************************************
/*
 * Da la ruta hasta el nodo final con el que se hizo dijkstra desde 'id_ini'
 * Hay que haber llamado antes a dijkstra, y el array 'nodos' de salida es el que aquí
 * es entrada, de tamaño 1xn.
 * En 'secu' devuelve un array de la secuencia a seguir desde el nodo 'id_ini' hasta el nodo final
 * Es de tamaño el número de nodos de la red, pero sólo están ocupados los 'n' primeros con la secuencia.
 */
double Colv_geom::ruta_dj_inv(int id_ini, int *secu, Djkt_nodo *nodos, int nmax, int *n)
{
	int padre= id_ini;
	int nn = 0;
	while (padre>=0 && nn<nmax)
	{
		secu[nn++] = padre;
		padre = nodos[padre].id_padre;
	}
	if(nn==nmax)
		nn=nn;
	*n = nn;
	
	return nodos[id_ini].dis;
}
//*************************************************************************************
/*
 * Da la ruta hasta el nodo final con el que se hizo dijkstra desde 'id_ini'
 * Hay que haber llamado antes a dijkstra, y el array 'nodos' de salida es el que aquí
 * es entrada, de tamaño 1xn.
 * En 'secu' devuelve un array de la secuencia a seguir desde el nodo 'id_ini' hasta el nodo final
 * Es de tamaño el número de nodos de la red, pero sólo están ocupados los 'n' primeros con la secuencia.
 */
double Colv_geom::ruta_dj_inv_ok(int id_ini, int *secu, Djkt_nodo *nodos, int nmax, int *n)
{
	int padre= id_ini;
	int nn = 0;
	int proce=-1;
	int i;
	if(nodos[padre].ids_ady.nady<=0)
		return ruta_dj_inv(id_ini,secu,nodos,nmax,n);
	while (padre>=0 && nn<nmax)
	{
		
		if(proce<0)
		{
			secu[nn++] = padre;
			proce=padre;
			padre = nodos[padre].id_padre;
			
		}
		else
		{
			secu[nn++] = padre;
			
			if(!nodos[padre].ids_ady.dame_ii_jj(proce,-1,&i,NULL)|| i<0)
			{
				*n = nn;
				return MAYUSCULO;
			}
			proce=padre;
			padre=nodos[padre].ids_ady.ids_padre[i].id;
		}
		
	}
	if(nn==nmax)
		nn=nn;
	*n = nn;
	
	return nodos[id_ini].dis;
}
//*************************************************************************************
/**
 * Devuelve la posición del elemento i-ésimo si se cambia la posición iold por la inew
 */
int Colv_geom::dame_ind_per(int i, int iold, int inew)
{
	if(i==inew)
		return iold;
	if(i<iold)
	{
		if(i<inew)
			return i;
		return i-1;

	}
	else if(i>iold)
	{
		if(i<inew)
			return i+1;
		return i;

	}
	else
	{
		if(i<inew)
			return i+1;
		
		return i-1;
	}
}
//*************************************************************************************
int Colv_geom::dame_n_nucleos()
{
	//return 1;
	SYSTEM_INFO  sys;
	GetSystemInfo(&sys);
	return max(sys.dwNumberOfProcessors,1);
}

//*************************************************************************************
/**
 * Devuelve el factorial de i, OJO usar con moderación
 */
int Colv_geom::fact(int i)
{
	int res=1;
	while(i>1)
		res*=i--;

	return res;
}
#endif
//*************************************************************************************