www.pudn.com > MediaPlayer.rar > MyBmp.cpp
#include "stdafx.h"
#include "MyBmp.h"
float infi = 0.00100000 ;
#define PI 3.14159265358979323846
#define thresh 40
#define NULL 0
void MyBmp::SaveBMPData(unsigned char *imageData, int width, int height, char *bmpname, int nType)
{
BITMAPFILEHEADER bfh;
BITMAPINFOHEADER bih;
RGBQUAD rgbQuad[256]; //定义调色板
LONG lineBytes, dwImgDataSize;
unsigned char *out;
if(nType == 8)
{
lineBytes = WIDTHBYTES(width*8);
//用于内存处理的宽度是调整好的，字节数是4的整数倍
dwImgDataSize = lineBytes * height;
out = new unsigned char[lineBytes * height];
memset(out, (BYTE)255, lineBytes * height);
unsigned char *p, *p1;
//设定BMP的文件头（共14字节）
bfh.bfType = 0x4d42;
//文件的属性bfSize计算时用的图像数据大小是用调整后的宽度计算的
bfh.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)+dwImgDataSize;
bfh.bfReserved1 = 0;
bfh.bfReserved2 = 0;
bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD);
//设定BMP的信息头（共40字节）
bih.biSize = sizeof(BITMAPINFOHEADER);
//bih.biWidth = lineBytes;
//bmp文件里的biWidth属性是图像的实际宽度
bih.biWidth = width;
bih.biHeight = height;
bih.biPlanes = 1;
bih.biBitCount = 8;
bih.biCompression = BI_RGB;
bih.biSizeImage = dwImgDataSize;
bih.biYPelsPerMeter = 0;
bih.biXPelsPerMeter = 0;
bih.biClrUsed = 0;
bih.biClrImportant = 0;
//对调色板进行赋值
for(int i=0; i<256; i++)
{
rgbQuad[i].rgbBlue = (BYTE)i;
rgbQuad[i].rgbGreen = (BYTE)i;
rgbQuad[i].rgbRed = (BYTE)i;
rgbQuad[i].rgbReserved = 0;
}
//**************排列图像数据适合BMP格式
//为了凑齐4的整数倍而添加的图像数据不做处理
int pointer = 0;
unsigned char tempc;
for(i=0;iG)?R:G);
max = ((tmp>B)?tmp:B) ;
tmp = ((R=0)&(H<=20)|(H==316))
H=0;
else if ((H>=21)&(H<=40))
H=1;
else if ((H>=41)&(H<=75))
H=2;
else if ((H>=76)&(H<=155))
H=3;
else if ((H>=156)&(H<=190))
H=4;
else if ((H>=191)&(H<=270))
H=5;
else if ((H>=271)&(H<=295))
H=6;
else
H=7;
if ((S>0)&(S<=0.2))
S=0;
else if ((S>0.2)&(S<=0.7))
S=1;
else
S=2;
if ((V>0)&(V<=0.2))
V=0;
else if ((V>0.2)&(V<=0.7))
V=1;
else
V=2;
return ( 9*H+3*S+V ) ;
}
int MyBmp::value1(float H , float S , float V)
{
if ((H>0.05)&(H<=0.15+infi))
H=1;
else if ((H>0.15)&(H<=0.25+infi))
H=2;
else if ((H>0.25)&(H<=0.35+infi))
H=3;
else if ((H>0.35)&(H<=0.45+infi))
H=4;
else if ((H>0.45)&(H<=0.55+infi))
H=5;
else if ((H>0.55)&(H<=0.65+infi))
H=6;
else if ((H>0.65)&(H<=0.75+infi))
H=7;
else if((H>0.75)&(H<=0.85+infi))
H=8;
else if((H>0.85)&(H<=0.95+infi))
H=9;
else
H=10;
if ((S>=0.0)&&(S<=0.25+infi))
S=1;
else if ((S>0.25)&(S<=0.5+infi))
S=2;
else if ((S>0.5)&(S<=0.75+infi))
S=3;
else
S=4;
if ((V>=0.0)&(V<=0.2+infi))
V=1;
else if ((V>0.2)&(V<=0.4+infi))
V=2;
else if ((V>0.4)&(V<=0.6+infi))
V=3;
else if ((V>0.6)&(V<=0.8+infi))
V=4;
else
V=5;
return ( 20*H+5*S+V-25 ) ;
}
/****************************************************************
***
此函数运用X2直方图算法检测突变，隔帧差检测渐变
然后提取图像特征向量进行聚类提取关键帧
***
****************************************************************/
void MyBmp::FrameExaction(float * TepImg , int * Hist_hsv , int * result , int sframe , int eframe , int Width, int Height)
{
MyBmp bmpInstance;
int len = eframe - sframe + 2 ;
int Window = 15 ;
float * D ;
D = new float[len] ;
memset(D, 0, len*sizeof(float)) ;
float * FD ;
float MAX = infi ;
FD = new float[len] ;
memset(FD, 0, len*sizeof(float)) ;
for (int loop = sframe ; loop < eframe ; loop ++)
{
for( int k = 0 ; k < 72 ; k++)
{
//Output+= "loop+1";
/////////////////////////////////////////////////
int interval = 6 ; //求取隔帧差
if( (loop + 6) < eframe)
{
FD[loop - sframe + 1] += fabs(Hist_hsv[loop * 72 + k] - Hist_hsv[(loop + interval) * 72 + k]);
if (FD[loop - sframe + 1] > MAX) //求得全局最大的FD
{
MAX = FD[loop - sframe + 1] ;
}
}
if ( Hist_hsv[(loop + 1) * 72 + k] > Hist_hsv[loop * 72 + k] )
D[loop - sframe + 1] += sqr( Hist_hsv[(loop + 1) * 72 + k] - Hist_hsv[loop * 72 + k] )/(float)(Hist_hsv[(loop + 1) * 72 + k] + 1);
else
D[ loop - sframe + 1] += sqr( Hist_hsv[(loop+1) * 72 + k] - Hist_hsv[loop * 72 + k] )/(float)(Hist_hsv[loop * 72 + k] + 1);
}
}
// FILE *fpX;
// fpX=fopen("X2.txt","w");
// for(int w=1;w < eframe - sframe ;w++)
// {
// fprintf(fpX,"%f ",D[w]);
// if(w%5 == 0)fprintf(fpX,"\n");
// }
// fclose(fpX);
for( loop = 0 ; loop < len - 4 ; loop++) //开窗检测
{
int l = 0 ;
int g = 0 ;
for ( int k = ((loop-4 > 0)?(loop-4) : -1) ;k <=((loop+4 < len)?(loop+4) : (len-2)) ; k++ )
{
if ( D[loop+1] > 4 * D[k+1] ) // 4可作为参数调整
{
l++ ;
}
else if( D[loop+1] > 2 * D[k+1] && D[loop+1] < 3 * D[k+1])
{
g++ ;
}
}
if ( (l == 8 )||(l >= 7 && g <= 1))
{
for (int i = ((sframe + loop - 10 < sframe)? sframe : (sframe + loop - 10)); i < ((sframe + loop + 5 >= eframe)? eframe : (sframe + loop + 5)); i ++) //切变处前后15帧在检测渐变时应跳过检测
{
result[i] = 2 ;
}
result[sframe + loop + 1] = 1;
}
}
// else if ( l >= 6 )
// {
// t.Format("%d\n",loop+1);
// Output+=t;
// }
// FILE *fpF;
// fpF=fopen("FD.txt","w");
// for( w=1;w < eframe - sframe - 6 ;w++)
// {
// fprintf(fpF,"%f ",FD[w]);
// if(w%5 == 0)fprintf(fpF,"\n");
// }
// fclose(fpF);
int Paticalmaxlabel = 0 ;
//以下为处理隔帧差的曲线FD以提取出峰值区所在的潜在渐变区间
int Th = 2.0 * MAX / 3.0 ; //设定双重阈值
int Tl = MAX / 3.0 ;
int PaticalMAX = infi ;
// for (loop = 1 ; loop < eframe - 6 ; loop ++)
// {
// int PaticalMAX = infi ;
// for (int i = loop ; i <= loop + Window ; i ++)
// {
// if (FD[i] > PaticalMAX)
// {
// PaticalMAX = FD[i] ;
// Paticalmaxlabel = i ;
// }
// }
// if((FD[Paticalmaxlabel] - MAX/3.0 > infi)&&(FD[Paticalmaxlabel] > FD[Paticalmaxlabel + 1])&&(FD[Paticalmaxlabel] > FD[Paticalmaxlabel - 1]))
// {
// result[Paticalmaxlabel] = 1 ;
// }
// }
int gradstart = -1 ; //渐变起始帧号
int gradend = -1 ;
//int Win = 10 ;
for (int i = sframe ; i <= eframe ; i++)
{
if ((result[i] == 0)&&(FD[i] > Tl))
{
if (gradstart == -1)
{
gradstart = i + 6 ;
while ((result[i] == 0)&&(FD[i] > Tl))
{
if (FD[i] > PaticalMAX)
{
PaticalMAX = FD[i] ;
}
i++ ;
}
gradend = i ;
if (PaticalMAX > Th)
{
while (gradend >= gradstart)
{
result[gradend] = 1 ; //渐变标记
gradend -- ;
}
gradstart = -1 ;
gradend = -1 ;
}
}
}
}
for( i = sframe ; i <= eframe ; i++)
{
if (result[i] != 1)
{
bmpInstance.cluster(TepImg , result , i , eframe , Width , Height , Hist_hsv) ;
}
}
delete [] D ;
D = NULL ;
delete [] FD ;
FD = NULL ;
}
/************************************************************************
****
void cluster(float * TepImg , int * result , int i , int ed , int Width, int Height):聚类函数，用来将从第i帧开始的镜头进行镜头内的聚类
************************************************************************/
void MyBmp::cluster(float * TepImg , int * result , int &i , int ed , int Width, int Height , int * Hist_hsv)
{
MyBmp bmpInstance;
Childshot *pcshot , *qshot , *head;
float distance = 0.0 ;
float *vector ;
vector = new float[12];
memset(vector, 0.0, 12*sizeof(float));
float *vector1 ;
vector1 = new float[12];
memset(vector1, 0.0, 12*sizeof(float));
pcshot = (Childshot *)malloc(sizeof(Childshot)) ;
head = pcshot ;
pcshot->entropyMax = 0.0 ;
pcshot->keynum = i ;
bmpInstance.Feature(TepImg + i * 3 * Width * Height , Width , Height , vector);
bmpInstance.Entropy(Hist_hsv + i * 72 , pcshot->entropyMax , pcshot->keynum , Width , Height , i) ;
FILE *fpX;
fpX=fopen("Feature.txt","w");
pcshot->center = vector ;
pcshot->lenth = 1 ;
pcshot->start = i ;
pcshot->next = NULL ;
i ++ ;
do
{
bmpInstance.Feature(TepImg + i * 3 * Width * Height , Width , Height , vector1);
bmpInstance.Distance(vector1 , pcshot->center , distance) ;
fprintf(fpX,"%f ",distance);
if ((distance > thresh)&&(pcshot->lenth >= 5)) //若大于阈值则子镜头长大于5则新建一个子镜头
{
qshot = (Childshot *)malloc(sizeof(Childshot)) ;
for(int w = 0 ;w < 12 ; w ++) //注意：赋值与赋地址在此处同时出现
{
vector[w] = vector1[w] ;
}
qshot->center = vector ;
qshot->lenth = 1 ;
qshot->start = i ;
qshot->keynum = i ;
qshot->entropyMax = 0.0 ;
bmpInstance.Entropy(Hist_hsv + i * 72 , pcshot->entropyMax , pcshot->keynum , Width , Height , i) ;
qshot->next = NULL ;
pcshot->next = qshot ;
pcshot = pcshot->next ;
}
else //否则将下一帧归入原先的子镜头类
{
if (i == 668)
{
i = 668 ;
}
bmpInstance.Entropy(Hist_hsv + i * 72 , pcshot->entropyMax , pcshot->keynum , Width , Height , i) ;
for (int k = 0 ; k < 12 ; k++)
{
pcshot->center[k] = (pcshot->center[k] * pcshot->lenth + vector1[k]) / (float)(pcshot->lenth + 1) ;
}
pcshot->lenth ++ ;
}
i ++ ;
} while((result[i] != 1)&&(i <= ed));
pcshot = head ;
while (pcshot != NULL)
{
result[pcshot->keynum] = 10 ; //result数组值为10的为关键帧提取出来
pcshot = pcshot->next ;
}
delete [] vector ;
vector = NULL ;
delete [] vector1 ;
vector1 = NULL ;
fclose(fpX) ;
}
/*****************************************************************
***
Feature函数用来提取一幅图像的12维特征向量，返回float数组指针
******************************************************************/
void MyBmp::Feature(float * TepImg , int Width, int Height , float *vector)
{
double c[8][8] ;
double block_H[64] , block_S[64] , block_V[64] ;
int i , j , k ;
int Winwid ;
int Winhei ;
double H = 0.0 ;
double S = 0.0 ;
double V = 0.0 ;
double s_H , s_S , s_V;
double tmp_H[64];
double tmp_S[64];
double tmp_V[64];
int chWidth = Width / 8 ; //将图像分为8×8的块
int chHeight = Height / 8 ;
for(Winwid = 0 ; Winwid < 8 ; Winwid ++)
{
for(Winhei = 0 ; Winhei < 8 ; Winhei ++)
{
k = 0 ;
for (i = 0 ; i < ((Winwid == 7) ? (Width - 7 * chWidth) : chWidth) ; i ++)
for (j = 0 ; j < ((Winhei == 7) ? (Height - 7 * chHeight) : chHeight) ; j ++)
{
H += TepImg[((Winhei * chHeight + j) * Width + Winwid * chWidth + i) * 3] ;
S += TepImg[((Winhei * chHeight + j) * Width + Winwid * chWidth + i) * 3 + 1] ;
V += TepImg[((Winhei * chHeight + j) * Width + Winwid * chWidth + i) * 3 + 2] ;
k ++ ;
}
block_H[Winhei * 8 + Winwid] = H /(double) k ;
block_S[Winhei * 8 + Winwid] = S /(double) k ;
block_V[Winhei * 8 + Winwid] = V /(double) k ;
}
}
//对前向DCT变换进行初始化
for (i = 0 ; i < 8 ;i++)
{
s_H = (i == 0) ? sqrt(0.125) : 0.5 ;
for (j = 0 ; j < 8 ; j++)
{
c[i][j] = s_H * cos((PI/8.0) * i * (j + 0.5)) ;
}
}
//开始进行前向DCT变化
for (i = 0 ; i < 8 ; i ++)
for(j = 0 ; j < 8 ; j ++)
{
s_H = 0.0 ;
s_S = 0.0 ;
s_V = 0.0 ;
for (k = 0 ;k < 8 ; k ++)
{
s_H += c[j][k] * block_H[8 * i + k] ;
s_S += c[j][k] * block_S[8 * i + k] ;
s_V += c[j][k] * block_V[8 * i + k] ;
}
tmp_H[8 * i + j] = s_H ;
tmp_S[8 * i + j] = s_S ;
tmp_V[8 * i + j] = s_V ;
}
for(j = 0 ; j < 8 ; j ++)
for(i = 0 ; i < 8 ; i ++)
{
s_H = 0.0 ;
s_S = 0.0 ;
s_V = 0.0 ;
for (k = 0 ;k < 8 ; k ++)
{
s_H += c[i][k] * tmp_H[8 * k + j] ;
s_S += c[i][k] * tmp_S[8 * k + j] ;
s_V += c[i][k] * tmp_V[8 * k + j] ;
}
block_H[8 * i + j] = (int)floor(s_H + 0.499999) ;
block_S[8 * i + j] = (int)floor(s_S + 0.499999) ;
block_V[8 * i + j] = (int)floor(s_V + 0.499999) ;
}
vector[0] = block_H[0] ;
vector[1] = block_H[1] ;
vector[2] = block_H[8] ;
vector[3] = block_H[9] ;
vector[4] = block_S[0] ;
vector[5] = block_S[1] ;
vector[6] = block_S[8] ;
vector[7] = block_S[9] ;
vector[8] = block_V[0] ;
vector[9] = block_V[1] ;
vector[10] = block_V[8] ;
vector[11] = block_V[9] ;
}
/*******************************************************************************
***
Distance函数用来求vector1和vector2两个12维向量的距离
*******************************************************************************/
void MyBmp::Distance(float *vector1 , float *vector2 , float &distance)
{
int i ;
distance = 0.0 ;
for (i = 0 ; i < 12 ; i++)
{
distance += sqr(vector1[i] - vector2[i]) ;
}
distance = sqrt(distance) ;
}
/*******************************************************************************
***
Entropy函数用来得到子镜头中熵值最大的帧作为关键帧
*******************************************************************************/
void MyBmp::Entropy(int * Hist_hsv , float &entropyMax , int &keynum , int Width, int Height , int i)
{
float entropy = 0.0 ;
float rate ;
for (int w = 0 ; w < 72 ; w ++)
{
rate = Hist_hsv[w] / (float)(Width * Height) ;
if (rate != 0)
{
entropy -= rate * log(rate) / log(2) ;
}
}
if (entropy >= entropyMax)
{
entropyMax = entropy ;
keynum = i ;
}
}
void MyBmp::conv(int * Hist_hsv1 , int * result , int sframe , int eframe , int m)
{
int i = eframe - sframe + 2 ;
float *V ;
V = new float[i];
memset(V, 0, i*sizeof(float)) ;
float *V1 ;
V1 = new float[i];
memset(V1, 0, i*sizeof(float)) ;
float *D ;
D = new float[i];
memset(D, 0, i*sizeof(float)) ;
int n = 5 ;
int Window = 15 ;
int beta = 15 ;
int gama = 20 ;
for (int loop = sframe ; loop <= eframe ; loop++)
{
/* if(loop == 460)
{
loop = 460 ;
}*/
for( int k = 0 ; k < 200 ; k++)
{
V[loop - sframe + 1] += 1.0*(Hist_hsv1[loop*200+k] - m)*(Hist_hsv1[loop*200+k] - m)/199.0;
}
//V[loop - sframe + 1] /= ;
}
/* FILE *fp;
fp=fopen("v.txt","w");
for( int w=0;w<200;w++)
{
fprintf(fp,"%f ",V[w]);
if(w%5 == 0)fprintf(fp,"\n");
}
fclose(fp);*/
float aver = 0.001;
int num = 0 ;
for (loop = sframe ; loop <= eframe ; loop++)
{
/*if(loop == 456)
{
loop = 456;
}
*/
if ((loop >= sframe)&(loop <= eframe - n))
{
for (int j = loop ; j <= loop+n-1 ; j++)
{
V1[loop - sframe + 1] += V[j - sframe + 1] ;
}
V1[loop - sframe + 1] /= (float) n ;
}
else
{
for (int j = loop ; j <= eframe ; j++)
{
V1[loop - sframe + 1] += V[j - sframe + 1] ;
}
V1[loop - sframe + 1] /= (float) (eframe-loop+1) ;
}
if (loop > sframe)
{
D[loop - sframe] = V1[loop - sframe + 1] - V1[loop - sframe ] ;
if(D[loop - sframe] > 0.0001)
{
aver += D[loop - sframe] ;
num ++ ;
}
}
}
aver /= float(num) ;
FILE *fp1;
fp1=fopen("v1.txt","w");
for(int w=1;w < eframe - sframe ;w++)
{
fprintf(fp1,"%f ",D[w]);
if(w%5 == 0)fprintf(fp1,"\n");
}
fclose(fp1);
int Paticalmaxlabel = 0 ;
int Paticalminlabel = 0 ;
float MAX ;
float MIN ;
for (loop = 2 ; loop <= eframe - Window + 1 ; loop++) //开窗检验
{
if(loop == eframe - Window + 1)
{
loop = eframe - Window + 1 ;
}
MAX = infi ;
MIN = -infi ;
for(int j = loop ; j <= loop + Window ; j++)
{
if((D[j] > infi)&&(D[j] > D[j + 1])&&(D[j] > D[j - 1]))
{
if(D[j] > MAX)
{
MAX = D[j] ;
Paticalmaxlabel = j ;
}
}
else if((D[j] < - infi)&&(D[j] < D[j + 1])&&(D[j] < D[j - 1]))
{
if(D[j] < MIN)
{
MIN = D[j] ;
Paticalminlabel = j ;
}
}
}
float absMax = ((fabs(MAX) >= fabs(MIN))? fabs(MAX) : fabs(MIN)) ;
float absMin = ((fabs(MAX) <= fabs(MIN))? fabs(MAX) : fabs(MIN)) ;
int maxlabel = ((Paticalmaxlabel > Paticalminlabel)? Paticalmaxlabel : Paticalminlabel) ;
int minlabel = ((Paticalmaxlabel < Paticalminlabel)? Paticalmaxlabel : Paticalminlabel) ;
if((MAX > 10.0 * aver)&&(MIN != - infi)) //局部最大值相当的大时确定为渐变区
{
for(w = minlabel ; w <= maxlabel ; w++)
{
result[w +sframe + n/2] = 1 ; //移位复原
}
while(fabs(D[w]) >= fabs(absMin/3.0)) //选择该区域附近的渐变帧
{
result[w +sframe + n/2] = 1 ;
w ++ ;
}
w = minlabel ;
while(fabs(D[w]) >= fabs(absMin/3.0)) //选择该区域附近的渐变帧
{
result[w +sframe + n/2] = 1 ;
w -- ;
}
loop = (((maxlabel + 20) <= (eframe - Window + 1))?(maxlabel + 20) : (eframe - Window + 1)); //避免重复设置，将loop直接加20
}
else if((MIN < -aver) && (MAX > aver))
{
if((abs(Paticalmaxlabel - Paticalminlabel) >= 4)&&(fabs(MAX + MIN) < absMax / 4.0))
{
for(w = minlabel ; w <= maxlabel ; w++)
{
result[w +sframe + n/2] = 1 ; //移位复原
}
while(fabs(D[w]) >= fabs(absMin/3.0)&&(D[w] * D[maxlabel] > 0)) //选择该区域附近的渐变帧
{
result[w +sframe + n/2] = 1 ;
w ++ ;
}
result[w +sframe + n/2] = 1 ; //自定义扩大渐变区域以使镜头的划分覆盖更广
w = minlabel ;
while(fabs(D[w]) >= fabs(absMin/3.0)&&(D[w] * D[minlabel] > 0)) //选择该区域附近的渐变帧
{
result[w +sframe + n/2] = 1 ;
w -- ;
}
result[w +sframe + n/2] = 1 ; //自定义扩大渐变区域以使镜头的划分覆盖更广
loop = (((maxlabel + 20) <= (eframe - Window + 1))?(maxlabel+20) : (eframe - Window + 1));
}
}
}
/*for (loop = sframe ; loop < eframe ; loop++)
{
D[loop - sframe] = V1[loop - sframe + 2] - V1[loop - sframe + 1] ;
if (loop == sframe)
lenth = 1 ;
else if (D[loop - sframe] * D[loop - sframe - 1] > 0)
{
lenth ++ ;
}
else
lenth = 1;
if (lenth == alfa)
{
for (int j = loop - alfa + 1 ;j <= loop ; j++)
{
result[j] = 1 ;
}
}
else if (lenth > alfa)
{
result[loop] = 1 ;
}
}
float head = 0.0 ;
float tail = 0.0 ;
//以下循环用来丢弃平滑区域
for(loop = sframe ; loop <= eframe ; loop++)
{
if(loop > sframe)
{
if((result[loop] == 1)&&(result[loop - 1] == 0))
{
head = V1[sframe - loop + 1] ;
}
else if((result[loop] == 1)&&(result[loop + 1] == 0))
{
tail = V1[sframe - loop + 1] ;
}
if(head != 0 && tail != 0)
{
int min = ((head < tail)? head : tail) ;
if(abs(head - tail) < min / 3.0)
{
int j = loop ;
while(result[j] != 0)
{
result[j] = 0 ;
j -- ;
}
}
head = 0 ;
tail = 0 ;
}
}
else
{
if(result[loop] == 1)
{
head = V1[sframe - loop + 1] ;
}
}
}
//用于合并间隔小于beta的两端区间
lenth = 0 ;
for(loop = sframe ; loop <= eframe ; loop++)
{
if(loop == sframe)
{
do{
loop ++ ;
}while(result[loop] == 0 && loop <= eframe && result[loop - 1] == 1);
lenth ++ ;
}
else
{
if(result[loop] == 0)
{
lenth ++ ;
}
else if(result[loop] == 1 && result[loop - 1] == 0)
{
if(lenth < beta)
{
int j = loop - 1 ;
do{
result[j] = 1 ;
j --;
}while(result[j] == 0);
}
lenth = 0 ;
}
}
}
//以下统计区间长度，剔除长度小于gama的区间
for(loop = sframe ; loop <= eframe ; loop++)
{
if(loop == sframe)
{
if(result[loop] == 1)
{
head = loop ;
}
}
else
{
if((result[loop] == 1)&&(result[loop - 1] == 0))
{
head = loop ;
}
else if((result[loop] == 1)&&(result[loop + 1] == 0))
{
tail = loop ;
if(tail - head + 1 <= gama)
{
for(int j = head ; j <= tail ; j++)
{
result[j] = 0 ;
}
}
}
}
}*/
}