binaries/src/tcoffee/t_coffee_source/io_func.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <ctype.h>
   4 #include <string.h>
   5 #include <ctype.h>
   6 #include <stdlib.h>
   7 #include "io_lib_header.h"
   8 #include "util_lib_header.h"
   9 #include "define_header.h"
  10 #include "matrices.h"
  11
  12 #define DEFAULT_COLOR -1
  13 #define GAP_COLOR     -2
  14 #define INK_COLOR     -3
  15
  16 Sequence * cw_read_sequences ( char *seq_name)
  17         {
  18         Sequence *S;
  19
  20
  21         char **seq=NULL;
  22         char **name=NULL;
  23         int *len=NULL;
  24         int nseq=0;
  25         int min_len=0;
  26         int max_len=0;
  27         int a;
  28
  29         get_sequence ( seq_name, &nseq, &seq, &name, &len, &min_len, &max_len);
  30
  31         S=declare_sequence ( min_len, max_len, nseq);
  32         for ( a=0; a< nseq; a++)sprintf ( S->file[a], "%s", seq_name);
  33
  34         for ( a=0; a<S->nseq; a++)
  35             {
  36             S->len[a]=len[a];
  37             sprintf ( S->name[a],"%s", name[a]);
  38             vfree ( name[a]);
  39             sprintf ( S->seq[a], "%s", seq[a]);
  40             vfree ( seq[a]);
  41             }
  42         vfree (seq);
  43         vfree (name);
  44         vfree (len);
  45         S=get_sequence_type ( S);
  46         return S;
  47         }
  48 char *    get_string_type   (char *S)
  49         {
  50         int a, l;
  51         int protein=0,  dna=0,rna=0, tot=0;
  52         char *type;
  53         static char *ltype;
  54         static int warning;
  55
  56         if ( !ltype)
  57           declare_name(ltype);
  58
  59         declare_name(type);
  60         l=(int)strlen (S);
  61
  62         if (l==0)
  63           {
  64             sprintf ( type, "UNKNOWN");
  65             return type;
  66           }
  67
  68         for ( a=0; a<l; a++)
  69                 {
  70                     if ( !is_gap(S[a]))
  71                         {
  72                         protein+=( is_aa (S[a]) && !is_dna(S[a]));
  73                         dna+=    ( is_dna(S[a]));
  74                         rna+=    ( is_rna(S[a]));
  75                         tot++;
  76                         }
  77                 }
  78
  79         protein=(protein*100)/tot;
  80         dna=(dna*100)/tot;
  81         rna=(rna*100)/tot;
  82
  83         if ( l<20 && warning==0)
  84           {
  85             /*add_warning ( stderr, "WARNING: short sequences, use -type=DNA or PROTEIN");*/
  86             warning=1;
  87           }
  88         if ( l<20 && ltype && ltype[0])
  89           {
  90             if (dna==100)
  91               {
  92                 sprintf ( type, "%s", ltype);
  93                 ltype[0]='\0';
  94               }
  95             else
  96               sprintf ( type, "PROTEIN");
  97
  98           }
  99         else if ( dna>98 && rna>0)sprintf ( type, "RNA");
 100         else if ( dna>98)sprintf ( type, "DNA");
 101         else sprintf ( type, "PROTEIN");
 102
 103         sprintf ( ltype, "%s", type);
 104         return type;
 105         }
 106
 107 Alignment* get_aln_type (Alignment *A)
 108         {
 109           if ( !A) return A;
 110
 111           if ( A->S && !(A->S)->type)(A->S)->type=vcalloc (30, sizeof (char));
 112
 113           if ( A->S && (A->S)->type[0]!='\0')
 114             {
 115             ;
 116             }
 117           else if (A->S!=NULL && (A->S)->type[0]=='\0')
 118             {
 119               A->S=get_sequence_type (A->S);
 120             }
 121           else if (A->S==NULL)
 122               {
 123                 A->S=aln2seq (A);
 124                 A->S=get_sequence_type(A->S);
 125               }
 126           return A;
 127         }
 128
 129
 130
 131 char *unset_mode ()
 132 {
 133   return set_mode (UNSET, NULL);
 134 }
 135 char *store_mode (char *val)
 136 {
 137   return set_mode (SET, val);
 138 }
 139 char *retrieve_mode ()
 140 {
 141   return set_mode (GET,NULL);
 142 }
 143 char *set_mode (int mode, char *val)
 144 {
 145   static char type[100];
 146   if (mode==SET)
 147     {
 148       if (!val)printf_exit (EXIT_FAILURE, stderr, "Error:  programme mode unset in io_func.c:set_seq_type");
 149       sprintf ( type,"%s", val);
 150     }
 151   else if ( mode==GET)
 152     {
 153       ;
 154     }
 155   else if ( mode==UNSET)
 156     {
 157       type[0]='\0';
 158     }
 159   else
 160     {
 161       printf_exit (EXIT_FAILURE, stderr, "Error: unknown mode in function io_func.c:set_seq_type, use SET, GET or UNSET");
 162     }
 163   return type;
 164 }
 165 /************************************************************/
 166
 167
 168
 169 char *unset_seq_type ()
 170 {
 171   return set_seq_type (UNSET, NULL);
 172 }
 173 char *store_seq_type (char *val)
 174 {
 175   return set_seq_type (SET, val);
 176 }
 177 char *retrieve_seq_type ()
 178 {
 179   return set_seq_type (GET,NULL);
 180 }
 181 char *set_seq_type (int mode, char *val)
 182 {
 183   static char type[100];
 184   if (mode==SET)
 185     {
 186       if (!val)printf_exit (EXIT_FAILURE, stderr, "Error: sequence type unset in io_func.c:set_seq_type");
 187       sprintf ( type,"%s", val);
 188     }
 189   else if ( mode==GET)
 190     {
 191       ;
 192     }
 193   else if ( mode==UNSET)
 194     {
 195       type[0]='\0';
 196     }
 197   else
 198     {
 199       printf_exit (EXIT_FAILURE, stderr, "Error: unknown mode in function io_func.c:set_seq_type, use SET, GET or UNSET");
 200     }
 201   return type;
 202 }
 203 char * get_array_type (int n, char **seq)
 204 {
 205   char *buf, *buf2;
 206   int a, tot=0;
 207   buf2=vcalloc ( 100, sizeof (char));
 208
 209
 210   for ( tot=0,a=0; a<n; a++)tot+=strlen (seq[a]);
 211   buf=vcalloc (tot+1, sizeof (char));
 212   for ( a=0; a<n; a++)strcat (buf, seq[a]);
 213   sprintf ( buf2, "%s", get_string_type(buf));
 214   vfree (buf);
 215   return buf2;
 216 }
 217 Sequence *get_sequence_type (Sequence *S)
 218 {
 219   if ( !S) return NULL;
 220   else sprintf ( S->type, "%s", get_array_type (S->nseq, S->seq));
 221   return S;
 222 }
 223
 224
 225 void get_sequence (char *seq_file,int *NSEQ, char ***SEQ, char ***SN, int **sl, int *min, int *max)
 226         {
 227         int a,b;
 228         int min_len;
 229         int max_len;
 230         int nseq;
 231
 232         int **SL;
 233
 234         nseq=NSEQ[0]= readseqs ( seq_file,  SEQ, SN, &SL);
 235         sl[0]=vcalloc ( nseq, sizeof (int));
 236
 237
 238         min_len= max_len= (SL)[0][0];
 239         for ( a=0; a<NSEQ[0]; a++)
 240                 {
 241                 sl[0][a]=SL[a][0];
 242                 for ( b=0; b<(SL)[a][0]; b++)
 243                         (SEQ[0])[a][b]=tolower ((SEQ[0])[a][b]);
 244                  }
 245         for ( a=1; a<NSEQ[0]; a++)
 246                 {
 247                 min_len= ( min_len > (SL)[a][0])?(SL)[a][0]:min_len;
 248                 max_len= ( max_len < (SL)[a][0])?(SL)[a][0]:max_len;
 249                 }
 250         min[0]=min_len;
 251         max[0]=max_len;
 252         }
 253
 254 int ** get_matrix   ( char *name, char *format)
 255        {
 256
 257        if ( strm ( "blast", format))return read_blast_matrix ( name);
 258        else if ( strm ( "clustalw", format))return read_matrice(name);
 259        else
 260            {
 261            fprintf ( stderr, "\nError:\nUnknowm Format %s for Matrix %s[FATAL]", format, name);
 262            myexit (EXIT_FAILURE);
 263            }
 264        return NULL;
 265        }
 266 void display_matrix (int **mat);
 267 int ** read_matrice (char *mat_name_in)
 268         {
 269         int a,b,c, l;
 270
 271         char *AA;
 272         FILE *fp;
 273         int **matrice;
 274         int **matrix2;
 275         char mat_name[200];
 276         int *vector=NULL;
 277
 278         AA=vcalloc (256, sizeof (char));
 279         sprintf (AA, "abcdefghiklmnpqrstvwxyz");
 280         l=strlen(AA);
 281
 282
 283
 284
 285         if ( strm2 (mat_name_in, "pam", "PAM"))sprintf ( mat_name, "pam250mt");
 286         else if (strm2 (mat_name_in, "blosum", "BLOSUM"))sprintf ( mat_name, "blosum62mt");
 287         else if (strm3 (mat_name_in, "id", "ID", "idmat"))sprintf ( mat_name, "idmat");
 288         else sprintf ( mat_name, "%s", mat_name_in);
 289
 290         /*Read Header Matrices*/
 291         if (strm(mat_name, "pam250mt"))vector=pam250mt;
 292         else if (strm(mat_name, "idmat"))vector=idmat;
 293         else if (strm(mat_name, "dna_idmat"))vector=idmat;
 294         else if (strm(mat_name, "est_idmat"))vector=est_idmat;
 295         else if (strm(mat_name, "md_350mt"))vector=md_350mt;
 296         else if (strm(mat_name, "md_250mt"))vector=md_250mt;
 297         else if (strm(mat_name, "md_120mt"))vector=md_120mt;
 298         else if (strm(mat_name, "md_40mt" ))vector= md_40mt;
 299         else if (strm(mat_name, "pam350mt" ))vector=pam350mt;
 300         else if (strm(mat_name, "pam160mt" ))vector=pam160mt;
 301         else if (strm(mat_name, "pam120mt" ))vector=pam120mt;
 302
 303         else if (strm(mat_name, "blosum80mt" ))vector=blosum80mt;
 304         else if (strm(mat_name, "blosum62mt" ))vector=blosum62mt;
 305         else if (strm(mat_name, "exon2mt" ))vector=blosum62mt;
 306         else if (strm(mat_name, "blosum62mt3" ))vector=blosum62mt3;
 307
 308         else if (strm(mat_name, "blosum62mt2" ))vector=blosum62mt2;
 309         else if (strm(mat_name, "blosum55mt" ))vector=blosum55mt;
 310         else if (strm(mat_name, "blosum50mt" ))vector=blosum50mt;
 311         else if (strm(mat_name, "blosum45mt" ))vector=blosum45mt;
 312
 313         else if (strm(mat_name, "blosum40mt" ))vector=blosum40mt;
 314         else if (strm(mat_name, "blosum30mt" ))vector=blosum30mt;
 315         else if (strm(mat_name, "beta_mat" ))vector=beta_mat;
 316         else if (strm(mat_name, "alpha_mat" ))vector=alpha_mat;
 317         else if (strm(mat_name, "coil_mat" ))vector=coil_mat;
 318
 319         else if (strm(mat_name, "rblosum80mt" ))vector=rblosum80mt;
 320         else if (strm(mat_name, "rblosum62mt" ))vector=rblosum62mt;
 321         else if (strm(mat_name, "rblosum30mt" ))vector=rblosum30mt;
 322
 323         else if (strm(mat_name, "rpam250mt" ))vector=rpam250mt;
 324         else if (strm(mat_name, "rpam350mt" ))vector=rpam350mt;
 325         else if (strm(mat_name, "rpam160mt" ))vector=rpam160mt;
 326         else if (strm(mat_name, "rpam120mt" ))vector=rpam120mt;
 327
 328         else if (strm(mat_name, "tmpam250mt" ))vector=tmpam250mt;
 329         else if (strm(mat_name, "rtmpam250mt" ))vector=rtmpam250mt;
 330
 331         else if (strm(mat_name, "rbeta_mat" ))vector=rbeta_mat;
 332         else if (strm(mat_name, "ralpha_mat" ))vector=ralpha_mat;
 333         else if (strm(mat_name, "rcoil_mat" ))vector=rcoil_mat;
 334         else if (strm (mat_name, "jtttm250mt"))vector=jtttm250mt;
 335
 336         else if (strm (mat_name, "promoter_tf1"))vector=promoter_tf1;
 337         else if (strm (mat_name, "blosumR"))vector=blosumR;
 338
 339         /*Header Matrices*/
 340         if(vector)
 341           {
 342             matrice=declare_int ( 256, 256);
 343             for (a=0; a<l; ++a)
 344                 {
 345                  for (b=0;b<=a;++b)
 346                    {
 347                      matrice[a][b]=matrice[b][a]=(vector[(a*a+a)/2+b]);
 348                    }
 349                 }
 350           }
 351
 352           /*Hard coded Matrices*/
 353
 354         else if ( strm (mat_name, "exon_mt"))
 355           {
 356             matrice=declare_int ( 256, 256);
 357             sprintf (AA, "bojx");
 358             l=4;
 359             for ( a=0; a<l-1; a++)
 360               {
 361                 matrice[a][a]=10;
 362                 for ( b=a+1; b< l-2; b++)
 363                   {
 364                     matrice[a][b]=matrice[b][a]=5;
 365                   }
 366               }
 367
 368           }
 369         else if ( strm ( mat_name, "tdamat"))
 370           {
 371             int x, y;
 372             matrice=declare_int ( 256, 256);
 373             sprintf ( AA, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 374             l=strlen (AA);
 375             for ( x=0; x<l; x++)
 376               for ( y=0; y<l; y++)matrice[x][y]=-10;
 377             for ( x=0; x<l; x++) {matrice[x][x]=0; matrice[x][GAP_CODE]=-3;}
 378             return matrice;
 379           }
 380         /*Blast Matrices*/
 381         else if ( check_file_exists(mat_name) && is_blast_matrix (mat_name))
 382           {
 383
 384             matrice=read_blast_matrix ( mat_name);
 385             return matrice;
 386           }
 387         else if ( check_file_exists(mat_name) && is_pavie_matrix (mat_name))
 388           {
 389
 390             matrice=read_pavie_matrix ( mat_name);
 391             return matrice;
 392           }
 393
 394         else if ( check_file_exists(mat_name) && is_clustalw_matrix (mat_name))
 395                 {
 396
 397                   fp=vfopen ( mat_name, "r");
 398                   while ( (c=fgetc (fp))!='$' && c!=EOF);
 399                   if ( c==EOF){vfclose (fp);return NULL;};
 400
 401                   matrice=declare_int ( 256, 256);
 402                   fgetc(fp);
 403                   for ( a=0; a<l; a++)
 404                     {
 405                       for ( b=0; b<=a; b++)
 406                         if (fscanf ( fp, "%d,", &matrice[a][b])==0){vfclose (fp);free_int (matrice, -1);return NULL;};
 407                       fscanf ( fp, "\n");
 408                     }
 409                   fclose ( fp);
 410                 }
 411         else {return NULL;}
 412
 413
 414         matrix2=declare_int ( 256, 256);
 415         for ( b=0; b<l; b++)
 416                 for ( c=0; c<l; c++)
 417                         {
 418
 419                         matrix2[toupper(AA[b])-'A'][toupper(AA[c])-'A']=matrice[b][c];
 420                         matrix2[toupper(AA[b])-'A'][tolower(AA[c])-'A']=matrice[b][c];
 421                         matrix2[tolower(AA[b])-'A'][toupper(AA[c])-'A']=matrice[b][c];
 422                         matrix2[tolower(AA[b])-'A'][tolower(AA[c])-'A']=matrice[b][c];
 423                         }
 424         if ( strm ( "exon2mt", mat_name))
 425           {
 426             char EE[4];
 427             int v=(getenv ("EXONVALUE_4_TCOFFEE"))?atoi("EXONVALUE_4_TCOFFEE"):100;
 428             sprintf (EE, "obj");
 429             for (a=0; a<strlen (EE); a++)
 430               {
 431                 matrix2[toupper(EE[a])-'A'][toupper(EE[a])-'A']=v;
 432                 matrix2[tolower(EE[a])-'A'][toupper(EE[a])-'A']=v;
 433                 matrix2[toupper(EE[a])-'A'][tolower(EE[a])-'A']=v;
 434                 matrix2[tolower(EE[a])-'A'][tolower(EE[a])-'A']=v;
 435               }
 436           }
 437
 438         /*Correct for RNA: Add the U cost*/
 439         for (b=0; b<l; b++)
 440           {
 441
 442             matrix2['U'-'A'][toupper(AA[b])-'A']=matrix2['T'-'A'][toupper(AA[b])-'A'];
 443             matrix2[toupper(AA[b])-'A']['U'-'A']=matrix2[toupper(AA[b])-'A']['T'-'A'];
 444             matrix2['U'-'A'][toupper(AA[b])-'A']=matrix2['t'-'A'][tolower(AA[b])-'A'];
 445             matrix2[tolower(AA[b])-'A']['u'-'A']=matrix2[tolower(AA[b])-'A']['t'-'A'];
 446
 447           }
 448         matrix2['U'-'A']['U'-'A']=matrix2['T'-'A']['T'-'A'];
 449         matrix2['u'-'A']['U'-'A']=matrix2['t'-'A']['T'-'A'];
 450         matrix2['U'-'A']['u'-'A']=matrix2['T'-'A']['t'-'A'];
 451         matrix2['u'-'A']['u'-'A']=matrix2['t'-'A']['t'-'A'];
 452
 453         free_int (matrice, -1);
 454         return (matrix2);
 455
 456         }
 457
 458 void display_matrix (int **mat)
 459 {
 460   int a, b;
 461
 462   for ( a=0; a< 26; a++)
 463     {
 464       fprintf ( stderr, "\n%c ", a+'a');
 465       for ( b=0; b< 26; b++)
 466         fprintf ( stderr, " %2d", mat[a][b]);
 467     }
 468 }
 469
 470 int **neg_matrix2pos_matrix ( int **matrix)
 471     {
 472       int b,c,l, min, max;
 473       char AA[]="abcdefghiklmnpqrstvwxyzABCDEFGHIKLMNPQRSTVWXYZ";
 474       l=strlen(AA);
 475       min=max=matrix[AA[0]-'A'][AA[0]-'A'];
 476       for ( b=0; b<l; b++)
 477         for ( c=0; c<l; c++)
 478           {
 479             min=(matrix[AA[b]-'A'][AA[c]-'A']<min)?matrix[AA[b]-'A'][AA[c]-'A']:min;
 480             max=(matrix[AA[b]-'A'][AA[c]-'A']<max)?matrix[AA[b]-'A'][AA[c]-'A']:max;
 481           }
 482       if (min>0)return matrix;
 483       else
 484          {
 485            for ( b=0; b<l; b++)
 486              for ( c=0; c<l; c++)
 487                {
 488                  matrix[b][c]=matrix[b][c]-min;
 489                }
 490          }
 491       return matrix;
 492     }
 493
 494
 495
 496 /*****************************************************************/
 497 void get_rgb_values ( int val, Color *C)
 498      {
 499
 500        /*Colors can be modified, see the definition of
 501          COLOR_FILE in prgogrammes_define.h
 502        */
 503
 504      static char **html_code;
 505      static float **ps_code;
 506      int class, n, c;
 507      float *r, *g, *b;
 508      FILE *fp;
 509
 510
 511
 512      if ( !html_code)
 513        {
 514          html_code=declare_char(10, 10);
 515          ps_code=declare_float  (10, 3);
 516
 517          n=0;
 518          /*0*/
 519          sprintf (html_code[n], "#6666FF");
 520          ps_code[n][0]=0.4;
 521          ps_code[n][1]=0.4;
 522          ps_code[n][2]=1;
 523          n++;
 524          /*1*/
 525          sprintf (html_code[n], "#00FF00");
 526          ps_code[n][0]=0.6;
 527          ps_code[n][1]=1;
 528          ps_code[n][2]=0;
 529          n++;
 530
 531          /*2*/
 532          sprintf (html_code[n], "#66FF00");
 533          ps_code[n][0]=0.8;
 534          ps_code[n][1]=1;
 535          ps_code[n][2]=0;
 536          n++;
 537
 538          /*3*/
 539          sprintf (html_code[n], "#CCFF00");
 540          ps_code[n][0]=1.0;
 541          ps_code[n][1]=1.0;
 542          ps_code[n][2]=0;
 543          n++;
 544
 545          /*4*/
 546          sprintf (html_code[n], "#FFFF00");
 547          ps_code[n][0]=1;
 548          ps_code[n][1]=0.85;
 549          ps_code[n][2]=0;
 550          n++;
 551
 552          /*5*/
 553          sprintf (html_code[n], "#FFCC00");
 554          ps_code[n][0]=1;
 555          ps_code[n][1]=0.7;
 556          ps_code[n][2]=0;
 557          n++;
 558
 559          /*6*/
 560          sprintf (html_code[n], "#FF9900");
 561          ps_code[n][0]=1;
 562          ps_code[n][1]=0.6;
 563          ps_code[n][2]=0;
 564          n++;
 565
 566          /*7*/
 567          sprintf (html_code[n], "#FF6600");
 568          ps_code[n][0]=1;
 569          ps_code[n][1]=0.4;
 570          ps_code[n][2]=0;
 571          n++;
 572
 573          /*8*/
 574          sprintf (html_code[n], "#FF3300");
 575          ps_code[n][0]=1;
 576          ps_code[n][1]=0.2;
 577          ps_code[n][2]=0;
 578          n++;
 579
 580
 581          /*9*/
 582          sprintf (html_code[n], "#FF2000");
 583          ps_code[n][0]=1;
 584          ps_code[n][1]=0;
 585          ps_code[n][2]=0;
 586          n++;
 587
 588
 589
 590
 591
 592          if ( check_file_exists(COLOR_FILE))
 593            {
 594              fp=vfopen( COLOR_FILE, "r");
 595
 596              while ((c=fgetc(fp))!='*');
 597              while ((c=fgetc(fp))!='\n');
 598
 599              c=0;
 600              while ((c=fgetc(fp))!=EOF)
 601                {
 602                  ungetc(c, fp);
 603                  if ( fscanf (fp, "%d", &class)==0)break;
 604                  fscanf (fp, "%s %f %f %f", html_code[class], &ps_code[class][0], &ps_code[class][1],&ps_code[class][2]);
 605                  while ((c=fgetc(fp))!='\n' && c!=EOF);
 606                  if ( c==EOF)ungetc(c, fp);
 607                }
 608              vfclose(fp);
 609            }
 610        }
 611
 612
 613
 614      /*Conversions*/
 615      if ( val==10)val--;
 616
 617      r=&C->r;
 618      g=&C->g;
 619      b=&C->b;
 620
 621      if ( val==10)val--;
 622      sprintf ( C->html_color_class, "value%d",val);
 623
 624
 625      if (val<=9 && val>=0)
 626        {
 627
 628          sprintf ( C->html_color, "%s", html_code[val]);
 629          r[0]=ps_code[val][0];
 630          g[0]=ps_code[val][1];
 631          b[0]=ps_code[val][2];
 632        }
 633
 634      else if (val==DEFAULT_COLOR || val==NO_COLOR_RESIDUE || val==NO_COLOR_GAP || (val>'A' && val<'z'))
 635        {
 636         C->html_color[0]='\0';
 637         sprintf ( C->html_color_class, "valuedefault");
 638         r[0]=1.;
 639         g[0]=1;
 640         b[0]=1;
 641
 642         }
 643      else if (val==GAP_COLOR)
 644        {
 645         C->html_color[0]='\0';
 646         sprintf ( C->html_color_class, "valuegap");
 647         r[0]=1.;
 648         g[0]=1;
 649         b[0]=1;
 650         }
 651      else if (val==INK_COLOR )
 652         {
 653         sprintf ( C->html_color, "000000");
 654         sprintf ( C->html_color_class, "valueink");
 655         r[0]=0.;
 656         g[0]=0;
 657         b[0]=0;
 658         }
 659      return;
 660
 661
 662      }
 663
 664 // void output_tm_mark(FILE_format *fps)
 665 // {
 666 //    Color *box_c=vcalloc ( 1, sizeof (Color));
 667 //    Color *ink;
 668 //    get_rgb_values_format (INK_COLOR,     (ink  =vcalloc ( 1, sizeof (Color))));
 669 //
 670 //    get_rgb_values_format ( 5, box_c);
 671 //    fps=print_format_char ( " IN ", box_c,ink,fps);
 672 //
 673 //    get_rgb_values_format ( 9, box_c);
 674 //    fps=print_format_char ( " HEL ", box_c,ink,fps);
 675 //
 676 //    get_rgb_values_format ( 0, box_c);
 677 //    fps=print_format_char ( "OUT", box_c,ink,fps);
 678 // }
 679
 680 int output_color_format ( Alignment *B,Alignment *Sin,char *name, \
 681 FILE_format *(*vfopen_format)          ( char *),\
 682 FILE_format *(*print_format_string)    ( char * ,Color *, Color *, FILE_format*),\
 683 FILE_format *(*print_format_char)      ( int    ,Color *, Color *, FILE_format*),\
 684 void         (*get_rgb_values_format)  ( int    ,Color *),\
 685 FILE_format* (*vfclose_format)         ( FILE_format *))
 686     {
 687     int a, b, c;
 688     int max_name_len=15;
 689     int max_len=0;
 690     char *buf2, *buf3;
 691
 692     static char *buf;
 693     int s;
 694     int *n_residues;
 695     static FILE_format *fps;
 696     Color *ink;
 697     Color *box_c;
 698     Color *white;
 699     Alignment *S;
 700
 701
 702     S=copy_aln (B, NULL);
 703
 704     buf2=vcalloc (Sin->len_aln+1, sizeof (char));
 705     buf3=vcalloc (  B->len_aln+1, sizeof (char));
 706     for ( a=0; a<B->nseq; a++)
 707       {
 708         int i,n, r;
 709
 710         i=name_is_in_list ( B->name[a], Sin->name, Sin->nseq, -1);
 711         if (i==-1)continue;
 712         sprintf (buf2, "%s", Sin->seq_al[i]);ungap(buf2);
 713         sprintf (buf3, "%s", S->seq_al[a]);ungap(buf3);
 714
 715         if ( strlen (buf2) !=strlen(buf3))
 716           {
 717
 718             fprintf ( stderr, "\nERROR: Incompatible cache ON sEQ: %s\n", S->name[a]);
 719             fprintf ( stderr, "\n%s\n%s", buf2, buf3);
 720             fprintf ( stderr, "\n\n%s\n%s", Sin->seq_al[i],S->seq_al[a]); exit (EXIT_FAILURE);
 721           }
 722
 723         for (n=0,b=0;b<B->len_aln; b++)
 724           {
 725             r=S->seq_al[a][b];
 726             if (!is_gap(r))
 727               {
 728                 S->seq_al[a][b]=buf2[n++];
 729               }
 730           }
 731       }
 732
 733     S=aln2number(S);
 734     vfree (buf2);
 735
 736     box_c=vcalloc ( 1, sizeof (Color));
 737     get_rgb_values_format (DEFAULT_COLOR, (white=vcalloc ( 1, sizeof (Color))));
 738     get_rgb_values_format (INK_COLOR,     (ink  =vcalloc ( 1, sizeof (Color))));
 739
 740     n_residues=vcalloc ( B->nseq+1, sizeof (int));
 741     for ( a=0; a<B->nseq; a++)n_residues[a]=B->order[a][1];
 742
 743     fps=vfopen_format( name);
 744     if ( buf==NULL)
 745         {
 746         buf=vcalloc (10000, sizeof (int));
 747         }
 748
 749     if ( max_len==0)
 750         {
 751         for ( a=0; a< B->nseq; a++)
 752             {if ( strlen (B->name[a])>max_len)
 753                 max_len= strlen ( (B->name[a]));
 754             }
 755         }
 756     if ( max_len>max_name_len)max_len=max_name_len;
 757
 758    sprintf (buf, "\n%s, %s(%s)\n%s\n",PROGRAM,VERSION,DATE, AUTHOR);
 759    fps=print_format_string ( buf,white, ink, fps);
 760
 761    if(B->output_tm == 1)
 762    {
 763         fps=print_format_char ( '\n', white, ink, fps);
 764         get_rgb_values_format ( 5, box_c);
 765         fps=print_format_string ( " IN ", box_c,ink,fps);
 766
 767         get_rgb_values_format ( 9, box_c);
 768         fps=print_format_string ( " HEL ", box_c,ink,fps);
 769
 770         get_rgb_values_format ( 0, box_c);
 771         fps=print_format_string ( " OUT ", box_c,ink,fps);
 772    }
 773
 774    fps=print_format_string ( "\n\n",white,ink, fps);
 775
 776    fps->line-=max_len;
 777    fps->line=fps->line-fps->line%3;
 778
 779
 780
 781
 782    for (a=0; a<B->len_aln; a+=fps->line)
 783            {
 784
 785            if ( (fps->n_line+(B->nseq+4))>fps->max_line_ppage && !((B->nseq+4)>fps->max_line_ppage))
 786                  {
 787                  fps=print_format_char ( fps->eop,white, ink, fps);
 788                  }
 789
 790            for (b=0; b<=B->nseq; b++)
 791              {
 792                sprintf (buf,"%-*.*s ",max_len+2, max_len,(b==B->nseq)?"":S->name[b]);
 793                fps=print_format_string ( buf,white, ink, fps);
 794                if(B->output_res_num)
 795                  {
 796                    sprintf (buf, " %4d ", n_residues[b]+1);
 797                    fps=print_format_string ( buf,white, ink, fps);
 798                  }
 799
 800                for (fps->in_seq=1,c=a;c<a+fps->line && c<B->len_aln;c++)
 801                  {
 802                    if (b==B->nseq)
 803                      {
 804                        n_residues[b]++;
 805                        get_rgb_values_format (DEFAULT_COLOR,box_c);
 806                        s=analyse_aln_column ( B, c);
 807                      }
 808                    else
 809                      {
 810                        n_residues[b]+=!is_gap(B->seq_al[b][c]);
 811                        s=B->seq_al[b][c];
 812                        if (!is_gap(s) && S->seq_al[b][c]!=NO_COLOR_RESIDUE )
 813                          {
 814                            get_rgb_values_format ( S->seq_al[b][c], box_c);
 815                          }
 816                        else
 817                          {
 818                            get_rgb_values_format (GAP_COLOR, box_c);
 819                          }
 820                      }
 821                 fps=print_format_char ( s,box_c, ink,fps);
 822                 }
 823               fps->in_seq=0;
 824
 825                if(B->output_res_num)
 826                  {
 827                  sprintf (buf, " %4d ", n_residues[b]);
 828                  fps=print_format_string ( buf,white, ink, fps);
 829                  }
 830
 831               fps=print_format_char ( '\n', white, ink, fps);
 832
 833              }
 834             fps=print_format_string ( "\n\n",white, ink, fps);
 835             }
 836     fps=print_format_string ( "\n\n\n",white, ink,fps);
 837
 838
 839     vfclose_format( fps);
 840     free_aln (S);
 841     vfree (n_residues);
 842     return 1;
 843
 844     }
 845
 846 int output_reliability_format ( Alignment *B,Alignment *S,char *name, \
 847 FILE_format *(*vfopen_format)          ( char *),\
 848 FILE_format *(*print_format_string)    ( char * ,Color *, Color *, FILE_format*),\
 849 FILE_format *(*print_format_char)      ( int    ,Color *, Color *, FILE_format*),\
 850 void         (*get_rgb_values_format)  ( int    ,Color *),\
 851 FILE_format* (*vfclose_format)         ( FILE_format *))
 852     {
 853     int a, b, c,l;
 854     int max_name_len=15;
 855     int max_len=0;
 856     static char *buf,*buf2;
 857     int s;
 858     static FILE_format *fps;
 859     Color *ink;
 860     Color *box_c;
 861     Color *white;
 862     int *n_residues;
 863
 864
 865     box_c=vcalloc ( 1, sizeof (Color));
 866     get_rgb_values_format (DEFAULT_COLOR, (white=vcalloc ( 1, sizeof (Color))));
 867     get_rgb_values_format (INK_COLOR,     (ink  =vcalloc ( 1, sizeof (Color))));
 868
 869     n_residues=vcalloc ( B->nseq+1, sizeof (int));
 870     for ( a=0; a<B->nseq; a++)n_residues[a]=B->order[a][1];
 871
 872
 873     fps=vfopen_format( name);
 874     if ( buf==NULL)
 875         {
 876         buf=vcalloc (10000, sizeof (int));
 877         buf2=vcalloc (10000, sizeof (int));
 878         }
 879
 880     if ( max_len==0)
 881         {
 882         for ( a=0; a< B->nseq; a++)
 883             {if ( strlen (B->name[a])>max_len)
 884                 max_len= strlen ( (B->name[a]));
 885             }
 886         }
 887
 888     if ( vfopen_format==vfopen_ascii)
 889       {
 890         fps->line+= max_len;
 891       }
 892     else if ( max_len>max_name_len)max_len=max_name_len;
 893
 894
 895
 896     sprintf (buf, "%s, %s(%s)\n%s\nCPU TIME:%d sec.\n%s",PROGRAM,VERSION,DATE, AUTHOR,  (B->cpu+get_time())/1000, (S->generic_comment)?S->generic_comment:"");
 897     fps=print_format_string ( buf,white, ink, fps);
 898     sprintf (buf, "SCORE=%d\n*\n", S->score_aln);
 899     fps=print_format_string ( buf,white, ink, fps);
 900
 901    sprintf ( buf2, " BAD AVG GOOD");
 902    l=strlen(buf2);
 903    get_rgb_values_format ( DEFAULT_COLOR, box_c);
 904    fps=print_format_char ( buf2[0],box_c, ink, fps);
 905    for ( a=1; a<l-1; a++)
 906         {
 907         get_rgb_values_format ( MIN(9,a-1), box_c);
 908         fps=print_format_char ( buf2[a],box_c,ink,fps);
 909         }
 910    fps=print_format_char ( buf2[a], box_c, ink, fps);
 911
 912
 913    fps=print_format_string ( "\n*\n",white,ink, fps);
 914
 915    for ( a=0;S->score_seq && a< B->nseq; a++)
 916        {
 917        get_rgb_values_format (S->score_seq[a]/10, box_c);
 918        sprintf ( buf, "%-*.*s ", max_len+2,max_len, S->name[a]);
 919        fps=print_format_string ( buf,box_c, ink,fps);
 920        sprintf ( buf, ": %3d\n", S->score_seq[a]);
 921        fps=print_format_string ( buf,white, ink,fps);
 922        }
 923    //Print the Consensus score
 924    get_rgb_values_format (S->score_aln/10, box_c);
 925    sprintf ( buf, "%-*.*s ", max_len+2,max_len, S->name[S->nseq]);
 926    fps=print_format_string ( buf,box_c, ink,fps);
 927    sprintf ( buf, ": %3d\n", S->score_aln);
 928    fps=print_format_string ( buf,white, ink,fps);
 929
 930    fps=print_format_string ( "\n",white, ink,fps);
 931
 932
 933
 934    fps->line-=max_len;
 935    fps->line=fps->line-(fps->line%3);
 936
 937    for (a=0; a<B->len_aln; a+=fps->line)
 938            {
 939
 940            if ( (fps->n_line+(B->nseq+4))>fps->max_line_ppage && !((B->nseq+4)>fps->max_line_ppage))
 941                  {
 942                  fps=print_format_char ( fps->eop,white, ink, fps);
 943                  }
 944
 945            for (b=0; b<=S->nseq; b++)
 946              {
 947              if ( b==S->nseq && print_format_string !=print_ascii_string) fps=print_format_string ( "\n",white, ink, fps);
 948              sprintf (buf,"%-*.*s ",max_len+2,max_len,S->name[b]);
 949              fps=print_format_string ( buf,white, ink, fps);
 950              if(B->output_res_num)
 951                  {
 952                  sprintf (buf, " %4d ", n_residues[b]+1);
 953                  fps=print_format_string ( buf,white, ink, fps);
 954                  }
 955
 956              for (fps->in_seq=1,c=a;c<a+fps->line && c<B->len_aln;c++)
 957                 {
 958                 if (b==S->nseq)
 959                    {
 960
 961                    if (S->score_seq)
 962                      {
 963                        int s;
 964                        s=S->seq_al[b][c];
 965                        if ( s>='0' && s<='9')s-='0';
 966                        get_rgb_values_format (s,box_c);
 967                      }
 968                    else get_rgb_values_format (DEFAULT_COLOR,box_c);
 969                    n_residues[b]++;
 970                    s=analyse_aln_column ( B, c);
 971                    }
 972                 else
 973                    {
 974                    n_residues[b]+=!is_gap(B->seq_al[b][c]);
 975                    //s=toupper(B->seq_al[b][c]);
 976                    s=B->seq_al[b][c];
 977                    if (!is_gap(s) && S->seq_al[b][c]!=NO_COLOR_RESIDUE )
 978                         {
 979                         get_rgb_values_format ( S->seq_al[b][c], box_c);
 980
 981                         }
 982                    else
 983                         {
 984                         get_rgb_values_format (GAP_COLOR, box_c);
 985
 986                         }
 987
 988                    }
 989                 fps=print_format_char ( s,box_c, ink,fps);
 990                 }
 991               fps->in_seq=0;
 992
 993               if(B->output_res_num)
 994                  {
 995                  sprintf (buf, " %4d ",n_residues[b]);
 996                  fps=print_format_string ( buf,white, ink, fps);
 997                  }
 998
 999               fps=print_format_char ( '\n', white, ink, fps);
1000
1001              }
1002             fps=print_format_string ( "\n\n",white, ink, fps);
1003             }
1004     fps=print_format_string ( "\n\n\n",white, ink,fps);
1005     vfclose_format( fps);
1006     return 1;
1007
1008     }
1009
1010
1011 /*****************************************************************************/
1012 /*                       PDF         FUNCTIONS                               */
1013 /*                                                                           */
1014 /*****************************************************************************/
1015 int       output_color_pdf    ( Alignment *B,Alignment *S, char *name)
1016       {
1017       char *tmp_name;
1018       char command[LONG_STRING];
1019
1020
1021 #ifndef PS2PDF
1022       fprintf (stderr, "\nPDF FORMAT IS NOT SUPPORTED: INSTALL THE PROGRAM PS2PDF\n");
1023       myexit (EXIT_FAILURE);
1024 #else
1025       tmp_name=vtmpnam(NULL);
1026
1027       output_color_ps (B, S, tmp_name);
1028       sprintf ( command, "%s %s %s", PS2PDF, tmp_name, name);
1029       my_system  ( command);
1030       vremove  ( tmp_name);
1031 #endif
1032
1033
1034       return 1;
1035       }
1036 int       output_reliability_pdf    ( Alignment *B,Alignment *S, char *name)
1037       {
1038       char *tmp_name;
1039       char command[LONG_STRING];
1040
1041
1042
1043 #ifndef PS2PDF
1044       fprintf (stderr, "\nPDF FORMAT IS NOT SUPPORTED: INSTALL THE PROGRAM PS2PDF\n");
1045       myexit (EXIT_FAILURE);
1046 #else
1047       tmp_name=vtmpnam(NULL);
1048
1049       output_reliability_ps (B, S, tmp_name);
1050       sprintf ( command, "%s %s %s", PS2PDF, tmp_name, name);
1051       my_system  ( command);
1052       vremove  ( tmp_name);
1053 #endif
1054
1055
1056       return 1;
1057       }
1058 /*****************************************************************************/
1059 /*                       POST SCRIPT FUNCTIONS                               */
1060 /*                                                                           */
1061 /*****************************************************************************/
1062 int       output_color_ps     ( Alignment *B,Alignment *S, char *name)
1063       {
1064       output_color_format (B, S, name, vfopen_ps,print_ps_string,print_ps_char,get_rgb_values_ps, vfclose_ps);
1065       return 1;
1066       }
1067 int       output_reliability_ps     ( Alignment *B,Alignment *S, char *name)
1068       {
1069       output_reliability_format (B, S, name, vfopen_ps,print_ps_string,print_ps_char,get_rgb_values_ps, vfclose_ps);
1070       return 1;
1071       }
1072 FILE_format *print_ps_string( char *s, Color *box, Color *ink, FILE_format *fps)
1073       {
1074       int l;
1075       int a;
1076
1077       l=strlen (s);
1078
1079       for ( a=0; a< l; a++)
1080           {
1081           fps=print_ps_char (s[a], box, ink, fps);
1082           }
1083       return fps;
1084       }
1085
1086
1087 FILE_format * print_ps_char ( int c, Color *box, Color *ink, FILE_format *f)
1088        {
1089
1090        int ch;
1091        int cw;
1092
1093        ch=f->font+3;
1094        cw=f->font-2;
1095
1096        if ( c=='(' || c==')')return f;
1097        else if (c!='\n' && c!=f->eop)
1098           {
1099           fprintf(f->fp,"%d %d moveto\n", f->x,f->y);
1100           fprintf(f->fp,"0 %d rlineto\n%d 0 rlineto\n0 -%d rlineto\nclosepath\n",ch,cw,ch   );
1101           fprintf(f->fp,"%3.1f %3.1f %3.1f setrgbcolor\nfill\n%3.1f %3.1f %3.1f setrgbcolor\n", box->r,box->g,box->b, ink->r, ink->g, ink->b);
1102           fprintf(f->fp,"%d %d moveto\n(%c) show\n", f->x+1,f->y+3, c);
1103
1104           f->x+=cw;
1105           }
1106        else
1107           {
1108           f->n_line++;
1109           if ( f->n_line==f->max_line_ppage || c==f->eop)
1110              {
1111
1112              f->n_line=0;
1113              f->x=f->x0;
1114              f->y=f->y0;
1115              fprintf(f->fp,"showpage\n");
1116              f->n_pages++;
1117              fprintf ( f->fp, "%c%cPage:  %d %d\n",'%', '%', f->n_pages, f->n_pages);
1118              }
1119           else
1120              {
1121              f->x=f->x0;
1122              f->y-=ch;
1123              }
1124           }
1125        return f;
1126        }
1127 void get_rgb_values_ps ( int val, Color *C)
1128      {
1129      get_rgb_values ( val, C);
1130      }
1131
1132
1133
1134 FILE_format* vfopen_ps ( char *name)
1135       {
1136       FILE_format*fps;
1137
1138       fps=vcalloc ( 1, sizeof ( FILE_format));
1139       fps->font=9;
1140       fps->max_line_ppage=60;
1141       fps->line=get_msa_line_length (0, 0);/*N char per line*/
1142       fps->x0=15;
1143       fps->y0=750;
1144       fps->eop='^';
1145
1146       fps->fp=vfopen ( name, "w");
1147       fprintf(fps->fp,"%%!PS-Adobe-2.0\n/Courier findfont\n%d scalefont\nsetfont\n",fps->font);
1148       fprintf(fps->fp, "%%%%Pages: (atend)\n");
1149       fprintf(fps->fp,"newpath\n");
1150       ++(fps->n_pages);
1151       fprintf (fps->fp, "%%%%Page:  %d %d\n", fps->n_pages, fps->n_pages);
1152       fprintf (fps->fp,"%d %d translate\n",fps->x0, fps->y0);
1153       return fps;
1154       }
1155
1156 FILE_format* vfclose_ps ( FILE_format *fps)
1157       {
1158
1159       fprintf(fps->fp,"showpage\n");
1160       fprintf ( fps->fp, "%%%%Pages:  %d\n", fps->n_pages);
1161       fprintf(fps->fp,"%%%%EOF");
1162       fprintf(fps->fp,"%%%%\n");
1163       vfclose ( fps->fp);
1164       vfree (fps);
1165       return NULL;
1166       }
1167 /*****************************************************************************/
1168 /*                       HTML FUNCTIONS                               */
1169 /*                                                                           */
1170 /*****************************************************************************/
1171
1172 /*****************************************************************************/
1173 //JM_ADD
1174 /*****************************************************************************/
1175 void output_hit_matrix(char *fileName, float **ffpHitScoreMatrix, int nl)
1176 {
1177         int i, j;
1178         FILE *fp;
1179
1180         fp=vfopen(fileName, "w");
1181         for(i = 0; i < nl; i++)
1182         {
1183                 for(j = 0; j < i; j++)
1184                         fprintf(fp, "%6.2f ", ffpHitScoreMatrix[j][i-j]);
1185                 for(j = i; j < nl; j++)
1186                         fprintf(fp, "%6.2f ", ffpHitScoreMatrix[i][j-i]);
1187                 fprintf(fp, "\n");
1188         }
1189         vfclose(fp);
1190 }
1191 int output_hit_color_format (Alignment *B, float **ffPScoreTable, int nl, char *name, \
1192 FILE_format *(*vfopen_format)          ( char *),\
1193 FILE_format *(*print_format_string)    ( char * ,Color *, Color *, FILE_format*),\
1194 FILE_format *(*print_format_char)      ( int    ,Color *, Color *, FILE_format*),\
1195 void         (*get_rgb_values_format)  ( int    ,Color *),\
1196 FILE_format* (*vfclose_format)         ( FILE_format *));
1197 int output_hit_color_html (Alignment *B, float **ffPScoreTable, int nl, char *name)
1198 {
1199    output_hit_color_format (B, ffPScoreTable, nl, name, vfopen_html,print_html_string,print_html_char,get_rgb_values_html, vfclose_html);
1200    return 1;
1201 }
1202
1203 int output_hit_color_format (Alignment *B, float **ffPScoreTable, int nl, char *name, \
1204 FILE_format *(*vfopen_format)          ( char *),\
1205 FILE_format *(*print_format_string)    ( char * ,Color *, Color *, FILE_format*),\
1206 FILE_format *(*print_format_char)      ( int    ,Color *, Color *, FILE_format*),\
1207 void         (*get_rgb_values_format)  ( int    ,Color *),\
1208 FILE_format* (*vfclose_format)         ( FILE_format *))
1209 {
1210         int a, b;
1211         int max_name_len=15;
1212         int max_len=0;
1213
1214         static char *buf;
1215         static FILE_format *fps;
1216         Color *ink;
1217         Color *box_c;
1218         Color *white;
1219
1220         box_c=vcalloc ( 1, sizeof (Color));
1221         get_rgb_values_format (DEFAULT_COLOR, (white=vcalloc ( 1, sizeof (Color))));
1222         get_rgb_values_format (INK_COLOR,     (ink  =vcalloc ( 1, sizeof (Color))));
1223
1224         if ( max_len==0)
1225         {
1226                 for ( a=0; a< B->nseq; a++)
1227                 {
1228                         if ( strlen (B->name[a])>max_len)
1229                                 max_len= strlen ( (B->name[a]));
1230                 }
1231         }
1232         if ( max_len>max_name_len)max_len=max_name_len;
1233
1234         if ( buf==NULL)
1235                 buf=vcalloc (10000, sizeof (int));
1236         int iEmptyChr = 32; //SPACE ASCIICODE
1237         int iColorValue;
1238         fps=vfopen_format(name);
1239         for (a=0; a < nl; a++)
1240         {
1241                 sprintf (buf,"%*d ", max_len+2, a);
1242                 fps=print_format_string ( buf,white, ink, fps);
1243                 for(b = 0; b < a; b++)
1244                 {
1245                       iColorValue = (int)((ffPScoreTable[b][a-b]*9)/100);
1246                       get_rgb_values_format (iColorValue, box_c);
1247                       fps=print_format_char (iEmptyChr,box_c, ink,fps);
1248                 }
1249                 for(b = a; b < nl; b++)
1250                 {
1251                       iColorValue = (int)((ffPScoreTable[a][b-a]*9)/100);
1252                       get_rgb_values_format (iColorValue, box_c);
1253                       fps=print_format_char (iEmptyChr,box_c, ink,fps);
1254                 }
1255               fps=print_format_char ('\n', white, ink, fps);
1256         }
1257         vfclose_format(fps);
1258         vfree(buf);
1259         vfree(box_c);
1260         return 1;
1261 }
1262
1263 /*****************************************************************************/
1264
1265 int       output_color_html     ( Alignment *B,Alignment *S, char *name)
1266       {
1267       output_color_format (B, S, name, vfopen_html,print_html_string,print_html_char,get_rgb_values_html, vfclose_html);
1268       return 1;
1269       }
1270 int       output_reliability_html     ( Alignment *B,Alignment *S, char *name)
1271       {
1272       output_reliability_format (B, S, name, vfopen_html,print_html_string,print_html_char,get_rgb_values_html, vfclose_html);
1273       return 1;
1274       }
1275 FILE_format *print_html_string( char *s, Color *box, Color *ink, FILE_format *fhtml)
1276       {
1277       int l;
1278       int a;
1279
1280       l=strlen (s);
1281
1282       for ( a=0; a< l; a++)
1283           {
1284           fhtml=print_html_char (s[a], box, ink, fhtml);
1285           }
1286       fhtml=print_html_char (CLOSE_HTML_SPAN,NULL,NULL,fhtml);
1287       return fhtml;
1288       }
1289
1290
1291 FILE_format * print_html_char ( int c, Color *box, Color *ink, FILE_format *f)
1292        {
1293        char html_color[100];
1294        int in_span, new_color;
1295        char string[1000];
1296
1297
1298         if (c==CLOSE_HTML_SPAN)
1299          {
1300            if (f->in_html_span)fprintf ( f->fp, "</span>");
1301            f->in_html_span=0;
1302            return f;
1303          }
1304
1305
1306        in_span=f->in_html_span;
1307        new_color=1-(strm (box->html_color_class, f->previous_html_color));
1308
1309
1310
1311        sprintf (f->previous_html_color, "%s", box->html_color_class);
1312        sprintf ( html_color, "class=%s", box->html_color_class);
1313
1314
1315        if ( c!=' ')sprintf ( string, "%c", c);
1316        else sprintf ( string, "&nbsp;");
1317
1318        if ( !in_span &&                  c!='\n' && c!=f->eop)
1319           {
1320           fprintf ( f->fp, "<span %s>%s",html_color,string );
1321           f->in_html_span=1;
1322           }
1323        else if (in_span && !new_color && c!='\n' && c!=f->eop)
1324           {
1325
1326           fprintf ( f->fp, "%s",string);
1327           }
1328        else if (in_span &&  new_color && c!='\n' && c!=f->eop)
1329           {
1330           fprintf ( f->fp, "</span><span %s>%s",html_color,string);
1331           }
1332        else if ( c=='\n')
1333           {
1334           if ( f->in_html_span)fprintf ( f->fp, "</span>");
1335           fprintf ( f->fp, "<br>");
1336           sprintf ( f->previous_html_color, "no_color_set");
1337           f->in_html_span=0;
1338           f->n_line++;
1339           }
1340
1341
1342
1343
1344
1345        return f;
1346        }
1347
1348 void get_rgb_values_html ( int val, Color *C)
1349      {
1350      get_rgb_values ( val, C);
1351      }
1352
1353 FILE_format* vfopen_html ( char *name)
1354       {
1355       FILE_format*fhtml;
1356       Color *color;
1357       int a;
1358
1359       color=vcalloc ( 1, sizeof (Color));
1360
1361       fhtml=vcalloc ( 1, sizeof ( FILE_format));
1362       fhtml->font=11;
1363       fhtml->max_line_ppage=100000;
1364       fhtml->line=get_msa_line_length (0, 0);/*N char per line*/
1365       fhtml->x0=15;
1366       fhtml->y0=800;
1367       fhtml->eop='^';
1368       sprintf ( fhtml->previous_html_color, "no_value_set");
1369       fhtml->fp=vfopen ( name, "w");
1370
1371       fprintf(fhtml->fp,"<html>\n<style>\n");
1372
1373       fprintf(fhtml->fp,"SPAN { font-family: courier new, courier-new, courier, monospace; font-weight: bold; font-size: %dpt;}\n", fhtml->font);
1374       fprintf(fhtml->fp,"SPAN { line-height:100%%}\n");
1375       fprintf(fhtml->fp,"SPAN { white-space: pre}\n");
1376
1377       for ( a=0; a< 10; a++)
1378           {
1379           get_rgb_values_html ( a, color);
1380           if ( !strm (color->html_color, ""))fprintf (fhtml->fp, "SPAN.%s {background: %s}\n", color->html_color_class, color->html_color );
1381           else fprintf (fhtml->fp, "SPAN.%s {}\n", color->html_color_class );
1382           }
1383       get_rgb_values_html (DEFAULT_COLOR, color);
1384       if ( !strm (color->html_color, ""))fprintf (fhtml->fp, "SPAN.%s {background: %s}\n", color->html_color_class, color->html_color );
1385       else fprintf (fhtml->fp, "SPAN.%s {}\n", color->html_color_class );
1386
1387       get_rgb_values_html (GAP_COLOR, color);
1388       if ( !strm (color->html_color, ""))fprintf (fhtml->fp, "SPAN.%s {background: %s}\n", color->html_color_class, color->html_color );
1389       else fprintf (fhtml->fp, "SPAN.%s {}\n", color->html_color_class );
1390
1391       get_rgb_values_html (INK_COLOR, color);
1392       if ( !strm (color->html_color, ""))fprintf (fhtml->fp, "SPAN.%s {background: %s}\n", color->html_color_class, color->html_color );
1393       else fprintf (fhtml->fp, "SPAN.%s {}\n", color->html_color_class );
1394
1395
1396
1397       fprintf(fhtml->fp,"</style>");
1398       fprintf(fhtml->fp,"<body>");
1399
1400       return fhtml;
1401       }
1402 FILE_format* vfclose_html ( FILE_format *fhtml)
1403       {
1404       if ( fhtml->in_html_span)fprintf(fhtml->fp,"</span>");
1405       fprintf(fhtml->fp,"</body></html>\n");
1406       vfclose ( fhtml->fp);
1407       vfree (fhtml);
1408       return NULL;
1409       }
1410 /*****************************************************************************/
1411 /*                       ascii FUNCTIONS                               */
1412 /*                                                                           */
1413 /*****************************************************************************/
1414 int       output_color_ascii     ( Alignment *B,Alignment *S, char *name)
1415       {
1416         output_color_format (B, S, name, vfopen_ascii,print_ascii_string,print_ascii_char,get_rgb_values_ascii, vfclose_ascii);
1417         return 1;
1418       }
1419 int       output_reliability_ascii     ( Alignment *B,Alignment *S, char *name)
1420       {
1421       output_reliability_format (B, S, name, vfopen_ascii,print_ascii_string,print_ascii_char,get_rgb_values_ascii, vfclose_ascii);
1422       return 1;
1423       }
1424
1425 FILE_format *print_ascii_string( char *s, Color *box, Color *ink, FILE_format *fascii)
1426       {
1427       int l;
1428       int a;
1429
1430       l=strlen (s);
1431
1432       for ( a=0; a< l; a++)
1433           {
1434           fascii=print_ascii_char (s[a], box, ink, fascii);
1435           }
1436       return fascii;
1437       }
1438
1439
1440 FILE_format * print_ascii_char ( int c, Color *box, Color *ink, FILE_format *f)
1441        {
1442        if (box->ascii_value>=0 && f->in_seq)fprintf ( f->fp, "%c", box->ascii_value);
1443        else fprintf ( f->fp, "%c",c);
1444        return f;
1445        }
1446
1447
1448 void get_rgb_values_ascii ( int val, Color *C)
1449      {
1450
1451      if ( val==NO_COLOR_RESIDUE)C->ascii_value='-';
1452      else if ( val==NO_COLOR_GAP)C->ascii_value='*';
1453      else if ( val>9)C->ascii_value='#';
1454      else if ( val>=0 && val<=9) C->ascii_value=val+'0';
1455      else   C->ascii_value=val;
1456      }
1457
1458 FILE_format* vfopen_ascii ( char *name)
1459       {
1460       FILE_format*fascii;
1461       fascii=vcalloc ( 1, sizeof ( FILE_format));
1462       fascii->font=11;
1463       fascii->max_line_ppage=100000;
1464       fascii->line=get_msa_line_length (0,0);/*N char per line*/
1465       fascii->x0=15;
1466       fascii->y0=800;
1467       fascii->eop='^';
1468       fascii->fp=vfopen ( name, "w");
1469
1470
1471       return fascii;
1472       }
1473 FILE_format* vfclose_ascii ( FILE_format *fascii)
1474       {
1475        vfclose ( fascii->fp);
1476       vfree (fascii);
1477       return NULL;
1478       }
1479
1480
1481 /*****************************************************************************/
1482 /*                       seq_score output                                    */
1483 /*                                                                           */
1484 /*****************************************************************************/
1485
1486 int       output_seq_reliability_ascii     ( Alignment *B,Alignment *S, char *name)
1487 {
1488   FILE *fp;
1489   int a;
1490   int max_len=0;
1491   for ( a=0; a< B->nseq; a++)
1492     {if ( strlen (B->name[a])>max_len)
1493       max_len= strlen ( (B->name[a]));
1494     }
1495
1496   fp=vfopen ( name, "w");
1497   fprintf ( fp, "ALN_SCORE %d\n", S->score_aln);
1498   for ( a=0; a< S->nseq; a++)fprintf (fp, "SEQ_SCORE %*.*s %3d\n",  max_len+2,max_len,S->name[a],S->score_seq[a]);
1499   vfclose (fp);
1500
1501   return 1;
1502 }
1503
1504 /******************************COPYRIGHT NOTICE*******************************/
1505 /*© Centro de Regulacio Genomica */
1506 /*and */
1507 /*Cedric Notredame */
1508 /*Fri Feb 18 08:27:45 CET 2011 - Revision 596. */
1509 /*All rights reserved.*/
1510 /*This file is part of T-COFFEE.*/
1511 /**/
1512 /*    T-COFFEE is free software; you can redistribute it and/or modify*/
1513 /*    it under the terms of the GNU General Public License as published by*/
1514 /*    the Free Software Foundation; either version 2 of the License, or*/
1515 /*    (at your option) any later version.*/
1516 /**/
1517 /*    T-COFFEE is distributed in the hope that it will be useful,*/
1518 /*    but WITHOUT ANY WARRANTY; without even the implied warranty of*/
1519 /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the*/
1520 /*    GNU General Public License for more details.*/
1521 /**/
1522 /*    You should have received a copy of the GNU General Public License*/
1523 /*    along with Foobar; if not, write to the Free Software*/
1524 /*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/
1525 /*...............................................                                                                                      |*/
1526 /*  If you need some more information*/
1527 /*  cedric.notredame@europe.com*/
1528 /*...............................................                                                                                                                                     |*/
1529 /**/
1530 /**/
1531 /*      */
1532 /******************************COPYRIGHT NOTICE*******************************/