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