全球名称'；筛选'；未在python中定义（Pi 3 B）

当我在带有

opencv3.0.0

的窗口上运行此示例代码时，

sift=cv2.sift（）

起作用，当我在带有

opencv3.2.0

的Raspberry Pi中运行相同的代码时，它显示了此错误，

"global name 'SIFT' is not defined"

#/usr/bin/env python
#版权所有2014 Jarmo Puttonen。版权所有。
#此源代码的使用受MIT风格的约束
#可在许可证文件中找到的许可证。
“”“从网络摄像头馈送检测速度限制”“”
进口稀土
导入操作系统
导入系统
进口cv2
导入线程
将numpy作为np导入
导入argparse
#从gps导入gps，观察启用
def onTrackbarChange（u2;）：
“”“传递任何轨迹栏更改”“”
类GPSInfo（线程。线程）：
“”“负责更新GPS速度信息的线程。”“”
定义初始化（自）：
threading.Thread.\uuuuu init\uuuuuu（自）
self.gpsd=gps（模式=WATCH\u ENABLE）
self.running=True
自身速度=0
def运行（自）：
自运行时：
self.gpsd.next（）
self.speed=self.gpsd.fix.speed*3.6#从m/s到km/h
def读取路径（路径）：
“”“返回给定路径中的文件列表”“”
图像=\[\[\]表示范围（2）\]
对于dirname，dirnames，u在os.walk（path）中：
对于目录名中的子域名：
filepath=os.path.join（dirname，subdirname）
对于os.listdir（文件路径）中的文件名：
尝试：
imgpath=str（os.path.join（filepath，filename））
图像\[0\].append（imgpath）
limit=re.findall（'\[0-9\]+'，文件名）
图像\[1\]。追加（限制\[0\]）
除了IOError（错误号，strerror）：
打印“I/O错误（{0}）：{1}”。格式（errno，strerror）
除：
打印“意外错误：”，sys.exc\u info（）\[0\]
提升
返回图像
def加载_映像（imgpath）：
“”“加载给定路径中的图像并返回
包含图像和关键点“”的列表
图像=读取路径（imgpath）
imglist=\[\[\]，\[\]，\[\]，\[\]\]
cur_img=0
SIFT=cv2.xfeature2d.SIFT_create（）
对于图像\[0\]中的i：
img=cv2.imread（i，0）
imglist\[0\]。附加（img）
imglist\[1\].追加（图像\[1\]\[cur\u img\]]
电流img+=1
关键点，des=筛选、检测和计算（img，无）
imglist\[2\].追加（关键点）
imglist\[3\].追加（des）
返回imglist
def管路法兰（img）：
“”“使用给定图像列表为给定图像运行FLANN检测器”“”
#使用SIFT查找关键点描述符
_，des=SIFT.detectAndCompute（img，无）
如果des为无：
返回“未知”，0
如果len（des）最大值：
最大值=匹配值
最大速度=图像\[1\]\[cur\u img\]
电流img+=1
如果最大值>ARGS.MINKP：
返回最大速度，最大值
其他：
返回“未知”，0
例外情况除外：
打印例外
返回“未知”，0
图像=加载图像（“数据”）
def run_逻辑（）：
“”“运行TSR和ISA”“”
lastlimit=“00”
lastdetect=“00”
downscale=ARGS.downscale
匹配项=0
可能匹配=“00”
尝试：
如果CAP.isOpened（）：
rval，frame=CAP.read（）
打印（“打开相机并读取帧”）
其他：
rval=False
打印（“相机未打开”）
而rval：
origframe=框架
如果ARGS.MORPH：
帧=cv2.morphologyEx(
框架
cv2.MORPH_打开，
cv2.getStructuringElement（cv2.MORPH_RECT，（2,2））
)
帧=cv2.morphologyEx(
框架
cv2.MORPH_CLOSE，
cv2.getStructuringElement（cv2.MORPH_RECT，（2,2））
)
frame=cv2.CVT颜色（frame，cv2.COLOR\u BGR2GRAY）
如果ARGS.EQ：
cv2.均衡器历史（帧，帧）
如果ARGS.trackbar：
ARGS.MINKP=cv2.getTrackbarPos（'MINKEYPOINTS'，'preview'）
downscale=cv2.getTrackbarPos（'downscale'，'preview'）
ARGS.FLANNTHRESHOLD=浮动(
cv2.getTrackbarPos（'FLANNTHRESHOLD'，'preview'）
)/10
ARGS.CHECKS=cv2.getTrackbarPos（'FLANNCHECKS'，'preview'）
ARGS.TREES=cv2.getTrackbarPos（'FLANNTREES'，'preview'）
scaledsize=（frame.shape\[1\]/缩小，frame.shape\[0\]/缩小）
scaledframe=cv2。调整大小（frame，scaledsize）
#在缩小的帧中检测标志
符号=分类器。检测多尺度(
缩放帧，
1.1,
5.
0,
(10, 10),
(200, 200))
对于登录标志：
xpos、YPO、宽度、高度=\[i*符号i的缩尺\]
裁剪图像=帧\[ypos:ypos+高度，xpos:xpos+宽度\]
大小=cv2。调整大小（裁剪（128，128））
comp=“未知”
组件，amnt=运行法兰（尺寸）
如果comp！=“未知”：
如果comp！=最后限额：
#要求连续两次点击新限制。
如果comp==lastdetect：
可能匹配=comp
#!/usr/bin/env python

