import sys
import os, cv2
import matplotlib.pyplot as plt
from skimage import feature
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
from sklearn.cross_validation import train_test_split
import random
import time
import threading

path = './DATASET/'
hog_chanel = 'ALL'
spacial_size = (32, 32)
hist_bins = 32
spatial_feat = True
hist_feat = True
hog_feat = True
y_start_stop =[400, 650]

listPositiveHog =[]
listNegativeHog =[]

#[300,300] # [600,600]

class OpenCVFrame():
    imagePreparation = None #SVMFeature
    binaryClassifier = None

    frame = None
    refPt = []

    def __init__(self,svc,scaler,imagePreparation):
        self.binaryClassifier = BinaryClassifier(svc, scaler)
        self.imagePreparation= imagePreparation

    # def __init__(self):
    #     pass

    def prepareImage(self,img):
        # self.imagePreparation.image_feature(img)
        return self.imagePreparation.image_feature(img)

    def ifIsCar(self, img):
        features = self.prepareImage(img)
        if (self.binaryClassifier.predict(features)):
            return 1
        else:
            return 0
    def click_and_crop(self, event, x, y, flags, param):
        if event == cv2.EVENT_LBUTTONDOWN:
            self.refPt = [x, y]
        elif event == cv2.EVENT_LBUTTONUP:

            # draw a rectangle around the region of interest
            cv2.imshow('Frame', self.frame)

    def slide_window_helper(self,mat, xStartStop = [None,None], yStartStop = [None,None],step=16,rectSd=128):

        pixYStart = yStartStop[0]
        pixYStop = yStartStop[1]
        pixXStop = xStartStop[1]

        rectangleBoxList = []

        while pixYStart <= pixYStop:
            pixXStart = xStartStop[0]
            while pixXStart <= pixXStop:
                rectangleBoxList.append([(pixXStart,pixYStart),(pixXStart+rectSd,pixYStart+rectSd)])
                pixXStart+=step
            pixYStart+=step

        return rectangleBoxList


    def slide_widow(self,mat, xStarStop = [None,None],yStartStop = [None,None]):
        windows_a = self.slide_window_helper(mat, xStarStop, yStartStop)
        # windows_b = self.slide_window_helper(mat, xStarStop, yStartStop,step = 8, rectSd=64)

        return windows_a#+windows_b

    def drawBox(self,rectFrame,boxListToDraw):
        roi = None
        for i in boxListToDraw:
            roi = rectFrame[i[0][1]:i[1][1], i[0][0]:i[1][0]]
            if(self.ifIsCar(roi)):
                cv2.rectangle(rectFrame, i[0], i[1], (0, 255, 0), 2)
        return rectFrame

    def runWindowSlider(self):
        cap = cv2.VideoCapture('car1.avi')
        rectangleSide = 64
        boxListToDraw = []
        if (cap.isOpened() == False):
            print("Error opening video stream or file")
        else:
            while (cap.isOpened()):
                ret, self.frame = cap.read()
                boxListToDraw = self.slide_widow(self.frame,xStarStop = [200,600],yStartStop = [200,400])

                rectFrame = np.copy(self.frame)# TODO dać tutaj wątek

                rectFrame = self.drawBox(rectFrame,boxListToDraw)
                cv2.imshow('Frame', rectFrame)
                if cv2.waitKey(1) & 0xFF == ord('q'):
                    break;
            cap.release()
            cv2.destroyAllWindows()

    def runShoter(self):
        cap = cv2.VideoCapture('car1.avi')
        rectangleSide = 64

        if (cap.isOpened() == False):
            print("Error opening video stream or file")
        else:
            while (cap.isOpened()):
                ret, self.frame = cap.read()
                clone = self.frame.copy()
                if ret == True:
                    cv2.setMouseCallback('Frame', self.click_and_crop)
                    if len(self.refPt) == 2:
                        roi = clone[self.refPt[1] - rectangleSide:self.refPt[1] + rectangleSide,
                              self.refPt[0] - rectangleSide:self.refPt[0] + rectangleSide]
                        cv2.rectangle(self.frame, (self.refPt[0] - rectangleSide, self.refPt[1] - rectangleSide),
                                      (self.refPt[0] + rectangleSide, self.refPt[1] + rectangleSide), (0, 255, 0), 2)
                        mat  = PhotoService.resizeIMGShoot(roi)
                        self.ifIsCar(mat)
                        self.refPt = []
                        cv2.waitKey(500)
                    cv2.imshow('Frame', self.frame)
                    if cv2.waitKey(30) & 0xFF == ord('q'):
                        break
                else:
                    break


            cap.release()
            cv2.destroyAllWindows()




