/** * Filter reads that are less than <PCTID> reference. * I.E. if a read matches the reference along 80% of its * length, and your cutoff is 90% PCTID, throw it out. */ Alignment Filter::percent_identity_filter(Alignment& aln){ double read_pctid = 0.0; //read pct_id = len(matching sequence / len(total sequence) int64_t aln_total_len = aln.sequence().size(); int64_t aln_match_len = 0; std::function<double(int64_t, int64_t)> calc_pct_id = [](int64_t rp, int64_t ttlp){ return ((double) rp / (double) ttlp); }; Path path = aln.path(); //TODO handle reversing mappings for (int i = 0; i < path.mapping_size(); i++){ Mapping mapping = path.mapping(i); for (int j = 0; j < mapping.edit_size(); j++){ Edit ee = mapping.edit(j); if (ee.from_length() == ee.to_length() && ee.sequence() == ""){ aln_match_len += ee.to_length(); } } } if (calc_pct_id(aln_match_len, aln_total_len) < min_percent_identity){ return inverse ? aln : Alignment(); } return inverse ? Alignment() : aln; }
Alignment Filter::soft_clip_filter(Alignment& aln){ //Find overhangs - portions of the read that // are inserted at the ends. if (aln.path().mapping_size() > 0){ Path path = aln.path(); Edit left_edit = path.mapping(0).edit(0); Edit right_edit = path.mapping(path.mapping_size() - 1).edit(path.mapping(path.mapping_size() - 1).edit_size() - 1); int left_overhang = left_edit.to_length() - left_edit.from_length(); int right_overhang = right_edit.to_length() - right_edit.from_length(); if (left_overhang > soft_clip_limit || right_overhang > soft_clip_limit){ return inverse ? Alignment() : aln; } else{ return inverse ? aln : Alignment(); } } else{ if (aln.sequence().length() > soft_clip_limit){ return inverse ? Alignment() : aln; } cerr << "WARNING: SHORT ALIGNMENT: " << aln.sequence().size() << "bp" << endl << "WITH NO MAPPINGS TO REFERENCE" << endl << "CONSIDER REMOVING IT FROM ANALYSIS" << endl; return inverse ? Alignment() : aln; } }
pair<Alignment, Alignment> Filter::orientation_filter(Alignment& aln_first, Alignment& aln_second){ bool f_rev = false; bool s_rev = false; Path f_path = aln_first.path(); Path s_path = aln_second.path(); for (int i = 0; i < f_path.mapping_size(); i++){ if (f_path.mapping(i).position().is_reverse()){ f_rev = true; } } for (int j = 0; j < s_path.mapping_size(); j++){ if (s_path.mapping(j).position().is_reverse()){ s_rev = true; } } if (!s_rev != !f_rev){ return inverse ? std::make_pair(aln_first, aln_second) : std::make_pair(Alignment(), Alignment()); } else{ return inverse ? std::make_pair(Alignment(), Alignment()) : std::make_pair(aln_first, aln_second); } }
pair<Alignment, Alignment> Filter::interchromosomal_filter(Alignment& aln_first, Alignment& aln_second){ if (aln_first.path().name() != aln_second.path().name()){ return std::make_pair(aln_first, aln_second); } else{ return std::make_pair(Alignment(), Alignment()); } }
/*PE Functions*/ pair<Alignment, Alignment> Filter::one_end_anchored_filter(Alignment& aln_first, Alignment& aln_second){ if (aln_first.mapping_quality() == 0 | aln_second.mapping_quality() == 0){ return inverse ? std::make_pair(Alignment(), Alignment()) : std::make_pair(aln_first, aln_second); } else{ return inverse ? std::make_pair(aln_first, aln_second) : std::make_pair(Alignment(), Alignment()); } }
Alignment Filter::interchromosomal_filter(Alignment& aln){ bool fails = aln.path().name() != aln.fragment_prev().path().name(); if (fails){ return inverse ? Alignment() : aln; } else{ return inverse ? aln : Alignment(); } }
std::pair<Alignment, Alignment> Filter::path_length_filter(Alignment& aln_first, Alignment& aln_second){ Alignment x = path_length_filter(aln_first); Alignment y = path_length_filter(aln_second); if (x.name().empty() || y.name().empty()){ return inverse ? make_pair(x, y) : make_pair(Alignment(), Alignment()); } else{ return inverse ? make_pair(Alignment(), Alignment()) : make_pair(x, y); } }
pair<Alignment, Alignment> Filter::insert_size_filter(Alignment& aln_first, Alignment& aln_second){ // TODO: gret positions from aln_first and aln_second int distance = my_xg_index->approx_path_distance(aln_first.path().name(), 1, 1); if (distance > my_max_distance){ return std::make_pair(aln_first, aln_second); } else{ return std::make_pair(Alignment(), Alignment()); } }
pair<Alignment, Alignment> Filter::depth_filter(Alignment& aln_first, Alignment& aln_second){ aln_first = depth_filter(aln_first); aln_second = depth_filter(aln_second); if (!(aln_first.name() == "") && !(aln_first.name() == "")){ return inverse ? make_pair(aln_first, aln_second) : make_pair(Alignment(), Alignment()); } else{ return inverse ? make_pair(Alignment(), Alignment()) : make_pair(aln_first, aln_second); } }
pair<Alignment, Alignment> percent_identity_filter(Alignment& aln_first, Alignment& aln_second){ if (aln_first.name() == "" || aln_first.name() == ""){ return make_pair(Alignment(), Alignment()); } else{ return make_pair(aln_first, aln_second); } }
pair<Alignment, Alignment> Filter::soft_clip_filter(Alignment& aln_first, Alignment& aln_second){ Alignment a_check = soft_clip_filter(aln_first); Alignment b_check = soft_clip_filter(aln_second); if (a_check.name() == "" || b_check.name() == ""){ return inverse ? make_pair(Alignment(), Alignment()) : make_pair(aln_first, aln_second) ; } else{ return inverse ? make_pair(aln_first, aln_second) : make_pair(Alignment(), Alignment()) ; } }
/* PE functions using fragment_prev and fragment_next */ Alignment Filter::one_end_anchored_filter(Alignment& aln){ if (aln.fragment_prev().name() != ""){ if (aln.path().name() == "" || aln.fragment_prev().path().name() == ""){ inverse ? Alignment() : aln; } else{ inverse ? aln : Alignment(); } } else{ return inverse ? aln : Alignment(); } }
Alignment Filter::avg_qual_filter(Alignment& aln){ double total_qual = 0.0; // If the parameter for window size is zero, set the local equivalent // to the entire size of the qual scores. int win_len = window_length; //>= 1 ? window_length : aln.quality().size(); cerr << "UNTESTED" << endl; exit(1); std::function<double(int64_t, int64_t)> calc_avg_qual = [](int64_t total_qual, int64_t length){ return ((double) total_qual / (double) length); }; /** * Helper function. * Sums qual scores from start : start + window_length * if start + window_len > qualstr.size(), return a negative float * otherwise return the average quality within the window * */ std::function<double(string, int, int)> window_qual = [&](string qualstr, int start, int window_length){ if (start + window_length > qualstr.size()){ return -1.0; } total_qual = 0.0; for (int i = start; i < start + window_length; i++){ total_qual += (int) qualstr[i]; } return calc_avg_qual(total_qual, window_length); }; //TODO: handle reversing alignments string quals = aln.quality(); for (int i = 0; i < quals.size() - win_len; i++){ double w_qual = window_qual(quals, i, win_len); if ( w_qual < 0.0){ break; } if (w_qual < min_avg_qual){ return inverse ? aln : Alignment(); } } return inverse ? Alignment() : aln; }
Alignment Filter::path_length_filter(Alignment& aln){ for (int i = 0; i < aln.fragment_size(); i++){ Path t = aln.fragment(i); if (t.length() > this->max_path_length){ return inverse ? Alignment() : aln; } else{ return inverse ? aln : Alignment(); } } return inverse ? aln : Alignment(); }
void BTitledColumn::DrawString(const char* string, BView* parent, BRect rect) { float width = rect.Width() - (2 * kTEXT_MARGIN); float y; BFont font; font_height finfo; parent->GetFont(&font); font.GetHeight(&finfo); y = rect.top + ((rect.Height() - (finfo.ascent + finfo.descent + finfo.leading)) / 2) + (finfo.ascent + finfo.descent) - 2; switch (Alignment()) { default: case B_ALIGN_LEFT: parent->MovePenTo(rect.left + kTEXT_MARGIN, y); break; case B_ALIGN_CENTER: parent->MovePenTo(rect.left + kTEXT_MARGIN + ((width - font.StringWidth(string)) / 2), y); break; case B_ALIGN_RIGHT: parent->MovePenTo(rect.right - kTEXT_MARGIN - font.StringWidth(string), y); break; } parent->DrawString(string); }
//------------------------------------------------------------------------------ status_t BMenuField::Archive(BMessage *data, bool deep) const { BView::Archive(data, deep); if (Label()) data->AddString("_label", Label()); if (!IsEnabled()) data->AddBool("_disable", true); data->AddInt32("_align", Alignment()); data->AddFloat("_divide", Divider()); if (fFixedSizeMB) data->AddBool("be:fixeds", true); BMenuItem *item = fMenuBar->ItemAt(0); if (!item) return B_OK; _BMCItem_ *bmcitem = dynamic_cast<_BMCItem_*>(item); if (bmcitem && !bmcitem->fShowPopUpMarker) data->AddBool("be:dmark", false); return B_OK; }
void test4() { std::string string_a = "AGAGTCAATCCATAG"; std::string string_b = "CAGAGGTCCATCATG"; std::vector<std::vector<int>> similarity = { {+2, +0, +0, +0, -1}, {+0, +2, +0, +0, -1}, {+0, +0, +2, +0, -1}, {+0, +0, +0, +2, -1}, {-1, -1, -1, -1, +2} }; Alignment alignment = Alignment(string_a, string_b, Alignment::STR_WEIGHTS(1, -1, -1), similarity, [](int j) { return -(j+2); }); std::pair<std::string, std::string> result = alignment.global_alignment(); std::string expected_a = "-AGAG-TCAATCCATAG"; std::string expected_b = "CAGAGGTCCATC-AT-G"; if (result.first != expected_a || result.second != expected_b) { alignment.debugS(); this->testFailed("Test4"); } }
void Slider::updateSliderTrack(void) { Pnt2f BorderTopLeft, BorderBottomRight; getInsideInsetsBounds(BorderTopLeft, BorderBottomRight); UInt16 MajorAxis, MinorAxis; if(getOrientation() == VERTICAL_ORIENTATION) { MajorAxis = 1; } else { MajorAxis = 0; } MinorAxis = (MajorAxis+1)%2; //Update the Knob position if(getKnobButton() != NULL && getRangeModel() != NULL) { Vec2f Size; Size[MinorAxis] = getKnobButton()->getPreferredSize().x(); Size[MajorAxis] = getKnobButton()->getPreferredSize().y(); Pnt2f AlignedPosition; //Size[MajorAxis] = getSize()[MajorAxis] - 2; Vec2f Alignment(0.5,0.5); Alignment[MajorAxis] = static_cast<Real32>(getValue() - getMinimum())/static_cast<Real32>(getMaximum() - getMinimum()); AlignedPosition = calculateSliderAlignment(getSliderTrackTopLeft(), getSliderTrackSize(), getKnobButton()->getPreferredSize(), Alignment.y(), Alignment.x()); getKnobButton()->setPosition(AlignedPosition); getKnobButton()->setSize(Size); } }
void BBitmapColumn::DrawField(BField* field, BRect rect, BView* parent) { BBitmapField *bitmapField = static_cast<BBitmapField *>(field); const BBitmap *bitmap = bitmapField->Bitmap(); if (bitmap != NULL) { float x = 0.0; float y; BRect r = bitmap->Bounds(); y = rect.top + ((rect.Height() - r.Height()) / 2); switch (Alignment()) { case B_ALIGN_LEFT: x = rect.left + kTEXT_MARGIN; break; case B_ALIGN_CENTER: x = rect.left + ((rect.Width() - r.Width()) / 2); break; case B_ALIGN_RIGHT: x = rect.right - kTEXT_MARGIN - r.Width(); break; } parent->SetDrawingMode(B_OP_ALPHA); parent->DrawBitmap(bitmap, BPoint(x, y)); parent->SetDrawingMode(B_OP_OVER); } }
void NumberEntry::Paint(Bitmap *destination, int x, int y, int width, bool selected) { int totalWidth; totalWidth = 0; for (int i = 0; i < m_count; i++) totalWidth += Width(m_items + i); switch (Alignment()) { default: case caLeft: // x is already left break; case caCentre: x += (width - totalWidth) / 2; break; case caRight: x += width - totalWidth; break; } int itemHeight = Height(); for (int i = 0; i < m_count; i++) { HOLDER *item = m_items + i; int itemWidth = Width(item); bool invert = selected && (m_index == i); if (invert) destination->FillRect(x, y, x + itemWidth, y + itemHeight, true); Print(destination, item, x, y, invert); x += itemWidth; } }
void write_alignments(std::ostream& out, vector<Alignment>& buf) { function<Alignment(uint64_t)> lambda = [&buf] (uint64_t n) { return buf[n]; }; stream::write(cout, buf.size(), lambda); }
status_t BMenuField::Archive(BMessage* data, bool deep) const { BArchiver archiver(data); status_t ret = BView::Archive(data, deep); if (ret == B_OK && Label()) ret = data->AddString("_label", Label()); if (ret == B_OK && !IsEnabled()) ret = data->AddBool("_disable", true); if (ret == B_OK) ret = data->AddInt32("_align", Alignment()); if (ret == B_OK) ret = data->AddFloat("_divide", Divider()); if (ret == B_OK && fFixedSizeMB) ret = data->AddBool("be:fixeds", true); bool dmark = false; if (_BMCMenuBar_* menuBar = dynamic_cast<_BMCMenuBar_*>(fMenuBar)) dmark = menuBar->IsPopUpMarkerShown(); data->AddBool("be:dmark", dmark); return archiver.Finish(ret); }
void CTableFormatter::ApplyCellAlignmentRules(CTableFormatting& Formatting, const CTableFormatRuleSet& RuleSet) { CPoint cpMax = Formatting.m_cpTableDims; CRect crArea = Formatting.m_crArea; CPoint cpCell; // Run through all the cells and apply the rules. for (cpCell.y = crArea.top; cpCell.y <= crArea.bottom; cpCell.y++) { for (cpCell.x = crArea.left; cpCell.x <= crArea.right; cpCell.x++) { // Apply the cell rules. const CTableCellAlignmentRule* pRule = RuleSet.m_pCellAlignmentRules; for (int nRule = 0; nRule < RuleSet.m_nCellAlignmentRules; nRule++, pRule++) { if (pRule->RuleMatches(cpCell, cpMax)) { Formatting.m_CellAlignments.Add(&pRule->m_CellAlignment); break; } } // We need to find some matching rule. if (nRule == RuleSet.m_nCellAlignmentRules) { // We did not find a rule. ASSERT(FALSE); CTableCellAlignment Alignment(ALIGN_left, ALIGN_top); Formatting.m_CellAlignments.Add(&Alignment); } } } }
void test2() { std::string string_a = "CAGCCCTAC"; std::string string_b = "CCTGTACCC"; std::vector<std::vector<int>> similarity = { {+2, +0, +0, +0, -1}, {+0, +2, +0, +0, -1}, {+0, +0, +2, +0, -1}, {+0, +0, +0, +2, -1}, {-1, -1, -1, -1, +2} }; Alignment alignment = Alignment(string_a, string_b, Alignment::STR_WEIGHTS(1, -1, -1), similarity, [](int j) { return -(1); }); std::pair<std::string, std::string> result = alignment.global_alignment(); std::string expected_a = "CAGCCCTAC--"; std::string expected_b = "C--CTGTACCC"; if (result.first != expected_a || result.second != expected_b) { alignment.debugS(); this->testFailed("Test2"); } }
void test1() { std::string string_a = "GCATGCA"; std::string string_b = "GATTACA"; std::vector<std::vector<int>> similarity = { //A G C T - {+2, +0, +0, +0, -1}, {+0, +2, +0, +0, -1}, {+0, +0, +2, +0, -1}, {+0, +0, +0, +2, -1}, {-1, -1, -1, -1, +2}, }; Alignment alignment = Alignment(string_a, string_b, Alignment::STR_WEIGHTS(1, -1, -1), similarity, [](int j) { return -(j); }); std::pair<std::string, std::string> result = alignment.global_alignment(); std::string expected_a = "GCATG-CA"; std::string expected_b = "G-ATTACA"; std::cout << alignment.get_similarity(); if (result.first != expected_a || result.second != expected_b) { alignment.debugS(); this->testFailed("Test1"); } }
void test5() { std::string string_a = "GTATT"; std::string string_b = "TTT"; std::vector<std::vector<int>> similarity = { //A G C T - {+1, -1, -1, -1, -1}, {-1, +1, -1, -1, -1}, {-1, -1, +1, -1, -1}, {-1, -1, -1, +1, -1}, {-1, -1, -1, -1, +1} }; Alignment alignment = Alignment(string_a, string_b, Alignment::STR_WEIGHTS(1, -1, -1), similarity, [](int j) { return -(j+2); }); int result = alignment.get_similarity(); int expected_result = -3; if (result != expected_result) { alignment.debugS(); this->testFailed("Test5"); } }
void test0() { std::string string_a = "AGAGTCAATCCATAG"; std::string string_b = "CAGAGGTCCATCATG"; std::vector<std::vector<int>> similarity = { //A G C T - {+2, +0, +0, +0, -1}, {+0, +2, +0, +0, -1}, {+0, +0, +2, +0, -1}, {+0, +0, +0, +2, -1}, {-1, -1, -1, -1, +2}, }; Alignment alignment = Alignment(string_a, string_b, Alignment::STR_WEIGHTS(1, -1, -1), similarity); std::pair<std::string, std::string> result = alignment.global_alignment(); std::string expected_a = "-AGAG-TCAATCCATAG"; std::string expected_b = "CAGAGGTCCATC-AT-G"; std::cout << alignment.get_similarity(); if (result.first != expected_a || result.second != expected_b) { alignment.debugS(); this->testFailed("Test0"); } }
HypothesisFixture::HypothesisFixture() { string source = "je ne sais pas . "; vector<string> target; vector<Alignment> alignments; m_empty.reset(new MockHypothesisGuard(source,alignments,target)); target.push_back("i"); target.push_back("do not"); alignments.push_back(Alignment(0,0)); alignments.push_back(Alignment(3,3)); m_partial.reset(new MockHypothesisGuard(source,alignments,target)); target.push_back("know"); target.push_back("."); alignments.push_back(Alignment(1,2)); alignments.push_back(Alignment(4,4)); m_full.reset(new MockHypothesisGuard(source,alignments,target)); }
// Return the alignment HRESULT CAsyncIo::Alignment(LONG *pAlignment) { CheckPointer(pAlignment,E_POINTER); *pAlignment = Alignment(); return S_OK; }
/** * Split reads map to two separate paths in the graph OR vastly separated non-consecutive * nodes in a single path. * * They're super important for detecting structural variants, so we may want to * filter them out or collect only split reads. */ Alignment Filter::split_read_filter(Alignment& aln){ //TODO binary search for breakpoint in read would be awesome. Path path = aln.path(); //check if nodes are on same path(s) int top_side = path.mapping_size() - 1; int bottom_side = 0; Mapping bottom_mapping; Mapping top_mapping; string main_path = ""; while (top_side > bottom_side){ //main_path = path_of_node(path.mapping(bottom_side); // //Check if paths are different //if (divergent(node1, node2){ // return inverse ? aln : Alignment(); //} top_mapping = path.mapping(top_side); bottom_mapping = path.mapping(bottom_side); Position top_pos = top_mapping.position(); Position bot_pos = bottom_mapping.position(); id_t top_id = top_pos.node_id(); id_t bottom_id = bot_pos.node_id(); // TODO USE THE XG if (abs(top_id - bottom_id) > 10){ return inverse ? aln : Alignment(); } // Check if two mappings are far apart // // Check if a single mapping has a huge indel top_side--; bottom_side++; } return inverse ? Alignment() : aln; }