static void convertToPsl(struct mafComp *qc, struct mafComp *tc, FILE *pslFh) /* convert two components to a psl */ { struct psl* psl; int qStart = qc->start; int qEnd = qc->start+qc->size; int tStart = tc->start; int tEnd = tc->start+tc->size; char strand[3]; strand[0] = qc->strand; strand[1] = tc->strand; strand[2] = '\0'; if (qc->strand == '-') reverseIntRange(&qStart, &qEnd, qc->srcSize); if (tc->strand == '-') reverseIntRange(&tStart, &tEnd, tc->srcSize); psl = pslFromAlign(skipDot(qc->src), qc->srcSize, qStart, qEnd, qc->text, skipDot(tc->src), tc->srcSize, tStart, tEnd, tc->text, strand, 0); if (psl != NULL) { /* drop target strand */ if (psl->strand[1] == '-') pslRc(psl); psl->strand[1] = '\0'; pslTabOut(psl, pslFh); } }
static void adjustOrientation(unsigned opts, struct psl *inPsl, char *inPslOrigStrand, struct psl* mappedPsl) /* adjust strand, possibly reverse complementing, based on * pslTransMapKeepTrans option and input psls. */ { if (!(opts&pslTransMapKeepTrans) || ((inPslOrigStrand[1] == '\0') && (mappedPsl->strand[1] == '\0'))) { /* make untranslated */ if (pslTStrand(mappedPsl) == '-') pslRc(mappedPsl); mappedPsl->strand[1] = '\0'; /* implied target strand */ } }
int pslShowAlignment(struct psl *psl, boolean isProt, char *qName, bioSeq *qSeq, int qStart, int qEnd, char *tName, bioSeq *tSeq, int tStart, int tEnd, FILE *f) /* Show protein/DNA alignment or translated DNA alignment in HTML format. */ { /* At this step we just do a little shuffling of the strands for * untranslated DNA alignments. */ char origStrand[2]; boolean needsSwap = (psl->strand[0] == '-' && psl->strand[1] == 0); if (needsSwap) { memcpy(origStrand, psl->strand, 2); pslRc(psl); } pslShowAlignmentStranded(psl, isProt, qName, qSeq, qStart, qEnd, tName, tSeq, tStart, tEnd, f); if (needsSwap) { pslRc(psl); memcpy(psl->strand, origStrand, 2); } return psl->blockCount; }
int pslGenoShowAlignment(struct psl *psl, boolean isProt, char *qName, bioSeq *qSeq, int qStart, int qEnd, char *tName, bioSeq *tSeq, int tStart, int tEnd, int exnStarts[], int exnEnds[], int exnCnt, FILE *f) /* Show aligned exons between a pre-located gene (a stamper gene)and its homologues (stamp elements) * in the genome. The aligned exon sequences are shown in blue as regular blat alignment. * The unaligned exon sequence are shown in red. Intron sequences are shown in black */ { /* At this step we just do a little shuffling of the strands for * untranslated DNA alignments. */ char origStrand[2]; boolean needsSwap = (psl->strand[0] == '-' && psl->strand[1] == 0); if (needsSwap) { memcpy(origStrand, psl->strand, 2); pslRc(psl); } pslShowAlignmentStranded2(psl, isProt, qName, qSeq, qStart, qEnd, tName, tSeq, tStart, tEnd,exnStarts, exnEnds, exnCnt, f); if (needsSwap) { pslRc(psl); memcpy(psl->strand, origStrand, 2); } return psl->blockCount; }
static struct hash* loadPslByQname(char* inPslFile) /* load PSLs in to hash by qName. Make sure target strand is positive * to make process easier later. */ { struct hash* pslsByQName = hashNew(0); struct psl *psls = pslLoadAll(inPslFile); struct psl *psl; while ((psl = slPopHead(&psls)) != NULL) { if (pslTStrand(psl) != '+') pslRc(psl); struct hashEl *hel = hashStore(pslsByQName, psl->qName); struct psl** queryPsls = (struct psl**)&hel->val; slAddHead(queryPsls, psl); } return pslsByQName; }
void pslRcFile(char *inPslFile, char *outPslFile) /* reverse target and query in a psl file */ { struct lineFile *inLf = pslFileOpen(inPslFile); FILE *outFh = mustOpen(outPslFile, "w"); struct psl *psl; while ((psl = pslNext(inLf)) != NULL) { pslRc(psl); pslTabOut(psl, outFh); pslFree(&psl); } carefulClose(&outFh); lineFileClose(&inLf); }
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; }