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

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

生物技术

开发平台：

C/C++

alnmap.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: alnmap.hpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/04/12 17:34:39  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.35
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef OBJECTS_ALNMGR___ALNMAP__HPP
  11. #define OBJECTS_ALNMGR___ALNMAP__HPP
  13. /*  $Id: alnmap.hpp,v 1000.1 2004/04/12 17:34:39 gouriano Exp $
  14. * ===========================================================================
  15. *
  16. *                            PUBLIC DOMAIN NOTICE
  17. *               National Center for Biotechnology Information
  18. *
  19. *  This software/database is a "United States Government Work" under the
  20. *  terms of the United States Copyright Act.  It was written as part of
  21. *  the author's official duties as a United States Government employee and
  22. *  thus cannot be copyrighted.  This software/database is freely available
  23. *  to the public for use. The National Library of Medicine and the U.S.
  24. *  Government have not placed any restriction on its use or reproduction.
  25. *
  26. *  Although all reasonable efforts have been taken to ensure the accuracy
  27. *  and reliability of the software and data, the NLM and the U.S.
  28. *  Government do not and cannot warrant the performance or results that
  29. *  may be obtained by using this software or data. The NLM and the U.S.
  30. *  Government disclaim all warranties, express or implied, including
  31. *  warranties of performance, merchantability or fitness for any particular
  32. *  purpose.
  33. *
  34. *  Please cite the author in any work or product based on this material.
  35. *
  36. * ===========================================================================
  37. *
  38. * Author:  Kamen Todorov, NCBI
  39. *
  40. * File Description:
  41. *   Interface for examining alignments (of type Dense-seg)
  42. *
  43. */
  45. #include <objects/seqalign/Dense_seg.hpp>
  46. #include <objtools/alnmgr/alnexception.hpp>
  47. #include <util/range.hpp>
  49. BEGIN_NCBI_SCOPE
  50. BEGIN_objects_SCOPE // namespace ncbi::objects::
  52. class NCBI_XALNMGR_EXPORT CAlnMap : public CObject
  53. {
  54.     typedef CObject TParent;
  56. public:
  57.     // data types
  58.     typedef unsigned int TSegTypeFlags; // binary OR of ESegTypeFlags
  59.     enum ESegTypeFlags {
  60.         fSeq                     = 0x01,
  61.         fNotAlignedToSeqOnAnchor = 0x02,
  62.         fInsert                  = fSeq | fNotAlignedToSeqOnAnchor,
  63.         fUnalignedOnRight        = 0x04, // unaligned region on the right
  64.         fUnalignedOnLeft         = 0x08,
  65.         fNoSeqOnRight            = 0x10, // maybe gaps on the right but no seq
  66.         fNoSeqOnLeft             = 0x20,
  67.         fEndOnRight              = 0x40, // this is the last segment
  68.         fEndOnLeft               = 0x80,
  69.         // reserved for internal use
  70.         fTypeIsSet            = (TSegTypeFlags) 0x80000000
  71.     };
  72.     
  73.     typedef CDense_seg::TDim      TDim;
  74.     typedef TDim                  TNumrow;
  75.     typedef CRange<TSeqPos>       TRange;
  76.     typedef CRange<TSignedSeqPos> TSignedRange;
  77.     typedef CDense_seg::TNumseg   TNumseg;
  78.     typedef list<TSeqPos>         TSeqPosList;
  81.     enum EGetChunkFlags {
  82.         fAllChunks           = 0x0000,
  83.         fIgnoreUnaligned     = 0x0001,
  84.         // fInsertSameAsSeq, fDeletionSameAsGap and fIgnoreAnchor
  85.         // are used to consolidate adjacent segments which whose type
  86.         // only differs in how they relate to the anchor.
  87.         // Still, when obtaining the type of the chunks, the info about
  88.         // the relationship to anchor (fNotAlignedToSeqOnAnchor) will be
  89.         // present.
  90.         fInsertSameAsSeq     = 0x0002,
  91.         fDeletionSameAsGap   = 0x0004,
  92.         fIgnoreAnchor        = fInsertSameAsSeq | fDeletionSameAsGap,
  93.         fIgnoreGaps          = 0x0008,
  94.         fChunkSameAsSeg      = 0x0010,
  95.         
  96.         fSkipUnalignedGaps   = 0x0020,
  97.         fSkipDeletions       = 0x0040,
  98.         fSkipAllGaps         = fSkipUnalignedGaps | fSkipDeletions,
  99.         fSkipInserts         = 0x0080,
  100.         fSkipAlnSeq          = 0x0100,
  101.         fSeqOnly             = fSkipAllGaps | fSkipInserts,
  102.         fInsertsOnly         = fSkipAllGaps | fSkipAlnSeq,
  103.         fAlnSegsOnly         = fSkipInserts | fSkipUnalignedGaps,
  105.         // preserve the wholeness of the segments when intersecting
  106.         // with the given range instead of truncating them
  107.         fDoNotTruncateSegs   = 0x0200
  108.     };
  109.     typedef int TGetChunkFlags; // binary OR of EGetChunkFlags
  111.     typedef TNumseg TNumchunk;
  113.     enum ESearchDirection {
  114.         eNone,
  115.         eBackwards,
  116.         eForward,
  117.         eLeft,
  118.         eRight
  119.     };
  121.     // constructors
  122.     CAlnMap(const CDense_seg& ds);
  123.     CAlnMap(const CDense_seg& ds, TNumrow anchor);
  125.     // destructor
  126.     ~CAlnMap(void);
  128.     // Underlying Dense_seg accessor
  129.     const CDense_seg& GetDenseg(void) const;
  131.     // Dimensions
  132.     TNumseg GetNumSegs(void) const;
  133.     TDim    GetNumRows(void) const;
  135.     // Seq ids
  136.     const CSeq_id& GetSeqId(TNumrow row) const;
  138.     // Strands
  139.     bool IsPositiveStrand(TNumrow row) const;
  140.     bool IsNegativeStrand(TNumrow row) const;
  141.     int  StrandSign      (TNumrow row) const; // returns +/- 1
  143.     // Widths
  144.     int  GetWidth        (TNumrow row) const;
  146.     // Sequence visible range
  147.     TSignedSeqPos GetSeqAlnStart(TNumrow row) const; //aln coords, strand ignored
  148.     TSignedSeqPos GetSeqAlnStop (TNumrow row) const;
  149.     TSignedRange  GetSeqAlnRange(TNumrow row) const;
  150.     TSeqPos       GetSeqStart   (TNumrow row) const; //seq coords, with strand
  151.     TSeqPos       GetSeqStop    (TNumrow row) const;  
  152.     TRange        GetSeqRange   (TNumrow row) const;
  154.     // Segment info
  155.     TSignedSeqPos GetStart  (TNumrow row, TNumseg seg, int offset = 0) const;
  156.     TSignedSeqPos GetStop   (TNumrow row, TNumseg seg, int offset = 0) const;
  157.     TSignedRange  GetRange  (TNumrow row, TNumseg seg, int offset = 0) const;
  158.     TSeqPos       GetLen    (             TNumseg seg, int offset = 0) const;
  159.     TSeqPos       GetSeqLen (TNumrow row, TNumseg seg, int offset = 0) const;
  160.     TSegTypeFlags GetSegType(TNumrow row, TNumseg seg, int offset = 0) const;
  161.     
  162.     TSegTypeFlags GetTypeAtAlnPos(TNumrow row, TSeqPos aln_pos) const;
  164.     static bool IsTypeInsert(TSegTypeFlags type);
  166.     TSeqPos GetInsertedSeqLengthOnRight(TNumrow row, TNumseg seg) const;
  168.     // Alignment segments
  169.     TSeqPos GetAlnStart(TNumseg seg) const;
  170.     TSeqPos GetAlnStop (TNumseg seg) const;
  171.     TSeqPos GetAlnStart(void)        const { return 0; }
  172.     TSeqPos GetAlnStop (void)        const;
  174.     bool    IsSetAnchor(void)           const;
  175.     TNumrow GetAnchor  (void)           const;
  176.     void    SetAnchor  (TNumrow anchor);
  177.     void    UnsetAnchor(void);
  179.     // get number of
  180.     TNumseg GetNumberOfInsertedSegmentsOnRight(TNumrow row, TNumseg seg) const;
  181.     TNumseg GetNumberOfInsertedSegmentsOnLeft (TNumrow row, TNumseg seg) const;
  183.     //
  184.     // Position mapping funcitons
  185.     // 
  186.     // Note: Some of the mapping functions have optional parameters
  187.     //       ESearchDirection dir and bool try_reverse_dir 
  188.     //       which are used in case an exact match is not found.
  189.     //       If nothing is found in the ESearchDirection dir and 
  190.     //       try_reverse_dir == true will search in the opposite dir.
  192.     TNumseg       GetSeg                 (TSeqPos aln_pos)              const;
  193.     // if seq_pos falls outside the seq range or into an unaligned region
  194.     // and dir is provided, will return the first seg in according to dir
  195.     TNumseg       GetRawSeg              (TNumrow row, TSeqPos seq_pos,
  196.                                           ESearchDirection dir = eNone,
  197.                                           bool try_reverse_dir = true)  const;
  198.     // if seq_pos is outside the seq range or within an unaligned region or
  199.     // within an insert dir/try_reverse_dir will be used
  200.     TSignedSeqPos GetAlnPosFromSeqPos    (TNumrow row, TSeqPos seq_pos,
  201.                                           ESearchDirection dir = eNone,
  202.                                           bool try_reverse_dir = true)  const;
  203.     TSignedSeqPos GetSeqPosFromSeqPos    (TNumrow for_row,
  204.                                           TNumrow row, TSeqPos seq_pos) const;
  205.     // if seq pos is a gap, will use dir/try_reverse_dir
  206.     TSignedSeqPos GetSeqPosFromAlnPos    (TNumrow for_row,
  207.                                           TSeqPos aln_pos,
  208.                                           ESearchDirection dir = eNone,
  209.                                           bool try_reverse_dir = true)  const;
  210.     
  211.     // Create a vector of relative mapping positions from row0 to row1.
  212.     // Input:  row0, row1, aln_rng (vertical slice)
  213.     // Output: result (the resulting vector of positions),
  214.     //         rng0, rng1 (affected ranges in native sequence coords)
  215.     void          GetResidueIndexMap     (TNumrow row0,
  216.                                           TNumrow row1,
  217.                                           TRange aln_rng,
  218.                                           vector<TSignedSeqPos>& result,
  219.                                           TRange& rng0,
  220.                                           TRange& rng1)                 const;
  222.     // AlnChunks -- declared here for access to typedefs
  223.     class CAlnChunk;
  224.     class CAlnChunkVec;
  225.     
  226. protected:
  227.     void x_GetChunks              (CAlnChunkVec * vec,
  228.                                    TNumrow row,
  229.                                    TNumseg first_seg,
  230.                                    TNumseg last_seg,
  231.                                    TGetChunkFlags flags) const;
  233. public:
  234.     // Get a vector of chunks defined by flags
  235.     // in alignment coords range
  236.     CRef<CAlnChunkVec> GetAlnChunks(TNumrow row, const TSignedRange& range,
  237.                                     TGetChunkFlags flags = fAlnSegsOnly) const;
  238.     // or in native sequence coords range
  239.     CRef<CAlnChunkVec> GetSeqChunks(TNumrow row, const TSignedRange& range,
  240.                                     TGetChunkFlags flags = fAlnSegsOnly) const;
  242.     class NCBI_XALNMGR_EXPORT CAlnChunkVec : public CObject
  243.     {
  244.     public:
  245.         CAlnChunkVec(const CAlnMap& aln_map, TNumrow row)
  246.             : m_AlnMap(aln_map), m_Row(row) { }
  248.         CConstRef<CAlnChunk> operator[] (TNumchunk i) const;
  250.         TNumchunk size(void) const { return m_StartSegs.size(); };
  252.     private:
  253. #ifdef NCBI_COMPILER_MSVC // kludge
  254.         friend class CAlnMap;
  255. #else
  256.         friend
  257.         CRef<CAlnChunkVec> CAlnMap::GetAlnChunks(TNumrow row,
  258.                                                  const TSignedRange& range,
  259.                                                  TGetChunkFlags flags) const;
  260.         friend
  261.         CRef<CAlnChunkVec> CAlnMap::GetSeqChunks(TNumrow row,
  262.                                                  const TSignedRange& range,
  263.                                                  TGetChunkFlags flags) const;
  264.         friend
  265.         void               CAlnMap::x_GetChunks (CAlnChunkVec * vec,
  266.                                                  TNumrow row,
  267.                                                  TNumseg first_seg,
  268.                                                  TNumseg last_seg,
  269.                                                  TGetChunkFlags flags) const;
  270. #endif
  272.         // can only be created by CAlnMap::GetAlnChunks
  273.         CAlnChunkVec(void); 
  274.     
  275.         const CAlnMap&  m_AlnMap;
  276.         TNumrow         m_Row;
  277.         vector<TNumseg> m_StartSegs;
  278.         vector<TNumseg> m_StopSegs;
  279.         TSeqPos         m_LeftDelta;
  280.         TSeqPos         m_RightDelta;
  281.     };
  283.     class NCBI_XALNMGR_EXPORT CAlnChunk : public CObject
  284.     {
  285.     public:    
  286.         TSegTypeFlags GetType(void) const { return m_TypeFlags; }
  287.         CAlnChunk&    SetType(TSegTypeFlags type_flags)
  288.             { m_TypeFlags = type_flags; return *this; }
  290.         const TSignedRange& GetRange(void) const { return m_SeqRange; }
  292.         const TSignedRange& GetAlnRange(void) const { return m_AlnRange; }
  294.         bool IsGap(void) const { return m_SeqRange.GetFrom() < 0; }
  295.         
  296.     private:
  297.         // can only be created or modified by
  298.         friend CConstRef<CAlnChunk> CAlnChunkVec::operator[](TNumchunk i)
  299.             const;
  300.         CAlnChunk(void) {}
  301.         TSignedRange& SetRange(void)    { return m_SeqRange; }
  302.         TSignedRange& SetAlnRange(void) { return m_AlnRange; }
  304.         TSegTypeFlags m_TypeFlags;
  305.         TSignedRange  m_SeqRange;
  306.         TSignedRange  m_AlnRange;
  307.     };
  310. protected:
  311.     class CNumSegWithOffset
  312.     {
  313.     public:
  314.         CNumSegWithOffset(TNumseg seg, int offset = 0)
  315.             : m_AlnSeg(seg), m_Offset(offset) { }
  317.         TNumseg GetAlnSeg(void) const { return m_AlnSeg; };
  318.         int     GetOffset(void) const { return m_Offset; };
  319.         
  320.     private:
  321.         TNumseg m_AlnSeg;
  322.         int     m_Offset;
  323.     };
  325.     // Prohibit copy constructor and assignment operator
  326.     CAlnMap(const CAlnMap& value);
  327.     CAlnMap& operator=(const CAlnMap& value);
  329.     friend CConstRef<CAlnChunk> CAlnChunkVec::operator[](TNumchunk i) const;
  331.     // internal functions for handling alignment segments
  332.     void              x_Init            (void);
  333.     void              x_CreateAlnStarts (void);
  334.     TSegTypeFlags     x_GetRawSegType   (TNumrow row, TNumseg seg) const;
  335.     TSegTypeFlags     x_SetRawSegType   (TNumrow row, TNumseg seg) const;
  336.     CNumSegWithOffset x_GetSegFromRawSeg(TNumseg seg)              const;
  337.     TNumseg           x_GetRawSegFromSeg(TNumseg seg)              const;
  338.     TSignedSeqPos     x_GetRawStart     (TNumrow row, TNumseg seg) const;
  339.     TSignedSeqPos     x_GetRawStop      (TNumrow row, TNumseg seg) const;
  340.     TSeqPos           x_GetLen          (TNumrow row, TNumseg seg) const;
  341.     const TNumseg&    x_GetSeqLeftSeg   (TNumrow row)              const;
  342.     const TNumseg&    x_GetSeqRightSeg  (TNumrow row)              const;
  344.     bool x_SkipType               (TSegTypeFlags type,
  345.                                    TGetChunkFlags flags) const;
  346.     bool x_CompareAdjacentSegTypes(TSegTypeFlags left_type, 
  347.                                    TSegTypeFlags right_type,
  348.                                    TGetChunkFlags flags) const;
  349.     // returns true if types are the same (as specified by flags)
  351.     CConstRef<CDense_seg>           m_DS;
  352.     TNumrow                         m_NumRows;
  353.     TNumseg                         m_NumSegs;
  354.     const CDense_seg::TIds&         m_Ids;
  355.     const CDense_seg::TStarts&      m_Starts;
  356.     const CDense_seg::TLens&        m_Lens;
  357.     const CDense_seg::TStrands&     m_Strands;
  358.     const CDense_seg::TScores&      m_Scores;
  359.     const CDense_seg::TWidths&      m_Widths;
  360.     TNumrow                         m_Anchor;
  361.     vector<TNumseg>                 m_AlnSegIdx;
  362.     mutable vector<TNumseg>         m_SeqLeftSegs;
  363.     mutable vector<TNumseg>         m_SeqRightSegs;
  364.     CDense_seg::TStarts             m_AlnStarts;
  365.     vector<CNumSegWithOffset>       m_NumSegWithOffsets;
  366.     mutable vector<TSegTypeFlags> * m_RawSegTypes;
  367. };
  371. ///////////////////////////////////////////////////////////
  372. ///////////////////// inline methods //////////////////////
  373. ///////////////////////////////////////////////////////////
  375. inline
  376. CAlnMap::CAlnMap(const CDense_seg& ds) 
  377.     : m_DS(&ds),
  378.       m_NumRows(ds.GetDim()),
  379.       m_NumSegs(ds.GetNumseg()),
  380.       m_Ids(ds.GetIds()),
  381.       m_Starts(ds.GetStarts()),
  382.       m_Lens(ds.GetLens()),
  383.       m_Strands(ds.GetStrands()),
  384.       m_Scores(ds.GetScores()),
  385.       m_Widths(ds.GetWidths()),
  386.       m_Anchor(-1),
  387.       m_RawSegTypes(0)
  388. {
  389.     x_Init();
  390.     x_CreateAlnStarts();
  391. }
  394. inline
  395. CAlnMap::CAlnMap(const CDense_seg& ds, TNumrow anchor)
  396.     : m_DS(&ds),
  397.       m_NumRows(ds.GetDim()),
  398.       m_NumSegs(ds.GetNumseg()),
  399.       m_Ids(ds.GetIds()),
  400.       m_Starts(ds.GetStarts()),
  401.       m_Lens(ds.GetLens()),
  402.       m_Strands(ds.GetStrands()),
  403.       m_Scores(ds.GetScores()),
  404.       m_Widths(ds.GetWidths()),
  405.       m_Anchor(-1),
  406.       m_RawSegTypes(0)
  407. {
  408.     x_Init();
  409.     SetAnchor(anchor);
  410. }
  413. inline
  414. CAlnMap::~CAlnMap(void)
  415. {
  416.     if (m_RawSegTypes) {
  417.         delete m_RawSegTypes;
  418.     }
  419. }
  422. inline
  423. const CDense_seg& CAlnMap::GetDenseg() const
  424. {
  425.     return *m_DS;
  426. }
  429. inline TSeqPos CAlnMap::GetAlnStart(TNumseg seg) const
  430. {
  431.     return m_AlnStarts[seg];
  432. }
  435. inline
  436. TSeqPos CAlnMap::GetAlnStop(TNumseg seg) const
  437. {
  438.     return m_AlnStarts[seg] + m_Lens[x_GetRawSegFromSeg(seg)] - 1;
  439. }
  442. inline
  443. TSeqPos CAlnMap::GetAlnStop(void) const
  444. {
  445.     return GetAlnStop(GetNumSegs() - 1);
  446. }
  449. inline 
  450. CAlnMap::TSegTypeFlags 
  451. CAlnMap::GetSegType(TNumrow row, TNumseg seg, int offset) const
  452. {
  453.     return x_GetRawSegType(row, x_GetRawSegFromSeg(seg) + offset);
  454. }
  457. inline
  458. CAlnMap::TNumseg CAlnMap::GetNumSegs(void) const
  459. {
  460.     return IsSetAnchor() ? m_AlnSegIdx.size() : m_NumSegs;
  461. }
  464. inline
  465. CAlnMap::TDim CAlnMap::GetNumRows(void) const
  466. {
  467.     return m_NumRows;
  468. }
  471. inline
  472. bool CAlnMap::IsSetAnchor(void) const
  473. {
  474.     return m_Anchor >= 0;
  475. }
  477. inline
  478. CAlnMap::TNumrow CAlnMap::GetAnchor(void) const
  479. {
  480.     return m_Anchor;
  481. }
  485. inline
  486. CAlnMap::CNumSegWithOffset
  487. CAlnMap::x_GetSegFromRawSeg(TNumseg raw_seg) const
  488. {
  489.     return IsSetAnchor() ? m_NumSegWithOffsets[raw_seg] : raw_seg;
  490. }
  493. inline
  494. CAlnMap::TNumseg
  495. CAlnMap::x_GetRawSegFromSeg(TNumseg seg) const
  496. {
  497.     return IsSetAnchor() ? m_AlnSegIdx[seg] : seg;
  498. }
  501. inline
  502. TSignedSeqPos CAlnMap::x_GetRawStart(TNumrow row, TNumseg seg) const
  503. {
  504.     return m_Starts[seg * m_NumRows + row];
  505. }
  507. inline
  508. int CAlnMap::GetWidth(TNumrow row) const
  509. {
  510.     return
  511.         (m_Widths.size() == (size_t) m_NumRows) ? m_Widths[row] : 1;
  512. }
  514. inline
  515. TSeqPos CAlnMap::x_GetLen(TNumrow row, TNumseg seg) const
  516. {
  517.     return m_Lens[seg] * GetWidth(row);
  518. }
  520. inline
  521. TSignedSeqPos CAlnMap::x_GetRawStop(TNumrow row, TNumseg seg) const
  522. {
  523.     TSignedSeqPos start = x_GetRawStart(row, seg);
  524.     return ((start > -1) ? (start + (TSignedSeqPos)x_GetLen(row, seg) - 1)
  525.             : -1);
  526. }
  529. inline
  530. int CAlnMap::StrandSign(TNumrow row) const
  531. {
  532.     return IsPositiveStrand(row) ? 1 : -1;
  533. }
  536. inline
  537. bool CAlnMap::IsPositiveStrand(TNumrow row) const
  538. {
  539.     return (m_Strands.empty()  ||  m_Strands[row] != eNa_strand_minus);
  540. }
  543. inline
  544. bool CAlnMap::IsNegativeStrand(TNumrow row) const
  545. {
  546.     return ! IsPositiveStrand(row);
  547. }
  550. inline
  551. TSignedSeqPos CAlnMap::GetStart(TNumrow row, TNumseg seg, int offset) const
  552. {
  553.     return m_Starts
  554.         [(x_GetRawSegFromSeg(seg) + offset) * m_NumRows + row];
  555. }
  557. inline
  558. TSeqPos CAlnMap::GetLen(TNumseg seg, int offset) const
  559. {
  560.     return m_Lens[x_GetRawSegFromSeg(seg) + offset];
  561. }
  564. inline
  565. TSeqPos CAlnMap::GetSeqLen(TNumrow row, TNumseg seg, int offset) const
  566. {
  567.     return x_GetLen(row, x_GetRawSegFromSeg(seg) + offset);
  568. }
  571. inline
  572. TSignedSeqPos CAlnMap::GetStop(TNumrow row, TNumseg seg, int offset) const
  573. {
  574.     TSignedSeqPos start = GetStart(row, seg, offset);
  575.     return ((start > -1) ? 
  576.             (start + (TSignedSeqPos)GetSeqLen(row, seg, offset) - 1) :
  577.             -1);
  578. }
  581. inline
  582. const CSeq_id& CAlnMap::GetSeqId(TNumrow row) const
  583. {
  584.     return *(m_Ids[row]);
  585. }
  588. inline 
  589. CAlnMap::TSignedRange
  590. CAlnMap::GetRange(TNumrow row, TNumseg seg, int offset) const
  591. {
  592.     TSignedSeqPos start = GetStart(row, seg, offset);
  593.     if (start > -1) {
  594.         return TSignedRange(start, start + GetSeqLen(row, seg, offset) - 1);
  595.     } else {
  596.         return TSignedRange(-1, -1);
  597.     }
  598. }
  601. inline
  602. TSeqPos CAlnMap::GetSeqStart(TNumrow row) const
  603. {
  604.     return 
  605.         m_Starts[(IsPositiveStrand(row) ?
  606.                   x_GetSeqLeftSeg(row) :
  607.                   x_GetSeqRightSeg(row)) * m_NumRows + row];
  608. }
  611. inline
  612. TSeqPos CAlnMap::GetSeqStop(TNumrow row) const
  613. {
  614.     const TNumseg& seg = IsPositiveStrand(row) ?
  615.         x_GetSeqRightSeg(row) : x_GetSeqLeftSeg(row);
  616.     return m_Starts[seg * m_NumRows + row] + x_GetLen(row, seg) - 1;
  617. }
  620. inline
  621. CAlnMap::TRange CAlnMap::GetSeqRange(TNumrow row) const
  622. {
  623.     return TRange(GetSeqStart(row), GetSeqStop(row));
  624. }
  627. inline
  628. CAlnMap::TSignedRange CAlnMap::GetSeqAlnRange(TNumrow row) const
  629. {
  630.     return TSignedRange(GetSeqAlnStart(row), GetSeqAlnStop(row));
  631. }
  634. inline
  635. TSeqPos CAlnMap::GetInsertedSeqLengthOnRight(TNumrow row, TNumseg seg) const
  636. {
  637.     return (IsPositiveStrand(row) ?
  638.             GetStop(row, seg+1) - GetStart(row, seg) :
  639.             GetStart(row, seg+1) - GetStop(row, seg));
  640. }
  643. inline 
  644. CAlnMap::TSegTypeFlags 
  645. CAlnMap::x_GetRawSegType(TNumrow row, TNumseg seg) const
  646. {
  647.     TSegTypeFlags type;
  648.     if (m_RawSegTypes &&
  649.         (type = (*m_RawSegTypes)[row + m_NumRows * seg]) & fTypeIsSet) {
  650.         return type & (~ fTypeIsSet);
  651.     } else {
  652.         return x_SetRawSegType(row, seg);
  653.     }
  654. }
  656. inline
  657. bool CAlnMap::IsTypeInsert(TSegTypeFlags type)
  658. {
  659.     return (type & fInsert) == fInsert;
  660. }
  662. inline 
  663. CAlnMap::TSegTypeFlags 
  664. CAlnMap::GetTypeAtAlnPos(TNumrow row, TSeqPos aln_pos) const
  665. {
  666.     return GetSegType(row, GetSeg(aln_pos));
  667. }
  670. ///////////////////////////////////////////////////////////
  671. ////////////////// end of inline methods //////////////////
  672. ///////////////////////////////////////////////////////////
  675. END_objects_SCOPE // namespace ncbi::objects::
  677. END_NCBI_SCOPE
  679. /*
  680. * ===========================================================================
  681. *
  682. * $Log: alnmap.hpp,v $
  683. * Revision 1000.1  2004/04/12 17:34:39  gouriano
  684. * PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.35
  685. *
  686. * Revision 1.35  2004/03/03 20:33:27  todorov
  687. * +comments
  688. *
  689. * Revision 1.34  2004/03/03 19:39:43  todorov
  690. * +GetResidueIndexMap
  691. *
  692. * Revision 1.33  2004/01/21 20:59:42  todorov
  693. * fDoNotTruncate -> fDoNotTruncateSegs; +comments
  694. *
  695. * Revision 1.32  2004/01/21 20:53:44  todorov
  696. * EGetChunkFlags += fDoNotTruncate
  697. *
  698. * Revision 1.31  2003/12/31 17:26:18  todorov
  699. * +fIgnoreAnchore usage comment
  700. *
  701. * Revision 1.30  2003/09/18 23:05:11  todorov
  702. * Optimized GetSeqAln{Start,Stop}
  703. *
  704. * Revision 1.29  2003/09/09 19:42:37  dicuccio
  705. * Fixed thinko in GetWidth() - properly order ternary operator
  706. *
  707. * Revision 1.28  2003/09/08 19:49:19  todorov
  708. * signed vs unsigned warnings fixed
  709. *
  710. * Revision 1.27  2003/08/29 18:17:17  dicuccio
  711. * Minor change in specification of default parameters - rely only on prameters,
  712. * not on member variables
  713. *
  714. * Revision 1.26  2003/08/25 16:35:06  todorov
  715. * exposed GetWidth
  716. *
  717. * Revision 1.25  2003/08/20 14:35:14  todorov
  718. * Support for NA2AA Densegs
  719. *
  720. * Revision 1.24  2003/07/17 22:46:56  todorov
  721. * name change +TSeqPosList
  722. *
  723. * Revision 1.23  2003/07/08 20:26:28  todorov
  724. * Created seq end segments cache
  725. *
  726. * Revision 1.22  2003/06/05 19:03:29  todorov
  727. * Added const refs to Dense-seg members as a speed optimization
  728. *
  729. * Revision 1.21  2003/06/02 16:01:38  dicuccio
  730. * Rearranged include/objects/ subtree.  This includes the following shifts:
  731. *     - include/objects/alnmgr --> include/objtools/alnmgr
  732. *     - include/objects/cddalignview --> include/objtools/cddalignview
  733. *     - include/objects/flat --> include/objtools/flat
  734. *     - include/objects/objmgr/ --> include/objmgr/
  735. *     - include/objects/util/ --> include/objmgr/util/
  736. *     - include/objects/validator --> include/objtools/validator
  737. *
  738. * Revision 1.20  2003/05/23 18:10:38  todorov
  739. * +fChunkSameAsSeg
  740. *
  741. * Revision 1.19  2003/03/20 16:37:14  todorov
  742. * +fIgnoreGaps for GetXXXChunksalnmap.cpp
  743. *
  744. * Revision 1.18  2003/03/07 17:30:14  todorov
  745. * + ESearchDirection dir, bool try_reverse_dir for GetAlnPosFromSeqPos
  746. *
  747. * Revision 1.17  2003/03/04 16:18:58  todorov
  748. * Added advance search options for GetRawSeg
  749. *
  750. * Revision 1.16  2003/01/15 18:48:36  todorov
  751. * Added GetSeqChunks to be used with native seq range
  752. *
  753. * Revision 1.15  2003/01/09 22:08:11  todorov
  754. * Changed the default TGetChunkFlags for consistency
  755. *
  756. * Revision 1.14  2003/01/07 23:02:48  todorov
  757. * Fixed EGetChunkFlags
  758. *
  759. * Revision 1.13  2002/12/26 12:38:08  dicuccio
  760. * Added Win32 export specifiers
  761. *
  762. * Revision 1.12  2002/10/21 19:14:36  todorov
  763. * reworked aln chunks: now supporting more types; added chunk aln coords
  764. *
  765. * Revision 1.10  2002/10/04 17:05:31  todorov
  766. * Added GetTypeAtAlnPos method
  767. *
  768. * Revision 1.8  2002/09/27 16:58:21  todorov
  769. * changed order of params for GetSeqPosFrom{Seq,Aln}Pos
  770. *
  771. * Revision 1.7  2002/09/27 02:26:32  ucko
  772. * Remove static from the definition of CAlnMap::IsTypeInsert, as
  773. * (like virtual) it should appear only on the initial declaration.
  774. *
  775. * Revision 1.6  2002/09/26 18:43:11  todorov
  776. * Added a static method for convenient check for an insert
  777. *
  778. * Revision 1.5  2002/09/26 17:40:42  todorov
  779. * Changed flag fAlignedToSeqOnAnchor to fNotAlignedToSeqOnAnchor. This proved more convenient.
  780. *
  781. * Revision 1.4  2002/09/25 18:16:26  dicuccio
  782. * Reworked computation of consensus sequence - this is now stored directly
  783. * in the underlying CDense_seg
  784. * Added exception class; currently used only on access of non-existent
  785. * consensus.
  786. *
  787. * Revision 1.3  2002/09/05 19:31:18  dicuccio
  788. * - added ability to reference a consensus sequence for a given alignment
  789. * - added caching of CSeqVector (big performance win)
  790. * - many small bugs fixed
  791. *
  792. * Revision 1.2  2002/08/23 16:05:09  ucko
  793. * Kludge friendship for MSVC.  (Sigh.)
  794. *
  795. * Revision 1.1  2002/08/23 14:43:50  ucko
  796. * Add the new C++ alignment manager to the public tree (thanks, Kamen!)
  797. *
  798. *
  799. * ===========================================================================
  800. */
  802. #endif // OBJECTS_ALNMGR___ALNMAP__HPP