alnmap.cpp

来自「ncbi源码」· C++ 代码 · 共 1,302 行 · 第 1/3 页

        }
    } else {        
        if (IsPositiveStrand(row)) {
            first_seg = GetRawSeg(row, range.GetFrom());
            vec->m_LeftDelta = range.GetFrom() - x_GetRawStart(row, first_seg);
        } else {
            last_seg = GetRawSeg(row, range.GetFrom());
            vec->m_RightDelta = range.GetFrom() - x_GetRawStart(row, last_seg);
        }
    }
    if (range.GetTo() > GetSeqStop(row)) {
        if (IsPositiveStrand(row)) {
            last_seg = m_NumSegs - 1;
        } else {
            first_seg = 0;
        }
    } else {
        if (IsPositiveStrand(row)) {
            last_seg = GetRawSeg(row, range.GetTo());
            if ( !(flags & fDoNotTruncateSegs) ) {
                vec->m_RightDelta = x_GetRawStop(row, last_seg) - range.GetTo();
            }
        } else {
            first_seg = GetRawSeg(row, range.GetTo());
            if ( !(flags & fDoNotTruncateSegs) ) {
                vec->m_LeftDelta = x_GetRawStop(row, last_seg) - range.GetTo();
            }
        }
    }

    x_GetChunks(vec, row, first_seg, last_seg, flags);
    return vec;
}


inline
bool CAlnMap::x_SkipType(TSegTypeFlags type, TGetChunkFlags flags) const
{
    bool skip = false;
    if (type & fSeq) {
        if (type & fNotAlignedToSeqOnAnchor) {
            if (flags & fSkipInserts) {
                skip = true;
            }
        } else {
            if (flags & fSkipAlnSeq) {
                skip = true;
            }
        }
    } else {
        if (type & fNotAlignedToSeqOnAnchor) {
            if (flags & fSkipUnalignedGaps) {
                skip = true;
            }
        } else {
            if (flags & fSkipDeletions) {
                skip = true;
            }
        }
    }        
    return skip;
}


inline
bool
CAlnMap::x_CompareAdjacentSegTypes(TSegTypeFlags left_type, 
                                   TSegTypeFlags right_type,
                                   TGetChunkFlags flags) const
    // returns true if types are the same (as specified by flags)
{
    if (flags & fChunkSameAsSeg) {
        return false;
    }
        
    if ((left_type & fSeq) != (right_type & fSeq)) {
        return false;
    }
    if (!(flags & fIgnoreUnaligned)  &&
        (left_type & fUnalignedOnRight || right_type & fUnalignedOnLeft)) {
        return false;
    }
    if ((left_type & fNotAlignedToSeqOnAnchor) ==
        (right_type & fNotAlignedToSeqOnAnchor)) {
        return true;
    }
    if (left_type & fSeq) {
        if (!(flags & fInsertSameAsSeq)) {
            return false;
        }
    } else {
        if (!(flags & fDeletionSameAsGap)) {
            return false;
        }
    }
    return true;
}

void CAlnMap::x_GetChunks(CAlnChunkVec * vec,
                          TNumrow row,
                          TNumseg first_seg, TNumseg last_seg,
                          TGetChunkFlags flags) const
{
    TSegTypeFlags type, test_type;

    // add the participating segments to the vector
    for (TNumseg seg = first_seg;  seg <= last_seg;  seg++) {
        type = x_GetRawSegType(row, seg);

        // see if the segment needs to be skipped
        if (x_SkipType(type, flags)) {
            if (seg == first_seg) {
                vec->m_LeftDelta = 0;
            } else if (seg == last_seg) {
                vec->m_RightDelta = 0;
            }
            continue;
        }

        vec->m_StartSegs.push_back(seg); // start seg

        // find the stop seg
        TNumseg test_seg = seg;
        while (test_seg < last_seg) {
            test_seg++;
            test_type = x_GetRawSegType(row, test_seg);
            if (x_CompareAdjacentSegTypes(type, test_type, flags)) {
                seg = test_seg;
                continue;
            }

            // include included gaps if desired
            if (flags & fIgnoreGaps  &&  !(test_type & fSeq)  &&
                x_CompareAdjacentSegTypes(type & ~fSeq, test_type, flags)) {
                continue;
            }
            break;
        }
        vec->m_StopSegs.push_back(seg);
    }
}


