ImageModule.h

Go to the documentation of this file.

/*
  MFSM Image Module
  1.0-2.0

  Version 1.0 Copyright (C) 2010 Alexandre R.J. Francois

  Previous versions Copyright (C) 2002-2004 University of Southern California

  Author: Alexandre R.J. Francois - alexandrefrancois@yahoo.com
  www.alexandrefrancois.org

  Modular Flow Scheduling Middleware
  mfsm.sourceForge.net

  This code is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This code is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this code; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef IMAGE_MODULE_H
#define IMAGE_MODULE_H

#include "FsfCell.h"
#include "FsfTypeCellBase.h"

#include "FsfCharBuffer.h"


namespace image{



    const int IMAGE_DEPTH_1U=0; 
    const int IMAGE_DEPTH_8U=1; 
    const int IMAGE_DEPTH_8S=2; 
    const int IMAGE_DEPTH_16U=3; 
    const int IMAGE_DEPTH_16S=4; 
    const int IMAGE_DEPTH_32S=5; 
    const int IMAGE_DEPTH_32F=6; 
    
    const int IMAGE_DEPTH_BIT[10] = { 1,8,8,16,16,32,32,0,0,0 };
    const bool IMAGE_FLOATING[10] = { false,false,false,false,false,false,true,false,false,false };
    
    const unsigned char RGB_BLACK[3] = {0,0,0}; 
    const unsigned char RGB_GREY63[3] = {63,63,63}; 
    const unsigned char RGB_GREY127[3] = {127,127,127}; 
    const unsigned char RGB_WHITE[3] = {255,255,255}; 
    const unsigned char RGB_RED[3] = {255,0,0}; 
    const unsigned char RGB_GREEN[3] = {0,255,0}; 
    const unsigned char RGB_BLUE[3] = {0,0,255}; 
    const unsigned char RGB_CYAN[3] = {0,255,255}; 
    const unsigned char RGB_YELLOW[3] = {255,255,0}; 
    const unsigned char RGB_MAGENTA[3] ={255,0,255}; 

    
    void registerFactories();
        
    using namespace std;

    class CImage : public fsf::CCharBuffer {
    private:
        int m_nNbChannels; 
        int m_nDepth; 

        int m_nWidth; 
        int m_nHeight; 
        int m_nWidthStep; 

        int computeWidthStep(bool bNoAlign=false);

    public:


        CImage() : CCharBuffer(), m_nNbChannels(3), m_nDepth(IMAGE_DEPTH_8U),
            m_nWidth(0), m_nHeight(0), m_nWidthStep(0) {}
        CImage(fsf::CNode *pParent, fsf::Time tTime=0)
            : CCharBuffer(pParent,tTime), m_nNbChannels(3), m_nDepth(IMAGE_DEPTH_8U),
            m_nWidth(0), m_nHeight(0), m_nWidthStep(0) {}
        CImage(const string &strName, fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CCharBuffer(strName,pParent,tTime), m_nNbChannels(3), m_nDepth(IMAGE_DEPTH_8U),
            m_nWidth(0), m_nHeight(0), m_nWidthStep(0) {}
        CImage(int nWidth, int nHeight, int nNbChannels=3, int nDepth=IMAGE_DEPTH_8U,
               fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CCharBuffer(pParent,tTime), m_nNbChannels(nNbChannels), m_nDepth(nDepth),
            m_nWidth(nWidth), m_nHeight(nHeight), m_nWidthStep(0) {}
        CImage(const string &strName, int nWidth, int nHeight, int nNbChannels=3, int nDepth=IMAGE_DEPTH_8U,
               fsf::CNode *pParent=NULL, fsf::Time tTime=0)
            : CCharBuffer(strName,pParent,tTime), m_nNbChannels(nNbChannels), m_nDepth(nDepth),
            m_nWidth(nWidth), m_nHeight(nHeight), m_nWidthStep(0) {}
        CImage(const CImage&);
        // virtual ~CImage() {}
        virtual fsf::CNode *clone() const { return new CImage(*this); }



        CImage& operator=(const CImage&);

        void allocateImageBuffer(bool bNoAlign=false);

        void copyParameters(const CImage&);
        void copyImageData(const CImage&);

        void setWidth(int nWidth) { m_nWidth=nWidth; }
        void setHeight(int nHeight) { m_nHeight=nHeight; }
        void setNbChannels(int nNbChannels) { m_nNbChannels=nNbChannels; }
        void setPixelDepth(int nDepth) { m_nDepth=nDepth; }
        void setWidthStep(int nWidthStep) { m_nWidthStep=nWidthStep; }


        void setBytes(int val) { memset(data(),val,getSize()); }



        virtual void getTypeID(string &str) const { str.assign("IMAGE_IMAGE"); }

        // Image parameters access
        int getWidth() const { return m_nWidth; }
        int getHeight() const { return m_nHeight; }
        int getNbChannels() const { return m_nNbChannels; }
        int getPixelDepth() const { return m_nDepth; }
        int getWidthStep() const { return m_nWidthStep; }




        void drawPoint(int x, int y, const unsigned char *col);
        void drawLine(int xo, int yo, int xd, int yd, const unsigned char *col);
        void drawRectangle(int x, int y, int w, int h, const unsigned char *col);
        void fillRectangle(int x, int y, int w, int h, const unsigned char *col);
    };
    
    class CWidth : public fsf::CTypeCellBase {
    public:
        CWidth();
        virtual void getTypeID(std::string &str) const { str.assign("IMAGE_WIDTH"); }
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };

    class CHeight : public fsf::CTypeCellBase {
    public:
        CHeight();
        virtual void getTypeID(std::string &str) const { str.assign("IMAGE_HEIGHT"); }
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };

    class CNbChannels : public fsf::CTypeCellBase {
    public:
        CNbChannels();
        virtual void getTypeID(std::string &str) const { str.assign("IMAGE_NB_CHANNELS"); }
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };

    class CPixelDepth : public fsf::CTypeCellBase {
    public:
        CPixelDepth();
        virtual void getTypeID(std::string &str) const { str.assign("IMAGE_PIXEL_DEPTH"); }
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };

} // namespace image

#endif

---