精华内容
下载资源
问答
  • 模2除法原理

    2011-10-07 21:04:14
    模2除法,我刚刚费了很大的劲才找到的,但愿对大家有用,谢谢!
  • 与四则运算相同,模2运算也包括模2加、模2减、模2乘、模2除四种二进制运算。而且,模2运算也使用与四则运算相同的运算符,即“+”表示模2加,“-”表示模2减,“×”或“·”表示模2乘,“÷”或“/”表示模2除。...

    模2运算是一种二进制算法,CRC校验技术中的核心部分,因此,我们在分析CRC算法之前,必须掌握模2运算的规则。与四则运算相同,模2运算也包括模2加、模2减、模2乘、模2除四种二进制运算。而且,模2运算也使用与四则运算相同的运算符,即“+”表示模2加,“-”表示模2减,“×”或“·”表示模2乘,“÷”或“/”表示模2除。与四则运算不同的是模2运算不考虑进位和借位,即模2加法是不带进位的二进制加法运算,模2减法是不带借位的二进制减法运算。这样,两个二进制位相运算时,这两个位的值就能确定运算结果,不受前一次运算的影响,也不对下一次造成影响。

    ①模2加法运算定义为:
    0+0=0 0+1=1 1+0=1 1+1=0
    例如0101+0011=0110,列竖式计算:
    0 1 0 1
    +0 0 1 1
    ──────
    0 1 1 0

    ②模2减法运算定义为:
    0-0=0 0-1=1 1-0=1 1-1=0
    例如0110-0011=0101,列竖式计算:
    0 1 1 0
    -0 0 1 1
    ──────
    0 1 0 1

    ③模2乘法运算定义为:
    0×0=0 0×1=0 1×0=0 1×1=1
    多位二进制模2乘法类似于普通意义上的多位二进制乘法,不同之处在于后者累加中间结果(或称部分积)时采用带进位的加法,而模2乘法对中间结果的处理方式采用的是模2加法。例如1011×101=100111,列竖式计算:
    1 0 1 1
    × 1 0 1
    ──────
    1 0 1 1
    0 0 0 0

    1 0 1 1
    ────────
    1 0 0 1 1 1

    ④模2除法运算定义为:
    0÷1=0 1÷1=1
    多位二进制模2除法也类似于普通意义上的多位二进制除法,但是在如何确定商的问题上两者采用不同的规则。后者按带借位的二进制减法,根据余数减除数够减与否确定商1还是商0,若够减则商1,否则商0。多位模2除法采用模2减法,不带借位的二进制减法,因此考虑余数够减除数与否是没有意义的。实际上,在CRC运算中,总能保证除数的首位为1,则模2除法运算的商是由余数首位与除数首位的模2除法运算结果确定。

    当余数位数与除数位数相同时,才进行异或运算,余数首位是1,商就是1,余数首位是0,商就是0。当已经除了几位后,余数位数小于除数,商0,余数往右补一位,位数仍比除数少,则继续商0,当余数位数和除数位数一样时,商1,进行异或运算,得新的余数,以此至被除数最后一位。

    因为除数首位总是1,按照模2 除法运算法则,那么余数首位是1就商1,是0就商0。例如1100100÷1011=1110……110,列竖式计算:
    1 1 1 0
    ────────
    1 0 1 1〕1 1 0 0 1 0 0
    - 1 0 1 1
    ──────
    1 1 1 1
    - 1 0 1 1
    ──────
    1 0 0 0
    - 1 0 1 1
    ──────
    0 1 1 0
    -0 0 0 0
    ──────
    1 1 0

    展开全文
  • 对于利用LFSR实现模2除法原理,不解,找了很多资料,没有一个讲明白的,下面的一个算是有那么一点靠谱的,先记下来,以后有时间了沿着这个思路慢慢推导吧! 转自:...

    对于利用LFSR实现模2除法的原理,不解,找了很多资料,没有一个讲明白的,下面的一个算是有那么一点靠谱的,先记下来,以后有时间了沿着这个思路慢慢推导吧!

    转自:http://www.elecfans.com/dianzichangshi/2009101396345.html

    实现模2除法的线路

      循环校验码的核心逻辑线路是实现模2除的线路。按照前面介绍的方法,可将模2除的步骤分解归纳为两种操作:如果被除数或者余数最高位的值为0,直接将余数左移一位;如果被除数或部分余数最高位的值为1,用生成多项式G(x)作模2减,然后余数左移一位。


    2.2 实现模2除的逻辑图

      对前述用G(x)=1011产生(7,4)校验码的例子,可采用图2.2所示线路,产生3位的余数。图中的模2减用异或门实现,左移一位由移位寄存器实现;用异或门的输出控制左边一位寄存器的D输入端,可同时实现模2减和左移。用最左一位的取值控制是否做模2减,当其为1时,减去的数就是生成多项式G(x)=1011。这里,被除数D是逐位串行送到移位寄存器的,且由CP脉冲同步。


     
     
    图2.3 实现G(x)=1011的线性(7,4)分组码模2除线路图

      由于G(x)固定不变,故G2可省去;只求三位余数,故G3和T0也失去意义。图2.2可简化为图2.3(a)。
    对图2.3(a)的线路来说,在发送端,输入信息码D为1100,串行从低位送入,先左移三位形成1100000,再通过7步模2除,可在移位寄存器 T3 T2 T1 中得到余数010;在接收端,对7位的CRC码字1100010,执行7步模2除之后,若在 T3 T2 T1 得到000,表明CRC码字中无任何一位出错;若余数不为全0,可根据表2.4确定出错位置。

      设Ti为T3T2T1某触发器当前状态,Ti'为次态,可用次态方程表示图2.3(a)的模2除电路: T3'=T2, T2'=T3⊕T1 , T1'=T3⊕D。
    分别用被除数1100000和1010000验证取得余数为010和011的工作过程,见表2.6。读者可用模2除竖式计算各步结果并与之比较。 
    表2.6 图2.3(a)线路工作过程举例
    步骤
    信息码1100
    信息码1010
    输入D TTT
    输入D TTT
    初态
    1
    2
    3
    4
    5
    6
    7
     0  000
     1  001
     1  011
     0  110
     0  111
     0  101
     0  001
     0  010
     0  000
     1  001
     0  010
     1  101
     0  001
     0  010
     0  100
     0  011

      可以将图2.3(a)的线路稍加变化,即得到图2.3(b)的线路,用作为G(x)=1011的系统线性(7,4)分组码的编码线路。待编码信息D由高位端送入,CRC码由T送出。开始时,开关K1闭合,K2打到b位置,输入信息进入除法线路的同时送到T输出。经过4步之后,T3T2T1即为余数。然后,K1断开,K2打到a,T3T2T1只有移位功能,正好将余数拼接在信息码后经T送出。图2.3(b)中,开关K1闭合,K2打到b,T3T2T1及输出T可表达为: T=b=D, T3'=T2 , T2' =T1⊕T3⊕D, T1'=T3⊕D 。 当开关K1断开,K2打到a,T3T2T1及输出T可表达为: T=a=T3⊕D=T3(D为0), T3'=T2, T2' =T1, T1' =0。信息码为1100和1010取得的CRC码1100010和1010011的工作过程见表2.7。

    表2.7 图2.3(b)线路编码过程举例
    步骤
    信息码1100
    信息码1010
    输入D TTT 输出T
    输入D TTT 输出T
    初态
    1
    2
    3
    4
    5
    6
    7
    0  000  0
    1  011  1
    1  101  1
    0  001  0
    0  010  0
    0  100  0
    0  000  1
    0  000  0
    0  000  0
    1  011  1
    0  110  0
    1  100  1
    0  011  0
    0  110  0
    0  100  1
    0  000  1

    展开全文
  • 与四则运算相同,模2运算也包括模2加、模2减、模2乘、模2除四种二进制运算。而且,模2运算也使用与四则运算相同的运算符,即“+”表示模2加,“-”表示模2减,“×”或“·”表示模2乘,“÷”或“/”表示模2除。...

    模2运算是一种二进制算法,CRC校验技术中的核心部分,因此,我们在分析CRC算法之前,必须掌握模2运算的规则。与四则运算相同,模2运算也包括模2加、模2减、模2乘、模2除四种二进制运算。而且,模2运算也使用与四则运算相同的运算符,即“+”表示模2加,“-”表示模2减,“×”或“·”表示模2乘,“÷”或“/”表示模2除。与四则运算不同的是模2运算不考虑进位和借位,即模2加法是不带进位的二进制加法运算,模2减法是不带借位的二进制减法运算。这样,两个二进制位相运算时,这两个位的值就能确定运算结果,不受前一次运算的影响,也不对下一次造成影响。


    模2加法运算定义为:
    0+0=0        0+1=1        1+0=1        1+1=0
    例如0101+0011=0110,列竖式计算:
       0 1 0 1
    + 0 0 1 1
    ──────
       0 1 1 0


    模2减法运算定义为:
    0-0=0        0-1=1        1-0=1        1-1=0
    例如0110-0011=0101,列竖式计算:
       0 1 1 0
    -  0 0 1 1
    ──────
       0 1 0 1


    模2乘法运算定义为:
    0×0=0        0×1=0        1×0=0        1×1=1
    多位二进制模2乘法类似于普通意义上的多位二进制乘法,不同之处在于后者累加中间结果(或称部分积)时采用带进位的加法,而模2乘法对中间结果的处理方式采用的是模2加法。例如1011×101=100111,列竖式计算:
           1 0 1 1
         ×  1 0 1
        ──────
                1 0 1 1
         0 0 0 0
    + 1 0 1 1
    ────────
       1 0 0 1 1 1


    模2除法运算定义为:
    0÷1=0        1÷1=1
    多位二进制模2除法也类似于普通意义上的多位二进制除法,但是在如何确定商的问题上两者采用不同的规则。后者按带借位的二进制减法,根据余数减除数够减与否确定商1还是商0,若够减则商1,否则商0。多位模2除法采用模2减法,不带借位的二进制减法,因此考虑余数够减除数与否是没有意义 的。实际上,在CRC运算中,总能保证除数的首位为1,则模2除法运算的商是由余数首位与除数首位的模2除法运算结果确定。因为除数首位总是1,按照模2 除法运算法则,那么余数首位是1就商1,是0就商0。例如1100100÷1011=1110……110,列竖式计算:
                   1 1 1 0
           ────────
    1 0 1 1〕1 1 0 0 1 0 0
           1 0 1 1
          ──────
               1 1 1 1
            - 1 0 1 1
           ──────
                 1 0 0 0
              - 1 0 1 1
             ──────
                   0 1 1 0
                - 0 0 0 0
               ──────
                     1 1 0

    展开全文
  • python基于背景模型差的视频目标追踪帧差的问题:背景模型差目标追踪原理1. 基本思路:2. 图例讲解:3. 存在的问题&如何解决:4. 最终效果预览第一步——调用摄像头:1. 使用opencv打开视频or摄像头:2. ...

    帧差法的问题:

    在这里插入图片描述
    这是相邻帧差法的效果,运动物体有双重轮廓、空洞等现象现象影响观察;

    并且不运动或者运动较小的物体,也难以检测到;

    背景模型减除法目标追踪原理

    1. 基本思路:

    不同于帧差法前后两帧图片的像素差来确定运动物体,背景模型差法希望通过建立背景模型,然后再将每帧图片与背景模型作差,即可得到运动物体的轮廓。

    2. 图例讲解:

    我们使用opencv自带的测试视频来讲解:
    在这里插入图片描述
    我们希望的背景是这样的,及不包含任何目标的空背景图:
    在这里插入图片描述
    对于视频中运动目标,运动的目标区域会有相应变化,这样再与背景图作差,就可以得到运动目标的区域。

    这样的话,我们只需要检测到视频中相比于背景图片像素有较大变化的区域,就可以实现一个简单的运动物体检测;

    3. 存在的问题&如何解决:

    当然这里还有许多问题需要解决

    1. 视频中并不会出现空背景图,那么将如何去重建?
    2. 如何将目标区域选定出来?(比如用矩形框圈出来)
    3. 如何去掉重叠的矩形框或者筛选出合适的矩形框?
    4. 以及如何用代码实现?

    下面会一一讲解:

    4. 最终效果预览

    在这里插入图片描述

    第一步——调用摄像头:

    1. 使用opencv打开视频or摄像头:

    其中video_index是摄像头编号,一般前置摄像头为0,USB摄像头为1或2,使用时会打开摄像头;如果输入的是视频路径,则会读取视频。

    # open_camera.py
    import cv2
    
    def catch_video(name='my_video', video_index=0):
    
        # cv2.namedWindow(name)
    
        cap = cv2.VideoCapture(video_index) # 创建摄像头识别类
    
        if not cap.isOpened():
            # 如果没有检测到摄像头,报错
            raise Exception('Check if the camera is on.')
    
        while cap.isOpened():        
            catch, frame = cap.read()  # 读取每一帧图片
            
    	# ————————————————————————————————
    	# 处理图片
    	# ————————————————————————————————
    
            cv2.imshow(name, frame) # 在window上显示图片
    
            key = cv2.waitKey(10)
    
            if key & 0xFF == ord('q'):
                # 按q退出
                break
    
            if cv2.getWindowProperty(name, cv2.WND_PROP_AUTOSIZE) < 1:
                # 点x退出
                break
    
        # 释放摄像头
        cap.release()
        cv2.destroyAllWindows()
    
    if __name__ == "__main__":    
    
        catch_video('./test.avi')
    
    

    这样的话我们就成功地打开了视频:
    在这里插入图片描述

    2. 读取逐帧图片:

    在程序运行期间,opencv会不断读取输入的每一帧图片,再将图片进行一定处理,不断显示在window上:
    在这里插入图片描述
    这里使用了read方法,返回的frame就是某一时刻视频的图片。

    第二步——处理图片:

    1. 转换成灰度图:

    对读取到的每一帧图片,我们首先转换成灰度图:

    catch, frame = cap.read()  # 读取每一帧图片
    
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 转换成灰度图
    

    在这里插入图片描述

    3. 累加权重重构背景:

    我们通过权重累加前面的每一帧图片,重构视频背景:

    dialta = 0.9
    
    background = background*dialta + gray*(1-dialta)
    

    dialta 参数就是前面累加背景的权重。

    dialta = 0.9 的背景图:
    在这里插入图片描述

    dialta = 0.95 的背景图:

    在这里插入图片描述

    3. 计算像素差:

    然后我们计算视频中这一帧图片与重构背景图像素的绝对值差:

    gray_diff = cv2.absdiff(gray, background) # 计算绝对值差
    # background 是上一帧图片的灰度图
    

    在这里插入图片描述

    其中黑色区域是由于像素相同得0,灰色区域越接近白色,表示两帧图片该点的像素差越大。

    再将帧差图进行二值化,即图片像素差大于某一阙值(我们这里定为40)的标注为运动点,赋值为255(白色),其余点赋值为0(黑色):

    _, mask = cv2.threshold(                
    	gray_diff, 40, 255, cv2.THRESH_BINARY)
    

    得到的二值化图为:

    在这里插入图片描述

    3. 使用中值滤波和膨胀腐蚀去噪:

    这时候我们虽然得到了帧差图的二值化图,但图中有许多干扰是我们不想要的:
    在这里插入图片描述

    这时候我们就需要通过一定的方法去噪;

    3.1 中值滤波:

    mask = cv2.medianBlur(mask, 3) # 中值滤波
    

    中值滤波是一种图像平滑处理算法,基本原理就是,测试像素周围邻域像素集中的中值代替原像素,能够有效去除孤立的噪声点或较细的噪声线;

    使用中值滤波前后对比:

    在这里插入图片描述

    可以看到一部分噪声已经被去除了,图像也变得更加平滑。

    3.2 图像腐蚀和膨胀:

    腐蚀和膨胀具体原理可以看一下这篇博客:
    数字图像处理(六)形态学处理之腐蚀、膨胀、开运算、闭运算

    腐蚀和膨胀也是图片平滑处理的一种算法,一般先腐蚀再膨胀能够有效去除干扰线:

    es = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 4))
    m = cv2.erode(median, es, iterations=2) # 膨胀
    m = cv2.dilate(m, es, iterations=2) # 腐蚀
    

    处理前后对比:
    在这里插入图片描述

    4. 视频处理效果:

    完整代码:

    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    class Detector(object):
    
        def __init__(self, name='my_video'):
    
            self.name = name
    
            self.threshold = 40
    
            self.es = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 4))
    
        def catch_video(self, video_index=0):
    
            # cv2.namedWindow(name)
    
            cap = cv2.VideoCapture(video_index)  # 创建摄像头识别类
    
            if not cap.isOpened():
                # 如果没有检测到摄像头,报错
                raise Exception('Check if the camera is on.')
    
            frame_num = 0
    
            while cap.isOpened():
    
                catch, frame = cap.read()  # 读取每一帧图片
    
                if not catch:
    
                    raise Exception('Error.')
    
                if not frame_num:
                    # 这里是由于第一帧图片没有前一帧
                    previous = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 转换成灰度图
    
                gray = cv2.absdiff(gray, previous)  # 计算绝对值差
    
                gray = cv2.medianBlur(gray, 3)  # 中值滤波
    
                ret, mask = cv2.threshold(
                    gray, self.threshold, 255, cv2.THRESH_BINARY)
    
    
                mask = cv2.erode(mask, self.es, iterations=1)
                mask = cv2.dilate(mask, self.es, iterations=1)
    
                cv2.imshow(self.name, frame)  # 在window上显示图片
                cv2.imshow(self.name+'_frame', mask)  # 边界
    
                previous = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                frame_num += 1
    
                key = cv2.waitKey(10)
    
                if key & 0xFF == ord('q'):
                    # 按q退出
                    break
    
                if cv2.getWindowProperty(self.name, cv2.WND_PROP_AUTOSIZE) < 1:
                    # 点x退出
                    break
    
                if cv2.getWindowProperty(self.name+'_frame', cv2.WND_PROP_AUTOSIZE) < 1:
                    # 点x退出
                    break
    
            # 释放摄像头
            cap.release()
            cv2.destroyAllWindows()
    
    
    if __name__ == "__main__":
    
        detector = Detector()
    
        detector.catch_video()
    
    

    效果如图:

    在这里插入图片描述

    第三步——框出候选区域

    1. 找出所有目标的轮廓:

    这里使用cv2.findContours()函数来查找检测运动目标的轮廓,并标注在原图上:

    _, cnts, _ = cv2.findContours(
        mask.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_TC89_L1)
    
    for c in cnts:
    
        if cv2.contourArea(c) < min_area:
            continue
    
        x, y, w, h = cv2.boundingRect(c)
    
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
    

    cv2.findContours()参数:

    1. 第一个参数是寻找轮廓的图像;
    2. 第二个参数表示轮廓的检索模式,cv2.RETR_LIST表示检测的轮廓不建立等级关系;
    3. 第三个参数method为轮廓的近似办法,cv2.CHAIN_APPROX_TC89_L1使用teh-Chinl chain 近似算法;

    第一步筛选我们去掉面积过小的轮廓框,效果如图:
    在这里插入图片描述

    2. 非极大值抑制NMS:

    当然这里会有重叠框,我们使用非极大值抑制进行筛选;

    非极大值抑制的作用是去除相同目标的重叠的多余的轮廓框,只保留得分最大的那个,例如:
    在这里插入图片描述

    在这里,我们将得分定义为运动点占轮廓框总像素点的比例;

    在这里插入图片描述

    完整代码:

    # nms.py
    import numpy as np
    
    def py_cpu_nms(dets, thresh):
    
        y1 = dets[:, 1]
        x1 = dets[:, 0]
        y2 = y1 + dets[:, 3]
        x2 = x1 + dets[:, 2]
        
        scores = dets[:, 4]  # bbox打分
        
        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
        
        # 打分从大到小排列,取index
        order = scores.argsort()[::-1]
        
        # keep为最后保留的边框
        keep = []
        
        while order.size > 0:
            # order[0]是当前分数最大的窗口,肯定保留
            i = order[0]
            keep.append(i)
            
            # 计算窗口i与其他所有窗口的交叠部分的面积
            xx1 = np.maximum(x1[i], x1[order[1:]])
            yy1 = np.maximum(y1[i], y1[order[1:]])
            xx2 = np.minimum(x2[i], x2[order[1:]])
            yy2 = np.minimum(y2[i], y2[order[1:]])
            
            w = np.maximum(0.0, xx2 - xx1 + 1)
            h = np.maximum(0.0, yy2 - yy1 + 1)
            inter = w * h
            
            # 交/并得到iou值
            ovr = inter / (areas[i] + areas[order[1:]] - inter)
            
            # inds为所有与窗口i的iou值小于threshold值的窗口的index,其他窗口此次都被窗口i吸收
            inds = np.where(ovr <= thresh)[0]
            
            # order里面只保留与窗口i交叠面积小于threshold的那些窗口,由于ovr长度比order长度少1(不包含i),所以inds+1对应到保留的窗口
            order = order[inds + 1]
            
        return keep
    
    # frame.py
    import cv2
    import numpy as np
    from nms import py_cpu_nms
    from time import sleep
    
    
    class Detector(object):
    
        def __init__(self, name='my_video', frame_num=10, k_size=7, color=(0, 255, 0)):
    
            self.name = name
    
            self.color = color
    
            self.nms_threshold = 0.3
    
            self.time = 1/frame_num  # 频率
    
            self.es = cv2.getStructuringElement(
                cv2.MORPH_ELLIPSE, (k_size, k_size))
    
        def catch_video(self, video_index=0, method='T', k_size=7, dialta=0.95,
                        iterations=3, threshold=20, bias_num=1,logical='or',
                        min_area=360, show_test=True, nms=True):
    
            # video_index:摄像头索引(数字)或者视频路径(字符路径)
            # k_size:中值滤波的滤波器大小
            # dialta:背景权重
            # iteration:腐蚀+膨胀的次数,0表示不进行腐蚀和膨胀操作
            # threshold:二值化阙值
            # bias_num:计算帧差图时的帧数差
            # min_area:目标的最小面积
            # show_test:是否显示二值化图片
            # nms:是否进行非极大值抑制
    
            method = method.lower()
    
            if not bias_num > 0:
                raise Exception('bias_num must > 0')
    
            if isinstance(video_index, str):
                self.is_camera = False
                # 如果是视频,则需要调整帧率
            else:
                self.is_camera = True
    
            cap = cv2.VideoCapture(video_index)  # 创建摄像头识别类
    
            if not cap.isOpened():
                # 如果没有检测到摄像头,报错
                raise Exception('Check if the camera is on.')
    
            self.frame_num = 0
    
            if method != 'B':
    
                self.background = []
    
            while cap.isOpened():
    
                if method == 't':
    
                    mask, frame = self.temporal_difference(
                        cap, k_size, dialta, iterations, threshold,
                        bias_num, min_area, show_test, nms)
    
                elif method == 'b':
    
                    mask, frame = self.weights_bk(
                        cap, k_size, dialta, iterations, threshold,
                        bias_num, min_area, show_test, nms)
    
                elif method == 'tr':
    
                    mask, frame = self.tri_temporal_difference(
                        cap, k_size, dialta, iterations, threshold,
                        bias_num, min_area, show_test, nms, logical)
    
                else:
    
                    raise Exception('method must be \'T\' or \'Tr\' or \'B\'')
    
                _, cnts, _ = cv2.findContours(
                    mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
                bounds = self.nms_cnts(cnts, mask, min_area, nms=nms)
    
                for b in bounds:
    
                    x, y, w, h = b
    
                    thickness = (w*h)//min_area
    
                    thickness = thickness if thickness <= 3 else 3
                    thickness = thickness if thickness >= 1 else 1
    
                    cv2.rectangle(frame, (x, y), (x+w, y+h), self.color, thickness)
    
                if not self.is_camera:
    
                    sleep(self.time)
    
                # cv2.imshow(self.name+'_bk', self.background)  # 在window上显示背景
                cv2.imshow(self.name, frame)  # 在window上显示图片
                if show_test:
                    cv2.imshow(self.name+'_frame', mask)  # 边界
    
                cv2.waitKey(10)
    
                if cv2.getWindowProperty(self.name, cv2.WND_PROP_AUTOSIZE) < 1:
                    # 点x退出
                    break
    
                if show_test and cv2.getWindowProperty(self.name+'_frame', cv2.WND_PROP_AUTOSIZE) < 1:
                    # 点x退出
                    break
    
            # 释放摄像头
            cap.release()
            cv2.destroyAllWindows()
    
        def weights_bk(self, cap, k_size=7, dialta=0.95,
                       iterations=3, threshold=20, bias_num=1,
                       min_area=360, show_test=True, nms=True):
    
            catch, frame = cap.read()  # 读取每一帧图片
    
            if not catch:
    
                if self.is_camera:
    
                    raise Exception('Unexpected Error.')
    
            if self.frame_num < bias_num:
    
                value = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                self.background = value
    
                self.frame_num += 1
    
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            raw = gray.copy()
    
            gray = np.abs(gray-self.background).astype('uint8')
    
            self.background = self.background*dialta + raw*(1-dialta)
            self.background = self.background.astype('uint8')
    
            gray = cv2.medianBlur(gray, k_size)
    
            _, mask = cv2.threshold(
                gray, threshold, 255, cv2.THRESH_BINARY)
    
            # mask = cv2.medianBlur(mask, k_size)
    
            mask = cv2.dilate(mask, self.es, iterations)
            mask = cv2.erode(mask, self.es, iterations)
    
            return mask, frame
    
        def temporal_difference(self, cap, k_size=7, dialta=0.95,
                                iterations=3, threshold=20, bias_num=1,
                                min_area=360, show_test=True, nms=True):
    
            catch, frame = cap.read()  # 读取每一帧图片
    
            if not catch:
    
                if self.is_camera:
    
                    raise Exception('Unexpected Error.')
    
            if self.frame_num < bias_num:
    
                value = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                self.background.append(value)
    
                self.frame_num += 1
    
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            raw = gray.copy()
    
            gray = cv2.absdiff(gray, self.background[0])
    
            gray = cv2.medianBlur(gray, k_size)
    
            _, mask = cv2.threshold(
                gray, threshold, 255, cv2.THRESH_BINARY)
    
            # mask = cv2.medianBlur(mask, k_size)
    
            mask = cv2.dilate(mask, self.es, iterations)
            mask = cv2.erode(mask, self.es, iterations)
    
            self.background = self.pop(self.background, raw)
    
            return mask, frame
    
        def tri_temporal_difference(self, cap, k_size=7, dialta=0.95,
                                    iterations=3, threshold=20, bias_num=1,
                                    min_area=360, show_test=True, nms=True,
                                    logical='or'):
    
            catch, frame = cap.read()  # 读取每一帧图片
    
            if not catch:
    
                if self.is_camera:
    
                    raise Exception('Unexpected Error.')
    
            if self.frame_num < bias_num:
    
                value = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                self.background = [value]*bias_num
    
                self.frame_num = bias_num
    
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
            gray1 = cv2.absdiff(gray, self.background[0])
            gray1 = cv2.medianBlur(gray1, k_size)
    
            _, mask1 = cv2.threshold(
                gray1, threshold, 255, cv2.THRESH_BINARY)
    
            gray2 = cv2.absdiff(gray, self.background[1])
            gray2 = cv2.medianBlur(gray2, k_size)
    
            _, mask2 = cv2.threshold(
                gray2, threshold, 255, cv2.THRESH_BINARY)
    
            if logical == 'or':
                mask = (np.logical_or(mask1, mask2) + 0)
            elif logical == 'and':
                mask = (np.logical_and(mask1, mask2) + 0)
            else:
                raise Exception('Logical must be \'OR\' or \'AND\'')
            mask = (mask * 255).astype(np.uint8)
    
            mask = cv2.dilate(mask, self.es, iterations)
            mask = cv2.erode(mask, self.es, iterations)
    
            self.background = self.pop(self.background, gray)
    
            return mask, frame
    
        def nms_cnts(self, cnts, mask, min_area, nms=True):
            # 对检测到的边界框使用非极大值抑制
            bounds = [cv2.boundingRect(
                c) for c in cnts if cv2.contourArea(c) > min_area]
    
            if len(bounds) == 0:
                return []
    
            if not nms:
                return bounds
    
            scores = [self.calculate(b, mask) for b in bounds]
    
            bounds = np.array(bounds)
    
            scores = np.expand_dims(np.array(scores), axis=-1)
    
            keep = py_cpu_nms(np.hstack([bounds, scores]), self.nms_threshold)
    
            return bounds[keep]
    
        def calculate(self, bound, mask):
    
            x, y, w, h = bound
    
            area = mask[y:y+h, x:x+w]
    
            pos = area > 0
            pos = pos.astype(np.float)
            # 得分应与检测框大小也有关系
    
            score = np.sum(pos)/(w*h)
    
            return score
    
        def pop(self, l, value):
    
            l.pop(0)
            l.append(value)
    
            return l
    
    
    if __name__ == "__main__":
    
        detector = Detector(name='test')
    
        detector.catch_video('./test.avi', method='b', bias_num=2, iterations=2,
                             k_size=5, show_test=True, min_area=360,
                             nms=False, threshold=30, dialta=0.9)                         
    
    

    其中method参数可选 t,tr 或者 b,分别代表相邻帧差法、三帧差法和我们这里讲的背景模型差法。

    在这里插入图片描述
    完整代码和测试视频放在了我的Github上,记得点一个⭐哦:

    Sharpiless/Temporal-Difference

    关注我的公众号:

    感兴趣的同学关注我的公众号——可达鸭的深度学习教程:
    在这里插入图片描述

    展开全文
  • CRC冗余校验的真正原理模2除法

    千次阅读 2018-07-24 10:46:42
    过程不难,难点在于对模2除法的理解深度,由于是一套新的算法,所以交换律,结合律等都无法使用,以下为鄙人拙见,如有错误,望指正!万分感谢   ...
  • 一、CRC定义 CRC(Cyclic Redundancy Check),即循环冗余检验码,也可叫做循环码,具有检错和纠错能力。... 模2除法,就是在进行除法运算时不计进位的除法。 先看三点在模2除时要记住的准则 ...
  • 模2除法——用非常直观的例子解释

    千次阅读 热门讨论 2020-03-05 16:28:34
    差错检测中有名唤CRC之方法,但很多学习者难以理解其运行原理——特别是模2除法,故博主将其原理以示例方式记录下来,以便同道稍作借鉴。因博主水平有限,难免会出现错误,希各位能多多包涵和给予建议。 注意:本...
  •   关于模2除法,网上的人说了一大堆规则和原理,感觉很容易把小白绕进去,下面我只说怎么计算,不说其中的规则和原理
  • 模2运算的原理

    千次阅读 2015-08-02 14:24:22
    模2运算的原理 模2加法,模2减法,模2乘法,模2除法 模2运算是一种二进制算法,CRC校验技术中的核心部分,因此,我们在分析CRC算法之前,必须掌握模2运算的规则。与四则运算相同,模2运算也包括模2加、模2减、模2...
  • 计算机组成原理模2运算

    千次阅读 2020-05-07 09:27:13
    模2运算是一种二进制运算,与普通的四则运算相同,模2运算也包括模2加法、模2减法、模2乘法、模2除法。但是与普通四则运算不同的是,模2运算不考虑进位和借位,两个二进制位相运算的时候,这两个值就能确定出结果,...
  • 移位除法器模型 三、实验代码 module div2(clk, reset, start, A, B, D, R, ok, err); parameter n = 32; parameter m = 16; input clk, reset, start; input [n-1:0] A, B; output [n+m-1:0] D; output [n-1:0] R; ...
  • 模2运算

    2012-03-10 20:17:25
    模2运算的原理 模2加法,模2减法,模2乘法,模2除法 2011-05-06 23:24:47| 分类: c | 标签:模2除法 模2运算的原理 模2加法 模2减法 模2乘法 |字号 订阅 模2运算的原理(转) 模2运算是一种二进制算法,...
  • CRC查表运算原理

    2021-05-16 11:30:10
    CRC校验是依据多项式模2运算进行的,这里有两点: 1. 一个二进制串总可以表示为多项式,例如: 10101 表示为 ...除法:依据多项式模2减法算得 多项式模2运算满足分配律和结合律:已知多项式 则 ...
  • jvm原理,内存模型及GC机制

    千次阅读 2017-07-06 14:21:47
    目录 1. jvm结构 JVM方法区结构(内存模型) 1.1 程序计数器 ...2.1 引用计数 2.2 可达性分析算法 2.3 一般回收算法也有如下几种 2.3.1 按照基本回收策略分 (1)标记-清除(Mark-sweep) (2)...
  • 一、质数: 定义:若一个正整数无法被除了1和它自身...1】试除法: 若一个正整数n是合数,则存在一个小于等于sqrt(n)的数能整除n。其实也好理解,一个合数的因子总是成对出现,比如10的因子就有(1,10)、(2...
  • 2.实验原理 2.实验原理 21古典谱估计 相关谱估计是以相关函数为媒介米计算功率谱,又叫做间接 它的理论基础是维纳-辛钦定理,其具体实现步骤如下: 第一步,由获得的N点数据构成的有限长序列xn(n)来估计自相关 哟数,...
  • 题意:给定a进制的大数s,将其转换为b进制。其中2<=a,b<=62。 题意:一般进制转换是以10进制为中介进行转换,但这里...这里我用的短除法,复杂度比较小。原理大致是将s每次除以b,得到的余数的逆序列是b进制...
  • CRC校验原理

    2019-06-03 16:55:50
    原理:发送端采用模2除法,在原数据后面加校验位。接收端将接受的数据也采用模2除法,取出原数据。当接收端余数为0的时候说明接受正确。 模2除法: 除数选择:用户随机选择,假设k位。一般以多项式表示。假如是...
  • 二运算

    千次阅读 2017-09-03 09:30:13
    计算机网络的数据链路层中的CRC校验...模2除法举例: 被除数:10110010000 除数:11001   10110 010000 前四位摸2除 1 11001 ------------ 01111 前四结果   11110 10000 移位后再除 1 11001 -----
  • CRC校验原理及示例

    2020-07-30 16:42:23
    原理 在要发送的帧后面附加一个数,生成一个新帧发送给接收端。...模2除法模2除法与算术除法类似,但每一位除的结果不影响其它位,即不向上一位借位,所以实际上就是异或。只要以相同位数进行相除即可,两者对
  • 次方求

    2013-11-07 16:25:15
    蒙哥马利乘的优点在于减少了取模的次数(在大数的条件下)以及简化了除法的复杂度(在2的k次幂的进制下除法仅需要进行左移操作)。幂运算是RSA 的核心算法,最直接地决定了RSA 算法的性能。 例如求D=C^15%N ...
  • 通俗CRC校验原理剖析

    2021-05-22 10:55:30
    当然,这个附加的数不是随意的,它要使所生成的新帧能与发送端和接收端共同选定的某个特定数整除(注意,这里不是直接采用二进制除法,而是采用一种称之为“模2除法”)。到达接收端后,再把接收到的新帧除以(同样...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 270
精华内容 108
关键字:

模2除法原理