VarExprReturnSP LitMatrixExprReturn::convertToVarExprReturn( VarExprReturn &varExprReturn ) { SFC::DT dt = getDT(); // assert( dt == varExprReturn.getDT() ); SFCTypesManager::DimensionVector dimensionVector = SFCTypesManager::getDimensions( dt ); if ( dimensionVector.empty() ) { Exprs exprs = DE( getSequence().front() ); VarExprReturnSP varExprReturnSP = VarExprReturn::create( getBlock(), exprs, ExprsProxyVector(), SFCTypesManager::getSingleton().getBasicType( "double" ) ); varExprReturn.combine( "=", varExprReturnSP )->collapse(); return VarExprReturn::create( varExprReturn ); } SFCTypesManager::DimensionVector countVector( dimensionVector.size(), 0 ); for( Sequence::iterator sqnItr = getSequence().begin() ; sqnItr != getSequence().end() ; ++sqnItr ) { for( unsigned int ix = 0 ; ix < (unsigned int) dimensionVector.size() ; ++ix ) { varExprReturn.getExprsProxyVector()[ ix ].setExprs( IE( countVector[ ix ] ) ); } Exprs exprs = BE( varExprReturn.getExprs(), "=", DE( *sqnItr ) ); exprs.buildUdm( getBlock(), SFC::CompoundStatement::meta_stmnt ); for( int ix = dimensionVector.size() ; --ix >= 0 ;) { if ( ++countVector[ix] < dimensionVector[ix] ) break; countVector[ix] = 0; } } return VarExprReturn::create( varExprReturn ); }
virtual void render(bool use_vbo) const { VL_CHECK(GLEW_VERSION_1_4); VL_CHECK(!use_vbo || (use_vbo && (GLEW_ARB_vertex_buffer_object||GLEW_VERSION_1_5||GLEW_VERSION_3_0))) use_vbo &= GLEW_ARB_vertex_buffer_object||GLEW_VERSION_1_5||GLEW_VERSION_3_0; // && indices()->gpuBuffer()->handle() && indices()->sizeGPU(); if ( !use_vbo && !indices()->size() ) return; // apply patch parameters if any and if using PT_PATCHES applyPatchParameters(); // primitive restart enable if(primitiveRestartEnabled()) { if(GLEW_VERSION_3_1) { glEnable(GL_PRIMITIVE_RESTART); glPrimitiveRestartIndex(primitiveRestartIndex()); } else if(GLEW_NV_primitive_restart) { glEnable(GL_PRIMITIVE_RESTART_NV); glPrimitiveRestartIndexNV(primitiveRestartIndex()); } else { vl::Log::error("MultiDrawElements error: primitive restart not supported by this OpenGL implementation!\n"); VL_TRAP(); return; } } GLvoid **indices_ptr = (GLvoid**)&mPointerVector[0]; if (use_vbo && indices()->gpuBuffer()->handle()) { VL_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices()->gpuBuffer()->handle()); indices_ptr = (GLvoid**)&mNULLPointerVector[0]; } else VL_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); if (baseVertices().size()) { VL_CHECK( baseVertices().size() == pointerVector().size() ) VL_CHECK( baseVertices().size() == countVector().size() ) if (GLEW_ARB_draw_elements_base_vertex || GLEW_VERSION_3_1) glMultiDrawElementsBaseVertex( primitiveType(), (GLsizei*)&mCountVector[0], indices()->glType(), indices_ptr, (GLsizei)mCountVector.size(), (GLint*)&mBaseVertices[0] ); else { vl::Log::error("MultiDrawElements::render(): glMultiDrawElementsBaseVertex() not supported!\n" "OpenGL 3.1 or GL_ARB_draw_elements_base_vertex extension required.\n" ); } }
// Correct a read with a k-mer based corrector ErrorCorrectResult ErrorCorrectProcess::kmerCorrection(const SequenceWorkItem& workItem) { ErrorCorrectResult result; typedef std::map<std::string, int> KmerCountMap; KmerCountMap kmerCache; SeqRecord currRead = workItem.read; std::string readSequence = workItem.read.seq.toString(); #ifdef KMER_TESTING std::cout << "Kmer correcting read " << workItem.read.id << "\n"; #endif if((int)readSequence.size() < m_params.kmerLength) { // The read is shorter than the kmer length, nothing can be done result.correctSequence = readSequence; result.kmerQC = false; return result; } int n = readSequence.size(); int nk = n - m_params.kmerLength + 1; // Are all kmers in the read well-represented? bool allSolid = false; bool done = false; int rounds = 0; int maxAttempts = m_params.numKmerRounds; // For each kmer, calculate the minimum phred score seen in the bases // of the kmer std::vector<int> minPhredVector(nk, 0); for(int i = 0; i < nk; ++i) { int end = i + m_params.kmerLength - 1; int minPhred = std::numeric_limits<int>::max(); for(int j = i; j <= end; ++j) { int ps = workItem.read.getPhredScore(j); if(ps < minPhred) minPhred = ps; } minPhredVector[i] = minPhred; } while(!done && nk > 0) { // Compute the kmer counts across the read // and determine the positions in the read that are not covered by any solid kmers // These are the candidate incorrect bases std::vector<int> countVector(nk, 0); std::vector<int> solidVector(n, 0); for(int i = 0; i < nk; ++i) { std::string kmer = readSequence.substr(i, m_params.kmerLength); // First check if this kmer is in the cache // If its not, find its count from the fm-index and cache it int count = 0; KmerCountMap::iterator iter = kmerCache.find(kmer); if(iter != kmerCache.end()) { count = iter->second; } else { count = BWTAlgorithms::countSequenceOccurrencesWithCache(kmer, m_params.pOverlapper->getBWT(), m_params.pIntervalCache); kmerCache.insert(std::make_pair(kmer, count)); } // Get the phred score for the last base of the kmer int phred = minPhredVector[i]; countVector[i] = count; // std::cout << i << "\t" << phred << "\t" << count << "\n"; // Determine whether the base is solid or not based on phred scores int threshold = CorrectionThresholds::Instance().getRequiredSupport(phred); if(count >= threshold) { for(int j = i; j < i + m_params.kmerLength; ++j) solidVector[j] = 1; } } allSolid = true; for(int i = 0; i < n; ++i) { #ifdef KMER_TESTING std::cout << "Position[" << i << "] = " << solidVector[i] << "\n"; #endif if(solidVector[i] != 1) allSolid = false; } #ifdef KMER_TESTING std::cout << "Read " << workItem.read.id << (allSolid ? " is solid\n" : " has potential errors\n"); #endif // Stop if all kmers are well represented or we have exceeded the number of correction rounds if(allSolid || rounds++ > maxAttempts) break; // Attempt to correct the leftmost potentially incorrect base bool corrected = false; for(int i = 0; i < n; ++i) { if(solidVector[i] != 1) { // Attempt to correct the base using the leftmost covering kmer int phred = workItem.read.getPhredScore(i); int threshold = CorrectionThresholds::Instance().getRequiredSupport(phred); int left_k_idx = (i + 1 >= m_params.kmerLength ? i + 1 - m_params.kmerLength : 0); corrected = attemptKmerCorrection(i, left_k_idx, std::max(countVector[left_k_idx], threshold), readSequence); if(corrected) break; // base was not corrected, try using the rightmost covering kmer size_t right_k_idx = std::min(i, n - m_params.kmerLength); corrected = attemptKmerCorrection(i, right_k_idx, std::max(countVector[right_k_idx], threshold), readSequence); if(corrected) break; } } // If no base in the read was corrected, stop the correction process if(!corrected) { assert(!allSolid); done = true; } } if(allSolid) { result.correctSequence = readSequence; result.kmerQC = true; } else { result.correctSequence = workItem.read.seq.toString(); result.kmerQC = false; } return result; }