/scr/tee1/isis/lib/Core/DataStorage/valuearray.hpp

Go to the documentation of this file.

/*
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef TYPEPTR_HPP
#define TYPEPTR_HPP

#include <boost/static_assert.hpp>

#include "valuearray_base.hpp"
#include "valuearray_converter.hpp"
#include "../CoreUtils/value.hpp"
#include "common.hpp"
#include <boost/type_traits/remove_const.hpp>
#include "endianess.hpp"

namespace isis
{
namespace data
{

namespace _internal
{
template<typename T, uint8_t STEPSIZE> std::pair<T, T> calcMinMax( const T *data, size_t len )
{
    BOOST_STATIC_ASSERT( std::numeric_limits<T>::has_denorm != std::denorm_indeterminate ); //well we're pretty f**ed in this case
    std::pair<T, T> result(
        std::numeric_limits<T>::max(),
        std::numeric_limits<T>::has_denorm ? -std::numeric_limits<T>::max() : std::numeric_limits<T>::min() //for types with denormalization min is _not_ the lowest value
    );
    LOG( Runtime, verbose_info ) << "using generic min/max computation for " << util::Value<T>::staticName();

    for ( const T *i = data; i < data + len; i += STEPSIZE ) {
        if(
            std::numeric_limits<T>::has_infinity &&
            ( *i == std::numeric_limits<T>::infinity() || *i == -std::numeric_limits<T>::infinity() )
        )
            continue; // skip this one if its inf

        if ( *i > result.second )result.second = *i; //*i is the new max if its bigger than the current (gets rid of nan as well)

        if ( *i < result.first )result.first = *i; //*i is the new min if its smaller than the current (gets rid of nan as well)
    }

    return result;
}

#ifdef __SSE2__

// specialize calcMinMax for (u)int(8,16,32)_t /

template<> std::pair< uint8_t,  uint8_t> calcMinMax< uint8_t, 1>( const  uint8_t *data, size_t len );
template<> std::pair<uint16_t, uint16_t> calcMinMax<uint16_t, 1>( const uint16_t *data, size_t len );
template<> std::pair<uint32_t, uint32_t> calcMinMax<uint32_t, 1>( const uint32_t *data, size_t len );

template<> std::pair< int8_t,  int8_t> calcMinMax< int8_t, 1>( const  int8_t *data, size_t len );
template<> std::pair<int16_t, int16_t> calcMinMax<int16_t, 1>( const int16_t *data, size_t len );
template<> std::pair<int32_t, int32_t> calcMinMax<int32_t, 1>( const int32_t *data, size_t len );
#endif //__SSE2__

API_EXCLUDE_BEGIN
template<typename T, bool isNumber> struct getMinMaxImpl { // fallback for unsupported types
    std::pair<T, T> operator()( const ValueArray<T> &/*ref*/ ) const {
        LOG( Debug, error ) << "min/max computation of " << util::Value<T>::staticName() << " is not supported";
        return std::pair<T, T>();
    }
};

template<typename T> struct getMinMaxImpl<T, true> { // generic min-max for numbers (this _must_ not be run on empty ValueArray)
    std::pair<T, T> operator()( const ValueArray<T> &ref ) const {
        return calcMinMax<T, 1>( &ref[0], ref.getLength() );
    }
};

template<typename T> struct getMinMaxImpl<util::color<T>, false> { // generic min-max for color (get bounding box in color space)
    std::pair<util::color<T> , util::color<T> > operator()( const ValueArray<util::color<T> > &ref ) const {
        std::pair<util::color<T> , util::color<T> > ret;

        for( uint_fast8_t i = 0; i < 3; i++ ) {
            const std::pair<T, T> buff = calcMinMax<T, 3>( &ref[0].r + i, ref.getLength() * 3 );
            *( &ret.first.r + i ) = buff.first;
            *( &ret.second.r + i ) = buff.second;
        }

        return ret;
    }
};
template<typename T> struct getMinMaxImpl<std::complex<T>, false> { // generic min-max for complex values (get bounding box in complex space)
    std::pair<std::complex<T> , std::complex<T> > operator()( const ValueArray<std::complex<T> > &ref ) const {
        BOOST_STATIC_ASSERT( sizeof( std::complex<T> ) == sizeof( T ) * 2 ); // we need this for the calcMinMax-hack below
        const std::pair<T, T > real = calcMinMax<T, 2>( &ref[0].real(), ref.getLength() * 2 );
        const std::pair<T, T > imag = calcMinMax<T, 2>( &ref[0].imag(), ref.getLength() * 2 );

        return std::make_pair( std::complex<T>( real.first, imag.first ), std::complex<T>( real.second, imag.second ) );
    }
};
API_EXCLUDE_END

