开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
wavelet_utils.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：19k
源码类别：

多媒体编程

开发平台：

Visual C++

wavelet_utils.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2. *
  3. * $Id: wavelet_utils.cpp,v 1.3 2005/01/30 05:11:40 gabest Exp $ $Name:  $
  4. *
  5. * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  6. *
  7. * The contents of this file are subject to the Mozilla Public License
  8. * Version 1.1 (the "License");  you may not use this file except in compliance
  9. * with the License. You may obtain a copy of the License at
  10. * http://www.mozilla.org/MPL/
  11. *
  12. * Software distributed under the License is distributed on an "AS IS" basis,
  13. * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
  14. * the specific language governing rights and limitations under the License.
  15. *
  16. * The Original Code is BBC Research and Development code.
  17. *
  18. * The Initial Developer of the Original Code is the British Broadcasting
  19. * Corporation.
  20. * Portions created by the Initial Developer are Copyright (C) 2004.
  21. * All Rights Reserved.
  22. *
  23. * Contributor(s): Thomas Davies (Original Author), Scott R Ladd
  24. *
  25. * Alternatively, the contents of this file may be used under the terms of
  26. * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
  27. * Public License Version 2.1 (the "LGPL"), in which case the provisions of
  28. * the GPL or the LGPL are applicable instead of those above. If you wish to
  29. * allow use of your version of this file only under the terms of the either
  30. * the GPL or LGPL and not to allow others to use your version of this file
  31. * under the MPL, indicate your decision by deleting the provisions above
  32. * and replace them with the notice and other provisions required by the GPL
  33. * or LGPL. If you do not delete the provisions above, a recipient may use
  34. * your version of this file under the terms of any one of the MPL, the GPL
  35. * or the LGPL.
  36. * ***** END LICENSE BLOCK ***** */
  39. #include <libdirac_common/wavelet_utils.h>
  40. #include <libdirac_common/common.h>
  41. using namespace dirac;
  43. #include <cstdlib>
  45. // Default constructor
  46. Subband::Subband()
  47. {
  48.     // this space intentionally left blank
  49. }
  51. // Constructor
  52. Subband::Subband(int xpos,int ypos, int xlen, int ylen):
  53.     xps(xpos),
  54.     yps(ypos),
  55.     xln(xlen),
  56.     yln(ylen),
  57.     wgt(1),
  58.     qfac(8)
  59. {
  60.     // this space intentionally left blank
  61. }
  63. // Constructor
  64. Subband::Subband(int xpos,int ypos, int xlen, int ylen, int d)
  65.   : xps(xpos),
  66.     yps(ypos),
  67.     xln(xlen), 
  68.     yln(ylen),
  69.     wgt(1),
  70.     dpth(d),
  71.     qfac(8)
  72. {
  73.     // this space intentionally left blank
  74. }
  76. //! Destructor
  77. Subband::~Subband()
  78. {
  79.     // this space intentionally left blank
  80. }
  82. //subband list methods
  84. void SubbandList::Init(const int depth,const int xlen,const int ylen)
  85. {
  86.     int xl=xlen; 
  87.     int yl=ylen; 
  88.     
  89.     Clear(); 
  90.     Subband* tmp;
  91.      
  92.     for (int level = 1; level <= depth; ++level)
  93.     {
  94.         xl/=2; 
  95.         yl/=2; 
  96.         
  97.         tmp=new Subband(xl , 0 , xl , yl , level); 
  98.         AddBand( *tmp ); 
  99.         delete tmp; 
  100.         
  101.         tmp=new Subband( 0 , yl , xl , yl , level); 
  102.         AddBand( *tmp ); 
  103.         delete tmp; 
  104.         
  105.         tmp=new Subband( xl , yl , xl , yl , level); 
  106.         AddBand( *tmp ); 
  107.         delete tmp; 
  108.         
  109.         if (level == depth)
  110.         {
  111.             tmp=new Subband( 0 , 0 , xl , yl , level); 
  112.             AddBand( *tmp ); 
  113.             delete tmp; 
  114.         }        
  115.     }
  116.     //now set the parent-child relationships
  117.     int len = bands.size(); 
  118.     (*this)(len).SetParent(0);         
  119.     (*this)(len).AddChild(len-3); 
  120.     (*this)(len-3).SetParent(len); 
  121.     (*this)(len).AddChild(len-2); 
  122.     (*this)(len-2).SetParent(len); 
  123.     (*this)(len).AddChild(len-1); 
  124.     (*this)(len-1).SetParent(len); 
  126.     for (int level = 1; level < depth; ++level)
  127.     {
  128.          //do parent-child relationship for other bands
  129.         (*this)(3*level + 1).AddChild( 3*(level-1) + 1); 
  130.         (*this)(3*(level-1) + 1).SetParent(3*level + 1); 
  132.         (*this)(3*level + 2).AddChild(3*(level-1) + 2); 
  133.         (*this)(3*(level-1) + 2).SetParent(3*level + 2); 
  135.         (*this)(3*level + 3).AddChild(3*(level-1) + 3); 
  136.         (*this)(3*(level-1) + 3).SetParent(3*level + 3); 
  137.     }// level
  138. }
  140. //wavelet transform methods
  141. ///////////////////////////
  143. //public methods
  145. WaveletTransform::WaveletTransform(int d, WltFilter f)
  146.   : depth(d),
  147.     filt_sort(f)
  148. {
  149.     // this space intentionally left blank
  150. }
  152. //! Destructor
  153. WaveletTransform::~WaveletTransform()
  154. {
  155.     // this space intentionally left blank
  156. }
  158. void WaveletTransform::Transform(const Direction d, PicArray& pic_data)
  159. {
  160.     int xl,yl; 
  162.     if (d == FORWARD)
  163.     {
  164.         //do work
  165.         xl=pic_data.LengthX(); 
  166.         yl=pic_data.LengthY(); 
  167.         
  168.         for (int l = 1; l <= depth; ++l)
  169.         {
  170.             VHSplit(0,0,xl,yl,pic_data); 
  171.             xl /= 2; 
  172.             yl /= 2; 
  173.         }
  175.         band_list.Init( depth , pic_data.LengthX() , pic_data.LengthY() ); 
  176.     }
  177.     else
  178.     {
  179.         //do work
  180.         xl = pic_data.LengthX()/(1<<(depth-1)); 
  181.         yl = pic_data.LengthY()/(1<<(depth-1)); 
  182.         
  183.         for (int l = 1; l <= depth; ++l)
  184.         {
  185.             VHSynth(0,0,xl,yl,pic_data); 
  186.             xl *= 2; 
  187.             yl *= 2; 
  188.         }
  189.         
  190.         //band list now inaccurate, so clear        
  191.         band_list.Clear();     
  192.     }
  193. }
  195. //private functions
  196. ///////////////////
  198. void WaveletTransform::VHSplit(const int xp, const int yp, const int xl, const int yl, PicArray& pic_data)
  199. {
  201.     //version based on integer-like types
  202.     //using edge-extension rather than reflection
  204.     OneDArray<ValueType *> tmp_data(yl); 
  205.     const int xl2 = xl/2; 
  206.     const int yl2 = yl/2; 
  207.     const int xend=xp+xl;
  208.     const int yend=yp+yl;
  210.     ValueType* line_data; 
  212.     // Positional variables
  213.     int i,j,k,r,s; 
  214.   
  215.     // Objects to do lifting stages 
  216.     // (in revese order and type from synthesis)
  217.     const PredictStep< 6497 > predictA;
  218.     const PredictStep< 217 > predictB;
  219.     const UpdateStep< 3616 > updateA;
  220.     const UpdateStep< 1817 > updateB;
  222.      //first do horizontal 
  224.     for (j = yp;  j < yend; ++j)
  225.     {
  226.         // First lifting stage
  227.         line_data = pic_data[j];                 
  229.         predictA.Filter( line_data[xp+1] , line_data[xp+2] , line_data[xp] );
  230.         predictB.Filter( line_data[xp] , line_data[xp+1] , line_data[xp+1] );
  232.         for (i = xp+2, k = xp+3; i < xend-2; i+=2, k+=2)
  233.         {
  234.             predictA.Filter( line_data[k] , line_data[i+2] , line_data[i] );
  235.             predictB.Filter( line_data[i] , line_data[k-2] , line_data[k] );
  236.         }// i
  237.         
  238.         predictA.Filter( line_data[xend-1] , line_data[xend-2] , line_data[xend-2] );
  239.         predictB.Filter( line_data[xend-2] , line_data[xend-3] , line_data[xend-1] );
  242.          //second lifting stage 
  243.         
  244.         updateA.Filter( line_data[xp+1] , line_data[xp+2] , line_data[xp] );
  245.         updateB.Filter( line_data[xp] , line_data[xp+1] , line_data[xp+1] );
  247.         for (i = xp+2, k = xp+3;  i < xend-2; i+=2 , k+=2)
  248.         { 
  249.             updateA.Filter( line_data[k] , line_data[i+2] , line_data[i] );
  250.             updateB.Filter( line_data[i] , line_data[k-2] , line_data[k] );
  251.         }// i
  253.         updateA.Filter( line_data[xend-1] , line_data[xend-2] , line_data[xend-2] );
  254.         updateB.Filter( line_data[xend-2] , line_data[xend-3] , line_data[xend-1] );
  256.     }// j
  258.     // next do vertical
  260.     // First lifting stage
  262.     // top edge - j=xp
  263.     for ( i = xp ; i<xend ; ++ i)
  264.     {
  265.         predictA.Filter( pic_data[yp+1][i] , pic_data[yp+2][i] , pic_data[yp][i] );
  266.         predictB.Filter( pic_data[yp][i] , pic_data[yp+1][i] , pic_data[yp+1][i] );
  267.     }// i
  269.     // middle bit
  270.     for ( j = yp+2, k = yp+3 ; j<yend-2 ; j+=2 , k+=2)
  271.     {
  272.         for ( i = xp ; i<xend ; ++ i)
  273.         {
  274.             predictA.Filter( pic_data[k][i] , pic_data[j+2][i] , pic_data[j][i] );
  275.             predictB.Filter( pic_data[j][i] , pic_data[k-2][i] , pic_data[k][i] );
  276.         }// i
  277.     }// j
  278.     // bottom edge
  279.     for ( i = xp ; i<xend ; ++ i)
  280.     {
  281.         predictA.Filter( pic_data[yend-1][i] , pic_data[yend-2][i] , pic_data[yend-2][i] );
  282.         predictB.Filter( pic_data[yend-2][i] , pic_data[yend-3][i] , pic_data[yend-1][i] );
  283.     }// i
  285.     // Second lifting stage
  287.     // top edge - j=xp
  288.     for ( i = xp ; i<xend ; ++ i)
  289.     {
  290.         updateA.Filter( pic_data[yp+1][i] , pic_data[yp+2][i] , pic_data[yp][i] );
  291.         updateB.Filter( pic_data[yp][i] , pic_data[yp+1][i] , pic_data[yp+1][i] );
  292.     }// i
  294.     // middle bit
  295.     for ( j = yp+2, k = yp+3 ; j<yend-2 ; j+=2 , k+=2)
  296.     {
  297.         for ( i = xp ; i<xend ; ++ i)
  298.         {
  299.             updateA.Filter( pic_data[k][i] , pic_data[j+2][i] , pic_data[j][i] );
  300.             updateB.Filter( pic_data[j][i] , pic_data[k-2][i] , pic_data[k][i] );
  301.         }// i
  302.     }// j
  303.     // bottom edge
  304.     for ( i = xp ; i<xend ; ++ i)
  305.     {
  306.         updateA.Filter( pic_data[yend-1][i] , pic_data[yend-2][i] , pic_data[yend-2][i] );
  307.         updateB.Filter( pic_data[yend-2][i] , pic_data[yend-3][i] , pic_data[yend-1][i] );
  308.     }// i
  310.     // Lastly, have to reorder so that subbands are no longer interleaved
  312.     ValueType** temp_data = new ValueType*[yl];
  313.     for ( j = 0 ; j< yl ; ++ j)
  314.         temp_data[j] = new ValueType[xl];
  316.     // Make a temporary copy of the subband
  317.     for ( j = yp; j<yend ; j++ )
  318.         memcpy( temp_data[j-yp] , pic_data[j]+xp , xl * sizeof( ValueType ) );
  320.     // Re-order to de-interleave
  321.     for ( j = yp, s=0; j<yp+yl2 ; j++, s+=2)
  322.     {
  323.         for ( i = xp , r=0 ; i<xp+xl2 ; i++ , r += 2)
  324.             pic_data[j][i] = temp_data[s][r];
  325.         for ( i = xp+xl2, r=1; i<xend ; i++ , r += 2)
  326.             pic_data[j][i] = temp_data[s][r];
  327.     }// j 
  329.     for ( j = yp+yl2, s=1 ; j<yend ; j++ , s += 2)
  330.     {
  331.         for ( i = xp , r=0 ; i<xp+xl2 ; i++ , r += 2)
  332.             pic_data[j][i] = temp_data[s][r];
  333.         for ( i = xp+xl2, r=1; i<xend ; i++ , r += 2)
  334.             pic_data[j][i] = temp_data[s][r];
  335.     }// j 
  338.     for ( j = 0 ; j< yl ; ++ j)
  339.         delete[] temp_data[j];
  340.     delete[] temp_data;
  342. }
  344. void WaveletTransform::VHSynth(const int xp, const int yp, const int xl, const int yl, PicArray& pic_data)
  345. {
  346.     int i,j,k,r,s;
  348.     const int xend( xp+xl );
  349.     const int yend( yp+yl );
  350.     const int xl2( xl/2 );
  351.     const int yl2( yl/2 );
  353.     const PredictStep< 1817 > predictB;
  354.     const PredictStep< 3616 > predictA;
  355.     const UpdateStep< 217 > updateB;
  356.     const UpdateStep< 6497 > updateA;
  358.     ValueType* line_data;
  360.     // Firstly reorder to interleave subbands, so that subsequent calculations can be in-place
  362.     ValueType** temp_data = new ValueType*[yl];
  363.     for ( j = 0 ; j< yl ; ++ j)
  364.         temp_data[j] = new ValueType[xl];
  366.     // Make a temporary copy of the subband
  367.     for ( j = yp; j<yend ; j++ )
  368.         memcpy( temp_data[j-yp] , pic_data[j]+xp , xl * sizeof( ValueType ) );
  370.     // Re-order to interleave
  371.     for ( j = 0, s=yp; j<yl2 ; j++, s+=2)
  372.     {
  373.         for ( i = 0 , r=xp ; i<xl2 ; i++ , r += 2)
  374.             pic_data[s][r] = temp_data[j][i];
  375.         for ( i = xl2, r=xp+1; i<xl ; i++ , r += 2)
  376.             pic_data[s][r] = temp_data[j][i];
  377.     }// j 
  379.     for ( j = yl2, s=yp+1 ; j<yl ; j++ , s += 2)
  380.     {
  381.         for ( i = 0 , r=xp ; i<xl2 ; i++ , r += 2)
  382.             pic_data[s][r] = temp_data[j][i];
  383.         for ( i = xl2, r=xp+1; i<xl ; i++ , r += 2)
  384.             pic_data[s][r] = temp_data[j][i];
  385.     }// j 
  387.     for ( j = 0 ; j< yl ; ++ j)
  388.         delete[] temp_data[j];
  389.     delete[] temp_data;
  391.     // Next, do the vertical synthesis
  392.     // First lifting stage
  394.     // Begin with the bottom edge
  395.     for ( i = xend-1 ; i>=xp ; --i)
  396.     {
  397.         predictB.Filter( pic_data[yend-2][i] , pic_data[yend-3][i] , pic_data[yend-1][i] );
  398.         predictA.Filter( pic_data[yend-1][i] , pic_data[yend-2][i] , pic_data[yend-2][i] );
  399.     }// i
  400.     // Next, do the middle bit
  401.     for ( j = yend-4, k = yend-3 ; j>yp ; j-=2 , k-=2)
  402.     {
  403.         for ( i = xend-1 ; i>=xp ; --i)
  404.         {
  405.             predictB.Filter( pic_data[j][i] , pic_data[k-2][i] , pic_data[k][i] );
  406.             predictA.Filter( pic_data[k][i] , pic_data[j+2][i] , pic_data[j][i] );
  407.         }// i
  408.     }// j
  409.     // Then do the top edge
  410.     for ( i = xend-1 ; i>=xp ; --i)
  411.     {
  412.         predictB.Filter( pic_data[yp][i] , pic_data[yp+1][i] , pic_data[yp+1][i] );
  413.         predictA.Filter( pic_data[yp+1][i] , pic_data[yp+2][i] , pic_data[yp][i] );
  414.     }// i
  416.     // Second lifting stage
  418.     // Begin with the bottom edge
  419.     for ( i = xend-1 ; i>=xp ; --i)
  420.     {
  421.         updateB.Filter( pic_data[yend-2][i] , pic_data[yend-3][i] , pic_data[yend-1][i] );
  422.         updateA.Filter( pic_data[yend-1][i] , pic_data[yend-2][i] , pic_data[yend-2][i] );
  423.     }// i
  424.     // Next, do the middle bit
  425.     for ( j = yend-4, k = yend-3 ; j>yp ; j-=2 , k-=2)
  426.     {
  427.         for ( i = xend-1 ; i>=xp ; --i)
  428.         {
  429.             updateB.Filter( pic_data[j][i] , pic_data[k-2][i] , pic_data[k][i] );
  430.             updateA.Filter( pic_data[k][i] , pic_data[j+2][i] , pic_data[j][i] );
  431.         }// i
  432.     }// j
  433.     // Then do the top edge
  434.     for ( i = xend-1 ; i>=xp ; --i)
  435.     {
  436.         updateB.Filter( pic_data[yp][i] , pic_data[yp+1][i] , pic_data[yp+1][i] );
  437.         updateA.Filter( pic_data[yp+1][i] , pic_data[yp+2][i] , pic_data[yp][i] );
  438.     }// i
  441.     // Next do the horizontal synthesis
  442.     for (j = yend-1;  j >= yp ; --j)
  443.     {
  444.         // First lifting stage 
  445.         line_data = pic_data[j];
  447.         predictB.Filter( line_data[xend-2] , line_data[xend-3] , line_data[xend-1] ); 
  448.         predictA.Filter( line_data[xend-1] , line_data[xend-2] , line_data[xend-2] );
  450.         for (i = xend-4, k = xend-3;  i > xp; i-=2 , k-=2)
  451.         { 
  452.             predictB.Filter( line_data[i] , line_data[k-2] , line_data[k] );
  453.             predictA.Filter( line_data[k] , line_data[i+2] , line_data[i] );
  454.         }// i
  456.         predictB.Filter( line_data[xp] , line_data[xp+1] , line_data[xp+1] );
  457.         predictA.Filter( line_data[xp+1] , line_data[xp+2] , line_data[xp] );
  459.         // Second lifting stage
  461.         updateB.Filter( line_data[xend-2] , line_data[xend-3] , line_data[xend-1] );
  462.         updateA.Filter( line_data[xend-1] , line_data[xend-2] , line_data[xend-2] );
  464.         for (i = xend-4, k = xend-3;  i > xp; i-=2 , k-=2)
  465.         {
  466.             updateB.Filter( line_data[i] , line_data[k-2] , line_data[k] );
  467.             updateA.Filter( line_data[k] , line_data[i+2] , line_data[i] );
  468.         }// i
  470.         updateB.Filter( line_data[xp] , line_data[xp+1] , line_data[xp+1] );
  471.         updateA.Filter( line_data[xp+1] , line_data[xp+2] , line_data[xp] );
  473.     }
  475. }
  477. //perceptual weighting stuff
  478. ////////////////////////////
  480. // Returns a perceptual noise weighting based on extending CCIR 959 values
  481. // assuming a two-d isotropic response. Also has a fudge factor of 20% for chroma
  482. float WaveletTransform::PerceptualWeight( float xf , float yf , CompSort cs )
  483. {
  484.     double freq_sqd( xf*xf + yf*yf );
  486.     if ( cs != Y_COMP )
  487.         freq_sqd *= 1.2;
  489.     return 0.255 * std::pow( 1.0 + 0.2561*freq_sqd , 0.75) ;
  491. }
  493. void WaveletTransform::SetBandWeights (const float cpd, 
  494.                                        const FrameSort& fsort,
  495.                                        const ChromaFormat& cformat,
  496.                                        const CompSort csort)
  497. {
  498.     //NB - only designed for progressive to date    
  500.     int xlen, ylen, xl, yl, xp, yp, depth;
  501.     float xfreq, yfreq;
  502.     float temp;
  504.     // Compensate for chroma subsampling
  506.     float chroma_xfac(1.0);
  507.     float chroma_yfac(1.0);
  509.     if( csort != Y_COMP)
  510.     {
  511.         if( cformat == format422)
  512.         {
  513.             chroma_xfac = 2.0;
  514.             chroma_yfac = 1.0;
  515.         }
  516.         else if( cformat == format411 )
  517.         {
  518.             chroma_xfac = 4.0;
  519.             chroma_yfac = 1.0;
  520.         }
  521.         else if( cformat == format420 )
  522.         {
  523.             chroma_xfac = 2.0;
  524.             chroma_yfac = 2.0;
  525.         }
  527.     }
  529.     xlen = 2 * band_list(1).Xl();
  530.     ylen = 2 * band_list(1).Yl();
  532.     if (cpd != 0.0)
  533.     {
  534.         for( int i = 1; i<=band_list.Length() ; i++ )
  535.         {
  536.             xp = band_list(i).Xp();
  537.             yp = band_list(i).Yp();
  538.             xl = band_list(i).Xl();
  539.             yl = band_list(i).Yl();
  542.             xfreq = cpd * ( float(xp) + (float(xl)/2.0) ) / float(xlen);
  543.             yfreq = cpd * ( float(yp) + (float(yl)/2.0) ) / float(ylen);
  545.             if ( fsort != I_frame )
  546.             {
  547.                 xfreq /= 8.0;
  548.                 yfreq /= 8.0;
  549.             }
  552.             temp = PerceptualWeight( xfreq/chroma_xfac , yfreq/chroma_yfac , csort );
  554.             band_list(i).SetWt(temp);
  555.         }// i
  557.         // Give more welly to DC in a completely unscientific manner ...
  558.         // (should really relate this to the frame rate)
  559.         band_list( band_list.Length() ).SetWt(band_list(13).Wt()/6.0);
  561.         // Make sure dc is always the lowest weight
  562.         float min_weight=band_list(band_list.Length()).Wt();
  564.         for( int b=1 ; b<=band_list.Length()-1 ; b++ )
  565.             min_weight = ((min_weight>band_list(b).Wt()) ? band_list(b).Wt() : min_weight);
  567.         band_list( band_list.Length() ).SetWt( min_weight );
  569.         // Now normalize weights so that white noise is always weighted the same
  571.         // Overall factor to ensure that white noise ends up with the same RMS, whatever the weight
  572.         double overall_factor=0.0;
  573.         //fraction of the total number of samples belonging to each subband
  574.         double subband_fraction;    
  576.         for( int i=1 ; i<=band_list.Length() ; i++ )
  577.         {
  578.             subband_fraction = 1.0/((double) band_list(i).Scale() * band_list(i).Scale());
  579.             overall_factor += subband_fraction/( band_list(i).Wt() * band_list(i).Wt() );
  580.         }
  581.         overall_factor = std::sqrt( overall_factor );
  583.         //go through and normalise
  585.         for( int i=band_list.Length() ; i>0 ; i-- )
  586.             band_list(i).SetWt( band_list(i).Wt() * overall_factor );
  587.     }
  588.     else
  589.     {//cpd=0 so set all weights to 1
  591.         for( int i=1 ; i<=band_list.Length() ; i++ )
  592.            band_list(i).SetWt( 1.0 );        
  594.     }
  596.     //Finally, adjust to compensate for the absence of scaling in the transform
  597.     //Factor used to compensate:
  598.     const double alpha(1.149658203);    
  599.     for ( int i=1 ; i<=band_list.Length() ; ++i )
  600.     {
  601.         depth=band_list(i).Depth();
  603.         if ( band_list(i).Xp() == 0 && band_list(i).Yp() == 0)
  604.             temp=std::pow(alpha,2*depth);
  605.         else if ( band_list(i).Xp() != 0 && band_list(i).Yp() != 0)
  606.             temp=std::pow(alpha,2*(depth-2));
  607.         else
  608.             temp=std::pow(alpha,2*(depth-1));
  610.         band_list(i).SetWt(band_list(i).Wt()/temp);
  612.     }// i        
  614. }