C++ (Cpp) isValidBase Examples

Example #1

File: MorphTarget.cpp Project: TheRyaz/c_reading

void MorphTarget::apply( Model* model, float weight ) 
{
	assert( m_scale > 0.f || m_deltas.size() == 0 );
	assert( isValidBase(model) );

	if ( weight > Float::MIN_VALUE && m_scale > Float::MIN_VALUE )
	{
		float* vdata = 0;
		int vpitch = 0;
		model->getVertexPositionData( &vdata, &vpitch );

		float s = m_scale * weight;
		int deltaCount = m_deltas.size();
		for ( int i = 0 ; i < deltaCount ; ++i )
		{
			const Delta& delta = m_deltas[i];
			Vector3 d( 
				((float)delta.dx - 16384.f) * s, 
				((float)delta.dy - 16384.f) * s, 
				((float)delta.dz - 16384.f) * s );

			float* p = vdata + vpitch*(int)delta.vertexIndex;
			p[0] += d.x;
			p[1] += d.y;
			p[2] += d.z;
		}
	}
}

Example #2

File: formatreal.cpp Project: ruphy/speedcrunch

bool RealFormat::setScaleBase(char aBase)
{
  if (!isValidBase(aBase))
    return false;
  scalebase = aBase;
  return true;
}

Example #3

File: formatreal.cpp Project: ruphy/speedcrunch

bool RealFormat::setSignificandBase(char aBase)
{
  if (!isValidBase(aBase))
    return false;
  significandbase = aBase;
  return true;
}

Example #4

File: ClassifyVariant.cpp Project: Lingrui/TS

void AlleleIdentity::SubCategorizeMNP(const LocalReferenceContext &reference_context) {
  // This function only works for the n Base -> n Base mnp representation
  // Possible misalign, align by right shift, example:
  //    Ref:   AAGGGTTTTCCAT
  //    Alt:    GGTTTCCCAT
  // Algorithm:
  //    for HP base in Alt (eg G, T, C)
  //       if (0th base)
  //          find HP base in ref to right
  //       else
  //          find next right adjacent HP base
  //       test if same base
  //   If all match, flag for realignment (possible on right)
  //   repeat for left side
  // 
  // Variant may actually be part of an undercalled or overcalled HP

  if ( ! reference_context.context_detected )
    return;

  assert(altAllele.size()==reference_context.reference_allele.size());
  
  //   possible misalign, align by left shift)
  //   Ref:   GGTTAC   (refBaseLeft = G = reference_context.ref_left_hp_base)
  //   Var:     GTAA
  //   Ref:   GTTTAC   (refBaseLeft = T = reference_context.reference_allele.at(start_index))
  //   Var:     GTAC
  int start_index = left_anchor;                    // start index of real variant
  char altBaseLeft = altAllele.at(start_index);
  int altPos = start_index;

  long ref_start_pos = reference_context.position0 + start_index;  
  char refBaseLeft = (reference_context.my_hp_start_pos.at(start_index) == ref_start_pos)
    ? reference_context.ref_left_hp_base : reference_context.reference_allele.at(start_index);
  int refPos =  (reference_context.my_hp_start_pos.at(start_index) == ref_start_pos)
    ? start_index -1 : start_index;

  bool leftAlign = true;

  char altBase =  altBaseLeft;
  char refBase =  refBaseLeft;
  while ( isValidBase(altBase) && isValidBase(refBase) ) {
    if ( altBase != refBase ){
      leftAlign = false;
      break;
    }
    refBase = getNextHPBase(reference_context.reference_allele, &refPos, refBase, 1);
    altBase = getNextHPBase(altAllele, &altPos, altBase, 1);  
  }
  
  if (leftAlign) {
    status.doRealignment = true;
  }
   
  if (!leftAlign) {
    //   Ref:   AGTT
    //   Var:   GT   (possible misalign, align by right shift)
    int end_index = altAllele.size()-1-right_anchor;  // end index of real variant
    char altBaseRight = altAllele.at(end_index);
    altPos = end_index;

    ref_hp_length = reference_context.my_hp_length.at(start_index);
    long ref_end_pos = reference_context.position0 + end_index;
    long ref_right_hp_end = reference_context.my_hp_start_pos.at(end_index) + reference_context.my_hp_length.at(end_index);

    char refBaseRight = (ref_end_pos == ref_right_hp_end) ?
      reference_context.ref_right_hp_base : reference_context.reference_allele.at(end_index);
    refPos =  (ref_end_pos == ref_right_hp_end) ? end_index+1 : end_index;

    bool rightAlign = true;

    altBase =  altBaseRight;
    refBase =  refBaseRight;
    while ( isValidBase(altBase) && isValidBase(refBase) ) {
      if ( altBase != refBase ){
	rightAlign = false;
	break;
      }
      refBase = getNextHPBase(reference_context.reference_allele, &refPos, refBase, -1);
      altBase = getNextHPBase(altAllele, &altPos, altBase, -1);  
    }

    if(rightAlign) {
      status.doRealignment = true;
    }
  }

  if (DEBUG > 0 and status.doRealignment) {
    cout << "-Possible MNP alignment error detected-";
  }
}