Keras-image

# import the necessary packages
from keras.preprocessing.image import ImageDataGenerator
from keras.preprocessing.image import img_to_array
from keras.preprocessing.image import load_img
import argparse
import cv2

############
#image basic
############

# Construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required = True,help = "Path to the image")
args = vars(ap.parse_args())

# im operations
image = cv2.imread(args["image"])  # Load the image and show some basic information on it
cv2.imshow("Image", image)  # Show the image
cv2.imwrite("newimage.jpg", image)  # Save the image
cv2.waitKey(0)  # wait for a keypress

# Crop
corner = image[0:100, 0:100]  

# Draw rectangle
cv2.rectangle(canvas, (200, 50), (225, 125), (255, 0, 0), -1)  
cv2.rectangle(output, (x - 2, y - 2), (x + w + 4, y + h + 4),(0, 255, 0), 1) 

# Convert 
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)  # HSV (Hue, Saturation, Value) color spaces
gray = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)  # L*a*b* color spaces

# Flip 
flipped = cv2.flip(image, 1)  # horizontally
flipped = cv2.flip(image, 0)  # vertically
flipped = cv2.flip(image, -1)  # along both axes

# Resize 
resized = cv2.resize(image, dim, interpolation = cv2.INTER_AREA)
resized = imutils.resize(image, width = 100, height=100, inter=cv2.INTER_AREA)  # we can specify our target width or height

# Rotate 
rotated = imutils.rotate(image, 180)

# Split and Merge 
(B, G, R) = cv2.split(image)
merged = cv2.merge([B, G, R])

# Translate
shifted = imutils.translate(image, 0, 100)

# color histogram 
hist = cv2.calcHist([chan], [0], None, [256], [0, 256])  # 1D color histogram
hist = cv2.calcHist([chans[1], chans[0]], [0, 1], None,[32, 32], [0, 256, 0, 256])  # 2D color histogram

# Apply histogram equalization to stretch the constrast of our image
eq = cv2.equalizeHist(image)

# Blurr 
blurred = cv2.blur(image, (3, 3))  # Averaged
blurred = cv2.GaussianBlur(image, (3, 3), 0)  # GaussianBlur
blurred = cv2.medianBlur(image, 3)  # medianBlur
blurred = cv2.bilateralFilter(image, 5, 21, 21)  # bilateralFilter

# Simple Threshold
(T, threshInv) = cv2.threshold(blurred, 155, 255, cv2.THRESH_BINARY_INV)
(T, thresh) = cv2.threshold(blurred, 155, 255, cv2.THRESH_BINARY)

# Adaptive Threshold
image = cv2.imread(args["image"])
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(image, (5, 5), 0)
thresh = cv2.adaptiveThreshold(blurred, 255,cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 11, 4)  # Mean Thresh
thresh = cv2.adaptiveThreshold(blurred, 255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 15, 3)  # Gaussian Thresh

#Canny
image = cv2.imread(args["image"])
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
image = cv2.GaussianBlur(image, (5, 5), 0)
canny = cv2.Canny(image, 30, 150)

# Compute the Laplacian of the image
lap = cv2.Laplacian(image, cv2.CV_64F)
lap = np.uint8(np.absolute(lap))

# Compute gradients along the X and Y axis, respectively
sobelX = cv2.Sobel(image, cv2.CV_64F, 1, 0)
sobelY = cv2.Sobel(image, cv2.CV_64F, 0, 1)

# Pad
gray = cv2.copyMakeBorder(gray, 20, 20, 20, 20, cv2.BORDER_REPLICATE)

# Find the Right Contours
(_, cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(coins, cnts, -1, (0, 255, 0), 2)
(x, y, w, h) = cv2.boundingRect(c)
((centerX, centerY), radius) = cv2.minEnclosingCircle(c)

# Text
cv2.putText(image, str(digit), (x - 10, y - 10),cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 255, 0), 2)



##############
#image imutils
##############
def translate(image, x, y):
	# Define the translation matrix and perform the translation
	M = np.float32([[1, 0, x], [0, 1, y]])
	shifted = cv2.warpAffine(image, M, (image.shape[1], image.shape[0]))

	# Return the translated image
	return shifted

