int main(int argc, char *argv[]) {
/*
* For each cigar in file, update the coordinates and write to the second file.
*/
struct option opts[] = { {"onlyContig1", no_argument, NULL, '1'},
{"onlyContig2", no_argument, NULL, '2'},
{0, 0, 0, 0} };
int convertContig1 = TRUE, convertContig2 = TRUE, flag;
while((flag = getopt_long(argc, argv, "", opts, NULL)) != -1) {
switch(flag) {
case '1':
convertContig2 = FALSE;
break;
case '2':
convertContig1 = FALSE;
break;
}
}
if(!(convertContig1 || convertContig2)) {
fprintf(stderr, "--onlyContig1 and --onlyContig2 options are "
"mutually exclusive\n");
return 1;
}
assert(argc == optind + 3);
FILE *fileHandleIn = fopen(argv[optind], "r");
FILE *fileHandleOut = fopen(argv[optind + 1], "w");
int64_t roundsOfConversion;
int64_t i = sscanf(argv[optind + 2], "%" PRIi64 "", &roundsOfConversion);
(void)i;
assert(i == 1);
assert(roundsOfConversion >= 1);
struct PairwiseAlignment *pairwiseAlignment;
while ((pairwiseAlignment = cigarRead(fileHandleIn)) != NULL) {
//Correct coordinates
for(int64_t j=0; j<roundsOfConversion; j++) {
convertCoordinatesOfPairwiseAlignment(pairwiseAlignment,
convertContig1,
convertContig2);
}
cigarWrite(fileHandleOut, pairwiseAlignment, 0);
destructPairwiseAlignment(pairwiseAlignment);
}
fclose(fileHandleIn);
fclose(fileHandleOut);
return 0;
}
int main(int argc, char *argv[]) {
// Parse arguments
if (argc != 3) {
usage(argv);
return 1;
}
// You would load a custom HMM here if you wanted using
// hmm_getStateMachine (see the realign code)
StateMachine *stateMachine = stateMachine5_construct(fiveState);
PairwiseAlignmentParameters *parameters = pairwiseAlignmentBandingParameters_construct();
stHash *targetSequences = readFastaFile(argv[1]);
stHash *querySequences = readFastaFile(argv[2]);
// For each query sequence, align it against all target sequences.
stHashIterator *queryIt = stHash_getIterator(querySequences);
char *queryHeader;
while ((queryHeader = stHash_getNext(queryIt)) != NULL) {
char *querySeq = stHash_search(querySequences, queryHeader);
stHashIterator *targetIt = stHash_getIterator(targetSequences);
char *targetHeader;
while ((targetHeader = stHash_getNext(targetIt)) != NULL) {
char *targetSeq = stHash_search(targetSequences, targetHeader);
// Here we should try both the target sequence and its
// reverse-complemented version
// Aligns the sequences.
// If you have alignment constraints (anchors) you should
// replace this with getAlignedPairsUsingAnchors.
stList *alignedPairs = getAlignedPairs(stateMachine, targetSeq,
querySeq, parameters,
true, true);
// Takes into account the probability of aligning to a
// gap, by transforming the posterior probability into the
// AMAP objective function (see Schwartz & Pachter, 2007).
alignedPairs = reweightAlignedPairs2(alignedPairs, strlen(targetSeq),
strlen(querySeq),
parameters->gapGamma);
// I think this calculates the optimal ordered set of
// alignments from the unordered set of aligned pairs, not
// completely sure.
alignedPairs = filterPairwiseAlignmentToMakePairsOrdered(alignedPairs,
targetSeq,
querySeq,
// This parameter says that the minimum posterior probability we will accept has to be at least 0.9.
0.9);
// After this the "aligned pairs" data structure changes,
// which is a little sketchy. It's just so that the
// alignment can be printed properly.
stList_mapReplace(alignedPairs, convertToAnchorPair, NULL);
stList_sort(alignedPairs, (int (*)(const void *, const void *)) stIntTuple_cmpFn);
struct PairwiseAlignment *alignment = convertAlignedPairsToPairwiseAlignment(targetHeader, queryHeader,
0, strlen(targetSeq), strlen(querySeq), alignedPairs);
// Output the cigar string
cigarWrite(stdout, alignment, 0);
stList_destruct(alignedPairs);
destructPairwiseAlignment(alignment);
}
stHash_destructIterator(targetIt);
}
stHash_destructIterator(queryIt);
// Clean up
stHash_destruct(targetSequences);
stHash_destruct(querySequences);
pairwiseAlignmentBandingParameters_destruct(parameters);
stateMachine_destruct(stateMachine);
}