RU_AlgorithmMacros.h File Reference

#include <SYS/SYS_Types.h>

Include dependency graph for RU_AlgorithmMacros.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DECLARE_GENERATOR_OP(name, override_)
#define	DECLARE_PIXEL_OP(name, override_)
#define	DECLARE_FILTER_OP(name, override_)
#define	DECLARE_BINARY_OP(name, override_)
#define	IMPLEMENT_GENERATOR_OP(classname, name)
#define	IMPLEMENT_PIXEL_OP(classname, name)
#define	IMPLEMENT_FILTER_OP(classname, name)
#define	IMPLEMENT_BINARY_OP(classname, name)

Macro Definition Documentation

#define DECLARE_BINARY_OP	(		name,
			override_
	)

Value:

virtual RU_BinaryOp<uint8, 0> *   allocateBinary(uint8, int) override_;    \
    virtual RU_BinaryOp<uint16, 0> *  allocateBinary(uint16, int) override_;   \
    virtual RU_BinaryOp<uint32, 0> *  allocateBinary(uint32, int) override_;   \
    virtual RU_BinaryOp<fpreal32, 0> *allocateBinary(fpreal32, int) override_; \
    virtual RU_BinaryOp<fpreal16, 0> *allocateBinary(fpreal16, int) override_; \
    virtual RU_BinaryOp<uint8, 1> *   allocateBinary(uint8) override_;         \
    virtual RU_BinaryOp<uint16, 1> *  allocateBinary(uint16) override_;        \
    virtual RU_BinaryOp<uint32, 1> *  allocateBinary(uint32) override_;        \
    virtual RU_BinaryOp<fpreal32, 1> *allocateBinary(fpreal32) override_;      \
    virtual RU_BinaryOp<fpreal16, 1> *allocateBinary(fpreal16) override_;

Definition at line 66 of file RU_AlgorithmMacros.h.

#define DECLARE_FILTER_OP	(		name,
			override_
	)

Value:

virtual RU_FilterOp<uint8, 0> *   allocateFilter(uint8, int) override_;    \
    virtual RU_FilterOp<uint16, 0> *  allocateFilter(uint16, int) override_;   \
    virtual RU_FilterOp<uint32, 0> *  allocateFilter(uint32, int) override_;   \
    virtual RU_FilterOp<fpreal32, 0> *allocateFilter(fpreal32, int) override_; \
    virtual RU_FilterOp<fpreal16, 0> *allocateFilter(fpreal16, int) override_; \
    virtual RU_FilterOp<uint8, 1> *   allocateFilter(uint8) override_;         \
    virtual RU_FilterOp<uint16, 1> *  allocateFilter(uint16) override_;        \
    virtual RU_FilterOp<uint32, 1> *  allocateFilter(uint32) override_;        \
    virtual RU_FilterOp<fpreal32, 1> *allocateFilter(fpreal32) override_;      \
    virtual RU_FilterOp<fpreal16, 1> *allocateFilter(fpreal16) override_;

Definition at line 53 of file RU_AlgorithmMacros.h.

#define DECLARE_GENERATOR_OP	(		name,
			override_
	)

Value:

virtual RU_GeneratorOp<uint8, 0> *                                         \
                                    allocateGenerator(uint8,int) override_;    \
    virtual RU_GeneratorOp<uint16, 0> *                                        \
                                    allocateGenerator(uint16,int) override_;   \
    virtual RU_GeneratorOp<uint32, 0> *                                        \
                                    allocateGenerator(uint32,int) override_;   \
    virtual RU_GeneratorOp<fpreal32, 0> *                                      \
                                    allocateGenerator(fpreal32,int) override_; \
    virtual RU_GeneratorOp<fpreal16, 0> *                                      \
                                    allocateGenerator(fpreal16,int) override_; \
    virtual RU_GeneratorOp<uint8, 1> *                                         \
                                    allocateGenerator(uint8) override_;        \
    virtual RU_GeneratorOp<uint16, 1> *                                        \
                                    allocateGenerator(uint16) override_;       \
    virtual RU_GeneratorOp<uint32, 1> *                                        \
                                    allocateGenerator(uint32) override_;       \
    virtual RU_GeneratorOp<fpreal32, 1> *                                      \
                                    allocateGenerator(fpreal32) override_;     \
    virtual RU_GeneratorOp<fpreal16, 1> *                                      \
                                    allocateGenerator(fpreal16) override_;

