ValueError:值太多，无法解压缩python 2.7

因此，我试图编译以下代码，但它显示了cv2.findContours上的错误。不过，我使用的是Python 2.7版本。有没有理由解释为什么会出现错误：太多的值无法解压Python2.7

import cv2
import numpy as np
import time

#Open Camera object
cap = cv2.VideoCapture(0)

#Decrease frame size
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1000)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 600)

def nothing(x):
    pass

# Function to find angle between two vectors
def Angle(v1,v2):
    dot = np.dot(v1,v2)
    x_modulus = np.sqrt((v1*v1).sum())
    y_modulus = np.sqrt((v2*v2).sum())
    cos_angle = dot / x_modulus / y_modulus
    angle = np.degrees(np.arccos(cos_angle))
    return angle

# Function to find distance between two points in a list of lists
def FindDistance(A,B): 
    return np.sqrt(np.power((A[0][0]-B[0][0]),2) + np.power((A[0][1]-B[0][1]),2)) 

# Creating a window for HSV track bars
cv2.namedWindow('HSV_TrackBar')

# Starting with 100's to prevent error while masking
h,s,v = 100,100,100

# Creating track bar
cv2.createTrackbar('h', 'HSV_TrackBar',0,179,nothing)
cv2.createTrackbar('s', 'HSV_TrackBar',0,255,nothing)
cv2.createTrackbar('v', 'HSV_TrackBar',0,255,nothing)

while(1):

    #Measure execution time 
    start_time = time.time()

    #Capture frames from the camera
    ret, frame = cap.read()

    #Blur the image
    blur = cv2.blur(frame,(3,3))

    #Convert to HSV color space
    hsv = cv2.cvtColor(blur,cv2.COLOR_BGR2HSV)

    #Create a binary image with where white will be skin colors and rest is black
    mask2 = cv2.inRange(hsv,np.array([2,50,50]),np.array([15,255,255]))

    #Kernel matrices for morphological transformation    
    kernel_square = np.ones((11,11),np.uint8)
    kernel_ellipse= cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))

    #Perform morphological transformations to filter out the background noise
    #Dilation increase skin color area
    #Erosion increase skin color area
    dilation = cv2.dilate(mask2,kernel_ellipse,iterations = 1)
    erosion = cv2.erode(dilation,kernel_square,iterations = 1)    
    dilation2 = cv2.dilate(erosion,kernel_ellipse,iterations = 1)    
    filtered = cv2.medianBlur(dilation2,5)
    kernel_ellipse= cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(8,8))
    dilation2 = cv2.dilate(filtered,kernel_ellipse,iterations = 1)
    kernel_ellipse= cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
    dilation3 = cv2.dilate(filtered,kernel_ellipse,iterations = 1)
    median = cv2.medianBlur(dilation2,5)
    ret,thresh = cv2.threshold(median,127,255,0)

    #Find contours of the filtered frame
    contours, hierarchy =    cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) //error!

    #Draw Contours
    #cv2.drawContours(frame, cnt, -1, (122,122,0), 3)
    #cv2.imshow('Dilation',median)

    #Find Max contour area (Assume that hand is in the frame)
    max_area=100
    ci=0    
    for i in range(len(contours)):
        cnt=contours[i]
        area = cv2.contourArea(cnt)
        if(area>max_area):
            max_area=area
            ci=i  

    #Largest area contour             
    cnts = contours[ci]

    #Find convex hull
    hull = cv2.convexHull(cnts)

    #Find convex defects
    hull2 = cv2.convexHull(cnts,returnPoints = False)
    defects = cv2.convexityDefects(cnts,hull2)

    #Get defect points and draw them in the original image
    FarDefect = []
    for i in range(defects.shape[0]):
        s,e,f,d = defects[i,0]
        start = tuple(cnts[s][0])
        end = tuple(cnts[e][0])
        far = tuple(cnts[f][0])
        FarDefect.append(far)
        cv2.line(frame,start,end,[0,255,0],1)
        cv2.circle(frame,far,10,[100,255,255],3)

    #Find moments of the largest contour
    moments = cv2.moments(cnts)

    #Central mass of first order moments
    if moments['m00']!=0:
        cx = int(moments['m10']/moments['m00']) # cx = M10/M00
        cy = int(moments['m01']/moments['m00']) # cy = M01/M00
    centerMass=(cx,cy)    

    #Draw center mass
    cv2.circle(frame,centerMass,7,[100,0,255],2)
    font = cv2.FONT_HERSHEY_SIMPLEX
    cv2.putText(frame,'Center',tuple(centerMass),font,2,(255,255,255),2)     

    #Distance from each finger defect(finger webbing) to the center mass
    distanceBetweenDefectsToCenter = []
    for i in range(0,len(FarDefect)):
        x =  np.array(FarDefect[i])
        centerMass = np.array(centerMass)
        distance = np.sqrt(np.power(x[0]-centerMass[0],2)+np.power(x[1]-centerMass[1],2))
        distanceBetweenDefectsToCenter.append(distance)

    #Get an average of three shortest distances from finger webbing to center mass
    sortedDefectsDistances = sorted(distanceBetweenDefectsToCenter)
    AverageDefectDistance = np.mean(sortedDefectsDistances[0:2])

    #Get fingertip points from contour hull
    #If points are in proximity of 80 pixels, consider as a single point in the group
    finger = []
    for i in range(0,len(hull)-1):
        if (np.absolute(hull[i][0][0] - hull[i+1][0][0]) > 80) or ( np.absolute(hull[i][0][1] - hull[i+1][0][1]) > 80):
            if hull[i][0][1] <500 :
                finger.append(hull[i][0])

    #The fingertip points are 5 hull points with largest y coordinates  
    finger =  sorted(finger,key=lambda x: x[1])   
    fingers = finger[0:5]

    #Calculate distance of each finger tip to the center mass
    fingerDistance = []
    for i in range(0,len(fingers)):
        distance = np.sqrt(np.power(fingers[i][0]-centerMass[0],2)+np.power(fingers[i][1]-centerMass[0],2))
        fingerDistance.append(distance)

    #Finger is pointed/raised if the distance of between fingertip to the center mass is larger
    #than the distance of average finger webbing to center mass by 130 pixels
    result = 0
    for i in range(0,len(fingers)):
        if fingerDistance[i] > AverageDefectDistance+130:
            result = result +1

    #Print number of pointed fingers
    cv2.putText(frame,str(result),(100,100),font,2,(255,255,255),2)

    #show height raised fingers
    #cv2.putText(frame,'finger1',tuple(finger[0]),font,2,(255,255,255),2)
    #cv2.putText(frame,'finger2',tuple(finger[1]),font,2,(255,255,255),2)
    #cv2.putText(frame,'finger3',tuple(finger[2]),font,2,(255,255,255),2)
    #cv2.putText(frame,'finger4',tuple(finger[3]),font,2,(255,255,255),2)
    #cv2.putText(frame,'finger5',tuple(finger[4]),font,2,(255,255,255),2)
    #cv2.putText(frame,'finger6',tuple(finger[5]),font,2,(255,255,255),2)
    #cv2.putText(frame,'finger7',tuple(finger[6]),font,2,(255,255,255),2)
    #cv2.putText(frame,'finger8',tuple(finger[7]),font,2,(255,255,255),2)

    #Print bounding rectangle
    x,y,w,h = cv2.boundingRect(cnts)
    img = cv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),2)

    cv2.drawContours(frame,[hull],-1,(255,255,255),2)

    ##### Show final image ########
    cv2.imshow('Dilation',frame)
    ###############################

    #Print execution time
    #print time.time()-start_time

    #close the output video by pressing 'ESC'
    k = cv2.waitKey(5) & 0xFF
    if k == 27:
        break