# Copyright 2014 Jarmo Puttonen <jarmo.puttonen@gmail.com>. All rights reserved.
# Use of this source code is governed by a MIT-style
# licence that can be found in the LICENCE file.

"""Detect speed limits from webcam feed"""
import re
import os
import sys
import cv2
import threading
import numpy as np
import argparse
#from gps import gps, WATCH_ENABLE

def onTrackbarChange(_):
    """Pass any trackbar changes"""

class GPSInfo(threading.Thread):
    """Thread that takes care of updating GPS Speed info."""
    def __init__(self):
        threading.Thread.__init__(self)
        self.gpsd = gps(mode=WATCH_ENABLE)
        self.running = True
        self.speed = 0

    def run(self):
        while self.running:
            self.gpsd.next()
            self.speed = self.gpsd.fix.speed*3.6 #from m/s to km/h

def read_paths(path):
    """Returns a list of files in given path"""
    images = \[\[\] for _ in range(2)\]
    for dirname, dirnames, _ in os.walk(path):
        for subdirname in dirnames:
            filepath = os.path.join(dirname, subdirname)
            for filename in os.listdir(filepath):
                try:
                    imgpath = str(os.path.join(filepath, filename))
                    images\[0\].append(imgpath)
                    limit = re.findall('\[0-9\]+', filename)
                    images\[1\].append(limit\[0\])
                except IOError, (errno, strerror):
                    print "I/O error({0}): {1}".format(errno, strerror)
                except:
                    print "Unexpected error:", sys.exc_info()\[0\]
                    raise
    return images

def load_images(imgpath):
    """Loads images in given path and returns
     a list containing image and keypoints"""
    images = read_paths(imgpath)
    imglist = \[\[\], \[\], \[\], \[\]\]
    cur_img = 0
    SIFT = cv2.xfeatures2d.SIFT_create()
    for i in images\[0\]:
        img = cv2.imread(i, 0)
        imglist\[0\].append(img)
        imglist\[1\].append(images\[1\]\[cur_img\])
        cur_img += 1
        keypoints, des = SIFT.detectAndCompute(img, None)
        imglist\[2\].append(keypoints)
        imglist\[3\].append(des)
    return imglist

def run_flann(img):
    """Run FLANN-detector for given image with given image list"""
# Find the keypoint descriptors with SIFT
    _, des = SIFT.detectAndCompute(img, None)
    if des is None:
        return "Unknown", 0
    if len(des) < ARGS.MINKP:
        return "Unknown", 0

    biggest_amnt = 0
    biggest_speed = 0
    cur_img = 0
    try:
        for _ in IMAGES\[0\]:
            des2 = IMAGES\[3\]\[cur_img\]
            matches = FLANN.knnMatch(des2, des, k=2)
            matchamnt = 0
    # Find matches with Lowe's ratio test
            for _, (moo, noo) in enumerate(matches):
                if moo.distance < ARGS.FLANNTHRESHOLD*noo.distance:
                    matchamnt += 1
            if matchamnt > biggest_amnt:
                biggest_amnt = matchamnt
                biggest_speed = IMAGES\[1\]\[cur_img\]
            cur_img += 1
        if biggest_amnt > ARGS.MINKP:
            return biggest_speed, biggest_amnt
        else:
            return "Unknown", 0
    except Exception, exept:
        print exept
        return "Unknown", 0

