highlight.cc

unix或linux下的DNA分析软件源码 其功能如下 1. Edit up to 256 peptide or DNA sequences simultaneously. 2. Transla

         case 2:  // match 1st or 2nd sequence 
            for(j=0; j<count; j++)  
            {  if(j!=0 && ismatch(s1[j][i], s1[0][i], im)){ match[0][i]=1; match[j][i]=1; }
               if(j!=1 && ismatch(s1[j][i], s1[1][i], im)){ match[1][i]=1; match[j][i]=1; }
            }
            break;
         case 3:  // find any match 
            for(j=0; j<count; j++)  
            for(j2=0; j2<count; j2++)  
               if(j2!=j && ismatch(s1[j][i], s1[j2][i], im)){ match[j][i]=1; match[j2][i]=1;}
            break;
         case 4:  // find best consensus
            for(j=0; j<count; j++) hit[j]=0; 
            for(j=0; j<count; j++) 
            for(j2=0; j2<count; j2++)  
               if(j2!=j && ismatch(s1[j][i], s1[j2][i], im)) hit[j]++;
            most = highest = 0;
            for(j=0; j<count; j++)  
               if(hit[j] > highest){ highest = j; most = s1[j][i]; }
            for(j=0; j<count; j++)  
               if(ismatch(s1[j][i], most, im)) { match[j][i]=1; }
            break;
      }
   }
}

//-------------------------------------------------------------------------//
// ismatch                                                                 //
//-------------------------------------------------------------------------//
int ismatch(char a, char b, int identitymode)
{
    int answer = 0;
    a = toupper(a);
    b = toupper(b);
    if(!isalpha(a) || !isalpha(b)) return 0;
    if(identitymode ==1)
    {   if(a == b) return 1;
    }else 
    {   answer = 0;
        if(a==b) answer = 1;
        switch(a)
        {   case 'D': if(b=='E') answer++; break;
            case 'E': if(b=='D') answer++; break;
            case 'F': if(b=='W' || b=='Y') answer++; break;
            case 'I': if(b=='L') answer++; break;
            case 'K': if(b=='R') answer++; break;
            case 'L': if(b=='I') answer++; break;
            case 'N': if(b=='Q') answer++; break;
            case 'Q': if(b=='N') answer++; break;
            case 'R': if(b=='K') answer++; break;
            case 'S': if(b=='T') answer++; break;
            case 'T': if(b=='S') answer++; break;
            case 'W': if(b=='F' || b=='Y') answer++; break;
            case 'Y': if(b=='W' || b=='F') answer++; break;
        }
        return answer;
    }
    return 0; 
}

//-------------------------------------------------------------------------//
// fill_sequence_strings                                                   //
//-------------------------------------------------------------------------//
void fill_sequence_strings(char *norm, char *hilight, char **s1, char **match,
     int seqno, int offset, int width)
{
    char c;
    int k;
    for(k=0;k<width;k++)
    {
       c = s1[seqno][k+offset];
       if(match[seqno][k+offset])
       {   norm[k] = ' '; 
           hilight[k] = c; 
       }else
       {   norm[k] = c; 
           hilight[k] = ' '; 
       }
    }
    norm[width] = 0;
    hilight[width] = 0;
}


//-------------------------------------------------------------------------//
// read_data                                                               //
//-------------------------------------------------------------------------//
void read_data(FILE *fp1, char **s1, char **match, int &count, char **label, 
   int &labelcount, int &longest_length)
{
  int reading_sequences = 0;
  char tempstring[10000];
  while(!feof(fp1) && count<1000)
  {   
       fgets(tempstring, 9999, fp1);
       if(feof(fp1)) break;
       if(tempstring[0] == '#' || tempstring[0]=='\n') continue;
       remove_terminal_cr(tempstring);   
       remove_terminal_spaces(tempstring); 
       if(strlen(tempstring)==0) continue;
       if(!strcmp(tempstring, "SEQUENCES")){ reading_sequences = 1; continue; }
       if(!strcmp(tempstring, "END")){ reading_sequences = 0; continue; }
       if(reading_sequences)
       {    s1[count] = new char[10000]; 
            match[count] = new char[10000]; 
            strcpy(s1[count], tempstring);
            longest_length = max(longest_length, (int)strlen(s1[count]));
            count++;
       }else
       {    label[labelcount] = new char[10000]; 
            strcpy(label[labelcount], tempstring);
            labelcount++;
       }
   }
}


