i_filter.h

Go to the documentation of this file.

/*
 * $Id: i_filter.h 18347 2014-12-03 16:58:53Z jguan1 $
 */

#ifndef KJB_CPP_FILTER_H
#define KJB_CPP_FILTER_H

#include "m_cpp/m_matrix.h"
#include "l_cpp/l_exception.h"
#include "i_cpp/i_image.h"
#include <string>

namespace kjb 
{

class Filter
{
public:

    typedef Matrix::Value_type Value_type;

    Filter(int rows, int cols)
        : m_kernel(rows % 2 != 0 ? rows : rows + 1, cols % 2 != 0 ? cols : cols + 1)
    {}

    Filter(const Matrix& src) :
        m_kernel(src)
    {}

    Filter(const char* fname) 
        : m_kernel(fname)
    {}

    Filter(const std::string& fname) 
        : m_kernel(fname.c_str())
    {}

    Filter(const Filter& src)
        : m_kernel(src.m_kernel)
    {}

    /* /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ /\ */

    ~Filter()
    {}

    void swap(Filter& other)
    {
        using std::swap;
        swap(m_kernel, other.m_kernel);
    }

    int get_num_rows() const
    {
        return m_kernel.get_num_rows();
    }

    int get_num_cols() const
    {
        return m_kernel.get_num_cols();
    }

    Filter& operator=(const kjb::Matrix& src)
    {
        if(&m_kernel != &src)
        {
            m_kernel = src;
        }

        return *this;
    }

    Filter& operator=(const Filter& src)
    {
        if(this != &src)
        {
            m_kernel = src.m_kernel;
        }

        return *this;
    }

    Value_type& operator()(int row, int col)
    {
        // hit KJB(UNTESTED_CODE());
        return m_kernel(row, col);
    }

    Value_type operator()(int row, int col) const
    {
        // hit KJB(UNTESTED_CODE());
        return m_kernel(row, col);
    }

    void check_bounds(int row, int col) const
    {
        // hit KJB(UNTESTED_CODE()); 
        if(row < 0 || get_num_rows() <= row || col < 0 || get_num_cols() <= col)
        {
            // hit KJB(UNTESTED_CODE());
            KJB_THROW(Index_out_of_bounds);
        }
    }

    Value_type& at(int row, int col)
    {
        // hit KJB(UNTESTED_CODE());
        check_bounds(row, col);
        return operator()(row, col);
    }

    Value_type at(int row, int col) const
    {
        // hit KJB(UNTESTED_CODE());
        check_bounds(row, col);
        return operator()(row, col);
    }

    void write(std::string fname)
    {
        m_kernel.write(fname.c_str());
    }

    friend Image operator*(const Image&, const Filter&);
    friend Matrix operator*(const Matrix&, const Filter&);

private:
    Matrix m_kernel;
};

Filter gaussian_filter(double sigma, int size);

inline Filter gaussian_filter(double sigma)
{
    return gaussian_filter(sigma, 6 * static_cast<int>(sigma) + 1);
}

Filter laplacian_of_gaussian_filter(int size, double sigma);

Image operator*(const Image& image, const Filter& kernel);

Image gauss_sample_image(const Image& in, int resolution, double sigma);


} // namespace kjb

namespace std {

template<>
inline void swap(kjb::Filter& a, kjb::Filter& b) 
{
    a.swap(b);
}

} // namespace std

#endif /*KJB_CPP_FILTER_H */