void Busca(AB *Ptab, char item, AB **pt)
{
if(*Ptab == NULL || *pt != NULL)
return;
if(*Ptab->info != item){
Busca(Ptab->esq, item, pt);
Busca(Ptab->dir, item, pt);
}
else *pt = Ptab;
return;
}
int main (int Narg, char *Arg[])
{
contador i;
entero Lista[N];
cadena Camino[N];
logico Exito;
for ( i=0 ; i<N ; i++ )
{ Lista[i] = CadenaAEntero (Arg[i+1]); }
Meta = CadenaAEntero (Arg[N+1]);
Nod_Ordena (Lista);
for ( i=0 ; i<N ; i++ )
{ Cad_ConvierteEntero(Camino[i],Lista[i]); }
CambiaMejor (Lista[0],Camino[0]);
Nod_Total = -1;
Nod_Visto = -1;
if ( Diferencia )
{ Exito = Busca (Lista,Camino); }
else
{ Exito = SI; }
printf ( "%d\n%d\n%lu", Nod_Visto+1, Nod_Total+1, Mejor);
printf ( "\n" );
Explica (MejorCamino);
printf ( "\n" );
return (0);
}
void MochilaDinMem (int k, int VolDisp, TSolucion *SolOptima, TObjeto Objetos[], int N,
TMemoria *Mem) {
TSolucion SolMeterlo, SolNOMeterlo;
int Enc;
if (VolDisp < 0) SolOptima->Beneficio = -INFINITO;
else if (k == N) SolOptima->Beneficio = 0;
else {
Enc = Busca (Mem,N,k,VolDisp,SolOptima);
if (!Enc) {
/* Metemos el objeto en la mochila */
MochilaDinMem (k+1,VolDisp-Objetos[k].Volumen,&SolMeterlo,Objetos,N,Mem);
SolMeterlo.Beneficio += Objetos[k].Beneficio;
SolMeterlo.Objeto[k] = TRUE;
/* NO Metemos el objeto en la mochila */
MochilaDinMem (k+1,VolDisp,&SolNOMeterlo,Objetos,N,Mem);
SolNOMeterlo.Objeto[k] = FALSE;
if (SolMeterlo.Beneficio > SolNOMeterlo.Beneficio) *SolOptima = SolMeterlo;
else *SolOptima = SolNOMeterlo;
}
Almacenar(Mem,N,k,VolDisp,*SolOptima);
}
}
TAB *Busca(TAB* x, int ch){
int i;
TAB *resp = NULL;
if(!x) return resp;
i = 0;
while(i < x->nchaves && ch > x->chave[i]) i++;
if(i < x->nchaves && ch == x->chave[i]) return x;
if(x->folha) return resp;
return Busca(x->filho[i], ch);
}
int InserirFilhoaEsquerda(AB* Ptab, char itempai, char itemfilho){
AB *pai, *pt;
pai == NULL;
Busca(Ptab, itempai, &pai);
if(pai == NULL && pai->esq == NULL){
if(pt == NULL)
return 0;
pt->esq=NULL;
pt->info = itemfilho;
pt->dir = NULL;
pt->esq = pt;
return 1;
}
}
int InserirFilhoaDireita(AB* Ptab, char itempai, char itemfilho){
AB *pai, *pt;
pai == NULL;
Busca(Ptab, itempai, &pai);
if(pai != NULL && pai->dir == NULL){
pt = (AB*)malloc(sizeof(AB));
if(pt == NULL)
return 0;
pt->esq = NULL;
pt->info = itemfilho;
pt->dir=NULL;
pt->dir = pt;
return 1;
}
else return 0;
}
TAB *Insere(TAB *T, int k, int t){
if(Busca(T,k)) return T;
if(!T){
T=Cria(t);
T->chave[0] = k;
T->nchaves=1;
return T;
}
if(T->nchaves == (2*t)-1){
TAB *S = Cria(t);
S->nchaves=0;
S->folha = 0;
S->filho[0] = T;
S = Divisao(S,1,T,t);
S = Insere_Nao_Completo(S,k,t);
return S;
}
T = Insere_Nao_Completo(T,k,t);
return T;
}
int main(void) {
Lista l = CriaLista(10);
InsereInicio(&l, 1);
InsereFim(&l, 116);
InsereFim(&l, 62);
InsereInicio(&l, 145);
InsereInicio(&l, 5);
InsereFim(&l, 662);
InsereFim(&l, 696);
InsereFim(&l, 6);
Imprime(l);
printf("\n");
RemoveInicio(&l);
RemoveInicio(&l);
RemoveFim(&l);
Imprime(l);
printf("\n");
InsereInicio(&l, 1);
InsereInicio(&l, 5);
InsereFim(&l, 662);
InsereFim(&l, 696);
Imprime(l);
printf("\n");
printf("Comprimento: %d\n", Comprimento(l));
printf("Posicao de 62: %d\n", Busca(l, 62));
Libera(&l);
return 0;
}
TAB* retira(TAB* arv, int k, int t){
if(!arv || !Busca(arv, k)) return arv;
return remover(arv, k, t);
}
int main(int argc, char* argv[])
{
long data, x, y, contador, menor_cont, nivel_cinza_inf, nivel_cinza_sup, nivel_mat_decisao;
char vetor[1000];
long lin, col, num_linhas = 0, Janela, lim_jan;
long i,j;
float **matDecisao;
int **matImagem, **matImagem2;
float dado, Media, Variancia, Skewness, Curtosis, DesvioPadrao, Lacunaridade, distancia, menor_dist, dist_ant, menor_dist2, menor_dist3, dist_aux, m_variancia, m_var_lido, fator_k;
float MaxMedia, MaxVariancia, MaxSkewness, MinSkewness, MaxCurtosis, soma_Media, Media_Aprendizagem;
long menor_cont2, menor_cont3, menor_cont_aux;
int soma0, soma255, somadist0, somadist255, iclas, kmed, kvar, kske, kcur, klac, kCorrecaoMedia, knn, FatCorrecao;
struct {
float distancia;
int classe;
} classificacao[15];
ini = clock();
BYTE *ImgIn, ImgOut;
CDIB DIBIn, DIBOut;
short int var1;
struct cell *aux;
inicializa();
if (argc < 3)
{
printf ("Sintaxe: LIM_KNN ImgIn ImOut MatDecisao.txt m v s c l CorrMedia Knn\n");
exit(0);
}
else printf ("LIM_KNN ImgIn ImOut MatDecisao.txt m v s c l CorrMedia Knn\n");
printf ("Limiarizando a imagem %s em %s\n",argv[1], argv[2]);
kmed = atoi(argv[4]);
kvar = atoi(argv[5]);
kske = atoi(argv[6]);
kcur = atoi(argv[7]);
klac = atoi(argv[8]);
kCorrecaoMedia = atoi(argv[9]);
knn = atoi(argv[10]);
DIBIn .LoadBMPFromFile(argv[1]);
printf("Definindo altura e largura da imagem k=%d \n", knn);
x = DIBIn.GetImageWidth();
y = DIBIn.GetImageHeight();
FILE *fpArqMatDecisao;
if ((fpArqMatDecisao = fopen(argv[3], "r")) == NULL)
printf("File Read Error MatDecisao.txt");
while (!feof(fpArqMatDecisao))
{
fgets(vetor, 1000, fpArqMatDecisao);
num_linhas++;
}
fclose(fpArqMatDecisao);
num_linhas = num_linhas - 2;
matImagem = (int **) new (int *[y]);
matImagem2 = (int **) new (int *[y]);
for (i = 0; i < y; i++)
{
matImagem[i] = (int *) new (int [x]);
matImagem2[i] = (int *) new (int [x]);
}
printf("Lendo Aprendizagem\n");
fpArqMatDecisao = fopen(argv[3], "r");
fscanf(fpArqMatDecisao, " %d %f %d %d %d", &Janela, &Media_Aprendizagem, &col, &col, &i); /*HEADER os ultimos tres sao desprezados*/
if (knn == 1) ler(argv[3]);/*Le o arquivo e Monta o vetor - Versao Luciano*/
else /*Versao Horacio*/
{
matDecisao = (float **) new (float *[num_linhas]);
for (i = 0; i < num_linhas; i++)
matDecisao[i] = (float *) new (float [6]);
for (lin = 0; lin < num_linhas; lin++)
{
for (col = 0; col < 6; col++)
{
fscanf(fpArqMatDecisao, " %f ", &dado);
matDecisao[lin][col] = dado;
}
}
}
fclose(fpArqMatDecisao);
printf("Matriz de Decisao lida e armazenada\n");
soma_Media = 0.0;
ImgIn = DIBIn.GetImageBits();
for (lin=0;lin<y;lin++)
{
for (col=0;col<x;col++)
{
matImagem[lin][col]=(int)DIBIn.GetPixelG8(col,lin);
soma_Media = soma_Media + matImagem[lin][col];
}
}
soma_Media = soma_Media / (x*y);
printf("Imagem convertida para a matriz\n");
if (kCorrecaoMedia == 1)
{
FatCorrecao = (int)(Media_Aprendizagem - soma_Media);
for (lin = 0; lin < y; lin++)
for (col = 0; col < x; col++)
{
if ((matImagem[lin][col] + FatCorrecao) > 255) matImagem[lin][col] = 255;
else
if ((matImagem[lin][col] + FatCorrecao) < 0) matImagem[lin][col] = 0;
else matImagem[lin][col] = matImagem[lin][col] + FatCorrecao;
}
}
/********************************/
/*Aqui calculam-se valores p/normalizacao */
MaxVariancia = 0.0;
MaxSkewness = 0.0;
MaxCurtosis = 0.0;
MinSkewness = 99999999999999.9;
printf ("Normalizando dados...\n");
lim_jan = Janela /2;
for (lin = lim_jan; lin < y-lim_jan; lin++)
for (col = lim_jan; col < x-lim_jan; col++)
{
dado = (float)lin/(float)y;
printf("Processando %.2f %\r", (dado*100));
Media = 0.0;
for (i=lin-lim_jan; i<lin+lim_jan+1; i++)
for (j=col-lim_jan; j<col+lim_jan+1; j++)
Media = Media + (float)matImagem[i][j];
Media = (float) Media / (Janela * Janela);
if (Media > MaxMedia) MaxMedia = Media;
Variancia = 0.0;
Skewness = 0.0;
Curtosis = 0.0;
Lacunaridade = 0.0;
for (i=lin-lim_jan; i<lin+lim_jan+1; i++)
for (j=col-lim_jan; j<col+lim_jan+1; j++)
{
Variancia = Variancia + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
Skewness = Skewness + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
Curtosis = Curtosis + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
Lacunaridade = Lacunaridade + (Variancia /((Media + (float)matImagem[i][j]) * (Media + (float)matImagem[i][j])));
}
Variancia = Variancia / (Janela * Janela);
if (Variancia > MaxVariancia) MaxVariancia = Variancia;
if (Variancia == 0.0) DesvioPadrao = 0.000001;
else DesvioPadrao = (float) sqrt (Variancia);
Skewness = Skewness / (Janela * Janela * DesvioPadrao * DesvioPadrao * DesvioPadrao);
if (Skewness > MaxSkewness) MaxSkewness = Skewness;
if (Skewness < MinSkewness) MinSkewness = Skewness;
Curtosis = Curtosis / (Janela * Janela * DesvioPadrao * DesvioPadrao * DesvioPadrao * DesvioPadrao);
if (Curtosis > MaxCurtosis) MaxCurtosis = Curtosis;
Lacunaridade = (float) Lacunaridade /(Janela * Janela);
}
printf ("MaxVariancia %f MinSkewness %f MaxSkewness %f MaxCurtosis %f\n", MaxVariancia, MinSkewness, MaxSkewness, MaxCurtosis);
/********************************/
lim_jan = Janela /2;
printf("Realizando Buscas na Aprendizagem \n");
for (lin = lim_jan; lin < y-lim_jan; lin++)
for (col = lim_jan; col < x-lim_jan; col++)
{
contador = 0;
dado = (float)lin/(float)y;
printf("Processando %.2f %\r", (dado*100));
Media = 0.0;
for (i=lin-lim_jan; i<lin+lim_jan+1; i++)
for (j=col-lim_jan; j<col+lim_jan+1; j++)
Media = Media + (float)matImagem[i][j];
Media = (float) Media / (Janela * Janela);
Variancia = 0.0;
Skewness = 0.0;
Curtosis = 0.0;
Lacunaridade = 0.0;
for (i=lin-lim_jan; i<lin+lim_jan+1; i++)
for (j=col-lim_jan; j<col+lim_jan+1; j++)
{
Variancia = Variancia + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
Skewness = Skewness + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
Curtosis = Curtosis + (((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media) * ((float)matImagem[i][j] - Media));
Lacunaridade = Lacunaridade + (Variancia /((Media + (float)matImagem[i][j]) * (Media + (float)matImagem[i][j])));
}
Variancia = Variancia / (Janela * Janela);
if (Variancia == 0.0) DesvioPadrao = 0.000001;
else DesvioPadrao = (float) sqrt (Variancia);
Skewness = Skewness / (Janela * Janela * DesvioPadrao * DesvioPadrao * DesvioPadrao);
Curtosis = Curtosis / (Janela * Janela * DesvioPadrao * DesvioPadrao * DesvioPadrao * DesvioPadrao);
Lacunaridade = (float) Lacunaridade /(Janela * Janela);
/* Normalizando valores e verificando as caracteristicas a utilizar*/
Media = kmed * Media;
Variancia = kvar * 255 * (Variancia / MaxVariancia);
Skewness = kske * 255 * ((Skewness - MinSkewness) / (MaxSkewness - MinSkewness));
Curtosis = kcur * 255 * (Curtosis / MaxCurtosis);
Lacunaridade = klac * Lacunaridade;
if (knn == 1) /*Versao do Luciano*/
{
aux=Busca(matImagem[lin][col],Media,Variancia,0,Skewness,Curtosis, Lacunaridade);
/*nivel_cinza_inf = tom_cinza->dado;
nivel_cinza_sup = tom_cinza->dado;*/
matImagem2[lin][col] = aux->c3;
} /*Fim versao do Luciano*/
else /*Versao do Horacio para k>1*/
{
while ( (matImagem[lin][col] > (int)matDecisao[contador][0]) && (contador < num_linhas-1) )
contador++; //Possiciona-se na primeira linha correta da Matriz de Decisao
nivel_cinza_inf = matDecisao[contador][0];
nivel_cinza_sup = matDecisao[contador][0];
if (matImagem[lin][col] != (int)matDecisao[contador][0]) /*Nao é igual*/
{
if (contador != 0)
{
nivel_cinza_inf = matDecisao[contador-1][0];
contador = 0;
while ( (nivel_cinza_inf != (int)matDecisao[contador][0]) && (contador < num_linhas-1) )
contador++; /*Possiciona-se na primeira linha correta da Matriz de Decisao*/
}
else nivel_cinza_inf = matDecisao[contador][0];
}
for (iclas=0; iclas<knn; iclas++)
{
classificacao[iclas].distancia = 10000000;
classificacao[iclas].classe = -1;
}
menor_dist = 10000000;
while ((nivel_cinza_inf <= (int)matDecisao[contador][0]) && (nivel_cinza_sup >= (int)matDecisao[contador][0]) && (contador < num_linhas-1) )
{
distancia = (matImagem[lin][col] - matDecisao[contador][0]) + (kmed * ((Media - matDecisao[contador][1]))) + (kvar * ((Variancia - matDecisao[contador][2]) )) + (kske * ((Skewness - matDecisao[contador][4]))) + (kcur * ((Curtosis - matDecisao[contador][5]) )) + (klac * ((Lacunaridade - matDecisao[contador][6])));
if (distancia < menor_dist)
{
for (iclas=(knn-2); iclas > -1; iclas--)
{
classificacao[iclas+1].distancia = classificacao[iclas].distancia;
classificacao[iclas+1].classe = classificacao[iclas].classe;
}
menor_dist = distancia;
classificacao[0].distancia = distancia;
classificacao[0].classe = matDecisao[contador][3];
}
contador++;
}
soma0=0;
soma255=0;
somadist0=0;
somadist255=0;
for (iclas=0; iclas<knn; iclas++)
{
if (classificacao[iclas].classe == 0) soma0++;
if (classificacao[iclas].classe == 255) soma255++;
}
if (soma0 > soma255) matImagem2[lin][col] = 0;
if (soma255 > soma0) matImagem2[lin][col] = 255;
if (soma0 == soma255) //caso especial K= par;
{
for (iclas=0; iclas<knn; iclas++)
{
if (classificacao[iclas].classe == 0) somadist0 = somadist0 + classificacao[iclas].distancia;
if (classificacao[iclas].classe == 255) somadist255 = somadist255 + classificacao[iclas].distancia;
}
if (somadist0 < somadist255) matImagem2[lin][col] = 0;
else matImagem2[lin][col] = 255;
}
} /*Fim versao do Horacio para k>1 */
}
printf("\nFim das Buscas\n");
DIBOut.CreateImage(x,y,8);
for (lin=0;lin<y;lin++)
{
for (col=0;col<x;col++)
{
DIBOut.SetPixelG8(col,lin,BYTE(matImagem2[lin][col]));
/*DIBOut.SetPixelG8(lin,col,BYTE(0));
//DIBOut.SetPixelG8(lin,col,BYTE(matImagem2[lin][col]);*/
}
}
printf("Gravando %s\n",argv[2]);
DIBOut.SaveBMPFromFile(argv[2]);
limpar();
printf("Tempo de execucao (ms): %d\n", (clock() - ini)/1000);
return 0;
}
int main()
{
int i=0;
int InfoInserir;
int x, op=-1, valor;
deque *d;
system("cls");
d=(deque*)malloc(sizeof(deque));
inicializaDeque(d);
while(op != 0)
{
system("pause");
system("cls");
printf("\n\n DEQUE \n\n");
printf("( 1 ) Insere pela Direita.\n");
printf("( 2 ) Insere pela Esquerda.\n");
printf("( 3 ) Remove pela Direita. \n");
printf("( 4 ) Remove pela Esquerda.\n");
printf("( 5 ) Exibe.\n");
printf("( 6 ) Busca. \n");
printf("( 7 ) Organiza. \n");
printf("( 8 ) Limpa Tudo. \n");
printf("\nTempo na Busca: %f\n", tempoB/CLOCKS_PER_SEC);
printf("Tempo no Organizar: %f\n", tempoO/CLOCKS_PER_SEC);
printf("\nInforme a operacao: ");
scanf("%d", &op);
switch(op)
{
case 1:
{
printf("Diga quantos valores deseja inserir pela Direita <-: ");
scanf("%d", &InfoInserir);
for(i=InfoInserir; i>0; i--)
InsereFrent(d,i);
break;
}
case 2:
{
printf("Diga quantos valores deseja inserir pela Esquerda ->: ");
scanf("%d", &InfoInserir);
for(i=0; i<InfoInserir; i++)
InsereFund(d,i);
break;
}
case 3:
{
if(taVazio(d))
RetiraFrent(d);
break;
}
case 4:
{
if(taVazio(d))
RetiraFund(d);
break;
}
case 5:
{
printDeque(d);
break;
}
case 6:
{
printf("Informe valor para busca :");
scanf("%d", &valor);
Busca(d,valor);
break;
}
case 7:
{
Ordena(d);
break;
}
case 8:
{
ApagaTudo(d);
break;
}
default:
{
printf("\nErro: Opcao invalida! Informe novamente.\n");
}
}
}
system("pause");
return 0;
}
void CurvaFluxVol()
{
float far *apt;
float far *apt1;
float volume=0.0, volumeAlca=0.0;
int counter,NumSinal, contador, ContinuaCalculos=FALSE, SinalAnt=0;
NumeroSinal = 0;
moveto(194,115);
apt = inicFlux1;
Atendeu = FALSE;
DisparaContador();
HabilitaInterrup();
do {
DesabilitaInterrup ();
Help = kbhit() && (ESC == getch());
HabilitaInterrup();
if (Help)
Abortou = TRUE;
else
{
while(!Atendeu);
Sinal = Sinal>Zero ? Busca(Sinal,GanhoExp)-512 : Busca(Sinal,GanhoIns)-512;
Atendeu = FALSE;
}
} while((abs(Sinal) < 10)&&(!Abortou));
if (!Abortou)
{
do {
DesabilitaInterrup ();
Help = kbhit() && (ESC == getch());
HabilitaInterrup();
if (Help)
Abortou = TRUE;
else
{
while(!Atendeu);
Sinal = Sinal>Zero ? Busca(Sinal,GanhoExp)-512 : Busca(Sinal,GanhoIns)-512;
if (abs(Sinal-SinalAnt)<120)
{
SinalAnt=Sinal;
volume += Sinal / 6400.0;
lineto (volume*41+194 , (Sinal * -6.25/32) + 115);
}
Atendeu = FALSE;
}
} while ((!Abortou) && (volume >= (-.5)));
do {
DesabilitaInterrup ();
Help = kbhit() && (ESC == getch());
HabilitaInterrup();
if (Help)
Abortou = TRUE;
else
{
while(!Atendeu);
Sinal = Sinal>Zero ? Busca(Sinal,GanhoExp)-512 : Busca(Sinal,GanhoIns)-512;
if (abs(Sinal-SinalAnt)<120)
{
volume += Sinal / 6400.0;
if (ContinuaCalculos && Sinal<=0)
{
ContinuaCalculos=FALSE;
apt=inicFlux1;
NumeroSinal=0;
}
if (ContinuaCalculos && (Sinal <= SinalAnt) && (Sinal>0))
{
ContinuaCalculos=FALSE;
apt=inicFlux1;
NumeroSinal=0;
}
if (Sinal>0)
{
ContinuaCalculos=TRUE;
*apt=Sinal;
++apt;
++NumeroSinal;
}
SinalAnt=Sinal;
lineto (volume*41+194 , (Sinal * -6.25/32) + 115);
}
else
Sinal = SinalAnt;
Atendeu = FALSE;
}
} while ((!Abortou) && (Sinal <= 5));
/************************* 2 ALCA ******************************************/
do {
DesabilitaInterrup ();
Help = kbhit() && (ESC == getch());
HabilitaInterrup();
if (Help)
Abortou = TRUE;
else
{
while(!Atendeu);
Sinal = Sinal>Zero ? Busca(Sinal,GanhoExp)-512 : Busca(Sinal,GanhoIns)-512;
if (abs(Sinal-SinalAnt)<120)
{
SinalAnt=Sinal;
volume += Sinal / 6400.0;
*apt = Sinal;
++apt;
++NumeroSinal;
lineto (volume*41+194 , (Sinal * -6.25/32) +115);
}
else
Sinal = SinalAnt;
Atendeu = FALSE;
}
} while ((Sinal>=0) && (!Abortou) && (NumeroSinal<=NUMMAXPONTOSINF-2000));
/************************* 3 ALCA ******************************************/
contador = 0;
do {
DesabilitaInterrup ();
Help = kbhit() && (ESC == getch());
HabilitaInterrup();
if (Help)
Abortou = TRUE;
else
{
while(!Atendeu);
Sinal = Sinal>Zero ? Busca(Sinal,GanhoExp)-512 : Busca(Sinal,GanhoIns)-512;
if (abs(Sinal-SinalAnt)<120)
{
SinalAnt=Sinal;
volume += Sinal / 6400.0;
*apt = Sinal;
++apt;
++contador;
volumeAlca += Sinal / 6400.0;
lineto (volume*41+194 , (Sinal * -6.25/32) +115);
}
else
Sinal = SinalAnt;
Atendeu = FALSE;
}
} while ((Sinal<=0) && (!Abortou) && (contador <= 2000));
DesabilitaInterrup();
*(apt-1)=FIM;
if (!Abortou)
{
for (apt1 = inicFlux1, counter=0; (*(apt1+1) != FIM) &&
(apt1<inicFlux1+NUMMAXPONTOSINF)&&(*apt1>=0); ++apt1, ++counter);
if (counter<=200)
{
Abortou=TRUE;
gprintf(160,40,"VEF1 INDEFINIDO; TEMPO < 1s");
}
}
if (!Abortou) {
clearviewport();
DesenhaEixos(10,435,10,210,10,75,80,25);
ScalaFluxOlhe();
volume = 0.0;
moveto (20,210);
for (apt=inicFlux1;(*(apt+1)!=FIM)&&(apt<inicFlux1+NUMMAXPONTOSINF);apt++)
{
volume += *apt / 6400.0;
if ( *apt != 0 ) {
lineto (volume*40+20, (* apt / 64.0) * (-12.5) + 135);
}
}
if (FlagIntegridade)
ReCalcula();
CalculaParamFlux(NumSinal);
AtivaJanelaGrafica(GRAF1);
CalculoPercents();
ExibeParametrosUN(180,5);
outtextxy(310,190,PREouPOS);
if (teste1Flux) {
teste2Flux = TRUE;
teste1Flux = FALSE;
}
else
teste1Flux = TRUE;
}
}
else
DesabilitaInterrup();
} /* CurvaFluxVol */
