/***************************************************************************
 *   Copyright (C) 2009 by Douglas Castro   *
 *   douglas@ime.unicamo.br   *
 *                                                                         *
 ***************************************************************************/

#ifndef BASES_H
#define BASES_H


#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "bool.h"
#include "definicoes.h"
#include "arvore.h"
#include "pswr.h"
#include "pswr_iso.h"


/**
 * Compara os valores a e b. retornado um valor negativo se b>a, nulo se a==b e positivo se a>b.
 * @param a [in] dado a ser comparado
 * @param b [in] dado a ser comparado
 */
int compare_doubles (const void *a, const void *b);

/**
 * Pega um pacote de arvores nulas e interpola seus valores ate que nao haja difrenca significante entre toso eles.
 * @param 
 */
void cria_base(VNo pac[], double xmin[], double xmax[], int profund, Preditor pred, double eps, bool_t op);

void interp_pacote(VNo pac[],double xmin[], double xmax[], int ex, Preditor pred, int qual, bool_t op);

void DrawTentMax(char *prefixo, VNo pac[], int d, int prof, Preditor pred, double xmin[], double xmax[], bool_t op);

void desenha_tenda_base_maximal(PSStream *ps, int d, VNo pac[], int prof, Preditor pred, double xmin[], double xmax[], int este, int *atual, double vStart, double vStep, int kMin, int kMax, double *R, double *G, double *B, bool_t maior, double linf[], double lsup[], bool_t op);

/**
 * para uma certa malha {G == pac} encontra a base maximal de S^1(G).
 * o centro do pacote eh a celula superior do dominio da tenda 
 */
void base_maximal(int d, VNo pac[], int prof, Preditor pred, int *elem, int ind, double xmin[], double xmax[], bool_t maior, bool_t op);

/**
 * Para uma certa malha {G == pac} encontra a base minimal de S^1(G).
 * Retorna o numero de elementos da base minimal, isto eh, cada 
 * tenda tem suporte minimo.
 * o centro do pacote eh a celula superior do suporte da tenda 
 * @param d [in] dimensao do dominio 
 * @param pac [in] pacote
 * @param prof [in] profundidade
 * @param pred [in] esquema de previsao
 * @param elem [out] numero de elementos da base minimal
 * @param ind [ind] indice da celula superior no suporte
 */
void base_minimal(int d, VNo pac[], int prof, Preditor pred, int *elem, int ind, bool_t op);

/**
 * para uma certa malha {G == pac} encontra a base minimal de S^1(G). 
 * Pinta o suporte de cada uma das tendas da base, salavando em diferentes
 * arquivos {ps}.
 * Novamente, supoe-se que o centro do pacote eh a celula superior do suporte da tenda.
 * @param d [in] dimensao do dominio 
 * @param pac [in] pacote
 * @param prof [in] profundidade
 * @param pred [in] esquema de previsao
 * @param ind [in] indice da celula superior do suporte
 */
void desenha_elem_base_minimal(PSStream *ps, int d, VNo pac[], int prof, Preditor pred, double xmin[], double xmax[], int este, int *atual, bool_t op);

/**
 * Desenha uma celula que esta no suporte de uma tenda e pinta
 * com uma cor difrente de branco caso seja pedido. Supoe que o dominio eh bidimensional.
 * @param ps [out] arquivo em que a celula do suporte sera desenhada
 * @param xmin [in] coordenada - x - do vertice inferior da celula
 * @param xmax [in] coordenada - x - do vertice superior da celula
 * @param ymin [in] coordenada - y - do vertice inferior da celula
 * @param ymax [in] coordenada - y - do vertice superior da celula
 * @param fill [in] diz se eh ou nao para pintar a celula (TRUE - pinta, FALSE - nao pinta)
 * @param eo [in] nao sei pra que isso(esqueci)...
 */
void DrawCellsSupp(PSStream *ps, double xmin, double xmax, double ymin, double ymax, bool_t fill, bool_t draw, bool_t eo);

/**
 * A chamada de DrawCellSupp faz com que as bordas das celulas folha de uma malha {G} 
 * sejam eventualmente apagadas. Essa funcao redesenha as folhas que foram apagadas.
 * @param ps [out] arquivo em que as folhas serao desenhadas
 * @param d [in] dimensao do dominio (d==2)
 * @param pac [in] malha que tera as folhas gravadas em {ps}
 * @param prof [in] profundidade de uma celula na malha
 * @param pred [in] funcao que preve a media do filho de uma celula, usando seus vizinhos
 * @param xmin [in] coordenadas do vertice inferior da celula mae (centro do pacote {pac})
 * @param xmax [in] coordenadas do vertice superior da celula mae (centro do pacote {pac})
 */
