Simple_images.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 
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 

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