Esempio n. 1
0
static Alignment *HPair_refine_alignment(HPair *hpair,
                                         Alignment *alignment){
    register Alignment *refined_alignment = NULL;
    register Region *region;
    register gint query_region_start, target_region_start;
    g_assert(hpair->heuristic->optimal);
    if(hpair->verbosity > 1)
        g_message("Refining alignment ... (%d)", alignment->score);
    switch(hpair->heuristic->has->refinement){
        case Heuristic_Refinement_FULL:
            region = Region_create(0, 0, hpair->query_length,
                                         hpair->target_length);
            refined_alignment = Optimal_find_path(
                    hpair->heuristic->optimal, region,
                    hpair->user_data, alignment->score, hpair->subopt);
            g_assert(refined_alignment);
            Region_destroy(region);
            break;
        case Heuristic_Refinement_REGION:
            query_region_start
                = MAX(0, alignment->region->query_start
                       - hpair->heuristic->has->refinement_boundary);
            target_region_start
                = MAX(0, alignment->region->target_start
                       - hpair->heuristic->has->refinement_boundary);
            region = Region_create(query_region_start,
                                   target_region_start,
                MIN(hpair->query_length,
                    Region_query_end(alignment->region)
                  + hpair->heuristic->has->refinement_boundary)
                - query_region_start,
                MIN(hpair->target_length,
                    Region_target_end(alignment->region)
                  + hpair->heuristic->has->refinement_boundary)
                - target_region_start);
            refined_alignment = Optimal_find_path(
                    hpair->heuristic->optimal, region,
                    hpair->user_data, alignment->score, hpair->subopt);
            g_assert(refined_alignment);
            Region_destroy(region);
            break;
        default:
            g_error("Bad type for refinement [%s]",
                Heuristic_Refinement_to_string(
                       hpair->heuristic->has->refinement));
            break;
        }
    g_assert(refined_alignment);
    g_assert(refined_alignment->score >= alignment->score);
    return refined_alignment;
    }
Esempio n. 2
0
static void test_alignment(C4_Model *model,
                           Sequence *query, Sequence *target,
                           Protein2Genome_Data *p2gd){
    register C4_Score score;
    register Alignment *alignment;
    register Optimal *optimal = Optimal_create(model,
                                               NULL,
                                               Optimal_Type_SCORE
                                              |Optimal_Type_PATH,
                                              FALSE);
    register Region *region = Region_create(0, 0,
                                           query->len, target->len);
    score = Optimal_find_score(optimal, region, p2gd, NULL);
    g_message("Score is [%d] (expect 131)", score);
    g_assert(score == 129);
    alignment = Optimal_find_path(optimal, region, p2gd,
                                  C4_IMPOSSIBLY_LOW_SCORE, NULL);
    g_message("Alignment score is [%d]", alignment->score);
    Alignment_display(alignment, query, target,
                      NULL,
                      Protein2Genome_Data_get_submat(p2gd),
                      Protein2Genome_Data_get_translate(p2gd), stdout);
    g_assert(score == alignment->score);
    Alignment_destroy(alignment);
    Optimal_destroy(optimal);
    Region_destroy(region);
    return;
    }
Esempio n. 3
0
int
KDTree_neighbor_search(struct KDTree* tree, float neighbor_radius,
                       struct Neighbor** neighbors)
{
    long int i;
    int ok;
    Region_dim=tree->dim;

    if(tree->_neighbor_list)
    {
        free(tree->_neighbor_list);
        tree->_neighbor_list = NULL;
    }
    tree->_neighbor_count=0;
    /* note the use of r^2 to avoid use of sqrt */
    tree->_neighbor_radius=neighbor_radius;
    tree->_neighbor_radius_sq=neighbor_radius*neighbor_radius;

