Image.h

Go to the documentation of this file.
00001 /*
00002 *        This file contains classes that represents image returned from camera.
00003 *
00004 *       Author:
00005 *                       Tomas Mrkvicka
00006 *                       xmrkvi03@stud.fit.vutbr.cz
00007 *
00008 */
00009 
00010 #include <windows.h>
00011 #include <vector>
00012 using namespace std;
00013 
00014 //FORWARD DECLARATIONS
00015 namespace NSPipeline
00016 {
00017         class TImageARGB;
00018         class TImageRGB;
00019         class TImageGray;
00020 
00021         class TImageSetReal;
00022         class TImageSetManager;
00023         class TFrameReal;
00024 };
00025 
00026 namespace NSSimpleUnit
00027 {
00028         class TImageRGBResult;
00029 }
00030 
00031 #ifndef _PIPELINE_IMAGE_HH_
00032 #define _PIPELINE_IMAGE_HH_
00033 
00034 #include "pipeline/ImageAbstract.h"
00035 #include "pipeline/CriticalSection.h"
00036 
00037 namespace NSPipeline
00038 {
00039 ////////////////////////////////////////////////////////////////////////////////
00040 ////////////////////////////////////////////////////////////////////////////////
00041 ////////////////////////////////////////////////////////////////////////////////
00042 // TImageARGB
00043 
00044 /** Tato trida obsahuje obrazy typu ARGB kde kazdy pixel zabira 32 bitu - tedy 8 bitu na kanal.
00045 *       
00046 *       V teto tride jsou obrazova data ulozena spojite - PITCH je tedy roven poctu pixelu v radku
00047 *       nasobenych velikosti pixelu ( 4 bajtu ).
00048 *
00049 *       Kazdy pixel je reprezentovan jako DWORD 0xAARRGGBB.
00050 *       Tedy v pameti je postupne ulozen nejprve kanal BLUE, GREEN, RED, ALPHA.
00051 *
00052 *       Objekt teto tridy muze byt vytvoren pouze tridou TImageSetReal.
00053 */
00054 class TImageARGB : public TImage
00055 {
00056 friend class TImageSetReal;
00057 
00058 //PUBLIC OVERRIDEN METHODS
00059 public:
00060         virtual EnumImageType   GetImageType(void) const;
00061         virtual DWORD                   GetPixelSize(void) const;
00062 
00063         virtual DWORD                   GetWidth(void) const;
00064         virtual DWORD                   GetHeight(void) const;
00065         virtual DWORD                   GetPitch(void) const;
00066 
00067         virtual DWORD                   GetDataSize(void) const;
00068         virtual const void*             GetData(void) const;
00069 
00070 //PRIVATE OVERRIDEN METHODS
00071 private:
00072         virtual                                 ~TImageARGB(void);
00073 
00074 //PUBLIC METHODS
00075 public:
00076         void*                                   GetDataWrite(void);
00077         void                                    FromGray( const TImageGray * image );
00078         void                                    FromRGB( const TImageRGB * image );
00079 
00080         bool                                    IsRectInside( DWORD x, DWORD y, DWORD width, DWORD height ) const;
00081         void                                    CopyFrom( const TImageARGB * src, DWORD x, DWORD y, DWORD width, DWORD height);
00082 
00083 //PRIVATE METHODS
00084 private:
00085                                                         TImageARGB(DWORD width, DWORD height);
00086 
00087 //PRIVATE FAKE METHODS
00088 private:
00089                                                         TImageARGB( const TImageARGB & orig );  ///< falesny kopirovaci konstruktor
00090         void                                    operator=( const TImageARGB & orig );   ///< falesny operator prirazeni
00091 
00092 //PRIVATE COMPONENTS
00093 private:
00094         unsigned char*                  m_data;                 ///< data obrazu
00095 
00096         DWORD                                   m_width;                ///< sirka v pixelech
00097         DWORD                                   m_height;               ///< vyska v pixelech
00098 };
00099 //OK 2007-08-25 14:51:16 B04-315B\Tom
00100 
00101 /** Vrati typ tohoto obrazku.
00102 */
00103 inline EnumImageType TImageARGB::GetImageType(void) const
00104 {
00105         return ENUM_IMAGETYPE_ARGB; 
00106 }
00107 //OK 2007-08-25 14:51:23 B04-315B\Tom
00108 
00109 /** Vrati ukazatel na data.
00110 */
00111 inline void* TImageARGB::GetDataWrite(void)
00112 {
00113         return m_data;
00114 }
00115 //OK 2007-08-25 14:51:27 B04-315B\Tom
00116 
00117 /** Tato metoda urci jestli je zadany obdelnik uvnitr tohoto obrazu.
00118 *
00119 *       \param  x               [in] x-souradnice leveho horniho rohu obdelniku
00120 *       \param  y               [in] y-souradnice leveho horniho rohu obdelniku
00121 *       \param  width   [in] sirka obdelniku v pixelech
00122 *       \param  height  [in] vysla obdelniku v pixelech
00123 */
00124 inline bool TImageARGB::IsRectInside( DWORD x, DWORD y, DWORD width, DWORD height ) const
00125 {
00126         return 
00127                 ( x + width ) <= ( m_width ) &&
00128                 ( y + height ) <= ( m_height );         
00129 }
00130 //OK 2007-08-26 17:08:05 B04-315B\Tom
00131 
00132 // TImageARGB
00133 ////////////////////////////////////////////////////////////////////////////////
00134 ////////////////////////////////////////////////////////////////////////////////
00135 ////////////////////////////////////////////////////////////////////////////////
00136 // TImageRGB
00137 
00138 /** Tato trida obsahuje obrazy typu RGB kde kazdy pixel zabira 24 bitu - tedy 8 bitu na kanal.
00139 *       
00140 *       V teto tride jsou obrazova data ulozena spojite - PITCH je tedy roven poctu pixelu v radku
00141 *       nasobenych velikosti pixelu ( 4 bajty ).
00142 *
00143 *       Kazdy pixel je reprezentovan jako BYTE[3].
00144 *       Tedy v pameti je postupne ulozen nejprve kanal BLUE, GREEN, RED.
00145 *
00146 *       Objekt teto tridy muze byt vytvoren pouze tridou TImageSetReal.
00147 */
00148 class TImageRGB : public TImage
00149 {
00150 friend class TImageSetReal;
00151 friend class NSSimpleUnit::TImageRGBResult;
00152 
00153 //PUBLIC OVERRIDEN METHODS
00154 public:
00155         virtual EnumImageType   GetImageType(void) const;
00156         virtual DWORD                   GetPixelSize(void) const;
00157 
00158         virtual DWORD                   GetWidth(void) const;
00159         virtual DWORD                   GetHeight(void) const;
00160         virtual DWORD                   GetPitch(void) const;
00161 
00162         virtual DWORD                   GetDataSize(void) const;
00163         virtual const void*             GetData(void) const;
00164 
00165 //PRIVATE OVERRIDEN METHODS
00166 private:
00167         virtual                                 ~TImageRGB(void);
00168 
00169 //PUBLIC METHODS
00170 public:
00171         void*                                   GetDataWrite(void);
00172         void                                    FromGray( const TImageGray * image );
00173         void                                    FromARGB( const TImageARGB * image );
00174 
00175         bool                                    IsRectInside( DWORD x, DWORD y, DWORD width, DWORD height ) const;
00176         void                                    CopyFrom( const TImageRGB * src, DWORD x, DWORD y, DWORD width, DWORD height);
00177 
00178 //PRIVATE METHODS
00179 private:
00180                                                         TImageRGB(DWORD width, DWORD height);
00181 
00182 //PRIVATE FAKE METHODS
00183 private:
00184                                                         TImageRGB( const TImageRGB & orig );    ///< falesny kopirovaci konstruktor
00185         void                                    operator=( const TImageRGB & orig );    ///< falesny operator prirazeni
00186 
00187 //PRIVATE COMPONENTS
00188 private:
00189         unsigned char*                  m_data;                 ///< data obrazu
00190 
00191         DWORD                                   m_width;                ///< sirka v pixelech
00192         DWORD                                   m_height;               ///< vyska v pixelech
00193 };
00194 //OK 2007-09-04 12:09:37 B04-315B\Tom
00195 
00196 /** Vrati typ tohoto obrazku.
00197 */
00198 inline EnumImageType TImageRGB::GetImageType(void) const
00199 {
00200         return ENUM_IMAGETYPE_RGB; 
00201 }
00202 //OK 2007-09-04 12:09:42 B04-315B\Tom
00203 
00204 /** Vrati ukazatel na data.
00205 */
00206 inline void* TImageRGB::GetDataWrite(void)
00207 {
00208         return m_data;
00209 }
00210 //OK 2007-09-04 12:10:02 B04-315B\Tom
00211 
00212 /** Tato metoda urci jestli je zadany obdelnik uvnitr tohoto obrazu.
00213 *
00214 *       \param  x               [in] x-souradnice leveho horniho rohu obdelniku
00215 *       \param  y               [in] y-souradnice leveho horniho rohu obdelniku
00216 *       \param  width   [in] sirka obdelniku v pixelech
00217 *       \param  height  [in] vysla obdelniku v pixelech
00218 */
00219 inline bool TImageRGB::IsRectInside( DWORD x, DWORD y, DWORD width, DWORD height ) const
00220 {
00221         return 
00222                 ( x + width ) <= ( m_width ) &&
00223                 ( y + height ) <= ( m_height );         
00224 }
00225 //OK 2007-08-26 17:08:05 B04-315B\Tom
00226 
00227 // TImageRGB
00228 ////////////////////////////////////////////////////////////////////////////////
00229 ////////////////////////////////////////////////////////////////////////////////
00230 ////////////////////////////////////////////////////////////////////////////////
00231 // TImageGray
00232 
00233 /** Tato trida obsahuje monochromaticke obrazy s 8 bity na pixel.
00234 *       
00235 *       V teto tride jsou obrazova data ulozena spojite - PITCH je tedy roven poctu pixelu v radku
00236 *       nasobenych velikosti pixelu ( 1 bajt ).
00237 *
00238 *       Kazdy pixel je reprezentovan jako 8-bitova hodnota.
00239 *
00240 *       Objekt teto tridy muze byt vytvoren pouze tridou TImageSetReal.
00241 */
00242 class TImageGray : public TImage
00243 {
00244 friend class TImageSetReal;
00245 
00246 //PUBLIC OVERRIDEN METHODS
00247 public:
00248         virtual EnumImageType   GetImageType(void) const;
00249         virtual DWORD                   GetPixelSize(void) const;
00250 
00251         virtual DWORD                   GetWidth(void) const;
00252         virtual DWORD                   GetHeight(void) const;
00253         virtual DWORD                   GetPitch(void) const;
00254 
00255         virtual DWORD                   GetDataSize(void) const;
00256         virtual const void*             GetData(void) const;
00257 
00258 //PRIVATE OVERRIDEN METHODS
00259 private:
00260         virtual                                 ~TImageGray(void);
00261 
00262 //PUBLIC METHODS
00263 public:
00264         void*                                   GetDataWrite(void);
00265         void                                    FromARGB( const TImageARGB * image );
00266         void                                    FromRGB( const TImageRGB * image );
00267 
00268         bool                                    IsRectInside( DWORD x, DWORD y, DWORD width, DWORD height ) const;
00269         void                                    CopyFrom( const TImageGray * src, DWORD x, DWORD y, DWORD width, DWORD height);
00270 
00271 //PRIVATE METHODS
00272 private:
00273                                                         TImageGray(DWORD width, DWORD height);
00274 
00275 //PRIVATE FAKE METHODS
00276 private:
00277                                                         TImageGray( const TImageGray & orig );  ///< falesny kopirovaci konstruktor
00278         void                                    operator=( const TImageGray & orig );   ///< falesny operator prirazeni
00279 
00280 //PRIVATE COMPONENTS
00281 private:
00282         unsigned char*                  m_data;                 ///< data obrazu
00283 
00284         DWORD                                   m_width;                ///< sirka v pixelech
00285         DWORD                                   m_height;               ///< vyska v pixelech
00286 };
00287 //OK 2007-08-25 14:52:16 B04-315B\Tom
00288 
00289 /** Vrati typ tohoto obrazku.
00290 */
00291 inline EnumImageType TImageGray::GetImageType(void) const
00292 {
00293         return ENUM_IMAGETYPE_GRAY; 
00294 }
00295 //OK 2007-08-25 14:52:40 B04-315B\Tom
00296 
00297 /** Vrati ukazatel na data.
00298 */
00299 inline void* TImageGray::GetDataWrite(void)
00300 {
00301         return m_data;
00302 }
00303 //OK 2007-08-25 14:52:41 B04-315B\Tom
00304 
00305 /** Tato metoda urci jestli je zadany obdelnik uvnitr tohoto obrazu.
00306 *
00307 *       \param  x               [in] x-souradnice leveho horniho rohu obdelniku
00308 *       \param  y               [in] y-souradnice leveho horniho rohu obdelniku
00309 *       \param  width   [in] sirka obdelniku v pixelech
00310 *       \param  height  [in] vysla obdelniku v pixelech
00311 */
00312 inline bool TImageGray::IsRectInside( DWORD x, DWORD y, DWORD width, DWORD height ) const
00313 {
00314         return 
00315                 ( x + width ) <= ( m_width ) &&
00316                 ( y + height ) <= ( m_height );         
00317 }
00318 //OK 2007-08-26 17:08:05 B04-315B\Tom
00319 
00320 // TImageGray
00321 ////////////////////////////////////////////////////////////////////////////////
00322 ////////////////////////////////////////////////////////////////////////////////
00323 ////////////////////////////////////////////////////////////////////////////////
00324 
00325 /** Tato trida obsahuje ruzne verze jednoho obrazu ulozene jako objekty
00326 *       typu TImage a odvozenych trid.
00327 *
00328 *       Objekty tohoto typu nejsou konstruovany primo, ale pomoci manageru techto objektu
00329 *       typu TImageSetManager. Tento manager je zodpovedny za spravu techto objektu.
00330 */
00331 class TImageSetReal : public TImageSet
00332 {
00333 friend class TImageSetManager;
00334 friend class TFrameReal;
00335 
00336 //PUBLIC OVERRIDEN METHODS
00337 public:
00338         virtual const TImage*   GetARGB(void) const;
00339         virtual const TImage*   GetGray(void) const;
00340         virtual const TImage*   GetRGB(void) const;     
00341 
00342 //PRIVATE OVERRIDEN METHODS
00343 private:
00344         virtual                                 ~TImageSetReal(void);
00345 
00346 //PUBLIC METHODS
00347 public:
00348         TImageARGB*                             GetARGBWrite(void) const;
00349         TImageGray*                             GetGrayWrite(void) const;
00350         TImageRGB*                              GetRGBWrite(void) const;        
00351 
00352 //PRIVATE METHODS
00353 private:
00354                                                         TImageSetReal(TImageSetManager * manager, DWORD id, DWORD width, DWORD height);
00355 
00356         DWORD                                   GetID(void) const;
00357         TImageSetManager*               GetManager(void);
00358 
00359 //PRIVATE FAKE METHODS
00360 private:
00361                                                         TImageSetReal( const TImageSetReal & orig );///< falesny kopirovaci konstruktor
00362         void                                    operator=( const TImageSetReal & orig );        ///< falesny operator prirazeni
00363 
00364 //PRIVATE COMPONENTS
00365 private:
00366         TImageARGB*                             m_image_ARGB;           ///< obraz typu ARGB - 32 bitu na pixel
00367         TImageGray*                             m_image_gray;           ///< obraz sedotonovy - 8 bitu na pixel
00368         TImageRGB*                              m_image_RGB;            ///< obraz typu RGB - 24 bitu na pixel
00369 
00370         TImageSetManager*               m_manager;                      ///< manazer kde byl tento objekt vytvoren
00371         DWORD                                   m_managerID;            ///< jednoznacny identifikator v manageru
00372                                                                                                 ///< podle nej manager pozna objekt pri vraceni do manageru
00373 };
00374 //OK 2007-08-25 14:53:42 B04-315B\Tom
00375 
00376 /** Vrati obraz ARGB s moznosti upravit ho.
00377 */
00378 inline TImageARGB* TImageSetReal::GetARGBWrite(void) const
00379 {
00380         return m_image_ARGB;
00381 }
00382 //OK 2007-08-25 14:56:33 B04-315B\Tom
00383 
00384 /** Vrati monochromaticky obraz s moznosti upravit ho.
00385 */
00386 inline TImageGray* TImageSetReal::GetGrayWrite(void) const
00387 {
00388         return m_image_gray;
00389 }
00390 //OK 2007-08-25 14:56:35 B04-315B\Tom
00391 
00392 /** Vrati obraz RGB s moznosti upravit ho.
00393 */
00394 inline TImageRGB* TImageSetReal::GetRGBWrite(void) const
00395 {
00396         return m_image_RGB;
00397 }
00398 //OK 2007-09-04 14:13:57 B04-315B\Tom
00399 
00400 /** Vrati jednoznacny identifikator vraceny manazerem techto objektu.
00401 */
00402 inline DWORD TImageSetReal::GetID(void) const
00403 {
00404         return m_managerID;
00405 }
00406 //OK 2007-08-25 14:56:36 B04-315B\Tom
00407 
00408 /** Vrati manazer kde byl tento snimek vytvoren.
00409 */
00410 inline TImageSetManager* TImageSetReal::GetManager(void)
00411 {
00412         return m_manager;
00413 }
00414 //OK 2007-08-25 14:56:38 B04-315B\Tom
00415 
00416 // TImageSetReal
00417 ////////////////////////////////////////////////////////////////////////////////
00418 ////////////////////////////////////////////////////////////////////////////////
00419 ////////////////////////////////////////////////////////////////////////////////
00420 // TImageSetManager
00421 
00422 /** Tato trida slouzi jako manazer pro tvorbu objektu typu TImageSetReal.
00423 *
00424 *       Objekty jsou zde alokovany a dealokovany. Jinym zpusobem nelze tyto objekty vytvorit.
00425 *
00426 *       Trida obsahuje predalokovane objekty, takze aplikace neni zatezovana neustalou alokaci
00427 *       a dealokaci objektu.
00428 *
00429 *       Pri vytvareni je nutne zadat maximalni pocet predalokovanych objektu. Vetsi mnozstvi
00430 *       objektu manager nealokuje a pokud jiz neni zadny dalsi objekt k dispozici pak vraci
00431 *       manager NULL.
00432 */
00433 class TImageSetManager
00434 {
00435 //PUBLIC METHODS
00436 public:
00437                                                         TImageSetManager( DWORD width, DWORD height, DWORD initSize );
00438                                                         ~TImageSetManager(void);
00439 
00440         TImageSetReal*                  GetImageSet(void);
00441         void                                    ReleaseImageSet(const TImageSetReal * img);
00442 
00443 //PRIVATE FAKE METHODS
00444 private:
00445                                                         TImageSetManager( const TImageSetManager & orig );      ///< falesny kopirovaci konstruktor
00446         void                                    operator=( const TImageSetManager & orig );                     ///< falesny operator prirazeni
00447 
00448 //PRIVATE COMPONENTS
00449 private:
00450         TCriticalSection                m_critical;             ///< synchronizace pro GetImage() a ReleaseImage()
00451 
00452         DWORD                                   m_width;                ///< zakladni sirka obrazku v pixelech
00453         DWORD                                   m_height;               ///< zakladni vyska obrazku v pixelech  
00454 
00455         vector<TImageSetReal*>  m_imageSets;    ///< pole s s predalokovanymi objekty pro obrazova data
00456         vector<BOOL>                    m_imgFlags;             ///< pole stejne velikosti jako m_imageSets
00457                                                                                         ///< pro kazdy objekt obsahuje informaci zda je
00458                                                                                         ///< nebo neni aktualne pouzit
00459 };
00460 //OK 2007-08-25 14:57:44 B04-315B\Tom
00461 
00462 // TImageSetManager
00463 ////////////////////////////////////////////////////////////////////////////////
00464 ////////////////////////////////////////////////////////////////////////////////
00465 ////////////////////////////////////////////////////////////////////////////////
00466 // TFrameReal
00467 
00468 /** Tato trida reprezentuje snimek ziskany z kamery.
00469 *
00470 *       Snimek muze obsahovat vice obrazu (v ruznych formatech), ktere jsou dostupne pres metodu
00471 *       TFrame::GetImageSet().
00472 *
00473 *       Kazdy snimek ma prirazenu casovou znacku jeho vytvoreni, takze lze jednotlive snimky
00474 *       snadno identifikovat. Casova znacka obsahuje take identifikator, kterym lze rozpoznat
00475 *       poradi snimku ve kterem byly generovany.
00476 */
00477 class TFrameReal : public TFrame
00478 {
00479 //PUBLIC OVERRIDEN METHODS
00480 public:
00481         virtual const TImageSet*        GetImageSet(void) const;
00482 
00483         virtual const TTimeStamp &      GetTimestamp(void) const;
00484 
00485         virtual void                            AddRefs(void);
00486         virtual void                            Release(void);
00487         virtual DWORD                           GetRefs(void) const;
00488 
00489         virtual DWORD                           AddLock(void);
00490         virtual DWORD                           ReleaseLock(void);
00491         virtual DWORD                           GetLockCount(void) const;
00492 
00493 //PRIVATE OVERRIDEN METHODS
00494 private:
00495         virtual                                         ~TFrameReal(void);
00496 
00497 //PUBLIC STATIC METHODS
00498 public:                                                 
00499         static TFrameReal*                      Create( TImageSetReal * images );
00500 
00501 //PRIVATE FAKE METHODS
00502 private:
00503                                                                 TFrameReal( const TFrameReal & orig );  ///< falesny kopirovaci konstruktor
00504         void                                            operator=( const TFrameReal & orig );   ///< falesny operator prirazeni
00505 
00506 //PRIVATE METHODS
00507 private:
00508                                                                 TFrameReal( TImageSetReal * images );
00509 
00510 //PRIVATE COMPONENTS
00511 private:        
00512         DWORD                                           m_refs;                 ///< pocet referenci na snimek
00513         DWORD                                           m_locks;                ///< pocet zamku na snimku
00514         TCriticalSection                        m_critSection;
00515         TCriticalSection                        m_critSection2;
00516 
00517         TTimeStamp                                      m_time;                 ///< cas vytvoreni snimku
00518         TImageSetReal*                          m_image;                ///< data v tomto snimku
00519 };
00520 
00521 /** Vytvoreni snimku z pripravene mnoziny obrazu.
00522 *
00523 *       \param  images  [in] platna mnozina obrazu
00524 */
00525 inline TFrameReal* TFrameReal::Create( TImageSetReal * images )
00526 {
00527         return new TFrameReal( images );
00528 }
00529 //OK 2007-08-25 15:03:48 B04-315B\Tom
00530 
00531 // TFrameReal
00532 ////////////////////////////////////////////////////////////////////////////////
00533 ////////////////////////////////////////////////////////////////////////////////
00534 ////////////////////////////////////////////////////////////////////////////////
00535 
00536 }; //end of NSPipeline
00537 using namespace NSPipeline;
00538 
00539 #endif

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