template<typename TYPE> class ValueArrayIterator: public std::iterator<std::random_access_iterator_tag, TYPE>
{
    TYPE *p;
    typedef typename std::iterator<std::random_access_iterator_tag, TYPE>::difference_type distance;
    friend class ValueArrayIterator<const TYPE>;
public:
    ValueArrayIterator(): p( NULL ) {}
    ValueArrayIterator( TYPE *_p ): p( _p ) {}
    ValueArrayIterator( const ValueArrayIterator<typename boost::remove_const<TYPE>::type > &src ): p( src.p ) {}

    ValueArrayIterator<TYPE>& operator++() {++p; return *this;}
    ValueArrayIterator<TYPE>& operator--() {--p; return *this;}

    ValueArrayIterator<TYPE>  operator++( int ) {ValueArrayIterator<TYPE> tmp = *this; ++*this; return tmp;}
    ValueArrayIterator<TYPE>  operator--( int ) {ValueArrayIterator<TYPE> tmp = *this; --*this; return tmp;}

    TYPE &operator*() const { return *p; }
    TYPE *operator->() const { return p; }

    bool operator==( const ValueArrayIterator<TYPE> &cmp )const {return p == cmp.p;}
    bool operator!=( const ValueArrayIterator<TYPE> &cmp )const {return !( *this == cmp );}

    bool operator>( const ValueArrayIterator<TYPE> &cmp )const {return p > cmp.p;}
    bool operator<( const ValueArrayIterator<TYPE> &cmp )const {return p < cmp.p;}

    bool operator>=( const ValueArrayIterator<TYPE> &cmp )const {return p >= cmp.p;}
    bool operator<=( const ValueArrayIterator<TYPE> &cmp )const {return p <= cmp.p;}

    ValueArrayIterator<TYPE> operator+( distance n )const {return ValueArrayIterator<TYPE>( p + n );}
    ValueArrayIterator<TYPE> operator-( distance n )const {return ValueArrayIterator<TYPE>( p - n );}

    distance operator-( const ValueArrayIterator<TYPE> &cmp )const {return p - cmp.p;}

    ValueArrayIterator<TYPE> &operator+=( distance n ) {p += n; return *this;}
    ValueArrayIterator<TYPE> &operator-=( distance n ) {p -= n; return *this;}

    TYPE &operator[]( distance n )const {return *( p + n );}
};

}