//-------------------------------------------------------------------------//
// print_title                                                             //
//-------------------------------------------------------------------------//
void print_title(FILE *fp, char **label, int labelcount, int xstart,
     int &ystart, int size, char *lcolor, char *ps_color_string, char *titlefont)
{
   int k;
   char *ptr=NULL;
   for(k=0; k<labelcount; k++)
   { 
      if(labeltype(label[k], ptr) == TITLE)
      {  
         fprintf(fp, "%s %s\n", lcolor, ps_color_string);
         fprintf(fp, "/%s findfont\n", titlefont);
         fprintf(fp, "%g scalefont setfont\n",  size*1.4);
         fprintf(fp, "%d %d moveto\n", xstart, ystart+size);
         fprintf(fp, "(%s) show\n", ptr);
         ystart -=size;
      }
   }
}


//-------------------------------------------------------------------------//
// print_box                                                               //
//-------------------------------------------------------------------------//
void print_box(FILE *fp, char **label, int count, int labelcount, int startpos,
     int width, int size, int chunkspacesize, int chunk, int xseqstart, int ystart)
{
   int k,x1,y1,x2,y2;
   char *ptr=NULL;
   char thirdline[64];
   for(k=0; k<labelcount; k++)
   {  if(labeltype(label[k], ptr) == BOX)
      {  
         x1 = nextarg(ptr);
         x2 = nextarg(ptr);
         y1 = nextarg(ptr);
         y2 = nextarg(ptr);
         if(between(x1, startpos+1, startpos + width))
         {  
             if(between(x2, startpos, startpos + width))
                 strcpy(thirdline, "lineto");
             else
                 strcpy(thirdline, "moveto");
             x1 = xseqstart + (x1-startpos-1)*size - 1;
             x2 = xseqstart + (x2-startpos  )*size - 1;
             x2 = min(x2, xseqstart + width*size - 1);
             y1 = ystart - 1 - (y1-2)*size - chunk*(count*size+chunkspacesize);
             y2 = ystart - 1 - (y2-1)*size - chunk*(count*size+chunkspacesize);
             fprintf(fp, "{ 0 0 596 842 setbbox\n");
             fprintf(fp, "%d %d moveto\n", x1, y1);
             fprintf(fp, "%d %d lineto\n", x2, y1);
             fprintf(fp, "%d %d %s\n",     x2, y2, thirdline);
             fprintf(fp, "%d %d lineto\n", x1, y2);
             fprintf(fp, "%d %d lineto\n", x1, y1);
             fprintf(fp, "} ustroke\n");

         }else if(between(x2, startpos+1, startpos + width))
         {  
             if(between(x1, startpos+1, startpos + width))
                 strcpy(thirdline, "lineto");
             else
                 strcpy(thirdline, "moveto");
             x1 = xseqstart + (x1-startpos-1)*size - 1;
             x2 = xseqstart + (x2-startpos  )*size - 1;
             x1 = max(x1, xseqstart - 1);
             y1 = ystart - 1 - (y1-2)*size - chunk*(count*size+chunkspacesize);
             y2 = ystart - 1 - (y2-1)*size - chunk*(count*size+chunkspacesize);
             fprintf(fp, "{ 0 0 596 842 setbbox\n");
             fprintf(fp, "%d %d moveto\n", x1, y1);
             fprintf(fp, "%d %d lineto\n", x2, y1);
             fprintf(fp, "%d %d lineto\n", x2, y2);
             fprintf(fp, "%d %d lineto\n", x1, y2);
             fprintf(fp, "%d %d %s\n",     x1, y1, thirdline);
             fprintf(fp, "} ustroke\n");
         }

      }
   }
}


//-------------------------------------------------------------------------//
// print_label                                                             //
//-------------------------------------------------------------------------//
void print_label(FILE *fp, char **label, int count, int labelcount, int startpos,
     int width, int size, int chunkspacesize, int chunk, int xseqstart, int ystart,
     char *font)
{
   int k,x,y;
   char *ptr=NULL;
   for(k=0; k<labelcount; k++)
   {  if(labeltype(label[k], ptr) == LABEL)
      {  
         x = nextarg(ptr);
         y = nextarg(ptr);
         if(x>=startpos && x<=startpos + width)
         {  
             fprintf(fp, "/%s  findfont\n", font);
             fprintf(fp, "%d scalefont setfont\n", size);
             x = xseqstart + (x-startpos-1)*size - 1;
             y = ystart - (y-1)*size - chunk*(count*size+chunkspacesize);
             fprintf(fp, "%d %d moveto\n", x, y);
             fprintf(fp, "(%s) show\n", ptr);
         }
      }
   }
}


