FvConversionTemplate.h

[詳解]

//  $Revision: 1.1 $
/*
    @file   FvConversionTemplate.h
    @brief  image convert template functions
    @author FAST Corporation
*/


#ifndef     _FVCONVERSIONTEMPLATE_H_INCLUDED_
#define     _FVCONVERSIONTEMPLATE_H_INCLUDED_

#include "FvMacros.h"
#include "FvDefs.h"
#include "Math/FvMathTemplate.h"

namespace FVCL
{
namespace Conversion
{

template<class TD, class TS> bool BinToAny( TD* dst, const TS* src, UINT start, UINT end, const TD& low, const TD& high )
{
    if( dst == NULL ) return false;
    if( src == NULL ) return false;

    UINT    bits = sizeof(TS) * 8;
    for( UINT xpos=start ; xpos<=end ; xpos++ )
    {
        const TS*   src_adrs = src + (xpos/bits);
        UINT        bit = xpos % bits;
        INT         shift = (INT)(bits - bit - 1);
        TS          mask;
        Math::BitShiftL( &mask, (TS)0x1, shift );
        *dst = ((*src_adrs) & mask) ? high : low;
        dst++;
    }
    return true;
}

template<class TD, class TS> bool GrayToGray( TD* dst, INT dst_depth, TS* src, INT src_depth, UINT pixels )
{
    if( dst == NULL ) return false;
    if( src == NULL ) return false;

    INT     shift = src_depth - dst_depth;
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        Math::BitShiftR( dst, (*src), shift );
        dst++;
        src++;
    }
    return true;
}

template<class TD, class TS> bool GrayToRGB( TD* dst, INT dst_depth, TS* src, INT src_depth, UINT pixels, const TD* initval=NULL )
{
    if( dst == NULL ) return false;
    if( src == NULL ) return false;

    INT     shift = src_depth - dst_depth;
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        UINT    D;
        Math::BitShiftR( &D, *src, shift );
        if( initval )   *dst = *initval;
        dst->R = D;
        dst->G = D;
        dst->B = D;
        dst++;
        src++;
    }
    return true;
}

template<class TD, class TS> bool RGBToGray( TD* dst, INT dst_depth, TS* src, INT src_depth, UINT pixels, DOUBLE dbR=0.299, DOUBLE dbG=0.587, DOUBLE dbB=0.114 )
{
    if( dst == NULL ) return false;
    if( src == NULL ) return false;

    INT     shift = src_depth - dst_depth;
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        TD  R, G, B;
        Math::BitShiftR( &R, src->R, shift );
        Math::BitShiftR( &G, src->G, shift );
        Math::BitShiftR( &B, src->B, shift );
        *dst = (TD)(R*dbR + G*dbG + B*dbB);
        dst++;
        src++;
    }
    return true;
}

template<class TD, class TS> bool RGBToGray( TD* dst, INT dst_depth, TS* srcR, TS* srcG, TS* srcB, INT src_depth, UINT pixels, DOUBLE dbR=0.299, DOUBLE dbG=0.587, DOUBLE dbB=0.114 )
{
    if( dst == NULL ) return false;
    if( srcR == NULL ) return false;
    if( srcG == NULL ) return false;
    if( srcB == NULL ) return false;

    INT     shift = src_depth - dst_depth;
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        TD  R, G, B;
        Math::BitShiftR( &R, *srcR, shift );
        Math::BitShiftR( &G, *srcG, shift );
        Math::BitShiftR( &B, *srcB, shift );
        *dst = (TD)(R*dbR + G*dbG + B*dbB);
        dst++;
        srcR++;
        srcG++;
        srcB++;
    }
    return true;
}

template<class TD, class TS> bool RGBToRGB( TD* dst, INT dst_depth, TS* src, INT src_depth, UINT pixels, const TD* initval=NULL )
{
    if( dst == NULL ) return false;
    if( src == NULL ) return false;

    INT     shift = src_depth - dst_depth;
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        UINT    R, G, B;
        Math::BitShiftR( &R, src->R, shift );
        Math::BitShiftR( &G, src->G, shift );
        Math::BitShiftR( &B, src->B, shift );
        if( initval )   *dst = *initval;
        dst->R = R;
        dst->G = G;
        dst->B = B;
        dst++;
        src++;
    }
    return true;
}

template<class TD, class TS> bool PackRGB( TD* dst, INT dst_depth, TS* srcR, TS* srcG, TS* srcB, INT src_depth, UINT pixels, const TD* initval=NULL )
{
    if( dst == NULL ) return false;
    if( srcR == NULL ) return false;
    if( srcG == NULL ) return false;
    if( srcB == NULL ) return false;

    INT     shift = src_depth - dst_depth;
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        UINT    R, G, B;
        Math::BitShiftR( &R, *(srcR+xpos), shift );
        Math::BitShiftR( &G, *(srcG+xpos), shift );
        Math::BitShiftR( &B, *(srcB+xpos), shift );
        if( initval )   *dst = *initval;
        dst->R = R;
        dst->G = G;
        dst->B = B;
        dst++;
    }
    return true;
}

template<class TD, class TS> bool UnpackRGB( TD* dstR, TD* dstG, TD* dstB, INT dst_depth, TS* src, INT src_depth, UINT pixels )
{
    if( src == NULL ) return false;
    if( dstR == NULL ) return false;
    if( dstG == NULL ) return false;
    if( dstB == NULL ) return false;

    TS* srcR = src;
    TS* srcG = src;
    TS* srcB = src;

    INT     shift = src_depth - dst_depth;
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        Math::BitShiftR( dstR, srcR->R, shift );
        srcR++;
        dstR++;
    }
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        Math::BitShiftR( dstG, srcG->G, shift );
        srcG++;
        dstG++;
    }
    for( UINT xpos=0 ; xpos<pixels ; xpos++ )
    {
        Math::BitShiftR( dstB, srcB->B, shift );
        srcB++;
        dstB++;
    }
    return true;
}

}   // Conversion
}   // FVCL

#endif  // _FVCONVERSIONTEMPLATE_H_INCLUDED_