template<typename TYPE> class ValueArray: public ValueArrayBase
{
    boost::shared_ptr<TYPE> m_val;
    static const util::ValueReference getValueFrom( const void *p ) {
        return util::Value<TYPE>( *reinterpret_cast<const TYPE *>( p ) );
    }
    static void setValueInto( void *p, const util::ValueBase &val ) {
        *reinterpret_cast<TYPE *>( p ) = val.as<TYPE>();
    }
protected:
    ValueArray() {} // should only be used by child classed who initialize the pointer them self
    ValueArrayBase *clone() const {
        return new ValueArray( *this );
    }
public:
    typedef _internal::ValueArrayIterator<TYPE> iterator;
    typedef _internal::ValueArrayIterator<const TYPE> const_iterator;
    typedef typename iterator::reference reference;
    typedef typename const_iterator::reference const_reference;

    static const unsigned short staticID = util::_internal::TypeID<TYPE>::value << 8;
    struct NonDeleter {
        void operator()( TYPE *p ) {
            //we have to cast the pointer to void* here, because in case of uint8_t it will try to print the "string"
            LOG( Debug, info ) << "Not freeing pointer " << ( void * )p << " (" << ValueArray<TYPE>::staticName() << ") ";
        };
    };
    struct BasicDeleter {
        void operator()( TYPE *p ) {
            //we have to cast the pointer to void* here, because in case of uint8_t it will try to print the "string"
            LOG( Debug, verbose_info ) << "Freeing pointer " << ( void * )p << " (" << ValueArray<TYPE>::staticName() << ") ";
            free( p );
        };
    };
    ValueArray( size_t length ): ValueArrayBase( length ) {
        if( length )
            m_val.reset( ( TYPE * )calloc( length, sizeof( TYPE ) ), BasicDeleter() );

        LOG_IF( length == 0, Debug, warning )
                << "Creating an empty ValueArray of type " << util::MSubject( staticName() )
                << " you should overwrite it with a useful pointer before using it";
    }

    ValueArray( const boost::shared_ptr<TYPE> &ptr, size_t length ): ValueArrayBase( length ), m_val( ptr ) {}

    ValueArray( TYPE *const ptr, size_t length ): ValueArrayBase( length ), m_val( ptr, BasicDeleter() ) {}

    template<typename D> ValueArray( TYPE *const ptr, size_t length, D d ): ValueArrayBase( length ), m_val( ptr, d ) {}

    virtual ~ValueArray() {}

    boost::shared_ptr<const void> getRawAddress( size_t offset = 0 )const {
        if( offset ) {
            DelProxy proxy( *this );
            const uint8_t *const b_ptr = reinterpret_cast<const uint8_t *>( m_val.get() ) + offset;
            return boost::shared_ptr<const void>( b_ptr, proxy );
        } else
            return boost::static_pointer_cast<const void>( m_val );
    }
    boost::shared_ptr<void> getRawAddress( size_t offset = 0 ) { // use the const version and cast away the const
        return boost::const_pointer_cast<void>( const_cast<const ValueArray *>( this )->getRawAddress( offset ) );
    }
    virtual value_iterator beginGeneric() {
        return value_iterator( ( uint8_t * )m_val.get(), ( uint8_t * )m_val.get(), bytesPerElem(), getValueFrom, setValueInto );
    }
    virtual const_value_iterator beginGeneric()const {
        return const_value_iterator( ( uint8_t * )m_val.get(), ( uint8_t * )m_val.get(), bytesPerElem(), getValueFrom, setValueInto );
    }

    iterator begin() {return iterator( m_val.get() );}
    iterator end() {return begin() + m_len;};
    const_iterator begin()const {return const_iterator( m_val.get() );}
    const_iterator end()const {return begin() + m_len;}

    virtual std::string toString( bool labeled = false )const {
        std::string ret;

        if ( m_len ) {
            // if you get trouble with to_tm here include <boost/date_time/gregorian/gregorian.hpp> or <boost/date_time/posix_time/posix_time.hpp> in your cpp
            for ( const_iterator i = begin(); i < end() - 1; i++ )
                ret += util::Value<TYPE>( *i ).toString( false ) + "|";


            ret += util::Value<TYPE>( *( end() - 1 ) ).toString( labeled );
        }

        return boost::lexical_cast<std::string>( m_len ) + "#" + ret;
    }

    std::string getTypeName()const {return staticName();}
    unsigned short getTypeID()const {return staticID;}
    bool isFloat() const {return boost::is_float< TYPE >::value;}
    bool isInteger() const {return boost::is_integral< TYPE >::value;}

    static std::string staticName() {
        return std::string( util::Value<TYPE>::staticName() ) + "*";
    }

    TYPE &operator[]( size_t idx ) {
        return begin()[idx];
    }
    const TYPE &operator[]( size_t idx )const {
        return begin()[idx];
    }
    operator boost::shared_ptr<TYPE>&() {return m_val;}
    operator const boost::shared_ptr<TYPE>&()const {return m_val;}

    size_t bytesPerElem()const {return sizeof( TYPE );}

    std::pair<util::ValueReference, util::ValueReference> getMinMax()const {
        if ( getLength() == 0 ) {
            LOG( Debug, error ) << "Skipping computation of min/max on an empty ValueArray";
            return std::pair<util::ValueReference, util::ValueReference>();
        } else {

            const std::pair<util::Value<TYPE>, util::Value<TYPE> > result = _internal::getMinMaxImpl<TYPE, boost::is_arithmetic<TYPE>::value>()( *this );

            return std::make_pair( util::ValueReference( result.first ), util::ValueReference( result.second ) );
        }
    }

    std::vector<Reference> splice( size_t size )const {
        if ( size >= getLength() ) {
            LOG( Debug, warning )
                    << "splicing data of the size " << getLength() << " up into blocks of the size " << size << " is kind of useless ...";
        }

        const size_t fullSplices = getLength() / size;

        const size_t lastSize = getLength() % size;//rest of the division - size of the last splice

        const size_t splices = fullSplices + ( lastSize ? 1 : 0 );

        std::vector<Reference> ret( splices );

        DelProxy proxy( *this );

        for ( size_t i = 0; i < fullSplices; i++ )
            ret[i].reset( new ValueArray( m_val.get() + i * size, size, proxy ) );

        if ( lastSize )
            ret.back().reset( new ValueArray( m_val.get() + fullSplices * size, lastSize, proxy ) );

        return ret;
    }
    //
    scaling_pair getScalingTo( unsigned short typeID, autoscaleOption scaleopt = autoscale )const {
        if( typeID == staticID && scaleopt == autoscale ) { // if id is the same and autoscale is requested
            static const util::Value<uint8_t> one( 1 );
            static const util::Value<uint8_t> zero( 0 );
            return std::pair<util::ValueReference, util::ValueReference>( one, zero ); // the result is always 1/0
        } else { // get min/max and compute the scaling
            std::pair<util::ValueReference, util::ValueReference> minmax = getMinMax();
            assert( ! ( minmax.first.isEmpty() || minmax.second.isEmpty() ) );
            return ValueArrayBase::getScalingTo( typeID, minmax, scaleopt );
        }
    }
    void endianSwap(){
        data::endianSwapArray(begin(),end(),begin());
    }
};
// specialisation for complex - there shall be no scaling - and we cannot compute minmax
template<> scaling_pair ValueArray<std::complex<float> >::getScalingTo( unsigned short /*typeID*/, autoscaleOption /*scaleopt*/ )const;
template<> scaling_pair ValueArray<std::complex<double> >::getScalingTo( unsigned short /*typeID*/, autoscaleOption /*scaleopt*/ )const;
template<typename T> bool ValueArrayBase::is()const
{
    util::checkType<T>();
    return getTypeID() == ValueArray<T>::staticID;
}


}
}
#endif // TYPEPTR_HPP