//-------------------------------------------------------------------------//
// print_text                                                              //
//-------------------------------------------------------------------------//
void print_text(FILE *fp, char **label, int count, int labelcount, int startpos,
     int separatorpos, int width, int size, int chunkspacesize, int chunk, 
     int xseqstart, int ystart, char *font)
{
   int k,x,y,text_xpos;
   char *ptr=NULL;
   char textstring[2*width];
   textstring[0] = 0;
   for(k=0; k<labelcount; k++)
   {  if(labeltype(label[k], ptr) == TEXT)
      {   y = nextarg(ptr);
          y = ystart - (y-1)*size - chunk*(count*size+chunkspacesize);
          do
          {   get_sequence_text(textstring, label[k]+separatorpos, startpos, width, text_xpos);
              if(strlen(textstring))
              {   fprintf(fp, "/%s %s\n", font, "findfont");
                  fprintf(fp, "%d %s\n",  size,"scalefont setfont");
                  x = xseqstart + (text_xpos - 1) * size;
                  fprintf(fp, "%d %d moveto\n", x, y);
                  fprintf(fp, "(%s) show\n", textstring);
              }
          } while(strlen(textstring));
      }
   }
}



//-------------------------------------------------------------------------//
// get_sequence_text                                                       //
// Text items are separated by 2 or more contiguous spaces.                //
// NOTE: this changes s1[seqno]                                            //
//-------------------------------------------------------------------------//
void get_sequence_text(char *result, char *label, int offset, int width, 
     int &text_xpos)
{
    int c,k;
    int in_text = 0;
    result[0] = 0;
    for(k=0; k<2*width; k++)  // go past end in case string is too long
    {   c = label[k+offset]; 
        if(!in_text && c!= ' '){ text_xpos = k; in_text = 1; }
        if(in_text)
        {   result[k-text_xpos] = c;
            result[k-text_xpos+1] = 0;
            // Cheap way of ensuring same string isn't found twice
            label[k+offset] = ' '; 
            if(k>=10000-1 || (c==' ' && label[k+offset+1]== ' ')) break;
        }else if(k>width) break;
    } 
}


//-------------------------------------------------------------------------//
// labeltype                                                               //
//-------------------------------------------------------------------------//
int labeltype(char *s, char *&ptr)
{
    char tempstring[64];    
    int pos;
    pos = (int)strchr(s, ' ');
    if(!pos) return COMMENT;
    pos -= (int)s;  // first space after identifier 
    ptr = s + pos + 1;                       // remaining string after identifier
    strncpy(tempstring, s, pos);
    tempstring[pos] = 0;
    if(!strcmp(tempstring, "TITLE")) return TITLE;
    if(!strcmp(tempstring, "BOX")) return BOX;
    if(!strcmp(tempstring, "LABEL")) return LABEL;
    if(!strcmp(tempstring, "TEXT")) return TEXT;
    return COMMENT;
}

//--------------------------------------------------------------------------//
// nextarg                                                                  //
//--------------------------------------------------------------------------//
int nextarg(char *&ptr)
{
    int pos; 
    char tempstring[64];
    char *str = strchr(ptr, ' ');
    if(str==NULL) pos = strlen(ptr);
    else          pos = (int)str - (int)ptr;
    strncpy(tempstring, ptr, pos);
    ptr += pos + 1;
    tempstring[pos] = 0;
    return(atoi(tempstring));
}


//--------------------------------------------------------------------------//
// between    - returns 1 if a is between b and c                           //
//--------------------------------------------------------------------------//
int between(int a,int b,int c)
{   if((a>=b)&&(a<=c))return(1);
    else return(0);
}

//--------------------------------------------------------------------------//
// between    - returns 1 if a is between b and c                           //
//--------------------------------------------------------------------------//
int between(double a, double b, double c)
{   if((a>=b)&&(a<=c))return(1);
    else return(0);
}