How to use the imutils.object_detection.non_max_suppression function in imutils

scales = [(200,200), (300,300)]
#        scales = [(200,200), (250, 250), (300,300)]
        for (winW,winH) in scales:
            for (x, y, window) in sliding_window(image, stepSize=100, windowSize=(winW,winH)):
                result = 0
                if window.shape[0] != winH or window.shape[1] != winW:
                    continue
                if window.shape[0] != 200 or window.shape[1] != 200:
                    window = cv2.resize(window,(200,200),interpolation=cv2.INTER_CUBIC)
                    win_fd = getFeat(window)
                    win_fd.shape = 1,-1
                    result = int(clf.predict(win_fd))
                    if result == 1:
                        rects.append([x, y, x + winW, y + winH])
        rects = np.array(rects)
        pick = non_max_suppression(rects, probs=None, overlapThresh=0.1)
        minx = 10000
        miny = 10000
        maxx = 0
        maxy = 0
        for (xA, yA, xB, yB) in pick:
            if xA < minx:
                minx = xA
            if yA < miny:
                miny = yA
            if xB > maxx:
                maxx = xB
            if yB > maxy:
                maxy = yB
        if (abs(maxx - minx) < image.shape[1]) and (abs(maxy - miny) < image.shape[0]):
            cv2.rectangle(image, (minx, miny), (maxx, maxy), (0, 255, 0), 2)
        cv2.imshow("After NMS", image)

def suppress(boxes, shape):
    rects = rects_from_boxes(boxes, shape)
    picked = non_max_suppression(rects, overlapThresh=.065)
    # print(picked)
    ans = []
    for (x, y, x2, y2) in picked:
        for box in boxes:
            (X, Y, X2, Y2) = box
            if isclose(x, X * shape[0], abs_tol=2) and \
                    isclose(y, Y * shape[1], abs_tol=2) and \
                    isclose(x2, X2 * shape[0], abs_tol=2) and \
                    isclose(y2, Y2 * shape[1], abs_tol=2):
                ans.append(box)
    return ans

(123.68, 116.78, 103.94), swapRB=True, crop=False)
	net.setInput(blob)
	(scores, geometry) = net.forward(layerNames)
 
	# decode the predictions, then  apply non-maxima suppression to
	# suppress weak, overlapping bounding boxes
	(rects, confidences) = decode_predictions(scores, geometry)
	predictedTexts=0
	for val in confidences:
	    if val>0.5:
	       predictedTexts=predictedTexts+1
	
	conf=np.array(confidences)
    #print("the number of words/confidences is: ",str(predictedTexts),"/",str(len(confidences)))
	print("the confidences are :"+str(confidences))
	boxes = non_max_suppression(np.array(rects), probs=confidences)
    
	# loop over the bounding boxes
	for (startX, startY, endX, endY) in boxes:
		# scale the bounding box coordinates based on the respective
		# ratios
		startX = int(startX * rW)-10
		startY = int(startY * rH)-10
		endX = int(endX * rW)+10
		endY = int(endY * rH)+10

		# draw the bounding box on the frame
		cv2.rectangle(orig, (startX, startY), (endX, endY), (125, 255, 35), 2)
    # update the FPS counter
	fps.update()
 
	# show the output frame

