VRS - The Virtual Rendering System

version 3.3

xpminterpreter.h

Go to the documentation of this file.

#include <vrs/image/memoryimage.h>
#include <vrs/color.h>

using VRS::SO;
using VRS::Image;
using VRS::MemoryImage;
using VRS::Color;

#if !defined(WIN32) && !defined(WIN64)
  #ifdef __APPLE__
    #define strcpy_s(dest,size,src) strlcpy(dest,src,size)
  #else
    #define strcpy_s(dest,size,src) strcpy(dest,src)
  #endif
  #define strncpy_s(dest,size,src,count) strncpy(dest,src,size)
  #define strtok_s strtok_r
  #define sscanf_s sscanf
#endif

class XPMInterpreter
{
public:
    XPMInterpreter(char *data[])
    {
        interpret(&(data[0]));
    }

    unsigned int width() const { return m_imgWidth; }
    unsigned int height() const { return m_imgHeight; }

    SO<Image> image() const { return m_image; }

    static SO<Image> image(char *data[])
    {
        XPMInterpreter tmp(data);
        return tmp.image();
    }

    static std::map<std::string, Color> initKnownColors()
    {
        std::map<std::string, Color> knownColors;
        knownColors["none"]    = Color(0.0, 0.0, 0.0, 0.0);
        knownColors["black"]   = Color(0.0, 0.0, 0.0);
        knownColors["white"]   = Color(1.0, 1.0, 1.0);

        knownColors["red"]     = Color(1.0, 0.0, 0.0);
        knownColors["green"]   = Color(0.0, 1.0, 0.0);
        knownColors["blue"]    = Color(0.0, 0.0, 1.0);

        knownColors["cyan"]    = Color(0.0, 1.0, 1.0);
        knownColors["magenta"] = Color(1.0, 0.0, 1.0);
        knownColors["yellow"]  = Color(1.0, 1.0, 0.0);

        return knownColors;
    }

private:
    unsigned int m_imgWidth;
    unsigned int m_imgHeight;
    unsigned int m_colorCount;
    unsigned int m_charsPerColor;
    std::map<std::string, Color> m_colorMap;
    SO<Image> m_image;
    std::vector<std::vector<Color> > m_colorData;

    static std::map<std::string, Color> s_knownColors;


    bool parseValueLine(const std::string &values, unsigned int &width, unsigned int &height, unsigned int &numColors, unsigned int &charsPerColor, unsigned int &hotspotX, unsigned int hotspotY)
    {
        char *context = NULL, *token = NULL;

        const size_t len = values.size() + 1;
        char *tokenString = new char[len];
        char seps[] = " \t";
        tokenString[len - 1] = 0;
        strcpy_s(&tokenString[0], len, values.c_str());

        unsigned int i = 0;
        unsigned int results[6] = { 0, 0, 0, 0, 0, 0 };

        token = strtok_s(tokenString, seps, &context);

        while (token && i < 6)
        {
            int count = sscanf_s(token, "%u", &(results[i]));
            if (count == 1)
            {
                ++i;
                token = strtok_s(NULL, seps, &context);
            }
            else
            {
                token = NULL;
            }
        }

        delete [] tokenString;
        if (i >= 4)
        {
            width = results[0];
            height = results[1];
            numColors = results[2];
            charsPerColor = results[3];
            hotspotX = results[4];
            hotspotY = results[5];

            return true;
        }

        return false;
    }


    bool getColorFromString(const std::string &color, Color &result)
    {
        std::string lcColor = color;
        for (size_t i = 0, iEnd = lcColor.size(); i < iEnd; ++i)
        {
            lcColor[i] = tolower(lcColor[i]);
        }

        std::map<std::string, Color>::iterator iter = s_knownColors.find(lcColor);
        if (iter != s_knownColors.end())
        {
            result = iter->second;
        }
        else if (lcColor[0] == '#') // rgb
        {
            unsigned int r = 0, g = 0, b = 0;
            if (sscanf(lcColor.c_str(), "#%2x%2x%2x", &r, &g, &b) != 3)
            {
                return false;
            }

            result = Color(r / 255.0, g / 255.0, b / 255.0);
        }
        else if (lcColor[0] == '%') // hsv
        {
            unsigned int h = 0, s = 0, v = 0;
            if (sscanf(lcColor.c_str(), "%%%2x%2x%2x", &h, &s, &v) != 3)
            {
                return false;
            }

            result = Color::hsv(360.0 * h / 256.0, s / 255.0, v / 255.0);
        }
        else
        {
            return false;
        }
        return true;
    }


