def processAndClassify(frame):
backgroundClass = 3
predictionArray = []
centroidArray = []
# Convert the image into a grayscale image
grayScaleInput = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Apply meanshift on the RGB image
meanShiftResult = prePro.meanShift(frame)
# Convert the result of the Mean shifted image into Grayscale
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
# Apply adaptive thresholding on the resulting greyscale image
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
# Draw Contours on the Input image with results from the meanshift
contourPlot = prePro.contourDraw(frame, meanShiftAdapResult)
# Find the contours on the mean shifted image
contours, hierarchy = prePro.contourFindFull(meanShiftAdapResult)
# Find the contours on the mean shifted image
boundBoxContour = grayScaleInput.copy()
frameBoundingBox = frame.copy()
# For each contour
for cnt in contours:
# If the area covered by the contour is greater than 500 pixels
if cv2.contourArea(cnt)>20:
# Get the bounding box of the contour
[x, y, w, h] = cv2.boundingRect(cnt)
# Get the moments of the each contour for computing the centroid of the contour
moments = cv2.moments(cnt)
if moments['m00']!=0:
cx = int(moments['m10']/moments['m00']) # cx = M10/M00
cy = int(moments['m01']/moments['m00']) # cy = M01/M00
centroid = (cx,cy)
# cx,cy are the centroid of the contour
extendBBox = 10
# Extend it by 10 pixels to avoid missing the key points on the edges
roiImage = boundBoxContour[y-extendBBox:y+h+extendBBox, x-extendBBox:x+w+extendBBox]
roiImageFiltered = roiImage
# Detect the corner key points
kp, roiKeyPointImage = detDes.featureDetectCorner(roiImageFiltered)
# Use the ORB feature detector and descriptor on the contour
kp, des, roiKeyPointImage = detDes.featureDescriptorORB(roiImageFiltered, kp)
if np.size(kp)>0:
histPoints = tH.histogramContour(des)
prediction = tC.classify(np.float32(histPoints))
## If the predicted class is not the background class then add the prediction to the prediction array and get its centroid
if prediction != backgroundClass:
cv2.rectangle(frameBoundingBox,(x,y),(x+w,y+h),(0,255,0),2)
return contourPlot
def processAndClassify(frame):
backgroundClass = 3
predictionArray = []
centroidArray = []
# Convert the image into a grayscale image
grayScaleInput = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Apply meanshift on the RGB image
meanShiftResult = prePro.meanShift(frame)
# Convert the result of the Mean shifted image into Grayscale
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
# Apply adaptive thresholding on the resulting greyscale image
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
# Draw Contours on the Input image with results from the meanshift
contourPlot = prePro.contourDraw(frame, meanShiftAdapResult)
#cv2.imwrite('contourPlot.png',contourPlot)
# Find the contours on the mean shifted image
contours, hierarchy = prePro.contourFindFull(meanShiftAdapResult)
# Find the contours on the mean shifted image
boundBoxContour = grayScaleInput.copy()
frameBoundingBox = frame.copy()
# For each contour
for cnt in contours:
# If the area covered by the contour is greater than 500 pixels
if cv2.contourArea(cnt) > 20:
# Get the bounding box of the contour
[x, y, w, h] = cv2.boundingRect(cnt)
# Get the moments of the each contour for computing the centroid of the contour
moments = cv2.moments(cnt)
if moments['m00'] != 0:
cx = int(moments['m10'] / moments['m00']) # cx = M10/M00
cy = int(moments['m01'] / moments['m00']) # cy = M01/M00
centroid = (cx, cy)
# cx,cy are the centroid of the contour
extendBBox = 10
# Extend it by 10 pixels to avoid missing the key points on the edges
roiImage = boundBoxContour[y - extendBBox:y + h + extendBBox,
x - extendBBox:x + w + extendBBox]
roiImageFiltered = roiImage
# Detect the corner key points
kp, roiKeyPointImage = detDes.featureDetectCorner(
roiImageFiltered)
# Use the ORB feature detector and descriptor on the contour
kp, des, roiKeyPointImage = detDes.featureDescriptorORB(
roiImageFiltered, kp)
if np.size(kp) > 0:
histPoints = tH.histogramContour(des)
prediction = tC.classify(np.float32(histPoints))
## If the predicted class is not the background class then add the prediction to the prediction array and get its centroid
if prediction != backgroundClass:
cv2.rectangle(frameBoundingBox, (x, y), (x + w, y + h),
(0, 255, 0), 2)
return predictionArray, centr
import cv2
from matplotlib import pyplot as plt
import preObj as prePro
import detectorDescriptor2 as detDes
import glob
import os
formatName = '*.jpg'
fileList = glob.glob('dataset/' + formatName)
for fileName in fileList:
image = cv2.imread(fileName)
grayScaleInput = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Apply meanshift on the RGB image
meanShiftResult = prePro.meanShift(image)
# Convert the result of the Mean shifted image into Grayscale
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
# Apply adaptive thresholding on the resulting greyscale image
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
# Draw Contours on the Input image with results from the meanshift
contourPlot = prePro.contourDraw(image, meanShiftAdapResult)
cv2.imshow('contourplot', contourPlot)
# Find the contours on the mean shifted image
contours, hierarchy = prePro.contourFind(meanShiftAdapResult)
## Use Histogram equalization
boundBoxContour = grayScaleInput.copy()
count = 0
# For each contour
for cnt in contours:
listDir.append("TrainingSetNao/phone/red_blinds_closed/")
listDir.append("TrainingSetNao/phone/red_blinds_open/")
listDir.append("TrainingSetNew/apple/")
listDir.append("TrainingSetNew/banana/")
listDir.append("TrainingSetNew/cube/")
dirCount = 0
for direct in listDir:
fileList = glob.glob(rootInputName + listDir[dirCount] + formatName)
print("Current Directory Name:" + rootInputName + listDir[dirCount])
count = 0
for files in fileList:
inputImage = cv2.imread(fileList[count])
print("Processing Image " + fileList[count])
grayScaleInput = cv2.cvtColor(inputImage, cv2.COLOR_BGR2GRAY)
meanShiftResult = prePro.meanShift(inputImage)
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
contourPlot = prePro.contourDraw(inputImage, meanShiftAdapResult)
contours, hierarchy = prePro.contourFindFull(meanShiftAdapResult)
boundBoxContour = grayScaleInput.copy()
counter = 0
for cnt in contours:
if cv2.contourArea(cnt) > 500:
print("Processing Contour no.", str(counter))
[x, y, w, h] = cv2.boundingRect(cnt)
extendBBox = 10
roiImage = boundBoxContour[y - extendBBox:y + h + extendBBox,
x - extendBBox:x + w + extendBBox]
rootOutputName = "TrainingSet/newDatasetPrep/contours/"
rootMeanName = "TrainingSet/newDatasetPrep/meanShift/"
rootAdapThreshold = "TrainingSet/newDatasetPrep/adapThreshold/"
rootContourDraw = "TrainingSet/newDatasetPrep/contourDraw/"
formatName = "*.jpg"
fileList = glob.glob(rootInputName + formatName)
print ("Current Directory Name:" + rootInputName)
count = 0
for files in fileList:
inputImage=cv2.imread(fileList[count])
fileName = os.path.basename(fileList[count])
print ("Processing Image " + fileList[count])
grayScaleInput = cv2.cvtColor(inputImage, cv2.COLOR_BGR2GRAY)
meanShiftResult = prePro.meanShift(inputImage)
cv2.imwrite(rootMeanName + fileName, meanShiftResult)
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
cv2.imwrite(rootAdapThreshold + fileName, meanShiftAdapResult)
contourPlot = prePro.contourDraw(inputImage, meanShiftAdapResult)
cv2.imwrite(rootContourDraw + fileName, contourPlot)
print ("Preprocessing Results Written.")
contours, hierarchy = prePro.contourFindFull(meanShiftAdapResult)
boundBoxContour = grayScaleInput.copy()
counter = 0
for cnt in contours:
import cv2
from matplotlib import pyplot as plt
import preObj as prePro
import detectorDescriptor2 as detDes
import glob
import os
formatName = '*.jpg'
fileList = glob.glob('dataset/' + formatName)
for fileName in fileList:
image = cv2.imread(fileName)
grayScaleInput = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Apply meanshift on the RGB image
meanShiftResult = prePro.meanShift(image)
# Convert the result of the Mean shifted image into Grayscale
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
# Apply adaptive thresholding on the resulting greyscale image
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
# Draw Contours on the Input image with results from the meanshift
contourPlot = prePro.contourDraw(image, meanShiftAdapResult)
cv2.imshow('contourplot',contourPlot)
# Find the contours on the mean shifted image
contours, hierarchy = prePro.contourFind(meanShiftAdapResult)
## Use Histogram equalization
boundBoxContour = grayScaleInput.copy()
count = 0
# For each contour
for cnt in contours:
#listDir.append("TrainingSetOccMul/")
dirCount = 0
for direct in listDir:
fileList = glob.glob(rootInputName + listDir[dirCount] + formatName)
print("Current Directory Name:" + rootInputName + listDir[dirCount])
count = 0
for files in fileList:
frame = cv2.imread(fileList[count])
base = os.path.basename(files)
fileName = os.path.splitext(base)[0]
print("Processing Image " + fileList[count])
time_whole_begin = time.time()
grayScaleInput = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Apply meanshift on the RGB image
time_meanshift_begin = time.time()
meanShiftResult = prePro.meanShift(frame)
time_meanshift_end = time.time()
# Convert the result of the Mean shifted image into Grayscale
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
# Apply adaptive thresholding on the resulting greyscale image
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
'''########################################################################################################################
Uncomment the following lines to add morphology
Comment the following lines if morphology need not be used
############################################## Morphology begins ##########################################################################'''
# kernel = np.ones((5,5),np.uint8)
# opening = cv2.dilate(meanShiftAdapResult,kernel,iterations=1)
# # Draw Contours on the Input image with results from the meanshift
def processAndClassify(frame,networkTopology, network,trainingParameters):
objects = ['basket', 'kettle', 'milk', 'mug', 'Background'];
#'coffeemug', 'kettleBackground','milkcartonBackground','trashcanBackground', 'mugBackground',
backgroundClass = 3
predictionArray = []
centroidArray = []
labels = []
# Convert the image into a grayscale image
framecopy = frame.copy()
#grayScaleInput = cv2.cvtColor(framecopy, cv2.COLOR_BGR2GRAY)
# Apply meanshift on the RGB image
meanShiftResult = prePro.meanShift(np.uint8(framecopy))
#plt.imshow(meanShiftResult)
# Convert the result of the Mean shifted image into Grayscale
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
# Apply adaptive thresholding on the resulting greyscale image
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
# kernel = np.ones((5,5),np.uint8)
# opening = cv2.dilate(meanShiftAdapResult,kernel,iterations=1)
# Draw Contours on the Input image with results from the meanshift
# Find the contours on the mean shifted image
contours, hierarchy = prePro.contourFindFull(meanShiftAdapResult)
## Use Histogram equalabs
#boundingBoxContour = opening
boundBoxContour = framecopy.copy()
#boundBoxContour = cv2.equalizeHist(grayScaleInput.copy())
#heatmap = frame.copy()
#heatmapFromZeros = np.zeros(np.shape(frame))
count = 0
# For each contour
for cnt in contours:
prediction = None
# If the area covered by the contour is greater than 500 pixels
if cv2.contourArea(cnt)>500:
# Get the bounding box of the contour
[x, y, w, h] = cv2.boundingRect(cnt)
# Get the moments of the each contour for computing the centroid of the contour
moments = cv2.moments(cnt)
if moments['m00']!=0:
cx = int(moments['m10']/moments['m00']) # cx = M10/M00
cy = int(moments['m01']/moments['m00']) # cy = M01/M00
centroid = (cx,cy)
# cx,cy are the centroid of the contour
extendBBox20 = 20
extendBBox10 = 10
left = 0
right = 0
top = 0
bottom = 0
#
#Extend it by 10 pixels to avoid missing the key points on the edges
if x-extendBBox20 > 0:
left = x-extendBBox20
elif x-extendBBox10 > 0:
left = x-extendBBox10
else:
left = x
if y-extendBBox20 > 0:
top = y-extendBBox20
elif y-extendBBox10 > 0:
top = y-extendBBox10
else:
top = y
if x+w+extendBBox20 < boundBoxContour.shape[0]:
right = x+w+extendBBox20
elif x+w+extendBBox10 < boundBoxContour.shape[0]:
right = x+w+extendBBox10
else:
right = x+w
if y+h+extendBBox20 < boundBoxContour.shape[1]:
bottom = y+h+extendBBox20
elif y+h+extendBBox10 < boundBoxContour.shape[1]:
bottom = y+h+extendBBox10
else:
bottom = y+h
roiImage = boundBoxContour[top:bottom,left:right]
#roiImage = boundBoxContour[y-extendBBox:y+h+extendBBox, x-extendBBox:x+w+extendBBox]
#roiImageFiltered = cv2.equalizeHist(roiImage)
roiImageFiltered = cv2.resize(roiImage,(100,100))
count +=1
roiImageFiltered,roiImageFilteredframe = DataUtil.prepareDataLive(roiImageFiltered, DataUtil.DATA_MODALITY["Image"], networkTopology[6][0][0][4])
prediction = MCCNN.classify(network[len(network)-1],[roiImageFiltered],trainingParameters[4])[0]
if prediction < backgroundClass and prediction != 1:
predictionArray.append(prediction)
centroidArray.append(centroid)
labels.append(objects[np.int(prediction)])
#heatmap[y:y+h,x:x+w] = prediction
#heatmapFromZeros[y:y+h,x:x+w] = prediction
#################### Code using SIFT/ORB Features ###########################
# Detect the corner key points
# kp, roiKeyPointImage = detDes.featureDetectCorner(roiImageFiltered)
#
# # Use the ORB feature detector and descriptor on the contour
# kp, des, roiKeyPointImage = detDes.featureDetectDesSIFT(roiImageFiltered, kp)
# if np.size(kp)>0:
# histPoints = tH.histogramContour(des,codeBookCenters)
# prediction = tC.classify(histPoints, svm)
#print prediction
## If the predicted class is not the background class then add the prediction to the prediction array and get its centroid
#heatmapFromZeros.convertTo(heatmap, cv2.CV_8UC1)
#plt.imshow(heatmapFromZeros)
return predictionArray, centroidArray,labels
def processAndClassify(frame,codeBookCenters, svm):
objects = ['waterkettle', 'milkcarton', 'trashcan', 'coffeemug', 'kettleBackground','milkcartonBackground','trashcanBackground', 'mugBackground', 'Background'];
backgroundClass = 10
predictionArray = []
centroidArray = []
labels = []
# Convert the image into a grayscale image
framecopy = frame.copy()
grayScaleInput = cv2.cvtColor(framecopy, cv2.COLOR_BGR2GRAY)
# Apply meanshift on the RGB image
meanShiftResult = prePro.meanShift(np.uint8(framecopy))
#plt.imshow(meanShiftResult)
# Convert the result of the Mean shifted image into Grayscale
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
# Apply adaptive thresholding on the resulting greyscale image
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
# kernel = np.ones((5,5),np.uint8)
# opening = cv2.dilate(meanShiftAdapResult,kernel,iterations=1)
# Draw Contours on the Input image with results from the meanshift
# Find the contours on the mean shifted image
contours, hierarchy = prePro.contourFindFull(meanShiftAdapResult)
## Use Histogram equalabs
#boundingBoxContour = opening
boundBoxContour = grayScaleInput.copy()
#boundBoxContour = cv2.equalizeHist(grayScaleInput.copy())
count = 0
# For each contour
for cnt in contours:
# If the area covered by the contour is greater than 500 pixels
if cv2.contourArea(cnt)>500:
# Get the bounding box of the contour
[x, y, w, h] = cv2.boundingRect(cnt)
# Get the moments of the each contour for computing the centroid of the contour
moments = cv2.moments(cnt)
if moments['m00']!=0:
cx = int(moments['m10']/moments['m00']) # cx = M10/M00
cy = int(moments['m01']/moments['m00']) # cy = M01/M00
centroid = (cx,cy)
# cx,cy are the centroid of the contour
extendBBox20 = 20
extendBBox10 = 10
left = 0
right = 0
top = 0
bottom = 0
#
#Extend it by 10 pixels to avoid missing the key points on the edges
if x-extendBBox20 > 0:
left = x-extendBBox20
elif x-extendBBox10 > 0:
left = x-extendBBox10
else:
left = x
if y-extendBBox20 > 0:
top = y-extendBBox20
elif y-extendBBox10 > 0:
top = y-extendBBox10
else:
top = y
if x+w+extendBBox20 < boundBoxContour.shape[0]:
right = x+w+extendBBox20
elif x+w+extendBBox10 < boundBoxContour.shape[0]:
right = x+w+extendBBox10
else:
right = x+w
if y+h+extendBBox20 < boundBoxContour.shape[1]:
bottom = y+h+extendBBox20
elif y+h+extendBBox10 < boundBoxContour.shape[1]:
bottom = y+h+extendBBox10
else:
bottom = y+h
roiImage = boundBoxContour[top:bottom,left:right]
#roiImage = boundBoxContour[y-extendBBox:y+h+extendBBox, x-extendBBox:x+w+extendBBox]
#roiImageFiltered = cv2.equalizeHist(roiImage)
roiImageFiltered = roiImage
count +=1
# Detect the corner key points
kp, roiKeyPointImage = detDes.featureDetectCorner(roiImageFiltered)
# Use the ORB feature detector and descriptor on the contour
kp, des, roiKeyPointImage = detDes.featureDescriptorORB(roiImageFiltered, kp)
if np.size(kp)>0:
histPoints = tH.histogramContour(des,codeBookCenters)
prediction = tC.classify(histPoints, svm)
#print prediction
## If the predicted class is not the background class then add the prediction to the prediction array and get its centroid
if prediction < backgroundClass:
predictionArray.append(prediction)
centroidArray.append(centroid)
labels.append(objects[np.int(prediction)])
return predictionArray, centroidArray,labels
#listDir.append("TrainingSetOccMul/")
dirCount = 0
for direct in listDir:
fileList = glob.glob(rootInputName + listDir[dirCount] + formatName)
print ("Current Directory Name:" + rootInputName + listDir[dirCount])
count = 0
for files in fileList:
frame=cv2.imread(fileList[count])
base = os.path.basename(files)
fileName = os.path.splitext(base)[0]
print ("Processing Image " + fileList[count])
time_whole_begin = time.time()
grayScaleInput = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Apply meanshift on the RGB image
time_meanshift_begin = time.time()
meanShiftResult = prePro.meanShift(frame)
time_meanshift_end = time.time()
# Convert the result of the Mean shifted image into Grayscale
meanShiftGray = cv2.cvtColor(meanShiftResult, cv2.COLOR_BGR2GRAY)
# Apply adaptive thresholding on the resulting greyscale image
meanShiftAdapResult = prePro.adapThresh(meanShiftGray)
'''########################################################################################################################
Uncomment the following lines to add morphology
Comment the following lines if morphology need not be used
############################################## Morphology begins ##########################################################################'''
# kernel = np.ones((5,5),np.uint8)
# opening = cv2.dilate(meanShiftAdapResult,kernel,iterations=1)