IMAGES = load_images("data")
def run_logic():
    """Run TSR and ISA"""
    lastlimit = "00"
    lastdetect = "00"
    downscale = ARGS.DOWNSCALE
    matches = 0
    possiblematch = "00"
    try:
        if CAP.isOpened():
            rval, frame = CAP.read()

            print("Camera opened and frame read")
        else:
            rval = False
            print("Camera not opened")
        while rval:
            origframe = frame
            if ARGS.MORPH:
                frame = cv2.morphologyEx(
                    frame,
                    cv2.MORPH_OPEN, 
                    cv2.getStructuringElement(cv2.MORPH_RECT,(2,2))
                    )
                frame = cv2.morphologyEx(
                    frame, 
                    cv2.MORPH_CLOSE, 
                    cv2.getStructuringElement(cv2.MORPH_RECT,(2,2))
                    )
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            if ARGS.EQ:
                cv2.equalizeHist(frame, frame)
            if ARGS.TRACKBARS:
                ARGS.MINKP = cv2.getTrackbarPos('MINKEYPOINTS','preview')
                downscale = cv2.getTrackbarPos('DOWNSCALE','preview')
                ARGS.FLANNTHRESHOLD = float(
                    cv2.getTrackbarPos('FLANNTHRESHOLD','preview')
                    )/10
                ARGS.CHECKS = cv2.getTrackbarPos('FLANNCHECKS','preview')
                ARGS.TREES = cv2.getTrackbarPos('FLANNTREES','preview')

            scaledsize = (frame.shape\[1\]/downscale, frame.shape\[0\]/downscale)
            scaledframe = cv2.resize(frame, scaledsize)

            # Detect signs in downscaled frame
            signs = CLASSIFIER.detectMultiScale(
                scaledframe,
                1.1,
                5,
                0,
                (10, 10),
                (200, 200))
            for sign in signs:
                xpos, ypos, width, height = \[ i*downscale for i in sign \]

                crop_img = frame\[ypos:ypos+height, xpos:xpos+width\]
                sized = cv2.resize(crop_img, (128, 128))
                comp = "Unknown"
                comp, amnt  = run_flann(sized)
                if comp != "Unknown":
                    if comp != lastlimit:
                        # Require two consecutive hits for new limit.
                        if comp == lastdetect:
                            possiblematch = comp
                            matches = matches + 1
                            if matches >= ARGS.matches:
                                print "New speed limit: "+possiblematch
                                lastlimit = possiblematch
                                matches = 0
                        else:
                            possiblematch = "00"
                            matches = 0
                    cv2.rectangle(
                        origframe, 
                        (xpos, ypos), 
                        (xpos+width, ypos+height), 
                        (0, 0, 255))
                    cv2.putText(
                        origframe,
                        "Speed limit: "+comp+" KP: "+str(amnt),
                        (xpos,ypos-5),
                        cv2.FONT_HERSHEY_SIMPLEX,
                         0.4,
                        (0,0,255),
                        1,)
                else:
                    cv2.rectangle(
                        origframe,
                        (xpos,ypos),
                        (xpos+width,ypos+height),
                        (255,0,0))
                    cv2.putText(
                        origframe,
                        "UNKNOWN SPEED LIMIT",
                        (xpos,ypos-5),
                        cv2.FONT_HERSHEY_SIMPLEX,
                        0.4,
                        (255,0,0),
                        1,)
                    comp = lastdetect
                lastdetect = comp

            cv2.putText(
            origframe,
            "Current speed limit: "+str(lastlimit)+" km/h.",
            (5,50),
            cv2.FONT_HERSHEY_SIMPLEX,
            1,
            (0,0,0),
            2
            )
            cv2.imshow("preview", origframe)
            if ARGS.PREVIEW:
                cv2.imshow("preview", origframe)
            _ = cv2.waitKey(20)
            rval, frame = CAP.read()
    except (KeyboardInterrupt, Exception), exept:
        print exept
##        if ARGS.GPS:
##            print "Killing GPS"
##            GPSP.running = False
##            GPSP.join()
##        print "Shutting down!"