    if (Node_is_leaf(tree->_root))
    {
        /* this is a boundary condition */
        /* bucket_size>nr of points */
        ok = KDTree_search_neighbors_in_bucket(tree, tree->_root);
    }
    else
    {
        /* "normal" situation */
        struct Region *region;
        /* start with [-INF, INF] */
        region= Region_create(NULL, NULL);
        if (!region) return 0;
        ok = KDTree__neighbor_search(tree, tree->_root, region, 0);
        Region_destroy(region);
    }
    if (!ok) return 0;

    *neighbors = NULL;
    for (i = 0; i < tree->_neighbor_count; i++)
    {
        struct Neighbor* neighbor = malloc(sizeof(struct Neighbor));
        if (!neighbor)
        {
            while(1)
            {
                neighbor = *neighbors;
                if (!neighbor) return 0;
                *neighbors = neighbor->next;
                free(neighbor);
            }
        }
        *neighbor = tree->_neighbor_list[i];
        neighbor->next = *neighbors;
        *neighbors = neighbor;
    }

    return 1;
}
Esempio n. 4
0
static struct Region*
Region_create_intersect_right(struct Region* region, float split_coord, int current_dim)
{
    struct Region* p;
    const float value = region->_left[current_dim];
    region->_left[current_dim]=split_coord;
    p = Region_create(region->_left, region->_right);
    region->_left[current_dim]=value;
    return p;
}
Esempio n. 5
0
OPair *OPair_create(Optimal *optimal, SubOpt *subopt,
                    gint query_length, gint target_length, gpointer user_data){
    register OPair *opair = g_new(OPair, 1);
    g_assert(optimal);
    g_assert(query_length >= 0);
    g_assert(target_length >= 0);
    opair->optimal = Optimal_share(optimal);
    opair->user_data = user_data;
    opair->subopt = SubOpt_share(subopt);
    opair->region = Region_create(0, 0, query_length, target_length);
    opair->prev_score = C4_IMPOSSIBLY_HIGH_SCORE;
    return opair;
    }
Esempio n. 6
0
int KDTree_search_center_radius(struct KDTree* tree, float *coord, float radius)
{
    int i;
    int dim = tree->dim;
    float* left = malloc(dim*sizeof(float));
    float* right = malloc(dim*sizeof(float));
    if (left==NULL || right==NULL)
    {
        if (left) free(left);
        if (right) free(right);
        return 0;
    }

    Region_dim=tree->dim;

    if (tree->_radius_list)
    {
        free(tree->_radius_list);
        tree->_radius_list = NULL;
    }
    tree->_count=0;

    tree->_radius=radius;
    /* use of r^2 to avoid sqrt use */
    tree->_radius_sq=radius*radius;

    for (i=0; i<tree->dim; i++)
    {
        left[i]=coord[i]-radius;
        right[i]=coord[i]+radius;
        /* set center of query */
        tree->_center_coord[i]=coord[i];
    }

    /* clean up! */
    if (coord) free(coord);

    Region_destroy(tree->_query_region);
    tree->_query_region= Region_create(left, right);

    free(left);
    free(right);

    if (!tree->_query_region) return 0;

    return KDTree_search(tree, NULL, NULL, 0);
}
Esempio n. 7
0
int Argument_main(Argument *arg){
    register C4_Model *est2genome;
    register C4_Score score;
    register Alignment *alignment;
    register Optimal *optimal;
    register gchar *query_seq =
                  "CGATCGATCGNATCGATCGATC"
                  "CATCTATCTAGCGAGCGATCTA",
                   *target_seq =
                  "CGATCGATCGATCGATCGATC"
              "GTNNNNNNNNNNNNNNNNNNNN"
              "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN"
              "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN"
              "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN"
              "NNNNNNNNNNNNNNNNNNNNNNNNNNNAG"
           /* "CTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNAC" */
                   "CATCTATCTANNNGCGAGCGATCTA";
    register Alphabet *dna_alphabet = Alphabet_create(
                                       Alphabet_Type_DNA, FALSE);
    register Sequence *query = Sequence_create("query", NULL,
                               query_seq, 0, Sequence_Strand_UNKNOWN,
                               dna_alphabet),
                      *target = Sequence_create("target", NULL,
                              target_seq, 0, Sequence_Strand_UNKNOWN,
                              dna_alphabet);
/**/
    register Region *region = Region_create(0, 0,
                               query->len, target->len);
    register EST2Genome_Data *e2gd;
    Match_ArgumentSet_create(arg);
    Affine_ArgumentSet_create(arg);
    Intron_ArgumentSet_create(arg);
    Viterbi_ArgumentSet_create(arg);
    Argument_process(arg, "est2genome.test", NULL, NULL);
    est2genome = EST2Genome_create();
    g_message("Has [%d] shadows", est2genome->shadow_list->len);
    optimal = Optimal_create(est2genome, NULL,
                             Optimal_Type_SCORE|Optimal_Type_PATH,
                             FALSE);
    e2gd = EST2Genome_Data_create(query, target);
    score = Optimal_find_score(optimal, region, e2gd, NULL);
    g_message("Score is [%d]", score);
    g_assert(score == 159);
/**/
    alignment = Optimal_find_path(optimal, region, e2gd,
                                  C4_IMPOSSIBLY_LOW_SCORE, NULL);
    g_message("Alignment score is [%d]", alignment->score);
    Alignment_display(alignment, query, target,
                      EST2Genome_Data_get_submat(e2gd),
                      EST2Genome_Data_get_submat(e2gd),
                      NULL, stdout);
    g_assert(score == alignment->score);
/**/
    Alphabet_destroy(dna_alphabet);
    C4_Model_destroy(est2genome);
    Alignment_destroy(alignment);
    Optimal_destroy(optimal);
    EST2Genome_Data_destroy(e2gd);
    Sequence_destroy(query);
    Sequence_destroy(target);
    Region_destroy(region);
    return 0;
    }
