UnitTypes.h

Go to the documentation of this file.
00001 /*
00002 *       This file contains data types for working units.
00003 *
00004 *       Author:
00005 *                       Tomas Mrkvicka
00006 *                       xmrkvi03@stud.fit.vutbr.cz
00007 *
00008 */
00009 
00010 #include <windows.h>
00011 
00012 namespace NSPipeline
00013 {
00014         class TImage;
00015 };
00016 
00017 #ifndef _PIPELINE_UNITTYPES_HH_
00018 #define _PIPELINE_UNITTYPES_HH_
00019 
00020 namespace NSPipeline
00021 {
00022 ////////////////////////////////////////////////////////////////////////////////
00023 ////////////////////////////////////////////////////////////////////////////////
00024 ////////////////////////////////////////////////////////////////////////////////
00025 
00026 /** Tento enumerator definuje typ vypocetni jednotky.
00027 *
00028 *       Typ jednotky urcuje, jake vysledky jednotka vraci.
00029 */
00030 enum EnumUnitType
00031 {
00032         ENUM_UNITTYPE_NODATA = 0,                               ///< tento typ nevraci zadna data
00033                                                                                         ///< jednotka tohoto typu vraci vzdy NULL
00034 
00035         ENUM_UNITTYPE_INTEGER = 1,                              ///< navratova hodnota je integer
00036                                                                                         ///< vysledky jsou typu TUnitRetType_integeres
00037 
00038         ENUM_UNITTYPE_RECTANGLES = 2,                   ///< typ vraci pole obdelniku typu TRT_Rect
00039                                                                                         ///< vysledky jsou typu TUnitRetType_rectangles
00040 
00041         ENUM_UNITTYPE_IMAGES_RGB = 3,                   ///< typ vraci pole obrazku typu RGB ( TImageRGB)
00042                                                                                         ///< s obdelniky urcujicimi platnou cast obrazku
00043                                                                                         ///< vysledky jsou typu TUnitRetType_images     
00044 
00045         ENUM_UNITTYPE_IMAGES_RGB_RECTANGLES = 4,///< typ vraci pole obrazku typu RGB (TImageRGB) a zaroven 
00046                                                                                         ///< nezavisle pole obdelniku TRT_Rect
00047                                                                                         ///< vysledky jsou typu TUnitRetType_images_rectangles
00048 
00049         //ZDE MOHOU BYT PRIDAVANY DALSI TYPY
00050 
00051         ENUM_UNITTYPE_FORCED32 = 0x7fffffff,    ///< zarovnani na 32-bitu
00052 };
00053 
00054 ////////////////////////////////////////////////////////////////////////////////
00055 ////////////////////////////////////////////////////////////////////////////////
00056 ////////////////////////////////////////////////////////////////////////////////
00057 // datove typy pro vraceni vysledku z jednotek
00058 #pragma pack( 1 )
00059 
00060 /** Datovy typ reprezentujici obdelnik.
00061 *
00062 *       X-souradnice roste zleva doprava.
00063 *       Y-souradnice roste odshora dolu.
00064 */
00065 struct TRT_Rect
00066 {
00067 //PUBLIC METHODS
00068 public:
00069                         TRT_Rect(void);
00070                         TRT_Rect( int l, int t, int r, int b);
00071 
00072         int             GetWidth(void) const;
00073         int             GetHeight(void) const;
00074 
00075 //PUBLIC COMPONENTS
00076 public:
00077         int             left;
00078         int             top;
00079         int             right;
00080         int             bottom;
00081 };
00082 //OK 2007-08-25 15:48:29 B04-315B\Tom
00083 
00084 /** Defaultni konstruktor.
00085 *
00086 *       Nastavi vsechny polozky na 0.
00087 */
00088 inline TRT_Rect::TRT_Rect(void)
00089 {
00090         left = 
00091         right = 
00092         top = 
00093         bottom = 0;
00094 }
00095 //OK 2007-08-25 18:12:46 B04-315B\Tom
00096 
00097 /** Konstruktor.
00098 *
00099 *       \param  l               [in] x-souradnice leveho horniho rohu
00100 *       \param  t               [in] y-souradnice leveho horniho rohu
00101 *       \param  r               [in] x-souradnice leveho horniho rohu
00102 *       \param  b               [in] y-souradnice leveho horniho rohu
00103 */
00104 inline TRT_Rect::TRT_Rect( int l, int t, int r, int b)
00105 {
00106         left    =       l;
00107         top             =       t;
00108         right   =       r;
00109         bottom  =       b;
00110 }
00111 //OK 2007-08-25 15:48:31 B04-315B\Tom
00112 
00113 /** Vrati sirku obdelniku.
00114 */
00115 inline int TRT_Rect::GetWidth(void) const
00116 {
00117         return right - left + 1;
00118 }
00119 //OK 2007-08-25 15:48:33 B04-315B\Tom
00120 //OK 2007-09-08 12:45:38 B04-315B\Tom
00121 
00122 /** Vrati vysku obdelniku.
00123 */
00124 inline int TRT_Rect::GetHeight(void) const
00125 {
00126         return bottom - top + 1;
00127 }
00128 //OK 2007-08-25 15:48:35 B04-315B\Tom
00129 //OK 2007-09-08 12:45:40 B04-315B\Tom
00130 
00131 #pragma pack()
00132 ////////////////////////////////////////////////////////////////////////////////
00133 ////////////////////////////////////////////////////////////////////////////////
00134 ////////////////////////////////////////////////////////////////////////////////
00135 // abstraktni tridy pro navrat hodnot z vypocetnich jednotek
00136 
00137 /** Rozhrani pro vsechny tridy, pomoci nichz se predavaji vysledky.
00138 *
00139 *       Jednotlive navratove datove typy jednotek se odvozuji z tohoto rozhrani.
00140 *
00141 *       Vzdy musi byt zachovana pouze jednoducha dedicnost - kvuli snadnemu pretypovani bez RTTI
00142 *       z potomka na predka!!!
00143 */
00144 class TUnitRetTypeInterface
00145 {
00146 //PUBLIC METHODS
00147 public:
00148         virtual EnumUnitType    GetType(void) const = 0;                ///< vrati typ dat,
00149                                                                                                                         ///< mel by byt shodny s typem jednotky
00150         virtual void                    Release(void) = 0;                              ///< uvolneni vysledku zpet jednotce
00151 
00152 //PROTECTED METHODS
00153 protected:
00154                                                         TUnitRetTypeInterface(void){};  ///< konstruktor
00155                                                         ~TUnitRetTypeInterface(void){}; ///< destruktor je pristupny pouze 
00156                                                                                                                         ///< pro odvozene tridy
00157 
00158 //PROTECTED FAKE METHODS
00159 protected:
00160                                                         TUnitRetTypeInterface( const TUnitRetTypeInterface & orig );///< falesny kopirovaci konstruktor
00161         void                                    operator=( const TUnitRetTypeInterface & orig );                        ///< falesny prirazovaci operator
00162 
00163 };
00164 //OK 2007-08-25 15:49:54 B04-315B\Tom
00165 
00166 ////////////////////////////////////////////////////////////////////////////////
00167 ////////////////////////////////////////////////////////////////////////////////
00168 ////////////////////////////////////////////////////////////////////////////////
00169 
00170 /** Tato trida reprezentuje navratovy typ vypocetni jednotky reprezentujici cele cislo.
00171 *
00172 *       Odvozena trida musi reimplementovat metody Release() a GetValue().
00173 */
00174 class TUnitRetType_integer : public TUnitRetTypeInterface
00175 {
00176 //PUBLIC OVERRIDEN METHODS
00177 public:
00178         virtual EnumUnitType    GetType(void) const { return ENUM_UNITTYPE_INTEGER; };
00179         virtual void                    Release(void) = 0;
00180 
00181 //PUBLIC METHODS
00182 public:
00183         virtual int                             GetValue(void) = 0;
00184 
00185 //PROTECTED METHODS
00186 protected:
00187                                                         TUnitRetType_integer(void){};   ///< konstruktor
00188                                                         ~TUnitRetType_integer(void){};  ///< destruktor je pristupny pouze 
00189                                                                                                                         ///< pro odvozene tridy
00190 //PROTECTED FAKE METHODS
00191 protected:
00192                                                         TUnitRetType_integer( const TUnitRetType_integer & orig );      ///< falesny kopirovaci konstruktor
00193         void                                    operator=( const TUnitRetType_integer & orig );                         ///< falesny prirazovaci operator
00194 };
00195 //OK 2007-08-25 18:08:23 B04-315B\Tom
00196 
00197 ////////////////////////////////////////////////////////////////////////////////
00198 ////////////////////////////////////////////////////////////////////////////////
00199 ////////////////////////////////////////////////////////////////////////////////
00200 
00201 /** Tato trida reprezentuje navratovy typ vypocetni jednotky reprezentujici pole obdelniku.
00202 *
00203 *       Odvozena trida musi reimplementovat metody Release(), GetRectangleCount()
00204 *       a GetRectangle().
00205 */
00206 class TUnitRetType_rectangles : public TUnitRetTypeInterface
00207 {
00208 //PUBLIC OVERRIDEN METHODS
00209 public:
00210         virtual EnumUnitType    GetType(void) const { return ENUM_UNITTYPE_RECTANGLES; };
00211         virtual void                    Release(void) = 0;
00212 
00213 //PUBLIC METHODS
00214 public:
00215         virtual DWORD                   GetRectangleCount(void) = 0;            ///< pocet obdelniku
00216         virtual const TRT_Rect* GetRectangle( DWORD index ) = 0;        ///< vrati obdelnik na zadanem indexu
00217                                                                                                                                 ///< vraci NULL pri chybnem indexu
00218 
00219 //PROTECTED METHODS
00220 protected:
00221                                                         TUnitRetType_rectangles(void){};        ///< konstruktor
00222                                                         ~TUnitRetType_rectangles(void){};       ///< destruktor je pristupny pouze 
00223                                                                                                                                 ///< pro odvozene tridy
00224 
00225 //PROTECTED FAKE METHODS
00226 protected:
00227                                                         TUnitRetType_rectangles( const TUnitRetType_rectangles & orig );///< falesny kopirovaci konstruktor
00228         void                                    operator=( const TUnitRetType_rectangles & orig );                              ///< falesny prirazovaci operator
00229 };
00230 //OK 2007-08-25 18:08:20 B04-315B\Tom
00231 
00232 ////////////////////////////////////////////////////////////////////////////////
00233 ////////////////////////////////////////////////////////////////////////////////
00234 ////////////////////////////////////////////////////////////////////////////////
00235 
00236 /** Tato trida reprezentuje navratovy typ vypocetni jednotky reprezentujici pole obrazku.
00237 *       Ke kazdemu obrazku lze ziskat obdelnik, ktery urcuje platny vyrez v obrazku
00238 *
00239 *       Odvozena trida musi reimplementovat metody 
00240 \verbatim
00241         GetType()
00242         Release()
00243         GetImageCount()
00244         GetImage()
00245         GetRectangle()  
00246 \endverbatim
00247 */
00248 class TUnitRetType_images : public TUnitRetTypeInterface
00249 {
00250 //PUBLIC OVERRIDEN METHODS
00251 public:
00252         virtual EnumUnitType    GetType(void) const = 0;
00253         virtual void                    Release(void) = 0;
00254 
00255 //PUBLIC METHODS
00256 public:
00257         virtual DWORD                   GetImageCount(void) = 0;                        ///< pocet obrazku (a obdelniku)
00258         virtual const TImage*   GetImage( DWORD index ) = 0;            ///< vrati obrazek na zadanem indexu
00259                                                                                                                                 ///< vraci NULL pri chybnem indexu
00260         virtual const TRT_Rect* GetRectangle( DWORD index ) = 0;        ///< vrati obdelnik na zadanem indexu
00261                                                                                                                                 ///< vraci NULL pri chybnem indexu
00262 
00263 //PROTECTED METHODS
00264 protected:
00265                                                         TUnitRetType_images(void){};            ///< konstruktor
00266                                                         ~TUnitRetType_images(void){};           ///< destruktor je pristupny pouze 
00267                                                                                                                                 ///< pro odvozene tridy
00268 
00269 //PROTECTED FAKE METHODS
00270 protected:
00271                                                         TUnitRetType_images( const TUnitRetType_images & orig );///< falesny kopirovaci konstruktor
00272         void                                    operator=( const TUnitRetType_images & orig );                  ///< falesny prirazovaci operator
00273 
00274 };
00275 //OK 2007-08-25 18:08:18 B04-315B\Tom
00276 
00277 ////////////////////////////////////////////////////////////////////////////////
00278 ////////////////////////////////////////////////////////////////////////////////
00279 ////////////////////////////////////////////////////////////////////////////////
00280 
00281 /** Tato trida reprezentuje navratovy typ vypocetni jednotky reprezentujici pole 
00282 *       obrazku a obdelniku.
00283 *
00284 *       Obrazky a obdelniky jsou nezavisle - muze jich tedy byt ruzny pocet.
00285 *
00286 *       Odvozena trida musi reimplementovat metody 
00287 \verbatim
00288         GetType()
00289         Release()
00290         GetImageCount()
00291         GetImage()
00292         GetRectangleCount()
00293         GetRectangle()  
00294 \endverbatim
00295 */
00296 class TUnitRetType_images_rectangles : public TUnitRetTypeInterface
00297 {
00298 //PUBLIC OVERRIDEN METHODS
00299 public:
00300         virtual EnumUnitType    GetType(void) const = 0;
00301         virtual void                    Release(void) = 0;
00302 
00303 //PUBLIC METHODS
00304 public:
00305         virtual DWORD                   GetImageCount(void) = 0;                        ///< pocet obrazku
00306         virtual const TImage*   GetImage( DWORD index ) = 0;            ///< vrati obrazek na zadanem indexu
00307                                                                                                                                 ///< vraci NULL pri chybnem indexu
00308 
00309         virtual DWORD                   GetRectangleCount(void) = 0;            ///< pocet obdelniku
00310         virtual TRT_Rect                GetRectangle( DWORD index ) = 0;        ///< vrati obdelnik na zadanem indexu
00311 
00312 //PROTECTED METHODS
00313 protected:
00314                                                         TUnitRetType_images_rectangles(void){};         ///< konstruktor
00315                                                         ~TUnitRetType_images_rectangles(void){};        ///< destruktor je pristupny pouze 
00316                                                                                                                                                 ///< pro odvozene tridy
00317 
00318 //PROTECTED FAKE METHODS
00319 protected:
00320                                                         TUnitRetType_images_rectangles( const TUnitRetType_images_rectangles & orig );  ///< falesny kopirovaci konstruktor
00321         void                                    operator=( const TUnitRetType_images_rectangles & orig );                                               ///< falesny prirazovaci operator
00322 
00323 };
00324 //OK 2007-11-13 21:44:17 B04-315A\Tom
00325 
00326 ////////////////////////////////////////////////////////////////////////////////
00327 ////////////////////////////////////////////////////////////////////////////////
00328 ////////////////////////////////////////////////////////////////////////////////
00329 
00330 }; //END of namespace NSPipeline
00331 using namespace NSPipeline;
00332 
00333 #endif

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