Definition at line 18 of file RU_AlgorithmMacros.h.

#define DECLARE_PIXEL_OP	(		name,
			override_
	)

Value:

virtual RU_PixelOp<uint8, 0> *   allocatePixel(uint8, int) override_;      \
    virtual RU_PixelOp<uint16, 0> *  allocatePixel(uint16, int) override_;     \
    virtual RU_PixelOp<uint32, 0> *  allocatePixel(uint32, int) override_;     \
    virtual RU_PixelOp<fpreal32, 0> *allocatePixel(fpreal32, int) override_;   \
    virtual RU_PixelOp<fpreal16, 0> *allocatePixel(fpreal16, int) override_;   \
    virtual RU_PixelOp<uint8, 1> *   allocatePixel(uint8) override_;           \
    virtual RU_PixelOp<uint16, 1> *  allocatePixel(uint16) override_;          \
    virtual RU_PixelOp<uint32, 1> *  allocatePixel(uint32) override_;          \
    virtual RU_PixelOp<fpreal32, 1> *allocatePixel(fpreal32) override_;        \
    virtual RU_PixelOp<fpreal16, 1> *allocatePixel(fpreal16) override_;

Definition at line 41 of file RU_AlgorithmMacros.h.

#define IMPLEMENT_BINARY_OP	(		classname,
			name
	)

Value:

RU_BinaryOp<unsigned char,0> *classname::allocateBinary(unsigned char,int)\
        { return new name<unsigned char,0>(this); }                     \
     RU_BinaryOp<unsigned short,0> *classname::allocateBinary(unsigned short,int)\
        { return new name<unsigned short,0>(this); }                    \
     RU_BinaryOp<unsigned int,0> *classname::allocateBinary(unsigned int,int) \
        { return new name<unsigned int,0>(this); }                      \
     RU_BinaryOp<float,0> *classname::allocateBinary(float,int)         \
        { return new name<float,0>(this); }                             \
     RU_BinaryOp<fpreal16,0> *classname::allocateBinary(fpreal16,int)\
        { return new name<fpreal16,0>(this); }                  \
     RU_BinaryOp<unsigned char,1> *classname::allocateBinary(unsigned char)\
        { return new name<unsigned char,1>(this); }                     \
     RU_BinaryOp<unsigned short,1> *classname::allocateBinary(unsigned short)\
        { return new name<unsigned short,1>(this); }                    \
     RU_BinaryOp<unsigned int,1> *classname::allocateBinary(unsigned int)\
        { return new name<unsigned int,1>(this); }                      \
     RU_BinaryOp<float,1> *classname::allocateBinary(float)             \
        { return new name<float,1>(this); }                             \
     RU_BinaryOp<fpreal16,1> *classname::allocateBinary(fpreal16)       \
        { return new name<fpreal16,1>(this); }

Definition at line 148 of file RU_AlgorithmMacros.h.

#define IMPLEMENT_FILTER_OP	(		classname,
			name
	)

Value:

RU_FilterOp<unsigned char,0>  *classname::allocateFilter(unsigned char,int) \
                { return new name<unsigned char,0>(this); }                  \
     RU_FilterOp<unsigned short,0> *classname::allocateFilter(unsigned short,int)\
                { return new name<unsigned short,0>(this); }                 \
     RU_FilterOp<unsigned int,0>   *classname::allocateFilter(unsigned int,int)\
                { return new name<unsigned int,0>(this); }                   \
     RU_FilterOp<float,0>          *classname::allocateFilter(float,int)     \
                { return new name<float,0>(this); }                          \
     RU_FilterOp<fpreal16,0>     *classname::allocateFilter(fpreal16,int)\
                { return new name<fpreal16,0>(this); }               \
     RU_FilterOp<unsigned char,1>  *classname::allocateFilter(unsigned char) \
                { return new name<unsigned char,1>(this); }                  \
     RU_FilterOp<unsigned short,1> *classname::allocateFilter(unsigned short)\
                { return new name<unsigned short,1>(this); }                 \
     RU_FilterOp<unsigned int,1>   *classname::allocateFilter(unsigned int)  \
                { return new name<unsigned int,1>(this); }                   \
     RU_FilterOp<float,1>          *classname::allocateFilter(float)         \
                { return new name<float,1>(this); }                          \
     RU_FilterOp<fpreal16,1>     *classname::allocateFilter(fpreal16)    \
                { return new name<fpreal16,1>(this); }

