精华内容
下载资源
问答
  • complex_t 编写函数以计算两个复杂变量的和,,乘积和除法。
  • ICA去除EEG中眼动伪差和工频干扰方法研究,万柏坤,朱欣,眼动伪差和工频干扰是临床脑电图(EEG)中常见噪声,严重影响其有用信息提取。本文尝试采用独立分量分析(Independent Component Analysis, ICA)方
  • 利用分去除突变值

    千次阅读 2018-12-18 08:47:28
    今天同学问我去除一堆数据里的异常值(突然上升、突然下降)有什么好的算法,并附有一张截图: 这些突然变化的点就是需要检测出来 ...本文中设置的阈值是3-3,只有前一个分值后一个分值是一正一负,或者...

    今天同学问我去除一堆数据里的异常值(突然上升、突然下降)有什么好的算法,并附有一张截图:
    这里写图片描述
    这些突然变化的点就是需要检测出来 的点。

    针对这个问题,首先想到的是出现奇异值的时候与前一个点和后一个点是有很大的变化的,因此,用差分应该是管用的,差分后的结果是:

    这里写图片描述

    只需要设置一个阈值,就可以将大部分的‘变异值’过滤掉

    本文中设置的阈值是3和-3,只有前一个差分值和后一个差分值是一正一负,或者是一负一正的情况下才能认为是发生了突变,具体的程序如下所示:

    length = len(d_diff)
    
    temp = []
    for i in range(length-1):
        if d_diff[i]>3 and d_diff[i+1]<-3:
            #temp.append(i+1)
            print i+1
            
        if d_diff[i]<-3 and d_diff[i+1]>3:
            #print i+1
            temp.append(i+1)
            
    a = data.drop(temp)
    

    过滤后的结果如下所示:

    这里写图片描述

    从图中对比可得,通过引入差分过滤方式,可以快速有效地将大部分的异常值删除并记录下来。

    展开全文
  • :跟差不多 乘:计算的过程基本上列竖式做乘法相同。为编程方便,并不急于处理进位,而将进位问题留待最后统一处理 :基本的思想是反复做减法,看看从被数里最多能减去多少个除数,商就是多少。一个一个减...


    思想:

    用字符串来控制输入,数组来存储,数组的低位存整数的低位,高位来存储高位,

    和:计算的过程基本上和小学生列竖式做加法相同。

    差:跟和差不多

    乘:计算的过程基本上和列竖式做乘法相同。为编程方便,并不急于处理进位,而将进位问题留待最后统一处理

    除:基本的思想是反复做减法,看看从被除数里最多能减去多少个除数,商就是多少。一个一个减显然太慢,如何减得更快一些呢?以7546除以23 为例来看一下:开始商为0。先减去23 的100 倍,就是2300,发现够减3 次,余下646。于是商的值就增加300。然后用646 减去230,发现够减2次,余下186,于是商的值增加20。最后用186 减去23,够减8 次因此最终商就是328。

    n的核心是要写一个大整数的减法函数,然后反复调用该函数进行减法操作。 计算除数的10倍、100 倍的时候,不用做乘法,直接在除数后面补0 即可。

    void sum(char *str1,char *str2,int MAX_LEN);
    void substract(char *str1,char *str2,int MAX_LEN);
    void product(char *str1,char *str2,int MAX_LEN);
    void divide(char *str1,char *str2,int MAX_LEN);
    
    int main(int argc, const char * argv[])
    {
    
        const int MAX_LEN = 200;
        
        char str1[MAX_LEN],str2[MAX_LEN];
        
        scanf("%s",str1);
        scanf("%s",str2);
        
        printf("和:");
            sum(str1,str2,MAX_LEN);
        printf("差:");
            substract(str1,str2,MAX_LEN);
        printf("乘:");
            product(str1,str2,MAX_LEN);
        printf("除:");
            divide(str1,str2,MAX_LEN);
     
        return 0;
    }
    
    void sum(char *str1,char *str2,int MAX_LEN)//加
    {
        //    求两个不超过100位的非负整数的和
        
        int arr1[MAX_LEN];
        int arr2[MAX_LEN];
        
        memset(arr1,0,sizeof(arr1));//对数组进行清零
        memset(arr2,0,sizeof(arr2));
        
        int strlen1 =(int)strlen(str1);
        int strlen2 =(int)strlen(str2);
        
        int i,j;
        for(i=0,j=strlen1-1;j>=0;i++,j--)//把字符串的字符转换为数字后
            arr1[i]=str1[j]-'0';            //从后往前传递给数组
        for(i=0,j=strlen2-1;j>=0;i++,j--)
            arr2[i]=str2[j]-'0';
        
        for(i=0;i<MAX_LEN;i++)//按位相加
        {
            arr1[i]+=arr2[i];//数组arr1保存运算后的结果
            if(arr1[i]>=10) //按10进位
            {
                arr1[i]-=10;
                arr1[i+1]++;//进位
            }
        }
        
        for(i=MAX_LEN-1;(i>=0)&&(arr1[i]==0);i--);//从数组后面往前输出,即为结果
        if(i>=0)
            for(;i>=0;i--)
                printf("%d",arr1[i]);
        else
            printf("0");
        printf("\n");
    }
    void substract(char *str1,char *str2,int MAX_LEN)//减
    {
        //    求两个不超过100位的非负整数的差
        
        int arr1[MAX_LEN];
        int arr2[MAX_LEN];
        
        memset(arr1,0,sizeof(arr1));//对数组进行清零
        memset(arr2,0,sizeof(arr2));
        
        int strlen1 =(int)strlen(str1);
        int strlen2 =(int)strlen(str2);
        
        int i,j;
        for(i=0,j=strlen1-1;j>=0;i++,j--)//把字符串的字符转换为数字后
            arr1[i]=str1[j]-'0';            //从后往前传递给数组
        for(i=0,j=strlen2-1;j>=0;i++,j--)
            arr2[i]=str2[j]-'0';
        
        int nStartPos=0;
        for(i=0;i<MAX_LEN;i++)//按位相减
        {
            arr1[i]-=arr2[i];//数组arr1保存运算后的结果
            if(arr1[i]<0) //借位
            {
                arr1[i]+=10;
                arr1[i+1]--;//借位
            }
            if(arr1[i])
                nStartPos=i;//记录最高位的位置
        }
        
    //    for(i=MAX_LEN-1;(i>=0)&&(arr1[i]==0);i--);//从数组后面往前输出,即为结果
        i=nStartPos;
        if(i>=0)
            for(;i>=0;i--)
                printf("%d",arr1[i]);
        else
            printf("0");
        printf("\n");
    }
    void product(char *str1,char *str2,int MAX_LEN)//乘
    {
        //    求两个不超过100位的非负整数的积
        
        int arr1[MAX_LEN],arr2[MAX_LEN],arr3[2*MAX_LEN];
        
        for(int k=0;k<MAX_LEN;k++)arr1[k]=0;
        for(int k=0;k<MAX_LEN;k++)arr2[k]=0;
        for(int k=0;k<2*MAX_LEN;k++)arr3[k]=0;
        
        int i,j;
        int strlen1=(int)strlen(str1);
        int strlen2=(int)strlen(str2);
        
        for(i=0,j=strlen1-1;j>=0;i++,j--)//把字符串的字符转换为数字后
            arr1[i]=str1[j]-'0';            //从后往前传递给数组
        for(i=0,j=strlen2-1;j>=0;i++,j--)
            arr2[i]=str2[j]-'0';
        
        for(i=0;i<strlen2;i++)//用第二个数乘以第一个数
        {
            for(j=0;j<strlen1;j++)
                arr3[i+j]+=arr2[i]*arr1[j];//乘
        }
        for(i=0;i<MAX_LEN*2;i++)//进位
        {
            if(arr3[i]>=10)
            {
                arr3[i+1]+=arr3[i]/10;
                arr3[i]%=10;
            }
        }
        for(i=2*MAX_LEN-1;(arr3[i]==0)&&(i>=0);i--);
        if(i>=0)
            for(;i>=0;i--)
                printf("%d",arr3[i]);
        else
            printf("0");
        printf("\n");
    }
    void divide(char *str1,char *str2,int MAX_LEN)//除
    {
        int divide_sub( int * p1, int * p2, int strlen1, int strlen2);
        int arr1[MAX_LEN]; //被除数, arr1[0]对应于个位
        int arr2[MAX_LEN]; //除数, arr2[0]对应于个位
        int aResult[MAX_LEN]; //存放商,aResult[0]对应于个位
        //长度为 strlen1 的大整数p1 减去长度为strlen2 的大整数p2
        //结果放在p1 里,返回值代表结果的长度
        //如不够减返回-1,正好减完返回 0
        
        int i, j;
        int strlen1 = (int)strlen( str1);
        memset( arr1, 0, sizeof(arr1));
        memset( arr2, 0, sizeof(arr2));
        memset( aResult, 0, sizeof(aResult));
        
        for( j = 0, i = strlen1 - 1;i >= 0 ; i --)
            arr1[j++] = str1[i] - '0';
        int strlen2 = (int)strlen(str2);
        for( j = 0, i = strlen2 - 1;i >= 0 ; i --)
            arr2[j++] = str2[i] - '0';
        if( strlen1 < strlen2 )
        {
            printf("0\n");
        }
        int nTimes = strlen1 - strlen2;
        if(nTimes > 0)
        {
            for( i = strlen1 -1; i >= nTimes; i -- )
                arr2[i] = arr2[i-nTimes];//朝高位移动
            for( ; i >= 0; i--)//低位补0
                arr2[i] = 0;
            strlen2 = strlen1;
        }
        for( j = 0 ; j <= nTimes; j ++ )
        {
            int nTmp;
            //一直减到不够减为止
            //先减去若干个 arr2×(10 的 nTimes 次方),
            //不够减了,再减去若干个 arr2×(10 的 nTimes-1 次方),......
            while( (nTmp = divide_sub(arr1, arr2+j, strlen1, strlen2-j)) >= 0)
            {
                strlen1 = nTmp;
                aResult[nTimes-j]++; //每成功减一次,则将商的相应位加1
            }
        }
        //下面输出结果,先跳过高位0
        for( i = MAX_LEN-1; (i >= 0) && (aResult[i] == 0); i -- );
        if( i >= 0)
            for( ; i>=0; i--)
                printf("%d", aResult[i]);
        else
            printf("0");
        printf("\n");
    }
    int divide_sub( int * p1, int * p2, int strlen1, int strlen2)
    {
        int i;
        if( strlen1 < strlen2 )
            return -1;
        //下面判断p1 是否比p2 大,如果不是,返回-1
        if( strlen1 == strlen2 )
        {
            for( i = strlen1-1; i >= 0; i -- )
            {
                if( p1[i] > p2[i] )           break; //p1>p2
                else if( p1[i] < p2[i] )   return -1; //p1<p2
            }
        }
        for( i = 0; i < strlen1; i ++ )
        { //要求调用本函数确保当i>=strlen2 时,p2[i] = 0
            p1[i] -= p2[i];
            if( p1[i] < 0 )
            {
                p1[i]+=10;
                p1[i+1] --;
            }
        }
        for( i = strlen1 -1 ; i >= 0 ; i-- )
            if( p1[i] )//找到最高位第一个不为0
                return i + 1;
        return 0;//全部为0,说明两者相等
    }
    

    测试:

    666666666666666666666666666666666666666666666666666666666666666666

    22222222222222222222222222222222222222222222222222222222222222222

    和:688888888888888888888888888888888888888888888888888888888888888888

    差:644444444444444444444444444444444444444444444444444444444444444444

    乘:14814814814814814814814814814814814814814814814814814814814814814651851851851851851851851851851851851851851851851851851851851851852

    除:30


    展开全文
  • 1225余数之 F(n) = (n % 1) + (n % 2) + (n % 3) + ...... (n % n)。其中%表示Mod,也就是余数。 例如F(6) = 6 % 1 + 6 % 2 + 6 % 3 + 6 % 4 + 6 % 5 + 6 % 6 = 0 + 0 + 0 + 2 + 1 + 0 = ...
                                 1225 余数之和
     
    F(n) = (n % 1) + (n % 2) + (n % 3) + ...... (n % n)。其中%表示Mod,也就是余数。 
    例如F(6) = 6 % 1 + 6 % 2 + 6 % 3 + 6 % 4 + 6 % 5 + 6 % 6 = 0 + 0 + 0 + 2 + 1 + 0 = 3。
    给出n,计算F(n), 由于结果很大,输出Mod 1000000007的结果即可。
     
    Input
    输入1个数N(2 <= N <= 10^12)。
    Output
    输出F(n) Mod 1000000007的结果。
    Input示例
    6
    Output示例
    3
     
    我们知道 
    F(n)=n%1+n%2+n%3+n%4.......+n%n 
        =n-(n/1*1)+n-(n/2*2)+n-(n/3*3)+n-(n/4*4) ........+n-(n/n*n) (ps:这里的除法都是整数除法)
        =n*n-(n/1*1+n/2+2+n/3*3........+n/n*n) 
    由于 n/i 有 sqrt(n) 个不同的值
    对与 n/i 相同 就构成了如下的等差序列
        (n/i)*(i+(i+1)+(i+2)+(i+3)....+(i+m))
    以上等式中的 n/i n/(i+1) n/(i+2)  ....n/(i+m) 的值都相同 我们就可以使用等差数列求和公式 
    N*(A+B)/2  N为元素个数 A,B分别为数列的首项和最后一项 
    这个/2 相当于求在%意义下2的逆元 
     
    注意开longlong 
    注意取模 这个取模有毒!我在取模上WA了15次!!
     
     1 #include <cctype>
     2 #include <cstdio>
     3 #include <iostream>
     4 
     5 typedef long long LL;
     6 
     7 const int mod=1000000007;
     8 const int M=5e8+4;
     9 
    10 LL n,ans;
    11 
    12 int hh() {
    13     std::cin>>n;
    14     ans=n%mod*(n%mod)%mod;
    15     for(LL t,r,i=1;i<=n;++i) {
    16         t=n/i;
    17         r=n/t;
    18         ans=ans-((r-i+1)%mod*((r+i)%mod))%mod*M%mod*t%mod;
    19         while(ans<0) ans+=mod;
    20         i=r;
    21     }
    22     std::cout<<ans;
    23     return 0;
    24 }
    25 
    26 int sb=hh();
    27 int main(int argc,char**argv) {;}
    代码

     

     
     

    转载于:https://www.cnblogs.com/whistle13326/p/7650797.html

    展开全文
  • 视频处理:帧法、光流法背景减法的视频目标识别视频处理:帧法、光流法背景减法的视频目标识别视频处理:帧法、光流法背景减法的视频目标识别 1.调用摄像头 import numpy as np import cv2 cap = cv2...

    :视频处理:帧差法、光流法和背景减除法的视频目标识别


    1.调用摄像头

    在这里插入图片描述

    import numpy as np
    import cv2
    cap = cv2.VideoCapture(0)  # 0 使用默认的电脑摄像头
    while(True):
        #获取一帧帧图像
        ret, frame = cap.read()
        #转化为灰度图
        #gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        cv2.imshow('frame',frame)
        #按下“q”键停止
        if cv2.waitKey(1) & 0xFF == ord('q'): # cv2.waitKey(1) 1毫秒读一次
            break
    cap.release()
    cv2.destroyAllWindows()
    

    在这里插入图片描述


    2.保存视频

    import cv2
    
    #调用摄像头函数cv2.VideoCapture,参数0:系统摄像头
    cap = cv2.VideoCapture(0)
    #创建编码方式
    #mp4:'X','V','I','D'avi:'M','J','P','G'或'P','I','M','1' flv:'F','L','V','1'
    fourcc = cv2.VideoWriter_fourcc('F','L','V','1')
    
    #创建VideoWriter对象
    out = cv2.VideoWriter('output_1.flv',fourcc, 20.0, (640,480))  # 20.0 是帧率  (640,480)是宽和高,添加第五个参数 false可以保存灰度图
    #创建循环结构进行连续读写
    while(cap.isOpened()):
        ret, frame = cap.read()
        if ret==True:
            out.write(frame)
            cv2.imshow('frame',frame)
            if cv2.waitKey(1) & 0xFF == ord('q'):  
                break
        else:
            break
    cap.release()
    out.release()
    cv2.destroyAllWindows()
    
    

    在这里插入图片描述


    3.修改视频格式

    import numpy as np
    import cv2
    
    cap = cv2.VideoCapture('output_1.flv')
    fourcc = cv2.VideoWriter_fourcc('M','J','P','G')
    fps = cap.get(cv2.CAP_PROP_FPS)
    print(fps)
    
    
    # 视频图像的宽度
    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    # 视频图像的长度
    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    print(frame_width)
    print(frame_height)
    #创建VideoWriter对象
    out = cv2.VideoWriter('output_1_new.avi',fourcc, fps,(frame_width,frame_height))
    while(True):
        ret, frame = cap.read()
        if ret==True:
            # 水平翻转
            frame = cv2.flip(frame,1)
            out.write(frame)
            cv2.imshow('frame',frame)
            if cv2.waitKey(25) & 0xff == ord('q'):
                break
        else:
            break
    out.release()
    cap.release()
    cv2.destroyAllWindows()
    
    

    4.帧差法

    • 帧间差分法是通过对视频中相邻两帧图像做差分运算来标记运动物体的方法。
    • 当视频中存在移动物体的时候,相邻帧(或相邻三帧)之间在灰度上会有差别,求取两帧图像灰度差的绝对值,则静止的物体在差值图像上表现出来全是0,而移动物体特别是移动物体的轮廓处由于存在灰度变化为非0。
    # 导入必要的软件包 
    import cv2 
     
    # 视频文件输入初始化 
    filename = "move_detect.flv" 
    camera = cv2.VideoCapture(filename) 
     
    # 视频文件输出参数设置 
    out_fps = 12.0  # 输出文件的帧率 
    fourcc = cv2.VideoWriter_fourcc('M', 'P', '4', '2') 
    out1 = cv2.VideoWriter('E:/video/v1.avi', fourcc, out_fps, (500, 400)) 
    out2 = cv2.VideoWriter('E:/video/v2.avi', fourcc, out_fps, (500, 400)) 
     
    # 初始化当前帧的前帧 
    lastFrame = None 
     
    # 遍历视频的每一帧 
    while camera.isOpened(): 
     
        # 读取下一帧 
        (ret, frame) = camera.read() 
     
        # 如果不能抓取到一帧,说明我们到了视频的结尾 
        if not ret: 
            break 
     
        # 调整该帧的大小 
        frame = cv2.resize(frame, (500, 400), interpolation=cv2.INTER_CUBIC) 
     
        # 如果第一帧是None,对其进行初始化 
        if lastFrame is None: 
            lastFrame = frame 
            continue 
     
        # 计算当前帧和前帧的不同 
        frameDelta = cv2.absdiff(lastFrame, frame) 
     
        # 当前帧设置为下一帧的前帧 
        lastFrame = frame.copy() 
     
        # 结果转为灰度图 
        thresh = cv2.cvtColor(frameDelta, cv2.COLOR_BGR2GRAY) 
     
        # 图像二值化 
        thresh = cv2.threshold(thresh, 25, 255, cv2.THRESH_BINARY)[1] 
     
        ''' 
        #去除图像噪声,先腐蚀再膨胀(形态学开运算) 
        thresh=cv2.erode(thresh,None,iterations=1) 
        thresh = cv2.dilate(thresh, None, iterations=2) 
        ''' 
     
        # 阀值图像上的轮廓位置 
        cnts, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) 
     
        # 遍历轮廓 
        for c in cnts: 
            # 忽略小轮廓,排除误差 
            if cv2.contourArea(c) < 300: 
                continue 
     
            # 计算轮廓的边界框,在当前帧中画出该框 
            (x, y, w, h) = cv2.boundingRect(c) 
            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) 
     
        # 显示当前帧 
        cv2.imshow("frame", frame) 
        cv2.imshow("frameDelta", frameDelta) 
        cv2.imshow("thresh", thresh) 
     
        # 保存视频 
        out1.write(frame) 
        out2.write(frameDelta) 
     
        # 如果q键被按下,跳出循环 
        if cv2.waitKey(20) & 0xFF == ord('q'): 
            break 
    # 清理资源并关闭打开的窗口 
    out1.release() 
    out2.release() 
    camera.release() 
    cv2.destroyAllWindows()
    

    在这里插入图片描述

    在这里插入图片描述


    5.光流法

    import cv2 as cv
    import numpy as np
    
    es = cv.getStructuringElement(cv.MORPH_ELLIPSE, (10, 10))
    kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, (3, 3))
    cap = cv.VideoCapture("move_detect.flv")
    frame1 = cap.read()[1]
    prvs = cv.cvtColor(frame1, cv.COLOR_BGR2GRAY)
    hsv = np.zeros_like(frame1)
    hsv[..., 1] = 255
    
    # 视频文件输出参数设置
    out_fps = 12.0  # 输出文件的帧率
    fourcc = cv.VideoWriter_fourcc('M', 'P', '4', '2')
    sizes = (int(cap.get(cv.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)))
    out1 = cv.VideoWriter('E:/video/v6.avi', fourcc, out_fps, sizes)
    out2 = cv.VideoWriter('E:/video/v8.avi', fourcc, out_fps, sizes)
    
    while True:
        (ret, frame2) = cap.read()
        next = cv.cvtColor(frame2, cv.COLOR_BGR2GRAY)
        flow = cv.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2, 0)
        mag, ang = cv.cartToPolar(flow[..., 0], flow[..., 1])
        hsv[..., 0] = ang * 180 / np.pi / 2
        hsv[..., 2] = cv.normalize(mag, None, 0, 255, cv.NORM_MINMAX)
    
        bgr = cv.cvtColor(hsv, cv.COLOR_HSV2BGR)
    
        draw = cv.cvtColor(bgr, cv.COLOR_BGR2GRAY)
        draw = cv.morphologyEx(draw, cv.MORPH_OPEN, kernel)
        draw = cv.threshold(draw, 25, 255, cv.THRESH_BINARY)[1]
    
        image, contours, hierarchy = cv.findContours(draw.copy(), cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    
        for c in contours:
            if cv.contourArea(c) < 500:
                continue
            (x, y, w, h) = cv.boundingRect(c)
            cv.rectangle(frame2, (x, y), (x + w, y + h), (255, 255, 0), 2)
    
        cv.imshow('frame2', bgr)
    
        cv.imshow('draw', draw)
        cv.imshow('frame1', frame2)
        out1.write(bgr)
        out2.write(frame2)
    
        k = cv.waitKey(20) & 0xff
        if k == 27 or k == ord('q'):
            break
        elif k == ord('s'):
            cv.imwrite('opticalfb.png', frame2)
            cv.imwrite('opticalhsv.png', bgr)
        prvs = next
    
    out1.release()
    out2.release()
    cap.release()
    cv.destroyAllWindows()
    

    在这里插入图片描述

    6.背景减除法

    import numpy as np
    import cv2
    
    # read the video
    cap = cv2.VideoCapture('move_detect.flv')
    
    # create the subtractor
    fgbg = cv2.createBackgroundSubtractorMOG2(
        history=500, varThreshold=100, detectShadows=False)
    
    
    def getPerson(image, opt=1):
    
        # get the front mask
        mask = fgbg.apply(frame)
    
        # eliminate the noise
        line = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 5), (-1, -1))
        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, line)
        cv2.imshow("mask", mask)
    
        # find the max area contours
        out, contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        for c in range(len(contours)):
            area = cv2.contourArea(contours[c])
            if area < 150:
                continue
            rect = cv2.minAreaRect(contours[c])
            cv2.ellipse(image, rect, (0, 255, 0), 2, 8)
            cv2.circle(image, (np.int32(rect[0][0]), np.int32(rect[0][1])), 2, (255, 0, 0), 2, 8, 0)
        return image, mask
    
    
    while True:
        ret, frame = cap.read()
        cv2.imwrite("input.png", frame)
        cv2.imshow('input', frame)
        result, m_ = getPerson(frame)
        cv2.imshow('result', result)
        k = cv2.waitKey(20)&0xff
        if k == 27:
            cv2.imwrite("result.png", result)
            cv2.imwrite("mask.png", m_)
    
            break
    cap.release()
    cv2.destroyAllWindows()
    

    在这里插入图片描述


    展开全文
  • 由于统计需求,要求计算2个时间,并且要求去除节假日周末的时间。 说一下需求规则: 1、如果开始时间结束时间在一个休假时间段内,时间为0,比如10.2到10.4这种。 2、其他情况,只计算在休假时间外的。 ...
  • Excel标准_计算函数StdevStdevP的使用方法Excel标准核算共有六个函数,它们分别用于核算样本标准差和整体标准,其间一些函数只能核算数值,另一些函数能核算数值外还能核算文本逻辑值。另外,假如要求...
  • 正文如下: 各种运算符如下: ...数据库的传统集合运算包括:并、、交、笛卡尔积运算。这四种运算都与数学上的同名运算概念相似。 并: : 交: 笛卡尔积: 广义笛卡尔积(Extended Cartes...
  • } 分 一维分是前缀的逆 #include using namespace std; const int N = 100010; int n,m; int a[N],b[N]; void insert(int l,int r,int c) { b[l]+=c; b[r+1]-=c; } int main() { scanf("%d%d",&n,&...
  • 有限分方法(Finite Differential Method)有限分方法是计算机数值模拟最早采用的方法,至今仍被广泛运用。该方法将求解域划分为分网格,用有限个网格节点代替连续的求解域。有限分法以泰勒级数展开等方法,把...
  • 利用前景目标区域、阴影区域背景区域像素亮度值存在差异的特点, 检测去除背景分图像中可能存在的阴影, 获得准确的运动目标。在室内夜间环境下采集视频进行试验, 结果验证了所提方法的有效性。
  • 法、光流法、背景减

    千次阅读 2013-12-31 21:02:11
    法、光流法、背景减除法 运动目标检测是指在序列图像中检测出变化区域并将运动目标从背景图像中提取出来。通常情况下,目标分类、跟踪行为理解等后处理过程仅仅考虑图像中对应于运动目标的像素区域,因此运动...
  • C++程序设计(第三版) 谭浩强 习题10.2 个人设计 ...编程序,分别求两个复数之、积商。 代码块: #include &amp;lt;iostream&amp;gt; using namespace std; class Complex { ...
  • 【问题描述】 定义一个复数类Complex,重载...编写程序,分别求两个复数之、积商。 Input 两个复数 Output 两个复数之、积商 Sample Input 3 4 5 -10 Sample Output c1+c2=(8.00,-6.00i) c1-c2=(-...
  • 代码:对于隐藏层的参数wb的初始化 self.params[ ' W1 ' ] = weight_scale * np.random.randn(input_dim, hidden_dim) self.params[ ' b1 ' ] = np.zeros((1 , hidden_dim)) self.params[ ' W2 ' ] = ...
  • JS的定时器清除定时器

    千次阅读 2019-06-10 09:52:14
    在我们的项目开发中,难免会需要按周期执行一些代码,这就需要定时器这个功能。 常用的定时器有2种 ...//需要注意的是这里说的一秒是大约一秒,定时器还是会有细微的时间 下面通过一个小demo来看一下效果 &l...
  • 本文讨论一种用于光学系统光学反射镜面检验中的完整而定量的方法....由此函数出发本文讨论了检验系统本身误差及调整误差去除的方法及计算被检波面的最小均方波及波分布,进而求得系统的PSFOTF值.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,478
精华内容 991
关键字:

和除差