bitmacarray3.h

Go to the documentation of this file.

/*
**  bitmacarray3.h
**
**  This is part of Shiokaze, a research-oriented fluid solver for computer graphics.
**  Created by Ryoichi Ando <rand@nii.ac.jp> on Ausugst 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_BITMACARRAY3_H
#define SHKZ_BITMACARRAY3_H
//
#include <shiokaze/array/bitarray3.h>
#include <algorithm>
#include <array>
//
SHKZ_BEGIN_NAMESPACE
//
class bitmacarray3 : public recursive_configurable, public messageable {
public:
    bitmacarray3 ( recursive_configurable *parent, const shape3 &shape, std::string core_name="") : m_shape(shape), m_array_0(this,shape.face(0),core_name), m_array_1(this,shape.face(1),core_name), m_array_2(this,shape.face(2),core_name) {
        if( parent ) parent->add_child(this);
        else setup_now();
    }
    bitmacarray3( recursive_configurable *parent, std::string core_name="" ) : bitmacarray3(parent,shape3(0,0,0),core_name) {}
    bitmacarray3 ( std::string core_name="") : bitmacarray3(nullptr,shape3(0,0,0),core_name) {}
    bitmacarray3( const shape3 &shape, std::string core_name="") : bitmacarray3(nullptr,shape,core_name) {}
    bitmacarray3 ( const bitmacarray3& v ) : m_array_0(this), m_array_1(this), m_array_2(this){
        copy(v);
    }
    virtual bool send_message( std::string message, void *ptr ) override {
        bool handled (false);
        if( m_array_0.send_message(message,ptr)) handled = true;
        if( m_array_1.send_message(message,ptr)) handled = true;
        if( m_array_2.send_message(message,ptr)) handled = true;
        return handled;
    }
    virtual bool const_send_message( std::string message, void *ptr ) const override {
        bool handled (false);
        if( m_array_0.const_send_message(message,ptr)) handled = true;
        if( m_array_1.const_send_message(message,ptr)) handled = true;
        if( m_array_2.const_send_message(message,ptr)) handled = true;
        return handled;
    }
    bitmacarray3& operator=(const bitmacarray3 &array) {
        copy(array);
        return *this;
    }
    void copy( const bitmacarray3 &array ) {
        if( this != &array ) {
            set_type(array.type());
            for( int dim : DIMS3 ) (*this)[dim].copy(array[dim]);
        }
    }
    void initialize ( const shape3 &shape ) {
        m_shape = shape;
        for( int dim : DIMS3 ) (*this)[dim].initialize(shape.face(dim));
    }
    size_t count () const {
        size_t sum (0);
        for( int dim : DIMS3 ) sum += (*this)[dim].count();
        return sum;
    }
    std::array<std::vector<vec3i>,DIM3> actives() const {
        std::array<std::vector<vec3i>,DIM3> result;
        m_parallel.for_each( DIM3, [&]( size_t dim ) {
            result[dim] = (*this)[dim].actives();
        });
        return result;
    }
    void activate( const std::array<std::vector<vec3i>,DIM3> &active_entries, const std::array<vec3i,DIM3> &offsets={vec3i(),vec3i(),vec3i()}  ) {
        m_parallel.for_each( DIM3, [&]( size_t dim ) {
            (*this)[dim].activate(active_entries[dim],offsets[dim]);
        });
    }
    void activate_as_bit( const bitmacarray3 &array, const std::array<vec3i,DIM3> &offsets={vec3i(),vec3i(),vec3i()} ) {
        m_parallel.for_each( DIM3, [&]( size_t dim ) {
            (*this)[dim].activate_as_bit(array[dim],offsets[dim]);
        });
    }
    template <class Y> void activate_as( const Y &array, const std::array<vec3i,DIM3> &offsets={vec3i(),vec3i(),vec3i()} ) {
        m_parallel.for_each( DIM3, [&]( size_t dim ) {
            (*this)[dim].activate_as(array[dim],offsets[dim]);
        });
    }
    void activate_all() {
        m_parallel.for_each( DIM3, [&]( size_t dim ) {
            (*this)[dim].activate_all();
        });
    }
    void copy_active_as( const bitmacarray3 &array, const vec3i &offset=vec3i() ) {
        m_parallel.for_each( DIM3, [&]( size_t dim ) {
            (*this)[dim].copy_active_as(array[dim],offset);
        });
    }
    shape3 shape() const { return m_shape; }
    shape3 shape(int dim) const { return (*this)[dim].shape(); }
    void clear() {
        for( int dim : DIMS3 ) (*this)[dim].clear();
    }
    bool operator!=( const bitmacarray3 &v ) const {
        return ! (*this == v);
    }
    bool operator==(const bitmacarray3 &v) const {
        for( int dim : DIMS3 ) {
            if ((*this)[dim] != v[dim]) return false;
        }
        return true;
    }
    const bitarray3& operator[](int dim) const {
        return dim==0 ? m_array_0 : (dim == 1 ? m_array_1 : m_array_2 );
    }
    bitarray3& operator[](int dim) {
        return dim==0 ? m_array_0 : (dim == 1 ? m_array_1 : m_array_2 );
    }
    void set_thread_num( int number ) {
        for( int dim : DIMS3 ) (*this)[dim].set_thread_num(number);
    }
    int get_thread_num() const {
        return m_array_0.get_thread_num();
    }
    //
    enum { ACTIVES = true, ALL = false };
    inline void parallel_actives( std::function<void(typename bitarray3::iterator& it)> func ) { parallel_op(func,ACTIVES); }
    inline void parallel_all( std::function<void(typename bitarray3::iterator& it)> func ) { parallel_op(func,ALL); }
    inline void parallel_op( std::function<void(typename bitarray3::iterator& it)> func, bool type=ALL ) {
        parallel_op([func](int dim, int i, int j, int k, typename bitarray3::iterator& it, int thread_index){
            func(it);
        },type);
    }
    inline void parallel_actives( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func ) { parallel_op(func,ACTIVES); }
    inline void parallel_all( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func ) { parallel_op(func,ALL); }
    inline void parallel_op( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func, bool type=ALL ) {
        parallel_op([func](int dim, int i, int j, int k, typename bitarray3::iterator& it, int thread_index){
            func(dim,i,j,k,it);
        },type);
    }
    inline void parallel_actives( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it, int thread_index)> func ) { parallel_op(func,ACTIVES); }
    inline void parallel_all( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it, int thread_index)> func ) { parallel_op(func,ALL); }
    inline void parallel_op( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it, int thread_index)> func, bool type=ALL ) {
        for( int dim : DIMS3 ) {
            (*this)[dim].parallel_op([&](int i, int j, int k, typename bitarray3::iterator& it, int thread_index) {
                func(dim,i,j,k,it,thread_index);
            },type);
        };
    }
    inline void const_parallel_all( std::function<void(const typename bitarray3::const_iterator& it)> func ) const { const_parallel_op(func,ALL); }
    inline void const_parallel_op( std::function<void(const typename bitarray3::const_iterator& it)> func, bool type=ALL ) const {
        const_parallel_op([func](int dim, int i, int j, int k, const typename bitarray3::const_iterator& it, int thread_index){
            func(it);
        },type);
    }
    inline void const_parallel_actives( std::function<void(int dim, int i, int j, int k)> func ) const {
        const_parallel_op([&](int dim, int i, int j, int k, const typename bitarray3::const_iterator& it){ func(dim,i,j,k); }, ACTIVES); }
    inline void const_parallel_all( std::function<void(int dim, int i, int j, int k, const typename bitarray3::const_iterator& it)> func ) const { const_parallel_op(func,ALL); }
    inline void const_parallel_op( std::function<void(int dim, int i, int j, int k, const typename bitarray3::const_iterator& it)> func, bool type=ALL ) const {
        const_parallel_op([func](int dim, int i, int j, int k, const typename bitarray3::const_iterator& it, int thread_index){
            func(dim,i,j,k,it);
        },type);
    }
    inline void const_parallel_actives( std::function<void(int dim, int i, int j, int k, int thread_index)> func ) const {
        const_parallel_op([&](int dim, int i, int j, int k, const typename bitarray3::const_iterator& it, int thread_index){ func(dim,i,j,k,thread_index); }, ACTIVES); }
    inline void const_parallel_all( std::function<void(int dim, int i, int j, int k, const typename bitarray3::const_iterator& it, int thread_index)> func ) const { const_parallel_op(func,ALL); }
    inline void const_parallel_op( std::function<void(int dim, int i, int j, int k, const typename bitarray3::const_iterator& it, int thread_index)> func, bool type=ALL ) const {
        for( int dim : DIMS3 ) {
            (*this)[dim].const_parallel_op([&](int i, int j, int k, const typename bitarray3::const_iterator& it, int thread_index) {
                func(dim,i,j,k,it,thread_index);
            },type);
        };
    }
    inline void serial_actives( std::function<void(typename bitarray3::iterator& it)> func ) { serial_op(func,ACTIVES); }
    inline void serial_all( std::function<void(typename bitarray3::iterator& it)> func ) { serial_op(func,ALL); }
    inline void serial_op( std::function<void(typename bitarray3::iterator& it)> func, bool type=ALL ) {
        serial_op([func](int dim, int i, int j, int k, typename bitarray3::iterator& it) {
            func(it);
        },type);
    }
    inline void serial_actives( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func ) { serial_op(func,ACTIVES); }
    inline void serial_all( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func ) { serial_op(func,ALL); }
    inline void serial_op( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func, bool type=ALL ) {
        for( int dim : DIMS3 ) {
            (*this)[dim].serial_op([&](int i, int j, int k, typename bitarray3::iterator& it) {
                func(dim,i,j,k,it);
            },type );
        }
    }
    inline void const_serial_all( std::function<void(const typename bitarray3::const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    inline void const_serial_op( std::function<void(const typename bitarray3::const_iterator& it)> func, bool type=ALL ) const {
        const_serial_op([func](int dim, int i, int j, int k, const typename bitarray3::const_iterator& it) {
            func(it);
        },type);
    }
    inline void const_serial_actives( std::function<void(int dim, int i, int j, int k)> func ) const {
        const_serial_op([&](int dim, int i, int j, int k, const typename bitarray3::const_iterator& it){ func(dim,i,j,k); }, ACTIVES); }
    inline void const_serial_all( std::function<void(int dim, int i, int j, int k, const typename bitarray3::const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    inline void const_serial_op( std::function<void(int dim, int i, int j, int k, const typename bitarray3::const_iterator& it)> func, bool type=ALL ) const {
        for( int dim : DIMS3 ) {
            (*this)[dim].const_serial_op([&](int i, int j, int k, const typename bitarray3::const_iterator& it) {
                func(dim,i,j,k,it);
            },type);
        }
    }
    inline void interruptible_serial_actives( std::function<bool(typename bitarray3::iterator& it)> func ) { serial_op(func,ACTIVES); }
    inline void interruptible_serial_all( std::function<bool(typename bitarray3::iterator& it)> func ) { serial_op(func,ALL); }
    inline void interruptible_serial_op( std::function<bool(typename bitarray3::iterator& it)> func, bool type=ALL ) {
        serial_op([func](int dim, int i, int j, int k, typename bitarray3::iterator& it) {
            func(it);
        },type);
    }
    inline void interruptible_serial_actives( std::function<bool(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func ) { serial_op(func,ACTIVES); }
    inline void interruptible_serial_all( std::function<bool(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func ) { serial_op(func,ALL); }
    inline void interruptible_serial_op( std::function<bool(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func, bool type=ALL ) {
        for( int dim : DIMS3 ) {
            (*this)[dim].serial_op([&](int i, int j, int k, typename bitarray3::iterator& it) {
                func(dim,i,j,k,it);
            },type);
        }
    }
    inline void interruptible_const_serial_all( std::function<bool(const typename bitarray3::const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    inline void interruptible_const_serial_op( std::function<bool(const typename bitarray3::const_iterator& it)> func, bool type=ALL ) const {
        const_serial_op([func](int dim, int i, int j, int k, const typename bitarray3::const_iterator& it) {
            func(it);
        },type);
    }
    inline void interruptible_const_serial_actives( std::function<bool(int dim, int i, int j, int k)> func ) const {
        const_serial_op([&](int dim, int i, int j, int k, const typename bitarray3::const_iterator& it){ return func(dim,i,j,k); }, ACTIVES); }
    inline void interruptible_const_serial_all( std::function<bool(int dim, int i, int j, int k, const typename bitarray3::const_iterator& it)> func ) const { const_serial_op(func,ALL); }
    inline void interruptible_const_serial_op( std::function<bool(int dim, int i, int j, int k, const typename bitarray3::const_iterator& it)> func, bool type=ALL ) const {
        for( int dim : DIMS3 ) {
            (*this)[dim].const_serial_op([&](int i, int j, int k, const typename bitarray3::const_iterator& it) {
                func(dim,i,j,k,it);
            },type);
        }
    }
    void dilate( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it, int thread_index)> func, int count=1 ) {
        while( count -- ) {
            m_parallel.for_each(DIM3,[&]( size_t dim ) {
                operator[](dim).dilate([&](int i, int j, int k, typename bitarray3::iterator& it, int thread_index) {
                    func(dim,i,j,k,it,thread_index);
                });
            });
        }
    }
    void dilate( std::function<void(int dim, int i, int j, int k, typename bitarray3::iterator& it)> func, int count=1 ) {
        dilate([&](int dim, int i, int j, int k, typename bitarray3::iterator& it, int thread_index) {
            func(dim,i,j,k,it);
        },count);
    }
    void dilate( int count=1 ) {
        dilate([&](int dim, int i, int j, int k, typename bitarray3::iterator& it){ it.set(); },count);
    }
    void erode( std::function<bool(int dim, int i, int j, int k, int thread_index)> func, int count=1 ) {
        while( count -- ) {
            m_parallel.for_each(DIM3,[&]( size_t dim ) {
                operator[](dim).erode([&](int i, int j, int k, int thread_index) {
                    return func(dim,i,j,k,thread_index);
                });
            });
        }
    }
    void erode( std::function<bool(int dim, int i, int j, int k)> func, int count=1 ) {
        erode([&](int dim, int i, int j, int k, int thread_index) {
            return func(dim,i,j,k);
        },count);
    }
    void erode( int count=1 ) {
        return erode([&](int dim, int i, int j, int k){ return true; },count);
    }
    void set_core_name( std::string core_name ) {
        m_array_0.set_core_name(core_name);
        m_array_1.set_core_name(core_name);
        m_array_2.set_core_name(core_name);
    }
    std::string get_core_name() const {
        return m_array_0.get_core_name();
    }
    struct type3 {
        std::string core_name;
        shape3 shape;
        typename bitarray3::type3 type0;
        typename bitarray3::type3 type1;
        typename bitarray3::type3 type2;
        bool operator==( const type3 &type ) const {
            return
                core_name == type.core_name && shape == type.shape &&
                type0 == type.type0 && type1 == type.type1 && type2 == type.type2;
        }
    };
    type3 type() const {
        return { get_core_name(), m_shape, m_array_0.type(), m_array_1.type(), m_array_2.type() };
    }
    void set_type( const type3 &type ) {
        m_shape = type.shape;
        m_array_0.set_type(type.type0);
        m_array_1.set_type(type.type1);
        m_array_2.set_type(type.type2);
    }
private:
    parallel_driver m_parallel{this};
    bitarray3 m_array_0;
    bitarray3 m_array_1;
    bitarray3 m_array_2;
    shape3 m_shape;
    //
};
//
SHKZ_END_NAMESPACE
//
#endif