300-Interpolator.cpp File Reference

[← Previous Example] [Next Example → 400-Transformations.cpp ]. More...

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
#include <fiber/field/ArrayRef.hpp>
#include <fiber/field/UniformCartesianArray.hpp>
#include "fiber/baseop/UniformMapping.hpp"
#include <vector/Interpolate.hpp>
#include <vector/LinearIpol.hpp>
#include <elementary/eagle/ColorSpace.hpp>
#include <elementary/meta/NativeTypeList.hpp>
#include <memcore/Console.hpp>

Classes
class	RGBOperator
struct	RGBOperator::rgb_real

Macros
#define	SMALLNUMBER   1e-6
#define	LEVEL   10

Functions
ostream &	operator<< (ostream &os, const rgb_t &x)
int	main ()

Detailed Description

[← Previous Example] [Next Example → 400-Transformations.cpp ].

In FiberLib Tutorial

#include <fiber/bundle/Bundle.hpp>
#include <fiber/finit/FinitAPI.h>
 
#include <fiber/field/ArrayRef.hpp>
 
#include <fiber/field/UniformCartesianArray.hpp>
 
#include "fiber/baseop/UniformMapping.hpp"
#include <vector/Interpolate.hpp>
#include <vector/LinearIpol.hpp>
#include <elementary/eagle/ColorSpace.hpp>
#include <elementary/meta/NativeTypeList.hpp>
#include <memcore/Console.hpp>
 
#define SMALLNUMBER 1e-6
#define LEVEL 10
 
using namespace MemCore;
using namespace Fiber;
using namespace Eagle::PhysicalSpace;
using namespace std;
using namespace META;
using namespace Eagle;
 
ostream&operator<<(ostream&os, const rgb_t&x)
{
        return
                os << "{ " << int(x.r())
                   << ", " << int(x.g())
                   << ", " << int(x.b()) << "}";
}
 
 
class   RGBOperator
{
public:
        struct  rgb_real : DomainVector<Vector<double, 3>, RGB>
        {
                rgb_real(const rgb_t&T)
                : DomainVector<Vector<double, 3>, RGB>( { double(T.r()), double(T.g()), double(T.b()) } )
                {}
 
                rgb_real(const DomainVector<Vector<double, 3>, RGB>&T)
                : DomainVector<Vector<double, 3>, RGB>( T )
                {}
 
                friend rgb_real operator*(const rgb_real&v, double scalar)
                {
                        return DomainVector<Vector<double, 3>, RGB>(v, Mult(), scalar);
                }
                
                friend rgb_real operator+(const rgb_real&u, const rgb_real&v)
                {
                        return DomainVector<Vector<double, 3>, RGB>(u,v, Operator<'+'>() );
                }
        
                operator rgb_t() const
                {
                        return rgb_t( { uint8_t(r()), uint8_t(g()), uint8_t(b()) } );
                }
        };
        
static  rgb_real limit(const rgb_t&T)
        {
                return rgb_real( T );
        }
 
 
};
 
        
int     main()
{
        Finit();
 
MultiIndex<3> Dims = {10,10,2}; 
 
//typedef rgb_real_t rgb_t;
 
/* simple rgb-array with uniform rgb: 60,61,62 */
RefPtr< MemArray<3,rgb_t> > UniformDatafieldMem = new  MemArray<3,rgb_t> (Dims);
MultiArray<3, rgb_t> UniformDatafield = *UniformDatafieldMem;
        UniformDatafield.set({60,61,62});
 
/* some funny index */ 
FixedArray<double,3> FloatingPointIndex ( {1.8 , 2.4 , 0.3} ); 
 
// Need to introduce an RGBOperator type for specific control of operations on RGB data types
Interpolate<3, rgb_t, LinearIpol<rgb_t>, double, RGBOperator>
                Interpolator( UniformDatafield, FloatingPointIndex );
 
                Console() << "Result should be: 60,61,62 and have: " << Interpolator.eval(); 
 
                /*
                  Problem: severe rounding errors when computing with chars and floats:
                 */
rgb_t   A = {60,61,62}, B = {60,61,62}; 
 
        cout << "A=" << A << " ,  B="<<B
             << " A*0.3 = " << A*0.3
             << " B*0.7 = " << B*0.7
             << " mix(A,B,0.3)=" << A*0.3 + B*0.7;
        
        return 0;
}