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