array2.h

Go to the documentation of this file.

/*
**  array2.h
**
**  This is part of Shiokaze, a research-oriented fluid solver for computer graphics.
**  Created by Ryoichi Ando <rand@nii.ac.jp> on Feb 7, 2017.
**
**  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_ARRAY2_H
#define SHKZ_ARRAY2_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 : public recursive_configurable, public messageable {
public:
    array2( recursive_configurable *parent, const shape2 &shape, T value=T(), std::string core_name="" ) :
        m_core_name(core_name), m_shape(shape), m_background_value(value) {
            if( parent ) parent->add_child(this);
            else setup_now();
    }
    array2( recursive_configurable *parent, std::string core_name="" ) : array2(parent,shape2(0,0),T(),core_name) {}
    array2( std::string core_name="" ) : array2(nullptr,shape2(0,0),T(),core_name) {}
    array2( const shape2 &shape, T value=T(), std::string core_name="" ) : array2(nullptr,shape,value,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,m_background_value);
        }
    }
    //
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);
    }
    array2( const array2 &array ) {
        m_core_name = array.m_core_name;
        setup_now();
        copy(array);
    }
    void set_touch_only_actives( bool touch_only_actives ) {
        m_touch_only_actives = touch_only_actives;
    }
    array2& operator=(const array2 &array) {
        if( this != &array ) {
            copy(array);
        }
        return *this;
    }
    void copy( const array2 &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) {
                    new (target) T(*static_cast<const T *>(src));
                },m_parallel);
            }
        }
    }
    std::vector<T> linearize() const {
        const shape3 &s = m_shape;
        std::vector<T> result(s.count(),m_background_value);
        const_parallel_actives([&]( int i, int j, auto it ) {
            result[i+j*s.w] = it();
        });
        const_parallel_inside([&]( int i, int j, auto it ) {
            if( ! it.active()) result[i+j*s.w] = it();
        });
        return result;
    }
    virtual ~array2() {
        clear();
    }
    shape2 shape() const { return m_shape; }
    void initialize( const shape2 &shape, T value=T()) {
        clear();
        m_core->initialize(shape.w,shape.h,sizeof(T));
        m_shape = shape;
        m_background_value = value;
        m_fillable = false;
        m_levelset = false;
        m_is_initialized = true;
    }
    void set_as_levelset( double bandwidth_half ) {
        m_levelset = true;
        m_fillable = false;
        m_background_value = bandwidth_half;
        m_fill_value = -bandwidth_half;
    }
    void set_as_fillable( const T& fill_value ) {
        m_levelset = false;
        m_fillable = true;
        m_fill_value = fill_value;
    }
    void set_as_fillable_as( const array2 &array ) { 
        set_as_fillable(array.m_fill_value);
    }
    void set_as_levelset_as( const array2 &array ) {
        set_as_levelset(array.m_background_value);
    }
    bool is_fillable() const {
        return m_fillable;
    }
    bool is_levelset() const {
        return m_levelset;
    }
    void flood_fill() {
        if( m_fillable ) {
            m_core->flood_fill([&](const void *value_ptr) {
                return *static_cast<const T *>(value_ptr) == m_fill_value;
            },m_parallel);
        } else if( m_levelset ) {
            m_core->flood_fill([&](const void *value_ptr) {
                return *static_cast<const T *>(value_ptr) < 0.0;
            },m_parallel);
        } else {
            printf( "Flood fill attempted without being set either levelset or fillable.\n");
            exit(0);
        }
    }
    std::vector<vec2i> fills() const {
        std::vector<vec2i> result;
        const_serial_inside([&](int i, int j, const auto &it) {
            result.push_back(vec2i(i,j));
        });
        return result;
    }
    bool filled( int i, int j ) const {
        bool filled;
        (*m_core)(i,j,filled);
        return filled;
    }
    bool filled( const vec2i &pi  ) const {
        return filled(pi[0],pi[1]);
    }
    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, const auto &it) {
            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) && ! active(pi)) {
                set(pi,(*this)(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->active(pi)) {
                this->set(pi,(*this)(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->active(pi)) {
                this->set(pi,(*this)(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->active(pi)) {
                this->set(pi,(*this)(pi));
            }
        });
    }
    void activate_all() {
        parallel_all([&](auto &it) {
            it.set(it());
        });
    }
    void activate_inside() {
        activate(fills());
    }
    template <class Y> void copy_active_as( const array2<Y> &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->active(pi) && ! array.active(pi)) {
                    it.set_off();
                }
            }
        });
        activate_as(array,offset);
    }
    T get_background_value () const { return m_background_value; }
    void set_background_value( const T& value ) { m_background_value = value; }
    void clear() {
        parallel_actives([&](iterator& it) {
            it.set_off();
        });
    }
    void clear(const T &v) {
        m_background_value = v;
        clear();
    }
    void set( int i, int j, const T& value  ) {
        m_core->set(i,j,[&](void *value_ptr, bool &active){
            if( ! active ) new (value_ptr) T(value);
            else *static_cast<T *>(value_ptr) = value;
            active = true;
        });
    }
    void set( const vec2i &pi, const T& value  ) {
        set(pi[0],pi[1],value);
    }
    bool active( int i, int j ) const {
        bool filled;
        return (*m_core)(i,j,filled) != nullptr;
    }
    bool active( const vec2i &pi  ) const {
        return active(pi[0],pi[1]);
    }
    bool safe_active( int i, int j ) const {
        if( ! m_shape.out_of_bounds(i,j)) {
            return active(i,j);
        }
        return false;
    }
    bool safe_active( const vec2i &pi ) const {
        return safe_active(pi[0],pi[1]);
    }
    void set_off( int i, int j  ) {
        m_core->set(i,j,[&](void *value_ptr, bool &active){
            if( active ) (static_cast<T *>(value_ptr))->~T();
            active = false;
        });
    }
    void set_off( const vec2i &pi  ) {
        set_off(pi[0],pi[1]);
    }
    void increment( int i, int j, const T& value  ) {
        m_core->set(i,j,[&](void *value_ptr, bool &active){
            if( active ) *static_cast<T *>(value_ptr) += value;
            else {
                *static_cast<T *>(value_ptr) = m_background_value + value;
                active = true;
            }
        });
    }
    void increment( const vec2i &pi, const T& value  ) {
        increment(pi[0],pi[1],value);
    }
    void subtract( int i, int j, const T& value  ) {
        m_core->set(i,j,[&](void *value_ptr, bool &active){
            if( active ) *static_cast<T *>(value_ptr) -= value;
            else {
                *static_cast<T *>(value_ptr) = m_background_value - value;
                active = true;
            }
        });
    }
    void subtract( const vec2i &pi, const T& value  ) {
        subtract(pi[0],pi[1],value);
    }
    void multiply( int i, int j, const T& value  ) {
        m_core->set(i,j,[&](void *value_ptr, bool &active){
            if( active ) *static_cast<T *>(value_ptr) *= value;
            else {
                *static_cast<T *>(value_ptr) = m_background_value * value;
                active = true;
            }
        });
    }
    void multiply( const vec2i &pi, const T& value  ) {
        multiply(pi[0],pi[1],value);
    }
    void divide( int i, int j, const T& value  ) {
        multiply(i,j,1.0/value);
    }
    void divide( const vec2i &pi, const T& value  ) {
        divide(pi[0],pi[1],value);
    }
    T* ptr(int i, int j ) {
        bool filled (false);
        return const_cast<T *>(static_cast<const T *>((*m_core)(i,j,filled)));
    }
    const T* ptr(int i, int j ) const {
        return const_cast<array2<T> *>(this)->ptr(i,j);
    }
    T* ptr( const vec2i &pi ) {
        return ptr(pi[0],pi[1]);
    }
    const T* ptr( const vec2i &pi ) const {
        return const_cast<array2<T> *>(this)->ptr(pi);
    }
    const T& operator()(int i, int j ) const {
        bool filled (false);
        const T* ptr = static_cast<const T *>((*m_core)(i,j,filled));
        if( ptr ) return *ptr;
        else return filled ? m_fill_value : m_background_value;
    }
    const T& operator()(const vec2i &pi ) const {
        return (*const_cast<array2<T> *>(this))(pi[0],pi[1]);
    }
    bool operator!=( const array2<T> &array ) const {
        return ! (*this == array);
    }
    bool operator==(const array2<T> &v) const {
        if( v.type() == type() ) {
            bool differnt (false);
            interruptible_const_serial_actives([&]( int i, int j, const const_iterator& it) {
                if( it() != v(i,j)) {
                    differnt = true;
                    return true;
                } else {
                    return false;
                }
            });
            if( ! differnt ) {
                interruptible_const_serial_inside([&]( int i, int j, const const_iterator& it) {
                    if( ! it.active()) {
                        if( it() != v(i,j)) {
                            differnt = true;
                            return true;
                        }
                    }
                    return false;
                });
            }
            return ! differnt;
        }
        return false;
    }
    void operator=(const T &v) {
        parallel_op([&](iterator& it) {
            it.set(v);
        },m_touch_only_actives);
    }
    void operator+=(const array2<T> &v) {
        assert(shape()==v.shape());
        parallel_op([&](int i, int j, iterator& it, int tn) {
            if( ! m_touch_only_actives || v.active(i,j)) {
                it.increment(v(i,j));
            }
        },m_touch_only_actives);
    }
    void operator-=(const array2<T> &v) {
        assert(shape()==v.shape());
        parallel_op([&](int i, int j, iterator& it, int tn) {
            if( ! m_touch_only_actives || v.active(i,j)) {
                it.subtract(v(i,j));
            }
        },m_touch_only_actives);
    }
    void operator+=(const T &v) {
        parallel_op([&](iterator& it) {
            it.increment(v);
        },m_touch_only_actives);
    }
    void operator-=(const T &v) {
        parallel_op([&](iterator& it) {
            it.subtract(v);
        },m_touch_only_actives);
    }
    void operator*=(const T &v) {
        parallel_op([&](iterator& it) {
            it.multiply(v);
        },m_touch_only_actives);
    }
    void operator/=(const T &v) {
        parallel_op([&](iterator& it) {
            it.divide(v);
        },m_touch_only_actives);
    }
    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 array2<T>;
    public:
        void set( const T &value ) {
            if( ! m_active ) allocate(value);
            else *static_cast<T *>(m_value_ptr) = value;
            m_active = true;
        }
        void set_off() {
            if( m_active && m_value_ptr ) deallocate();
            m_active = false;
        }
        void increment( const T& value ) {
            if( m_active ) {
                *static_cast<T *>(m_value_ptr) += value;
            } else {
                allocate(m_background_value + value);
                m_active = true;
            }
        }
        void subtract( const T& value ) {
            if( m_active ) {
                *static_cast<T *>(m_value_ptr) -= value;
            } else {
                allocate(m_background_value - value);
                m_active = true;
            }
        }
        void multiply( const T& value ) {
            if( m_active ) {
                *static_cast<T *>(m_value_ptr) *= value;
            } else {
                allocate(m_background_value * value);
                m_active = true;
            }
        }
        void divide( const T& value ) {
            multiply(1.0/value);
        }
        bool active() const {
            return m_active;
        }
        bool filled() const {
            return m_filled;
        }
        const T& operator()() const {
            if( m_active ) {
                return *static_cast<const T *>(m_value_ptr);
            } else {
                return m_background_value;
            }
        }
        T* ptr() { return m_active ? static_cast<T *>(m_value_ptr) : nullptr; }
        const T* ptr() const { return m_active ? static_cast<const T *>(m_value_ptr) : nullptr; }
    private:
        //
        iterator( void *value_ptr, bool &_active, bool _filled, const T& m_background_value ) 
            : m_value_ptr(value_ptr), m_active(_active), m_filled(_filled), m_background_value(m_background_value) {}
        //
        void allocate ( const T& value ) {
            new (m_value_ptr) T(value);
        }
        void deallocate() {
            (static_cast<T *>(m_value_ptr))->~T();
        }
        bool &m_active;
        bool m_filled;
        void *m_value_ptr;
        const T& m_background_value;
    };
    class const_iterator {
    friend class array2<T>;
    public:
        bool active() const {
            return m_active;
        }
        bool filled() const {
            return m_filled;
        }
        const T& operator()() const {
            if( m_active ) {
                return *static_cast<const T *>(m_value_ptr);
            } else {
                return m_background_value;
            }
        }
        const T* ptr() const { return m_active ? static_cast<const T *>(m_value_ptr) : nullptr; }
    private:
        const_iterator( const void *value_ptr, const bool &_active, bool _filled, const T& m_background_value ) 
            : m_value_ptr(value_ptr), m_active(_active), m_filled(_filled), m_background_value(m_background_value) {}
        //
        const bool &m_active;
        bool m_filled;
        const void *m_value_ptr;
        const T& m_background_value;
    };
    //
    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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                func(i,j,it,thread_n);
            },m_parallel);
        }
    }
    void const_parallel_actives( std::function<void(const const_iterator& it)> func ) const { const_parallel_op(func,ACTIVES); }
    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_inside( std::function<void(const const_iterator& it)> func ) const {
        const_parallel_inside([func](int i, int j, const const_iterator& it, int thread_index){
            func(it);
        });
    }
    void const_parallel_actives( std::function<void(int i, int j, const const_iterator& it)> func ) const { const_parallel_op(func,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_inside( std::function<void(int i, int j, const const_iterator& it)> func ) const {
        const_parallel_inside([func](int i, int j, const const_iterator& it, int thread_index){
            func(i,j,it);
        });
    }
    void const_parallel_actives( std::function<void(int i, int j, const const_iterator& it, int thread_index)> func ) const { const_parallel_op(func,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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                func(i,j,it,thread_n);
            },m_parallel);
        }
    }
    void const_parallel_inside( std::function<void(int i, int j, const const_iterator& it, int thread_index)> func ) const {
        m_core->const_parallel_inside([&](int i, int j, const void *value_ptr, const bool &active, int thread_n ){
            const_iterator it(value_ptr,active,true,m_fill_value);
            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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                func(i,j,it);
                return false;
            });
        }
    }
    void const_serial_actives( std::function<void(const const_iterator& it)> func ) const { const_serial_op(func,ACTIVES); }
    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_inside( std::function<void(const const_iterator& it)> func ) const {
        const_serial_inside([func](int i, int j, const const_iterator& it){
            func(it);
        });
    }
    void const_serial_actives( std::function<void(int i, int j, const const_iterator& it)> func ) const { const_serial_op(func,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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                func(i,j,it);
                return false;
            });
        }
    }
    void const_serial_inside( std::function<void(int i, int j, const const_iterator& it)> func ) const {
        m_core->const_serial_inside([&](int i, int j, const void *value_ptr, const bool &active ){
            const_iterator it(value_ptr,active,true,m_fill_value);
            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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                return func(i,j,it);
            });
        } else {
            m_core->serial_all([&](int i, int j, void *value_ptr, bool &active, const bool &filled ){
                iterator it(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                return func(i,j,it);
            });
        }
    }
    void interruptible_const_serial_actives( std::function<bool(const const_iterator& it)> func ) const { interruptible_const_serial_op(func,ACTIVES); }
    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_inside( std::function<bool(const const_iterator& it)> func ) const {
        const_serial_inside([func](int i, int j, const const_iterator& it){
            return func(it);
        });
    }
    void interruptible_const_serial_actives( std::function<bool(int i, int j, const const_iterator& it)> func ) const { interruptible_const_serial_op(func,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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                return func(i,j,it);
            });
        }
    }
    void interruptible_const_serial_inside( std::function<bool(int i, int j, const const_iterator& it)> func ) const {
        m_core->const_serial_inside([&](int i, int j, const void *value_ptr, const bool &active ){
            const_iterator it(value_ptr,active,true,m_fill_value);
            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(value_ptr,active,filled,filled ? m_fill_value : m_background_value);
                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(it()); },count);
    }
    void erode( std::function<bool(int i, int j, const const_iterator& it, 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, const auto &it, 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->active(pi)) {
                            if( func(i,j,it,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, const const_iterator& it)> func, int count=1 ) {
        erode([&](int i, int j, const const_iterator& it, int thread_index) {
            return func(i,j,it);
        },count);
    }
    void erode( int count=1 ) {
        erode([&](int i, int j, const const_iterator& it, int thread_index) { return true; },count);
    }
    void swap( array2& rhs ) {
        m_core.swap(rhs.m_core);
        std::swap(m_shape,rhs.m_shape);
        std::swap(m_background_value,rhs.m_background_value);
        std::swap(m_core_name,rhs.m_core_name);
        std::swap(m_touch_only_actives,rhs.m_touch_only_actives);
        std::swap(m_levelset,rhs.m_levelset);
        std::swap(m_fillable,rhs.m_fillable);
        std::swap(m_fill_value,rhs.m_fill_value);
    }
    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;
        T background_value;
        T fill_value;
        bool is_fillable;
        bool is_levelset;
        bool touch_only_actives;
        bool operator==(const type2 &rhs) const {
            return 
                core_name == rhs.core_name &&
                shape == rhs.shape &&
                background_value == rhs.background_value &&
                fill_value == rhs.fill_value &&
                is_fillable == rhs.is_fillable &&
                is_levelset == rhs.is_levelset &&
                touch_only_actives == rhs.touch_only_actives;
        }
    };
    type2 type() const { return { get_core_name(),shape(),m_background_value,m_fill_value,m_fillable,m_levelset,m_touch_only_actives}; }
    void set_type( const type2 &type ) {
        m_core_name = type.core_name;
        m_shape = type.shape;
        m_background_value = type.background_value;
        m_touch_only_actives = type.touch_only_actives;
        m_fillable = type.is_fillable;
        m_fill_value = type.fill_value;
        m_levelset = type.is_levelset;
    }
    //
private:
    //
    shape2 m_shape;
    parallel_driver m_parallel{this};
    T m_background_value {T()}, m_fill_value {T()};
    bool m_touch_only_actives {false}, m_fillable {false}, m_levelset {false}, m_is_initialized {false};
    array2_ptr m_core;
    std::string m_core_name;
};
//
SHKZ_END_NAMESPACE
//
#endif