CConstRef<CAlnMap::CAlnChunk>
CAlnMap::CAlnChunkVec::operator[](CAlnMap::TNumchunk i) const
{
    CAlnMap::TNumseg start_seg = m_StartSegs[i];
    CAlnMap::TNumseg stop_seg  = m_StopSegs[i];

    CRef<CAlnChunk>  chunk(new CAlnChunk());
    TSignedSeqPos from, to;
    from = m_AlnMap.m_Starts[start_seg * m_AlnMap.m_NumRows
                                     + m_Row];
    if (from >= 0) {
        to = from + m_AlnMap.x_GetLen(m_Row, start_seg) - 1;
    } else {
        from = -1;
        to = -1;
    }
    chunk->SetRange().Set(from, to);
    chunk->SetType(m_AlnMap.x_GetRawSegType(m_Row, start_seg));

    TSegTypeFlags type;
    for (CAlnMap::TNumseg seg = start_seg + 1;  seg <= stop_seg;  seg++) {
        type = m_AlnMap.x_GetRawSegType(m_Row, seg);
        if (type & fSeq) {
            // extend the range
            if (m_AlnMap.IsPositiveStrand(m_Row)) {
                chunk->SetRange().Set(chunk->GetRange().GetFrom(),
                                      chunk->GetRange().GetTo()
                                      + m_AlnMap.x_GetLen(m_Row, seg));
            } else {
                chunk->SetRange().Set(chunk->GetRange().GetFrom()
                                      - m_AlnMap.x_GetLen(m_Row, seg),
                                      chunk->GetRange().GetTo());
            }
        }
        // extend the type
        chunk->SetType(chunk->GetType() | type);
    }

    //determine the aln range
    {{
        // from position
        CNumSegWithOffset seg = m_AlnMap.x_GetSegFromRawSeg(start_seg);
        if (seg.GetAlnSeg() < 0) {
            // before the aln start
            from = -1;
        } else {
            if (seg.GetOffset() > 0) {
                // between aln segs
                from = m_AlnMap.GetAlnStop(seg.GetAlnSeg()) + 1;
            } else {
                // at an aln seg
                from = m_AlnMap.GetAlnStart(seg.GetAlnSeg()) +
                    (i == 0  &&  m_LeftDelta ? m_LeftDelta : 0);
            }
        }

        // to position
        seg = m_AlnMap.x_GetSegFromRawSeg(stop_seg);
        if (seg.GetAlnSeg() < 0) {
            // before the aln start
            to = 0;
        } else {
            if (seg.GetOffset() > 0) {
                // between aln segs
                to = m_AlnMap.GetAlnStop(seg.GetAlnSeg());
            } else {
                // at an aln seg
                to = m_AlnMap.GetAlnStop(seg.GetAlnSeg()) -
                    (i == size() - 1  &&  m_RightDelta ? m_RightDelta : 0);
            }
        }
        chunk->SetAlnRange().Set(from, to);
    }}


    // fix if extreme end
    if (i == 0 && m_LeftDelta) {
        if (!chunk->IsGap()) {
            if (m_AlnMap.IsPositiveStrand(m_Row)) {
                chunk->SetRange().Set
                    (chunk->GetRange().GetFrom()
                     + m_LeftDelta * m_AlnMap.GetWidth(m_Row),
                     chunk->GetRange().GetTo());
            } else {
                chunk->SetRange().Set(chunk->GetRange().GetFrom(),
                                      chunk->GetRange().GetTo()
                                      - m_LeftDelta
                                      * m_AlnMap.GetWidth(m_Row));
            }
            chunk->SetType(chunk->GetType() & ~fNoSeqOnLeft);
        }            
        chunk->SetType(chunk->GetType() & ~(fUnalignedOnLeft | fEndOnLeft));
    }
    if (i == size() - 1 && m_RightDelta) {
        if (!chunk->IsGap()) {
            if (m_AlnMap.IsPositiveStrand(m_Row)) {
                chunk->SetRange().Set
                    (chunk->GetRange().GetFrom(),
                     chunk->GetRange().GetTo()
                     - m_RightDelta * m_AlnMap.GetWidth(m_Row));
            } else {
                chunk->SetRange().Set
                    (chunk->GetRange().GetFrom()
                     + m_RightDelta * m_AlnMap.GetWidth(m_Row),
                     chunk->GetRange().GetTo());
            }
            chunk->SetType(chunk->GetType() & ~fNoSeqOnRight);
        }
        chunk->SetType(chunk->GetType() & ~(fUnalignedOnRight | fEndOnRight));
    }

    return chunk;
}


