yarpimage.cpp

来自「一个语言识别引擎」· C++ 代码 · 共 1,110 行 · 第 1/3 页

CPP
1,110 行
字号
123
// -*- mode:C++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-

/*
 * Copyright (C) 2006 Giorgio Metta, Paul Fitzpatrick
 * CopyPolicy: Released under the terms of the GNU GPL v2.0.
 *
 */

///
/// $Id: YARPImage.cpp,v 1.4 2006/10/24 16:43:51 eshuy Exp $
///
///

#include <yarp/YARPTime.h>
#include <yarp/YARPImage.h>
#include <yarp/YARPRefCount.h>

#include <iostream>
using namespace std;

#define DBGPF1 if (0)

void SatisfySize(YARPGenericImage& src, YARPGenericImage& dest)
{
	if (dest.GetHeight()!=src.GetHeight() ||
		dest.GetWidth() !=src.GetWidth())
        {
            dest.Resize(src.GetWidth(),src.GetHeight());
        }
}


// Default copy mechanism
template <class T1, class T2>
inline void CopyPixel(const T1 *src, T2 *dest)
{
	*dest = *src;
}

typedef YarpPixelMono Def_YARP_PIXEL_MONO;
typedef YarpPixelRGB Def_YARP_PIXEL_RGB;
typedef YarpPixelHSV Def_YARP_PIXEL_HSV;
typedef YarpPixelBGR Def_YARP_PIXEL_BGR;
typedef YarpPixelMonoSigned Def_YARP_PIXEL_MONO_SIGNED;
typedef YarpPixelRGBSigned Def_YARP_PIXEL_RGB_SIGNED;
typedef YarpPixelFloat Def_YARP_PIXEL_MONO_FLOAT;
typedef YarpPixelRGBFloat Def_YARP_PIXEL_RGB_FLOAT;
typedef YarpPixelHSVFloat Def_YARP_PIXEL_HSV_FLOAT;
typedef YarpPixelInt Def_YARP_PIXEL_INT;

#define VALID_PIXEL(x) ((x>255)?255:((x<0)?0:x))
#define SPECIAL_COPY_BEGIN void YARPDummyCopyPixel() {
#define SPECIAL_COPY(id1,id2) } inline void CopyPixel(const Def_##id1 *src, Def_##id2 *dest) {
#define SPECIAL_COPY_END }

static int implemented_yet = 1;

SPECIAL_COPY_BEGIN

SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_RGB)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_BGR)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_HSV)
    dest->v = *src;
dest->h = dest->s = 0;
SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_RGB_SIGNED)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_RGB_FLOAT)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_HSV_FLOAT)
    dest->v = *src;
dest->h = dest->s = 0;
SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_MONO_SIGNED)
    *dest = *src >> 1;
SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_INT)
    *dest = *src;
SPECIAL_COPY(YARP_PIXEL_MONO,YARP_PIXEL_MONO_FLOAT)
    *dest = *src;

SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_MONO)
    *dest = (unsigned char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_INT)
    *dest = (unsigned char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_HSV)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_MONO_SIGNED)
    *dest = (char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_RGB_SIGNED)
    dest->r = src->r; dest->g = src->g; dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_MONO_FLOAT)
    *dest = ((src->r + src->g + src->b)/3.0f);
SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_RGB_FLOAT)
    dest->r = src->r;
dest->g = src->g;
dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_BGR)
    dest->r = src->r;
dest->g = src->g;
dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_RGB,YARP_PIXEL_HSV_FLOAT)
    ACE_ASSERT(implemented_yet == 0);


SPECIAL_COPY(YARP_PIXEL_HSV,YARP_PIXEL_MONO)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV,YARP_PIXEL_RGB)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV,YARP_PIXEL_BGR)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV,YARP_PIXEL_MONO_SIGNED)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV,YARP_PIXEL_RGB_SIGNED)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV,YARP_PIXEL_MONO_FLOAT)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV,YARP_PIXEL_RGB_FLOAT)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV,YARP_PIXEL_HSV_FLOAT)
    ACE_ASSERT(implemented_yet == 0);


SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_MONO)
    *dest = (unsigned char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_INT)
    *dest = (unsigned char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_HSV)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_MONO_SIGNED)
    *dest = (char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_RGB_SIGNED)
    dest->r = src->r; dest->g = src->g; dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_MONO_FLOAT)
    *dest = ((src->r + src->g + src->b)/3.0f);
SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_RGB_FLOAT)
    dest->r = src->r;
dest->g = src->g;
dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_RGB)
    dest->r = src->r;
dest->g = src->g;
dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_BGR,YARP_PIXEL_HSV_FLOAT)
    ACE_ASSERT(implemented_yet == 0);


SPECIAL_COPY(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_RGB)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_BGR)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_HSV)
    dest->v = *src;
dest->h = dest->s = 0;
SPECIAL_COPY(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_RGB_SIGNED)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_RGB_FLOAT)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_HSV_FLOAT)
    dest->v = *src;
