00001 /* 00002 * This file contains class that represents working class inside 00003 * TSimpleUnit and returns 00004 * 00005 * IMAGES 00006 * 00007 * value. Returned class 00008 * is derived from 00009 * 00010 * TUnitRetType_images 00011 * 00012 * class. 00013 * 00014 * Author: 00015 * Tomas Mrkvicka 00016 * xmrkvi03@stud.fit.vutbr.cz 00017 * 00018 */ 00019 00020 00021 00022 #include <deque> 00023 #include <vector> 00024 using namespace std; 00025 00026 namespace NSSimpleUnit 00027 { 00028 class TUnitRetType_images_rgb_implemented; 00029 class TSimpleUnitProcessingInterface_images_rgb; 00030 }; 00031 00032 #ifndef _SIMPLEUNIT_SIMPLE_IMAGES_HH_ 00033 #define _SIMPLEUNIT_SIMPLE_IMAGES_HH_ 00034 00035 #include "pipeline/SimpleUnit.h" 00036 #include "simpleunit/Manager.h" 00037 #include "simpleunit/ImageResStruct.h" 00038 00039 namespace NSSimpleUnit 00040 { 00041 00042 //////////////////////////////////////////////////////////////////////////////// 00043 //////////////////////////////////////////////////////////////////////////////// 00044 //////////////////////////////////////////////////////////////////////////////// 00045 // TUnitRetType_images_rgb_implemented 00046 00047 /** Tato trida reprezentuje navratovy typ, reprezentujici obrazek ve formatu RGB (TImageRGB). 00048 * 00049 * Jedina pouzitelna metoda pro vypocetni jednotku je metoda InsertImage(), ktera 00050 * vlozi novy obrazek do vysledku 00051 * 00052 * Ostatni nevirtualni metody jsou nepodstatne. 00053 * 00054 * JE VZDY NUTNE REIMPLEMENTOVAT VSECHNY VIRTUALNI METODY Z BAZOVE TRIDY!!! 00055 */ 00056 class TUnitRetType_images_rgb_implemented : public TUnitRetType_images 00057 { 00058 friend TManager<TUnitRetType_images_rgb_implemented>; 00059 friend TSimpleUnitProcessingInterface_images_rgb; 00060 00061 //PUBLIC OVERRIDEN METHODS 00062 public: 00063 virtual EnumUnitType GetType(void) const; 00064 virtual void Release(void); 00065 00066 virtual DWORD GetImageCount(void); 00067 virtual const TImage* GetImage( DWORD index ); 00068 virtual const TRT_Rect* GetRectangle( DWORD index ); 00069 00070 //PUBLIC METHODS 00071 public: 00072 void InsertImage( TImageRGBResult * imageRes ); 00073 00074 //PRIVATE METHODS 00075 private: 00076 TUnitRetType_images_rgb_implemented(void); 00077 ~TUnitRetType_images_rgb_implemented(void); 00078 00079 void AddRefs(void); 00080 void PreReset(void); 00081 void Reset(void); 00082 void SetParent( TSimpleUnitProcessingInterface_images_rgb * parent); 00083 00084 //PRIVATE FAKE METHODS 00085 private: 00086 TUnitRetType_images_rgb_implemented( const TUnitRetType_images_rgb_implemented & orig); ///< falesny kopirovaci konstruktor 00087 void operator=( const TUnitRetType_images_rgb_implemented & orig); ///< falesny prirazovaci operator 00088 00089 00090 //PRIVATE COMPONENTS 00091 private: 00092 DWORD m_refs; ///< pocet referenci na objekt 00093 vector<TImageRGBResult*> m_values; ///< vlastni ulozene obrazky 00094 ///< kazdy udrzuje referenci na objekt 00095 00096 TCriticalSection m_cs; ///< synchronizace pro pocitani referenci 00097 00098 TSimpleUnitProcessingInterface_images_rgb* m_parent; ///< jednotka kde byl objekt vytvoren 00099 ///< a kam ma byt vracen 00100 }; 00101 //OK 2007-08-26 00:21:48 B04-315B\Tom 00102 00103 /** Vrati typ tridy. 00104 */ 00105 inline EnumUnitType TUnitRetType_images_rgb_implemented::GetType(void) const 00106 { 00107 return ENUM_UNITTYPE_IMAGES_RGB; 00108 } 00109 //OK 2007-09-06 20:16:55 B04-315B\Tom 00110 00111 /** Virtualni metoda vracejici pocet obrazku ulozenych v tomto vysledku. 00112 */ 00113 inline DWORD TUnitRetType_images_rgb_implemented::GetImageCount(void) 00114 { 00115 return (DWORD)m_values.size(); 00116 } 00117 //OK 2007-08-26 00:16:28 B04-315B\Tom 00118 00119 /** Vrati ukazatel na obrazek ulozeny na zadanem indexu. 00120 * 00121 * Pokud je index mimo rozsah pak vraci NULL. 00122 * 00123 * \param index [in] index pozadovaneho obrazku 00124 */ 00125 inline const TImage* TUnitRetType_images_rgb_implemented::GetImage( DWORD index ) 00126 { 00127 if ( index < (DWORD)m_values.size() ) 00128 { 00129 return m_values[index]->GetImage(); 00130 } 00131 else 00132 { 00133 return NULL; 00134 } 00135 } 00136 //OK 2007-08-26 00:16:32 B04-315B\Tom 00137 00138 /** Vrati ukazatel na informace o platnosti dat v obrazku ulozeny na zadanem indexu. 00139 * 00140 * Pokud je index mimo rozsah pak vraci NULL. 00141 * 00142 * \param index [in] index pozadovaneho obdelniku (obrazku) 00143 */ 00144 inline const TRT_Rect* TUnitRetType_images_rgb_implemented::GetRectangle( DWORD index ) 00145 { 00146 if ( index < (DWORD)m_values.size() ) 00147 { 00148 return m_values[index]->GetRectangle(); 00149 } 00150 else 00151 { 00152 return NULL; 00153 } 00154 } 00155 //OK 2007-08-26 00:16:35 B04-315B\Tom 00156 00157 /** Soukromy konstruktor. 00158 * 00159 * Vytvori objekt s jednou referenci a zadnym obrazkem uvnitr. 00160 * 00161 * METODA JE VOLANA Z MANAGERU TECHTO OBJEKTU VE VYPOCETNI JEDNOTCE DEFINOVANE NIZE. 00162 */ 00163 inline TUnitRetType_images_rgb_implemented::TUnitRetType_images_rgb_implemented(void) 00164 { 00165 m_refs = 1; 00166 } 00167 //OK 2007-08-26 00:16:53 B04-315B\Tom 00168 00169 /** Soukromy destruktor. 00170 * 00171 * METODA JE VOLANA Z MANAGERU TECHTO OBJEKTU VE VYPOCETNI JEDNOTCE DEFINOVANE NIZE. 00172 */ 00173 inline TUnitRetType_images_rgb_implemented::~TUnitRetType_images_rgb_implemented(void) 00174 { 00175 //odstranime reference na vsechny obrazky 00176 while( ! m_values.empty() ) 00177 { 00178 TImageRGBResult * img = m_values.back(); 00179 m_values.pop_back(); 00180 00181 img->Release(); 00182 } 00183 } 00184 //OK 2007-08-26 00:17:04 B04-315B\Tom 00185 00186 /** Prida dalsi obrazek do vysledku. 00187 * 00188 * Metoda zvysi pocet referenci na obrazek. 00189 * 00190 * Tato metoda by mela byt pouzita v ramci tridy TSimpleUnitProcessingInterface_images 00191 * v metode ProcessFrame, kdy objekt jeste neni zarazen do seznamu vysledku a tedy 00192 * nad nim pracuje pouze jedno vlakno. 00193 * 00194 * \param imageRes [in] pridany platny obrazek 00195 */ 00196 inline void TUnitRetType_images_rgb_implemented::InsertImage( TImageRGBResult * imageRes ) 00197 { 00198 imageRes->AddRefs(); 00199 00200 m_values.push_back( imageRes ); 00201 } 00202 //OK 2007-08-26 00:17:24 B04-315B\Tom 00203 00204 /** Pridani reference na objekt. 00205 */ 00206 inline void TUnitRetType_images_rgb_implemented::AddRefs(void) 00207 { 00208 m_cs.Enter(); 00209 m_refs++; 00210 m_cs.Leave(); 00211 } 00212 //OK 2007-08-26 00:17:26 B04-315B\Tom 00213 00214 /** Tato metoda je volana pred vracenim objektu zpatky do manazeru a zajistuje, ze vsechny 00215 * reference na obrazky budou uvolneny. 00216 * 00217 * Metoda by mela byt volana pouze z jednoho vlakna a tedy neni nutna synchronizace. 00218 */ 00219 inline void TUnitRetType_images_rgb_implemented::PreReset(void) 00220 { 00221 while( ! m_values.empty() ) 00222 { 00223 TImageRGBResult * img = m_values.back(); 00224 m_values.pop_back(); 00225 00226 img->Release(); 00227 } 00228 } 00229 //OK 2007-08-26 00:21:57 B04-315B\Tom 00230 00231 /** Tato metoda inicializuje zadany objekt do podoby po vytvoreni. 00232 * 00233 * Metoda by mela byt volana v manageru objektu pokud byl uz objekt 00234 * drive pouzit. To znamena, ze objekt je pri zavolani drzen pouze jednim vlaknem 00235 * a tedy neni potreba synchronizace. 00236 */ 00237 inline void TUnitRetType_images_rgb_implemented::Reset(void) 00238 { 00239 m_refs = 1; 00240 00241 //odstranime reference na vsechny obrazky - k tomu by nemelo nikdy dojit 00242 //nebot reference by mely byt vzdy odstraneny pred vracenim objektu do manageru!!! 00243 while( ! m_values.empty() ) 00244 { 00245 TImageRGBResult * img = m_values.back(); 00246 m_values.pop_back(); 00247 00248 img->Release(); 00249 } 00250 } 00251 //OK 2007-08-26 00:22:03 B04-315B\Tom 00252 00253 /** Nastaveni rodicovske jednotky pro tento objekt. 00254 * 00255 * Metoda je volana v manageru objektu zadane jednotky a tedy k ni pristupuje pouze 00256 * jedno vlakno. 00257 * 00258 * \param parent [in] rodicovska jednotka, ktera objekt vlastni a do ktere by mel byt vracen 00259 */ 00260 inline void 00261 TUnitRetType_images_rgb_implemented::SetParent( TSimpleUnitProcessingInterface_images_rgb * parent) 00262 { 00263 m_parent = parent; 00264 } 00265 //OK 2007-08-26 00:22:09 B04-315B\Tom 00266 00267 // TUnitRetType_images_rgb_implemented 00268 //////////////////////////////////////////////////////////////////////////////// 00269 //////////////////////////////////////////////////////////////////////////////// 00270 //////////////////////////////////////////////////////////////////////////////// 00271 // TSimpleUnitProcessingInterface_images_rgb 00272 00273 /** Tato jednotka vraci hodnoty typu IMAGES_RGB. 00274 * 00275 * ODVOZENA TRIDA MUSI REIMPLEMENTOVAT METODU PROCESSFRAME()!!! 00276 */ 00277 class TSimpleUnitProcessingInterface_images_rgb : public TSimpleUnitProcessingInterface 00278 { 00279 friend TUnitRetType_images_rgb_implemented; 00280 00281 //PUBLIC OVERRIDEN METHODS 00282 public: 00283 virtual void ProcessFrame( const TFrame * frame ) = 0; 00284 00285 virtual ~TSimpleUnitProcessingInterface_images_rgb(void); 00286 00287 /** Typ jednotky a vracenych vysledku. 00288 */ 00289 virtual EnumUnitType GetType(void) const { return ENUM_UNITTYPE_IMAGES_RGB; }; 00290 00291 virtual TUnitRetTypeInterface* GetResult( DWORD id ); 00292 00293 //PUBLIC METHODS 00294 public: 00295 TSimpleUnitProcessingInterface_images_rgb(void); 00296 00297 //PROTECTED METHODS 00298 protected: 00299 void AddResult( DWORD id, TUnitRetType_images_rgb_implemented * res ); 00300 00301 TUnitRetType_images_rgb_implemented* GetObject(void); 00302 void ReturnObject( TUnitRetType_images_rgb_implemented * object ); 00303 00304 void FreeImageResults(void); 00305 00306 //PROTECTED FAKE METHODS 00307 protected: 00308 TSimpleUnitProcessingInterface_images_rgb( const TSimpleUnitProcessingInterface_images_rgb & orig); ///< falesny kopirovaci konstruktor 00309 void operator=( const TSimpleUnitProcessingInterface_images_rgb & orig); ///< falesny prirazovaci operator 00310 00311 //PROTECTED COMPONENTS 00312 protected: 00313 static const DWORD sc_memory = 10; ///< maximalni pocet vysledku, ktere si trida pamatuje 00314 00315 //PRIVATE COMPONENTS 00316 private: 00317 deque<TUnitRetType_images_rgb_implemented*> m_results; ///< posledni vysledky 00318 deque<DWORD> m_resultsID; ///< identifikatory k vysledkum 00319 ///< identifikator urcuje ID snimku 00320 ///< ktereho se vysledek tyka 00321 00322 TManager<TUnitRetType_images_rgb_implemented> m_objects; ///< manager s objekty, neni je nutne 00323 ///< neustale alokovat 00324 00325 TCriticalSection m_cs_res; ///< synchronizace pristupu 00326 ///< k vysledkum 00327 TCriticalSection m_cs_manager; ///< synchronizace pristupu k manageru 00328 }; 00329 //OK 2007-08-26 00:22:50 B04-315B\Tom 00330 00331 /** Konstruktor. 00332 */ 00333 inline TSimpleUnitProcessingInterface_images_rgb::TSimpleUnitProcessingInterface_images_rgb(void) 00334 { 00335 //empty 00336 } 00337 //OK 2007-08-26 00:22:52 B04-315B\Tom 00338 00339 /** Virtualni destruktor. 00340 * 00341 * Smi byt volan v okamziku kdyz uz neexistuji zadne reference na vysledky teto jednotky!!! 00342 */ 00343 inline TSimpleUnitProcessingInterface_images_rgb::~TSimpleUnitProcessingInterface_images_rgb(void) 00344 { 00345 //odstranime vsechny vysledky 00346 while ( ! m_results.empty() ) 00347 { 00348 //muzeme pouzit operator delete, protoze na vysledek uz v aplikaci nejsou reference 00349 //metoda Release() by vysledek pouze vratila do manageru 00350 TUnitRetType_images_rgb_implemented * ptr = m_results.front(); 00351 m_results.pop_front(); 00352 delete ptr; 00353 } 00354 } 00355 //OK 2007-08-26 00:22:55 B04-315B\Tom 00356 00357 /** Ziskani vysledku ze snimku s pozadovanym ID. 00358 * 00359 * \param id [in] identifikator pozadovaneho snimku 00360 */ 00361 inline TUnitRetTypeInterface* TSimpleUnitProcessingInterface_images_rgb::GetResult( DWORD id ) 00362 { 00363 //TODO - mozna by se vyplatilo zahodit vsechny vysledky starsi nez ten posledni pozadovany 00364 00365 TUnitRetType_images_rgb_implemented * res = NULL; 00366 00367 m_cs_res.Enter(); 00368 //musime nalezt snimek s pozadovanym ID a vratit vysledek 00369 const size_t size = m_resultsID.size(); 00370 for ( size_t i = 0 ; i < size ; i++ ) 00371 { 00372 if ( id == m_resultsID[i] ) 00373 { 00374 //nasli jsme pozadovany vysledek 00375 res = m_results[i]; 00376 res->AddRefs(); 00377 break; 00378 } 00379 } 00380 m_cs_res.Leave(); 00381 00382 return res; 00383 }; 00384 //OK 2007-08-26 00:22:58 B04-315B\Tom 00385 00386 /** Pridani noveho vysledku do seznamu vysledku. 00387 * 00388 * Vysledek je pridan na konec seznamu. 00389 * 00390 * \param id [in] identifikace snimku pro nejz je vysledek urcen 00391 * \param res [in] platny vysledek - metoda nezvysuje pocet referenci na nej !!! 00392 */ 00393 inline void 00394 TSimpleUnitProcessingInterface_images_rgb::AddResult( DWORD id, TUnitRetType_images_rgb_implemented * res ) 00395 { 00396 m_cs_res.Enter(); 00397 m_results.push_back( res ); 00398 m_resultsID.push_back( id ); 00399 00400 //odstranime zastarale prvky 00401 if ( m_results.size() > sc_memory ) 00402 { 00403 TUnitRetType_images_rgb_implemented * ptr = m_results.front(); 00404 ptr->Release(); 00405 00406 m_results.pop_front(); 00407 m_resultsID.pop_front(); 00408 } 00409 m_cs_res.Leave(); 00410 } 00411 //OK 2007-08-26 00:23:17 B04-315B\Tom 00412 00413 /** Vrati novy objekt z manageru objektu. 00414 * 00415 * Tento objekt je dale ve vlastnictvi aplikace dokud jej nevrati zpet do manageru 00416 * pomoci metody ReturnObject(); 00417 * 00418 * Metoda je volana z metody ProcessFrame(). 00419 */ 00420 inline TUnitRetType_images_rgb_implemented * 00421 TSimpleUnitProcessingInterface_images_rgb::GetObject(void) 00422 { 00423 m_cs_manager.Enter(); 00424 TUnitRetType_images_rgb_implemented * ptr = m_objects.GetItem(); 00425 m_cs_manager.Leave(); 00426 00427 //re-inicializace objektu 00428 ptr->Reset(); 00429 00430 ptr->SetParent( this ); 00431 00432 return ptr; 00433 } 00434 //OK 2007-08-26 00:23:20 B04-315B\Tom 00435 00436 /** Vrati zpet do manageru objekt ziskany metodou GetObject(). 00437 * 00438 * Metoda by mela byt volana z metody Release() vraceneho objektu. 00439 * 00440 * Tato metoda zaroven uvolni vsechny obrazky drzene v objektu. 00441 * 00442 * \param object [in] vraceny objekt - metoda jej zaradi do manageru a pri pristim 00443 * pouziti jej manager znovu reinicializuje 00444 */ 00445 inline void 00446 TSimpleUnitProcessingInterface_images_rgb::ReturnObject( TUnitRetType_images_rgb_implemented * object ) 00447 { 00448 m_cs_manager.Enter(); 00449 //uvolnime reference v objektu 00450 object->PreReset(); 00451 //vratime objekt do manageru 00452 m_objects.PushItem( object ); 00453 m_cs_manager.Leave(); 00454 } 00455 //OK 2007-08-26 00:23:34 B04-315B\Tom 00456 00457 // TSimpleUnitProcessingInterface_images_rgb 00458 //////////////////////////////////////////////////////////////////////////////// 00459 //////////////////////////////////////////////////////////////////////////////// 00460 //////////////////////////////////////////////////////////////////////////////// 00461 00462 }; //END of namespace NSSimpleUnit 00463 using namespace NSSimpleUnit; 00464 00465 #endif 00466