def img_contour_select(ctrs, im):
    # ????????????
    cand_rect = []
    for item in ctrs:
        epsilon = 0.02*cv2.arcLength(item, True)
        approx = cv2.approxpolyDP(item, epsilon, True)  
        if len(approx) <= 8:
            rect = cv2.minAreaRect(item)
            if rect[1][0] < 20 or rect[1][1] < 20:
                continue
            if rect[1][0] > 150 or rect[1][1] > 150:
                continue        
            #ratio = (rect[1][1]+0.00001) / rect[1][0]
            #if ratio > 1 or ratio < 0.9:
            #    continue
            Box = cv2.BoxPoints(rect)
            Box_d = np.int0(Box)
            cv2.drawContours(im, [Box_d], 0, (0,255,0), 3)
            cand_rect.append(Box)
    img_show_hook("????", im)   
    return cand_rect

def draw_markers(img,markers):
    for m in markers:
        centroid = np.array(m[''centroid''],dtype=np.float32)
        origin = np.array(m[''verts''][0],dtype=np.float32)
        hat = np.array([[[0,0],[0,1],[.5,1.25],[1,0]]],dtype=np.float32)
        hat = cv2.perspectiveTransform(hat,m_marker_to_screen(m))
        if m[''id_confidence'']>.9:
            cv2.polylines(img,np.int0(hat),color = (0,0,255),isClosed=True)
        else:
            cv2.polylines(img,isClosed=True)
        # cv2.polylines(img,np.int0(centroid),color = (255,255,int(255*m[''id_confidence''])),isClosed=True,thickness=2)
        m_str = ''id: {:d}''.format(m[''id''])
        org = origin.copy()
        # cv2.rectangle(img,tuple(np.int0(org+(-5,-13))[0,:]),tuple(np.int0(org+(100,30))[0,color=(0,0),thickness=-1)
        cv2.putText(img,m_str,tuple(np.int0(org)[0,fontFace=cv2.FONT_HERShey_SIMPLEX, fontScale=0.4, color=(0,255))
        if ''id_confidence'' in m:
            m_str = ''idc: {:.3f}''.format(m[''id_confidence''])
            org += (0, 12)
            cv2.putText(img,255))
        if ''loc_confidence'' in m:
            m_str = ''locc: {:.3f}''.format(m[''loc_confidence''])
            org += (0, 12 )
            cv2.putText(img,255))
        if ''frames_since_true_detection'' in m:
            m_str = ''otf: {}''.format(m[''frames_since_true_detection''])
            org += (0,255))
        if ''opf_vel'' in m:
            m_str = ''otf: {}''.format(m[''opf_vel''])
            org += (0,255))

def img_contour_select(ctrs, True)  
        if len(approx) <= 8:
            rect = cv2.minAreaRect(item)
            #????????
            if rect[2] < -10 and rect[2] > -80:
                continue
            if rect[1][0] < 10 or rect[1][1] < 10:
                continue
            #ratio = (rect[1][1]+0.00001) / rect[1][0]
            #if ratio > 1 or ratio < 0.9:
            #    continue
            Box = cv2.BoxPoints(rect)
            Box_d = np.int0(Box)
            cv2.drawContours(im, im)   
    return cand_rect

def remove_border(contour, ary):
    """Remove everything outside a border contour."""
    # Use a rotated rectangle (should be a good approximation of a border).
    # If it''s far from a right angle,it''s probably two sides of a border and
    # we should use the bounding Box instead.
    c_im = np.zeros(ary.shape)
    r = cv2.minAreaRect(contour)
    degs = r[2]
    if angle_from_right(degs) <= 10.0:
        Box = cv2.BoxPoints(r)
        Box = np.int0(Box)
        cv2.drawContours(c_im, [Box], 255, -1)
        cv2.drawContours(c_im, 4)
    else:
        x1, y1, x2, y2 = cv2.boundingRect(contour)
        cv2.rectangle(c_im, (x1, y1), (x2, y2), -1)
        cv2.rectangle(c_im, 4)
 
    return np.minimum(c_im, ary)

def getMask(self, shape):
 
        p=self.state[''pos'']
        s=self.state[''size'']
        center=p + s / 2
        a=self.state[''angle'']
        # opencv convention:
        shape = (shape[1], shape[0])
        arr1 = np.zeros(shape, dtype=np.uint8)
        arr2 = np.zeros(shape, dtype=np.uint8)
 
        # draw rotated rectangle:
        vertices = np.int0(cv2.BoxPoints((center, s, a)))
        cv2.drawContours(arr1, [vertices], color=1, thickness=-1)
        # draw ellipse:
        cv2.ellipse(arr2, (int(center[0]), int(center[1])), (int(s[0] / 2 * self._ratioEllispeRectangle),
                     int(s[1] / 2 * self._ratioEllispeRectangle)), int(a),
                    startAngle=0, endAngle=360, thickness=-1)
        # bring both together:
        return np.logical_and(arr1, arr2).T