dest->h = dest->s = 0;
SPECIAL_COPY(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_MONO)
    *dest = *src + 128;
SPECIAL_COPY(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_INT)
    *dest = *src;

SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_MONO)
    *dest = (unsigned char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_INT)
    *dest = (unsigned char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_HSV)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_MONO_SIGNED)
    *dest = (char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_RGB)
    dest->r = src->r;
dest->g = src->g;
dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_BGR)
    dest->r = src->r;
dest->g = src->g;
dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_MONO_FLOAT)
    *dest = ((src->r + src->g + src->b)/3.0f);
SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_RGB_FLOAT)
    dest->r = src->r;
dest->g = src->g;
dest->b = src->b;
SPECIAL_COPY(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_HSV_FLOAT)
    ACE_ASSERT(implemented_yet == 0);

SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_MONO)
    *dest = (unsigned char)*src;
SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_INT)
    *dest = (unsigned char)*src;
SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_MONO_SIGNED)
    *dest = (char)*src;
SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_RGB)
    dest->r = dest->g = dest->b = (unsigned char)(*src);
SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_BGR)
    dest->r = dest->g = dest->b = (unsigned char)(*src);
SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_HSV)
    dest->v = (unsigned char)*src;
dest->h = dest->s = 0;
SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_RGB_SIGNED)
    dest->r = dest->g = dest->b = (signed char) *src;
SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_RGB_FLOAT)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_HSV_FLOAT)
    dest->v = *src;
dest->h = dest->s = 0;

SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_MONO)
    *dest = (unsigned char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_INT)
    *dest = (unsigned char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_HSV)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_MONO_SIGNED)
    *dest = (char)((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_RGB)
    dest->r = (unsigned char) src->r;
dest->g = (unsigned char) src->g;
dest->b = (unsigned char) src->b;
SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_BGR)
    dest->r = (unsigned char) src->r;
dest->g = (unsigned char) src->g;
dest->b = (unsigned char) src->b;
SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_MONO_FLOAT)
    *dest = ((src->r + src->g + src->b)/3);
SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_RGB_SIGNED)
    dest->r = (signed char) src->r;
dest->g = (signed char) src->g;
dest->b = (signed char) src->b;
SPECIAL_COPY(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_HSV_FLOAT)
    ACE_ASSERT(implemented_yet == 0);

SPECIAL_COPY(YARP_PIXEL_HSV_FLOAT,YARP_PIXEL_MONO)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV_FLOAT,YARP_PIXEL_RGB)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV_FLOAT,YARP_PIXEL_BGR)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV_FLOAT,YARP_PIXEL_MONO_SIGNED)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV_FLOAT,YARP_PIXEL_RGB_SIGNED)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV_FLOAT,YARP_PIXEL_MONO_FLOAT)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV_FLOAT,YARP_PIXEL_RGB_FLOAT)
    ACE_ASSERT(implemented_yet == 0);
SPECIAL_COPY(YARP_PIXEL_HSV_FLOAT,YARP_PIXEL_HSV)
    ACE_ASSERT(implemented_yet == 0);

SPECIAL_COPY(YARP_PIXEL_INT,YARP_PIXEL_RGB)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_INT,YARP_PIXEL_BGR)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_INT,YARP_PIXEL_HSV)
    dest->v = *src;
dest->h = dest->s = 0;
SPECIAL_COPY(YARP_PIXEL_INT,YARP_PIXEL_RGB_SIGNED)
    dest->r = dest->g = dest->b = *src;
SPECIAL_COPY(YARP_PIXEL_INT,YARP_PIXEL_RGB_FLOAT)
    dest->r = dest->g = dest->b = float(*src);
SPECIAL_COPY(YARP_PIXEL_INT,YARP_PIXEL_HSV_FLOAT)
    dest->v = float(*src);
dest->h = dest->s = 0;
SPECIAL_COPY(YARP_PIXEL_INT,YARP_PIXEL_MONO_SIGNED)
    *dest = *src >> 1;
SPECIAL_COPY(YARP_PIXEL_INT,YARP_PIXEL_MONO)
    *dest = *src;

SPECIAL_COPY_END

inline int PAD_BYTES (int len, int pad)
{
	const int rem = len % pad;
	return (rem != 0) ? (pad - rem) : rem;
}

///
///
template <class T1, class T2>
void CopyPixels(const T1 *src, T2 *dest, int w, int h)
{
	const int p1 = PAD_BYTES (w * sizeof(T1), YarpImageAlign);
	const int p2 = PAD_BYTES (w * sizeof(T2), YarpImageAlign);

	for (int i=0; i<h; i++)
        {
            for (int j = 0; j < w; j++)
                {
                    CopyPixel(src,dest);
                    src++;
                    dest++;
                }

            src = (const T1*)(((char *)src) + p1);
            dest = (T2*)(((char *)dest) + p2);
        }
}