void desenha_folhas_bm(PSStream *ps, int d, VNo pac[], int prof, Preditor pred, double xmin[], double xmax[], double linf[], double lsup[], bool_t op);

/**
 * quando nao tem suporte a ser pintado usa essa rotina, que constroi as
 * celulas usando retas e nao retangulos. isso preserva a cor das celulas
 * do suporte que estao em nivel inferior pois nao tem retangulo a ser preenchido
 * com outra cor.
 * @param ps [out] arquivo em que as retas serao desenhadas, formando as folhas
 * @param xmin [in] coordenadas do vertice inferior da celula mae (centro do pacote {pac})
 * @param xmax [in] coordenadas do vertice superior da celula mae (centro do pacote {pac})
 * @param arrowheads [in] diz se desenha ou nao uma seta na ponta das retas
 */
void DrawLinesSupp(PSStream *ps, double xmin[], double xmax[], bool_t arrowheads);

/**
 * desenha a malha diadica {G} varias vezes, em cada uma delas destaca o suporte de uma
 * tenda da base de S^1(G).
 * @param prefixo [out] prefixo do nome do arquivo em que o supp da tenda sera desenhado
 * @param pac [in] malha que tera o suporte das tendas gravadas
 * @param d [in] dimensao do dominio (d==2)
 * @param prof [in] profundidade de uma celula na malha
 * @param pred [in] funcao que preve a media do filho de uma celula, usando seus vizinhos
 * @param xmin [in] coordenadas do vertice inferior da celula mae (centro do pacote {pac})
 * @param xmax [in] coordenadas do vertice superior da celula mae (centro do pacote {pac})
 */
void DrawSupp(char *prefixo, VNo pac[], int d, int prof, Preditor pred, double xmin[], double xmax[], bool_t op);

/**
 * Calcula a quantidade de celulas teria a malha uniforme em uma certa 
 * profundidade e numa certa direcao.
 * @param d [in] dimensao do dominio
 * @param prof [in] profundidade de uma celula na malha
 * @param ex [in] eixo perpendicular ao hiperplano de refinamento
 */
int num_cel_por_eixo(int d, int prof, int ex);

/**
 * desenha a malha diadica {G} varias vezes, em cada uma delas plota uma
 * tenda da base de S^1(G), usando as curvas de nivel.
 * @param prefixo [out] prefixo do nome do arquivo em que a tenda sera desenhada
 * @param pac [in] malha que tera o suporte das tendas gravadas
 * @param d [in] dimensao do dominio (d==2)
 * @param prof [in] profundidade de uma celula na malha
 * @param pred [in] funcao que preve a media do filho de uma celula, usando seus vizinhos
 * @param xmin [in] coordenadas do vertice inferior da celula mae (centro do pacote {pac})
 * @param xmax [in] coordenadas do vertice superior da celula mae (centro do pacote {pac})
 */
void DrawTentMin(char *prefixo, VNo pac[], int d, int prof, Preditor pred, double xmin[], double xmax[], bool_t op);

/**
 * para uma certa malha {G == pac} encontra a base minimal de S^1(G). 
 * Plota cada uma das tendas da base, salvando em diferentes
 * arquivos {ps}.
 * Supoe-se que o centro do pacote eh a celula superior do suporte da tenda.
 * @param ps [out] arquivo em que as tendas da base minimal serao desenhadas, formando as folhas
 * @param d [in] dimensao do dominio 
 * @param pac [in] pacote
 * @param prof [in] profundidade
 * @param pred [in] esquema de previsao
 * @param xmin [in] coordenadas do vertice inferior da celula mae (centro do pacote {pac})
 * @param xmax [in] coordenadas do vertice superior da celula mae (centro do pacote {pac})
 * @param este [in] numero do elemento da base que sera plotado
 * @param atual [out] proximo elemento da base a ser plotado
 * @param vStart [in] altura da primeira curva de nivel 
 * @param vStep [in] distancia entre as curvas de nivel
 * @param kMin [in]  valor minimo da curva de nivel em {vStart + kMin*vStep}
 * @param kMax [in]  valor maximo da curva de nivel em {vStart + kMax*vStep}
 * @param R [in] cor vermelha, para pintar os diferentes niveis da tenda
 * @param G [in] cor verde, para pintar os diferentes niveis da tenda
 * @param B [in] cor azul, para pintar os diferentes niveis da tenda
 */
