UNIVERSIDAD DE SAN CARLOS DE GUATEMALA

FACULTAD DE INGENIERÍA
ESCUELA DE CIENCIAS Y SISTEMAS
ESTRUCTURA DE DATOS SECCIÓN: “B”

Manual Técnico
Proyecto 2

Nombre: Germán Mazariegos Salguero

Carne: 201114496
Cargar Archivos
Este método contiene las variables necesarias para realizar la conexión con el cliente
esta a su vez realiza operaciones que devuelven valores necesarios.

void Principal::on_Cargar_autobuses_clicked()

char *placa;
char *modelo;
char *estado;
char file[100];
crearTabla(&autobuses);

QString filename = QFileDialog::getOpenFileName(

this,
tr("Open File"),
"C://",
"All Files (*.txt*);;Text File(*.txt)"
);

std::string str = filename.toStdString();

if(!str.empty()){
QFile f(filename);
QFileInfo fileInfo(f.fileName());
QString name(fileInfo.fileName());

string nombre_archivo = name.toStdString();

int tam = nombre_archivo.length();
nombre_archivo.erase(tam-4);
strcpy(file,nombre_archivo.c_str());

}
ifstream lectura;
lectura.open(filename.toStdString().c_str(),ios::in);
if (lectura.is_open())
{
int primera = 0;
for (std::string linea; std::getline(lectura, linea); )
{
if(primera == 1){
std::stringstream registro(linea);
int contador = 0;

for (std::string dato; std::getline(registro, dato, ','); )

{

if(contador == 0)
 {
cout<<"Placa: "<<dato<<endl;
placa = strdup(dato.c_str());
ui->comboBoxBloqueAutobus->addItem(placa);
contador++;
}
else if(contador == 1)
{
cout<<"Modelo: "<<dato<<endl;
modelo = strdup(dato.c_str());
contador++;
}
else if(contador == 2)
{
cout<<"Estado: "<<dato<<endl;
estado = strdup( dato.c_str());

}
}

Autobus A;
A.codigo=clave(placa);
A.placa =placa;
A.modelo=modelo;
A.estado=estado;
darAlta(&autobuses,A);
contador = 0;

}
primera = 1;
}

Grafica_Autobus(&autobuses);
QPixmap pix("autobus.png");
int x = pix.width();
int z = pix.height();
ui->labelview_autobuses-
>setPixmap(pix.scaled(x,z,Qt::KeepAspectRatio));

lectura.close();
QMessageBox::information(NULL, "Informacion", "Carga de Archivo Exitosa");
}else { std::cout<<"Fichero inexistente o faltan permisos para
abrirlo"<<std::endl; }
}
 Crear Gráficas
Existen diversos métodos para cargar archivos así como también las
diferentes gráficas en ellos se realiza los recorridos diversos de
las diferentes estructuras las cuales se realizan en diversos
archivos.

void Grafica_grafo(NodoGrafo *grafo)

{

NodoGrafo *aux;
NodoLista *ady;
aux = grafo;

ofstream Archivo;
Archivo.open("Estaciones.gv");
Archivo<<"digraph G {\n";
Archivo<<"rankdir = LR\n";
Archivo<<"label=\"Grafo\"\n";
Archivo<<"node[shape=circle style=filled,fillcolor=steelblue1, width=0.6]\n";
while(aux)
{

ady = aux->lista;
if(ady!=NULL){
Archivo<<aux->vertice<<"->{";
}
while (ady)
{
Archivo<<" "<<ady->destino->vertice<<" ";
ady = ady->enlace;
}
if(aux->lista!=NULL){
Archivo<<"}\n";
}
aux = aux->enlace;

}
Archivo<<"}\n";
Archivo.close();
system("circo Estaciones.gv > estaciones.gv");
system("neato -n estaciones.gv -Tpng -O");

//system("dot grafo.dot -Tpng -o grafo.png");

//system("shotwell grafo.png");
}

void BuscarNodo(NodoGrafo *grafo, const char *vertice)

{

NodoGrafo *aux;
 aux = grafo;

while(aux)
{
if(strcmp(aux->vertice,vertice)== 0)
{
grafo_actual_seleccionado = aux;

}
aux = aux->enlace;
}
}

Método por el cual se realiza la gráfica de transacciones