cap.release()
cv2.destroyAllWindows()

导入cv2
将numpy作为np导入
导入时间
#打开摄影机对象
cap=cv2.视频捕获（0）
#减小帧大小
封盖套件（cv2.cap\u PROP\u FRAME\u WIDTH，1000）
盖组件（cv2.cap\u PROP\u FRAME\u HEIGHT，600）
def nothing（x）：
通过
#函数查找两个向量之间的角度
def角度（v1、v2）：
点=np点（v1，v2）
x_模数=np.sqrt（（v1*v1.sum（））
y_模数=np.sqrt（（v2*v2.sum（））
cos_角度=点/x_模数/y_模数
角度=np度（np角（余角））
返回角
#函数查找列表中两点之间的距离
def FindInstance（A、B）：
返回np.sqrt（np.power（（A[0][0]-B[0][0]），2）+np.power（（A[0][1]-B[0][1]），2））
#为HSV轨迹栏创建窗口
cv2.namedWindow（“HSV_轨迹栏”）
#从100开始，以防止掩蔽时出错
h、 s，v=100100
#创建轨迹栏
cv2.createTrackbar（'h'，'HSV_TrackBar'，0179，无）
cv2.createTrackbar（'s'，'HSV_TrackBar'，0255，无）
cv2.createTrackbar（'v'，'HSV_TrackBar'，0255，无）
而(一):
#测量执行时间
开始时间=time.time（）
#从相机捕获帧
ret，frame=cap.read（）
#模糊图像
模糊=cv2。模糊（帧，（3,3））
#转换为HSV颜色空间
hsv=cv2.cvt颜色（模糊，cv2.COLOR\u BGR2HSV）
#创建一个二值图像，其中白色为皮肤颜色，其余为黑色
mask2=cv2.inRange（hsv，np.数组（[2,50,50]），np.数组（[15255255]））
#形态变换的核矩阵
核平方=np.ones（（11,11），np.uint8）
kernel_椭圆=cv2.getStructuringElement（cv2.MORPH_椭圆，（5,5））
#执行形态变换以滤除背景噪声
#扩张增加肤色面积
#侵蚀增加皮肤颜色区域
扩张=cv2.扩张（mask2，核_椭圆，迭代次数=1）
侵蚀=cv2。侵蚀（膨胀，核平方，迭代次数=1）
扩张2=cv2.扩张（侵蚀，核_椭圆，迭代次数=1）
过滤=cv2.medianBlur（2,5）
kernel_椭圆=cv2.getStructuringElement（cv2.MORPH_椭圆，（8,8））
扩张2=cv2.扩张（过滤，核_椭圆，迭代次数=1）
kernel_椭圆=cv2.getStructuringElement（cv2.MORPH_椭圆，（5,5））
扩张3=cv2.扩张（过滤，核_椭圆，迭代次数=1）
中位数=cv2.medianBlur（2,5）
ret，thresh=cv2。阈值（中位数127255,0）
#查找过滤帧的轮廓
轮廓，层次=cv2.findContours（阈值，cv2.RETR\u树，cv2.CHAIN\u近似值\u简单）//错误！
#画轮廓
#cv2.绘图轮廓（框架，cnt，-1，（122122,0），3）
#cv2.imshow（‘扩张’、中值）
#查找最大轮廓面积（假设手在框架内）
最大面积=100
ci=0
对于范围内的i（透镜（轮廓））：
cnt=等高线[i]
面积=cv2。轮廓面积（cnt）
如果（面积>最大面积）：
最大面积=面积
ci=i
#最大面积等高线
cnts=轮廓[ci]
#求凸壳
外壳=cv2.凸形外壳（cnts）
#查找凸缺陷
hull2=cv2.convxhull（CNT，返回点=False）
缺陷=cv2.凸性缺陷（CNT，hull2）
#获取缺陷点并在原始图像中绘制它们
FarDefect=[]
对于范围内的i（缺陷形状[0]）：
s、 e，f，d=缺陷[i，0]
start=tuple（cnts[s][0]）
end=tuple（cnts[e][0]）
far=元组（cnts[f][0]）
FarDefect.append（far）
cv2.线（帧，开始，结束，[0255,0]，1）
cv2.圆（帧，远，10，[100255255]，3）
#求最大轮廓的矩
力矩=cv2.力矩（CNT）
#一阶矩的中心质量
如果时刻['m00']=0:
cx=int（力矩['m10']/力矩['m00']）#cx=m10/m00
cy=int（力矩['m01']/力矩['m00']）#cy=m01/m00
中心质量=（cx，cy）
#画重心
cv2.圆（框架，中心质量，7，[100,0255]，2）
font=cv2.font\u HERSHEY\u SIMPLEX
cv2.putText（框架，“中心”，元组（中心质量），字体，2，（255255），2）
#每个手指缺陷（手指织带）到中心质量的距离
fectstocenter=[]之间的距离
对于范围（0，len（FarDefect））中的i：
x=np.数组（fardeffect[i]）
中心质量=np.阵列（中心质量）
距离=np.sqrt（np.power（x[0]-中心质量[0]，2）+np.power（x[1]-中心质量[1]，2））
distanceBetweenDefectsToCenter.append（距离）
#从手指织带到重心的平均三个最短距离
sortedDefectsDistances=已排序（DefectsToCenter之间的距离）
平均缺陷距离=np.平均值（分拣缺陷距离[0:2]）
#从轮廓外壳获取指尖点
如果点接近80个像素，则将其视为组中的单点。
手指=[]
对于范围内的i（0，长度（外壳）-1）：
如果（np.绝对（外壳[i][0][0]-外壳[i+1][0][0]）>80或（np.绝对（外壳[i][0][1]-外壳[i+1][0][1]）>80：
如果船体[i][0][1]平均缺陷距离+130：
结果=结果+1
#打印尖手指的数量
cv2.putText（框架，str（结果），（100100），字体，2，（255255），2）
#举起手指显示高度
#cv2.putText（框架，'finger1'，元组（finger[0]），字体，2，（255255），2）
#putText（框架，'finger2'，元组（finger[1]），字体，2，（255255），2）
#putText（框架，'finger3'，元组（finger[2]），字体，2，（255255），2）
#cv2.putText（框架，'finger4'，元组（finger[3]），字体，2，（255255），2）
#cv2.putText（框架，'finger5'，元组（finger[4]），字体，2，（255255），2）
#cv2.putText（框架，'finger6'，元组（finger[5]），字体，2，（255255），2）
#cv2.putText（框架，'finger7'，元组（finger[6]），字体，2，（255255），2）
#putText（框架，'finger8'，元组（finger[7]），字体，2，（255255），2）
#打印边框
x、 y，w，h=cv2.boundingRect（碳纳米管）
我
contours, hierarchy =    cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

image, contours, hierarchy =    cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)