Esempio n. 8
0
static int KDTree__neighbor_search(struct KDTree* tree, struct Node *node, struct Region *region, int depth)
{
    struct Node *left, *right;
    struct Region *left_region = NULL;
    struct Region *right_region = NULL;
    int localdim;
    int intersect;
    float cut_value;
    int ok = 1;

    localdim=depth%tree->dim;

    left=node->_left;
    right=node->_right;

    cut_value = node->_cut_value;

    /* planes of left and right nodes */
    intersect=Region_test_intersect_left(region, cut_value, localdim);
    if(intersect==1)
    {
        left_region = Region_create(region->_left, region->_right);
        if (!left_region) ok = 0;
    }
    else if(intersect==0)
    {
        left_region = Region_create_intersect_left(region, cut_value, localdim);
        if (!left_region) ok = 0;
    }
    else if(intersect==-1)
    /* intersect is -1 if no overlap */
    {
        left_region = NULL;
    }

    intersect=Region_test_intersect_right(region, cut_value, localdim);
    if(intersect==-1)
    {
        right_region = Region_create(region->_left, region->_right);
        if (!right_region) ok = 0;
    }
    else if(intersect==0)
    {
        right_region = Region_create_intersect_right(region, cut_value, localdim);
        if (!right_region) ok = 0;
    }
    else if(intersect==+1)
    /* intersect is +1 if no overlap */
    {
        right_region = NULL;
    }

    if (ok)
    {
        if (!Node_is_leaf(left))
        {
            /* search for pairs in this half plane */
            ok = KDTree__neighbor_search(tree, left, left_region, depth+1);
        }
        else
        {
            ok = KDTree_search_neighbors_in_bucket(tree, left);
        }
    }
    
    if (ok)
    {
        if (!Node_is_leaf(right))
        {
            /* search for pairs in this half plane */
            ok = KDTree__neighbor_search(tree, right, right_region, depth+1);
        }
        else
        {
            ok = KDTree_search_neighbors_in_bucket(tree, right);
        }
    }

    /* search for pairs between the half planes */
    if (ok)
    {
        ok = KDTree_neighbor_search_pairs(tree, left, left_region, right, right_region, depth+1);
    }

    /* cleanup */
    Region_destroy(left_region);
    Region_destroy(right_region);

    return ok;
}
Esempio n. 9
0
static int KDTree_neighbor_search_pairs(struct KDTree* tree, struct Node *down, struct Region *down_region, struct Node *up, struct Region *up_region, int depth)
{
    int down_is_leaf, up_is_leaf;
    int localdim;
    int ok = 1;

    /* if regions do not overlap - STOP */
    if (!down || !up || !down_region || !up_region) 
    {
        /* STOP */
        return ok;
    }
    
    if (Region_test_intersection(down_region, up_region, tree->_neighbor_radius)==0)
    {
        /* regions cannot contain neighbors */
        return ok;
    }

    /* dim */
    localdim=depth%tree->dim;

    /* are they leaves? */
    up_is_leaf=Node_is_leaf(up);
    down_is_leaf=Node_is_leaf(down);

    if (up_is_leaf && down_is_leaf)
    {
        /* two leaf nodes */
        ok = KDTree_search_neighbors_between_buckets(tree, down, up);
    }
    else
    {
        /* one or no leaf nodes */

        struct Node *up_right, *up_left, *down_left, *down_right;
        struct Region *up_left_region = NULL;
        struct Region *up_right_region = NULL;
        struct Region *down_left_region = NULL;
        struct Region *down_right_region = NULL;  
        
        if (down_is_leaf)
        {
            down_left=down;
            /* make a copy of down_region */
            down_left_region= Region_create(down_region->_left, down_region->_right);
            if (down_left_region==NULL) ok = 0;
            down_right=NULL;
            down_right_region=NULL;
        }
        else
        {
            float cut_value;
            int intersect;

            cut_value=down->_cut_value;

            down_left=down->_left;
            down_right=down->_right;
            intersect=Region_test_intersect_left(down_region, cut_value, localdim);

            if(intersect==1)
            {
                down_left_region = Region_create(down_region->_left, down_region->_right);
                if (down_left_region==NULL) ok = 0;
            }
            else if(intersect==0)
            {
                down_left_region = Region_create_intersect_left(down_region, cut_value, localdim);
                if (down_left_region==NULL) ok = 0;
            }
            else if(intersect==-1)
            /* intersect is -1 if no overlap */
            {
                down_left_region = NULL;
            }

            intersect=Region_test_intersect_right(down_region, cut_value, localdim); 
            if(intersect==-1)
            {
                down_right_region = Region_create(down_region->_left, down_region->_right);
                if (down_right_region==NULL) ok = 0;
            }
            else if(intersect==0)
            {
                down_right_region = Region_create_intersect_right(down_region, cut_value, localdim);
                if (down_right_region==NULL) ok = 0;
            }
            else if(intersect==+1)
            {
                down_right_region = NULL;
            }
        }

        if (up_is_leaf)
        {
            up_left=up;
            /* make a copy of up_region */
            up_left_region= Region_create(up_region->_left, up_region->_right);
            if (up_left_region==NULL) ok = 0;
            up_right=NULL;
            up_right_region=NULL;
        }
        else
        {
            float cut_value;
            int intersect;

            cut_value=up->_cut_value;

            up_left=up->_left;
            up_right=up->_right;
            intersect=Region_test_intersect_left(up_region, cut_value, localdim);

            if(intersect==1)
            {
                up_left_region = Region_create(up_region->_left, up_region->_right);
                if (up_left_region==NULL) ok = 0;
            }
            else if(intersect==0)
            {
                up_left_region = Region_create_intersect_left(up_region, cut_value, localdim);
                if (up_left_region==NULL) ok = 0;
            }
            else if(intersect==-1)
            /* intersect is -1 if no overlap */
            {
                up_left_region = NULL;
            }

            intersect=Region_test_intersect_right(up_region, cut_value, localdim);
            if(intersect==-1)
            {
                up_right_region = Region_create(up_region->_left, up_region->_right);
                if (up_right_region==NULL) ok = 0;
            }
            else if(intersect==0)
            {
                up_right_region = Region_create_intersect_right(up_region, cut_value, localdim);
                if (up_right_region==NULL) ok = 0;
            }
            else if(intersect==+1)
            /* intersect is +1 if no overlap */
            {
                up_right_region = NULL;
            }
        }

        if (ok)
            ok = KDTree_neighbor_search_pairs(tree, up_left, up_left_region, down_left, down_left_region, depth+1);
        if (ok)
            ok = KDTree_neighbor_search_pairs(tree, up_left, up_left_region, down_right, down_right_region, depth+1);
        if (ok)
            ok = KDTree_neighbor_search_pairs(tree, up_right, up_right_region, down_left, down_left_region, depth+1);
        if (ok)
            ok = KDTree_neighbor_search_pairs(tree, up_right, up_right_region, down_right, down_right_region, depth+1);

        Region_destroy(down_left_region);
        Region_destroy(down_right_region);
        Region_destroy(up_left_region);
        Region_destroy(up_right_region);
    }
    return ok;
}
Esempio n. 10
0
static int KDTree_search(struct KDTree* tree, struct Region *region, struct Node *node, int depth)
{
    int current_dim;
    int ok = 1;

    if(depth==0)
    {
        /* start with [-INF, INF] region */
        
        region = Region_create(NULL, NULL);
        if (region==NULL) return 0;

        /* start with root node */
        node=tree->_root;
    }

    current_dim=depth%tree->dim;

    if(Node_is_leaf(node))
    {
        long int i;

        for (i=node->_start; i<node->_end; i++)
        {
            struct DataPoint data_point;

            data_point=tree->_data_point_list[i];

            if (Region_encloses(tree->_query_region, data_point._coord))
            {
                /* point is enclosed in query region - report & stop */
                ok = KDTree_report_point(tree, data_point._index, data_point._coord);
            }
        }
    }
    else
    {
        struct Node *left_node, *right_node;
        struct Region *left_region, *right_region;
        int intersect_left, intersect_right;

        left_node=node->_left;

        /* LEFT HALF PLANE */

        /* new region */
        intersect_left=Region_test_intersect_left(region, node->_cut_value, current_dim);

        if(intersect_left==1)
        {
            left_region = Region_create(region->_left, region->_right);
            if (left_region)
                ok = KDTree_test_region(tree, left_node, left_region, depth);
            else
                ok = 0;
        }
        else if (intersect_left==0)
        {
            left_region = Region_create_intersect_left(region, node->_cut_value, current_dim);
            if (left_region)
                ok = KDTree_test_region(tree, left_node, left_region, depth);
            else
                ok = 0;
        }
        /* intersect_left is -1 if no overlap */

        /* RIGHT HALF PLANE */

        right_node=node->_right;

        /* new region */
        intersect_right=Region_test_intersect_right(region, node->_cut_value, current_dim);
        if (intersect_right==-1)
        {
            right_region = Region_create(region->_left, region->_right);
            /* test for overlap/inside/outside & do recursion/report/stop */
            if (right_region)
                ok = KDTree_test_region(tree, right_node, right_region, depth);
            else
                ok = 0;
        }
        else if (intersect_right==0)
        {
            right_region = Region_create_intersect_right(region, node->_cut_value, current_dim);
            /* test for overlap/inside/outside & do recursion/report/stop */
            if (right_region)
                ok = KDTree_test_region(tree, right_node, right_region, depth);
            else
                ok = 0;
        }
        /* intersect_right is +1 if no overlap */
    }

    Region_destroy(region);
    return ok;
}
Esempio n. 11
0
Region *Region_copy(Region *region) {
    g_assert(region);
    return Region_create(region->query_start, region->target_start,
                         region->query_length, region->target_length);
}