void desenha_tenda_base_minimal(PSStream *ps, int d, VNo pac[], int prof, Preditor pred, double xmin[], double xmax[], int este, int *atual, double vStart, double vStep, int kMin, int kMax, double *R, double *G, double *B, double linf[], double lsup[], bool_t op);


/**
 * Desenha as curvas de nivel em cada um dos retalhos, mais precisamente, em cada celula do suporte da tenda
 * plota as curvas de nivel correspondentes.
 * @param ps [out] arquivo em que as tendas da base minimal serao desenhadas, formando as folhas
 * @param d [in] dimensao do dominio (d==2)
 * @param xmin [in] coordenadas do vertice inferior da celula mae (centro do pacote {pac})
 * @param xmax [in] coordenadas do vertice superior da celula mae (centro do pacote {pac})
 * @param vStart [in] altura da primeira curva de nivel 
 * @param vStep [in] distancia entre as curvas de nivel
 * @param kMin [in]  valor minimo da curva de nivel em {vStart + kMin*vStep}
 * @param kMax [in]  valor maximo da curva de nivel em {vStart + kMax*vStep}
 * @param R [in] cor vermelha, para pintar os diferentes niveis da tenda
 * @param G [in] cor verde, para pintar os diferentes niveis da tenda
 * @param B [in] cor azul, para pintar os diferentes niveis da tenda
 * @param lugar [in] diz qual a posicao da celula no suporte (0,1,2,3) 
 */
void desenha_curvas_nivel_retalho(PSStream *ps, int d, double xmin[], double xmax[], double vStart, double vStep, int kMin, int kMax, double *R, double *G, double *B, int lugar, double linf[], double lsup[]);

/**
 * Constroi as celulas usando retas e nao retangulos. isso preserva a cor das 
 * curvas caracteristicas que estao em nivel inferior
 * @param ps [out] arquivo em que as retas serao desenhadas, formando as folhas
 * @param xmin [in] coordenadas do vertice inferior da celula
 * @param xmax [in] coordenadas do vertice superior da celula
 * @param arrowheads [in] diz se desenha ou nao uma seta na ponta das retas
 */
void DrawLinesTenda(PSStream *ps, double xmin[], double xmax[], bool_t arrowheads, double linf[], double lsup[]);

/**
 * Quando se desenha as tendas sobre uma malha {G}, as bordas das celulas folha da malha
 * sao eventualmente apagadas. Essa funcao redesenha as folhas que foram apagadas.
 * @param ps [out] arquivo em que as folhas serao desenhadas
 * @param d [in] dimensao do dominio (d==2)
 * @param pac [in] malha que tera as folhas gravadas em {ps}
 * @param prof [in] profundidade de uma celula na malha
 * @param pred [in] funcao que preve a media do filho de uma celula, usando seus vizinhos
 * @param xmin [in] coordenadas do vertice inferior da celula mae (centro do pacote {pac})
 * @param xmax [in] coordenadas do vertice superior da celula mae (centro do pacote {pac})
 */
void desenha_folhas_tenda_bm(PSStream *ps, int d, VNo pac[], int prof, Preditor pred, double xmin[], double xmax[], double linf[], double lsup[], bool_t op);

/** exemplo de como desenhar as curvas de nivel */
void Retalho(char *prefixo, VNo pac[], int d, int prof, Preditor pred, double xmin[], double xmax[]);

/** desenha sa curvas nivel numa folha considerando uma funcao generica 
 * 
 * 
 */
void desenha_curvas_nivel_retalho_spline(PSStream *ps, int d, double xmin[], double xmax[], double fx[], double vStart, double vStep, int kMin, int kMax, double *R, double *G, double *B, double linf[], double lsup[]);

void splineExemplo(char *prefixo, VNo pac[], int d, int prof, Preditor pred, double xmin[], double xmax[], Funcao f, bool_t op);
void desenha_retalho_spline(PSStream *ps, int d, VNo pac[], int prof, Preditor pred, double xmin[], double xmax[], double vStart, double vStep, int kMin, int kMax, double *R, double *G, double *B, Funcao f, double linf[], double lsup[], bool_t op);
#endif