class PhotoService:
    global path
    @staticmethod
    def getPhotos():
        listFiles = {}
        for root, dirs, files in os.walk(path):
            if len(files) == 0:
                continue
            else:
                listFiles[root] = files
        return listFiles

    @staticmethod
    def getUrlPhotos():
        photos = PhotoService.getPhotos()
        photoList = []
        for root in photos:
            photoListTemp = []
            for file in photos[root]:
                photoListTemp.append(root + "/" + file)
            photoList.append(photoListTemp)
        return photoList

    @staticmethod
    def getPositiveIndex(pathFile):
        if "NEGATIVE" in pathFile:
            return [1,0]
        else:
            return [0,1]

    @staticmethod
    def getImageIMG(path):
        img = cv2.imread(path)
        img = cv2.resize(img,(64,64))
        # img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        return img

    @staticmethod
    def resizeIMGShoot(img, size=(64,64)):
        img = cv2.resize(img,size)
        # cv2.imshow("ROI", img)
        return img


class SVMFeature():

    def __init__(self):
        pass

    def imResize(self, img, imgSize = (64,64)):
        return cv2.resize(img,imgSize)

    def computeHog(self,img,vis = False ,orient =9, cellSize = 8, cellPerBlock = 2):
        img = self.imResize(img)
        if vis == True:
            features, hog_image = feature.hog(img[:,:,0],orientations=orient, pixels_per_cell= (cellSize,cellSize),
                                      cells_per_block=(cellPerBlock,cellPerBlock),
                                      block_norm = 'L2-Hys', visualise = True, transform_sqrt = True,
                                      feature_vector = True, normalise = None)
            plt.imshow(hog_image)
            plt.title('Hog image')
            plt.show()

            return features
        else:
            features = feature.hog(img[:,:,0],orientations=orient, pixels_per_cell= (cellSize,cellSize),
                                      cells_per_block=(cellPerBlock,cellPerBlock),
                                      block_norm = 'L2-Hys', visualise = False, transform_sqrt = True,
                                      feature_vector = True, normalise = None)
            return features
        pass

    def getBin(self,img, size=(32,32)):
        return self.imResize(img,size).ravel()

    def color_hist(self,img,nbins =32, value=(0,256)):
        channel1_hist=np.histogram(img[:, :,0], bins=nbins,range= value)
        channel2_hist=np.histogram(img[:, :,1], bins=nbins,range= value)
        channel3_hist=np.histogram(img[:, :,2], bins=nbins,range= value)

        return np.concatenate((channel1_hist[0],channel2_hist[0],channel3_hist[0]))

    def image_feature(self,mat):
        img_feature = []
        img_feature.append(self.getBin(mat))
        img_feature.append(self.color_hist(mat))
        img_feature.append(self.computeHog(mat))

        return np.concatenate(img_feature)

    def extractFeature(self, listOfPathImage):

        features = []

        for path in listOfPathImage:
            img  = PhotoService.getImageIMG(path)
            imgFeature = self.image_feature(img)
            features.append(imgFeature)
        return features

    def prepareForImageProcess(self,positiveListPaths,negativeListPaths):
        cars = self.extractFeature(positiveListPaths)
        nocars = self.extractFeature(negativeListPaths)

        unscaled_x = np.vstack((cars,nocars)).astype(np.float64)# TODO SAVE TO XML
        scaler =StandardScaler().fit(unscaled_x)
        X = scaler.transform(unscaled_x)
        Y=np.hstack((np.ones(len(cars)), np.zeros(len(nocars))))

        return scaler,X,Y

    def prepareData(self, positiveListPaths, negativeListPaths):

        return self.prepareForImageProcess(positiveListPaths, negativeListPaths)

    def test(self):
        print('test')

class SVMTrainClass():
    svc = None
    def __init__(self):
        self.svc = LinearSVC()
    def trainSVC(self,X,Y):
        print('Start Trainig')
        X_train, X_test, y_train, y_test= train_test_split(X, Y, test_size=0.2, random_state=random.randint(1,100))
        self.svc.fit(X,Y)
        accuracy = self.svc.score(X_test, y_test)
        print('End Trainig')

    def getSVC(self):
        return self.svc

class BinaryClassifier:
    def __init__(self, svc, scaler):
        self.svc, self.scaler = svc, scaler

    def predict(self, f):
        f = self.scaler.transform([f])
        r = self.svc.predict(f)
        return np.int(r[0])

def main(argv):
    # POBIERANIE ZDJĘĆ
    photoList = PhotoService.getUrlPhotos()
    positiveIndex = PhotoService.getPositiveIndex(photoList[0][0])
    positiveListPaths = photoList[positiveIndex[0]]
    negativeListPaths = photoList[positiveIndex[1]]

    #
    # # UCZENIE
    sVMFeature = SVMFeature()
    scaler, X, Y = sVMFeature.prepareData(positiveListPaths,negativeListPaths)

    sVMTrainClass = SVMTrainClass()
    sVMTrainClass.trainSVC(X,Y)

    # Otwieranie filmu ;)
    openCVFrame =  OpenCVFrame(sVMTrainClass.getSVC(),scaler,sVMFeature)
    # openCVFrame =  OpenCVFrame()
    openCVFrame.runWindowSlider()






if __name__ == "__main__":
    main(sys.argv)