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