#include <filter.hpp>

Public Member Functions
	Filter ()

	~Filter ()

bool	perfect_filter (Alignment &aln)

bool	anchored_filter (Alignment &aln)

bool	mark_sv_alignments (Alignment &a, Alignment &b)

bool	mark_smallVariant_alignments (Alignment &a, Alignment &b)

Alignment	depth_filter (Alignment &aln)

Alignment	qual_filter (Alignment &aln)

Alignment	coverage_filter (Alignment &aln)

Alignment	avg_qual_filter (Alignment &aln)

Alignment	percent_identity_filter (Alignment &aln)

bool	soft_clip_filter (Alignment &aln)

bool	unmapped_filter (Alignment &aln)

bool	split_read_filter (Alignment &aln)

Alignment	path_divergence_filter (Alignment &aln)

Alignment	reversing_filter (Alignment &aln)

vector< Alignment >	remap (Alignment &aln)

vector< Alignment >	remap (string seq)

bool	is_left_clipped (Alignment &a)

pair< Alignment, int >	refactor_split_alignment (Alignment &a)

Alignment	path_length_filter (Alignment &aln)

bool	one_end_anchored_filter (Alignment &aln_first, Alignment &aln_second)

bool	interchromosomal_filter (Alignment &aln_first, Alignment &aln_second)

bool	insert_size_filter (Alignment &aln_first, Alignment &aln_second)

bool	pair_orientation_filter (Alignment &aln_first, Alignment &aln_second)

pair< Alignment, Alignment >	deletion_filter (Alignment &aln_first, Alignment &aln_second)

pair< Locus, Locus >	insertion_filter (Alignment &aln_first, Alignment &aln_second)

pair< Locus, Locus >	duplication_filter (Alignment &aln_first, Alignment &aln_second)

bool	inversion_filter (Alignment &aln_first, Alignment &aln_second)

pair< Locus, Locus >	breakend_filter (Alignment &aln_first, Alignment &aln_second)

void	set_min_depth (int depth)

void	set_min_qual (int qual)

void	set_min_percent_identity (double pct_id)

void	set_avg (bool do_avg)

void	set_filter_matches (bool fm)

void	set_remove_failing_edits (bool fm)

void	set_soft_clip_limit (int max_clip)

void	set_split_read_limit (int split_limit)

void	set_window_length (int window_length)

void	set_my_vg (vg::VG *vg)

void	set_my_path_position_graph (PathPositionHandleGraph *graph)

void	set_inverse (bool do_inv)

void	init_mapper ()

void	fill_node_to_position (string pathname)

int64_t	distance_between_positions (Position first, Position second)

string	get_clipped_seq (Alignment &a)

int64_t	get_clipped_ref_position (Alignment &a)

Position	get_clipped_position (Alignment &a)

Alignment	remove_clipped_portion (Alignment &a)

Public Attributes
vg::VG *	my_vg = NULL

PathPositionHandleGraph *	my_path_position_graph = NULL

gcsa::GCSA *	gcsa_ind

gcsa::LCPArray *	lcp_ind

Mapper *	my_mapper

map< int64_t, int64_t >	node_to_position

unordered_map< string, unordered_map< string, int > >	pos_to_edit_to_depth

unordered_map< int, int >	pos_to_qual

bool	inverse = false

bool	do_remap = false

bool	remove_failing_edits = false

bool	filter_matches = false

bool	use_avg = false

int	min_depth = 0

int	min_qual = 0

int	min_cov = 0

int	window_length = 0

int	qual_offset = 0

int	soft_clip_limit = -1

int	split_read_limit = -1

double	min_percent_identity = 0.0

double	min_avg_qual = 0.0

int	max_path_length = 0

int	my_max_distance = 1000

float	insert_mean = 1000

float	insert_sd = 100

Constructor & Destructor Documentation

◆ Filter()

vg::Filter::Filter ( )

◆ ~Filter()

vg::Filter::~Filter ( )

Member Function Documentation

◆ anchored_filter()

bool vg::Filter::anchored_filter ( Alignment & aln )

◆ avg_qual_filter()

Alignment vg::Filter::avg_qual_filter ( Alignment & aln )

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

