shape.h

Go to the documentation of this file.

/*
**  shape.h
**
**  This is part of Shiokaze, a research-oriented fluid solver for computer graphics.
**  Created by Ryoichi Ando <rand@nii.ac.jp> on Feb 10, 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_SHAPE_H
#define SHKZ_SHAPE_H
//
#include <shiokaze/math/vec.h>
#include <algorithm>
#include <cstdint>
#include <functional>
#include <cmath>
//
SHKZ_BEGIN_NAMESPACE
//
//
struct shape2 {
    shape2( const unsigned gn[DIM2] ) : w(gn[0]), h(gn[1]) {}
    shape2( unsigned w, unsigned h ) : w(w), h(h) {}
    shape2() : w(0), h(0) {}
    bool operator==( const shape2 &shape ) const {
        return w==shape.w && h==shape.h;
    }
    bool operator!=( const shape2 &shape ) const {
        return ! (*this == shape);
    }
    unsigned operator[](unsigned idx) const {
        if( idx == 0 ) return w;
        else if( idx == 1 ) return h;
        else return 0;
    }
    unsigned& operator[](unsigned idx) {
        static unsigned dummy (0);
        if( idx == 0 ) return w;
        else if( idx == 1 ) return h;
        else return dummy;
    }
    shape2 operator+(const shape2& rhs) const { 
        return shape2(w+rhs.w,h+rhs.h);
    }
    void operator+=(const shape2& rhs) { 
        w += rhs.w;
        h += rhs.h;
    }
    shape2 operator-(const shape2& rhs) const { 
        return shape2(w-rhs.w,h-rhs.h);
    }
    void operator-=(const shape2& rhs) { 
        w -= rhs.w;
        h -= rhs.h;
    }
    shape2 operator*(double s) const { 
        return shape2(s*w,s*h);
    }
    void operator*=(double v) { 
        w *= v;
        h *= v;
    }
    shape2 operator/(double s) const { 
        return shape2(w/s,h/s);
    }
    void operator/=(double v) { 
        w /= v;
        h /= v;
    }
    void get( unsigned &w, unsigned &h ) const {
        w = this->w;
        h = this->h;
    }
    void get( unsigned gn[DIM2] ) const {
        gn[0] = w;
        gn[1] = h;
    }
    vec2d box( double dx ) const {
        return vec2d(dx*w,dx*h);
    }
    bool operator<(const shape2& rhs) const { 
        return hash() < rhs.hash();
    }
    size_t hash() const {
        size_t _w (w);
        size_t _h (h);
        unsigned log2h = (unsigned)log2(h)+1;
        return _w ^ (_h << log2h);
    }
    shape2 cell() const { return shape2(w,h); }
    shape2 nodal() const { return shape2(w+1,h+1); }
    shape2 face(int dim) const { return shape2(w+(dim==0),h+(dim==1)); }
    template <class T> vec2i find_cell( const vec2<T> &p ) const {
        return cell().clamp(p);
    }
    template <class T> vec2i find_node( const vec2<T> &p ) const {
        return nodal().clamp(p+vec2d(0.5,0.5));
    }
    template <class T> vec2i find_face( const vec2<T> &p, unsigned dim ) const {
        return face(dim).clamp(p+0.5*vec2d(dim==0,dim==1));
    }
    double dx() const {
        double dx(1.0);
        for( unsigned dim : DIMS2 ) dx = std::min(dx,1.0/(*this)[dim]);
        return dx;
    }
    unsigned max() const {
        unsigned result (0);
        for( int dim : DIMS2 ) result = std::max(result,(*this)[dim]);
        return result;
    }
    vec2i clamp( const vec2i &pi ) const { 
        return clamp(pi[0],pi[1]);
    }
    vec2i clamp( int i, int j ) const {
        if( i < 0 ) i = 0;
        if( i > w-1 ) i = w-1;
        if( j < 0 ) j = 0;
        if( j > h-1 ) j = h-1;
        return vec2i(i,j);
    }
    bool out_of_bounds( int i, int j ) const {
        return ( i < 0 || i >= w || j < 0 || j >= h );
    }
    bool out_of_bounds( const vec2i &pi ) const {
        return out_of_bounds(pi[0],pi[1]);
    }
    bool on_edge( int i, int j ) const {
        return i==0 || j==0 || i==w-1 || j==h-1;
    }
    bool on_edge( const vec2i &pi ) const {
        return on_edge(pi[0],pi[1]);
    }
    size_t count() const {
        size_t _w(w);
        size_t _h(h);
        return _w*_h;
    }
    bool empty() const {
        return w == 0 && h == 0;
    }
    size_t encode( int i, int j ) const {
        size_t _w(w);
        return _w*j+i;
    }
    size_t encode( const vec2i &pi ) const {
        return encode(pi[0],pi[1]);
    }
    vec2i decode( size_t value ) const {
        return vec2i( value % w, value / w );
    }
    void for_each( std::function<void(int i, int j)> func ) const {
        for( int j=0; j<h; ++j ) for( int i=0; i<w; ++i ) {
            func(i,j);
        }
    }
    void interruptible_for_each( std::function<bool(int i, int j)> func ) const {
        for( int j=0; j<h; ++j ) for( int i=0; i<w; ++i ) {
            if(func(i,j)) return;
        }
    }
    unsigned w;
    unsigned h;
};
//
static inline shape2 operator*(double s, const shape2 &shape) {
    return shape*s;
}
static inline shape2 operator/(double s, const shape2 &shape) {
    return shape/s;
}
//
struct shape3 {
    shape3( const unsigned gn[DIM2] ) : w(gn[0]), h(gn[1]), d(gn[2]) {}
    shape3( unsigned w, unsigned h, unsigned d) : w(w), h(h), d(d) {}
    shape3() : w(0), h(0), d(0) {}
    bool operator==( const shape3 &shape ) const {
        return w==shape.w && h==shape.h && d==shape.d;
    }
    bool operator!=( const shape3 &shape ) const {
        return ! (*this == shape);
    }
    unsigned operator[](unsigned idx) const {
        if( idx == 0 ) return w;
        else if( idx == 1 ) return h;
        else if( idx == 2 ) return d;
        else return 0;
    }
    unsigned& operator[](unsigned idx) {
        static unsigned dummy (0);
        if( idx == 0 ) return w;
        else if( idx == 1 ) return h;
        else if( idx == 2 ) return d;
        else return dummy;
    }
    shape3 operator+(const shape3& rhs) const { 
        return shape3(w+rhs.w,h+rhs.h,d+rhs.d);
    }
    void operator+=(const shape3& rhs) { 
        w += rhs.w;
        h += rhs.h;
        d += rhs.d;
    }
    shape3 operator-(const shape3& rhs) const { 
        return shape3(w-rhs.w,h-rhs.h,d-rhs.d);
    }
    void operator-=(const shape3& rhs) { 
        w -= rhs.w;
        h -= rhs.h;
        d -= rhs.d;
    }
    shape3 operator*(double s) const { 
        return shape3(s*w,s*h,s*d);
    }
    void operator*=(double v) { 
        w *= v;
        h *= v;
        d *= v;
    }
    shape3 operator/(double s) const { 
        return shape3(w/s,h/s,d/s);
    }
    void operator/=(double v) { 
        w /= v;
        h /= v;
        d /= v;
    }
    void get( unsigned &w, unsigned &h, unsigned &d ) const {
        w = this->w;
        h = this->h;
        d = this->d;
    }
    void get( unsigned gn[DIM3] ) const {
        gn[0] = w;
        gn[1] = h;
        gn[2] = d;
    }
    vec3d box( double dx ) const {
        return vec3d(dx*w,dx*h,dx*d);
    }
    bool operator<(const shape2& rhs) const { 
        return hash() < rhs.hash();
    }
    size_t hash() const {
        size_t _w (w);
        size_t _h (h);
        size_t _d (h);
        unsigned log2h = (unsigned)log2(h)+1;
        unsigned log2d = (unsigned)log2(d)+1;
        return _w ^ (_h << log2h) ^ (_d << (log2h+log2d));
    }
    shape3 cell() const { return shape3(w,h,d); }
    shape3 nodal() const { return shape3(w+1,h+1,d+1); }
    shape3 face(int dim) const { return shape3(w+(dim==0),h+(dim==1),d+(dim==2)); }
    shape3 edge(int dim) const { return shape3(w+(dim!=0),h+(dim!=1),d+(dim!=2)); }
    vec3i find_cell( const vec3d &p ) const {
        return shape3(w,h,d).clamp(p);
    }
    template <class T> vec3i find_node( const vec3<T> &p ) const {
        return nodal().clamp(p+vec3d(0.5,0.5,0.5));
    }
    template <class T> vec3i find_edge( const vec3<T> &p, unsigned dim ) const {
        return edge(dim).clamp(p+0.5*vec3d(dim!=0,dim!=1,dim!=2));
    }
    template <class T> vec3i find_face( const vec3<T> &p, unsigned dim ) const {
        return face(dim).clamp(p+0.5*vec3d(dim==0,dim==1,dim==2));
    }
    double dx() const {
        double dx(1.0);
        for( unsigned dim : DIMS3 ) dx = std::min(dx,1.0/(*this)[dim]);
        return dx;
    }
    unsigned max() const {
        unsigned result (0);
        for( int dim : DIMS3 ) result = std::max(result,(*this)[dim]);
        return result;
    }
    vec3i clamp( const vec3i &pi ) const { 
        return clamp(pi[0],pi[1],pi[2]);
    }
    vec3i clamp( int i, int j, int k ) const {
        if( i < 0 ) i = 0;
        if( i > w-1 ) i = w-1;
        if( j < 0 ) j = 0;
        if( j > h-1 ) j = h-1;
        if( k < 0 ) k = 0;
        if( k > d-1 ) k = d-1;
        return vec3i(i,j,k);
    }
    bool out_of_bounds( int i, int j, int k ) const {
        return ( i < 0 || i >= w || j < 0 || j >= h || k < 0 || k >= d );
    }
    bool out_of_bounds( const vec3i &pi ) const {
        return out_of_bounds(pi[0],pi[1],pi[2]);
    }
    bool on_edge( int i, int j, int k ) const {
        return i==0 || j==0 || i==w-1 || j==h-1 || k==d-1 || k==d-1;
    }
    bool on_edge( const vec3i &pi ) const {
        return on_edge(pi[0],pi[1],pi[2]);
    }
    size_t count() const {
        size_t _w (w);
        size_t _h (h);
        size_t _d (d);
        return _w*_h*_d;
    }
    bool empty() const {
        return w == 0 && h == 0 && d == 0;
    }
    size_t encode( int i, int j, int k ) const {
        size_t _w (w);
        size_t _h (h);
        size_t _d (d);
        return (_w*_h)*k+_w*j+i;
    }
    size_t encode( const vec3i &pi ) const {
        return encode(pi[0],pi[1],pi[2]);
    }
    vec3i decode( size_t value ) const {
        size_t plane_count = w*h;
        int k = value / plane_count;
        size_t m = value % plane_count;
        int i = m % w;
        int j = m / w;
        return vec3i(i,j,k);
    }
    void for_each( std::function<void(int i, int j, int k)> func ) const {
        for( int k=0; k<d; ++k ) for( int j=0; j<h; ++j ) for( int i=0; i<w; ++i ) {
            func(i,j,k);
        }
    }
    void interruptible_for_each( std::function<bool(int i, int j, int k)> func ) const {
        for( int k=0; k<d; ++k ) for( int j=0; j<h; ++j ) for( int i=0; i<w; ++i ) {
            if(func(i,j,k)) return;
        }
    }
    unsigned w;
    unsigned h;
    unsigned d;
};
//
static inline shape3 operator*(double s, const shape3 &shape) {
    return shape*s;
}
static inline shape3 operator/(double s, const shape3 &shape) {
    return shape/s;
}
//
SHKZ_END_NAMESPACE
//
#endif