/**
* 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;
}