◆ breakend_filter()

pair< Locus, Locus > vg::Filter::breakend_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

split reads or discordant reads/insert size may indicate a breakend but not a clean SV type we'd like to report all possible breakends, even if that don't match an SV type very well.

◆ coverage_filter()

Alignment vg::Filter::coverage_filter ( Alignment & aln )

◆ deletion_filter()

pair< Alignment, Alignment > vg::Filter::deletion_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

◆ depth_filter()

Alignment vg::Filter::depth_filter ( Alignment & aln )

If an edit fails the filter, either return a new empty alignment OR return a new alignment identical to the old one EXCEPT where the offending edit has been replaced by a match to the reference.

◆ distance_between_positions()

int64_t vg::Filter::distance_between_positions	(	Position	first,
		Position	second
	)

◆ duplication_filter()

pair< Locus, Locus > vg::Filter::duplication_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

Find reads that support duplications

◆ fill_node_to_position()

void vg::Filter::fill_node_to_position ( string pathname )

◆ get_clipped_position()

Position vg::Filter::get_clipped_position ( Alignment & a )

Get the position of the first match

◆ get_clipped_ref_position()

int64_t vg::Filter::get_clipped_ref_position ( Alignment & a )

Get the position of the first match

◆ get_clipped_seq()

string vg::Filter::get_clipped_seq ( Alignment & a )

◆ init_mapper()

void vg::Filter::init_mapper ( )

◆ insert_size_filter()

bool vg::Filter::insert_size_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

◆ insertion_filter()

pair< Locus, Locus > vg::Filter::insertion_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

Filters insertion-characterizing reads based upon discordant pairs (fragment length too short) one-end anchored / softclipped portions and read depth, one day

◆ interchromosomal_filter()

bool vg::Filter::interchromosomal_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

◆ inversion_filter()

bool vg::Filter::inversion_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

Find reads that support inversions split reads discordant insert size bad orientation instead of -—> <--— we'll see <-— <--— or -—> --—>

◆ is_left_clipped()

bool vg::Filter::is_left_clipped ( Alignment & a )

◆ mark_smallVariant_alignments()

bool vg::Filter::mark_smallVariant_alignments	(	Alignment &	a,
		Alignment &	b
	)

◆ mark_sv_alignments()

bool vg::Filter::mark_sv_alignments	(	Alignment &	a,
		Alignment &	b
	)

◆ one_end_anchored_filter()

bool vg::Filter::one_end_anchored_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

◆ pair_orientation_filter()

bool vg::Filter::pair_orientation_filter	(	Alignment &	aln_first,
		Alignment &	aln_second
	)

◆ path_divergence_filter()

Alignment vg::Filter::path_divergence_filter ( Alignment & aln )

Looks for alignments that transition from one path to another over their length. This may occur for one of several reasons:

The read covers a translocation
The read looks a lot like two different (but highly-similar paths)
The read is shattered (e.g. as in chromothripsis)

Default behavior: if the Alignment is path divergent, return an empty Alignment, else return aln Inverse behavior: if the Alignment is path divergent, return aln, else return an empty Alignment

◆ path_length_filter()

Alignment vg::Filter::path_length_filter ( Alignment & aln )

◆ percent_identity_filter()

Alignment vg::Filter::percent_identity_filter ( Alignment & aln )

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.

◆ perfect_filter()

bool vg::Filter::perfect_filter ( Alignment & aln )

◆ qual_filter()

Alignment vg::Filter::qual_filter ( Alignment & aln )

Looks for Alignments that have large overhangs at the end of them.

Default behavior: if an alignment has a right- or left- clip that is longer than the maximum allowed, return an empty alignment.

Inverse Behavior: if the alignment has a clip that is larger than the maximum allowed at either end, return the alignment. CLI: vg filter -d 10 -q 40 -r -R -r: track depth of both novel variants and those in the graph. -R: remove edits that fail the filter (otherwise toss the whole alignment)

◆ refactor_split_alignment()

pair< Alignment, int > vg::Filter::refactor_split_alignment ( Alignment & a )

◆ remap() [1/2]

