Simple_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 *               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

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