void Grafica_transacciones()
{

ofstream Archivo;

Archivo.open("transacciones.dot");
Archivo <<"digraph G{\n";
Archivo <<"compound=true;\n";
Archivo <<"rankdir=TB;\n";
Archivo <<"node[shape = record, fillcolor=azure1, color = blue];\n";
Archivo <<"label = \" Arbol de Transacciones (AVL) \" \n ";
Archivo <<streamT.str();
Archivo <<"}\n";
Archivo.close();
system("dot transacciones.dot -Tpng -o transacciones.png");
//system("shotwell Avl.png");
streamT.str("");

void Escribir_trans(Arbol_trans actual)

{

streamT<<"node"<<actual<<"[label=\"<C0>|DPI: "<<actual->DPI<<"|<C1>\"];\n";
if(actual->izquierdo !=NULL)
{
streamT<<"node"<<actual<<":C0->"<<"node"<<actual->izquierdo<<"\n";
Escribir_trans(actual->izquierdo);
}
if(actual->derecho !=NULL)
{
streamT<<"node"<<actual<<":C1->"<<"node"<<actual->derecho<<"\n";
Escribir_trans(actual->derecho);
}

}
 Método Gratificar paqueo

void Graficar_parqueos(Lista_parqueos lista){

ofstream Archivo;
Archivo.open("parqueos.dot");
Archivo<<"digraph g{\n";
Archivo<<"rankdir = TB\n";
Archivo<<"node[shape=rect,style= \"rounded,filled\",
width=0.9,fontsize=15];\n";
Archivo<< "subgraph cluster_0{ \n";

Nodo_simple nodo = lista;

if(ListaVacia_parqueos(lista)) printf("Lista Vacia\n");
else{

while(nodo) {

if(nodo->seleccion == 1){

Archivo<<"node"<<nodo<<"[label = \"Nombre: "<<nodo-

>nombre<<"\"fillcolor=palegreen,fontsize=10]\n";

}else{

Archivo<<"node"<<nodo<<"[label = \"Nombre: "<<nodo-

>nombre<<"\",fontsize=10]\n";

}
nodo = nodo->siguiente;
}

nodo = lista;
while(nodo->siguiente) {

Archivo<<"node"<<nodo<<"->"<<"node"<<nodo->siguiente<<"\n";
nodo = nodo->siguiente;
}
}

Archivo<< "label = \"Parqueos\"\n ";

Archivo<< "}\n";
Archivo<<"} \n";
Archivo.close();
system("dot parqueos.dot -Tpng -o parqueos.png");
//system("shotwell parqueos.png");

void InsertaEspacios(Lista_parqueos Placa)

{
InsertarMatriz(&Placa->matriz,1,1,"ocupado","");
InsertarMatriz(&Placa->matriz,1,0,"ocupado","");
 InsertarMatriz(&Placa->matriz,1,2,"ocupado","");

void SeleccionarMatriz(Lista_parqueos lista, char nombre[30])

{

Nodo_simple nodo = lista;

if(nodo_seleccion_matriz!=NULL)
{
nodo_seleccion_matriz->seleccion = 0;
}

if(ListaVacia_parqueos(lista)) printf("Lista Vacia\n");

else{

while(nodo) {

if(strcmp(nombre, nodo->nombre) == 0)
{
nodo->seleccion = 1;
nodo_seleccion_matriz = nodo;
break;
}
nodo = nodo->siguiente;
}
}
}

Métodos, Funciones y Struct pare realizar bloques

Se encuentran los diversos métodos y struct necesarios para poder

realizar las deferentes operaciones entre estructuras.

struct busBloque
{
char placa[10];
char modelo[10];
char estado[10];

};
typedef struct busBloque B;

struct pilotobloque
{
char DPI[20];
char Nombre[100];
int Edad;
char Genero[5];

};
typedef struct pilotobloque P;
typedef struct nodobloque {
char nombre[20];
char fecha[20];
int seleccion;
B *bus;
P *piloto;
int numeroderutas;
struct nodoDoble *doble;
struct nodobloque *siguiente;

} tipoBloque;

typedef tipoBloque *NodoBLoque;

typedef tipoBloque *ListaBloque;

void InsertarBloque(ListaBloque *lista, char nombre[]);

void BorrarBloque(ListaBloque *lista, char nombre[20]);
int VaciaBloque(ListaBloque l);
void MostrarBloque(ListaBloque l);
void GraficaBloque(ListaBloque lista);
void SeleccionarBLoque(ListaBloque lista, char nombre[15]);
void GraficarPiloto_Bus();

extern int contadorNodos;

extern ListaBloque bloque;
extern NodoBLoque seleccion_bloque_actual;

int Altura(Arbol a, int dat);

Retorna la altura de un determinado nodo.

int AlturaArbol(Arbol a, int* altura);

Retorna la altura completa del árbol

int Vacio(Arbol r);

Metodo que indica si esta vació.

int EsHoja(nodo_arbol_avl r);

Método que retorna si es una hoja o padre.

void Graficar(int s);

Gráfica determinado nodo del árbol
void Escribir(Arbol actual);

Escribe el cuerpo para la grafica.

void Mostrar(int *d);

Metodo imprime los valores de los nodos

int NumeroNodos(Arbol a, int *contador);

Retorna el numero de nodos de determinado arbol.

void Crear_bloque(Arbol a);

Metodo que crea un bloque en formato json.

void Crear_llave_unica(Arbol a);

Crea la llave unica para el bloque.

Métodos y struct del árbol b, realizado para los reportes

using namespace std;

struct User
{

int dpi;
char tarjeta[30];
char nombre[50];
int edad;

};
typedef struct User user;

typedef int tipoClave;

typedef struct pagina
{
user *claves[5];
struct pagina* ramas[5];
int cuenta;
}Pagina;

int nodoLLeno(Pagina* actual);

int nodoSemiVacio(Pagina* actual);
void escribeNodo(Pagina* actual);
void crearArbolB(Pagina** raiz);

APLICACIÓN WEB

app.use("/public",express.static('public'));

app.use(bodyParser.json())// para peticiones app/json

app.use(bodyParser.urlencoded({extended: true}));

app.use(session({
secret: "234asd3453asdf",
saveUninitialized: false,
resave: true
}));

app.set("view engine", "jade");

app.get("/",function(req,res){
res.render("index");
});
 app.get("/login",function(req,res){

res.render("login");

});

app.get("/cerrar",function(req,res){
req.session.nombre = null;
res.redirect("/");

});

app.get("/lista",function(req,res){
// res.render("lista");
listar(res);
});

app.get("/lista2",function(req,res){
listar2(res)

});

app.get("/lista3/:id",function(pedido,respuesta){

respuesta.download(__dirname+'/public/upload/'+pedido.params.i
d,
pedido.params.id,function(err){
if(err){
console.log(err);
}else{
console.log("Listo");
}
});

});