def rotate(image, angle, center = None, scale = 1.0):
	# Grab the dimensions of the image
	(h, w) = image.shape[:2]

	# If the center is None, initialize it as the center of
	# the image
	if center is None:
		center = (w / 2, h / 2)

	# Perform the rotation
	M = cv2.getRotationMatrix2D(center, angle, scale)
	rotated = cv2.warpAffine(image, M, (w, h))

	# Return the rotated image
	return rotated

def resize(image, width = None, height = None, inter = cv2.INTER_AREA):
	# initialize the dimensions of the image to be resized and
	# grab the image size
	dim = None
	(h, w) = image.shape[:2]

	# if both the width and height are None, then return the
	# original image
	if width is None and height is None:
		return image

	# check to see if the width is None
	if width is None:
		# calculate the ratio of the height and construct the
		# dimensions
		r = height / float(h)
		dim = (int(w * r), height)

	# otherwise, the height is None
	else:
		# calculate the ratio of the width and construct the
		# dimensions
		r = width / float(w)
		dim = (width, int(h * r))

	# resize the image
	resized = cv2.resize(image, dim, interpolation = inter)

	# return the resized image
	return resized

###################
#image augmentation
###################
print("[INFO] loading example image...")
image = load_img(args["image"])
image = img_to_array(image)
image = np.expand_dims(image,axis=0)

aug = ImageDataGenerator(rotation_range=30, width_shift_range=0.1, height_shift_range=0.1,
	shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode="nearest")
total = 0

print("[INFO] generating images...")
imageGen = aug.flow(image, batch_size=1, save_to_dir=args["output"],
	save_prefix=args["prefix"], save_format="jpg")

for image in imageGen:
	total += 1
	if total == 10:
		break

####################
#image preprocessing
####################
imagePaths = list(paths.list_images(args["dataset"]))
classNames = [pt.split(os.path.sep)[-2] for pt in imagePaths]
classNames = [str(x) for x in np.unique(classNames)]

aap = AspectAwarePreprocessor(64,64)
iap = ImageToArrayPreprocessor()

sdl = SimpleDatasetLoader(preprocessors=[aap,iap])
(data,labels) = sdl.load(imagePaths, verbose=500)

#################
#image processing
#################

# loop over the input images
for imagePath in sorted(list(paths.list_images(args["dataset"]))):
    # load the image, pre-process it, and store it in the data list
    image = cv2.imread(imagePath)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    image = imutils.resize(image, width=28)  /  image = preprocess(image, 28, 28)
    image = img_to_array(image)
    data.append(image)

    # extract the class label from the image path and update the labels list
    label = imagePath.split(os.path.sep)[-2]
    labels.append(label)

# randomly sample a few of the input images
imagePaths = list(paths.list_images(args["input"]))
imagePaths = np.random.choice(imagePaths, size=(10,),replace=False)

##############
#image testing
##############

# loop over the image paths
for imagePath in imagePaths:
    # load the image and convert it to grayscale, then pad the image
    # to ensure digits caught only the border of the image are
    # retained
    image = cv2.imread(imagePath)

    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    gray = cv2.copyMakeBorder(gray, 20, 20, 20, 20, cv2.BORDER_REPLICATE)

    # threshold the image reveal the digits
    thresh = cv2.threshold(gray, 0, 255,
        cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]

    # find contours in the image, keeping only the four largest ones.
    # then sort them from left to right.
    cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    cnts = cnts[0] if imutils.is_cv2() else cnts[1]
    cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:4]
    cnts = contours.sort_contours(cnts)[0]

    # initialize the output image as "grayscale" image with 3 channels along
    # with the output predictions
    output = cv2.merge([gray] * 3)
    predictions = []

    for c in cnts:
        (x, y, w, h) = cv2.boundingRect(c)
        roi = gray[y - 5:y + h + 5, x - 5:x + w + 5]
        roi = preprocess(roi, 28, 28)
        roi = np.expand_dims(img_to_array(roi), axis=0)

        pred = model.predict(roi).argmax(axis=1)[0] + 1
        predictions.append(str(pred))

        # draw the prediction on the output image
        cv2.rectangle(output, (x - 2, y - 2), (x + w + 4, y + h + 4),(0, 255, 0), 1)
        cv2.putText(output, str(pred), (x - 5, y - 5), cv2.FONT_HERSHEY_SIMPLEX,0.55, (0, 255, 0), 2)

        # show the output image
        print("[INFO] captcha: {}".format("".join(predictions)))
        cv2.imshow("Output", output)
        cv2.waitKey()