    bool parseColorLine(const std::string &color)
    {
        bool returnValue = false;

        char *context = NULL, *token = NULL;


        const int len = (int)color.size() + 1;
        char *tokenString = new char[len];
        static char colorRep[5]; // allow 4 characters for color representation
        static const char seps[] = " \t";

        colorRep[m_charsPerColor] = 0;
        tokenString[len - 1] = 0;
        strcpy_s(&tokenString[0], len, color.c_str());

        strncpy_s(&colorRep[0], m_charsPerColor + 1, tokenString, m_charsPerColor);
        context = tokenString + m_charsPerColor;

        
        std::vector<std::string> colorElements;

        token = strtok_s(NULL, seps, &context);

        unsigned int cElement = -1;
        for (unsigned int i = 0; token; ++i)
        {
            colorElements.push_back(token);
            if (cElement == -1 && strcmp(token, "c") == 0)
            {
                cElement = i;
            }

            token = strtok_s(NULL, seps, &context);
        }

        Color result;
        if (cElement != -1 && getColorFromString(colorElements[cElement + 1], result))
        {
            m_colorMap[std::string(colorRep)] = result;
            returnValue = true;
        }

        delete [] tokenString;

        return returnValue;
    }


    bool parsePixelLine(const std::string &pixels, std::vector<Color> &pixelRow)
    {
        size_t expectedLength = m_imgWidth * m_charsPerColor;
        VRS_Warning(!(pixels.length() > expectedLength), "pixel data corrupt. truncating surplus values");
        VRS_Warning(!(pixels.length() < expectedLength), "pixel data corrupt. filling up missing values");

        static const Color none(0.0, 0.0, 0.0, 0.0);
        std::string pixel;
        std::map<std::string, Color>::iterator iter;
        for (size_t i = 0, iEnd = (pixels.length() / m_charsPerColor), offset = 0; i < iEnd; ++i, offset += m_charsPerColor)
        {
            pixel = pixels.substr(offset, m_charsPerColor);
            iter = m_colorMap.find(pixel);
            pixelRow[i] = (iter != m_colorMap.end() ? iter->second : none);
        }

        return true;
    }


    bool interpret(char *data[])
    {
        bool good = true, success = false;
        unsigned int i = 0, pixelRow = 0;
        std::string str;
        static unsigned int colorBlock, pixelBlock;
        while (good)
        {
            if (good = (data[i] != NULL))
            {
                str = data[i];

                if (i < 1)
                {
                    unsigned int dummy1 = 0, dummy2 = 0;
                    good = parseValueLine(str, m_imgWidth, m_imgHeight, m_colorCount, m_charsPerColor, dummy1, dummy2);
                    good &= m_charsPerColor < 5; // allow 4 characters for color representation
                    VRS_Warning(m_charsPerColor < 5, "only four characters for color represenation allowed");

                    std::vector<std::vector<Color> > newData(m_imgHeight, std::vector<Color>(m_imgWidth));
                    m_colorData.swap(newData);
                    colorBlock = 1 + m_colorCount;
                    pixelBlock = 1 + m_colorCount + m_imgHeight;
                }
                else if (i < colorBlock)
                {
                    // supposed to be a color line
                    good = parseColorLine(str);
                }
                else if (i < pixelBlock)
                {
                    // supposed to be a pixel line
                    good = parsePixelLine(str, m_colorData[pixelRow]);
                    success = good;
                    ++pixelRow;
                }
                else
                {
                    // ignore any other data
                    good = false;
                }
                ++i;
            }
        }

        if (success)
        {
            m_image = new MemoryImage(m_imgWidth, m_imgHeight, Image::RGBA);
            for (unsigned int r = 0; r < m_imgHeight; ++r)
            {
                for (unsigned int c = 0; c < m_imgWidth; ++c)
                {
                    m_image->setColor(c, m_imgHeight - r - 1, m_colorData[r][c]);
                }
            }
        }

        return good;
    }
};

std::map<std::string, Color> XPMInterpreter::s_knownColors = XPMInterpreter::initKnownColors();

---

Generated on Thu May 24 06:00:16 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact