filter_transform.hpp

Go to the documentation of this file.

#ifndef GENESIS_POPULATION_FUNCTIONS_FILTER_TRANSFORM_H_
#define GENESIS_POPULATION_FUNCTIONS_FILTER_TRANSFORM_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2022 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include "genesis/population/base_counts.hpp"
#include "genesis/population/functions/functions.hpp"
#include "genesis/population/functions/genome_region.hpp"
#include "genesis/population/genome_region.hpp"
#include "genesis/population/variant.hpp"
 
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace genesis {
namespace population {
 
// =================================================================================================
//     Filter Helpers
// =================================================================================================
 
enum class SampleFilterType
{
    kConjunction,
 
    kDisjunction,
 
    kMerge
};
 
// =================================================================================================
//     Filter by Status
// =================================================================================================
 
bool filter_by_status(
    std::function<bool(BaseCountsStatus const&)> predicate,
    Variant const& variant,
    SampleFilterType type,
    size_t min_coverage = 0,
    size_t max_coverage = 0,
    size_t min_count = 0,
    bool tolerate_deletions = false
);
 
inline std::function<bool(Variant const&)> filter_by_status(
    std::function<bool(BaseCountsStatus const&)> predicate,
    SampleFilterType type,
    size_t min_coverage = 0,
    size_t max_coverage = 0,
    size_t min_count = 0,
    bool tolerate_deletions = false
) {
    return [=]( Variant const& variant ){
        return filter_by_status(
            predicate, variant, type, min_coverage, max_coverage, min_count, tolerate_deletions
        );
    };
}
 
inline bool filter_is_snp(
    Variant const& variant,
    SampleFilterType type,
    size_t min_coverage = 0,
    size_t max_coverage = 0,
    size_t min_count = 0,
    bool tolerate_deletions = false
) {
    return filter_by_status(
        []( BaseCountsStatus const& stat ){
            return stat.is_covered && stat.is_snp;
        },
        variant, type, min_coverage, max_coverage, min_count, tolerate_deletions
    );
}
 
inline std::function<bool(Variant const&)> filter_is_snp(
    SampleFilterType type,
    size_t min_coverage = 0,
    size_t max_coverage = 0,
    size_t min_count = 0,
    bool tolerate_deletions = false
) {
    return [=]( Variant const& variant ){
        return filter_is_snp(
            variant, type, min_coverage, max_coverage, min_count, tolerate_deletions
        );
    };
}
 
inline bool filter_is_biallelic_snp(
    Variant const& variant,
    SampleFilterType type,
    size_t min_coverage = 0,
    size_t max_coverage = 0,
    size_t min_count = 0,
    bool tolerate_deletions = false
) {
    return filter_by_status(
        []( BaseCountsStatus const& stat ){
            return stat.is_covered && stat.is_snp && stat.is_biallelic;
        },
        variant, type, min_coverage, max_coverage, min_count, tolerate_deletions
    );
}
 
inline std::function<bool(Variant const&)> filter_is_biallelic_snp(
    SampleFilterType type,
    size_t min_coverage = 0,
    size_t max_coverage = 0,
    size_t min_count = 0,
    bool tolerate_deletions = false
) {
    return [=]( Variant const& variant ){
        return filter_is_biallelic_snp(
            variant, type, min_coverage, max_coverage, min_count, tolerate_deletions
        );
    };
}
 
// =================================================================================================
//     Filter by Count
// =================================================================================================
 
// TODO
 
// variant_filter_min_coverage
// variant_filter_max_coverage
// variant_filter_min_max_coverage
//
// variant_filter_min_frequency
// variant_filter_max_frequency
// variant_filter_min_max_frequency
 
// bool filter_by_min_maf_count( BaseCounts const& sample, size_t min_count );
//
// bool filter_by_min_maf_count( Variant const& variant, size_t min_count, SampleFilterType type );
//
// bool filter_by_max_count( BaseCounts const& sample, size_t max_count );
//
// bool filter_by_max_count( Variant const& variant, size_t max_count, SampleFilterType type );
 
// =================================================================================================
//     Filter by Region
// =================================================================================================
 
inline std::function<bool(Variant const&)> filter_by_region(
    GenomeRegion const& region,
    bool complement = false
) {
    return [region, complement]( Variant const& variant ){
        return complement ^ is_covered( region, variant );
    };
}
 
inline std::function<bool(Variant const&)> filter_by_region(
    std::shared_ptr<GenomeRegionList> regions,
    bool complement = false
) {
    if( ! regions ) {
        throw std::invalid_argument(
            "Can only used filter_by_region() with a valid shared pointer to a GenomeRegionList."
        );
    }
    return [regions, complement]( Variant const& variant ){
        return complement ^ is_covered( *regions, variant );
    };
}
 
inline std::function<bool(Variant const&)> filter_by_region(
    GenomeRegionList const& regions,
    bool complement = false,
    bool copy_regions = false
) {
    if( copy_regions ) {
        return [regions, complement]( Variant const& variant ){
            return complement ^ is_covered( regions, variant );
        };
    } else {
        return [&regions, complement]( Variant const& variant ){
            return complement ^ is_covered( regions, variant );
        };
    }
}
 
// =================================================================================================
//     Transformations
// =================================================================================================
 
// bascially, all of the above filters, but as transforms that set stuff to 0 intead of filtering
//
// inline std::functiom<void(Variant&)> variant_transform_min_counts( size_t min_count )
// {
//     return [min_count]( Variant& variant ){
//         for( auto& sample : variant.samples ) {
//             transform_min_count( sample, min_count );
//             --> add this function for variants as well first, and use this
//             (basically just a loop over the other one)
//             -->> also make this for max and min max, and use these.
//
//             --->> then, these already have the function signature that is needed for the iterator~
//             no need to do a lambda that just calles it!
//             --> ah no, because we need to capture the min count setting....
//         }
//     };
// }
//
// min count to 0
// max count to 0
// min max count to 0
 
// =================================================================================================
//     Transform by Count
// =================================================================================================
 
void transform_zero_out_by_min_count( BaseCounts& sample, size_t min_count );
 
void transform_zero_out_by_min_count( Variant& variant, size_t min_count );
 
void transform_zero_out_by_max_count( BaseCounts& sample, size_t max_count );
 
void transform_zero_out_by_max_count( Variant& variant, size_t max_count );
 
void transform_zero_out_by_min_max_count( BaseCounts& sample, size_t min_count, size_t max_count );
 
void transform_zero_out_by_min_max_count( Variant& variant, size_t min_count, size_t max_count );
 
} // namespace population
} // namespace genesis
 
#endif // include guard