static void printRetroAlignments(struct psl *pslList, int startFirst, char *hgcCommand,
char *aliTable, char *itemIn)
/* Print list of mRNA alignments. */
{
if (pslList == NULL || aliTable == NULL)
return;
printAlignmentsSimple(pslList, startFirst, hgcCommand, aliTable, itemIn);
#ifdef UNUSED /* Does nothing in face in the end except trim the psls that nobody looks at. */
struct psl *psl = pslList;
for (psl = pslList; psl != NULL; psl = psl->next)
{
if ( pslTrimToTargetRange(psl, winStart, winEnd) != NULL
&&
!startsWith("xeno", aliTable)
&& !(startsWith("user", aliTable) && pslIsProtein(psl))
&& psl->tStart == startFirst
)
{
char otherString[512];
safef(otherString, sizeof(otherString), "%d&aliTable=%s",
psl->tStart, aliTable);
}
}
#endif /* DOES_NOTHING */
}
static void writePslx(FILE *pslOutFh, struct seqReader *qSeqReader, struct seqReader *tSeqReader, struct psl *psl)
/* output a pslx, cheating in not creating the whole pslx to avoid more sequence
* manipulation */
{
if (pslIsProtein(psl))
errAbort("doesn't support protein PSLs: qName: %s", psl->qName);
pslOutput(psl, pslOutFh, '\t', '\t');
outputBlocks(pslOutFh, qSeqReader, psl->qName, psl->strand[0],
psl->qStart, psl->qEnd, psl->blockCount, psl->qStarts, psl->blockSizes);
fputc('\t', pslOutFh);
outputBlocks(pslOutFh, tSeqReader, psl->tName, psl->strand[1],
psl->tStart, psl->tEnd, psl->blockCount, psl->tStarts, psl->blockSizes);
fputc('\n', pslOutFh);
}
static void addPslBlocks(struct chromAnn* ca, unsigned opts, struct psl* psl)
/* add blocks from a psl */
{
boolean blkStrand = (opts & chromAnnUseQSide) ? pslQStrand(psl) : pslTStrand(psl);
int size = (opts & chromAnnUseQSide) ? psl->qSize : psl->tSize;
unsigned *blocks = (opts & chromAnnUseQSide) ? psl->qStarts : psl->tStarts;
boolean blkSizeMult = pslIsProtein(psl) ? 3 : 1;
int iBlk;
for (iBlk = 0; iBlk < psl->blockCount; iBlk++)
{
int start = blocks[iBlk];
int end = start + (blkSizeMult * psl->blockSizes[iBlk]);
if (blkStrand == '-')
reverseIntRange(&start, &end, size);
chromAnnBlkNew(ca, start, end);
}
}
void liftPsl(char *destFile, struct hash *liftHash, int sourceCount, char *sources[],
boolean querySide, boolean isExtended)
/* Lift up coordinates in .psl file. */
{
FILE *dest = mustOpen(destFile, "w");
char *source;
int i,j;
struct lineFile *lf;
struct psl *psl;
struct xAli *xa = NULL;
unsigned *starts;
unsigned *blockSizes;
struct liftSpec *spec;
int offset;
int blockCount;
char *seqName;
int dotMod = dots;
int seqSize;
int strandChar = (querySide ? 0 : 1);
if (!nohead)
pslWriteHead(dest);
for (i=0; i<sourceCount; ++i)
{
source = sources[i];
if (!fileExists(source))
{
warn("%s doesn't exist!", source);
continue;
}
verbose(1, "Lifting %s\n", source);
lf = pslFileOpenWithMeta(source, dest);
for (;;)
{
if (isExtended)
{
xa = xAliNext(lf);
psl = (struct psl *)xa;
}
else
psl = pslNext(lf);
if (psl == NULL)
break;
boolean isProt = pslIsProtein(psl);
doDots(&dotMod);
if (querySide)
seqName = psl->qName;
else
seqName = psl->tName;
spec = findLift(liftHash, seqName, lf);
if (spec == NULL)
{
if (how != carryMissing)
{
freePslOrXa(psl, isExtended);
continue;
}
}
else
{
offset = spec->offset;
blockSizes = psl->blockSizes;
if (querySide)
{
if (!isPtoG)
{
cantHandleSpecRevStrand(spec);
psl->qStart += offset;
psl->qEnd += offset;
}
else
{
psl->match *= 3;
psl->misMatch *= 3;
if (spec->strand == '-')
{
int tmp = psl->qEnd;
psl->qEnd = psl->qStart;
psl->qStart = tmp;
psl->qStart *= -3;
psl->qEnd *= -3;
psl->qStart += offset;
psl->qEnd += offset;
}
else if (spec->strand == '+')
{
psl->qStart *= 3;
psl->qStart += offset;
psl->qEnd *= 3;
psl->qEnd += offset;
}
}
starts = psl->qStarts;
seqSize = psl->qSize;
}
else
{
if (spec->strand == '-')
reverseIntRange(&psl->tStart, &psl->tEnd, psl->tSize);
psl->tStart += offset;
psl->tEnd += offset;
starts = psl->tStarts;
seqSize = psl->tSize;
}
blockCount = psl->blockCount;
if (isPtoG && (spec->strand == '-'))
{
psl->strand[strandChar] = spec->strand;
for (j=0; j<blockCount; ++j)
{
starts[j] *= -3;
starts[j] += offset;
starts[j] = spec->newSize - starts[j];
}
}
else if (isPtoG && (spec->strand == '+'))
{
psl->strand[strandChar] = spec->strand;
for (j=0; j<blockCount; ++j)
{
starts[j] *= 3;
starts[j] += offset;
}
}
else /* mRNA case. */
{
if (spec->strand == '+')
{
if (psl->strand[strandChar] == '-')
{
for (j=0; j<blockCount; ++j)
{
int tr = seqSize - starts[j];
tr += offset;
starts[j] = spec->newSize - tr;
}
}
else
{
for (j=0; j<blockCount; ++j)
starts[j] += offset;
}
}
else
{
if (isProt)
{
/* if it's protein, we can't reverse the query */
if (psl->strand[strandChar] == '-')
{
for (j=0; j<blockCount; ++j)
starts[j] += offset;
}
else
{
for (j=0; j<blockCount; ++j)
{
int tr = seqSize - starts[j];
tr += offset;
starts[j] = spec->newSize - tr;
}
}
psl->strand[strandChar] =
flipStrand(psl->strand[strandChar]);
}
else
{
if (psl->strand[strandChar] == '-')
errAbort("Can't handle all these minus strands! line %d",lf->lineIx);
else
{
for (j=0; j<blockCount; ++j)
{
psl->tStarts[j] = psl->tSize -
(psl->tStarts[j] + blockSizes[j]) + offset;
psl->qStarts[j] = psl->qSize -
(psl->qStarts[j] + blockSizes[j]); /* no offset. */
}
psl->strand[1-strandChar] =
flipStrand(psl->strand[1-strandChar]);
reverseUnsigned(blockSizes, blockCount);
reverseUnsigned(psl->qStarts, blockCount);
reverseUnsigned(psl->tStarts, blockCount);
}
}
}
}
if (isPtoG)
for (j=0; j<blockCount; ++j)
blockSizes[j] *= 3;
if (querySide)
{
psl->qSize = spec->newSize;
psl->qName = spec->newName;
}
else
{
psl->tSize = spec->newSize;
psl->tName = spec->newName;
}
}
if (isExtended)
{
xAliTabOut(xa, dest);
}
else
{
pslTabOut(psl, dest);
}
if (querySide)
psl->qName = seqName;
else
psl->tName = seqName;
freePslOrXa(psl, isExtended);
}
lineFileClose(&lf);
if (dots)
verbose(1, "\n");
}
if (ferror(dest))
errAbort("error writing %s", destFile);
fclose(dest);
}
struct psl* pslTransMap(unsigned opts, struct psl *inPsl, struct psl *mapPsl)
/* map a psl via a mapping psl, a single psl is returned, or NULL if it
* couldn't be mapped. */
{
int mappedPslMax = 8; /* allocated space in output psl */
int iMapBlk = 0;
char inPslOrigStrand[3];
boolean rcInPsl = (pslTStrand(inPsl) != pslQStrand(mapPsl));
boolean cnv1 = (pslIsProtein(inPsl) && !pslIsProtein(mapPsl));
boolean cnv2 = (pslIsProtein(mapPsl) && !pslIsProtein(inPsl));
int iBlock;
struct psl* mappedPsl;
/* sanity check size, but allow names to vary to allow ids to have
* unique-ifying suffixes. */
if (inPsl->tSize != mapPsl->qSize)
errAbort("Error: inPsl %s tSize (%d) != mapPsl %s qSize (%d)",
inPsl->tName, inPsl->tSize, mapPsl->qName, mapPsl->qSize);
/* convert protein PSLs */
if (cnv1)
pslProtToNA(inPsl);
if (cnv2)
pslProtToNA(mapPsl);
/* need to ensure common sequence is in same orientation, save strand for later */
safef(inPslOrigStrand, sizeof(inPslOrigStrand), "%s", inPsl->strand);
if (rcInPsl)
pslRc(inPsl);
mappedPsl = createMappedPsl(inPsl, mapPsl, mappedPslMax);
/* Fill in ungapped blocks. */
for (iBlock = 0; iBlock < inPsl->blockCount; iBlock++)
{
struct block align1Blk = blockFromPslBlock(inPsl, iBlock);
while (mapBlock(inPsl, mapPsl, &iMapBlk, &align1Blk, mappedPsl,
&mappedPslMax))
continue;
}
/* finish up psl, or free if no blocks were added */
assert(mappedPsl->blockCount <= mappedPslMax);
if (mappedPsl->blockCount == 0)
pslFree(&mappedPsl); /* nothing made it */
else
{
setPslBounds(mappedPsl);
adjustOrientation(opts, inPsl, inPslOrigStrand, mappedPsl);
}
/* restore input */
if (rcInPsl)
{
pslRc(inPsl);
strcpy(inPsl->strand, inPslOrigStrand);
}
if (cnv1)
pslNAToProt(inPsl);
if (cnv2)
pslNAToProt(mapPsl);
return mappedPsl;
}
