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

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

生物技术

开发平台：

C/C++

alnmap.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: alnmap.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:40:42  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.48
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: alnmap.cpp,v 1000.3 2004/06/01 19:40:42 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. * Author:  Kamen Todorov, NCBI
  36. *
  37. * File Description:
  38. *   Interface for examining alignments (of type Dense-seg)
  39. *
  40. * ===========================================================================
  41. */
  44. #include <ncbi_pch.hpp>
  45. #include <objtools/alnmgr/alnmap.hpp>
  47. BEGIN_NCBI_SCOPE
  48. BEGIN_objects_SCOPE // namespace ncbi::objects::
  51. void CAlnMap::x_Init(void)
  52. {
  53.     m_SeqLeftSegs.resize(GetNumRows(), -1);
  54.     m_SeqRightSegs.resize(GetNumRows(), -1);
  55. }
  58. void CAlnMap::x_CreateAlnStarts(void)
  59. {
  60.     m_AlnStarts.clear();
  61.     m_AlnStarts.reserve(GetNumSegs());
  62.     
  63.     int start = 0, len = 0;
  64.     for (int i = 0;  i < GetNumSegs();  ++i) {
  65.         start += len;
  66.         m_AlnStarts.push_back(start);
  67.         len = m_Lens[i];
  68.     }
  69. }
  72. void CAlnMap::UnsetAnchor(void)
  73. {
  74.     m_AlnSegIdx.clear();
  75.     m_NumSegWithOffsets.clear();
  76.     if (m_RawSegTypes) {
  77.         delete m_RawSegTypes;
  78.         m_RawSegTypes = 0;
  79.     }
  80.     m_Anchor = -1;
  82.     // we must call this last, as it uses some internal shenanigans that
  83.     // are affected by the reset above
  84.     x_CreateAlnStarts();
  85. }
  88. void CAlnMap::SetAnchor(TNumrow anchor)
  89. {
  90.     if (anchor == -1) {
  91.         UnsetAnchor();
  92.         return;
  93.     }
  94.     if (anchor < 0  ||  anchor >= m_NumRows) {
  95.         NCBI_THROW(CAlnException, eInvalidRow,
  96.                    "CAlnVec::SetAnchor(): "
  97.                    "Invalid row");
  98.     }
  99.     m_AlnSegIdx.clear();
  100.     m_AlnStarts.clear();
  101.     m_NumSegWithOffsets.clear();
  102.     if (m_RawSegTypes) {
  103.         delete m_RawSegTypes;
  104.         m_RawSegTypes = 0;
  105.     }
  107.     int start = 0, len = 0, aln_seg = -1, offset = 0;
  108.     
  109.     m_Anchor = anchor;
  110.     for (int i = 0, pos = m_Anchor;  i < m_NumSegs;
  111.          ++i, pos += m_NumRows) {
  112.         if (m_Starts[pos] != -1) {
  113.             ++aln_seg;
  114.             offset = 0;
  115.             m_AlnSegIdx.push_back(i);
  116.             m_NumSegWithOffsets.push_back(CNumSegWithOffset(aln_seg));
  117.             start += len;
  118.             m_AlnStarts.push_back(start);
  119.             len = m_Lens[i];
  120.         } else {
  121.             ++offset;
  122.             m_NumSegWithOffsets.push_back(CNumSegWithOffset(aln_seg, offset));
  123.         }
  124.     }
  125.     if (!m_AlnSegIdx.size()) {
  126.         NCBI_THROW(CAlnException, eInvalidDenseg,
  127.                    "CAlnVec::SetAnchor(): "
  128.                    "Invalid Dense-seg: No sequence on the anchor row");
  129.     }
  130. }
  133. CAlnMap::TSegTypeFlags 
  134. CAlnMap::x_SetRawSegType(TNumrow row, TNumseg seg) const
  135. {
  136.     TSegTypeFlags flags = 0;
  137.     TNumseg       l_seg, r_seg, l_index, r_index, index;
  138.     TSeqPos       cont_next_start, cont_prev_stop;
  140.     l_seg = r_seg = seg;
  141.     l_index = r_index = index = seg * m_NumRows + row;
  143.     TSignedSeqPos start = m_Starts[index];
  145.     // is it seq or gap?
  146.     if (start >= 0) {
  147.         flags |= fSeq;
  148.         cont_next_start = start + x_GetLen(row, seg);
  149.         cont_prev_stop  = start;
  150.     }
  152.     // is it aligned to sequence on the anchor?
  153.     if (IsSetAnchor()) {
  154.         flags |= fNotAlignedToSeqOnAnchor;
  155.         if (m_Starts[seg * m_NumRows + m_Anchor] >= 0) {
  156.             flags &= ~(flags & fNotAlignedToSeqOnAnchor);
  157.         }
  158.     }
  160.     // what's on the right?
  161.     if (r_seg < m_NumSegs - 1) {
  162.         flags |= fEndOnRight;
  163.     }
  164.     flags |= fNoSeqOnRight;
  165.     while (++r_seg < m_NumSegs) {
  166.         flags &= ~(flags & fEndOnRight);
  167.         r_index += m_NumRows;
  168.         if ((start = m_Starts[r_index]) >= 0) {
  169.             if ((flags & fSeq) && 
  170.                 (IsPositiveStrand(row) ?
  171.                  start != (TSignedSeqPos)cont_next_start :
  172.                  start + x_GetLen(row, r_seg) != cont_prev_stop)) {
  173.                 flags |= fUnalignedOnRight;
  174.             }
  175.             flags &= ~(flags & fNoSeqOnRight);
  176.             break;
  177.         }
  178.     }
  180.     // what's on the left?
  181.     if (l_seg > 0) {
  182.         flags |= fEndOnLeft;
  183.     }
  184.     flags |= fNoSeqOnLeft;
  185.     while (--l_seg >= 0) {
  186.         flags &= ~(flags & fEndOnLeft);
  187.         l_index -= m_NumRows;
  188.         if ((start = m_Starts[l_index]) >= 0) {
  189.             if ((flags & fSeq) && 
  190.                 (IsPositiveStrand(row) ?
  191.                  start + x_GetLen(row, l_seg) != cont_prev_stop :
  192.                  start != (TSignedSeqPos)cont_next_start)) {
  193.                 flags |= fUnalignedOnLeft;
  194.             }
  195.             flags &= ~(flags & fNoSeqOnLeft);
  196.             break;
  197.         }
  198.     }
  199.         
  200.     // add to cache
  201.     if ( !m_RawSegTypes ) {
  202.         // Using kZero for 0 works around a bug in Compaq's C++ compiler.
  203.         static const TSegTypeFlags kZero = 0;
  204.         m_RawSegTypes = new vector<TSegTypeFlags>
  205.             (m_NumRows * m_NumSegs, kZero);
  206.     }
  207.     (*m_RawSegTypes)[row + m_NumRows * seg] = flags | fTypeIsSet;
  209.     return flags;
  210. }
  213. CAlnMap::TNumseg CAlnMap::GetSeg(TSeqPos aln_pos) const
  214. {
  215.     TNumseg btm, top, mid;
  217.     btm = 0;
  218.     top = m_AlnStarts.size() - 1;
  220.     if (aln_pos > m_AlnStarts[top] +
  221.         m_Lens[x_GetRawSegFromSeg(top)] - 1) 
  222.         return -1; // out of range
  224.     while (btm < top) {
  225.         mid = (top + btm) / 2;
  226.         if (m_AlnStarts[mid] == (TSignedSeqPos)aln_pos) {
  227.             return mid;
  228.         }
  229.         if (m_AlnStarts[mid + 1] <= (TSignedSeqPos)aln_pos) {
  230.             btm = mid + 1; 
  231.         } else {
  232.             top = mid;
  233.         }
  234.     } 
  235.     return top;
  236. }
  239. CAlnMap::TNumseg
  240. CAlnMap::GetRawSeg(TNumrow row, TSeqPos seq_pos,
  241.                    ESearchDirection dir, bool try_reverse_dir) const
  242. {
  243.     TSignedSeqPos start = -1, sseq_pos = seq_pos;
  244.     TNumseg       btm, top, mid, cur, last, cur_top, cur_btm;
  245.     btm = cur_btm = 0; cur = top = last = cur_top = m_NumSegs - 1;
  247.     bool plus = IsPositiveStrand(row);
  249.     // if out-of-range, return either -1 or the closest seg in dir direction
  250.     if (sseq_pos < GetSeqStart(row)) {
  251.         if (dir == eNone) {
  252.             return -1;
  253.         } else if (dir == eForward  || 
  254.                    dir == (plus ? eRight : eLeft)  ||
  255.                    try_reverse_dir) {
  256.             TNumseg seg;
  257.             if (plus) {
  258.                 seg = -1;
  259.                 while (++seg < m_NumSegs) {
  260.                     if (m_Starts[seg * m_NumRows + row] >= 0) {
  261.                         return seg;
  262.                     }
  263.                 }
  264.             } else {
  265.                 seg = m_NumSegs;
  266.                 while (seg--) {
  267.                     if (m_Starts[seg * m_NumRows + row] >= 0) {
  268.                         return seg;
  269.                     }
  270.                 }
  271.             }
  272.         }
  273.     } else if (sseq_pos > GetSeqStop(row)) {
  274.         if (dir == eNone) {
  275.             return -1;
  276.         } else if (dir == eBackwards  ||
  277.                    dir == (plus ? eLeft : eRight)  ||
  278.                    try_reverse_dir) {
  279.             TNumseg seg;
  280.             if (plus) {
  281.                 seg = m_NumSegs;
  282.                 while (seg--) {
  283.                     if (m_Starts[seg * m_NumRows + row] >= 0) {
  284.                         return seg;
  285.                     }
  286.                 }
  287.             } else {
  288.                 seg = -1;
  289.                 while (++seg < m_NumSegs) {
  290.                     if (m_Starts[seg * m_NumRows + row] >= 0) {
  291.                         return seg;
  292.                     }
  293.                 }
  294.             }
  295.         }
  296.     }
  298.     // main loop
  299.     while (btm <= top) {
  300.         cur = mid = (top + btm) / 2;
  302.         while (cur <= top
  303.                &&  (start = m_Starts[(plus ? cur : last - cur) 
  304.                                              * m_NumRows + row]) < 0) {
  305.             ++cur;
  306.         }
  307.         if (cur <= top && start >= 0) {
  308.             if (sseq_pos >= start &&
  309.                 seq_pos < start + x_GetLen(row, plus ? cur : last - cur)) {
  310.                 return (plus ? cur : last - cur); // found
  311.             }
  312.             if (sseq_pos > start) {
  313.                 btm = cur + 1;
  314.                 cur_btm = cur;
  315.             } else {
  316.                 top = mid - 1;
  317.                 cur_top = cur;
  318.             }
  319.             continue;
  320.         }
  322.         cur = mid-1;
  323.         while (cur >= btm &&
  324.                (start = m_Starts[(plus ? cur : last - cur)
  325.                                          * m_NumRows + row]) < 0) {
  326.             --cur;
  327.         }
  328.         if (cur >= btm && start >= 0) {
  329.             if (sseq_pos >= start
  330.                 &&  seq_pos < start + x_GetLen(row, plus ? cur : last - cur)) {
  331.                 return (plus ? cur : last - cur); // found
  332.             }
  333.             if (sseq_pos > start) {
  334.                 btm = mid + 1;
  335.                 cur_btm = cur;
  336.             } else {
  337.                 top = cur - 1;
  338.                 cur_top = cur;
  339.             }
  340.             continue;
  341.         }
  343.         // if we get here, seq_pos falls into an unaligned region
  344.         // return either -1 or the closest segment in dir direction
  345.         if (dir == eNone) {
  346.             return -1;
  347.         } else if (dir == eBackwards  ||  dir == (plus ? eLeft : eRight)) {
  348.             return (plus ? cur_btm : last - cur_btm);
  349.         } else if (dir == eForward  ||  dir == (plus ? eRight : eLeft)) {
  350.             return (plus ? cur_top : last - cur_top);
  351.         }
  352.     }        
  353.     return -1; /* No match found */
  354. }
  355.     
  357. TSignedSeqPos CAlnMap::GetAlnPosFromSeqPos(TNumrow row, TSeqPos seq_pos,
  358.                                            ESearchDirection dir,
  359.                                            bool try_reverse_dir) const
  360. {
  361.     TNumseg raw_seg = GetRawSeg(row, seq_pos, dir, try_reverse_dir);
  362.     if (raw_seg < 0) { // out of seq range
  363.         return -1;
  364.     }
  366.     TSeqPos start = m_Starts[raw_seg * m_NumRows + row];
  367.     TSeqPos len   = x_GetLen(row, raw_seg);
  368.     TSeqPos stop  = start + len -1;
  369.     bool    plus  = IsPositiveStrand(row);
  371.     CNumSegWithOffset seg = x_GetSegFromRawSeg(raw_seg);
  373.     if (dir == eNone) {
  374.         if (seg.GetOffset()) {
  375.             // seq_pos is within an insert
  376.             return -1;
  377.         } 
  378.     } else {
  379.         // check if within unaligned region
  380.         // if seq_pos outside the segment returned by GetRawSeg
  381.         // then return the edge alnpos
  382.         if ((plus ? seq_pos < start : seq_pos > stop)) {
  383.             return GetAlnStart(seg.GetAlnSeg());
  384.         }
  385.         if ((plus ? seq_pos > stop : seq_pos < start)) {
  386.             return GetAlnStop(seg.GetAlnSeg());
  387.         }
  390.         // check if within an insert
  391.         if (seg.GetOffset()  &&  
  392.             (dir == eRight  ||
  393.              dir == (plus ? eForward : eBackwards))) {
  395.             // seek the nearest alnpos on the right
  396.             if (seg.GetAlnSeg() < GetNumSegs() - 1) {
  397.                 return GetAlnStart(seg.GetAlnSeg() + 1);
  398.             } else if (try_reverse_dir) {
  399.                 return GetAlnStop(seg.GetAlnSeg());
  400.             } else {
  401.                 return -1;
  402.             }
  404.         }
  405.         if (seg.GetOffset()  &&
  406.             (dir == eLeft  ||
  407.              dir == (plus ? eBackwards : eForward))) {
  408.             
  409.             // seek the nearest alnpos on left
  410.             if (seg.GetAlnSeg() >= 0) {
  411.                 return GetAlnStop(seg.GetAlnSeg());
  412.             } else if (try_reverse_dir) {
  413.                 return GetAlnStart(seg.GetAlnSeg() + 1);
  414.             } else {
  415.                 return -1;
  416.             }
  418.         }
  419.     } 
  421.     // main case: seq_pos is within an alnseg
  422.     //assert(seq_pos >= start  &&  seq_pos <= stop);
  423.     TSeqPos delta = (seq_pos - start) / GetWidth(row);
  424.     return m_AlnStarts[seg.GetAlnSeg()]
  425.         + (plus ? delta : m_Lens[raw_seg] - 1 - delta);
  426. }
  428. TSignedSeqPos CAlnMap::GetSeqPosFromAlnPos(TNumrow for_row,
  429.                                            TSeqPos aln_pos,
  430.                                            ESearchDirection dir,
  431.                                            bool try_reverse_dir) const
  432. {
  433.     if (aln_pos > GetAlnStop()) {
  434.         aln_pos = GetAlnStop(); // out-of-range adjustment
  435.     }
  436.     TNumseg seg = GetSeg(aln_pos);
  437.     TSignedSeqPos pos = GetStart(for_row, seg);
  438.     if (pos >= 0) {
  439.         TSeqPos delta = (aln_pos - GetAlnStart(seg)) * GetWidth(for_row);
  440.         if (IsPositiveStrand(for_row)) {
  441.             pos += delta;
  442.         } else {
  443.             pos += x_GetLen(for_row, x_GetRawSegFromSeg(seg)) - 1 - delta;
  444.         }
  445.     } else if (dir != eNone) {
  446.         // it is a gap, search in the neighbouring segments
  447.         // according to search direction (dir) and strand
  448.         bool reverse_pass = false;
  449.         TNumseg orig_seg = seg = x_GetRawSegFromSeg(seg);
  450.             
  451.         while (true) {
  452.             if (IsPositiveStrand(for_row)) {
  453.                 if (dir == eBackwards  ||  dir == eLeft) {
  454.                     while (--seg >=0  &&  pos == -1) {
  455.                         pos = x_GetRawStop(for_row, seg);
  456.                     }
  457.                 } else {
  458.                     while (++seg < m_NumSegs  &&  pos == -1) {
  459.                         pos = x_GetRawStart(for_row, seg);
  460.                     }
  461.                 }
  462.             } else {
  463.                 if (dir == eForward  ||  dir == eLeft) {
  464.                     while (--seg >=0  &&  pos == -1) {
  465.                         pos = x_GetRawStart(for_row, seg);
  466.                     }
  467.                 } else {
  468.                     while (++seg < m_NumSegs  &&  pos == -1) {
  469.                         pos = x_GetRawStop(for_row, seg);
  470.                     } 
  471.                 }
  472.             }
  473.             if (!try_reverse_dir) {
  474.                 break;
  475.             }
  476.             if (pos >= 0) {
  477.                 break; // found
  478.             } else if (reverse_pass) {
  479.                 string msg = "CAlnVec::GetSeqPosFromAlnPos(): "
  480.                     "Invalid Dense-seg: Row " +
  481.                     NStr::IntToString(for_row) +
  482.                     " contains gaps only.";
  483.                 NCBI_THROW(CAlnException, eInvalidDenseg, msg);
  484.             }
  485.             // not found, try reverse direction
  486.             reverse_pass = true;
  487.             seg = orig_seg;
  488.             switch (dir) {
  489.             case eLeft:
  490.                 dir = eRight; break;
  491.             case eRight:
  492.                 dir = eLeft; break;
  493.             case eForward:
  494.                 dir = eBackwards; break;
  495.             case eBackwards:
  496.                 dir = eForward; break;
  497.             }
  498.         }
  499.     }
  500.     return pos;
  501. }
  503. TSignedSeqPos CAlnMap::GetSeqPosFromSeqPos(TNumrow for_row,
  504.                                            TNumrow row, TSeqPos seq_pos) const
  505. {
  506.     TNumseg raw_seg = GetRawSeg(row, seq_pos);
  507.     if (raw_seg < 0) {
  508.         return -1;
  509.     }
  510.     unsigned offset = raw_seg * m_NumRows;
  511.     TSignedSeqPos start = m_Starts[offset + for_row];
  512.     if (start >= 0) {
  513.         TSeqPos delta
  514.             = seq_pos - m_Starts[offset + row];
  515.         if (GetWidth(for_row) != GetWidth(row)) {
  516.             delta = delta / GetWidth(row) * GetWidth(for_row);
  517.         }
  518.         return start
  519.             + (StrandSign(row) == StrandSign(for_row) ? delta
  520.                : x_GetLen(for_row, raw_seg) - 1 - delta);
  521.     } else {
  522.         return -1;
  523.     }
  524. }
  527. const CAlnMap::TNumseg& CAlnMap::x_GetSeqLeftSeg(TNumrow row) const
  528. {
  529.     TNumseg& seg = m_SeqLeftSegs[row];
  530.     if (seg < 0) {
  531.         while (++seg < m_NumSegs) {
  532.             if (m_Starts[seg * m_NumRows + row] >= 0) {
  533.                 return seg;
  534.             }
  535.         }
  536.     } else {
  537.         return seg;
  538.     }
  539.     seg = -1;
  540.     string err_msg = "CAlnVec::x_GetSeqLeftSeg(): "
  541.         "Invalid Dense-seg: Row " + NStr::IntToString(row) +
  542.         " contains gaps only.";
  543.     NCBI_THROW(CAlnException, eInvalidDenseg, err_msg);
  544. }
  545.     
  547. const CAlnMap::TNumseg& CAlnMap::x_GetSeqRightSeg(TNumrow row) const
  548. {
  549.     TNumseg& seg = m_SeqRightSegs[row];
  550.     if (seg < 0) {
  551.         seg = m_NumSegs;
  552.         while (seg--) {
  553.             if (m_Starts[seg * m_NumRows + row] >= 0) {
  554.                 return seg;
  555.             }
  556.         }
  557.     } else {
  558.         return seg;
  559.     }
  560.     seg = -1;
  561.     string err_msg = "CAlnVec::x_GetSeqRightSeg(): "
  562.         "Invalid Dense-seg: Row " + NStr::IntToString(row) +
  563.         " contains gaps only.";
  564.     NCBI_THROW(CAlnException, eInvalidDenseg, err_msg);
  565. }
  566.     
  568. void CAlnMap::GetResidueIndexMap(TNumrow row0,
  569.                                  TNumrow row1,
  570.                                  TRange aln_rng,
  571.                                  vector<TSignedSeqPos>& result,
  572.                                  TRange& rng0,
  573.                                  TRange& rng1) const
  574. {
  575.     _ASSERT( ! IsSetAnchor() );
  576.     TNumseg l_seg, r_seg;
  577.     TSeqPos aln_start = aln_rng.GetFrom();
  578.     TSeqPos aln_stop = aln_rng.GetTo();
  579.     int l_idx0 = row0;
  580.     int l_idx1 = row1;
  581.     TSeqPos aln_pos = 0, next_aln_pos, l_len, r_len, l_delta, r_delta;
  582.     bool plus0 = IsPositiveStrand(row0);
  583.     bool plus1 = IsPositiveStrand(row1);
  584.     TSeqPos l_pos0, r_pos0, l_pos1, r_pos1;
  586.     l_seg = 0;
  587.     while (l_seg < m_NumSegs) {
  588.         l_len = m_Lens[l_seg];
  589.         next_aln_pos = aln_pos + l_len;
  590.         if (m_Starts[l_idx0] >= 0  &&  m_Starts[l_idx1] >= 0  &&
  591.             aln_start >= aln_pos  &&  aln_start < next_aln_pos) {
  592.             // found the left seg
  593.             break;
  594.         }
  595.         aln_pos = next_aln_pos;
  596.         l_idx0 += m_NumRows; l_idx1 += m_NumRows;
  597.         l_seg++;
  598.     }
  599.     _ASSERT(l_seg < m_NumSegs);
  601.     // determine left seq positions
  602.     l_pos0 = m_Starts[l_idx0];
  603.     l_pos1 = m_Starts[l_idx1];
  604.     l_delta = aln_start - aln_pos;
  605.     l_len -= l_delta;
  606.     _ASSERT(l_delta >= 0);
  607.     if (plus0) {
  608.         l_pos0 += l_delta;
  609.     } else {
  610.         l_pos0 += l_len - 1;
  611.     }
  612.     if (plus1) {
  613.         l_pos1 += l_delta;
  614.     } else {
  615.         l_pos1 += l_len - 1;
  616.     }
  617.         
  618.     r_seg = m_NumSegs - 1;
  619.     int r_idx0 = r_seg * m_NumRows + row0;
  620.     int r_idx1 = r_seg * m_NumRows + row1;
  621.     aln_pos = GetAlnStop();
  622.     if (aln_stop > aln_pos) {
  623.         aln_stop = aln_pos;
  624.     }
  625.     while (r_seg >= 0) {
  626.         r_len = m_Lens[r_seg];
  627.         next_aln_pos = aln_pos - r_len;
  628.         if (m_Starts[l_idx0] >= 0  &&  m_Starts[l_idx1] >= 0  &&
  629.             aln_stop > next_aln_pos  &&  aln_stop <= aln_pos) {
  630.             // found the right seg
  631.             break;
  632.         }
  633.         aln_pos = next_aln_pos;
  634.         r_idx0 -= m_NumRows; r_idx1 -= m_NumRows;
  635.         r_seg--;
  636.     }
  637.     
  638.     // determine right seq positions
  639.     r_pos0 = m_Starts[r_idx0];
  640.     r_pos1 = m_Starts[r_idx1];
  641.     r_delta = aln_pos - aln_stop;
  642.     r_len -= r_delta;
  643.     _ASSERT(r_delta >= 0);
  644.     if (plus0) {
  645.         r_pos0 += r_len - 1;
  646.     } else {
  647.         r_pos0 += r_delta;
  648.     }
  649.     if (plus1) {
  650.         r_pos1 += r_len - 1;
  651.     } else {
  652.         r_pos1 += r_delta;
  653.     }
  654.         
  655.     // We now know the size of the resulting vector
  656.     TSeqPos size = (plus0 ? r_pos0 - l_pos0 : l_pos0 - r_pos0) + 1;
  657.     result.resize(size, -1);
  659.     // Initialize index positions (from left to right)
  660.     TSeqPos pos0 = plus0 ? 0 : l_pos0 - r_pos0;
  661.     TSeqPos pos1 = plus1 ? 0 : l_pos1 - r_pos1;
  663.     // Initialize 'next' positions
  664.     // -- to determine if there are unaligned pieces
  665.     TSeqPos next_l_pos0 = plus0 ? l_pos0 + l_len : l_pos0 - l_len;
  666.     TSeqPos next_l_pos1 = plus1 ? l_pos1 + l_len : l_pos1 - l_len;
  668.     l_idx0 = row0;
  669.     l_idx1 = row1;
  670.     TNumseg seg = l_seg;
  671.     TSeqPos delta;
  672.     while (true) {
  673.         if (m_Starts[l_idx0] >= 0) { // if row0 is not gapped
  675.             if (seg > l_seg) {
  676.                 // check for unaligned region / validate
  677.                 if (plus0) {
  678.                     delta = m_Starts[l_idx0] - next_l_pos0;
  679.                     next_l_pos0 = m_Starts[l_idx0] + l_len;
  680.                 } else {
  681.                     delta = next_l_pos0 - m_Starts[l_idx0] - l_len + 1;
  682.                     next_l_pos0 = m_Starts[l_idx0] - 1;
  683.                 }
  684.                 if (delta > 0) {
  685.                     // unaligned region
  686.                     if (plus0) {
  687.                         pos0 += delta;
  688.                     } else {
  689.                         pos0 -= delta;
  690.                     }
  691.                 } else if (delta < 0) {
  692.                     // invalid segment
  693.                     string errstr = string("CAlnMap::GetResidueIndexMap():")
  694.                         + " Starts are not consistent!"
  695.                         + " Row=" + NStr::IntToString(row0) +
  696.                         " Seg=" + NStr::IntToString(seg);
  697.                     NCBI_THROW(CAlnException, eInvalidDenseg, errstr);
  698.                 }
  699.             }
  701.             if (m_Starts[l_idx1] >= 0) { // if row1 is not gapped
  702.                 
  703.                 if (seg > l_seg) {
  704.                     // check for unaligned region / validate
  705.                     if (plus1) {
  706.                         delta = m_Starts[l_idx1] - next_l_pos1;
  707.                         next_l_pos1 = m_Starts[l_idx1] + l_len;
  708.                     } else {
  709.                         delta = next_l_pos1 - m_Starts[l_idx1] - l_len + 1;
  710.                         next_l_pos1 = m_Starts[l_idx1] - 1;
  711.                     }
  712.                     if (delta > 0) {
  713.                         // unaligned region
  714.                         if (plus1) {
  715.                             pos1 += delta;
  716.                         } else {
  717.                             pos1 -= delta;
  718.                         }
  719.                     } else if (delta < 0) {
  720.                         // invalid segment
  721.                         string errstr = string("CAlnMap::GetResidueIndexMap():")
  722.                             + " Starts are not consistent!"
  723.                             + " Row=" + NStr::IntToString(row1) +
  724.                             " Seg=" + NStr::IntToString(seg);
  725.                         NCBI_THROW(CAlnException, eInvalidDenseg, errstr);
  726.                     }
  727.                 }
  729.                 if (plus0) {
  730.                     if (plus1) { // if row1 on +
  731.                         while (l_len--) {
  732.                             result[pos0++] = pos1++;
  733.                         }
  734.                     } else { // if row1 on -
  735.                         while (l_len--) {
  736.                             result[pos0++] = pos1--;
  737.                         }
  738.                     }
  739.                 } else { // if row0 on -
  740.                     if (plus1) { // if row1 on +
  741.                         while (l_len--) {
  742.                             result[pos0--] = pos1++;
  743.                         }
  744.                     } else { // if row1 on -
  745.                         while (l_len--) {
  746.                             result[pos0--] = pos1--;
  747.                         }
  748.                     }
  749.                 }                    
  750.             } else {
  751.                 if (plus0) {
  752.                     pos0 += l_len;
  753.                 } else {
  754.                     pos0 -= l_len;
  755.                 }
  756.             }
  757.         }
  759.         // iterate to next segment
  760.         seg++;
  761.         l_idx0 += m_NumRows;
  762.         l_idx1 += m_NumRows;
  763.         if (seg < r_seg) {
  764.             l_len = m_Lens[seg];
  765.         } else if (seg == r_seg) {
  766.             l_len = r_len;
  767.         } else {
  768.             break;
  769.         }
  770.     }
  772.     // finally, set the ranges for the two sequences
  773.     rng0.SetFrom(plus0 ? l_pos0 : r_pos0);
  774.     rng0.SetTo(plus0 ? r_pos0 : l_pos0);
  775.     rng1.SetFrom(plus1 ? l_pos1 : r_pos1);
  776.     rng1.SetTo(plus1 ? r_pos1 : l_pos1);
  777. }
  780. TSignedSeqPos CAlnMap::GetSeqAlnStart(TNumrow row) const
  781. {
  782.     if (IsSetAnchor()) {
  783.         TNumseg seg = -1;
  784.         while (++seg < m_AlnSegIdx.size()) {
  785.             if (m_Starts[m_AlnSegIdx[seg] * m_NumRows + row] >= 0) {
  786.                 return GetAlnStart(seg);
  787.             }
  788.         }
  789.         return -1;
  790.     } else {
  791.         return GetAlnStart(x_GetSeqLeftSeg(row));
  792.     }
  793. }
  796. TSignedSeqPos CAlnMap::GetSeqAlnStop(TNumrow row) const
  797. {
  798.     if (IsSetAnchor()) {
  799.         TNumseg seg = m_AlnSegIdx.size();
  800.         while (seg--) {
  801.             if (m_Starts[m_AlnSegIdx[seg] * m_NumRows + row] >= 0) {
  802.                 return GetAlnStop(seg);
  803.             }
  804.         }
  805.         return -1;
  806.     } else {
  807.         return GetAlnStop(x_GetSeqRightSeg(row));
  808.     }
  809. }
  812. CRef<CAlnMap::CAlnChunkVec>
  813. CAlnMap::GetAlnChunks(TNumrow row, const TSignedRange& range,
  814.                       TGetChunkFlags flags) const
  815. {
  816.     CRef<CAlnChunkVec> vec(new CAlnChunkVec(*this, row));
  818.     // boundaries check
  819.     if (range.GetTo() < 0
  820.         ||  range.GetFrom() > (TSignedSeqPos) GetAlnStop(GetNumSegs() - 1)) {
  821.         return vec;
  822.     }
  824.     // determine the participating segments range
  825.     TNumseg first_seg, last_seg, aln_seg;
  827.     if (range.GetFrom() < 0) {
  828.         first_seg = 0;
  829.     } else {        
  830.         first_seg = x_GetRawSegFromSeg(aln_seg = GetSeg(range.GetFrom()));
  831.         if ( !(flags & fDoNotTruncateSegs) ) {
  832.             vec->m_LeftDelta = range.GetFrom() - GetAlnStart(aln_seg);
  833.         }
  834.     }
  835.     if ((TSeqPos)range.GetTo() > GetAlnStop(GetNumSegs()-1)) {
  836.         last_seg = m_NumSegs-1;
  837.     } else {
  838.         last_seg = x_GetRawSegFromSeg(aln_seg = GetSeg(range.GetTo()));
  839.         if ( !(flags & fDoNotTruncateSegs) ) {
  840.             vec->m_RightDelta = GetAlnStop(aln_seg) - range.GetTo();
  841.         }
  842.     }
  843.     
  844.     x_GetChunks(vec, row, first_seg, last_seg, flags);
  845.     return vec;
  846. }
  849. CRef<CAlnMap::CAlnChunkVec>
  850. CAlnMap::GetSeqChunks(TNumrow row, const TSignedRange& range,
  851.                       TGetChunkFlags flags) const
  852. {
  853.     CRef<CAlnChunkVec> vec(new CAlnChunkVec(*this, row));
  855.     // boundaries check
  856.     if (range.GetTo() < GetSeqStart(row)  ||
  857.         range.GetFrom() > GetSeqStop(row)) {
  858.         return vec;
  859.     }
  861.     // determine the participating segments range
  862.     TNumseg first_seg, last_seg;
  864.     if (range.GetFrom() < GetSeqStart(row)) {
  865.         if (IsPositiveStrand(row)) {
  866.             first_seg = 0;
  867.         } else {
  868.             last_seg = m_NumSegs - 1;
  869.         }
  870.     } else {        
  871.         if (IsPositiveStrand(row)) {
  872.             first_seg = GetRawSeg(row, range.GetFrom());
  873.             vec->m_LeftDelta = range.GetFrom() - x_GetRawStart(row, first_seg);
  874.         } else {
  875.             last_seg = GetRawSeg(row, range.GetFrom());
  876.             vec->m_RightDelta = range.GetFrom() - x_GetRawStart(row, last_seg);
  877.         }
  878.     }
  879.     if (range.GetTo() > GetSeqStop(row)) {
  880.         if (IsPositiveStrand(row)) {
  881.             last_seg = m_NumSegs - 1;
  882.         } else {
  883.             first_seg = 0;
  884.         }
  885.     } else {
  886.         if (IsPositiveStrand(row)) {
  887.             last_seg = GetRawSeg(row, range.GetTo());
  888.             if ( !(flags & fDoNotTruncateSegs) ) {
  889.                 vec->m_RightDelta = x_GetRawStop(row, last_seg) - range.GetTo();
  890.             }
  891.         } else {
  892.             first_seg = GetRawSeg(row, range.GetTo());
  893.             if ( !(flags & fDoNotTruncateSegs) ) {
  894.                 vec->m_LeftDelta = x_GetRawStop(row, last_seg) - range.GetTo();
  895.             }
  896.         }
  897.     }
  899.     x_GetChunks(vec, row, first_seg, last_seg, flags);
  900.     return vec;
  901. }
  904. inline
  905. bool CAlnMap::x_SkipType(TSegTypeFlags type, TGetChunkFlags flags) const
  906. {
  907.     bool skip = false;
  908.     if (type & fSeq) {
  909.         if (type & fNotAlignedToSeqOnAnchor) {
  910.             if (flags & fSkipInserts) {
  911.                 skip = true;
  912.             }
  913.         } else {
  914.             if (flags & fSkipAlnSeq) {
  915.                 skip = true;
  916.             }
  917.         }
  918.     } else {
  919.         if (type & fNotAlignedToSeqOnAnchor) {
  920.             if (flags & fSkipUnalignedGaps) {
  921.                 skip = true;
  922.             }
  923.         } else {
  924.             if (flags & fSkipDeletions) {
  925.                 skip = true;
  926.             }
  927.         }
  928.     }        
  929.     return skip;
  930. }
  933. inline
  934. bool
  935. CAlnMap::x_CompareAdjacentSegTypes(TSegTypeFlags left_type, 
  936.                                    TSegTypeFlags right_type,
  937.                                    TGetChunkFlags flags) const
  938.     // returns true if types are the same (as specified by flags)
  939. {
  940.     if (flags & fChunkSameAsSeg) {
  941.         return false;
  942.     }
  943.         
  944.     if ((left_type & fSeq) != (right_type & fSeq)) {
  945.         return false;
  946.     }
  947.     if (!(flags & fIgnoreUnaligned)  &&
  948.         (left_type & fUnalignedOnRight || right_type & fUnalignedOnLeft)) {
  949.         return false;
  950.     }
  951.     if ((left_type & fNotAlignedToSeqOnAnchor) ==
  952.         (right_type & fNotAlignedToSeqOnAnchor)) {
  953.         return true;
  954.     }
  955.     if (left_type & fSeq) {
  956.         if (!(flags & fInsertSameAsSeq)) {
  957.             return false;
  958.         }
  959.     } else {
  960.         if (!(flags & fDeletionSameAsGap)) {
  961.             return false;
  962.         }
  963.     }
  964.     return true;
  965. }
  967. void CAlnMap::x_GetChunks(CAlnChunkVec * vec,
  968.                           TNumrow row,
  969.                           TNumseg first_seg, TNumseg last_seg,
  970.                           TGetChunkFlags flags) const
  971. {
  972.     TSegTypeFlags type, test_type;
  974.     // add the participating segments to the vector
  975.     for (TNumseg seg = first_seg;  seg <= last_seg;  seg++) {
  976.         type = x_GetRawSegType(row, seg);
  978.         // see if the segment needs to be skipped
  979.         if (x_SkipType(type, flags)) {
  980.             if (seg == first_seg) {
  981.                 vec->m_LeftDelta = 0;
  982.             } else if (seg == last_seg) {
  983.                 vec->m_RightDelta = 0;
  984.             }
  985.             continue;
  986.         }
  988.         vec->m_StartSegs.push_back(seg); // start seg
  990.         // find the stop seg
  991.         TNumseg test_seg = seg;
  992.         while (test_seg < last_seg) {
  993.             test_seg++;
  994.             test_type = x_GetRawSegType(row, test_seg);
  995.             if (x_CompareAdjacentSegTypes(type, test_type, flags)) {
  996.                 seg = test_seg;
  997.                 continue;
  998.             }
  1000.             // include included gaps if desired
  1001.             if (flags & fIgnoreGaps  &&  !(test_type & fSeq)  &&
  1002.                 x_CompareAdjacentSegTypes(type & ~fSeq, test_type, flags)) {
  1003.                 continue;
  1004.             }
  1005.             break;
  1006.         }
  1007.         vec->m_StopSegs.push_back(seg);
  1008.     }
  1009. }
  1012. CConstRef<CAlnMap::CAlnChunk>
  1013. CAlnMap::CAlnChunkVec::operator[](CAlnMap::TNumchunk i) const
  1014. {
  1015.     CAlnMap::TNumseg start_seg = m_StartSegs[i];
  1016.     CAlnMap::TNumseg stop_seg  = m_StopSegs[i];
  1018.     CRef<CAlnChunk>  chunk(new CAlnChunk());
  1019.     TSignedSeqPos from, to;
  1020.     from = m_AlnMap.m_Starts[start_seg * m_AlnMap.m_NumRows
  1021.                                      + m_Row];
  1022.     if (from >= 0) {
  1023.         to = from + m_AlnMap.x_GetLen(m_Row, start_seg) - 1;
  1024.     } else {
  1025.         from = -1;
  1026.         to = -1;
  1027.     }
  1028.     chunk->SetRange().Set(from, to);
  1029.     chunk->SetType(m_AlnMap.x_GetRawSegType(m_Row, start_seg));
  1031.     TSegTypeFlags type;
  1032.     for (CAlnMap::TNumseg seg = start_seg + 1;  seg <= stop_seg;  seg++) {
  1033.         type = m_AlnMap.x_GetRawSegType(m_Row, seg);
  1034.         if (type & fSeq) {
  1035.             // extend the range
  1036.             if (m_AlnMap.IsPositiveStrand(m_Row)) {
  1037.                 chunk->SetRange().Set(chunk->GetRange().GetFrom(),
  1038.                                       chunk->GetRange().GetTo()
  1039.                                       + m_AlnMap.x_GetLen(m_Row, seg));
  1040.             } else {
  1041.                 chunk->SetRange().Set(chunk->GetRange().GetFrom()
  1042.                                       - m_AlnMap.x_GetLen(m_Row, seg),
  1043.                                       chunk->GetRange().GetTo());
  1044.             }
  1045.         }
  1046.         // extend the type
  1047.         chunk->SetType(chunk->GetType() | type);
  1048.     }
  1050.     //determine the aln range
  1051.     {{
  1052.         // from position
  1053.         CNumSegWithOffset seg = m_AlnMap.x_GetSegFromRawSeg(start_seg);
  1054.         if (seg.GetAlnSeg() < 0) {
  1055.             // before the aln start
  1056.             from = -1;
  1057.         } else {
  1058.             if (seg.GetOffset() > 0) {
  1059.                 // between aln segs
  1060.                 from = m_AlnMap.GetAlnStop(seg.GetAlnSeg()) + 1;
  1061.             } else {
  1062.                 // at an aln seg
  1063.                 from = m_AlnMap.GetAlnStart(seg.GetAlnSeg()) +
  1064.                     (i == 0  &&  m_LeftDelta ? m_LeftDelta : 0);
  1065.             }
  1066.         }
  1068.         // to position
  1069.         seg = m_AlnMap.x_GetSegFromRawSeg(stop_seg);
  1070.         if (seg.GetAlnSeg() < 0) {
  1071.             // before the aln start
  1072.             to = 0;
  1073.         } else {
  1074.             if (seg.GetOffset() > 0) {
  1075.                 // between aln segs
  1076.                 to = m_AlnMap.GetAlnStop(seg.GetAlnSeg());
  1077.             } else {
  1078.                 // at an aln seg
  1079.                 to = m_AlnMap.GetAlnStop(seg.GetAlnSeg()) -
  1080.                     (i == size() - 1  &&  m_RightDelta ? m_RightDelta : 0);
  1081.             }
  1082.         }
  1083.         chunk->SetAlnRange().Set(from, to);
  1084.     }}
  1087.     // fix if extreme end
  1088.     if (i == 0 && m_LeftDelta) {
  1089.         if (!chunk->IsGap()) {
  1090.             if (m_AlnMap.IsPositiveStrand(m_Row)) {
  1091.                 chunk->SetRange().Set
  1092.                     (chunk->GetRange().GetFrom()
  1093.                      + m_LeftDelta * m_AlnMap.GetWidth(m_Row),
  1094.                      chunk->GetRange().GetTo());
  1095.             } else {
  1096.                 chunk->SetRange().Set(chunk->GetRange().GetFrom(),
  1097.                                       chunk->GetRange().GetTo()
  1098.                                       - m_LeftDelta
  1099.                                       * m_AlnMap.GetWidth(m_Row));
  1100.             }
  1101.             chunk->SetType(chunk->GetType() & ~fNoSeqOnLeft);
  1102.         }            
  1103.         chunk->SetType(chunk->GetType() & ~(fUnalignedOnLeft | fEndOnLeft));
  1104.     }
  1105.     if (i == size() - 1 && m_RightDelta) {
  1106.         if (!chunk->IsGap()) {
  1107.             if (m_AlnMap.IsPositiveStrand(m_Row)) {
  1108.                 chunk->SetRange().Set
  1109.                     (chunk->GetRange().GetFrom(),
  1110.                      chunk->GetRange().GetTo()
  1111.                      - m_RightDelta * m_AlnMap.GetWidth(m_Row));
  1112.             } else {
  1113.                 chunk->SetRange().Set
  1114.                     (chunk->GetRange().GetFrom()
  1115.                      + m_RightDelta * m_AlnMap.GetWidth(m_Row),
  1116.                      chunk->GetRange().GetTo());
  1117.             }
  1118.             chunk->SetType(chunk->GetType() & ~fNoSeqOnRight);
  1119.         }
  1120.         chunk->SetType(chunk->GetType() & ~(fUnalignedOnRight | fEndOnRight));
  1121.     }
  1123.     return chunk;
  1124. }
  1127. END_objects_SCOPE // namespace ncbi::objects::
  1128. END_NCBI_SCOPE
  1130. /*
  1131. * ===========================================================================
  1132. *
  1133. * $Log: alnmap.cpp,v $
  1134. * Revision 1000.3  2004/06/01 19:40:42  gouriano
  1135. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.48
  1136. *
  1137. * Revision 1.48  2004/05/21 21:42:51  gorelenk
  1138. * Added PCH ncbi_pch.hpp
  1139. *
  1140. * Revision 1.47  2004/03/03 19:39:22  todorov
  1141. * +GetResidueIndexMap
  1142. *
  1143. * Revision 1.46  2004/01/21 21:15:59  ucko
  1144. * Fix typos in last revision.
  1145. *
  1146. * Revision 1.45  2004/01/21 20:59:42  todorov
  1147. * fDoNotTruncate -> fDoNotTruncateSegs; +comments
  1148. *
  1149. * Revision 1.44  2004/01/21 20:53:35  todorov
  1150. * EGetChunkFlags += fDoNotTruncate
  1151. *
  1152. * Revision 1.43  2004/01/14 22:32:16  todorov
  1153. * Check for out of range seq_pos in GetSeqPosFromSeqPos
  1154. *
  1155. * Revision 1.42  2004/01/14 21:32:40  todorov
  1156. * Swapped aln range coords for insert chunks to insure proper range arithmetics
  1157. *
  1158. * Revision 1.41  2003/11/04 19:37:38  todorov
  1159. * Fixed GetRawSeg and GetAlnPosFromSeqPos in case of unaligned region
  1160. *
  1161. * Revision 1.40  2003/09/18 23:05:18  todorov
  1162. * Optimized GetSeqAln{Start,Stop}
  1163. *
  1164. * Revision 1.39  2003/09/17 16:26:35  todorov
  1165. * Fixed GetSeqPosFromSeqPos
  1166. *
  1167. * Revision 1.38  2003/09/10 22:53:37  todorov
  1168. * Use raw seg in GetSeqPosFromAlnPos
  1169. *
  1170. * Revision 1.37  2003/08/25 16:34:59  todorov
  1171. * exposed GetWidth
  1172. *
  1173. * Revision 1.36  2003/08/20 14:34:58  todorov
  1174. * Support for NA2AA Densegs
  1175. *
  1176. * Revision 1.35  2003/07/17 22:47:13  todorov
  1177. * name change
  1178. *
  1179. * Revision 1.34  2003/07/08 20:26:34  todorov
  1180. * Created seq end segments cache
  1181. *
  1182. * Revision 1.33  2003/06/09 17:47:26  todorov
  1183. * local var start type fixed in GetSeqStart,GetSeqStop
  1184. *
  1185. * Revision 1.32  2003/06/05 21:14:15  todorov
  1186. * Type fixed
  1187. *
  1188. * Revision 1.31  2003/06/05 19:59:33  todorov
  1189. * Fixed a few inefficiencies
  1190. *
  1191. * Revision 1.30  2003/06/05 19:03:12  todorov
  1192. * Added const refs to Dense-seg members as a speed optimization
  1193. *
  1194. * Revision 1.29  2003/06/02 16:06:40  dicuccio
  1195. * Rearranged src/objects/ subtree.  This includes the following shifts:
  1196. *     - src/objects/asn2asn --> arc/app/asn2asn
  1197. *     - src/objects/testmedline --> src/objects/ncbimime/test
  1198. *     - src/objects/objmgr --> src/objmgr
  1199. *     - src/objects/util --> src/objmgr/util
  1200. *     - src/objects/alnmgr --> src/objtools/alnmgr
  1201. *     - src/objects/flat --> src/objtools/flat
  1202. *     - src/objects/validator --> src/objtools/validator
  1203. *     - src/objects/cddalignview --> src/objtools/cddalignview
  1204. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  1205. * replaces the three libmmdb? libs.
  1206. *
  1207. * Revision 1.28  2003/05/23 18:10:47  todorov
  1208. * +fChunkSameAsSeg
  1209. *
  1210. * Revision 1.27  2003/03/20 16:38:21  todorov
  1211. * +fIgnoreGaps for GetXXXChunks
  1212. *
  1213. * Revision 1.26  2003/03/07 17:30:26  todorov
  1214. * + ESearchDirection dir, bool try_reverse_dir for GetAlnPosFromSeqPos
  1215. *
  1216. * Revision 1.25  2003/03/04 16:19:05  todorov
  1217. * Added advance search options for GetRawSeg
  1218. *
  1219. * Revision 1.24  2003/01/31 17:22:14  todorov
  1220. * Fixed a typo
  1221. *
  1222. * Revision 1.23  2003/01/15 18:48:30  todorov
  1223. * Added GetSeqChunks to be used with native seq range
  1224. *
  1225. * Revision 1.22  2003/01/08 23:04:47  todorov
  1226. * Fixed a bug in x_CompareAdjacentSegTypes
  1227. *
  1228. * Revision 1.21  2003/01/03 17:00:41  todorov
  1229. * Fixed negative strand handling in GetRawSeg
  1230. *
  1231. * Revision 1.20  2002/12/20 21:25:14  todorov
  1232. * ... and another small fix
  1233. *
  1234. * Revision 1.19  2002/12/20 20:30:42  todorov
  1235. * Fixed a bug introduced in the previous revision
  1236. *
  1237. * Revision 1.18  2002/12/19 20:24:53  grichenk
  1238. * Updated usage of CRange<>
  1239. *
  1240. * Revision 1.17  2002/11/13 16:40:56  todorov
  1241. * out of range check for GetAlnPosFromSeqPos
  1242. *
  1243. * Revision 1.16  2002/11/04 21:29:08  grichenk
  1244. * Fixed usage of const CRef<> and CRef<> constructor
  1245. *
  1246. * Revision 1.15  2002/10/24 21:27:29  todorov
  1247. * out-of-range adjustment instead of return -1 for the GetSeqPosFromAlnPos
  1248. *
  1249. * Revision 1.14  2002/10/21 19:14:27  todorov
  1250. * reworked aln chunks: now supporting more types; added chunk aln coords
  1251. *
  1252. * Revision 1.13  2002/10/10 17:23:43  todorov
  1253. * switched back to one (but this time enhanced) GetSeqPosFromAlnPos method
  1254. *
  1255. * Revision 1.12  2002/10/04 16:38:06  todorov
  1256. * new method GetBestSeqPosFromAlnPos
  1257. *
  1258. * Revision 1.11  2002/09/27 16:57:46  todorov
  1259. * changed order of params for GetSeqPosFrom{Seq,Aln}Pos
  1260. *
  1261. * Revision 1.10  2002/09/26 18:24:50  todorov
  1262. * fixed a just introduced bug
  1263. *
  1264. * Revision 1.9  2002/09/26 17:43:17  todorov
  1265. * 1) Changed flag fAlignedToSeqOnAnchor to fNotAlignedToSeqOnAnchor. This proved
  1266. * more convenient.
  1267. * 2) Introduced some exceptions
  1268. * 3) Fixed a strand bug in CAlnMap::CAlnChunkVec::operator[]
  1269. *
  1270. * Revision 1.8  2002/09/25 18:16:29  dicuccio
  1271. * Reworked computation of consensus sequence - this is now stored directly
  1272. * in the underlying CDense_seg
  1273. * Added exception class; currently used only on access of non-existent
  1274. * consensus.
  1275. *
  1276. * Revision 1.7  2002/09/19 22:16:48  todorov
  1277. * fix the range on the extreme end only if not a gap
  1278. *
  1279. * Revision 1.6  2002/09/19 22:09:07  todorov
  1280. * fixed a problem due to switching of lines during code cleanup
  1281. *
  1282. * Revision 1.5  2002/09/18 19:24:54  todorov
  1283. * fixing the flags on the extreme end only if delta
  1284. *
  1285. * Revision 1.4  2002/09/05 19:30:39  dicuccio
  1286. * - added ability to reference a consensus sequence for a given alignment
  1287. * - added caching for CSeqVector objects (big performance gain)
  1288. * - many small bugs fixed
  1289. *
  1290. * Revision 1.3  2002/08/23 20:34:17  ucko
  1291. * Work around a Compaq C++ compiler bug.
  1292. *
  1293. * Revision 1.2  2002/08/23 20:31:17  todorov
  1294. * fixed neg strand deltas
  1295. *
  1296. * Revision 1.1  2002/08/23 14:43:52  ucko
  1297. * Add the new C++ alignment manager to the public tree (thanks, Kamen!)
  1298. *
  1299. *
  1300. * ===========================================================================
  1301. */