#################
#image annotating
#################
for (i, imagePath) in enumerate(imagePaths):
    print("[INFO] processing image {}/{}".format(i + 1, len(imagePaths)))

    try:
        # load image
        image = cv2.imread(imagePath)

        # convert to grayscale
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        # add padding
        gray = cv2.copyMakeBorder(gray, 8, 8, 8, 8, cv2.BORDER_REPLICATE)

        # threshold to black/white
        thresh = cv2.threshold(gray, 0, 255,cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]

        # find contours
        cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
        cnts = cnts[0] if imutils.is_cv2() else cnts[1]
        cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:4]

        # loop over each contour and extract the image
        for c in cnts:
            # compute bounding box for the contour
            (x, y, w, h) = cv2.boundingRect(c)
            roi = gray[y - 5:y + h + 5, x -  5:x + w + 5]

            # display the chracter, making it large enough for us to see, then
            # wait for keypress
            cv2.imshow("ROI", imutils.resize(roi, width=28))
            key = cv2.waitKey(0)

            if key == ord("`"):
                print("[INFO] ignoring character")
                continue

            # grab the key that was pressed and construct path to output
            # directory
            key = chr(key).upper()
            dirPath = os.path.sep.join([args["annot"], key])

            # if output directory does not exists, create it
            if not os.path.exists(dirPath):
                os.makedirs(dirPath)

            # write the labeled character to file
            count = counts.get(key, 1)
            p = os.path.sep.join([dirPath,"{}.png".format(str(count).zfill(6))])
            cv2.imwrite(p, roi)

            counts[key] = count + 1
    except KeyboardInterrupt:
        print("[INFO] manually leaving script")
        break
    except:
        # unkown error
        print("[INFO] skipping image...")

##################
#image downloading
##################
for i in range(0, args["num_images"]):
    try:
        # fetch the image
        r = requests.get(url, timeout=60)

        # save the image to disc
        p = os.path.join(args["output"], "{}.jpg".format(str(total).zfill(5)))

        f = open(p, "wb")
        f.write(r.content)
        f.close()

        # update counter
        print("[INFO] downloaded: {}".format(p))
        total += 1
    except:
        print("[INFO] error downloading image...")

    # sleep
    time.sleep(0.1)

#############
#video stream
#############

# if no video was supplied, use the webcam
if not args.get("video", False):
    camera = cv2.VideoCapture(0)
# otherwise load the video
else:
    camera = cv2.VideoCapture(args["video"])

while True:
    # grab the current frame
    (grabbed, frame) = camera.read()

    # if we are viewing a video and did not a grab a frame then we have reached
    # the end of the video
    if args.get("video") and not grabbed:
        break

    # resize, convert to grayscale, and then clone it (so we can annotate it)
    frame = imutils.resize(frame, width=300)
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    frameClone = frame.copy()

    # detect faces in the input frame, then clone the frame so we can draw on it
    rects = detector.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5,
        minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE)

    # loop over the detected bounding boxes
    for (fX, fY, fW, fH) in rects:
        # extract the ROI of the face from the grayscale image, resize it
        # to 28x28, and then prepare the ROI for classification
        roi = gray[fY:fY + fH, fX:fX + fW]
        roi = cv2.resize(roi, (28, 28))
        roi = roi.astype("float") / 255.0
        roi = img_to_array(roi)
        roi = np.expand_dims(roi, axis=0)

        (notSmiling, smiling) = model.predict(roi)[0]
        label = "Smiling" if smiling > notSmiling else "Not Smiling"

        cv2.putText(frameClone, label, (fX, fY - 10), cv2.FONT_HERSHEY_SIMPLEX,0.45, (0, 0, 255), 2)
        cv2.rectangle(frameClone, (fX, fY), (fX + fW, fY + fH), (0, 0, 255), 2)

        cv2.imshow("Face", frameClone)

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
# clean up
camera.release()
cv2.destroyAllWindows()