#define HASH(id1,id2) ((id1)*256+(id2))
#define HANDLE_CASE(len,x1,T1,x2,T2) CopyPixels((T1*)x1,(T2*)x2,w,h);
#define MAKE_CASE(id1,id2) case HASH(id1,id2): HANDLE_CASE(len,src,Def_##id1,dest,Def_##id2); break;
#define MAKE_2CASE(id1,id2) MAKE_CASE(id1,id2); MAKE_CASE(id2,id1);

// More elegant ways to do this, but needs to be efficient at pixel level
void YARPPixelCopier(const char *src, int id1, 
                     char *dest, int id2, int w, int h)
{
    switch(HASH(id1,id2))
        {
            // Macros rely on len, x1, x2 variable names

            MAKE_2CASE(YARP_PIXEL_MONO,YARP_PIXEL_RGB);
            MAKE_2CASE(YARP_PIXEL_MONO,YARP_PIXEL_HSV);
            MAKE_2CASE(YARP_PIXEL_MONO,YARP_PIXEL_BGR);
            MAKE_2CASE(YARP_PIXEL_MONO,YARP_PIXEL_MONO_SIGNED);
            MAKE_2CASE(YARP_PIXEL_MONO,YARP_PIXEL_RGB_SIGNED);
            MAKE_2CASE(YARP_PIXEL_MONO,YARP_PIXEL_MONO_FLOAT);
            MAKE_2CASE(YARP_PIXEL_MONO,YARP_PIXEL_RGB_FLOAT);
            MAKE_2CASE(YARP_PIXEL_MONO,YARP_PIXEL_HSV_FLOAT);

            MAKE_2CASE(YARP_PIXEL_RGB,YARP_PIXEL_HSV);
            MAKE_2CASE(YARP_PIXEL_RGB,YARP_PIXEL_BGR);
            MAKE_2CASE(YARP_PIXEL_RGB,YARP_PIXEL_MONO_SIGNED);
            MAKE_2CASE(YARP_PIXEL_RGB,YARP_PIXEL_RGB_SIGNED);
            MAKE_2CASE(YARP_PIXEL_RGB,YARP_PIXEL_MONO_FLOAT);
            MAKE_2CASE(YARP_PIXEL_RGB,YARP_PIXEL_RGB_FLOAT);
            MAKE_2CASE(YARP_PIXEL_RGB,YARP_PIXEL_HSV_FLOAT);

            MAKE_2CASE(YARP_PIXEL_HSV,YARP_PIXEL_BGR);
            MAKE_2CASE(YARP_PIXEL_HSV,YARP_PIXEL_MONO_SIGNED);
            MAKE_2CASE(YARP_PIXEL_HSV,YARP_PIXEL_RGB_SIGNED);
            MAKE_2CASE(YARP_PIXEL_HSV,YARP_PIXEL_MONO_FLOAT);
            MAKE_2CASE(YARP_PIXEL_HSV,YARP_PIXEL_RGB_FLOAT);
            MAKE_2CASE(YARP_PIXEL_HSV,YARP_PIXEL_HSV_FLOAT);

            MAKE_2CASE(YARP_PIXEL_BGR,YARP_PIXEL_MONO_SIGNED);
            MAKE_2CASE(YARP_PIXEL_BGR,YARP_PIXEL_RGB_SIGNED);
            MAKE_2CASE(YARP_PIXEL_BGR,YARP_PIXEL_MONO_FLOAT);
            MAKE_2CASE(YARP_PIXEL_BGR,YARP_PIXEL_RGB_FLOAT);
            MAKE_2CASE(YARP_PIXEL_BGR,YARP_PIXEL_HSV_FLOAT);

            MAKE_2CASE(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_RGB_SIGNED);
            MAKE_2CASE(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_MONO_FLOAT);
            MAKE_2CASE(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_RGB_FLOAT);
            MAKE_2CASE(YARP_PIXEL_MONO_SIGNED,YARP_PIXEL_HSV_FLOAT);


            MAKE_2CASE(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_MONO_FLOAT);
            MAKE_2CASE(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_RGB_FLOAT);
            MAKE_2CASE(YARP_PIXEL_RGB_SIGNED,YARP_PIXEL_HSV_FLOAT);

            MAKE_2CASE(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_RGB_FLOAT);
            MAKE_2CASE(YARP_PIXEL_MONO_FLOAT,YARP_PIXEL_HSV_FLOAT);

            MAKE_2CASE(YARP_PIXEL_RGB_FLOAT,YARP_PIXEL_HSV_FLOAT);

            MAKE_2CASE(YARP_PIXEL_BGR,YARP_PIXEL_INT);

        default:
            ACE_OS::printf("*** Tried to copy type %d to %d\n", id1, id2);
            ACE_OS::exit(1);
        }
}

static int _GetPixelSize(int pixel_type)
123

yarpimage.cpp - 源码说明

本页面展示了「一个语言识别引擎」中的 yarpimage.cpp 源码文件，采用 C++ 编程语言编写，共 1,110 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫下载站收录了大量与语言相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?