bitarray2.h

Go to the documentation of this file.

/*
**  bitarray2.h
**
**  This is part of Shiokaze, a research-oriented fluid solver for computer graphics.
**  Created by Ryoichi Ando <rand@nii.ac.jp> on August 8, 2018.
**
**  Permission is hereby granted, free of charge, to any person obtaining a copy of
**  this software and associated documentation files (the "Software"), to deal in
**  the Software without restriction, including without limitation the rights to use,
**  copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
**  Software, and to permit persons to whom the Software is furnished to do so,
**  subject to the following conditions:
**
**  The above copyright notice and this permission notice shall be included in all copies
**  or substantial portions of the Software.
**
**  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
**  INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
**  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
**  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
**  CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
**  OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
//
#ifndef SHKZ_BITARRAY2_H
#define SHKZ_BITARRAY2_H
//
#include <shiokaze/math/vec.h>
#include <shiokaze/parallel/parallel_driver.h>
#include <cassert>
#include <cstdio>
#include <algorithm>
#include <utility>
#include <shiokaze/math/shape.h>
#include "array_core2.h"
//
SHKZ_BEGIN_NAMESPACE
//
template <class T> class array2;
class bitarray2 : public recursive_configurable, public messageable {
public:
    bitarray2( recursive_configurable *parent, const shape2 &shape, std::string core_name="" ) :
        m_core_name(core_name), m_shape(shape) {
            if( parent ) parent->add_child(this);
            else setup_now();
    }
    bitarray2( recursive_configurable *parent, std::string core_name="" ) : bitarray2(parent,shape2(0,0),core_name) {}
    bitarray2( std::string core_name="" ) : bitarray2(nullptr,shape2(0,0),core_name) {}
    bitarray2( const shape2 &shape, std::string core_name="" ) : bitarray2(nullptr,shape,core_name) {}
    //
private:
    //
    virtual void load( configuration &config ) override {
        if( m_core_name.empty()) {
            m_core_name = shkz_default_array_core2;
        } else {
            auto pos = m_core_name.find('*');
            if( pos != std::string::npos ) {
                m_core_name.erase(pos,1);
                m_core_name.insert(pos,shkz_default_array_core2);
            }
        }
        m_core = array_core2::quick_load_module(config,m_core_name);
    }
    //
    virtual void configure( configuration &config ) override {
        m_core->recursive_configure(config);
    }
    //
    virtual void post_initialize() override {
        if( shape().count() && ! m_is_initialized ) {
            initialize(m_shape);
        }
    }
    //
public:
    virtual bool send_message( std::string message, void *ptr ) override {
        return get_core()->send_message(message,ptr);
    }
    virtual bool const_send_message( std::string message, void *ptr ) const override {
        return get_core()->const_send_message(message,ptr);
    }
    bitarray2( const bitarray2 &array ) {
        m_core_name = array.m_core_name;
        setup_now();
        copy(array);
    }
    bitarray2& operator=(const bitarray2 &array) {
        if( this != &array ) {
            copy(array);
        }
        return *this;
    }
    void copy( const bitarray2 &array ) {
        if( this != &array ) {
            set_type(array.type());
            assert(m_core);
            if( array.m_core ) {
                m_core->copy(*array.get_core(),[&](void *target, const void *src){},m_parallel);
            }
        }
    }
    virtual ~bitarray2() {
        clear();
    }
    shape2 shape() const { return m_shape; }
    void initialize( const shape2 &shape ) {
        clear();
        m_core->initialize(shape.w,shape.h,0);
        m_shape = shape;
        m_is_initialized = true;
    }
    size_t count () const { return m_core->count(m_parallel); }
    std::vector<vec2i> actives() const {
        std::vector<vec2i> result;
        const_serial_actives([&](int i, int j) {
            result.push_back(vec2i(i,j));
        });
        return result;
    }
    void activate( const std::vector<vec2i> &active_entries, const vec2i &offset=vec2i() ) {
        for( const auto &e : active_entries ) {
            const vec2i &pi = e + offset;
            if( ! shape().out_of_bounds(pi) && ! (*this)(pi)) {
                set(pi);
            }
        }
    }
    template <class Y> void activate_as( const array2<Y> &array, const vec2i &offset=vec2i() ) {
        array.const_serial_actives([&](int i, int j, const auto &it) {
            const vec2i &pi = vec2i(i,j) + offset;
            if( ! this->shape().out_of_bounds(pi) && ! (*this)(pi)) {
                this->set(pi);
            }
        });
    }
    template <class Y> void activate_as_bit( const Y &array, const vec2i &offset=vec2i() ) {
        array.const_serial_actives([&](int i, int j) {
            const vec2i &pi = vec2i(i,j) + offset;
            if( ! this->shape().out_of_bounds(pi) && ! (*this)(pi)) {
                this->set(pi);
            }
        });
    }
    template <class Y> void activate_inside_as( const array2<Y> &array, const vec2i &offset=vec2i() ) {
        array.const_serial_inside([&](int i, int j, const auto &it) {
            const vec2i &pi = vec2i(i,j) + offset;
            if( ! this->shape().out_of_bounds(pi) && ! (*this)(pi)) {
                this->set(pi);
            }
        });
    }
    void activate_all() {
        parallel_all([&](auto &it) {
            it.set();
        });
    }
    void copy_active_as( const bitarray2 &array, const vec2i &offset=vec2i() ) {
        parallel_actives([&](int i, int j, auto &it, int tn) {
            const vec2i &pi = vec2i(i,j) + offset;
            if( ! this->shape().out_of_bounds(pi) ) {
                if( (*this)(pi) && ! array(pi)) {
                    it.set_off();
                }
            }
        });
        activate_as_bit(array,offset);
    }
    void clear() {
        parallel_actives([&](iterator& it) {
            it.set_off();
        });
    }
    void set( int i, int j ) {
        m_core->set(i,j,[&](void *value_ptr, bool &active){
            active = true;
        });
    }
    void set( const vec2i &pi ) {
        set(pi[0],pi[1]);
    }
    bool operator()( int i, int j ) const {
        bool filled;
        return (*m_core)(i,j,filled) != nullptr;
    }
    bool operator()( const vec2i &pi ) const {
        return (*this)(pi[0],pi[1]);
    }
    bool safe_get( int i, int j ) const {
        if( ! m_shape.out_of_bounds(i,j)) {
            return (*this)(i,j);
        }
        return false;
    }
    bool safe_get( const vec2i &pi ) const {
        return (*this)(pi[0],pi[1]);
    }
    void set_off( int i, int j ) {
        m_core->set(i,j,[&](void *value_ptr, bool &active){
            active = false;
        });
    }
    void set_off( const vec2i &pi ) {
        set_off(pi[0],pi[1]);
    }
    bool operator!=( const bitarray2 &array ) const {
        return ! (*this == array);
    }
    bool operator==(const bitarray2 &v) const {
        if( v.type() == type() ) {
            bool differnt (false);
            interruptible_const_serial_actives([&]( int i, int j ) {
                if( ! v(i,j)) {
                    differnt = true;
                    return true;
                } else {
                    return false;
                }
            });
            return ! differnt;
        }
        return false;
    }
    void set_thread_num( int number ) {
        m_parallel.set_thread_num(number);
    }
    int get_thread_num() const {
        return m_parallel.get_thread_num();
    }
    class iterator {
    friend class bitarray2;
    public:
        void set() {
            m_active = true;
        }
        void set_off() {
            m_active = false;
        }
        bool operator()() const {
            return m_active;
        }
    private:
        //
        iterator( bool &_active ) : m_active(_active) {}
        bool &m_active;
    };
    class const_iterator {
    friend class bitarray2;
    public:
        bool operator()() const {
            return m_active;
        }
    private:
        //
        const_iterator( const bool &_active ) : m_active(_active) {}
        const bool &m_active;
    };
    //
    enum { ACTIVES = true, ALL = false };
    void parallel_actives( std::function<void(iterator& it)> func ) { parallel_op(func,ACTIVES); }
    void parallel_all( std::function<void(iterator& it)> func ) { parallel_op(func,ALL); }
    void parallel_op( std::function<void(iterator& it)> func, bool type=ALL ) {
        parallel_op([func](int i, int j, iterator& it, int thread_index){
            func(it);
        },type);
    }
    void parallel_actives( std::function<void(int i, int j, iterator& it)> func ) { parallel_op(func,ACTIVES); }
    void parallel_all( std::function<void(int i, int j, iterator& it)> func ) { parallel_op(func,ALL); }
    void parallel_op( std::function<void(int i, int j, iterator& it)> func, bool type=ALL ) {
        parallel_op([func](int i, int j, iterator& it, int thread_index){
            func(i,j,it);
        },type);
    }
    void parallel_actives( std::function<void(int i, int j, iterator& it, int thread_index)> func ) { parallel_op(func,ACTIVES); }
    void parallel_all( std::function<void(int i, int j, iterator& it, int thread_index)> func ) { parallel_op(func,ALL); }
    void parallel_op( std::function<void(int i, int j, iterator& it, int thread_index)> func, bool type=ALL ) {
        if( type == ACTIVES ) {
            m_core->parallel_actives([&](int i, int j, void *value_ptr, bool &active, const bool &filled, int thread_n ){
                iterator it(active);
                func(i,j,it,thread_n);
            },m_parallel);
        } else {
            m_core->parallel_all([&](int i, int j, void *value_ptr, bool &active, const bool &filled, int thread_n ){
                iterator it(active);
                func(i,j,it,thread_n);
            },m_parallel);
        }
    }
    void const_parallel_all( std::function<void(const const_iterator& it)> func ) const { const_parallel_op(func,ALL); }
    void const_parallel_op( std::function<void(const const_iterator& it)> func, bool type=ALL ) const {
        const_parallel_op([func](int i, int j, const const_iterator& it, int thread_index){
            func(it);
        },type);
    }
    void const_parallel_actives( std::function<void(int i, int j)> func ) const { const_parallel_op([&](int i, int j, const const_iterator& it) {
        func(i,j); },ACTIVES); }
    void const_parallel_all( std::function<void(int i, int j, const const_iterator& it)> func ) const { const_parallel_op(func,ALL); }
    void const_parallel_op( std::function<void(int i, int j, const const_iterator& it)> func, bool type=ALL ) const {
        const_parallel_op([func](int i, int j, const const_iterator& it, int thread_index){
            func(i,j,it);
        },type);
    }
    void const_parallel_actives( std::function<void(int i, int j, int thread_index)> func ) const { const_parallel_op(
        [&](int i, int j, const const_iterator& it, int thread_index) { func(i,j,thread_index); },ACTIVES); }
    void const_parallel_all( std::function<void(int i, int j, const const_iterator& it, int thread_index)> func ) const { const_parallel_op(func,ALL); }
    void const_parallel_op( std::function<void(int i, int j, const const_iterator& it, int thread_index)> func, bool type=ALL ) const {
        if( type == ACTIVES ) {
            m_core->const_parallel_actives([&](int i, int j, const void *value_ptr, const bool &filled, int thread_n ){
                bool active(true);
                const_iterator it(active);
                func(i,j,it,thread_n);
            },m_parallel);
        } else {
            m_core->const_parallel_all([&](int i, int j, const void *value_ptr, const bool &active, const bool &filled, int thread_n ){
                const_iterator it(active);
                func(i,j,it,thread_n);
            },m_parallel);
        }
    }
    void serial_actives( std::function<void(iterator& it)> func ) { serial_op(func,ACTIVES); }
    void serial_all( std::function<void(iterator& it)> func ) { serial_op(func,ALL); }
    void serial_op( std::function<void(iterator& it)> func, bool type=ALL ) {
        serial_op([func](int i, int j, iterator& it){
            func(it);
        },type);
    }
    void serial_actives( std::function<void(int i, int j, iterator& it)> func ) { serial_op(func,ACTIVES); }
    void serial_all( std::function<void(int i, int j, iterator& it)> func ) { serial_op(func,ALL); }
    void serial_op( std::function<void(int i, int j, iterator& it)> func, bool type=ALL ) {
        if( type == ACTIVES ) {
            m_core->serial_actives([&](int i, int j, void *value_ptr, bool &active, const bool &filled ){
                iterator it(active);
                func(i,j,it);
                return false;
            });
        } else {
            m_core->serial_all([&](int i, int j, void *value_ptr, bool &active, const bool &filled ){
                iterator it(active);
                func(i,j,it);
                return false;
            });
        }
    }
    void const_serial_all( std::function<void(const const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    void const_serial_op( std::function<void(const const_iterator& it)> func, bool type=ALL ) const {
        const_serial_op([func](int i, int j, const const_iterator& it){
            func(it);
        },type);
    }
    void const_serial_actives( std::function<void(int i, int j)> func ) const {
        const_serial_op([&]( int i, int j, const const_iterator& it ) {func(i,j);},ACTIVES); }
    void const_serial_all( std::function<void(int i, int j, const const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    void const_serial_op( std::function<void(int i, int j, const const_iterator& it)> func, bool type=ALL ) const {
        if( type == ACTIVES ) {
            m_core->const_serial_actives([&](int i, int j, const void *value_ptr, const bool &filled ){
                bool active(true);
                const_iterator it(active);
                func(i,j,it);
                return false;
            });
        } else {
            m_core->const_serial_all([&](int i, int j, const void *value_ptr, const bool &active, const bool &filled ){
                const_iterator it(active);
                func(i,j,it);
                return false;
            });
        }
    }
    void interruptible_serial_actives( std::function<bool(iterator& it)> func ) { interruptible_serial_op(func,ACTIVES); }
    void interruptible_serial_all( std::function<bool(iterator& it)> func ) { interruptible_serial_op(func,ALL); }
    void interruptible_serial_op( std::function<bool(iterator& it)> func, bool type=ALL ) {
        interruptible_serial_op([func](int i, int j, iterator& it){
            return func(it);
        },type);
    }
    void interruptible_serial_actives( std::function<bool(int i, int j, iterator& it)> func ) { interruptible_serial_op(func,ACTIVES); }
    void interruptible_serial_all( std::function<bool(int i, int j, iterator& it)> func ) { interruptible_serial_op(func,ALL); }
    void interruptible_serial_op( std::function<bool(int i, int j, iterator& it)> func, bool type=ALL ) {
        if( type == ACTIVES ) {
            m_core->serial_actives([&](int i, int j, void *value_ptr, bool &active, const bool &filled ){
                iterator it(active);
                return func(i,j,it);
            });
        } else {
            m_core->serial_all([&](int i, int j, void *value_ptr, bool &active, const bool &filled ){
                iterator it(active);
                return func(i,j,it);
            });
        }
    }
    void interruptible_const_serial_all( std::function<bool(const const_iterator& it)> func ) const { interruptible_const_serial_op(func,ALL); }
    void interruptible_const_serial_op( std::function<bool(const const_iterator& it)> func, bool type=ALL ) const {
        interruptible_const_serial_op([func](int i, int j, const const_iterator& it){
            return func(it);
        },type);
    }
    void interruptible_const_serial_actives( std::function<bool(int i, int j)> func ) const {
        interruptible_const_serial_op([&](int i, int j, const const_iterator& it) {return func(i,j);},ACTIVES); }
    void interruptible_const_serial_all( std::function<bool(int i, int j, const const_iterator& it)> func ) const { interruptible_const_serial_op(func,ALL); }
    void interruptible_const_serial_op( std::function<bool(int i, int j, const const_iterator& it)> func, bool type=ALL ) const {
        if( type == ACTIVES ) {
            m_core->const_serial_actives([&](int i, int j, const void *value_ptr, const bool &filled ){
                bool active(true);
                const_iterator it(active);
                return func(i,j,it);
            });
        } else {
            m_core->const_serial_all([&](int i, int j, const void *value_ptr, const bool &active, const bool &filled ){
                const_iterator it(active);
                return func(i,j,it);
            });
        }
    }
    void dilate( std::function<void(int i, int j, iterator& it, int thread_index)> func, int count=1 ) {
        while( count -- ) {
            m_core->dilate([&](int i, int j, void *value_ptr, bool &active, const bool &filled, int thread_index) {
                iterator it(active);
                func(i,j,it,thread_index);
            },m_parallel);
        }
    }
    void dilate( std::function<void(int i, int j, iterator& it)> func, int count=1 ) {
        dilate([&](int i, int j, iterator& it, int thread_index) {
            func(i,j,it);
        },count);
    }
    void dilate( int count=1 ) {
        dilate([&](int i, int j, iterator& it){ it.set(); },count);
    }
    void erode( std::function<bool(int i, int j, int thread_index)> func, int count=1 ) {
        //
        std::vector<std::vector<vec2i> > off_positions(get_thread_num());
        //
        while( count -- ) {
            const_parallel_actives([&](int i, int j, int tn) {
                bool exit_loop (false);
                for( int dim : DIMS2 ) {
                    for( int dir=-1; dir<=1; dir+=2 ) {
                        const vec2i &pi = vec2i(i,j) + dir*vec2i(dim==0,dim==1);
                        if( ! this->shape().out_of_bounds(pi) && ! (*this)(pi)) {
                            if( func(i,j,tn)) {
                                off_positions[tn].push_back(vec2i(i,j));
                                exit_loop = true;
                                break;
                            }
                        }
                    }
                    if( exit_loop ) break;
                }
            });
            for( const auto &bucket : off_positions ) for( const auto &pi : bucket ) {
                set_off(pi);
            }
        }
    }
    void erode( std::function<bool(int i, int j)> func, int count=1 ) {
        erode([&](int i, int j, int thread_index) {
            return func(i,j);
        },count);
    }
    void erode( int count=1 ) {
        erode([&](int i, int j, int thread_index) { return true; },count);
    }
    void swap( bitarray2& rhs ) {
        m_core.swap(rhs.m_core);
        std::swap(m_shape,rhs.m_shape);
    }
    parallel_driver & get_parallel_driver() {
        return m_parallel;
    }
    const parallel_driver & get_parallel_driver() const {
        return m_parallel;
    }
    void set_core_name( std::string core_name ) {
        m_core_name = core_name;
    }
    std::string get_core_name() const {
        return m_core_name;
    }
    const array_core2 * get_core() const {
        return m_core.get();
    }
    array_core2 * get_core() {
        return m_core.get();
    }
    struct type2 {
        std::string core_name;
        shape2 shape;
        bool operator==( const type2 &type ) const {
            return core_name == type.core_name && shape == type.shape;
        }
    };
    type2 type() const { return { get_core_name(),shape() }; }
    void set_type( const type2 &type ) {
        m_core_name = type.core_name;
        m_shape = type.shape;
    }
    //
private:
    //
    shape2 m_shape;
    parallel_driver m_parallel{this};
    bool m_is_initialized {false};
    array2_ptr m_core;
    std::string m_core_name;
};
//
SHKZ_END_NAMESPACE
//
#endif