ImageAbstract.h

Go to the documentation of this file.
00001 /*
00002 *       This file contains abstract (and others) classes from which are derived classes
00003 *       representing image returned from camera.
00004 *
00005 *       Author:
00006 *                       Tomas Mrkvicka
00007 *                       xmrkvi03@stud.fit.vutbr.cz
00008 *
00009 */
00010 
00011 #include <windows.h>
00012 
00013 //FORWARD DECLARATIONS
00014 namespace NSPipeline
00015 {
00016         struct TPF_ARGB;
00017 
00018         class TImage;
00019         class TImageSet;
00020         class TFrame;
00021 };
00022 
00023 #ifndef _PIPELINE_IMAGEABSTRACT_HH_
00024 #define _PIPELINE_IMAGEABSTRACT_HH_
00025 
00026 #include "pipeline/TimeStamp.h"
00027 
00028 namespace NSPipeline
00029 {
00030 
00031 ////////////////////////////////////////////////////////////////////////////////
00032 ////////////////////////////////////////////////////////////////////////////////
00033 ////////////////////////////////////////////////////////////////////////////////
00034 
00035 /** Tento enumerator definuje typ obrazku - typ pixelu uvnitr obrazku.
00036 */
00037 enum EnumImageType
00038 {
00039         ENUM_IMAGETYPE_GRAY             =       0,                      ///< obraz ve stupnich sedi - 8 bitu na pixel
00040         
00041         ENUM_IMAGETYPE_ARGB             =       1,                      ///< barevny obraz, 32 bitu na pixel
00042                                                                                         ///< pro little-endian
00043                                                                                         ///< poradi bajtu v pameti B,G,R,A
00044                                                                                         ///< jako DWORD 0xAARRGGBB
00045 
00046         ENUM_IMAGETYPE_RGB              =       2,                      ///< barevny obraz, 24 bitu
00047                                                                                         ///< pro little-endian
00048                                                                                         ///< poradi bajtu v pameti B,G,R                                                                                        
00049 
00050         ENUM_IMAGETYPE_FORCED32 = 0x7fffffff,   ///< zarovnani na 32-bitu
00051 };
00052 
00053 ////////////////////////////////////////////////////////////////////////////////
00054 ////////////////////////////////////////////////////////////////////////////////
00055 ////////////////////////////////////////////////////////////////////////////////
00056 // TImage
00057 
00058 /** Tato abstraktni trida reprezentuje objekty pro obrazova data.
00059 *
00060 *       V aplikaci bude dostupna pouze tato deklarace.
00061 *
00062 *       Odvozene tridy musi reimplementovat vsechny virtualni metody.
00063 *
00064 *       Objekty tridy nelze kopirovat!
00065 */
00066 class TImage
00067 {
00068 //PUBLIC METHODS
00069 public:
00070         virtual EnumImageType   GetImageType(void) const = 0;   ///< typ tohoto obrazu (typ pixelu)
00071         virtual DWORD                   GetPixelSize(void) const = 0;   ///< velikost pixelu v bajtech
00072 
00073         virtual DWORD                   GetWidth(void) const = 0;               ///< sirka v pixelech
00074         virtual DWORD                   GetHeight(void) const = 0;              ///< vyska v pixelech
00075         virtual DWORD                   GetPitch(void) const = 0;               ///< delka radku v bajtech
00076 
00077         virtual DWORD                   GetDataSize(void) const = 0;    ///< velikost obrazovych dat v bajtech
00078         virtual const void*             GetData(void) const = 0;                ///< ukazatel na obrazova data
00079 
00080 //PROTECTED METHODS
00081 protected:
00082         virtual                                 ~TImage(void) = 0 {};                   ///< virtualni destruktor
00083 
00084                                                         TImage(void) {};                                ///< defaultni konstruktor
00085                                         
00086 //PROTECTED FAKE METHODS
00087 protected:
00088                                                         TImage( const TImage & orig );          ///< falesny kopirovaci konstruktor
00089         void                                    operator=( const TImage & orig );       ///< falesny operator prirazeni
00090 };
00091 //OK 2007-08-24 23:18:18 B04-315B\Tom
00092 
00093 // TImage
00094 ////////////////////////////////////////////////////////////////////////////////
00095 ////////////////////////////////////////////////////////////////////////////////
00096 ////////////////////////////////////////////////////////////////////////////////
00097 // TImageSet
00098 
00099 /** Tato trida reprezentuje rozhrani pro tridu, ktera obsahuje ruzne verze jednoho 
00100 *       obrazu ulozene jako objekty typu TImage a odvozenych trid.
00101 */
00102 class TImageSet
00103 {
00104 //PUBLIC METHODS
00105 public:
00106         virtual const TImage*   GetARGB(void) const = 0;        ///< obrazek ve formatu ARGB - 32 bitu na pixel
00107         virtual const TImage*   GetGray(void) const = 0;        ///< obrazek ve stupnich sedi - 8 bitu na pixel
00108         virtual const TImage*   GetRGB(void) const = 0;         ///< obrazek ve formatu RGB - 24 bitu na pixel
00109 
00110 //PROTECTED METHODS
00111 protected:
00112         virtual                                 ~TImageSet(void) = 0 {};                ///< virtualni destruktor
00113 
00114                                                         TImageSet(void) {};                             ///< defaultni konstruktor
00115 
00116 //PROTECTED FAKE METHODS
00117 protected:
00118                                                         TImageSet( const TImageSet & orig );    ///< falesny kopirovaci konstruktor
00119         void                                    operator=( const TImageSet & orig );    ///< falesny operator prirazeni
00120 };
00121 //OK 2007-08-24 23:49:22 B04-315B\Tom
00122 
00123 ////////////////////////////////////////////////////////////////////////////////
00124 ////////////////////////////////////////////////////////////////////////////////
00125 ////////////////////////////////////////////////////////////////////////////////
00126 // TFrame
00127 
00128 /** Tato trida reprezentuje snimek ziskany z kamery.
00129 *
00130 *       Snimek muze obsahovat vice obrazu (v ruznych formatech), ktere jsou dostupne pres metodu
00131 *       TFrame::GetImageSet().
00132 *
00133 *       Na kazdy snimek je aplikovano pocitani referenci a zamku.
00134 *       Pokud dosahne pocet referenci 0 pak je snimek odstranen a nesmi byt jiz dale pouzit.
00135 *       
00136 *       Zamek se pouziva ve vypocetni jednotce v pripade, ze jednotka provadi vypocet, jehoz
00137 *       vypocet je nutny pri zobrazeni snimku. V takovem pripade ziska jednotka snimek
00138 *       se zamkem (z dispatcheru). Snimek s nenulovym poctem snimku nesmi opustit frontu snimku
00139 *       a tedy je zajisteno, ze se zobrazi az v okamziku, kdy bude kompletne zpracovan vsemi 
00140 *       jednotkami, ktere nad nim udrzuji zamek.
00141 *       
00142 */
00143 class TFrame
00144 {
00145 //PUBLIC METHODS
00146 public:
00147         virtual const TImageSet*        GetImageSet(void) const = 0;    ///< objekt s obrazy
00148 
00149         virtual const TTimeStamp &      GetTimestamp(void) const = 0;   ///< casove razitko
00150 
00151         virtual void                            AddRefs(void) = 0;                              ///< zvyseni poctu referenci
00152         virtual void                            Release(void) = 0;                              ///< snizeni poctu referenci
00153         virtual DWORD                           GetRefs(void) const = 0 ;               ///< pocet referenci na snimek
00154 
00155         virtual DWORD                           AddLock(void) = 0;                              ///< pridani zamku
00156         virtual DWORD                           ReleaseLock(void) = 0;                  ///< uvolneni zamku
00157         virtual DWORD                           GetLockCount(void) const = 0;   ///< pocet zamku na snimku
00158 
00159 //PROTECTED METHODS
00160 protected:
00161         virtual                                         ~TFrame(void) = 0 {};                   ///< virtualni destruktor
00162                                                                 TFrame(void) {};                                ///< defaultni konstruktor
00163 
00164 //PROTECTED FAKE METHODS
00165 protected:
00166                                                         TFrame( const TFrame & orig );          ///< falesny kopirovaci konstruktor
00167         void                                    operator=( const TFrame & orig );       ///< falesny operator prirazeni
00168 };
00169 //OK 2007-08-24 23:49:30 B04-315B\Tom
00170 
00171 // TFrame
00172 ////////////////////////////////////////////////////////////////////////////////
00173 ////////////////////////////////////////////////////////////////////////////////
00174 ////////////////////////////////////////////////////////////////////////////////
00175 
00176 /** Rozhrani dispatcheru dostupne vypocetnim jednotkam.
00177 *
00178 *       Dispatcher obsahuje informace o velikosti poskytovanych snimku.
00179 *       Tato informace je uzitecna pri inicializaci vypocetnich jednotek, ktere takovou
00180 *       informaci mohou vyuzit, protoze se predpoklada, ze za behu aplikace se tato velikost nebude menit.
00181 */
00182 class TDispatcherInterface
00183 {
00184 //PUBLIC METHODS
00185 public:
00186         virtual DWORD                   GetWidth(void) = 0;                     ///< informace o sirce vraceneho snimku
00187         virtual DWORD                   GetHeight(void) = 0;            ///< informace o vysce vraceneho snimku
00188 
00189         virtual TFrame *                GetFrame(void) = 0;                     ///< vrati snimek s pridanou referenci
00190         virtual TFrame *                GetLockedFrame(void) = 0;       ///< vrati snimek s referenci a zamkem
00191 
00192 //PROTECTED METHODS
00193 protected:
00194         virtual                                 ~TDispatcherInterface(void) = 0 {};             ///< virtualni destruktor
00195                                                         TDispatcherInterface(void) {};                  ///< defaultni konstruktor
00196 
00197 //PROTECTED FAKE METHODS
00198 protected:
00199                                                         TDispatcherInterface( const TDispatcherInterface & orig );      ///< falesny kopirovaci konstruktor
00200         void                                    operator=( const TDispatcherInterface & orig );                         ///< falesny operator prirazeni
00201 };
00202 //OK 2007-08-24 23:50:47 B04-315B\Tom
00203 
00204 // TFrame
00205 ////////////////////////////////////////////////////////////////////////////////
00206 ////////////////////////////////////////////////////////////////////////////////
00207 ////////////////////////////////////////////////////////////////////////////////
00208 
00209 }; //END of NSPipeline
00210 
00211 #endif

Generated on Sat Nov 17 16:23:26 2007 for Image Processing Pipeline by  doxygen 1.4.6-NO