def getMask(self, shape):
 
        p = self.state[''pos'']
        s = self.state[''size'']
        center = p + s / 2
        a = self.state[''angle'']
        # opencv convention:
        shape = (shape[1], shape[0])
        arr = np.zeros(shape, dtype=np.uint8)
        # draw rotated rectangle:
        vertices = np.int0(cv2.BoxPoints((center, a)))
        cv2.drawContours(arr,
                         0,
                         color=1,
                         thickness=-1)
        return arr.astype(bool).T

def deal(self,frame):
        frame=frame.copy()
        track_window=self.track_window
        term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
        roi_hist=self.roi_hist 
        dst = cv2.calcBackProject([frame],[0],roi_hist,180],1)
        if self.m==''m'':
            ret, track_window_r = cv2.meanShift(dst, track_window, term_crit)
            x,y,w,h = track_window_r
            img2 = cv2.rectangle(frame, (x,y), (x+w,y+h),2)
        elif self.m==''c'':
            ret, track_window_r = cv2.CamShift(dst, term_crit)
 
 
            pts = cv2.BoxPoints(ret)
            pts = np.int0(pts)
            img2 = cv2.polylines(frame,[pts],True,2)
        rectsNew=[]
 
        center1=(track_window[0]+track_window[2]//2,track_window[1]+track_window[3]//2)
        center2=(track_window_r[0]+track_window_r[2]//2,track_window_r[1]+track_window_r[3]//2)
        img2 = cv2.line(img2,center1,center2,color=0)
        rectsNew=track_window_r
#        x,y,w,h = track_window
#        img2 = cv2.rectangle(frame,(x,y),(x+w,y+h),2)
        cv2.imshow(''img2'',img2)
        cv2.waitKey(0) 
        cv2.destroyAllWindows()
        return rectsNew

def remove_border(contour,it''s probably two sides of a border and
    # we should use the bounding Box instead.
    c_im = np.zeros(ary.shape)
    r = cv2.minAreaRect(contour)
    degs = r[2]
    if angle_from_right(degs) <= 10.0:
        Box = cv2.cv.BoxPoints(r)
        Box = np.int0(Box)
        cv2.drawContours(c_im, ary)

def density_slice(rast, rel=np.less_equal, threshold=1000, nodata=-9999):
    ''''''
    Returns a density slice from a given raster. Arguments:
        rast        A gdal.Dataset or a NumPy array
        rel         A NumPy logic function; defaults to np.less_equal
        threshold   An integer number
    ''''''
    # Can accept either a gdal.Dataset or numpy.array instance
    if not isinstance(rast, np.ndarray):
        rastr = rast.ReadAsArray()
 
    else:
        rastr = rast.copy()
 
    if (len(rastr.shape) > 2 and min(rastr.shape) > 1):
        raise ValueError(''Expected a single-band raster array'')
 
    return np.logical_and(
        rel(rastr, np.ones(rast.shape) * threshold),
        np.not_equal(rastr, np.ones(rast.shape) * nodata)).astype(np.int0)

def shapeFiltering(img):
    contours = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[0]
    if len(contours) == 0:
        return "yoopsie"
    #else:
        #print contours
    """blank_image = np.zeros((img.shape[0],img.shape[1],3),np.uint8)
    cv2.drawContours(blank_image,contours,-1,(255,255))
    cv2.imshow("imagiae",blank_image)
    cv2.waitKey()"""
    good_shape = []
    for c in contours:
        x,h = cv2.boundingRect(c)
        """rect = cv2.minAreaRect(contour)
        Box = cv2.BoxPoints(rect)
        Box = np.int0(Box)
        w = """
        #if h == 0:
        #    continue
        ratio = w / h
        ratio_grade = ratio / (TMw / TMh)
        if 0.2 < ratio_grade < 1.8:
            good_shape.append(c)
    """blank_image = np.zeros((img.shape[0],good_shape,255))
    cv2.imshow("imagia",blank_image)
    cv2.waitKey()"""
    return good_shape

def findCorners(contour):
    """blank_image = np.zeros((img.shape[0],contour,255))
    rows,cols = img.shape[0],img.shape[1]
    M = cv2.getRotationMatrix2D((cols/2,rows/2),-45,0.5)
    dst = cv2.warpAffine(blank_image,M,(cols,rows))
    cv2.imshow("rotatio",dst)
    cv2.waitKey()"""
    rect = cv2.minAreaRect(contour)
    Box = cv2.BoxPoints(rect)
    Box = np.int0(Box)
    height_px_1 = Box[0][1] - Box[3][1]
    height_px_2 = Box[1][1] - Box[2][1]
    print height_px_1, height_px_2
    if height_px_1 < height_px_2:
        close_height_px = height_px_2
        far_height_px = height_px_1
    else:
        close_height_px = height_px_1
        far_height_px = height_px_2
 
    return close_height_px, far_height_px

def findCorners(contour):
    rect = cv2.minAreaRect(contour)
    Box = cv2.BoxPoints(rect)
    Box = numpy.int0(Box)
    height_px_1 = Box[0][1] - Box[3][1]
    height_px_2 = Box[1][1] - Box[2][1]
    print height_px_1, far_height_px

def update(roi):
        img1b.setimage(roi.getArrayRegion(arr, img1a), levels=(0, arr.max()))
        img1c.setimage(np.int0(r.getMask(arr.shape)))
 
    # cell.sigRegionChanged.connect(update)
    # update(cell)

def get_bounding_rect(contour):
    rect = cv2.minAreaRect(contour)
    Box = cv2.BoxPoints(rect)
    return np.int0(Box)

def shi_tomasi(gray):
    # image????
    # maxCorners???????
    # qualityLevel?????????????????????
    # mindistance??????????
    corners = cv2.goodFeaturesToTrack(gray,25,0.01,10)
    cv2.computeCorrespondEpilines()
    # ?????? [[ 311.,250.]] ????????
    corners = np.int0(corners)
    return corners

def calculateFrame(self,cap):
        data = self.getDataPoints()
        #targetCascade = cv2.CascadeClassifier(cascPath)
        frame = cap.read()
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        lower_bound = np.array([float(data[''HMIN'']),float(data["SMIN"]),float(data[''VMIN''])])
        upper_bound = np.array([float(data[''HMAX'']),float(data["SMAX"]),float(data[''VMAX''])])
 
        hsv = cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)
        mask = cv2.inRange(hsv,lower_bound,upper_bound)
 
        largest_area = 0
        xCenter = -1
        yCenter = -1
        targetRect = None
 
        ret,thresh = cv2.threshold(mask,200,0)
        contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
 
    if len(contours) > 1:
        areas = [cv2.contourArea(c) for c in contours]
        max_index = np.argmax(areas)
        cnt = contours[max_index]
        rect = cv2.minAreaRect(cnt)
        Box = cv2.cv.BoxPoints(rect)
        Box = np.int0(Box)
 
        xCenter = (Box[0][0] + Box[1][0] + Box[2][0] + Box[3][0]) /4
        yCenter = (Box[0][1] + Box[1][1] + Box[2][1] + Box[3][1]) /4
        cv2.drawContours(frame,[Box],(0,2) 
 
 
        output = {}
    distance = 0.0025396523 * yCenter**2 + 0.1000098497 *yCenter + 46.8824851568
    theta = math.atan2(xCenter-160, distance)
        output_dict = {"xCenter": xCenter, "yCenter": yCenter,"theta": theta, "distance":distance}
        output = json.dumps(output_dict)
 
 
        return frame ,output , True, mask

def cfmask(mask, mask_values=(1,2,3,4, nodata=-9999):
    ''''''
    Returns a binary mask according to the CFMask algorithm results for the
    image; mask has True for water,cloud,shadow,and sNow (if any) and False
    everywhere else. More information can be found:
        https://landsat.usgs.gov/landsat-surface-reflectance-quality-assessment
 
    Landsat 4-7 Pre-Collection pixel_qa values to be masked:
        mask_values = (1,2,3,4)
 
    Landsat 4-7 Collection 1 pixel_qa values to be masked (for "Medium" confidence):
        mask_values = (1,68,72,80,112,132,136,144,160,176,224)
 
    Landsat 8 Collection 1 pixel_qa values to be masked (for "Medium" confidence):
        mask_values = (1,324,328,386,388,392,400,416,432,480,832,836,840,848,864,880,900,904,912,928,944,992,1024)
 
    Arguments:
        mask        A gdal.Dataset or a NumPy array
        mask_path   The path to an EOS HDF4 CFMask raster
        mask_values The values in the mask that correspond to NoData pixels
        nodata      The NoData value; defaults to -9999.
    ''''''
    if not isinstance(mask, np.ndarray):
        maskr = mask.ReadAsArray()
 
    else:
        maskr = mask.copy()
 
    # Mask according to bit-packing described here:
    # https://landsat.usgs.gov/landsat-surface-reflectance-quality-assessment
    maskr = np.in1d(maskr.reshape((maskr.shape[0] * maskr.shape[1])), mask_values)\\
        .reshape((1, maskr.shape[0], maskr.shape[1])).astype(np.int0)
 
    return maskr

def getTargetBox(target):
    minRect = cv2.minAreaRect(target)
    Box = cv2.cv.BoxPoints(minRect)
    #Box = np.int0(Box) # convert points to ints
    return Box

def validate_contour(contour, img, aspect_ratio_range, area_range):
    rect = cv2.minAreaRect(contour)
    img_width = img.shape[1]
    img_height = img.shape[0]
    Box = cv2.BoxPoints(rect) 
    Box = np.int0(Box)
 
    X = rect[0][0]
    Y = rect[0][1]
    angle = rect[2] 
    width = rect[1][0]
    height = rect[1][1]
 
    angle = (angle + 180) if width < height else (angle + 90)
 
    output=False
 
    if (width > 0 and height > 0) and ((width < img_width/2.0) and (height < img_width/2.0)):
        aspect_ratio = float(width)/height if width > height else float(height)/width
        if (aspect_ratio >= aspect_ratio_range[0] and aspect_ratio <= aspect_ratio_range[1]):
            if((height*width > area_range[0]) and (height*width < area_range[1])):
 
                Box_copy = list(Box)
                point = Box_copy[0]
                del(Box_copy[0])
                dists = [((p[0]-point[0])**2 + (p[1]-point[1])**2) for p in Box_copy]
                sorted_dists = sorted(dists)
                opposite_point = Box_copy[dists.index(sorted_dists[1])]
                tmp_angle = 90
 
                if abs(point[0]-opposite_point[0]) > 0:
                    tmp_angle = abs(float(point[1]-opposite_point[1]))/abs(point[0]-opposite_point[0])
                    tmp_angle = rad_to_deg(math.atan(tmp_angle))
 
                if tmp_angle <= 45:
                    output = True
    return output

def bBoxes_to_xys(bBoxes, image_shape):
    """Convert Seglink bBoxes to xys,i.e.,eight points
    The `image_shape` is used to to make sure all points return are valid,within image area
    """
    if len(bBoxes) == 0:
        return []
 
    assert np.ndim(bBoxes) == 2 and np.shape(bBoxes)[-1] == 5, ''invalid `bBoxes` param with shape =  '' + str(np.shape(bBoxes))
 
    h, w = image_shape[0:2]
    def get_valid_x(x):
        if x < 0:
            return 0
        if x >= w:
            return w - 1
        return x
 
    def get_valid_y(y):
        if y < 0:
            return 0
        if y >= h:
            return h - 1
        return y
 
    xys = np.zeros((len(bBoxes), 8))
    for bBox_idx, bBox in enumerate(bBoxes):
        bBox = ((bBox[0], bBox[1]), (bBox[2], bBox[3]), bBox[4])
        points = cv2.cv.BoxPoints(bBox)
        points = np.int0(points)
        for i_xy, y) in enumerate(points):
            x = get_valid_x(x)
            y = get_valid_y(y)
            points[i_xy, :] = [x, y]
        points = np.reshape(points, -1)
        xys[bBox_idx, :] = points
    return xys

def __init__(self, fname=None, include_orth=True, include_pols=True):
        if fname is None:
            # fname is the name of the file to read in the design matrix
            self.design = np.zeros([0, 0])
            self.n_col = 0
            # number of columns (conditions) in the design matrix
            self.column_types = np.ones(0)
            self.n_basis = 0
            self.n_stim = 0
            self.n_orth = 0
            self.StimLabels = []
        else:
            # isAFNI = re.match(r''.+[.](1D|1d|txt)$'',fname)
            filename, ext = os.path.splitext(fname)
            # We assume all AFNI 1D files have extension of 1D or 1d or txt
            if ext in [''.1D'', ''.1d'', ''.txt'']:
                self.read_afni(fname=fname)
 
        self.include_orth = include_orth
        self.include_pols = include_pols
        # The two flags above dictates whether columns corresponding to
        # baseline drift modeled by polynomial functions of time and
        # columns corresponding to other orthogonal signals (usually motion)
        # are included in nuisance regressors.
        self.cols_task = np.where(self.column_types == 1)[0]
        self.design_task = self.design[:, self.cols_task]
        if np.ndim(self.design_task) == 1:
            self.design_task = self.design_task[:, None]
        # part of the design matrix related to task conditions.
        self.n_TR = np.size(self.design_task, axis=0)
        self.cols_nuisance = np.array([])
        if self.include_orth:
            self.cols_nuisance = np.int0(
                np.sort(np.append(self.cols_nuisance,
                                  np.where(self.column_types == 0)[0])))
        if self.include_pols:
            self.cols_nuisance = np.int0(
                np.sort(np.append(self.cols_nuisance,
                                  np.where(self.column_types == -1)[0])))
        if np.size(self.cols_nuisance) > 0:
            self.reg_nuisance = self.design[:, self.cols_nuisance]
            if np.ndim(self.reg_nuisance) == 1:
                self.reg_nuisance = self.reg_nuisance[:, None]
        else:
            self.reg_nuisance = None
        # Nuisance regressors for motion,baseline,etc.