开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
utils.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：33k
源码类别：

生物技术

开发平台：

C/C++

utils.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: utils.cpp,v $
  4.  * PRODUCTION Revision 1000.0  2004/06/01 21:21:32  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.7
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: utils.cpp,v 1000.0 2004/06/01 21:21:32 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Mike DiCuccio
  36.  *
  37.  * File Description:
  38.  *    General utility classes for GUI projects.
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <gui/objutils/utils.hpp>
  43. #include <gui/objutils/label.hpp>
  44. #include <gui/objutils/prot_product.hpp>
  45. #include <gui/objutils/alignment.hpp>
  46. #include <gui/objutils/graph.hpp>
  47. #include <gui/objutils/alignment_smear_layout.hpp>
  48. #include <gui/objutils/mate_pair.hpp>
  49. #include <gui/objutils/prot_product.hpp>
  50. #include <gui/objutils/graph.hpp>
  52. #include <algorithm>
  54. #include <objects/seqloc/Seq_loc.hpp>
  55. #include <objects/seqloc/Seq_interval.hpp>
  56. #include <objects/seq/Bioseq.hpp>
  57. #include <objects/seq/Seq_inst.hpp>
  58. #include <objects/seqset/Seq_entry.hpp>
  60. #include <objects/seqalign/Score.hpp>
  61. #include <objects/seqloc/Seq_loc.hpp>
  62. #include <objects/seqloc/Seq_loc_mix.hpp>
  63. #include <objects/seqloc/Seq_point.hpp>
  64. #include <objects/seqloc/Seq_interval.hpp>
  65. #include <objects/seqloc/Packed_seqint.hpp>
  66. #include <objects/seqloc/Packed_seqpnt.hpp>
  67. #include <objects/seqloc/Seq_bond.hpp>
  68. #include <objects/general/Int_fuzz.hpp>
  69. #include <objects/general/Dbtag.hpp>
  70. #include <objects/general/Object_id.hpp>
  72. #include <objmgr/align_ci.hpp>
  73. #include <objmgr/annot_ci.hpp>
  74. #include <objmgr/graph_ci.hpp>
  75. #include <objmgr/feat_ci.hpp>
  76. #include <objmgr/scope.hpp>
  77. #include <objmgr/util/feature.hpp>
  78. #include <objmgr/util/sequence.hpp>
  80. #include <objtools/alnmgr/alnmix.hpp>
  82. #include <serial/iterator.hpp>
  85. BEGIN_NCBI_SCOPE
  86. USING_SCOPE(objects);
  88. //
  89. // functor for sorting features based on their length
  90. //
  91. struct SFeatLengthPredicate
  92. {
  93.     bool operator()(const CMappedFeat& feat0,
  94.                     const CMappedFeat& feat1) const
  95.     {
  96.         TSeqRange r0 = feat0.GetLocation().GetTotalRange();
  97.         TSeqRange r1 = feat1.GetLocation().GetTotalRange();
  98.         return (r0.GetLength() < r1.GetLength());
  99.     }
  100. };
  103. //
  104. // functor for sorting features based on the NCBI feature sort order
  105. //
  106. struct SFeatSortPredicate
  107. {
  108.     bool operator()(const CMappedFeat& feat0,
  109.                     const CMappedFeat& feat1) const
  110.     {
  111.         const CSeq_feat& f0 = feat0.GetOriginalFeature();
  112.         const CSeq_feat& f1 = feat1.GetOriginalFeature();
  113.         return (f0.Compare(f1, feat0.GetLocation(), feat1.GetLocation()) < 0);
  114.     }
  115. };
  118. //
  119. // retrieve an annot selector
  120. //
  121. SAnnotSelector CSeqUtils::GetAnnotSelector(void)
  122. {
  123.     SAnnotSelector sel;
  124.     sel
  125.         // consider overlaps by total range...
  126.         .SetOverlapTotalRange()
  127.         // resolve all segments...
  128.         .SetResolveAll()
  129.         // make sure we see all named annots (except SNPs)
  130.         .ExcludeNamedAnnots("SNP")
  131.         // stop at the first set of whatever
  132.         .SetAdaptiveDepth(true)
  133.         // stop at the first set of whatever
  134.         .SetSegmentSelectFirst();
  135.     return sel;
  136. }
  139. //
  140. // retrieve an annot selector for our selected annotations
  141. //
  142. SAnnotSelector CSeqUtils::GetAnnotSelector(SAnnotSelector::TAnnotType c)
  143. {
  144.     SAnnotSelector sel = GetAnnotSelector();
  145.     sel
  146.         // limit by our annotation type
  147.         .SetAnnotType(c);
  148.     return sel;
  149. }
  152. //
  153. // retrieve an annot selector for our selected annotations
  154. //
  155. SAnnotSelector CSeqUtils::GetAnnotSelector(SAnnotSelector::TFeatType  feat)
  156. {
  157.     SAnnotSelector sel = GetAnnotSelector(CSeq_annot::TData::e_Ftable);
  158.     sel
  159.         // retrieve feature type and subtype of interest
  160.         .SetFeatType(feat);
  162.     return sel;
  163. }
  166. SAnnotSelector CSeqUtils::GetAnnotSelector(SAnnotSelector::TFeatSubtype sub)
  167. {
  168.     SAnnotSelector sel = GetAnnotSelector(CSeq_annot::TData::e_Ftable);
  169.     sel
  170.         // retrieve feature type and subtype of interest
  171.         .SetFeatSubtype(sub);
  173.     return sel;
  174. }
  177. //
  178. // GetLandmarkFeatures()
  179. // This returns a list of landmark features for a given sequence.  The current
  180. // implementation is a bit hackish; this function is mostly a hook and will be
  181. // replaced in ID2 by a retrieval for a specific named annotation that
  182. // contains precalculated landmark features
  183. //
  184. void CSeqUtils::GetLandmarkFeatures(const CBioseq_Handle&  handle,
  185.                                     const TSeqRange&          range,
  186.                                     size_t                 max_feats,
  187.                                     CLayoutFeat::TFeatList&   feats)
  188. {
  189.     // begin with all gene features
  190.     SAnnotSelector sel = GetAnnotSelector(CSeqFeatData::e_Gene);
  191.     //SetResolveDepth(handle, range, sel);
  193.     // retrieve all of our genes
  194.     CFeat_CI iter(handle, range.GetFrom(), range.GetTo(), sel);
  195.     if (iter.GetSize() < max_feats) {
  196.         // retrieve them all
  197.         for ( ;  iter;  ++iter) {
  198.             CRef<CLayoutFeat> ref(new CLayoutFeat(*iter));
  199.             feats.push_back(ref);
  200.         }
  201.     } else {
  202.         // we do some screening - separate hypothetical and actual
  203.         vector<CMappedFeat> hyp_feats;
  204.         vector<CMappedFeat> act_feats;
  206.         // preallocate a rough approximation of the right amount of space
  207.         hyp_feats.reserve(iter.GetSize() / 2);
  208.         act_feats.reserve(iter.GetSize() / 2);
  210.         string str;
  211.         // sift through our features, separating hypothetical from
  212.         // real
  213.         for ( ;  iter;  ++iter) {
  214.             str.erase();
  215.             feature::GetLabel(iter->GetOriginalFeature(),
  216.                               &str, feature::eContent);
  218.             // hypothetical is defined as having a gene name like
  219.             // 'LOC123456'
  220.             if (str.find("LOC") == 0  &&
  221.                 str.find_first_not_of("0123456789", 3) == string::npos) {
  222.                 hyp_feats.push_back(*iter);
  223.             } else {
  224.                 act_feats.push_back(*iter);
  225.             }
  226.         }
  228.         if (act_feats.size() < max_feats) {
  229.             // we need to add some hypothetical genes to the pool
  230.             std::sort(hyp_feats.begin(), hyp_feats.end(),
  231.                       SFeatLengthPredicate());
  232.             act_feats.insert(act_feats.end(),
  233.                              hyp_feats.end() - (max_feats - act_feats.size()),
  234.                              hyp_feats.end());
  236.             std::sort(act_feats.begin(), act_feats.end(),
  237.                       SFeatSortPredicate());
  238.         } else if (act_feats.size() > max_feats) {
  239.             // we have too many genes, so eliminate the short ones
  240.             std::sort(act_feats.begin(), act_feats.end(),
  241.                       SFeatLengthPredicate());
  242.             act_feats.erase(act_feats.begin(),
  243.                 act_feats.begin() + (act_feats.size() - max_feats));
  245.             std::sort(act_feats.begin(), act_feats.end(),
  246.                       SFeatSortPredicate());
  247.         }
  249.         //
  250.         // now we've got enough genes
  251.         //
  252.         ITERATE (vector<CMappedFeat>, iter, act_feats) {
  253.             CRef<CLayoutFeat> ref(new CLayoutFeat(*iter));
  254.             feats.push_back(ref);
  255.         }
  256.     }
  257. }
  260. //
  261. // GetFeatures()
  262. // this retrieves and cross-links a set of features from the document
  263. // representing the basic molecular biology pathway.  This will detail the
  264. // relationship between genes <-> rnas <-> coding regions <-> proteins, where
  265. // known.
  266. //
  267. void CSeqUtils::GetFeatures(const CBioseq_Handle&   handle,
  268.                             const TSeqRange&        range,
  269.                             CSeqFeatData::E_Choice  feat_type,
  270.                             CLayoutFeat::TFeatList& feats,
  271.                             TFeatureFlags           flags)
  272. {
  273.     SAnnotSelector selector = GetAnnotSelector(feat_type);
  274.     GetFeatures(handle, range, selector, feats, flags);
  275. }
  278. void CSeqUtils::GetFeatures(const CBioseq_Handle&   handle,
  279.                             const TSeqRange&        range,
  280.                             SAnnotSelector          sel,
  281.                             CLayoutFeat::TFeatList& feats,
  282.                             TFeatureFlags           flags)
  283. {
  284.     feats.clear();
  285.     if ( !handle ) {
  286.         return;
  287.     }
  289.     CFeat_CI feature_iter(handle, range.GetFrom(), range.GetTo(), sel);
  290.     feats.clear();
  291.     feats.reserve(feature_iter.GetSize());
  292.     for (;  feature_iter ;  ++feature_iter) {
  293.         const CMappedFeat& feat = *feature_iter;
  294.         CRef<CLayoutFeat> fref(new CLayoutFeat(feat));
  295.         feats.push_back(fref);
  296.     }
  298.     if (flags & fFeature_LinkFeatures) {
  299.         LinkFeatures(feats);
  300.     }
  301. }
  304. //
  305. // LinkFeatures()
  306. // This builds explicit links between features, creating a hierarchical tree of
  307. // features.
  308. //
  309. void CSeqUtils::LinkFeatures(CLayoutFeat::TFeatList& feats)
  310. {
  311.     CLayoutFeat::TFeatList out_feats;
  312.     out_feats.reserve(feats.size());
  314.     NON_CONST_ITERATE (CLayoutFeat::TFeatList, iter, feats) {
  316.         CLayoutFeat&        feat = **iter;
  318.         string label;
  319.         feature::GetLabel(feat.GetFeature(), &label, feature::eBoth);
  321.         CSeqFeatData::ESubtype parent_type = CSeqFeatData::eSubtype_bad;
  322.         switch (feat.GetFeature().GetData().GetSubtype()) {
  323.         case CSeqFeatData::eSubtype_cdregion:
  324.             if (dynamic_cast<const CLayoutProtProd*> (&feat)) {
  325.                 // search for preceding CDS for this protein product
  326.                 parent_type = CSeqFeatData::eSubtype_cdregion;
  327.             } else {
  328.                 // search for preceding mRNA
  329.                 parent_type = CSeqFeatData::eSubtype_mRNA;
  330.             }
  331.             break;
  333.         case CSeqFeatData::eSubtype_gene:
  334.             // don't link
  335.             out_feats.push_back(*iter);
  336.             continue;
  338.         case CSeqFeatData::eSubtype_mRNA:
  339.             parent_type = CSeqFeatData::eSubtype_gene;
  340.             break;
  342.         default:
  343.             // don't link
  344.             out_feats.push_back(*iter);
  345.             continue;
  346.         }
  348.         //
  349.         // find the suitable pool of features we can look at
  350.         //
  352.         bool linked = false;
  353.         CLayoutFeat::TFeatList::reverse_iterator start(iter);
  354.         CLayoutFeat::TFeatList::reverse_iterator end  (feats.begin());
  355.         for ( ;  start != end;  ++start) {
  356.             CLayoutFeat& curr = **start;
  358.             // only link features if they live in the same annotation
  359.             if (curr.GetMappedFeature().GetAnnot().IsNamed()  &&
  360.                 feat.GetMappedFeature().GetAnnot().IsNamed()  &&
  361.                 curr.GetMappedFeature().GetAnnot().GetName() !=
  362.                 feat.GetMappedFeature().GetAnnot().GetName()) {
  363.                 continue;
  364.             }
  366.             // make sure we're looking at the right parent type
  367.             CSeqFeatData::ESubtype type =
  368.                 curr.GetFeature().GetData().GetSubtype();
  369.             if (type != parent_type) {
  370.                 continue;
  371.             }
  373.             // an mRNA can have only one child bound to it
  374.             if (type == CSeqFeatData::eSubtype_mRNA  &&
  375.                 curr.GetChildren().size() >= 1) {
  376.                 continue;
  377.             }
  379.             // only link features if their locations are swallowable
  380.             sequence::ECompare comp =
  381.                 sequence::Compare(curr.GetLocation(), feat.GetLocation());
  382.             if (comp != sequence::eContains  &&  comp != sequence::eSame) {
  383.                 continue;
  384.             }
  386.             feat.SetParent(&curr);
  387.             curr.SetChildren().push_back(*iter);
  388.             linked = true;
  389.             break;
  390.         }
  392.         if ( !linked ) {
  393.             out_feats.push_back(*iter);
  394.         }
  395.     }
  397.     out_feats.swap(feats);
  398. }
  401. //
  402. // GetAlignments()
  403. // this retrieves the of alignments in a document by annotation
  404. // as a set of smears.
  405. //
  406. void CSeqUtils::GetAlignmentSmears(const CBioseq_Handle&    handle,
  407.                                    const TSeqRange&         range,
  408.                                    TSeqPos                  window,
  409.                                    CLayoutEngine::TObjects& aligns)
  410. {
  411.     aligns.clear();
  412.     if ( !handle ) {
  413.         return;
  414.     }
  416.     SAnnotSelector sel_annot;
  417.     CAnnot_CI   annot_iter(handle, range.GetFrom(), range.GetTo(), sel_annot);
  418.     
  419.     for (int an_i = 0;  annot_iter;  ++annot_iter, ++an_i)  {
  420.     
  421.         // TODO: remember the annotation's name. That is the smear's label.
  422.         if (annot_iter->IsNamed()) {
  423.             // cout << an_i << " Named: " << annot_iter->GetName() << endl;
  424.         } else {
  425.             // cout << an_i << " Unnamed: " << endl;
  426.         }
  427.         
  428.         const CSeq_annot& seq_annot = annot_iter->GetSeq_annot();
  429.         if ( ! seq_annot.GetData().IsAlign()) {
  430.             continue;
  431.         }
  432.         
  433.         
  434.         CRef<CLayoutObject> ref;
  436.         if (CAlignmentSmear::SeparateStrands(seq_annot)) {
  437.             ref.Reset(new CLayoutAlignSmear(handle,
  438.                                             range.GetFrom(), range.GetTo(), 
  439.                                             window,
  440.                                             CAlignmentSmear::eSmearStrand_Pos,
  441.                                             seq_annot));
  442.             if (ref) {
  443.                 aligns.push_back(ref);
  444.             }
  445.             ref.Reset(new CLayoutAlignSmear(handle,
  446.                                             range.GetFrom(), range.GetTo(), 
  447.                                             window,
  448.                                             CAlignmentSmear::eSmearStrand_Neg,
  449.                                             seq_annot));
  450.             if (ref) {
  451.                 aligns.push_back(ref);
  452.             }
  453.         } else {
  454.             ref.Reset(new CLayoutAlignSmear(handle,
  455.                                             range.GetFrom(), range.GetTo(), 
  456.                                             window,
  457.                                             CAlignmentSmear::eSmearStrand_Both,
  458.                                             seq_annot));
  459.             if (ref) {
  460.                 aligns.push_back(ref);
  461.             }
  462.         }
  463.     }
  464. }
  467. static bool
  468. s_CheckTraceMateAlign(const CSeq_align& align,
  469.                       int& ti,
  470.                       int& mate_ti,
  471.                       int expect_mate_ti = 0)
  472. {
  473.     //
  474.     // specific requirements for mate pair alignments:
  475.     //
  477.     // must be a pairwise dense-seg
  478.     if ( !align.GetSegs().IsDenseg()  ||
  479.          align.GetSegs().GetDenseg().GetIds().size() != 2) {
  480.         return false;
  481.     }
  483.     // check the IDs for a trace ID
  484.     ti = 0;
  485.     ITERATE (CDense_seg::TIds, iter,
  486.              align.GetSegs().GetDenseg().GetIds()) {
  487.         const CSeq_id& id = **iter;
  488.         if (id.IsGeneral()  &&
  489.             (id.GetGeneral().GetDb() == "ti"  ||
  490.             id.GetGeneral().GetDb() == "TRACE")) {
  491.             ti = id.GetGeneral().GetTag().GetId();
  492.             break;
  493.         }
  494.     }
  496.     if (ti == 0) {
  497.         return false;
  498.     }
  500.     // must have a score field named 'matepair_ti'
  501.     mate_ti = 0;
  502.     if ( !align.GetNamedScore("matepair ti", mate_ti)) {
  503.         if ( !align.GetNamedScore("bad matepair ti", mate_ti)) {
  504.             return false;
  505.         }
  506.     }
  508.     if (expect_mate_ti  &&  mate_ti != expect_mate_ti) {
  509.         return false;
  510.     }
  512.     return true;
  513. }
  516. //
  517. // GetAlignments()
  518. // this retrieves a set of alignments from the document
  519. //
  520. void CSeqUtils::GetAlignments(const CBioseq_Handle&    handle,
  521.                               const TSeqRange&         range,
  522.                               CLayoutEngine::TObjects& aligns,
  523.                               TAlignFlags flags)
  524. {
  525.     aligns.clear();
  526.     if ( !handle ) {
  527.         return;
  528.     }
  530.     SAnnotSelector selector = GetAnnotSelector(CSeq_annot::TData::e_Align);
  531.     CAlign_CI align_iter(handle, range.GetFrom(), range.GetTo(), selector);
  533.     typedef pair<CRef<CLayoutPWAlign> , int> TMatedAlign;
  534.     typedef map<int, TMatedAlign> TMatedAlignments;
  535.     TMatedAlignments mated_aligns;
  537.     for (;  align_iter ;  ++align_iter) {
  538.         const CSeq_align& align = *align_iter;
  540.         try {
  542.             // generate an alignment manager for this alignment
  543.             CRef<CAlnVec> aln_mgr;
  544.             if (align.GetSegs().IsDenseg()) {
  545.                 aln_mgr.Reset(new CAlnVec(align.GetSegs().GetDenseg(),
  546.                                           handle.GetScope()));
  547.             } else {
  548.                 CAlnMix mix(handle.GetScope());
  549.                 mix.Add(align);
  550.                 mix.Merge(CAlnMix::fGen2EST |
  551.                           CAlnMix::fTryOtherMethodOnFail |
  552.                           CAlnMix::fGapJoin);
  554.                 aln_mgr.Reset(new CAlnVec(mix.GetDenseg(), handle.GetScope()));
  555.             }
  557.             // anchor on the referent sequence
  558.             CAlnVec::TNumrow row = 0;
  559.             CAlnVec::TNumrow anchor = 0;
  560.             for (row = 0;  row != aln_mgr->GetNumRows();  ++row) {
  561.                 if ( handle.IsSynonym(aln_mgr->GetSeqId(row)) ) {
  562.                     aln_mgr->SetAnchor(row);
  563.                     anchor = row;
  564.                     break;
  565.                 }
  566.             }
  568.             //
  569.             // check to see if this is a mate pair alignment
  570.             //
  571.             int ti = 0;
  572.             int mate_ti = 0;
  573.             if ( s_CheckTraceMateAlign(align, ti, mate_ti) ) {
  574.                 CRef<CLayoutPWAlign> pwal
  575.                     (new CLayoutPWAlign(*aln_mgr, align));
  576.                 if (flags & fAlign_LinkMatePairs) {
  577.                     // we will process mate mair alignments in a separate pass
  578.                     // after we complete all other alignments
  579.                     TMatedAlign mp(pwal, mate_ti);
  580.                     mated_aligns[ti] = mp;
  581.                 } else {
  582.                     CLayoutMatePair::TAlignList als;
  583.                     als.push_back(pwal);
  584.                     CRef<CLayoutObject> obj(new CLayoutMatePair(als));
  585.                     aligns.push_back(obj);
  586.                 }
  587.             } else {
  588.                 // "normal" alignment
  589.                 CRef<CLayoutObject> ref;
  590.                 if (aln_mgr->GetNumRows() == 2) {
  591.                     ref.Reset(new CLayoutPWAlign(*aln_mgr, align));
  592.                 } else {
  593.                     ref.Reset(new CLayoutAlign(*aln_mgr, align));
  594.                 }
  595.                 aligns.push_back(ref);
  596.             }
  597.         }
  598.         catch (CException& e) {
  599.             // errors ignored
  600.             _TRACE("error in GetAlignments(): " << e.GetMsg());
  601.         }
  602.     }
  604.     //
  605.     // final pass - connect our mate pair alignments, if we can
  606.     //
  607.     NON_CONST_ITERATE (TMatedAlignments, iter, mated_aligns) {
  608.         if ( !iter->second.first ) {
  609.             continue;
  610.         }
  612.         CLayoutPWAlign& first_mate    = *iter->second.first;
  613.         const CSeq_align&     align   = first_mate.GetAlignment();
  614.         int                   ti      = iter->first;
  615.         int                   mate_ti = iter->second.second;
  617.         //
  618.         // verify that we have a mated alignment for this trace alignment
  619.         //
  620.         CRef<CLayoutPWAlign> second_mate;
  621.         TMatedAlignments::iterator mate_iter = mated_aligns.find(mate_ti);
  622.         if (mate_iter == mated_aligns.end()) {
  623.             //
  624.             // NOT FOUND
  625.             // try iterating
  626.             //
  627.             CSeq_id id("gnl|ti|" + NStr::IntToString(mate_ti));
  628.             CBioseq_Handle h = 
  629.                 handle.GetScope().GetBioseqHandle(id);
  630.             CAlign_CI second_mate_iter(h, 0, h.GetBioseqLength(),
  631.                                        selector);
  632.             for ( ;  second_mate_iter;  ++second_mate_iter) {
  633.                 int temp = 0;
  634.                 if ( !s_CheckTraceMateAlign(*second_mate_iter, temp,
  635.                                             mate_ti, ti) ) {
  636.                     continue;
  637.                 }
  639.                 CRef<CAlnVec> aln_mgr(new CAlnVec(align.GetSegs().GetDenseg(),
  640.                                                   handle.GetScope()));
  642.                 // anchor on the referent sequence
  643.                 CAlnVec::TNumrow row = 0;
  644.                 CAlnVec::TNumrow anchor = 0;
  645.                 for (row = 0;  row != aln_mgr->GetNumRows();  ++row) {
  646.                     if ( handle.IsSynonym(aln_mgr->GetSeqId(row)) ) {
  647.                         aln_mgr->SetAnchor(row);
  648.                         anchor = row;
  649.                         break;
  650.                     }
  651.                 }
  653.                 second_mate.Reset(new CLayoutPWAlign(*aln_mgr, align));
  654.                 break;
  655.             }
  657.             if ( !second_mate ) {
  658.                 LOG_POST(Error << "failed to find mate pair for ti = " << ti);
  660.                 // no mate available, so treat it as a normal alignment
  661.                 // we need to trim leading and trailing gaps to get a good
  662.                 // placement
  663.                 CRef<CLayoutObject> ref
  664.                     (new CLayoutPWAlign(first_mate.GetAlignMgr(), align));
  665.                 aligns.push_back(ref);
  666.                 continue;
  667.             }
  668.         } else if ( !mate_iter->second.first ) {
  669.             // already processed
  670.             continue;
  671.         } else {
  672.             second_mate = mate_iter->second.first;
  673.             mate_iter->second.first.Reset();
  674.         }
  676.         CLayoutMatePair::TAlignList als;
  677.         als.push_back(CRef<CLayoutPWAlign>(&first_mate));
  678.         als.push_back(second_mate);
  679.         CRef<CLayoutObject> obj(new CLayoutMatePair(als));
  680.         aligns.push_back(obj);
  681.     }
  683.     {//if (mated_aligns.size()) {
  684.         vector< CRef<CLayoutObject> > vec;
  685.         vec.reserve(aligns.size());
  686.         std::copy(aligns.begin(), aligns.end(), back_inserter(vec));
  688.         // we need to sort our alignments when done
  689.         std::sort(vec.begin(), vec.end(), SLayoutByPos());
  691.         aligns.clear();
  692.         std::copy(vec.begin(), vec.end(), back_inserter(aligns));
  693.     }
  694. }
  698. void CSeqUtils::GetGraphs(const CBioseq_Handle&  handle,
  699.                           const TSeqRange&          range,
  700.                           CLayoutEngine::TObjects& graphs)
  701. {
  702.     graphs.clear();
  703.     if ( !handle ) {
  704.         return;
  705.     }
  707.     SAnnotSelector selector = GetAnnotSelector(CSeq_annot::TData::e_Graph);
  708.     
  709.     CGraph_CI graph_iter(handle, range.GetFrom(), range.GetTo(), selector);
  710.     for (;  graph_iter ;  ++graph_iter) {
  711.         const CMappedGraph& graph = *graph_iter;
  712.         CRef<CLayoutObject> fref(new CLayoutGraph(graph));
  713.         graphs.push_back(fref);
  714.     }
  715. }
  719. //
  720. // remap a child location to a parent
  721. //
  722. CRef<CSeq_loc> CSeqUtils::RemapChildToParent(const CSeq_loc& parent,
  723.                                              const CSeq_loc& child,
  724.                                              CScope* scope)
  725. {
  726.     CSeq_loc dummy_parent;
  727.     dummy_parent.SetWhole(const_cast<CSeq_id&>(sequence::GetId(parent)));
  728.     SRelLoc converter(dummy_parent, child, scope);
  729.     converter.m_ParentLoc = &parent;
  730.     return converter.Resolve(scope);
  731. }
  734. bool CSeqUtils::Match(const CSeq_id& id1, const CSeq_id& id2, CScope* scope)
  735. {
  736.     if (id1.Match(id2))  {
  737.         return true;
  738.     } else if (scope) {
  739.         CBioseq_Handle handle = scope->GetBioseqHandle(id1);
  740.         if (handle)  {
  741.             return handle.IsSynonym(id2);
  742.         }
  743.     }
  744.     return false;
  745. }
  748. END_NCBI_SCOPE
  751. /*
  752.  * ===========================================================================
  753.  * $Log: utils.cpp,v $
  754.  * Revision 1000.0  2004/06/01 21:21:32  gouriano
  755.  * PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.7
  756.  *
  757.  * Revision 1.7  2004/05/21 22:27:44  gorelenk
  758.  * Added PCH ncbi_pch.hpp
  759.  *
  760.  * Revision 1.6  2004/05/20 12:31:16  dicuccio
  761.  * Added missing includes
  762.  *
  763.  * Revision 1.5  2004/05/14 16:08:05  dicuccio
  764.  * Added additional #includes for missing layout objects.  Restored final sort of
  765.  * seq-aligns
  766.  *
  767.  * Revision 1.4  2004/05/10 18:23:32  dicuccio
  768.  * Reworked mate pair checking routines to use GetNamedScore()
  769.  *
  770.  * Revision 1.3  2004/05/09 23:57:13  dicuccio
  771.  * Added flags controlling retrieval of alignments
  772.  *
  773.  * Revision 1.2  2004/05/07 15:39:22  dicuccio
  774.  * Removed CSeqUtils::GetLabel() - should use CLabel directly
  775.  *
  776.  * Revision 1.1  2004/04/30 11:48:16  dicuccio
  777.  * Initial commit - split out from src/gui/utils
  778.  *
  779.  * Revision 1.67  2004/04/20 19:17:55  dicuccio
  780.  * Minor revision.  Amendment to last commit:  Reworked GetLabel() to use
  781.  * pluggable label architecture
  782.  *
  783.  * Revision 1.66  2004/04/20 19:17:04  dicuccio
  784.  * Reworked GetAlignments() - added pairwise alignments, revised handing of mate
  785.  * pair alignments
  786.  *
  787.  * Revision 1.65  2004/04/15 13:00:01  lebedev
  788.  * do not use GetObject() in CLayoutObject
  789.  *
  790.  * Revision 1.64  2004/04/12 16:52:27  dicuccio
  791.  * Removed unnecessary debugging output
  792.  *
  793.  * Revision 1.63  2004/04/12 16:51:36  dicuccio
  794.  * Merged GetMatePairs() into GetAlignments()
  795.  *
  796.  * Revision 1.62  2004/04/07 13:06:56  dicuccio
  797.  * Use CSeq_annot_Handle for proper mapping of annotation names.  Split
  798.  * GetAnnotSelector() API to request feature type or subtype separately
  799.  *
  800.  * Revision 1.61  2004/04/06 19:28:34  ucko
  801.  * Tweak GetMatePairs to avoid confusing GCC.
  802.  *
  803.  * Revision 1.60  2004/04/06 18:30:05  dicuccio
  804.  * Added GetMatePairs()
  805.  *
  806.  * Revision 1.59  2004/04/02 16:13:16  yazhuk
  807.  * Added Match() function for comparing CSeq_id-s
  808.  *
  809.  * Revision 1.58  2004/03/23 13:40:57  dicuccio
  810.  * Deprecated a bunch of old conversion routines.  Moved #include from .hpp to .cpp
  811.  *
  812.  * Revision 1.57  2004/03/22 16:45:48  rsmith
  813.  * add GetAlignmentSmears and comment out obsolete code.
  814.  *
  815.  * Revision 1.56  2004/03/05 17:38:28  dicuccio
  816.  * Avoid using CAlnMix on alignments that are already only one dense-seg.
  817.  * Commented spurious pathway in s_GetSeqLabel()
  818.  *
  819.  * Revision 1.55  2004/03/01 20:10:29  dicuccio
  820.  * Fixed incorrect assignment of parent features
  821.  *
  822.  * Revision 1.54  2004/02/17 17:21:04  dicuccio
  823.  * Added handling of flags to GetFeatures()
  824.  *
  825.  * Revision 1.53  2004/02/13 21:25:04  dicuccio
  826.  * Fixed brain-dead omission of seq-id string
  827.  *
  828.  * Revision 1.52  2004/02/04 19:09:25  dicuccio
  829.  * Cleaned up LinkFeatures()
  830.  *
  831.  * Revision 1.51  2004/02/04 18:05:37  grichenk
  832.  * Added annotation filtering by set of types/subtypes.
  833.  * Renamed *Choice to *Type in SAnnotSelector.
  834.  *
  835.  * Revision 1.50  2004/01/30 17:14:13  dicuccio
  836.  * Moved GetLabel() from CPluginUtils
  837.  *
  838.  * Revision 1.49  2004/01/27 18:47:41  dicuccio
  839.  * Use TSeqRange instead of TRange.  Fixed computation of covered range of an
  840.  * alignment.  Added work-around for unsorted alignments from CAlign_CI
  841.  *
  842.  * Revision 1.48  2004/01/20 18:19:31  dicuccio
  843.  * Handle alignments more effectively - don't assume they're always dense-segs
  844.  *
  845.  * Revision 1.47  2004/01/05 19:12:52  dicuccio
  846.  * Restrict feature linking to features living in the same annotation.  Dropped
  847.  * unnecessary CAlnMix calls.
  848.  *
  849.  * Revision 1.46  2003/12/30 15:04:25  dicuccio
  850.  * Remove SNP removal (still too slow...)
  851.  *
  852.  * Revision 1.45  2003/12/22 19:36:48  dicuccio
  853.  * Turned on SNP retrieval
  854.  *
  855.  * Revision 1.44  2003/11/10 15:48:36  lebedev
  856.  * Typo fixed in GetGraphs (e_Graph instead of e_Align)
  857.  *
  858.  * Revision 1.43  2003/10/28 15:24:06  lebedev
  859.  * GetFeatures method that takes a selector added
  860.  *
  861.  * Revision 1.42  2003/10/22 15:40:57  dicuccio
  862.  * Added API to create a dummy seq-entry to wrap a seq-annot
  863.  *
  864.  * Revision 1.41  2003/10/20 18:04:35  dicuccio
  865.  * Disabled SNP retrieval
  866.  *
  867.  * Revision 1.40  2003/10/14 14:44:12  dicuccio
  868.  * Reimplemented RemapChildToParent() using SRelLoc internally
  869.  *
  870.  * Revision 1.39  2003/10/14 12:20:13  dicuccio
  871.  * Added RemapChildToParent() for remapping locations
  872.  *
  873.  * Revision 1.38  2003/10/10 17:21:02  dicuccio
  874.  * Commented out addition of SNP annot to named annots
  875.  *
  876.  * Revision 1.37  2003/10/10 12:02:51  dicuccio
  877.  * Fix for recent API change in SAnnotSelector
  878.  *
  879.  * Revision 1.36  2003/10/09 12:57:37  dicuccio
  880.  * Mkae sure we always iterate over all annotations, named or otherwise.
  881.  *
  882.  * Revision 1.35  2003/10/08 14:16:39  dicuccio
  883.  * Really use adaptive depth searching for annot selectors...
  884.  *
  885.  * Revision 1.34  2003/10/07 13:44:10  dicuccio
  886.  * CLeaned up preparation of alignments.  Alignments are now prepared as sets of
  887.  * separate seq-aligns, not a merged alignment (better data representation)
  888.  *
  889.  * Revision 1.33  2003/10/03 16:02:29  dicuccio
  890.  * Temporary fix: limit feature retrieval to one level of recursion
  891.  *
  892.  * Revision 1.32  2003/09/24 18:29:28  dicuccio
  893.  * Introduced additional prototype for GetAnnotSelector() - takes no params
  894.  *
  895.  * Revision 1.31  2003/09/19 00:28:59  ucko
  896.  * CLayoutAlign: use an unsigned range per CAlnMap::GetSeqRange's new rettype.
  897.  *
  898.  * Revision 1.30  2003/09/17 16:28:45  dicuccio
  899.  * Optimized and standardized use of annotation selectors.  Introduced standard
  900.  * formatting function for setting options in annot selectors; removed old depth
  901.  * setting functions in favor of explicitly setting adaptive retrieval
  902.  *
  903.  * Revision 1.29  2003/08/22 15:48:39  dicuccio
  904.  * Added 'USING_SCOPE(objects)'
  905.  *
  906.  * Revision 1.28  2003/08/21 12:04:28  dicuccio
  907.  * Rewored GetLandmarkFeatures() to return a better set of landmark genes
  908.  *
  909.  * Revision 1.27  2003/08/18 14:47:55  dicuccio
  910.  * Changed nales: CFeature -> CLayoutFeat; CAlignment -> CLayoutAlign; CGraph ->
  911.  * CLayoutGraph; CProtProduct -> CLayoutProtProd.
  912.  *
  913.  * Revision 1.26  2003/08/15 19:36:06  dicuccio
  914.  * Added SetResolveDepth() to correctly determine the depth of annotation
  915.  * resolution
  916.  *
  917.  * Revision 1.25  2003/08/12 16:48:16  dicuccio
  918.  * Disable retrieval of SNPs in all circumstances
  919.  *
  920.  * Revision 1.24  2003/07/29 13:41:07  lebedev
  921.  * GetGraphs method added
  922.  *
  923.  * Revision 1.23  2003/07/28 11:51:50  dicuccio
  924.  * Rewrote CTablePanel<> to be more flexible and better contained.  Added standard
  925.  * multicolumn list dialog.  Deprecated use of COutputDlg.
  926.  *
  927.  * Revision 1.22  2003/07/21 19:35:21  dicuccio
  928.  * Changed storage mechanism - CLayoutObject::GetObject() is now pure virtual.
  929.  * Changed CFeature to wrap a CMappedFeat instead of a CSeq_feat / CSeq_loc pair
  930.  *
  931.  * Revision 1.21  2003/07/18 13:34:53  lebedev
  932.  * Method to retrieve alignments added
  933.  *
  934.  * Revision 1.20  2003/07/08 19:00:05  dicuccio
  935.  * Added better resolution of features fr large records
  936.  *
  937.  * Revision 1.19  2003/06/23 13:23:14  dicuccio
  938.  * Deprecated seq_utils.[h,c]pp - moved functions into gui.utils/utils.hpp
  939.  *
  940.  * Revision 1.18  2003/06/13 12:38:54  dicuccio
  941.  * Fixed bugs in determination of mouse button state
  942.  *
  943.  * Revision 1.17  2003/06/10 13:35:11  dicuccio
  944.  * Added new API for retrieving landmark features.  Removed lots of dead code
  945.  *
  946.  * Revision 1.16  2003/06/02 16:06:25  dicuccio
  947.  * Rearranged src/objects/ subtree.  This includes the following shifts:
  948.  *     - src/objects/asn2asn --> arc/app/asn2asn
  949.  *     - src/objects/testmedline --> src/objects/ncbimime/test
  950.  *     - src/objects/objmgr --> src/objmgr
  951.  *     - src/objects/util --> src/objmgr/util
  952.  *     - src/objects/alnmgr --> src/objtools/alnmgr
  953.  *     - src/objects/flat --> src/objtools/flat
  954.  *     - src/objects/validator --> src/objtools/validator
  955.  *     - src/objects/cddalignview --> src/objtools/cddalignview
  956.  * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  957.  * replaces the three libmmdb? libs.
  958.  *
  959.  * Revision 1.15  2003/05/19 18:45:24  dicuccio
  960.  * Fixed bug in feature collection - forgot to pass in desired feature subtype
  961.  *
  962.  * Revision 1.14  2003/05/16 18:20:05  dicuccio
  963.  * Change mechanism of feature iteration - retrieve features from first
  964.  * available location
  965.  *
  966.  * Revision 1.13  2003/05/07 17:28:40  dicuccio
  967.  * Removed operator<< for CFeature.  Added missing link to xobjutil
  968.  *
  969.  * Revision 1.12  2003/05/07 13:07:29  dicuccio
  970.  * Code clean-up.  Removed dead functions.
  971.  *
  972.  * Revision 1.11  2003/05/07 12:34:15  dicuccio
  973.  * Removed CFeature::GetExtent()
  974.  *
  975.  * Revision 1.10  2003/03/18 21:55:24  grichenk
  976.  * Removed obsolete class CAnnot_CI
  977.  *
  978.  * Revision 1.9  2003/03/11 15:25:12  kuznets
  979.  * iterate -> ITERATE
  980.  *
  981.  * Revision 1.8  2003/02/10 18:10:59  dicuccio
  982.  * Fixed compilation errors relating to change in CFeat_CI API
  983.  *
  984.  * Revision 1.7  2003/01/15 21:15:48  dicuccio
  985.  * Rewored feature retrieval.  Added separate (explicit) call to link features
  986.  *
  987.  * Revision 1.6  2003/01/13 13:10:11  dicuccio
  988.  * Namespace clean-up.  Retired namespace gui -> converted all to namespace
  989.  * ncbi.  Moved all FLUID-generated code into namespace ncbi.
  990.  *
  991.  * Revision 1.5  2003/01/09 14:52:25  dicuccio
  992.  * Use 'const CBioseq_Handle&' instead of 'CBioseq_Handle&'
  993.  *
  994.  * Revision 1.4  2002/12/30 17:57:37  dicuccio
  995.  * Added cast to avoid compiler warning
  996.  *
  997.  * Revision 1.3  2002/12/06 19:12:44  dicuccio
  998.  * Updated to match change in API to ctor of CFeat_CI
  999.  *
  1000.  * Revision 1.2  2002/12/06 14:08:18  dicuccio
  1001.  * Moved feature sorting predicates into feature.[h,c]pp
  1002.  *
  1003.  * Revision 1.1  2002/11/29 15:30:38  dicuccio
  1004.  * Initial revision - split out from gui/core/view/graphic
  1005.  *
  1006.  * ===========================================================================
  1007.  */