END_objects_SCOPE // namespace ncbi::objects::
END_NCBI_SCOPE

/*
* ===========================================================================
*
* $Log: alnmap.cpp,v $
* Revision 1000.3  2004/06/01 19:40:42  gouriano
* PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.48
*
* Revision 1.48  2004/05/21 21:42:51  gorelenk
* Added PCH ncbi_pch.hpp
*
* Revision 1.47  2004/03/03 19:39:22  todorov
* +GetResidueIndexMap
*
* Revision 1.46  2004/01/21 21:15:59  ucko
* Fix typos in last revision.
*
* Revision 1.45  2004/01/21 20:59:42  todorov
* fDoNotTruncate -> fDoNotTruncateSegs; +comments
*
* Revision 1.44  2004/01/21 20:53:35  todorov
* EGetChunkFlags += fDoNotTruncate
*
* Revision 1.43  2004/01/14 22:32:16  todorov
* Check for out of range seq_pos in GetSeqPosFromSeqPos
*
* Revision 1.42  2004/01/14 21:32:40  todorov
* Swapped aln range coords for insert chunks to insure proper range arithmetics
*
* Revision 1.41  2003/11/04 19:37:38  todorov
* Fixed GetRawSeg and GetAlnPosFromSeqPos in case of unaligned region
*
* Revision 1.40  2003/09/18 23:05:18  todorov
* Optimized GetSeqAln{Start,Stop}
*
* Revision 1.39  2003/09/17 16:26:35  todorov
* Fixed GetSeqPosFromSeqPos
*
* Revision 1.38  2003/09/10 22:53:37  todorov
* Use raw seg in GetSeqPosFromAlnPos
*
* Revision 1.37  2003/08/25 16:34:59  todorov
* exposed GetWidth
*
* Revision 1.36  2003/08/20 14:34:58  todorov
* Support for NA2AA Densegs
*
* Revision 1.35  2003/07/17 22:47:13  todorov
* name change
*
* Revision 1.34  2003/07/08 20:26:34  todorov
* Created seq end segments cache
*
* Revision 1.33  2003/06/09 17:47:26  todorov
* local var start type fixed in GetSeqStart,GetSeqStop
*
* Revision 1.32  2003/06/05 21:14:15  todorov
* Type fixed
*
* Revision 1.31  2003/06/05 19:59:33  todorov
* Fixed a few inefficiencies
*
* Revision 1.30  2003/06/05 19:03:12  todorov
* Added const refs to Dense-seg members as a speed optimization
*
* Revision 1.29  2003/06/02 16:06:40  dicuccio
* Rearranged src/objects/ subtree.  This includes the following shifts:
*     - src/objects/asn2asn --> arc/app/asn2asn
*     - src/objects/testmedline --> src/objects/ncbimime/test
*     - src/objects/objmgr --> src/objmgr
*     - src/objects/util --> src/objmgr/util
*     - src/objects/alnmgr --> src/objtools/alnmgr
*     - src/objects/flat --> src/objtools/flat
*     - src/objects/validator --> src/objtools/validator
*     - src/objects/cddalignview --> src/objtools/cddalignview
* In addition, libseq now includes six of the objects/seq... libs, and libmmdb
* replaces the three libmmdb? libs.
*
* Revision 1.28  2003/05/23 18:10:47  todorov
* +fChunkSameAsSeg
*
* Revision 1.27  2003/03/20 16:38:21  todorov
* +fIgnoreGaps for GetXXXChunks
*
* Revision 1.26  2003/03/07 17:30:26  todorov
* + ESearchDirection dir, bool try_reverse_dir for GetAlnPosFromSeqPos
*
* Revision 1.25  2003/03/04 16:19:05  todorov
* Added advance search options for GetRawSeg
*
* Revision 1.24  2003/01/31 17:22:14  todorov
* Fixed a typo
*
* Revision 1.23  2003/01/15 18:48:30  todorov
* Added GetSeqChunks to be used with native seq range
*
* Revision 1.22  2003/01/08 23:04:47  todorov
* Fixed a bug in x_CompareAdjacentSegTypes
*
* Revision 1.21  2003/01/03 17:00:41  todorov
* Fixed negative strand handling in GetRawSeg
*
* Revision 1.20  2002/12/20 21:25:14  todorov
* ... and another small fix
*
* Revision 1.19  2002/12/20 20:30:42  todorov
* Fixed a bug introduced in the previous revision
*
* Revision 1.18  2002/12/19 20:24:53  grichenk
* Updated usage of CRange<>
*
* Revision 1.17  2002/11/13 16:40:56  todorov
* out of range check for GetAlnPosFromSeqPos
*
* Revision 1.16  2002/11/04 21:29:08  grichenk
* Fixed usage of const CRef<> and CRef<> constructor
*
* Revision 1.15  2002/10/24 21:27:29  todorov
* out-of-range adjustment instead of return -1 for the GetSeqPosFromAlnPos
*
* Revision 1.14  2002/10/21 19:14:27  todorov
* reworked aln chunks: now supporting more types; added chunk aln coords
*
* Revision 1.13  2002/10/10 17:23:43  todorov
* switched back to one (but this time enhanced) GetSeqPosFromAlnPos method
*
* Revision 1.12  2002/10/04 16:38:06  todorov
* new method GetBestSeqPosFromAlnPos
*
* Revision 1.11  2002/09/27 16:57:46  todorov
* changed order of params for GetSeqPosFrom{Seq,Aln}Pos
*
* Revision 1.10  2002/09/26 18:24:50  todorov
* fixed a just introduced bug
*
* Revision 1.9  2002/09/26 17:43:17  todorov
* 1) Changed flag fAlignedToSeqOnAnchor to fNotAlignedToSeqOnAnchor. This proved
* more convenient.
* 2) Introduced some exceptions
* 3) Fixed a strand bug in CAlnMap::CAlnChunkVec::operator[]
*
* Revision 1.8  2002/09/25 18:16:29  dicuccio
* Reworked computation of consensus sequence - this is now stored directly
* in the underlying CDense_seg
* Added exception class; currently used only on access of non-existent
* consensus.
*
* Revision 1.7  2002/09/19 22:16:48  todorov
* fix the range on the extreme end only if not a gap
*
* Revision 1.6  2002/09/19 22:09:07  todorov
* fixed a problem due to switching of lines during code cleanup
*
* Revision 1.5  2002/09/18 19:24:54  todorov
* fixing the flags on the extreme end only if delta
*
* Revision 1.4  2002/09/05 19:30:39  dicuccio
* - added ability to reference a consensus sequence for a given alignment
* - added caching for CSeqVector objects (big performance gain)
* - many small bugs fixed
*
* Revision 1.3  2002/08/23 20:34:17  ucko
* Work around a Compaq C++ compiler bug.
*
* Revision 1.2  2002/08/23 20:31:17  todorov
* fixed neg strand deltas
*
* Revision 1.1  2002/08/23 14:43:52  ucko
* Add the new C++ alignment manager to the public tree (thanks, Kamen!)
*
*
* ===========================================================================
*/