void free_sorted_alignment(sorted_alignment_block aln){
if(aln==NULL) return;
free(aln->data);
int i =0;
for(; i < aln->in_size; ++i){
free_sequence(aln->in_sequences[i]);
}
free(aln->in_sequences);
for(i=0; i < aln->out_size; ++i){
free_sequence(aln->out_sequences[i]);
}
free(aln->out_sequences);
free(aln);
}
void free_alignment_block(alignment_block aln){
if(aln==NULL) return;
free(aln->data);
for(int i =0; i < aln->size; ++i){
free_sequence(aln->sequences[i]);
}
free(aln->sequences);
free(aln);
}
/* free a SEQUENCES structure */
void free_sequences ( SEQUENCES *ss ) {
int i;
if (ss) {
for ( i = 0; i < ss->num_seq; i++ ) {
free_sequence (ss->sequence[i]);
}
}
xfree (ss);
}
int save_change_to_sequence (int seq_id, SEQUENCE *s) {
int i, num_seq;
num_seq = sequences->num_seq;
for (i = 0; i < num_seq; i++) {
if (seq_id == sequences->sequence[i]->id) {
free_sequence (sequences->sequence[i]);
sequences->sequence[i] = copy_sequence (s);
if (sequences->sequence[i] == NULL) return -1;
}
}
return 0;
}
void scan_tags(SeqTagLib *lib, FileReader *fwd, FileReader *rev, int is_fq, int pdirs){
Sequence *seq1, *seq2;
uint64_t id;
uint32_t i, len1, len2;
uint8_t *buf1, *buf2, v;
__n_seqs = lib->n_seq;
id = 0;
seq1 = seq2 = NULL;
buf1 = malloc(lib->p1len);
buf2 = malloc(lib->p2len);
while(is_fq? (fread_fastq_adv(&seq1, fwd, FASTQ_FLAG_NO_NAME | FASTQ_FLAG_NO_QUAL) &&
fread_fastq_adv(&seq2, rev, FASTQ_FLAG_NO_NAME | FASTQ_FLAG_NO_QUAL)) :
(fread_fasta_adv(&seq1, fwd, FASTA_FLAG_NO_NAME) && fread_fasta_adv(&seq2, rev, FASTA_FLAG_NO_NAME))){
id ++;
__n_scan ++;
len1 = seq1->seq.size;
if(len1 > lib->p1len) len1 = lib->p1len;
for(i=0;i<len1;i++){
v = base_bit_table[(int)seq1->seq.string[i]];
if(v == 4) v = lrand48() & 0x03;
buf1[i] = v;
}
len2 = seq2->seq.size;
if(len2 > lib->p2len) len2 = lib->p2len;
for(i=0;i<len2;i++){
v = base_bit_table[(int)seq2->seq.string[i]];
if(v == 4) v = lrand48() & 0x03;
buf2[i] = v;
}
if(pdirs & 0x01){ scan_tag_core(lib, id, buf1, len1, buf2, len2, 0); }
if(pdirs & 0x02){ scan_tag_core(lib, id, buf1, len1, buf2, len2, 1); }
}
free(buf1);
free(buf2);
if(seq1) free_sequence(seq1);
if(seq2) free_sequence(seq2);
}
void free_sequence (SEQUENCE *sequence) {
if (sequence) {
if (sequence->seq) xfree(sequence->seq);
if (sequence->name) xfree(sequence->name);
if (sequence->source) xfree(sequence->source);
if (sequence->feature_table) free_feature_table(sequence->feature_table);
if (sequence->left_end) free_site_hang (sequence->left_end);
if (sequence->right_end) free_site_hang (sequence->right_end);
if (sequence->cut_site_1) free_site_hang (sequence->cut_site_1);
if (sequence->cut_site_2) free_site_hang (sequence->cut_site_2);
if (sequence->fragment) free_sequence (sequence->fragment);
if (sequence->sites) free_sites (sequence->sites);
xfree (sequence);
}
}
Constraint_list *prepare_cl_for_moca ( Constraint_list *CL)
{
int a, b, c;
int tot_l, l;
char **name, **seq;
Sequence *NS=NULL;
/*Prepare the constraint list*/
CL->do_self=1;
CL->get_dp_cost=moca_slow_get_dp_cost;
CL->evaluate_residue_pair=moca_residue_pair_extended_list;
/*Prepare the moca parameters*/
(CL->moca)->evaluate_domain=evaluate_moca_domain;
(CL->moca)->cache_cl_with_domain=cache_cl_with_moca_domain;
(CL->moca)->make_nol_aln=make_moca_nol_aln;
/*Prepare the packing of the sequences*/
for ( a=0, b=1; a< (CL->S)->nseq; a++)b+=strlen ( (CL->S)->seq[a])+1;
seq =declare_char ( 1,b+1);
name=declare_char( 1,30);
CL->packed_seq_lu =declare_int ( b, 2);
for (tot_l=1,a=0; a< (CL->S)->nseq; a++)
{
strcat (seq[0], (CL->S)->seq[a]);
strcat (seq[0], "X");
l=strlen((CL->S)->seq[a]);
for ( c=1; c<= l; c++, tot_l++)
{
CL->packed_seq_lu[tot_l][0]=a;
CL->packed_seq_lu[tot_l][1]=c;
}
CL->packed_seq_lu[tot_l++][0]=UNDEFINED;
}
sprintf ( name[0], "catseq");
NS=fill_sequence_struc(1, seq, name, NULL);
CL->S=add_sequence (NS, CL->S, 0);
free_char( seq, -1);
free_char(name, -1);
free_sequence (NS, NS->nseq);
return CL;
}
Alignment *free_data_in_aln (Alignment *A)
{
//Frees only the sequence data (keeps profile information)
A->seq_al=free_char (A->seq_al, -1);
A->seq_comment=free_char (A->seq_comment, -1);
A->aln_comment=free_char (A->aln_comment, -1);
A->name=free_char (A->name, -1);
A->expanded_order=free_char (A->expanded_order, -1);
A->order=free_int (A->order, -1);
A->seq_cache=free_int (A->seq_cache, -1);
A->cdna_cache=free_int (A->cdna_cache, -1);
A->score_res=free_int (A->score_res, -1);
free_sequence (A->S, -1);
A->S=NULL;
return A;
}
void free_hash_alignment(hash_alignment_block aln){
if(aln == NULL) return;
free(aln->data);
ENTRY *ret_val;
// ENTRY search;
int hc=0;
for(int i = 0; i < aln->size; ++i){
ENTRY search={aln->species[i],NULL};
hc = hsearch_r(search,FIND,&ret_val,aln->sequences);
if(hc == 0){
fprintf(stderr,"Failed to read hash table: %s\n", strerror(errno));
exit(1);
}
if(ret_val != NULL){
free(ret_val->key);
free_sequence(ret_val->data);
// free(ret_val);
}
}free(aln->species);
hdestroy_r(aln->sequences);
free(aln->sequences);
free(aln);
}
/*
* Free a C object according to a type description. Do not free pointers at
* the first level; they may be referenced by other fields of a sequence, and
* will be freed by free_atype_ptr in a second pass.
*/
static void
free_atype(const struct atype_info *a, void *val)
{
switch (a->type) {
case atype_fn: {
const struct fn_info *fn = a->tinfo;
if (fn->free_func != NULL)
fn->free_func(val);
break;
}
case atype_sequence:
free_sequence(a->tinfo, val);
break;
case atype_ptr: {
const struct ptr_info *ptrinfo = a->tinfo;
void *ptr = LOADPTR(val, ptrinfo);
if (ptr != NULL) {
free_atype(ptrinfo->basetype, ptr);
free_atype_ptr(ptrinfo->basetype, ptr);
}
break;
}
case atype_offset: {
const struct offset_info *off = a->tinfo;
assert(off->basetype != NULL);
free_atype(off->basetype, (char *)val + off->dataoff);
break;
}
case atype_optional: {
const struct optional_info *opt = a->tinfo;
free_atype(opt->basetype, val);
break;
}
case atype_counted: {
const struct counted_info *counted = a->tinfo;
void *dataptr = (char *)val + counted->dataoff;
size_t count;
if (load_count(val, counted, &count) == 0)
free_cntype(counted->basetype, dataptr, count);
break;
}
case atype_nullterm_sequence_of:
case atype_nonempty_nullterm_sequence_of: {
size_t count = get_nullterm_sequence_len(val, a->tinfo);
free_sequence_of(a->tinfo, val, count);
break;
}
case atype_tagged_thing: {
const struct tagged_info *tag = a->tinfo;
free_atype(tag->basetype, val);
break;
}
case atype_bool:
case atype_int:
case atype_uint:
case atype_int_immediate:
break;
default:
abort();
}
}
void test_read_sequence_from_fastq_with_bad_reads_and_long_reads()
{
int ascii_offset=33;
//pre-allocate space where to read the sequences
Sequence* seq = malloc(sizeof(Sequence));
if (seq==NULL){
fputs("Out of memory trying to allocate a Sequence",stderr);
exit(1);
}
int max_read_length=200;
alloc_sequence(seq,max_read_length,LINE_MAX,ascii_offset);
int length_seq;
FILE* fp1 = fopen("../data/test/basic/includes_one_read_that_is_too_long.fastq", "r");
// @read1
// ACGT
// +
// !!!!
// @read2
// CCCC
// +
// 5555
// @read3
// AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
// -
// 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
// @read4
// ACGT
// +
// 3333
length_seq = read_sequence_from_fastq(fp1,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("read1",seq->name);
CU_ASSERT_STRING_EQUAL("ACGT",seq->seq);
CU_ASSERT((int) (seq->qual[0])==0);
CU_ASSERT((int) (seq->qual[1])==0);
CU_ASSERT((int) (seq->qual[2])==0);
CU_ASSERT((int) (seq->qual[3])==0);
length_seq = read_sequence_from_fastq(fp1,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("read2",seq->name);
CU_ASSERT_STRING_EQUAL("CCCC",seq->seq);
CU_ASSERT((int) (seq->qual[0])==20);
CU_ASSERT((int) (seq->qual[1])==20);
CU_ASSERT((int) (seq->qual[2])==20);
CU_ASSERT((int) (seq->qual[3])==20);
length_seq = read_sequence_from_fastq(fp1,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 100);
CU_ASSERT_STRING_EQUAL("read3",seq->name);
CU_ASSERT((int) (seq->qual[0])==15); // 0 translates as ascii 48; subtract 33 and get 15
length_seq = read_sequence_from_fastq(fp1,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("read4",seq->name);
CU_ASSERT_STRING_EQUAL("ACGT",seq->seq);
CU_ASSERT((int) (seq->qual[0])==18);
fclose(fp1);
FILE* fp2 = fopen("../data/test/basic/includes_reads_with_bad_characters.fastq", "r");
//@read1
//ACGTACGTACGTACGT
//+
//WEW2WEW2WEW2WEWA
//@read2
//AAAA#5A
//+
//1234567
//@read3
//TTTT
//+
//3333
length_seq = read_sequence_from_fastq(fp2,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 16);
CU_ASSERT_STRING_EQUAL("read1",seq->name);
CU_ASSERT_STRING_EQUAL("ACGTACGTACGTACGT",seq->seq);
length_seq = read_sequence_from_fastq(fp2,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("read3",seq->name);
CU_ASSERT_STRING_EQUAL("TTTT",seq->seq);
length_seq = read_sequence_from_fastq(fp2,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 0);
fclose(fp2);
FILE* fp3 = fopen("../data/test/basic/includes_one_read_where_quality_is_longer_than_seq.fastq", "r");
//@read1
//ACGTACGTACGTACGT
//+
//WEW2WEW2WEW2WEWA
//@read2
//AAAA#5A
//+
//!!!!!!!!!!!!!!!!!!!!!!
//@read3
//TTTT
//+
//3333
length_seq = read_sequence_from_fastq(fp3,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 16);
CU_ASSERT_STRING_EQUAL("read1",seq->name);
CU_ASSERT_STRING_EQUAL("ACGTACGTACGTACGT",seq->seq);
length_seq = read_sequence_from_fastq(fp3,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("read3",seq->name);
CU_ASSERT_STRING_EQUAL("TTTT",seq->seq);
length_seq = read_sequence_from_fastq(fp3,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 0);
fclose(fp3);
FILE* fp4 = fopen("../data/test/basic/includes_multiline_reads.fastq", "r");
// @read1
// ACGT
// +
// @@@@
// @read2 45 bases
// AAAAAAAAAAAAAAA
// CCCCCCCCCCCCCCC
// GGGGGGGGGGGGGGG
// +
// 222222222222222
// 333333333333333
// 444444444444444
// @read3
// TTT
// -
// ggg
length_seq = read_sequence_from_fastq(fp4,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("read1",seq->name);
CU_ASSERT_STRING_EQUAL("ACGT",seq->seq);
length_seq = read_sequence_from_fastq(fp4,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 45);
CU_ASSERT_STRING_EQUAL("read2",seq->name);
CU_ASSERT_STRING_EQUAL("AAAAAAAAAAAAAAACCCCCCCCCCCCCCCGGGGGGGGGGGGGGG",seq->seq);
length_seq = read_sequence_from_fastq(fp4,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 3);
CU_ASSERT_STRING_EQUAL("read3",seq->name);
CU_ASSERT_STRING_EQUAL("TTT",seq->seq);
length_seq = read_sequence_from_fastq(fp4,seq,max_read_length);
CU_ASSERT_EQUAL(length_seq, 0);
fclose(fp4);
free_sequence(&seq);
}
void test_read_sequence_from_fastq(){
int ascii_offset = 33;
//pre-allocate space where to read the sequences
Sequence* seq = malloc(sizeof(Sequence));
if (seq==NULL){
fputs("Out of memory trying to allocate a Sequence",stderr);
exit(1);
}
alloc_sequence(seq,200,LINE_MAX, ascii_offset);
int length_seq;
FILE* fp1 = fopen("../data/test/basic/one_entry.fastq", "r");
// 1. Read from simple fasta:
// >Zam
// ACGT
// +
// &&&&
length_seq = read_sequence_from_fastq(fp1,seq,1000);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("Zam",seq->name);
CU_ASSERT_STRING_EQUAL("ACGT",seq->seq);
// CU_ASSERT_STRING_EQUAL("&&&&",seq->qual);/Zam says - /changed this line when I changed the ual reading code to offset by 33
CU_ASSERT((int) seq->qual[0] == 5);
FILE* fp2 = fopen("../data/test/basic/three_entries.fastq", "r");
//2. Read from fastq:
// @Zam1
//ACGT
//+
//&&&&
//@Zam2
//AAAAAAAA
//+
//!((/8F+,
//@Zam3
//ATATATAT
//TTTTTTTTTT
//-
//(((((((+AAAAAABAAA
length_seq = read_sequence_from_fastq(fp2,seq, 1000);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("Zam1",seq->name);
CU_ASSERT_STRING_EQUAL("ACGT",seq->seq);
// CU_ASSERT_STRING_EQUAL("&&&&",seq->qual);/Zam says - /changed this line when I changed the ual reading code to offset by 33
CU_ASSERT((int) seq->qual[0] == 5);
length_seq = read_sequence_from_fastq(fp2,seq,1000);
CU_ASSERT_EQUAL(length_seq, 8);
CU_ASSERT_STRING_EQUAL("Zam2",seq->name);
CU_ASSERT_STRING_EQUAL("AAAAAAAA",seq->seq);
CU_ASSERT((int) seq->qual[0] == 0);//! is quality 0 - take 33 off its ascii code, can check on http://www.asciitable.com/
CU_ASSERT((int) seq->qual[1] == 7);// ( is quality 7
CU_ASSERT((int) seq->qual[2] == 7);// ( is quality 7
CU_ASSERT((int) seq->qual[3] == 14);// / is quality 14
CU_ASSERT((int) seq->qual[4] == 23);// 8 is quality 23
CU_ASSERT((int) seq->qual[5] == 37);// F is quality 37
CU_ASSERT((int) seq->qual[6] == 10);// + is quality 10
CU_ASSERT((int) seq->qual[7] == 11);// , is quality 11
length_seq = read_sequence_from_fastq(fp2,seq,1000);
CU_ASSERT_EQUAL(length_seq, 18);
CU_ASSERT_STRING_EQUAL("Zam3",seq->name);
CU_ASSERT_STRING_EQUAL("ATATATATTTTTTTTTTT",seq->seq);
CU_ASSERT((int) seq->qual[0] == 7);// ( is quality 7
length_seq = read_sequence_from_fastq(fp2,seq,1000);
CU_ASSERT_EQUAL(length_seq, 0);
fclose(fp2);
free_sequence(&seq);
}
//test reading several short entries from a fasta file
void test_read_sequence_from_fasta(){
Sequence * seq = malloc(sizeof(Sequence));
boolean full_entry;
if (seq == NULL){
fputs("Out of memory trying to allocate Sequence\n",stderr);
exit(1);
}
//pre-allocate space where to read the sequences
alloc_sequence(seq,200,LINE_MAX, 0);
int length_seq;
FILE* fp1 = fopen("../data/test/basic/one_entry.fasta", "r");
if (fp1 == NULL){
fputs("cannot open file:../data/test/basic/one_entry.fasta\n",stderr);
exit(1);
}
// 1. Read from simple fasta:
// >Zam
// ACGT
// ACGTACGTACGT
length_seq = read_sequence_from_fasta(fp1,seq,1000,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 16);
CU_ASSERT_STRING_EQUAL("Zam",seq->name);
CU_ASSERT_EQUAL(1,seq->start);
CU_ASSERT_EQUAL(16,seq->end);
CU_ASSERT_STRING_EQUAL("ACGTACGTACGTACGT",seq->seq);
CU_ASSERT(full_entry);
fclose(fp1);
FILE* fp2 = fopen("../data/test/basic/three_entries.fasta", "r");
// 2. Read from fasta:
//>Zam1
//ACGT
//ACGTACGTACGT
//>Zam2
//ACGT
//ACGTACGTACGT
//TTTTTTTT
//>Zam3
//ACGTNNACGTACGTACGT
length_seq = read_sequence_from_fasta(fp2,seq,1000,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 16);
CU_ASSERT_STRING_EQUAL("Zam1",seq->name);
CU_ASSERT_EQUAL(1,seq->start);
CU_ASSERT_EQUAL(16,seq->end);
CU_ASSERT_STRING_EQUAL("ACGTACGTACGTACGT",seq->seq);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,1000,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 24);
CU_ASSERT_STRING_EQUAL("Zam2",seq->name);
CU_ASSERT_EQUAL(1,seq->start);
CU_ASSERT_EQUAL(24,seq->end);
CU_ASSERT_STRING_EQUAL("ACGTACGTACGTACGTTTTTTTTt",seq->seq);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,1000,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 18);
CU_ASSERT_STRING_EQUAL("Zam3",seq->name);
CU_ASSERT_EQUAL(1,seq->start);
CU_ASSERT_EQUAL(18,seq->end);
CU_ASSERT_STRING_EQUAL("ACGTNNACGTACGTACGT",seq->seq);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,1000,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 0);
CU_ASSERT(full_entry);
fclose(fp2);
free_sequence(&seq);
}
void test_read_sequence_from_fasta_when_file_has_bad_reads()
{
int length_seq;
Sequence * seq = malloc(sizeof(Sequence));
boolean full_entry;
if (seq == NULL){
fputs("Out of memory trying to allocate Sequence\n",stderr);
exit(1);
}
//pre-allocate space where to read the sequences
int max_read_length=100;
alloc_sequence(seq,max_read_length,LINE_MAX, 0);
FILE* fp2= fopen("../data/test/basic/includes_reads_that_have_bad_characters.fasta", "r");
// >read1
// AAAAAAAAAAAA9
// >read2
// ¡€#9∞§¶#¶•#•#•#ª#ª#ª#ªº#º#º#º––––
// >read3 4 c's
// CCCC
// >read4 10 Ts
// TTTTTTTTTT
// >read5
// $
// >read6
// AAAAAAAAAAAAAAAAAA#A
// >read7
// AAA
length_seq = read_sequence_from_fasta(fp2,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 13);
CU_ASSERT_STRING_EQUAL("read1",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 63);
CU_ASSERT_STRING_EQUAL("read2",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("read3",seq->name);
CU_ASSERT_STRING_EQUAL("CCCC",seq->seq);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 10);
CU_ASSERT_STRING_EQUAL("read4",seq->name);
CU_ASSERT_STRING_EQUAL("TTTTTTTTTT",seq->seq);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 1);
CU_ASSERT_STRING_EQUAL("read5",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 20);
CU_ASSERT_STRING_EQUAL("read6",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 3);
CU_ASSERT_STRING_EQUAL("read7",seq->name);
CU_ASSERT_STRING_EQUAL("AAA",seq->seq);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp2,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 0);
CU_ASSERT(full_entry);
fclose(fp2);
//now make sure we do not get trapped in an infinite loop if the last read of a file is bad
FILE* fp3= fopen("../data/test/basic/includes_final_read_that_has_bad_characters.fasta", "r");
// >read1
// AAAAAAAAAAAA9
// >read2
// ¡€#9∞§¶#¶•#•#•#ª#ª#ª#ªº#º#º#º––––
// >read3 4 c's
// CCCC
// >read4 10 Ts
// TTTTTTTTTT
// >read5
// $
// >read6
// AAAAAAAAAAAAAAAAAA#A
length_seq = read_sequence_from_fasta(fp3,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 13);
CU_ASSERT_STRING_EQUAL("read1",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp3,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 63);
CU_ASSERT_STRING_EQUAL("read2",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp3,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 4);
CU_ASSERT_STRING_EQUAL("CCCC",seq->seq);
CU_ASSERT_STRING_EQUAL("read3",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp3,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 10);
CU_ASSERT_STRING_EQUAL("read4",seq->name);
CU_ASSERT_STRING_EQUAL("TTTTTTTTTT",seq->seq);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp3,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 1);
CU_ASSERT_STRING_EQUAL("read5",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp3,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 20);
CU_ASSERT_STRING_EQUAL("read6",seq->name);
CU_ASSERT(full_entry);
length_seq = read_sequence_from_fasta(fp3,seq,max_read_length,true,&full_entry,0);
CU_ASSERT_EQUAL(length_seq, 0);
CU_ASSERT(full_entry);
fclose(fp3);
free_sequence(&seq);
}
Sequence *free_constraint_list (Constraint_list *CL)
{
Sequence *S;
int a, b;
Constraint_list *pCL;
/*Prepare the selective freeing of the CL data structure:
If the CL has been obtained from copy, every pointer that is identical to the parent CL (CL->pCL)
will not be saved.
*/
if ( !CL)return NULL;
else S=CL->S;
if ( CL->copy_mode==SOFT_COPY && !CL->pCL)
{vfree(CL); return S;}
else if ( CL->copy_mode==SOFT_COPY)
{
pCL=CL->pCL;
CL->residue_index=NULL;
if ( CL->M ==pCL->M )CL->M=NULL;
if (CL->start_index ==pCL->start_index )CL->start_index=NULL;
if (CL->end_index ==pCL->end_index )CL->end_index=NULL;
if ( CL->fp ==pCL->fp )CL->fp=NULL;
if ( CL->matrices_list ==pCL->matrices_list )CL->matrices_list=NULL;
if ( CL->STRUC_LIST ==pCL->STRUC_LIST )CL->STRUC_LIST=NULL;
if ( CL->W ==pCL->W )CL->W=NULL;
if ( CL->DM ==pCL->DM )CL->DM=NULL;
if ( CL->ktupDM ==pCL->ktupDM )CL->ktupDM=NULL;
if ( CL->translation ==pCL->translation )CL->translation=NULL;
if ( CL->moca ==pCL->moca )CL->moca=NULL;
if ( CL->Prot_Blast ==pCL->Prot_Blast )CL->Prot_Blast=NULL;
if ( CL->DNA_Blast ==pCL->DNA_Blast )CL->DNA_Blast=NULL;
if ( CL->Pdb_Blast ==pCL->Pdb_Blast )CL->Pdb_Blast=NULL;
if ( CL->seq_for_quadruplet ==pCL->seq_for_quadruplet )CL->seq_for_quadruplet=NULL;
if ( CL->TC ==pCL->TC )CL->TC=NULL;
}
/*End of selective freeing of the CL data structure*/
if ( CL->residue_index)free_arrayN(CL->residue_index, 3);
if ( CL->M)free_int (CL->M, -1);
if ( CL->fp)vfclose (CL->fp);
if ( CL->matrices_list)free_char(CL->matrices_list,-1);
if ( CL->start_index)free_int ( CL->start_index,-1);
if ( CL->end_index)free_int ( CL->end_index,-1);
if ( CL->STRUC_LIST)free_sequence ( CL->STRUC_LIST, (CL->STRUC_LIST)->nseq);
if ( CL->W)free_weights (CL->W);
CL->DM=free_distance_matrix (CL->DM);
CL->ktupDM=free_distance_matrix (CL->ktupDM);
if ( CL->translation)vfree(CL->translation);
if ( CL->moca)free_moca (CL->moca);
if ( CL->Prot_Blast)free_blast_param ( CL->Prot_Blast);
if ( CL->DNA_Blast) free_blast_param ( CL->DNA_Blast);
if ( CL->Pdb_Blast) free_blast_param ( CL->Pdb_Blast);
if ( CL->TC) free_TC_param ( CL->TC);
if (CL->seq_for_quadruplet)vfree (CL->seq_for_quadruplet);
vfree(CL);
return S;
}
Constraint_list *free_constraint_list_full (Constraint_list *CL)
{
free_sequence (free_constraint_list (CL), -1);
return NULL;
}
int main(int argc, char *argv[])
{
sequence *seq; /* pointer to input sequence data structure */
image **imgs; /* pointer to input sequence array of images */
image *out; /* pointer the output image */
char seq_in[100], /* input sequence name */
seq_out[100], /* output sequence name */
file_out[100]; /* output file name */
int length; /* length of the sequence */
int i; /* loop index */
/* Process input arguments */
if(argc != 3)
{
fprintf(stderr,"Usage: %s [input PGM sequence name] [output PGM sequence name]\n", argv[0]);
exit(0);
}
else
{
strcpy(seq_in, argv[1]);
strcpy(seq_out, argv[2]);
}
/* Load the input sequence */
seq = load_sequence(seq_in);
/* Get a pointer to the sequence images */
imgs = get_sequence_images(seq);
/* Get sequence length */
length = get_sequence_length(seq);
/* Check if sequence is long enough */
if(length < 2) {
fprintf(stderr, "sequence is too short\n");
exit(1);
}
/* Clone the first image to store results */
out = clone_image(imgs[0]);
/* Loop through the sequence and write the mean sequence */
/* i.e. for each image of the input sequence, write the image */
/* resulting from the mean between the current image and */
/* the next one. */
for(i = 0; i < length - 1; i++) {
/* Compute the mean between the current picture and the next one */
mean_image(imgs[i], imgs[i+1], out);
/* Now write out the output image */
sprintf(file_out, "%s%03d.pgm", seq_out, i);
printf("Writing out %s\n",file_out);
pgm_write_image(out, file_out);
}
/* We must deallocate the memory the sequence and for the image before */
/* we finish */
free_image(out);
free_sequence(seq);
return(EXIT_SUCCESS);
}
seq get_sequence(char *data){
if(data == NULL) return NULL;
char *seq_parse;
char *src_parse;
seq new_seq = malloc(sizeof(*new_seq));
assert(new_seq!=NULL);
new_seq->src=NULL;
new_seq->sequence=NULL;
char *temp = strdup(data);
assert(temp!=NULL);
//First part of entry, is the 's', throw that away
char *datum =strtok_r(temp," \t\n",&seq_parse);
for(int i=2;i<8;++i){
datum = strtok_r(NULL," \t\n",&seq_parse);
if(datum == NULL){
fprintf(stderr,"Invalid sequence: %s\n", data);
free_sequence(new_seq);
return NULL;
}
switch (i){
//Second part is species name and contig
case 2:
new_seq->src = strdup(datum);
char *parse_src = strdup(datum);
new_seq->species = strtok_r(parse_src,".",&src_parse);
new_seq->scaffold = strtok_r(NULL,".",&src_parse);
assert(new_seq->src != NULL);
break;
//Third part is the start of the aligned region in the source sequence
case 3:
errno=0;
unsigned long start = strtol(datum,NULL,10);
if(errno !=0){
fprintf(stderr, "Invalid sequence start: %s\nIn sequence: %s\n"
,datum,data);
free_sequence(new_seq);
return NULL;
}
new_seq->start=start;
break;
//Fourth is aligned sequence length
case 4:
errno=0;
unsigned int size = strtol(datum,NULL,10);
if(errno !=0){
fprintf(stderr, "Invalid sequence start: %s\nIn sequence: %s\n"
,datum,data);
free_sequence(new_seq);
return NULL;
}
new_seq->size = size;
break;
//Fifth is strand
case 5:
if(datum[0] != '+' && datum[0] != '-'){
fprintf(stderr, "Invalid strand: %s\nIn sequence: %s\n"
,datum,data);
free_sequence(new_seq);
return NULL;
}
new_seq->strand=datum[0];
break;
//Sixth is size of source sequence
case 6:
errno=0;
unsigned long srcSize = strtol(datum,NULL,10);
if(errno !=0){
fprintf(stderr, "Invalid source sequence size: %s\nIn sequence: %s\n"
,datum,data);
free_sequence(new_seq);
return NULL;
}
new_seq->srcSize = srcSize;
break;
//Last is the sequence itself
case 7:
new_seq->sequence = strdup(datum);
assert(new_seq->sequence !=NULL);
break;
default:
printf("Default case\n");
}
}
free(temp);
return new_seq;
}
sorted_alignment_block get_sorted_alignment(maf_linear_parser parser,
char **in_group, int in_size, char **out_group, int out_size){
sorted_alignment_block new_align = NULL;
int in_block=0;
long bytesread;
int sizeLeftover=0;
int bLoopCompleted = 0;
int first = 1;
char *datum;
char *npos;
char *temp;
char *species;
do{
if(parser->fill_buf){
bytesread = fread(parser->buf+sizeLeftover, 1,
sizeof(parser->buf)-1-sizeLeftover, parser->maf_file);
if (bytesread<1){
bLoopCompleted = 1;
bytesread = 0;
continue;
}
if(ferror(parser->maf_file) != 0){
fprintf(stderr, "File stream error: %s\nError: %s",
parser->filename,strerror(errno));
return NULL;
}
parser->buf[sizeLeftover+bytesread]=0;
parser->curr_pos=0;
parser->pos=parser->buf;
--parser->fill_buf;
}
npos = strchr(parser->pos,'\n');
if(npos==NULL){
sizeLeftover = strlen(parser->pos);
memmove(parser->buf,parser->buf+(sizeof(parser->buf))-sizeLeftover-1,sizeLeftover);
++parser->fill_buf;
continue;
}
*npos=0;
datum = parser->pos;
parser->pos = npos+1;
//If we've yet to enter an alignment block, and the first character
//of the line isn't 'a', then skip over it.
if(!in_block && datum[0]!='a') continue;
//***HANDLE SCORE/PASS/DATA here**i
else if(datum[0]=='a'){
//If we find an 'a' after entering a block, then this is a new block
//so rewind the file pointer and break out of read loop.
if(in_block){
*npos='\n';
parser->pos = datum;
break;
}
//Else we're starting a new alignment block, initialize the data
//structure and set in_block to true.
new_align=malloc(sizeof(*new_align));
assert(new_align != NULL);
new_align->in_sequences = malloc(16*sizeof(*new_align->in_sequences));
assert(new_align->in_sequences != NULL);
new_align->in_size=0;
new_align->in_max=16;
new_align->out_sequences = malloc(16*sizeof(*new_align->out_sequences));
assert(new_align->out_sequences != NULL);
new_align->out_size=0;
new_align->out_max=16;
new_align->data = NULL;
new_align->seq_length=0;
in_block=1;
continue;
}
//If in a block and find 's', then it's a sequence to add to the
//current alignment block, parse it, reallocate alignment block's
//sequence array if necessary, and store the new sequence.
else if(datum[0]=='s'){
seq new_seq = get_sequence(datum);
if(new_seq == NULL){
fprintf(stderr, "Invalid sequence entry %s\n",datum);
return NULL;
}
if(first){
new_align->seq_length=strlen(new_seq->sequence);
first = 0;
}
temp = strdup(new_seq->src);
assert(temp != NULL);
species = strtok(temp,".");
if(in_list(species,in_group,in_size)){
if(new_align->in_size ==new_align->in_max){
new_align->in_sequences=realloc(new_align->in_sequences,
2*new_align->in_max*sizeof(seq));
assert(new_align->in_sequences!=NULL);
new_align->in_max *=2;
}new_align->in_sequences[new_align->in_size++]=new_seq;
}else if(in_list(species,out_group,out_size)){
if(new_align->out_size ==new_align->out_max){
new_align->out_sequences=realloc(new_align->out_sequences,
2*new_align->out_max*sizeof(seq));
assert(new_align->out_sequences!=NULL);
new_align->out_max *=2;
}new_align->out_sequences[new_align->out_size++]=new_seq;
//If not in in group or out group, throw away.
}else free_sequence(new_seq);
free(temp);
}
//If we hit a character other than 'a' or 's', then we've exited
//the current alignment block, break out of the read loop and return
//the current alignment block.
else break;
}while(!bLoopCompleted);
return new_align;
}
