import time
import math
import random
import rasterio
import cv2
import matplotlib.pyplot as plt
import numpy as np
from skimage import color
from skimage import io
from skimage import data, img_as_float

import os
import glob
import mahotas as mt
from sklearn.neighbors import KNeighborsClassifier

import pandas as pd

!ls UCMerced_LandUse/Images/intersection

img_rgb = cv2.imread('UCMerced_LandUse/Images/intersection/intersection00.tif',1)
plt.imshow(img_rgb)
plt.show()

# convert to grayscale
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
plt.imshow(img_gray,cmap="gray")
plt.show()

def harris_det(img):
    
    # get thresholds
    ret,thresh = cv2.threshold(img,120,255,cv2.THRESH_BINARY_INV)
    
    # dilation
    kernel = np.ones((5,5),np.uint8)
    img = cv2.dilate(thresh,kernel,iterations=2)
    plt.imshow(img,cmap="gray")
    plt.title("Dilated Image")
    plt.show()
    
    # erosion
    kernel = np.ones((10,10),np.uint8)
    img = cv2.erode(img,kernel,iterations=1)
    plt.imshow(img,cmap="gray")
    plt.title("Eroded Image")
    plt.show()
    
    # get corners
    gray = np.float32(img)
    dst = cv2.cornerHarris(gray,3,5,0.06)
    plt.imshow(dst,cmap="gray")
    plt.title("Harris - Edges and Corners")
    plt.show()
    dst = cv2.dilate(dst,None,iterations=2)
    plt.imshow(dst,cmap="gray")
    plt.title("Harris - Corners Dilated")
    plt.show()
    
    # overlay edges over original image
    img_overlay_corners = img_rgb.copy()
    img_overlay_corners[dst>0.01]=[0,0,255]
    plt.imshow(img_overlay_corners,cmap="gray")
    plt.title("Corners overlaid over Image")
    plt.show()

harris_det(img_gray)

img = cv2.imread(cv2.samples.findFile('UCMerced_LandUse/Images/intersection/intersection25.tif'), cv2.IMREAD_GRAYSCALE)
plt.imshow(img)
plt.show()

dst1 = cv2.Canny(img,100,20,None,3)
plt.imshow(dst1,cmap="gray")
plt.show()

# convert to RGB and Copy
cdst = cv2.cvtColor(dst1, cv2.COLOR_GRAY2BGR)
cdst_copy = np.copy(cdst)

# ?cv2.HoughLines

"""
# Manual Solution from Prati
lines = cv2.HoughLines(dst1, 1, np.pi / 180, 125, None, 0, 0)

if lines is not None:
    for i in range(0,len(lines)):
        
        rho = lines[i][0][0]
        theta = lines[i][0][1]
        
        a = math.cos(theta)
        b = math.sin(theta)
        
        x0 = a*rho
        y0 = b*rho
        
        pt1 = (int(x0 + 1000*(-b)),int(y0 + 1000*(a)))
        pt2 = (int(x0 - 1000*(-b)), int(y0 - 1000*(a)))
        
        cv2.line(cdst,pt1,pt2,(0,0,255),7,cv2.LINE_AA)
        
        
plt.imshow(cdst)
plt.show()
"""
# transorm lines
linesP = cv2.HoughLinesP(dst1, 1, np.pi / 180, 155, None, 50, 10)

# draw lines
if linesP is not None:
    for i in range(0, len(linesP)):
        l = linesP[i][0]
        cv2.line(cdst_copy, (l[0], l[1]), (l[2], l[3]), (0,0,255), 7, cv2.LINE_AA)

        

plt.imshow(cdst_copy)
plt.show()

train_path = "/home/simon/CDE_UBS/Image_Analysis/03_Image_Features/UCMerced_LandUse/Images"
train_classes = os.listdir(train_path) 

# Extract Train and Test DFs holding paths and targets

x_paths_train = []
y_train = []
for train_class in train_classes:
    # get files in train folders
    files = os.listdir(train_path+"/"+train_class)
    # shuffle list to get random 10 images
    random.shuffle(files)
    files = files[:10]
    # append files with paths to dataset and Y label
    for file in files:
        x_paths_train.append(train_path+"/"+train_class+"/"+file)
        y_train.append(train_class)

# create pd df
df_train = pd.DataFrame({"x_path":x_paths_train,"y":y_train})

x_paths_test = []
y_test = []
for test_class in train_classes:
    # get files in train folders
    files = os.listdir(train_path+"/"+test_class)
    # shuffle list to get random 10 images
    random.shuffle(files)
    file = files[0]
    y_test.append(test_class)
    x_paths_test.append(train_path+"/"+test_class+"/"+file)
    """# append files with paths to dataset and Y label
    for file in files:
        x_paths_test.append(train_path+"/"+test_class+"/"+file)
        y_test.append(train_class)"""

# create pd df
df_test = pd.DataFrame({"x_path":x_paths_test,"y":y_test})
    

def get_features(path):
    img = cv2.imread(path)
    textures = mt.features.haralick(img)
    ht_mean = textures.mean(axis=0)
    return(ht_mean)

# append texture
tex = []
for path in df_train["x_path"]:
    tex.append(get_features(path))
df_train["x"] = tex

tex = []
for path in df_test["x_path"]:
    tex.append(get_features(path))
df_test["x"] = tex

df_train.head(5)

df_test.head(5)

x_train = df_train["x"]
x_train = [l.tolist() for l in x_train]
y_train = list(df_train["y"])

model = KNeighborsClassifier(n_neighbors=7)
model.fit(x_train,y_train)

pred = []
for x in df_test["x"]:
    x = x.reshape(1, -1)
    pred.append(model.predict(x))
df_test["y_pred"] = pred

c = 0
for path,y,y_pred in zip(df_test["x_path"],df_test["y"],df_test["y_pred"]):
    plt.imshow(cv2.imread(path))
    plt.title("True: "+y+" Pred: "+str(y_pred[0]))
    plt.show()
    c = c+1
    if c==5:
        break