Esempio n. 1
0
void SGLookup::addInterval(const SGPosition& inPos,
                           const SGPosition& outPos,
                           sg_int_t length,
                           bool reversed)
{
  PosMap& pm = _mapVec.at(inPos.getSeqID());

  sg_int_t left = inPos.getPos();
  sg_int_t right = inPos.getPos() + length;

  // find the left point
  SGSide leftSide(SideGraph::NullPos, true);
  PosMap::iterator li = pm.insert(pair<sg_int_t, SGSide>(
                                    left, leftSide)).first;

  // find the right point
  PosMap::iterator ri = li;
  ++ri;
  if (ri == pm.end() || ri->second.getBase().getPos() != right)
  {
    SGSide rightSide(SideGraph::NullPos, true);
    ri = pm.insert(li, pair<sg_int_t, SGSide>(right, rightSide));
    --ri;
    assert(ri == li);
  }
  
  // update the left point
  assert(li->second.getBase() == SideGraph::NullPos);
  li->second = SGSide(outPos, !reversed);
}
Esempio n. 2
0
SGSide SGLookup::mapPosition(const SGPosition& inPos) const
{
  const PosMap& pm = _mapVec.at(inPos.getSeqID());
  PosMap::const_iterator i = pm.lower_bound(inPos.getPos());
  assert(i != pm.end());

  if (i->first > inPos.getPos())
  {
    assert(i != pm.begin());
    --i;
  }
  
  if (i->second.getBase() == SideGraph::NullPos)
  {
    return i->second;
  }
  
  assert(i->first <= inPos.getPos());  
  sg_int_t offset = inPos.getPos() - i->first;
  SGSide outSide(i->second);
  SGPosition outPos(outSide.getBase());
  outPos.setPos(outPos.getPos() + offset);
  if (outSide.getForward() == false)
  {
    PosMap::const_iterator j = i;
    ++j;
    sg_int_t transform = j->first - offset - i->first - 1 - offset;
    outPos.setPos(outPos.getPos() + transform);
  }
  outSide.setBase(outPos);
  return outSide;
}
Esempio n. 3
0
void Side2Seq::convertSequence(const SGSequence* seq)
{
  // we exclude the very first and last sides as they don't induce breaks
  // (very first start woult have forward == true, for example..)
  SGSide start = SGSide(SGPosition(seq->getID(), 0), false);
  SGSide end = SGSide(SGPosition(seq->getID(), seq->getLength() - 1), true);
  set<SGSide> cutSides;
  if (seq->getLength() > 1)
  {
    getIncidentJoins(start, end, cutSides);
  }
  if (_chop > 0)
  {
    getChopSides(seq, cutSides);
  }
  cleanCutSides(cutSides);
  
  SGPosition first(seq->getID(), 0);
  int firstIdx = _outGraph->getNumSequences();
  for (set<SGSide>::iterator i = cutSides.begin(); i != cutSides.end(); ++i)
  {
    SGPosition last = i->getBase();
    assert(last.getSeqID() == first.getSeqID());
    if (i->getForward() == true)
    {
      // left side of base: don't include this position
      last.setPos(last.getPos() - 1);
    }
    // add it
    addOutSequence(seq, first, last);
    // add one because segments inclusive
    first.setPos(last.getPos() + 1);
  }

  // need to do one segment at end
  SGPosition last(seq->getID(), seq->getLength() - 1);
  addOutSequence(seq, first, last);

  // chain all the added seqeunces with new joins
  for (int j = firstIdx + 1; j < _outGraph->getNumSequences(); ++j)
  {
    const SGSequence* fs = _outGraph->getSequence(j-1);
    const SGSequence* ts = _outGraph->getSequence(j);
    SGSide side1(SGPosition(fs->getID(), fs->getLength() - 1), false);
    SGSide side2(SGPosition(ts->getID(), 0), true);
    const SGJoin* newJoin = _outGraph->addJoin(new SGJoin(side1, side2));
    verifyOutJoin(newJoin);
  }
}
Esempio n. 4
0
void SGLookup::getPath(const SGPosition& startPos,
                       const SGPosition& endPos,
                       vector<SGSegment>& outPath) const
{
  SGPosition halStart = startPos;
  SGPosition halEnd = endPos;
  bool backward = endPos < startPos;
  if (backward == true)
  {
    // always make a forward path.  if query is reversed, we will
    // remember here and flip at very end. 
    swap(halStart, halEnd);
  }
  
  assert(halStart.getSeqID() == halEnd.getSeqID());

  const PosMap& pm = _mapVec.at(halStart.getSeqID());

  // find marker to the right of halStart
  PosMap::const_iterator i = pm.lower_bound(halStart.getPos());
  assert(i != pm.end());
  if (i->first == halStart.getPos())
  {
    ++i;
  }
  // find marker >= halEnd (ie one-past what we iterate)
  PosMap::const_iterator j = pm.lower_bound(halEnd.getPos());
  assert(j != pm.begin());
  if (j->first == halEnd.getPos())
  {
    ++j;
  }

  outPath.clear();
  sg_int_t pathLength = 0;

  sg_int_t prevHalPos = halStart.getPos();
  SGSide prevSgSide = mapPosition(halStart);

  for (PosMap::const_iterator k = i; k != j; ++k)
  {
    assert(k != pm.end());
    assert(k != pm.begin());
    sg_int_t halPos = k->first;
    sg_int_t segLen = halPos - prevHalPos;
    assert(segLen > 0);
    SGSide sgSide = k->second;

    // note we are taking advantage of the fact that
    // the side returned by mapPosition has a forward flag
    // consistent with its use in sgsegment.
    if (prevSgSide.getForward() == false && k != i)
    {
      // interval lookup always stores intervals left->right.
      // for reverse mapping, we have to manually adjust segment
      // coordinate (unless first iteration, which is already adjusted
      // by call to mapPosition)
      prevSgSide.setBase(SGPosition(prevSgSide.getBase().getSeqID(),
                                    prevSgSide.getBase().getPos() + segLen -1));
    }
    outPath.push_back(SGSegment(prevSgSide, segLen));
    pathLength += segLen;
    prevHalPos = halPos;
    prevSgSide = sgSide;
  }

  sg_int_t segLen = halEnd.getPos() - prevHalPos + 1;
  assert(segLen > 0);
  if (prevSgSide.getForward() == false)
  {
    prevSgSide.setBase(SGPosition(prevSgSide.getBase().getSeqID(),
                                  prevSgSide.getBase().getPos() + segLen -1));
  }
  outPath.push_back(SGSegment(prevSgSide, segLen));
  pathLength += segLen;
  (void)pathLength;
  if (halStart < halEnd)
  {
    assert(pathLength == halEnd.getPos() - halStart.getPos() + 1);
  }

  // we really wanted our path in the other direction.  flip the
  // order of the vector, and the orientation of every segment. 
  if (backward == true)
  {
    reverse(outPath.begin(), outPath.end());
    for (size_t i = 0; i < outPath.size(); ++i)
    {
      outPath[i].flip();
    }
  }  
}