Definition at line 125 of file RU_AlgorithmMacros.h.

#define IMPLEMENT_GENERATOR_OP	(		classname,
			name
	)

Value:

RU_GeneratorOp<unsigned char,0>  *classname::allocateGenerator(unsigned char,int) \
                { return new name<unsigned char,0>(this); }                   \
     RU_GeneratorOp<unsigned short,0> *classname::allocateGenerator(unsigned short,int)\
                { return new name<unsigned short,0>(this); }                  \
     RU_GeneratorOp<unsigned int,0> *classname::allocateGenerator(unsigned int,int)  \
                { return new name<unsigned int,0>(this); }                    \
     RU_GeneratorOp<float,0> *classname::allocateGenerator(float,int)         \
                { return new name<float,0>(this); }                           \
     RU_GeneratorOp<fpreal16,0> *classname::allocateGenerator(fpreal16,int)\
                { return new name<fpreal16,0>(this); }                \
     RU_GeneratorOp<unsigned char,1>  *classname::allocateGenerator(unsigned char) \
                { return new name<unsigned char,1>(this); }                   \
     RU_GeneratorOp<unsigned short,1> *classname::allocateGenerator(unsigned short)\
                { return new name<unsigned short,1>(this); }                  \
     RU_GeneratorOp<unsigned int,1>   *classname::allocateGenerator(unsigned int) \
                { return new name<unsigned int,1>(this); }                    \
     RU_GeneratorOp<float,1> *classname::allocateGenerator(float)             \
                { return new name<float,1>(this); }                           \
     RU_GeneratorOp<fpreal16,1> *classname::allocateGenerator(fpreal16)   \
                { return new name<fpreal16,1>(this); }

Definition at line 79 of file RU_AlgorithmMacros.h.

#define IMPLEMENT_PIXEL_OP	(		classname,
			name
	)

Value:

RU_PixelOp<unsigned char,0>  *classname::allocatePixel(unsigned char,int)\
                { return new name<unsigned char,0>(this); }                  \
     RU_PixelOp<unsigned short,0> *classname::allocatePixel(unsigned short,int)\
                { return new name<unsigned short,0>(this); }                 \
     RU_PixelOp<unsigned int,0>  *classname::allocatePixel(unsigned int,int) \
                { return new name<unsigned int,0>(this); }                   \
     RU_PixelOp<float,0>       *classname::allocatePixel(float,int)          \
                { return new name<float,0>(this); }                          \
     RU_PixelOp<fpreal16,0>  *classname::allocatePixel(fpreal16,int)     \
                { return new name<fpreal16,0>(this); }               \
     RU_PixelOp<unsigned char,1>  *classname::allocatePixel(unsigned char)   \
                { return new name<unsigned char,1>(this); }                  \
     RU_PixelOp<unsigned short,1> *classname::allocatePixel(unsigned short)  \
                { return new name<unsigned short,1>(this); }                 \
     RU_PixelOp<unsigned int,1>   *classname::allocatePixel(unsigned int)    \
                { return new name<unsigned int,1>(this); }                   \
     RU_PixelOp<float,1>       *classname::allocatePixel(float)              \
                { return new name<float,1>(this); }                          \
     RU_PixelOp<fpreal16,1>  *classname::allocatePixel(fpreal16 )            \
                { return new name<fpreal16,1>(this); }

Definition at line 102 of file RU_AlgorithmMacros.h.