# Preload all classes used in detection
sift = cv2.xfeatures2d.SIFT_create()
INDEX_PARAMS = None
SEARCH_PARAMS = None
FLANN = None
## Webcam logic starts
CAP = None
ARGS = None

if __name__ == "__main__":
    PARSER = argparse.ArgumentParser(
      description="Traffic sign recognition and intelligent speed assist.",
      )

    PARSER.add_argument("-d", "--device", dest="SOURCE", default=0,
      help="Index of used video device. Default: 0 (/dev/video0).")
    PARSER.add_argument("-g", "--gps", 
        dest="GPS", action="store_true", default=False,
      help="Enable over speeding detection.")
    PARSER.add_argument("-o", "--overspeed", 
        dest="COMMAND", default="false",
      help="Command used in overspeed warning." \
      " Default: echo OVERSPEEDING!.")
    PARSER.add_argument("-c", "--cascade", 
        dest="CASCADE", default="lbpCascade.xml",
      help="Cascade used in speed sign detection." \
      " Default: lbpCascade.xml.")
    PARSER.add_argument("-k", "--keypoints", 
        dest="MINKP", default=5,
      help="Min amount of keypoints required in" \
      " limit recognition. Default: 5.")
    PARSER.add_argument("-D", "--downscale", 
        dest="DOWNSCALE", default=1,
      help="Multiplier for downscaling frame before" \
      " detecting signs. Default: 1.")
    PARSER.add_argument("-f", "--flann", 
        dest="FLANNTHRESHOLD", default=0.8,
      help="Threshold multiplier for accepting FLANN matches." \
      " Default: 0.8.")
    PARSER.add_argument("-F", "--flannchecks", 
        dest="CHECKS", default=50,
      help="How many checks will be done in FLANN matching." \
      " Default: 50.")
    PARSER.add_argument("-t", "--flanntrees", 
        dest="TREES", default=5,
      help="How many trees will be used in FLANN matching." \
      " Default: 5.")
    PARSER.add_argument("-m", "--matches", 
        dest="matches", default=2,
      help="How many consecutive keypoint matches are needed" \
      " before setting new limit. Default: 2.")
    PARSER.add_argument("-e", "--disable-eq", 
        dest="EQ", action="store_false", default=True,
      help="Disable histogram equalization.")
    PARSER.add_argument("-M", "--morphopenclose", 
        dest="MORPH", action="store_true", default=False,
      help="Enable morphological open/close used in removing" \
      " noise from image.")
    PARSER.add_argument("-T", "--trackbars", 
        dest="TRACKBARS", action="store_true", default=False,
      help="Enable debug trackbars.")
    PARSER.add_argument("-s", "--showvid", 
        dest="PREVIEW", action="store_true", default=False,
      help="Show output video with detections.")
    ARGS = PARSER.parse_args()

    CAP = cv2.VideoCapture(0)
    CLASSIFIER = cv2.CascadeClassifier(ARGS.CASCADE)
    INDEX_PARAMS = dict(algorithm = 0, trees = ARGS.TREES)
    SEARCH_PARAMS = dict(checks=ARGS.CHECKS)   # or pass empty dictionary

    FLANN = cv2.FlannBasedMatcher(INDEX_PARAMS, SEARCH_PARAMS)


    if ARGS.PREVIEW:
        cv2.namedWindow("preview")

    if ARGS.GPS:
        GPSP = GPSInfo()
        GPSP.start()

    if ARGS.TRACKBARS:
        cv2.createTrackbar(
            'MINKEYPOINTS', 
            'preview', 
            ARGS.MINKP, 
            100,
            onTrackbarChange)
        cv2.createTrackbar(
            'DOWNSCALE', 
            'preview', 
            int(ARGS.DOWNSCALE),
            20,
            onTrackbarChange)
        cv2.createTrackbar(
            'FLANNTHRESHOLD',
            'preview',
            8,
            10,
            onTrackbarChange)
        cv2.createTrackbar(
            'FLANNCHECKS', 
            'preview', 
            ARGS.CHECKS, 
            1000, 
            onTrackbarChange)
        cv2.createTrackbar(
            'FLANNTREES', 
            'preview', 
            ARGS.TREES, 
            50, 
            onTrackbarChange)
    run_logic()][1]