ret, frame = cap.read()

        # frame1 = frame.clone()
        # frame1 = np.array(frame)

        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        gray = imutils.resize(gray )

        (rects, weights) = hog.detectMultiScale(gray, winStride=(4, 4),
                padding=(8, 8), scale=1.05)
        
        # for (x, y, w, h) in rects:
        #     cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
        
        rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects])
        pick = non_max_suppression(rects, probs=None, overlapThresh=0.65)

        # Write to csv, first column: frame number, 2nd column: no. of peoples
        peoplewriter.writerow([cap.get(1), len(pick)])
        for (xA, yA, xB, yB) in pick:
            cv2.rectangle(frame, (xA, yA), (xB, yB), (0, 255, 0), 2)
        
        # cv2.imshow('orig', frame)
        # cv2.imshow('non_max', frame)

        # index += 1
        # if index == 500:
        #     break
        out.write(frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

if window.shape[0] != winH or window.shape[1] != winW:
                continue
            cv2.imshow("asd", window)
            cv2.waitKey(0)
            print window.shape
            if window.shape[0] != 200 or window.shape[1] != 200:
                window = cv2.resize(window,(200,200),interpolation=cv2.INTER_CUBIC)
            win_fd = getFeat(window)
            win_fd.shape = 1,-1
            result = int(clf.predict(win_fd))
            print 'smamll image result is %d' %result
            if result == 1:
                rects.append([x, y, x + winW, y + winH])
                cv2.rectangle(orig, (x, y), (x + winW, y + winH), (0, 0, 255), 2)
    rects = np.array(rects)
    pick = non_max_suppression(rects, probs=None, overlapThresh=0.65)
    for (xA, yA, xB, yB) in pick:
        cv2.rectangle(image, (xA, yA), (xB, yB), (0, 255, 0), 2)
    t1 = time.time()
    print 'The cast of time is :%f seconds' % (t1-t0)
    cv2.imshow("Before NMS", orig)
    cv2.imshow("After NMS", image)
    cv2.waitKey(0)

def detect_people(frame):
    """
    detect humans using HOG descriptor
    Args:
        frame:
    Returns:
        processed frame
    """
    (rects, weights) = hog.detectMultiScale(frame, winStride=(8, 8), padding=(16, 16), scale=1.06)
    rects = non_max_suppression(rects, probs=None, overlapThresh=0.65)
    for (x, y, w, h) in rects:
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
    return frame

def detect_people(frame):
	"""
	detect humans using HOG descriptor
	Args:
		frame:
	Returns:
		processed frame
	"""
	(rects, weights) = hog.detectMultiScale(frame, winStride=(4, 4), padding=(16, 16), scale=1.06)
	rects = non_max_suppression(rects, probs=None, overlapThresh=0.65)
	for (x, y, w, h) in rects:
		cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
	return frame

# compute both the starting and ending (x, y)-coordinates for
        # the text prediction bounding box
        endX = int(offsetX + (cos * xData1[x]) + (sin * xData2[x]))
        endY = int(offsetY - (sin * xData1[x]) + (cos * xData2[x]))
        startX = int(endX - w)
        startY = int(endY - h)

        # add the bounding box coordinates and probability score to
        # our respective lists
        rects.append((startX, startY, endX, endY))
        confidences.append(scoresData[x])

# apply non-maxima suppression to suppress weak, overlapping bounding
# boxes
boxes = non_max_suppression(np.array(rects), probs=confidences)

# loop over the bounding boxes
for (startX, startY, endX, endY) in boxes:
    # scale the bounding box coordinates based on the respective
    # ratios
    startX = int(startX * rW)
    startY = int(startY * rH)
    endX = int(endX * rW)
    endY = int(endY * rH)

    # draw the bounding box on the image
    cv2.rectangle(orig, (startX, startY), (endX, endY), (0, 255, 0), 2)

# show the output image
cv2.imshow("Text Detection", orig)
cv2.waitKey(0)

image = cv2.resize(self.image, (320, 320))
        (H, W) = image.shape[:2]

        # construct a blob from the image and then perform a forward pass of
        # the model to obtain the two output layer sets
        blob = cv2.dnn.blobFromImage(
            self.image, 1.0, (W, H), (123.68, 116.78, 103.94), swapRB=True, crop=False
        )

        self.net.setInput(blob)
        (scores, geometry) = self.net.forward(self.layerNames)

        rects, confidences = self.__decode_predictions(scores, geometry)
        # apply non-maxima suppression to suppress weak, overlapping bounding
        # boxes
        boxes = non_max_suppression(np.array(rects), probs=confidences)
        text_rects = []
        # loop over the bounding boxes
        for (startX, startY, endX, endY) in boxes:
            # scale the bounding box coordinates based on the respective
            # ratios

            startX = int(startX * rW)
            startY = int(startY * rH)
            endX = int(endX * rW)
            endY = int(endY * rH)
            cv2.rectangle(self.image, (startX, startY), (endX, endY), (0, 0, 255), 3)
            text_rects.append([startX, startY, endX, endY])

        text_rects = sorted(text_rects, key=lambda item: item[0])
        final_rects = text_rects
        if len(text_rects) > 0:

image = cv2.imread(imagePath)

# Resize the image so it fits in the screen
image1 = imutils.resize(image, height=500)
gray = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)

# Detect faces in the image
faces = car_cascade.detectMultiScale(
    gray,
    scaleFactor=1.1,
    minNeighbors=5,
    minSize=(30, 30),
    # flags = cv2.cv.CV_HAAR_SCALE_IMAGE
    flags=0
)
face = non_max_suppression(faces, probs=None, overlapThresh=0.3)
if format(len(faces)) == 1:
    print("Found {0} face!".format(len(faces)))
else:
    print("Found {0} faces!".format(len(faces)))

# Draw a rectangle around the faces
for (x, y, w, h) in face:
    cv2.rectangle(image1, (x, y), (x + w, y + h), (0, 255, 0), 2)

cv2.imshow("Faces found", image1)
cv2.waitKey(0)