vector< Alignment > vg::Filter::remap ( Alignment & aln )

◆ remap() [2/2]

vector< Alignment > vg::Filter::remap ( string seq )

◆ remove_clipped_portion()

Alignment vg::Filter::remove_clipped_portion ( Alignment & a )

◆ reversing_filter()

Alignment vg::Filter::reversing_filter ( Alignment & aln )

Looks for alignments that change direction over their length. This may happen because of:

Mapping artifacts
Cycles
Highly repetitive regions
Inversions (if you're lucky enough)

Default behavior: if the Alignment reverses, return an empty Alignment. inverse behavior: if the Alignment reverses, return the Alignment.

◆ set_avg()

void vg::Filter::set_avg ( bool do_avg )

◆ set_filter_matches()

void vg::Filter::set_filter_matches ( bool fm )

◆ set_inverse()

void vg::Filter::set_inverse ( bool do_inv )

◆ set_min_depth()

void vg::Filter::set_min_depth ( int depth )

◆ set_min_percent_identity()

void vg::Filter::set_min_percent_identity ( double pct_id )

◆ set_min_qual()

void vg::Filter::set_min_qual ( int qual )

◆ set_my_path_position_graph()

void vg::Filter::set_my_path_position_graph ( PathPositionHandleGraph * graph )

◆ set_my_vg()

void vg::Filter::set_my_vg ( vg::VG * vg )

◆ set_remove_failing_edits()

void vg::Filter::set_remove_failing_edits ( bool fm )

◆ set_soft_clip_limit()

void vg::Filter::set_soft_clip_limit ( int max_clip )

◆ set_split_read_limit()

void vg::Filter::set_split_read_limit ( int split_limit )

◆ set_window_length()

void vg::Filter::set_window_length ( int window_length )

◆ soft_clip_filter()

bool vg::Filter::soft_clip_filter ( Alignment & aln )

◆ split_read_filter()

bool vg::Filter::split_read_filter ( Alignment & aln )

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.

◆ unmapped_filter()

bool vg::Filter::unmapped_filter ( Alignment & aln )

Member Data Documentation

◆ do_remap

bool vg::Filter::do_remap = false

◆ filter_matches

bool vg::Filter::filter_matches = false

◆ gcsa_ind

gcsa::GCSA* vg::Filter::gcsa_ind

◆ insert_mean

float vg::Filter::insert_mean = 1000

◆ insert_sd

float vg::Filter::insert_sd = 100

◆ inverse

bool vg::Filter::inverse = false

◆ lcp_ind

gcsa::LCPArray* vg::Filter::lcp_ind

◆ max_path_length

int vg::Filter::max_path_length = 0

◆ min_avg_qual

double vg::Filter::min_avg_qual = 0.0

◆ min_cov

int vg::Filter::min_cov = 0

◆ min_depth

int vg::Filter::min_depth = 0

◆ min_percent_identity

double vg::Filter::min_percent_identity = 0.0

◆ min_qual

int vg::Filter::min_qual = 0

◆ my_mapper

Mapper* vg::Filter::my_mapper

◆ my_max_distance

int vg::Filter::my_max_distance = 1000

◆ my_path_position_graph

PathPositionHandleGraph* vg::Filter::my_path_position_graph = NULL

◆ my_vg

vg::VG* vg::Filter::my_vg = NULL

◆ node_to_position

map<int64_t, int64_t> vg::Filter::node_to_position

◆ pos_to_edit_to_depth

unordered_map<string, unordered_map<string, int> > vg::Filter::pos_to_edit_to_depth

◆ pos_to_qual

unordered_map<int, int> vg::Filter::pos_to_qual

◆ qual_offset

int vg::Filter::qual_offset = 0

◆ remove_failing_edits

bool vg::Filter::remove_failing_edits = false

◆ soft_clip_limit

int vg::Filter::soft_clip_limit = -1

◆ split_read_limit

int vg::Filter::split_read_limit = -1

◆ use_avg

bool vg::Filter::use_avg = false

◆ window_length

int vg::Filter::window_length = 0

The documentation for this class was generated from the following files:

src/filter.hpp
src/filter.cpp

Public Member Functions

Public Attributes