static int *
get_exonlengths (int **exonmatches, int *nexons, List_T pairs, bool bysizep) {
int *exonlengths;
Intlist_T list = NULL, matchlist = NULL;
Pair_T firstpair, pair;
int querypos, nmatches = 0;
#ifdef DEBUG
int i;
#endif
firstpair = List_head(pairs);
querypos = firstpair->querypos;
while (pairs != NULL) {
pair = List_head(pairs);
if (pair->gapp == true && big_gap_p(pair,bysizep) == true) {
list = Intlist_push(list,querypos-firstpair->querypos+1);
matchlist = Intlist_push(matchlist,nmatches);
pairs = List_next(pairs);
if (pairs != NULL) {
firstpair = List_head(pairs);
querypos = firstpair->querypos;
nmatches = 0;
}
} else {
querypos = pair->querypos;
if (pair->comp == MATCH_COMP || pair->comp == DYNPROG_MATCH_COMP) {
nmatches++;
}
pairs = List_next(pairs);
}
}
list = Intlist_push(list,querypos-firstpair->querypos+1);
list = Intlist_reverse(list);
matchlist = Intlist_push(matchlist,nmatches);
matchlist = Intlist_reverse(matchlist);
exonlengths = Intlist_to_array(&(*nexons),list);
*exonmatches = Intlist_to_array(&(*nexons),matchlist);
debug(
printf("%d exons: ",*nexons);
for (i = 0; i < *nexons; i++) {
printf("%d (%d matches),",exonlengths[i],(*exonmatches)[i]);
}
printf("\n");
);
void* Queue_peek(Queue queue)
{
assert(queue);
List_head(queue);
return List_getCurrent(queue);
}
void List_empty(List list)
{
assert(list);
List_head(list);
while(!List_isEmpty(list))
List_remove(list);
}
void
Diagpool_free (T *old) {
List_T p;
struct Diag_T *diagptr;
struct List_T *listcellptr;
if (*old) {
for (p = (*old)->diagchunks; p != NULL; p = List_next(p)) {
diagptr = (struct Diag_T *) List_head(p);
FREE(diagptr);
}
List_free(&(*old)->diagchunks);
for (p = (*old)->listcellchunks; p != NULL; p = List_next(p)) {
listcellptr = (struct List_T *) List_head(p);
FREE(listcellptr);
}
List_free(&(*old)->listcellchunks);
FREE(*old);
}
return;
}
void freePath(List path)
{
List_head(path);
while(!List_isEmpty(path))
{
Position_delete(List_getCurrent(path));
List_remove(path);
}
List_delete(path);
}
void
Pairpool_free (T *old) {
List_T p;
struct Pair_T *pairptr;
struct List_T *listcellptr;
if (*old) {
for (p = (*old)->pairchunks; p != NULL; p = List_next(p)) {
pairptr = (struct Pair_T *) List_head(p);
FREE(pairptr);
}
List_free(&(*old)->pairchunks);
for (p = (*old)->listcellchunks; p != NULL; p = List_next(p)) {
listcellptr = (struct List_T *) List_head(p);
FREE(listcellptr);
}
List_free(&(*old)->listcellchunks);
FREE(*old);
}
return;
}
void* Queue_dequeue(Queue queue)
{
void* ptr;
assert(queue);
List_head(queue);
ptr = List_getCurrent(queue);
List_remove(queue);
return ptr;
}
void
Matchpool_free (T *old) {
List_T p;
struct Match_T *matchptr;
struct List_T *listcellptr;
if (*old) {
for (p = (*old)->matchchunks; p != NULL; p = List_next(p)) {
matchptr = (struct Match_T *) List_head(p);
FREE(matchptr);
}
List_free(&(*old)->matchchunks);
for (p = (*old)->listcellchunks; p != NULL; p = List_next(p)) {
listcellptr = (struct List_T *) List_head(p);
FREE(listcellptr);
}
List_free(&(*old)->listcellchunks);
FREE(*old);
}
return;
}
void List_insertSorted(List list, void* ptr, List_compare ptrList_compare){
Node node, current;
int beforeTail = 1;
int isHead = 1;
assert(list);
node = Node_new();
if(node == NULL)
return;
node->ptr = ptr;
if(list->current == NULL)
{
list->current = node;
list->head = node;
list->tail = node;
return;
}
List_head(list);
if(list->current->ptr == ptr)
List_remove(list);
while ((*ptrList_compare)(list->current->ptr, ptr) && beforeTail) {
isHead = 0;
beforeTail = List_next(list);
if(list->current->ptr == ptr)
List_remove(list);
}
current = list->current;
list->size++;
if(beforeTail){
node->next = current;
if(isHead)
list->head = node;
else{
node->prev = current->prev;
current->prev->next = node;
}
current->prev = node;
}
else{
current->next = node;
node->prev = current;
list->tail = node;
}
}
void List_delete(List list)
{
assert(list);
List_head(list);
if(!List_isEmpty(list))
LOGWARNING("Deleting a non-empty list");
while(!List_isEmpty(list))
List_remove(list);
free(list);
}
List doPathfinding(Map map, Car cars[3])
{
Heap openSet = Heap_new(State_compare);
List closedSet = List_new();
List finalPath = List_new();
List neighbors;
Position neighbor;
State state, newState;
Vector newSpeed, acceleration;
int end = 0, i, j, useBoost, positionTaken, distance;
float cost;
LOGINFO("A* doin' da werk!");
state = State_new(Car_getPosition(cars[0]), Car_getSpeed(cars[0]), Car_getBoosts(cars[0]), map);
Heap_insert(openSet, state);
while(!Heap_isEmpty(openSet) && !end)
{
state = Heap_extractMin(openSet);
if(Map_getTile(map, State_getPosition(state)->x, State_getPosition(state)->y) == ARRIVAL)
{
end = 1;
break;
}
distance = Map_getDistance(map, State_getPosition(state)->x, State_getPosition(state)->y);
neighbors = Map_getReachablePositions(map, State_getPosition(state), State_getSpeed(state), State_getBoosts(state));
List_foreach(neighbors, neighbor, i)
{
if(Map_getDistance(map, neighbor->x, neighbor->y) > distance)
{
Position_delete(neighbor);
continue;
}
cost = State_getRealCost(state) + 1;
newSpeed = Position_findOffset(State_getPosition(state), neighbor);
acceleration = Vector_copy(newSpeed);
Vector_substract(acceleration, State_getSpeed(state));
useBoost = 0;
positionTaken = 0;
if(Vector_squaredLength(acceleration) > 2)
{
useBoost = 1;
}
for(j = 1; j < 3; j++)
{
if(Position_equal(neighbor, Car_getPosition(cars[j])))
{
positionTaken = 1;
}
}
if(!positionTaken)
{
newState = State_new(neighbor, newSpeed, State_getBoosts(state) - useBoost, map);
State_setRealCost(newState, cost);
State_setParent(newState, state);
Heap_insert(openSet, newState);
}
Vector_delete(newSpeed);
Vector_delete(acceleration);
Position_delete(neighbor);
}
List_insert(closedSet, state);
List_empty(neighbors);
List_delete(neighbors);
}
while(state != NULL)
{
List_insert(finalPath, Position_copy(State_getPosition(state)));
state = State_getParent(state);
}
List_head(closedSet);
while(!List_isEmpty(closedSet))
{
state = List_getCurrent(closedSet);
List_remove(closedSet);
State_delete(state);
}
List_delete(closedSet);
while((state = Heap_extractMin(openSet)) != NULL)
{
State_delete(state);
}
Heap_delete(openSet);
LOGINFO("A* is done mate");
return finalPath;
}
static void
write_contig_file (char *genomesubdir, char *fileroot, Table_T accsegmentpos_table,
Tableint_T chrlength_table, List_T contigtypelist) {
FILE *textfp;
char *textfile, *iitfile, *annot;
int naccessions, i;
char **accessions, *divstring;
Segmentpos_T segmentpos;
Chrom_T chrom;
Genomicpos_T chroffset, universalpos1, universalpos2;
List_T divlist = NULL, intervallist = NULL, labellist = NULL, annotlist = NULL, p;
Table_T intervaltable, labeltable, annottable;
Interval_T interval;
#if 0
void **keys;
int *values, ntypes;
#endif
if (divsort == NO_SORT) {
accessions = (char **) Table_keys_by_timeindex(accsegmentpos_table,NULL);
naccessions = Table_length(accsegmentpos_table);
} else {
/* Get accessions in order */
accessions = (char **) Table_keys(accsegmentpos_table,NULL);
naccessions = Table_length(accsegmentpos_table);
current_accsegmentpos_table = accsegmentpos_table;
qsort(accessions,naccessions,sizeof(char *),bysegmentpos_compare);
}
#if 0
/* Get types in order */
keys = Tableint_keys(contigtype_table,NULL);
values = Tableint_values(contigtype_table,0);
ntypes = Tableint_length(contigtype_table);
contigtypes = (char **) CALLOC(ntypes+1,sizeof(char *)); /* Add 1 for type 0 */
contigtypes[0] = "";
for (j = 0; j < ntypes; j++) {
contigtypes[values[j]] = keys[j];
}
FREE(values);
FREE(keys);
#endif
/* Write contig text file */
textfile = (char *) CALLOC(strlen(genomesubdir)+strlen("/")+
strlen(fileroot)+strlen(".contig")+1,sizeof(char));
sprintf(textfile,"%s/%s.contig",genomesubdir,fileroot);
/* Use binary, not text, so files are Unix-compatible */
if ((textfp = FOPEN_WRITE_BINARY(textfile)) == NULL) {
fprintf(stderr,"Can't write to file %s\n",textfile);
exit(9);
}
FREE(textfile);
for (i = 0; i < naccessions; i++) {
segmentpos = (Segmentpos_T) Table_get(accsegmentpos_table,(void *) accessions[i]);
chrom = Segmentpos_chrom(segmentpos);
chroffset = (Genomicpos_T) Tableint_get(chrlength_table,chrom);
universalpos1 = chroffset + Segmentpos_chrpos1(segmentpos);
universalpos2 = chroffset + Segmentpos_chrpos2(segmentpos);
/* Print as 1-based, inclusive [a,b] */
if (Segmentpos_revcompp(segmentpos) == true) {
fprintf(textfp,"%s\t%u..%u\t%s:%u..%u\t%u",
accessions[i],universalpos2+1U,universalpos1,
Chrom_string(chrom),Segmentpos_chrpos2(segmentpos)+1U,Segmentpos_chrpos1(segmentpos),
Segmentpos_length(segmentpos));
} else {
fprintf(textfp,"%s\t%u..%u\t%s:%u..%u\t%u",
accessions[i],universalpos1+1U,universalpos2,
Chrom_string(chrom),Segmentpos_chrpos1(segmentpos)+1U,Segmentpos_chrpos2(segmentpos),
Segmentpos_length(segmentpos));
}
#if 0
if (Segmentpos_type(segmentpos) > 0) {
fprintf(textfp,"\t%s",contigtypes[Segmentpos_type(segmentpos)]);
}
#endif
fprintf(textfp,"\n");
/* Store as 0-based, inclusive [a,b] */
labellist = List_push(labellist,(void *) accessions[i]);
if (Segmentpos_revcompp(segmentpos) == true) {
/* The negative sign in the interval is the indication that the
contig was reverse complement */
intervallist = List_push(intervallist,
(void *) Interval_new(universalpos2-1U,universalpos1,
Segmentpos_type(segmentpos)));
} else {
intervallist = List_push(intervallist,
(void *) Interval_new(universalpos1,universalpos2-1U,
Segmentpos_type(segmentpos)));
}
#if 0
/* IIT version 1 */
sprintf(seglength,"%u",Segmentpos_length(segmentpos));
annot = (char *) CALLOC(strlen(seglength)+1,sizeof(char));
strcpy(annot,seglength);
#else
/* IIT versions >= 2 */
annot = (char *) CALLOC(1,sizeof(char));
annot[0] = '\0';
#endif
annotlist = List_push(annotlist,(void *) annot);
}
fclose(textfp);
#if 0
FREE(contigtypes);
#endif
FREE(accessions);
intervallist = List_reverse(intervallist);
/* contigtypelist = List_reverse(contigtypelist); -- Done by caller */
labellist = List_reverse(labellist);
annotlist = List_reverse(annotlist);
/* Write contig IIT file */
divstring = (char *) CALLOC(1,sizeof(char));
divstring[0] = '\0';
divlist = List_push(NULL,divstring);
intervaltable = Table_new(65522,Table_string_compare,Table_string_hash);
labeltable = Table_new(65522,Table_string_compare,Table_string_hash);
annottable = Table_new(65522,Table_string_compare,Table_string_hash);
Table_put(intervaltable,(void *) divstring,intervallist);
Table_put(labeltable,(void *) divstring,labellist);
Table_put(annottable,(void *) divstring,annotlist);
iitfile = (char *) CALLOC(strlen(genomesubdir)+strlen("/")+
strlen(fileroot)+strlen(".contig.iit")+1,sizeof(char));
sprintf(iitfile,"%s/%s.contig.iit",genomesubdir,fileroot);
#if 0
debug(
for (p = contigtypelist; p != NULL; p = List_next(p)) {
printf("Type %s\n",(char *) List_head(p));
}
);
/* Modifies chrlength_table to store offsets, rather than chrlengths */
static void
write_chromosome_file (char *genomesubdir, char *fileroot, Tableint_T chrlength_table) {
FILE *textfp, *chrsubsetfp;
char *divstring, *textfile, *chrsubsetfile, *iitfile, *chr_string, emptystring[1];
int n, i;
Chrom_T *chroms;
Genomicpos_T chroffset = 0, chrlength;
List_T divlist = NULL;
List_T intervallist = NULL, chrtypelist = NULL, labellist = NULL, annotlist = NULL, p;
Table_T intervaltable, labeltable, annottable;
Interval_T interval;
emptystring[0] = '\0';
if (divsort == NO_SORT) {
chroms = (Chrom_T *) Tableint_keys_by_timeindex(chrlength_table,0U);
n = Tableint_length(chrlength_table);
} else {
/* Get chromosomes in order */
chroms = (Chrom_T *) Tableint_keys(chrlength_table,0U);
n = Tableint_length(chrlength_table);
switch (divsort) {
case ALPHA_SORT: qsort(chroms,n,sizeof(Chrom_T),Chrom_compare_alpha); break;
case NUMERIC_ALPHA_SORT: qsort(chroms,n,sizeof(Chrom_T),Chrom_compare_numeric_alpha); break;
case CHROM_SORT: qsort(chroms,n,sizeof(Chrom_T),Chrom_compare_chrom); break;
default: abort();
}
}
/* Write chromosome text file and chrsubset file */
textfile = (char *) CALLOC(strlen(genomesubdir)+strlen("/")+
strlen(fileroot)+strlen(".chromosome")+1,sizeof(char));
sprintf(textfile,"%s/%s.chromosome",genomesubdir,fileroot);
/* Use binary, not text, so files are Unix-compatible */
if ((textfp = FOPEN_WRITE_BINARY(textfile)) == NULL) {
fprintf(stderr,"Can't write to file %s\n",textfile);
exit(9);
}
FREE(textfile);
chrsubsetfile = (char *) CALLOC(strlen(genomesubdir)+strlen("/")+
strlen(fileroot)+strlen(".chrsubset")+1,sizeof(char));
sprintf(chrsubsetfile,"%s/%s.chrsubset",genomesubdir,fileroot);
/* Use binary, not text, so files are Unix-compatible */
if ((chrsubsetfp = FOPEN_WRITE_BINARY(chrsubsetfile)) == NULL) {
fprintf(stderr,"Can't write to file %s\n",chrsubsetfile);
exit(9);
}
FREE(chrsubsetfile);
fprintf(chrsubsetfp,">all\n");
fprintf(chrsubsetfp,"\n");
chrtypelist = List_push(chrtypelist,"");
for (i = 0; i < n; i++) {
chrlength = (Genomicpos_T) Tableint_get(chrlength_table,chroms[i]);
assert(chroffset <= chroffset+chrlength-1);
chr_string = Chrom_string(chroms[i]);
if (i < 100) {
fprintf(stderr,"Chromosome %s has universal coordinates %u..%u\n",
chr_string,chroffset+1,chroffset+1+chrlength-1);
} else if (i == 100) {
fprintf(stderr,"More than 100 contigs. Will stop printing messages\n");
}
if (n <= 100) {
fprintf(chrsubsetfp,">%s\n",chr_string);
fprintf(chrsubsetfp,"+%s\n",chr_string);
}
fprintf(textfp,"%s\t%u..%u\t%u\n",
chr_string,chroffset+1,chroffset+chrlength,chrlength);
intervallist = List_push(intervallist,(void *) Interval_new(chroffset,chroffset+chrlength-1U,0));
labellist = List_push(labellist,(void *) chr_string);
annotlist = List_push(annotlist,(void *) emptystring); /* No annotations */
Tableint_put(chrlength_table,chroms[i],chroffset);
chroffset += chrlength;
}
FREE(chroms);
intervallist = List_reverse(intervallist);
labellist = List_reverse(labellist);
fclose(chrsubsetfp);
fclose(textfp);
/* Write chromosome IIT file */
divstring = (char *) CALLOC(1,sizeof(char));
divstring[0] = '\0';
divlist = List_push(NULL,divstring);
intervaltable = Table_new(65522,Table_string_compare,Table_string_hash);
labeltable = Table_new(65522,Table_string_compare,Table_string_hash);
annottable = Table_new(65522,Table_string_compare,Table_string_hash);
Table_put(intervaltable,(void *) divstring,intervallist);
Table_put(labeltable,(void *) divstring,labellist);
Table_put(annottable,(void *) divstring,annotlist);
iitfile = (char *) CALLOC(strlen(genomesubdir)+strlen("/")+
strlen(fileroot)+strlen(".chromosome.iit")+1,sizeof(char));
sprintf(iitfile,"%s/%s.chromosome.iit",genomesubdir,fileroot);
IIT_write(iitfile,divlist,chrtypelist,/*fieldlist*/(List_T) NULL,
intervaltable,labeltable,annottable,divsort,
/*version, use 1 for backward compatibility*/1,
/*label_pointers_8p*/false,/*annot_pointers_8p*/false);
FREE(iitfile);
List_free(&divlist);
FREE(divstring);
Table_free(&annottable);
Table_free(&labeltable);
Table_free(&intervaltable);
List_free(&annotlist);
/* Do not free strings in labellist, since they are not allocated */
List_free(&labellist);
/* chrtypelist has no dynamically allocated strings */
List_free(&chrtypelist);
for (p = intervallist; p != NULL; p = List_next(p)) {
interval = (Interval_T) List_head(p);
Interval_free(&interval);
}
List_free(&intervallist);
return;
}
