---

ImageGrey.h

/*
OpenMorpho Library - Mathematical Morphology (Image processing) Library
Copyright (C) 2000  Laurent Najman

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

This program 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 General Public License for more details.

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

You can contact the author at
        mailto:laurent@najman.org
and download the latest version at
        http://www.laurentnajman.org
*/

// ImageGrey.h: interface for the CImageGrey class.
//

#if !defined(AFX_IMAGEGREY_H__3E9B40A5_8698_11D4_B181_E5930507415E__INCLUDED_)
#define AFX_IMAGEGREY_H__3E9B40A5_8698_11D4_B181_E5930507415E__INCLUDED_

#define OpenMorphoVER 1
#define OpenMorphoOptVER 0

#ifndef SWIG // Remove whatever is not needed by SWIG

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

#ifdef _WINDOWS
#include <windows.h>
#endif

#include "PixelTypes.h"
#include "Error.h"

#endif // SWIG

class CImageGrey : public CError
{
        LPPIXEL pBitmap;        
        int Width, Height;      
        int MaxIndex;           
        int LineLength;         
        int Top, Left;          

        static int nb_images; 

public:
        CImageGrey();
#ifndef SWIG

        CImageGrey(int sx, int sy);
        CImageGrey(CImageGrey *in);
#endif

        virtual ~CImageGrey();

        inline int NbImagesGet(void) const { return nb_images; };
        inline int HeightGet(void) const { return Height; };
        inline int WidthGet(void) const { return Width; };
        inline int TopGet(void) const { return Top; };
        inline int LeftGet(void) const { return Left; };
        inline int LineLengthGet(void) const { return LineLength; };
        inline LPPIXEL BitmapGet(void) const { return pBitmap; };
        inline int MaxIndexGet(void) const { return MaxIndex; };
        inline LPPIXEL BeginGet(void) const { return pBitmap + 1 + LineLength; };
        inline PIXEL PixelGet(int x, int y) const { return *(pBitmap +1 + LineLength + x + y * LineLength); };
        inline void PixelSet(int x, int y, PIXEL value) const {  *(pBitmap +1 + LineLength + x + y * LineLength) = value; };

        void FrameSet(PIXEL val);
                void Set(PIXEL val);

        inline LPPIXEL dir6c_0(LPPIXEL p, short parity) const {
                return ( p + 1 );
        };
        inline LPPIXEL dir6c_1(LPPIXEL p, short parity) const {
                return ( p - LineLength + parity );
        };
        inline LPPIXEL dir6c_2(LPPIXEL p, short parity) const {
                return ( p - LineLength + parity - 1 );
        };
        inline LPPIXEL dir6c_3(LPPIXEL p, short parity) const {
                return ( p - 1 );
        };
        inline LPPIXEL dir6c_4(LPPIXEL p, short parity) const {
                return ( p + LineLength + parity - 1 );
        };
        inline LPPIXEL dir6c_5(LPPIXEL p, short parity) const {
                return ( p + LineLength + parity );
        };

        inline LPPIXEL dir4c_0(LPPIXEL p) const {
                return ( p + 1 );
        };
        inline LPPIXEL dir4c_1(LPPIXEL p) const {
                return ( p - LineLength );
        };
        inline LPPIXEL dir4c_2(LPPIXEL p) const {
                return ( p - 1 );
        };
        inline LPPIXEL dir4c_3(LPPIXEL p) const {
                return ( p + LineLength );
        };

        inline LPPIXEL dir8c_0(LPPIXEL p) const {
                return ( p + 1 );
        };
        inline LPPIXEL dir8c_1(LPPIXEL p) const {
                return ( p - LineLength + 1);
        };
        inline LPPIXEL dir8c_2(LPPIXEL p) const {
                return ( p - LineLength );
        };
        inline LPPIXEL dir8c_3(LPPIXEL p) const {
                return ( p - LineLength - 1);
        };
        inline LPPIXEL dir8c_4(LPPIXEL p) const {
                return ( p - 1 );
        };
        inline LPPIXEL dir8c_5(LPPIXEL p) const {
                return ( p + LineLength - 1);
        };
        inline LPPIXEL dir8c_6(LPPIXEL p) const {
                return ( p + LineLength );
        };
        inline LPPIXEL dir8c_7(LPPIXEL p) const {
                return ( p + LineLength + 1 );
        };
                inline bool isInImage(LPPIXEL p) const {
                        int x, y, z;
                        z = (p-pBitmap -Left-Top*LineLength);
                        y = z / LineLength;
                        x = z % LineLength;
                        if ((x<0) || (x>Width) || (y<0) || (y>Height))
                                return false;
                
                        return true;
                };
};

#endif // !defined(AFX_IMAGEGREY_H__3E9B40A5_8698_11D4_B181_E5930507415E__INCLUDED_)

---