a44421a79fb36cc2036fe116b97ea3bc9590cd0c
braney
  Fri Dec 2 09:34:39 2011 -0800
removed rcsid (#295)
diff --git src/hg/pslUnpile/pslUnpile.c src/hg/pslUnpile/pslUnpile.c
index e6e065a..7c1e3c1 100644
--- src/hg/pslUnpile/pslUnpile.c
+++ src/hg/pslUnpile/pslUnpile.c
@@ -1,120 +1,119 @@
 /* pslUnpile - Removes huge piles of alignments from sorted psl files 
  * (due to unmasked repeats presumably).. */
 #include "common.h"
 #include "cheapcgi.h"
 #include "psl.h"
 
-static char const rcsid[] = "$Id: pslUnpile.c,v 1.7 2003/05/06 07:22:34 kate Exp $";
 
 /* Constants that can be over-ridden by command line. */
 boolean doTarget = TRUE;
 boolean noHead = FALSE;
 int maxPile = 100;
 int minPile = 1;
 
 void usage()
 /* Explain usage and exit. */
 {
 errAbort(
   "pslUnpile - Removes huge piles of alignments from sorted \n"
   "psl files (due to unmasked repeats presumably).\n"
   "usage:\n"
   "   pslUnpile in.psl out.psl\n"
   "options:\n"
   "   -query - removes piles on query side\n"
   "   -target - removes piles on target side (default)\n"
   "   -nohead - suppress psl header in output.\n"
   "   -maxPile - maximum number of hits allowed in a pile before filtering\n"
   "              (default 100)\n"
   "   -minPile - min number of hits allowed in a pile before filtering \n"
   "              (default 1)\n"
   "in.psl should be sorted by query or target as appropriate");
 }
 
 boolean pslOverlap(struct psl *a, struct psl *b)
 /* Returns TRUE if two psl's overlap. */
 {
 if (doTarget)
     {
     if (!sameString(a->tName, b->tName))
         return FALSE;
     return rangeIntersection(a->tStart, a->tEnd, b->tStart, b->tEnd) > 0;
     }
 else
     {
     if (!sameString(a->qName, b->qName))
         return FALSE;
     return rangeIntersection(a->qStart, a->qEnd, b->qStart, b->qEnd) > 0;
     }
 }
 
 boolean checkPile(struct psl *list)
 /* If minPile is at its default, check maxPile; otherwise check minPile. */
 {
     if (minPile == 1)
 	return (slCount(list) <= maxPile);
     else
         return (slCount(list) >= minPile);
 }
 
 void pslUnpile(char *inName, char *outName)
 /* pslUnpile - Removes huge piles of alignments from sorted 
  * psl files (due to unmasked repeats presumably).. */
 {
 FILE *f = mustOpen(outName, "w");
 enum gfType qType, tType;
 struct lineFile *lf;
 struct psl *list = NULL, *psl, *el;
 
 pslxFileOpen(inName, &qType, &tType, &lf);
 if (!noHead)
     pslxWriteHead(f, qType, tType);
 for (;;)
     {
     psl = pslNext(lf);
     if (list != NULL && (psl == NULL || !pslOverlap(psl, list)))
         {
 	if (list != NULL)
 	    {
 	    slReverse(&list);
 	    if (checkPile(list))
 	        {
 		for (el = list; el != NULL; el = el->next)
 		    {
 		    pslTabOut(el, f);
 		    }
 		}
 	    else
 	        {
 		for (el = list; el != NULL; el = el->next)
 		    {
 		    if (psl == NULL)
 			pslTabOut(el, f);
 		    else if (psl->tEnd - psl->tStart > 4000)
 			pslTabOut(el, f);
 		    }
 		}
 	    pslFreeList(&list);
 	    }
 	}
     if (psl == NULL)
         break;
     slAddHead(&list, psl);
     }
 lineFileClose(&lf);
 carefulClose(&f);
 }
 
 int main(int argc, char *argv[])
 /* Process command line. */
 {
 cgiSpoof(&argc, argv);
 if (argc != 3)
     usage();
 doTarget = !cgiBoolean("query");
 noHead = (cgiBoolean("nohead") || cgiBoolean("noHead"));
 maxPile = cgiOptionalInt("maxPile", maxPile);
 minPile = cgiOptionalInt("minPile", minPile);
 pslUnpile(argv[1], argv[2]);
 return 0;
 }