grayf.hpp
上传用户:sun1608
上传日期:2007-02-02
资源大小:6116k
文件大小:10k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

Visual C++

  1. /*************************************************************************
  2. This software module was originally developed by 
  3. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  4. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  5. Bruce Lin (blin@microsoft.com), Microsoft Corporation
  6. Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
  7. (date: March, 1996)
  8. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  9. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  10. as specified by the MPEG-4 Video. 
  11. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  12. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  13. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  14. The original developer of this software module and his/her company, 
  15. the subsequent editors and their companies, 
  16. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  17. Copyright is not released for non MPEG-4 Video conforming products. 
  18. Microsoft retains full right to use the code for his/her own purpose, 
  19. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  20. This copyright notice must be included in all copies or derivative works. 
  21. Copyright (c) 1996, 1997.
  22. Module Name:
  23. grayf.hpp
  24. Abstract:
  25. Float image class for gray (one-plane) pictures 
  26. Revision History:
  27. *************************************************************************/
  28. #ifndef __GRAYF_HPP_ 
  29. #define __GRAYF_HPP_
  30. typedef Float PixelF;
  31. #define MAX_NUM_CONTOUR 200
  32. Class CVideoObjectPlane;
  33. Class CFloatImage
  34. {
  35. public:
  36. // Constructors
  37. ~CFloatImage ();
  38. CFloatImage (const CFloatImage& fi, const CRct& r = CRct ()); // crop from a floatimage
  39. CFloatImage (const CIntImage& fi, const CRct& r = CRct ()); // crop from an int image
  40. CFloatImage (const CVideoObjectPlane& vop, RGBA comp, const CRct& r = CRct ());
  41. CFloatImage (const CRct& r = CRct (), PixelF px = 0.); // floatimage with same pixel value everywhere
  42. CFloatImage (const CPolygonI& plg, const CRct& rct); // fill in the polygon (interior boundary)
  43. CFloatImage (
  44. const Char* pchFileName, // MPEG4 file format
  45. UInt ifr, // frame number
  46. const CRct& rct, // final rect 
  47. UInt nszHeader = 0 // number of header to be skipped
  48. );
  49. CFloatImage (const Char* vdlFileName); // read from a VM file.
  50. // Attributes
  51. Bool valid () const {return this != 0;}
  52. const CRct& where () const {return m_rc;}
  53. CRct boundingBox (const PixelF pxlfOutsideColor = (PixelF) transpValue) const;
  54. PixelF pixel (CoordI x, CoordI y) const {return m_ppxlf [m_rc.offset (x, y)];}
  55. PixelF pixel (const CSite& st) const {return pixel (st.x, st.y);}
  56. const PixelF* pixels () const {return (this == NULL) ? NULL : m_ppxlf;} // return pointer
  57. const PixelF* pixels (CoordI x, CoordI y) const {return m_ppxlf + m_rc.offset (x, y);}
  58. const PixelF* pixels (const CSite& st) const {return pixels (st.x, st.y);}
  59. // Resultants
  60. own CFloatImage* decimate (UInt rateX, UInt rateY) const; // decimate the vframe by rateX and rateY.
  61. own CFloatImage* decimateBinaryShape (UInt rateX, UInt rateY) const; // decimate by rateX and rateY in a conservative way
  62. own CFloatImage* zoomup (UInt rateX, UInt rateY) const;
  63. own CFloatImage* expand (UInt rateX, UInt rateY) const;  // expand by putting zeros in between
  64. own CFloatImage* biInterpolate () const; // bilinearly interpolate 
  65. own CFloatImage* downsampleForSpatialScalability () const;
  66. own CFloatImage* upsampleForSpatialScalability () const;
  67. own CFloatImage* biInterpolate (UInt accuracy) const; // bilinearly interpolate using 2/4/8/16 quantization
  68. own CFloatImage* transpose () const; // transpose the floatimge
  69. own CFloatImage* complement () const; // complement a binarized fi
  70. own CFloatImage* warp (const CAffine2D& aff) const; // affine warp
  71. own CFloatImage* warp (const CPerspective2D& persp) const; // perspective warp
  72. own CFloatImage* warp (const CPerspective2D& persp, const CRct& rctWarp) const; // perspective warp to rctWarp
  73. own CFloatImage* warp (const CPerspective2D& persp, const CRct& rctWarp, const UInt accuracy) const; // perspective warp to rctWarp
  74. own CFloatImage* smooth (UInt window) const; // smooth a binarized fi of window
  75. PixelF pixel (CoordD x, CoordD y) const; // bi-linear interpolation
  76. PixelF pixel (CoordI x, CoordI y, UInt accuracy) const; // bi-linear interpolation using 2/4/8/16 quantization
  77. PixelF pixel (const CSiteD& std) const {return pixel (std.x, std.y);} // bi-linear interpolation
  78. PixelF pixel (const CSite& std, UInt accuracy) const {return pixel (std.x, std.y, accuracy);} // bi-linear interpolation
  79. Double mean () const; // mean
  80. Double mean (const CFloatImage* pfiMsk) const; // mean
  81. Double sumAbs (const CRct& rct = CRct ()) const; // sum of absolute value
  82. Double sumDeviation () const; // sum of first-order deviation
  83. Double sumDeviation (const CFloatImage* pfiMsk) const; // sum of first-order deviation
  84. Bool allValue (Float vl, const CRct& rct = CRct ()) const; // whether all pixels have value of vl
  85. Bool biLevel (const CRct& rct = CRct ()) const; // whether it is a binary image
  86. Bool atLeastOneValue (Float vl, const CRct& rct = CRct ()) const; // whether at least one pixel has value of vl
  87. CRct whereVisible () const; // the tightest bounding box of non-transparent pixels
  88. UInt numPixelsNotValued (Float vl, const CRct& rct = CRct ()) const; // number of pixels not valued vl in region rct
  89. Double mse (const CFloatImage& fiCompare) const;
  90. Double mse (const CFloatImage& fiCompare, const CFloatImage& fiMsk) const;
  91. Double snr (const CFloatImage& fiCompare) const;
  92. Double snr (const CFloatImage& fiCompare, const CFloatImage& fiMsk) const;
  93. Void vdlDump (const Char* fileName = "tmp.vdl") const;
  94. Void dump (FILE *) const;
  95. Void txtDump (const Char* fileName = "tmp.txt") const;
  96. Void txtDump (FILE *) const;
  97. Void txtDumpMask (FILE *) const;
  98. own CFloatImage* extendPadLeft ();  // for block padding
  99. own CFloatImage* extendPadRight ();  // for block padding
  100. own CFloatImage* extendPadTop ();  // for block padding
  101. own CFloatImage* extendPadDown ();  // for block padding
  102. // Overloaded operators
  103. own CFloatImage& operator += (const CFloatImage &);
  104. own CFloatImage* operator + (const CFloatImage& fi) const;
  105. own CFloatImage* operator - (const CFloatImage& fi) const;
  106. own CFloatImage* operator * (Float scale) const; // multiply every pixel by scale
  107. own CFloatImage* operator / (Float scale) const; // divide every pixel by scale
  108. own CFloatImage* operator * (const CTransform& tf) const;
  109. own CFloatImage* operator * (const CAffine2D& aff) const {return warp (aff);} // affine warp
  110. own CFloatImage* operator * (const CPerspective2D& persp) const {return warp (persp);} // perspective warp
  111. Bool operator == (const CFloatImage& fi) const;
  112. // Operations
  113. Void where (const CRct& r); // crop based on r
  114. Void pixel (CoordI x, CoordI y, PixelF p) {m_ppxlf [m_rc.offset (x, y)] = p;} // set a pixel
  115. Void pixel (const CSite& st, PixelF p) {pixel (st.x, st.y, p);} //  set a pixel
  116. Void setRect (const CRct& rct); // set the rect
  117. Void shift (Int nX, Int nY) {m_rc.shift (nX, nY);} // shift CRct by nX and nY
  118. Void zeroPad (const CFloatImage* pfimsk); // zero padding
  119. Void LPEPad (const CFloatImage* pfimsk); // Low Pass Extrapolation Padding
  120. Void simplifiedRepeatPad(const CFloatImage *); // simplified repetitive padding
  121. Void modSimplifiedRepeatPad(const CFloatImage *);
  122. Void originalRepeatPad(const CFloatImage *);
  123. Void modOriginalRepeatPad(const CFloatImage *);
  124. Void repeatPad (const CFloatImage* pfimsk); // repetitive padding
  125. Void sHorRepeatPad (const CFloatImage* pfimsk); // simplified horizontal repetitive padding
  126. Void sVerRepeatPad (const CFloatImage* pfimsk); // simplified vertical repetitive padding
  127. Void mrepeatPad (const CFloatImage* pfimsk); // modified repetitive padding
  128. Void blockPad (const CFloatImage* pfiOrigMask, const UInt uintBlockSize); // block padding
  129. Void dilatePad (const CFloatImage* pfiOrigMask); // morphological dilating padding
  130. Void averagePad (const CFloatImage* pfiOrigMask); // averaging padding
  131. Void repeatPadNew (const CFloatImage* pfimsk); // repetitive padding
  132. Void threshold (Float thresh);    // cut < thresh to be zero
  133. Void binarize (Float fltThresh); // binarize it
  134. Void checkRange (Float fltMin, Float fltMax); 
  135. Void overlay (const CFloatImage& fi); // overlay fi on top of *this
  136. Void xorFi (const CFloatImage& fi); // xor two binarized fi
  137. Void orFi (const CFloatImage& fi); // or of two binarized fi
  138. Void andFi (const CFloatImage& fi); // or of two binarized fi
  139. Void maskOut (const CFloatImage& fi); // mask out fi
  140. Void mutiplyAlpha (const CFloatImage& fi); //multiply by alpha channel
  141. Void cropOnAlpha (); //  crop the image based on non-transparent value
  142. Void quantize (int stepsize, Bool dpcm = FALSE);
  143. // quantize the signal using the stepsize, dpcm if required
  144. Void deQuantize (int stepsize, Bool dpcm = FALSE);
  145. // deQuantize
  146. Void operator = (const CFloatImage& fi);
  147. Void roundNearestInt();
  148. ///////////////// implementation /////////////////
  149. protected:
  150. PixelF* m_ppxlf;
  151. CRct m_rc;
  152. Void allocate (const CRct& r, PixelF pxlf);
  153. Void copyConstruct (const CFloatImage& fi, const CRct& rct);
  154. Void swap (CFloatImage& fi);
  155. Void fillColumnDownward (
  156. const PixelF*& pxlOrigMask, 
  157. const PixelF*& ppxlOrigData, 
  158. PixelF*& ppxlFillMask, 
  159. PixelF*& ppxlFillData
  160. ) const;
  161. Void fillColumnUpward (
  162. const PixelF*& ppxlOrigMask, 
  163. const PixelF*& ppxlOrigData, 
  164. PixelF*& ppxlFillMask, 
  165. PixelF*& ppxlMaskData
  166. ) const;
  167. Void fillRowRightward (
  168. const PixelF*& ppxlOrigMask, 
  169. const PixelF*& ppxlOrigData, 
  170. PixelF*& ppxlFillMask, 
  171. PixelF*& ppxlFillData
  172. ) const;
  173. Void fillRowLeftward (
  174. const PixelF*& ppxlOrigMask, 
  175. const PixelF*& ppxlOrigData, 
  176. PixelF*& ppxlFillMask, 
  177. PixelF*& ppxlFillData
  178. ) const;
  179. Void fillCorners (CRct& nBlkRct);
  180. Void fillHoles (const CFloatImage *pfiFillMask);
  181. own CFloatImage* smooth_ (UInt window) const; // smooth a binarized fi of window
  182. // for block padding
  183. Void dilation4 (CFloatImage* pMask);
  184. Void dilation8 (CFloatImage* pMask);
  185. };
  186. #endif //_GRAYF_HPP_  
  187.