Simple_images_rectangles.h

Go to the documentation of this file.
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 

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