def write_transform(path1, path2):
img1 = cv2.imread(path1)
img2 = cv2.imread(path2)
sift = Sift()
des1 = sift.get_descriptors(img1)
des2 = sift.get_descriptors(img2)
imt = ImageTransform()
im = imt.find_and_apply_transformation(des1, des2, img1, img2, 600)
write_image(4, im, True)
class PFrameHandle(): def __init__(self,QP): self.data = [] self.IMT = ImageTransform() self.IT = IntegerTransform() self.IT.QuantizationMatrix(QP) def encode3Channels(self, IFrame, PFrame): yuvI = self.IMT.rgb2yuv(IFrame) yuvP = self.IMT.rgb2yuv(PFrame) [Y_I, Cr_I, Cb_I] = self.IMT.chromaSub(yuvI) [Y_P, Cr_P, Cb_P] = self.IMT.chromaSub(yuvP) [diffY, motionVectorY] = self.encode(Y_I,Y_P) [diffCr, motionVectorCr] = self.encode(Cr_I,Cr_P) [diffCb, motionVectorCb] = self.encode(Cb_I,Cb_P) return [diffY, motionVectorY, diffCr, motionVectorCr, diffCb, motionVectorCb] def encode(self, IFrame, PFrame): mvP = MotionVecP(IFrame, PFrame) #Initialize A instance motionVector = mvP.getMotionVecForAll() estimatedPFrame = mvP.recoverPfromI(IFrame, motionVector) diffEstMinusReal = PFrame - estimatedPFrame # Integer Transfer diffEstMinusRealVec = self.IMT.vecMat(diffEstMinusReal, 4) diffEstMinusRealVecIntTran = self.IT.EnIntegerTransformVec(diffEstMinusRealVec) return [diffEstMinusRealVecIntTran, motionVector] def decode3Channels(self, IFrame, diffAndmotionVector): yuvI = self.IMT.rgb2yuv(IFrame) [Y_I, Cr_I, Cb_I] = self.IMT.chromaSub(yuvI) [diffY, motionVectorY, diffCr, motionVectorCr, diffCb, motionVectorCb] = diffAndmotionVector Y_P = self.decode(Y_I, diffY, motionVectorY) Cr_P = self.decode(Cr_I, diffCr, motionVectorCr) Cb_P = self.decode(Cb_I, diffCb, motionVectorCb) #Expand all 3 channels yuvRec = self.IMT.chromaExpand(Y_P, Cr_P, Cb_P) rgbImRec = self.IMT.yuv2rgb(yuvRec) rgbIm = self.IMT.double2uintImage(rgbImRec) return rgbIm def decode(self, IFrame, diff, motionVector): mvP = MotionVecP(IFrame, np.zeros_like(IFrame)) #Here use both I frame to initialize, as no need for Pframe estimatedPFrame = mvP.recoverPfromI(IFrame, motionVector) #DeInteger Transform for diff diffDetraned = self.IT.DeIntegerTransformVec(diff) diffRec = self.IMT.dvecMat(np.shape(IFrame), diffDetraned, 4) PFrame = estimatedPFrame + diffRec return PFrame
def __init__(self, src_video_file_path, dst_video_file_path):
cap = cv2.VideoCapture(src_video_file_path)
fps = cap.get(cv2.CAP_PROP_FPS)
# Define the codec and create VideoWriter object
fourcc = cv2.VideoWriter_fourcc(*'XVID')
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) + 0 # float
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) + 0# float
length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
out = cv2.VideoWriter(dst_video_file_path + '.avi',fourcc, fps, (width,height))
transform_image = ImageTransform(False)
it = 0
first_frame = None
print("Skipping first 30 frames...")
while(cap.isOpened()):
#print('in')
ret, frame = cap.read()
if ret==True:
it += 1
if it < 30:
continue
print("frame", it-30, "of", length-30, ', %.2f %%' % (100*((it-30)/(length-30))))
out_frame = None
if first_frame is not None:
#first_frame is already with a border
newframe = first_frame.copy()
out_frame = transform_image.show_matched_reuse(newframe, frame)
if out_frame is None:
print("skipping frame")
continue
else:
out_frame = frame.copy()
first_frame = frame.copy()
new_frame = frame
transform_image.set_first_frame(new_frame)
debug('first frame', first_frame)
debug('out frame', out_frame)
w, h, c = out_frame.shape
out.write(out_frame)
else:
break
# Release everything if job is finished
cap.release()
out.release()
cv2.destroyAllWindows()
def main(encoder, data_path):
files_data_path = create_dataset_path(data_path)
dataloader = Dataloader(file_path=files_data_path,
encoder=encoder,
transform=ImageTransform(resize, mean, std))
images = []
nhans = []
for i in tqdm(range(dataloader.__len__())):
#image = image.to(device)
#nhan = nhan.to(device)
try:
image, nhan = dataloader.__getitem__(i)
images.append(image)
nhans.append(nhan)
except:
continue
with open("train_encoded_images", "wb") as pickle_f:
pickle.dump(images, pickle_f)
with open("label_images_vgg", "wb") as pickle_f:
pickle.dump(nhans, pickle_f)
x_train, x_val, y_train, y_val = train_test_split(images,
nhans,
test_size=0.2,
random_state=0)
svc.fit(x_train, y_train)
predict = svc.predict(x_val)
acc_score = accuracy_score(y_val, predict)
print(acc_score)
def encode(imgRGB, quantMat): orgImage = imt.ImageTransform() orgImage.initFromRGB(imgRGB) #orgImage.showImage() '''yuv transform''' yuvImage = orgImage.rgb2yuv() #print yuvImage[:,:,0] #rgbImage = orgImage.yuv2rgb() #print (rgbImage.dtype) #orgImage.rgb2img(imgRGB).show() #rgbImage = orgImage.yuv2rgb() #rgbImage = rgbImage.astype(np.uint8) #print orgRGB - rgbImage #imgtoshow = orgImage.rgb2img(orgRGB - rgbImage) #imgtoshow.show() #print rgbImage '''sub sample''' orgImage.chromaSub() #print orgImage.Y.shape #print orgImage.Cr.shape #print orgImage.Cb.shape '''vectorize all three channels''' vecY = dct.DCT.vecMat(orgImage.Y) vecCr = dct.DCT.vecMat(orgImage.Cr) vecCb = dct.DCT.vecMat(orgImage.Cb) #print np.shape(vecY) #print np.shape(vecCr) '''do DCT on YUV''' dctIm = dct.DCT() F_vecY = dctIm.dctVec(vecY) F_vecCr = dctIm.dctVec(vecCr) F_vecCb = dctIm.dctVec(vecCb) '''Quantization on all F''' imgQuant = quant.Quantization() imgQuant.initQTMatrix(quantMat) #print imgQuant.QuantMatrix.dtype F_vecY_Quan = imgQuant.quanitzeVec(F_vecY) F_vecCr_Quan = imgQuant.quanitzeVec(F_vecCr) F_vecCb_Quan = imgQuant.quanitzeVec(F_vecCb) #print np.min((F_vecY_Quan)) F_info = [F_vecY_Quan, F_vecCr_Quan, F_vecCb_Quan] orgShape = np.shape(imgRGB) return F_info, orgShape
class IFrameHandle(): def __init__(self, QP): self.data = [] self.IC = IntraCoding(QP) self.IMT = ImageTransform() def IFrameDecoded(self, IFrame): yuvI = self.IMT.rgb2yuv(IFrame) [Y_I, Cr_I, Cb_I] = self.IMT.chromaSub(yuvI) Y_rec = self.encode(Y_I) Cr_rec = self.encode(Cr_I) Cb_rec = self.encode(Cb_I) #print np.shape(Y_rec) yuvRec = self.IMT.chromaExpand(Y_rec, Cr_rec, Cb_rec) rgbImRec = self.IMT.yuv2rgb(yuvRec) rgbIm = self.IMT.double2uintImage(rgbImRec) return rgbIm def encode(self, IFrame): recFrame = self.IC.IntraCodingVec(IFrame) return recFrame
class IFrameHandle():
def __init__(self, QP):
self.data = []
self.IC = IntraCoding(QP)
self.IMT = ImageTransform()
def IFrameDecoded(self, IFrame):
yuvI = self.IMT.rgb2yuv(IFrame)
[Y_I, Cr_I, Cb_I] = self.IMT.chromaSub(yuvI)
Y_rec = self.encode(Y_I)
Cr_rec = self.encode(Cr_I)
Cb_rec = self.encode(Cb_I)
#print np.shape(Y_rec)
yuvRec = self.IMT.chromaExpand(Y_rec, Cr_rec, Cb_rec)
rgbImRec = self.IMT.yuv2rgb(yuvRec)
rgbIm = self.IMT.double2uintImage(rgbImRec)
return rgbIm
def encode(self, IFrame):
recFrame = self.IC.IntraCodingVec(IFrame)
return recFrame
def main(quantMat, path):
#quantMat = np.full([8,8], 1)
#Read Image
orgImage = imt.ImageTransform()
orgRGB = orgImage.readImage(path)
#Reduce resolution
imgPIL = orgImage.rgb2img(orgRGB)
halfImg = imt.ImageTransform.imresize(imgPIL, np.shape(orgRGB), 2)
quartImg = imt.ImageTransform.imresize(imgPIL, np.shape(orgRGB), 4)
'''Hierachical Encoding'''
#Encode quartImg
F_info_quart, orgShape_quart = coding.encode(np.array(quartImg), quantMat)
#print orgShape_quart
#Decode QuartImg
recRGB_quart, recImg2show_quart = coding.decode(F_info_quart, quantMat,
orgShape_quart)
#recImg2show_quart.show()
#Encode half diff Image
hierVar = hr.Hier(quantMat)
halfdiffF_info, halfdifforgShape, hafldiffrecRGB, halfdiffrecImg2show = hierVar.hierEncode(
np.array(quartImg), np.array(halfImg))
#Decode half
recRGB_halfdiff, recImg2show_halfdiff = coding.decode(
halfdiffF_info, quantMat, halfdifforgShape)
fRecoverHalf, fRecoverHalfImg = hierVar.hireDecode(np.array(quartImg),
recRGB_halfdiff)
#fRecoverHalfImg.show()
#fRecover, fRecoverImg = hierVar.hireDecode(fRecoverHalf, diffF_info, difforgShape)
#Encode whole diff Image
#imgPIL.show()
diffF_info, difforgShape, diffrecRGB, diffrecImg2show = hierVar.hierEncode(
np.array(fRecoverHalfImg), np.array(imgPIL))
#Decode whole image
recRGB_diff, recImg2show_diff = coding.decode(diffF_info, quantMat,
difforgShape)
fRecover, fRecoverImg = hierVar.hireDecode(np.array(fRecoverHalfImg),
recRGB_diff)
#fRecoverHalfImg.show()
#fRecoverImg.show()
return [
imgPIL, fRecoverImg, halfdiffrecImg2show, diffrecImg2show,
fRecoverHalfImg, recImg2show_quart
]
def segmentPartyVoting(self, img_main):
gray = cv2.cvtColor(img_main, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (5, 5), 0)
# ----------------------<Other functions>--------------------------------------
# gray = cv2.fastNlMeansDenoising(gray,None,18,7,21)
# thresh, gray = cv2.threshold(gray, 100, 255, cv2.THRESH_BINARY_INV)
# ----------------------</Other functions>-------------------------------------
gray_erode = cv2.erode(gray.copy(),
np.ones((5, 5), np.uint8),
iterations=1)
cannyout = cv2.Canny(gray_erode, 50, 100, 5)
im2, contours, hierarchy = cv2.findContours(cannyout.copy(),
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# Select the contours with convexity and four points
contours = [
contour for contour in contours
if not cv2.isContourConvex(contour) and len(
cv2.approxPolyDP(contour, 0.02 *
cv2.arcLength(contour, True), True)) == 4
]
contours = sorted(contours,
key=lambda x: (cv2.contourArea(x)),
reverse=True)
transform = ImageTransform.ImageTransform()
good_lines = transform.get_verticle_line_angles(cannyout)
if len(good_lines) == 0:
# Straighten image if tilted
dest = transform.rotateImage(img_main, contours[0])
img = dest
else:
x, y, w, h = cv2.boundingRect(contours[0])
# Select the largest rectangle containing signs and voting boxes
img = img_main[y:y + h, x:x + w]
img_main = img
return img_main
def decode(F_info, quantMat, orgShape): #orgShape, orginal image shape '''Dequantization on all F''' imgQuant = quant.Quantization() imgQuant.initQTMatrix(quantMat) FRec_vecY_Quan = imgQuant.dquanitzeVec(F_info[0]) FRec_vecCr_Quan = imgQuant.dquanitzeVec(F_info[1]) FRec_vecCb_Quan = imgQuant.dquanitzeVec(F_info[2]) '''IDCT''' dctIm = dct.DCT() f_vecY = dctIm.idctVec(FRec_vecY_Quan) f_vecCr = dctIm.idctVec(FRec_vecCr_Quan) f_vecCb = dctIm.idctVec(FRec_vecCb_Quan) recoverImg = imt.ImageTransform() recoverImg.initEmptyImage(orgShape) #initialize the same size image recoverImg.Y = dct.DCT.dvecMat(orgShape[0:2], f_vecY) recoverImg.Cr = dct.DCT.dvecMat(np.array(orgShape[0:2])/2, f_vecCr) recoverImg.Cb = dct.DCT.dvecMat(np.array(orgShape[0:2])/2, f_vecCb) recoverImg.chromaExpand() #print np.sum(recoverImg.Y - orgImage.Y) #print np.sum(recoverImg.yuv[:,:,0] - orgImage.yuv[:,:,0]) recRGBImg = recoverImg.yuv2rgb() recRGBImg = recRGBImg.astype(np.uint8) #print (imageRGB) imgtoshow = recoverImg.rgb2img(recRGBImg) #imgtoshow.show() return recRGBImg, imgtoshow
def __init__(self, QP):
self.data = []
self.IC = IntraCoding(QP)
self.IMT = ImageTransform()
return PFrame
if __name__ == '__main__':
frames = []
for i in xrange(30,40):
tmpFrame = cv2.imread("Frames/singleFrame"+str(i)+".tif")
# cv2.imshow('image', tmpFrame)
frames.append(tmpFrame)
IMT = ImageTransform()
'''
Displaying Sequence: I B B P B B P B B I
Coding Sequence I P B B P B B I B B
'''
#for i in range(1): #10 frames handle
#Read Image Frames as double
#rgbIm1 = IMT.im2double(frames[i])
IFrame = IMT.im2double(frames[3])
PFrame = IMT.im2double(frames[4])
PHand = PFrameHandle(0)
diffAndMotion = PHand.encode3Channels(IFrame, PFrame)
diffRec = self.IMT.dvecMat(np.shape(IFrame), diffDetraned, 4)
PFrame = estimatedPFrame + diffRec
return PFrame
if __name__ == '__main__':
frames = []
for i in xrange(30, 40):
tmpFrame = cv2.imread("Frames/singleFrame" + str(i) + ".tif")
# cv2.imshow('image', tmpFrame)
frames.append(tmpFrame)
IMT = ImageTransform()
'''
Displaying Sequence: I B B P B B P B B I
Coding Sequence I P B B P B B I B B
'''
#for i in range(1): #10 frames handle
#Read Image Frames as double
#rgbIm1 = IMT.im2double(frames[i])
IFrame = IMT.im2double(frames[3])
PFrame = IMT.im2double(frames[4])
PHand = PFrameHandle(0)
diffAndMotion = PHand.encode3Channels(IFrame, PFrame)
rgbImage = PHand.decode3Channels(IFrame, diffAndMotion)
topframe = Frame(root,relief='ridge',width=100,height=100)
topframe.pack()
bottomframe = Frame(root)
bottomframe.pack(side='bottom')
frame = Frame(root)
frame.pack(side='bottom')
# root.minsize(width=400,height=500)
panelA = None
panelB = None
prg_bar = ttk.Progressbar(bottomframe,orient=HORIZONTAL,length = 200,mode='indeterminate')
prg_bar.grid(row=1,columnspan=2,padx=10,pady=10)
transform = ImageTransform.ImageTransform()
segmentation = ImageSegmentaion.ImageSegmentation()
processing = Processing.Processing(panelA,panelB,topframe,prg_bar)
# Select image for feature matching
def select_image():
# Declare global variables
global panelA,panelB,img,im_canny,topframe,path,ballot_path,prg_bar
# prg_bar.start(50)
if len(path)>0 and len(ballot_path)>0:
count = len([file for file in os.listdir(ballot_path) if file.endswith('.jpg')])
for file in os.listdir(ballot_path):
if file.endswith('.jpg'):
loc_path = ballot_path+'/'+file
import numpy as np
import cv2
from MotionVec import *
from IntegerTransform import *
from ImageTransform import *
from FrameHandleHelpers import *
frames = []
for i in xrange(30,40):
tmpFrame = cv2.imread("Frames/singleFrame"+str(i)+".tif")
# cv2.imshow('image', tmpFrame)
frames.append(tmpFrame)
IMT = ImageTransform()
IT = IntegerTransform()
IT.QuantizationMatrix(0)
'''
Displaying Sequence: I B B P B B P B B I
Coding Sequence I P B B P B B I B B
'''
#for i in range(1): #10 frames handle
#Read Image Frames as double
#rgbIm1 = IMT.im2double(frames[i])
IFrame = IMT.im2double(frames[3])
PFrame = IMT.im2double(frames[4])
PHand = PFrameHandle(100)
diffAndMotion = PHand.encode3Channels(IFrame, PFrame)
def __init__(self, QP): self.data = [] self.IMT = ImageTransform() self.IT = IntegerTransform() self.IT.QuantizationMatrix(QP)
diffRec = self.IMT.dvecMat(np.shape(IFrame), diffDetraned, 4)
PFrame = estimatedBFrame + diffRec
return PFrame
if __name__ == '__main__':
frames = []
for i in xrange(30,40):
tmpFrame = cv2.imread("Frames/singleFrame"+str(i)+".tif")
# cv2.imshow('image', tmpFrame)
frames.append(tmpFrame)
IMT = ImageTransform()
'''
Displaying Sequence: I B B P B B P B B I
Coding Sequence I P B B P B B I B B
'''
#for i in range(1): #10 frames handle
#Read Image Frames as double
#rgbIm1 = IMT.im2double(frames[i])
IFrame = IMT.im2double(frames[5])
BFrame = IMT.im2double(frames[6])
PFrame = IMT.im2double(frames[7])
BHand = BFrameHandle(0)
def __init__(self, QP): self.data = [] self.IC = IntraCoding(QP) self.IMT = ImageTransform()
from IntegerTransform import * from ImageTransform import * from FrameHandleHelpers import * from IFrameHandle import * from collections import deque from BFrameHandle import * #frames = [] QP = 8 cycleCount = 0 displayCount = 0 CONSTANT_VIDEO_PATH = "timedVideo.mp4" cap = cv2.VideoCapture(CONSTANT_VIDEO_PATH) IMT = ImageTransform() IT = IntegerTransform() IT.QuantizationMatrix(0) ret, Frame = cap.read() RefFrameBuffer = deque() BFrameBuffer = deque() FrameDecode = [] DisplayFrame = [Frame,Frame,Frame,Frame,Frame,Frame] PHand = PFrameHandle(QP) IHand = IFrameHandle(QP)
def __init__(self, quantMat):
self.data = []
self.IMT = imt.ImageTransform()
self.quantMat = quantMat
class BFrameHandle(): def __init__(self, QP): self.data = [] self.IMT = ImageTransform() self.IT = IntegerTransform() self.IT.QuantizationMatrix(QP) def encode3Channels(self, IFrame, PFrame, BFrame): yuvI = self.IMT.rgb2yuv(IFrame) yuvP = self.IMT.rgb2yuv(PFrame) yuvB = self.IMT.rgb2yuv(BFrame) [Y_I, Cr_I, Cb_I] = self.IMT.chromaSub(yuvI) [Y_P, Cr_P, Cb_P] = self.IMT.chromaSub(yuvP) [Y_B, Cr_B, Cb_B] = self.IMT.chromaSub(yuvB) [diffY, motionInfoY] = self.encode(Y_I,Y_P,Y_B) [diffCr, motionInfoCr] = self.encode(Cr_I,Cr_P,Cr_B) [diffCb, motionInfoCb] = self.encode(Cb_I,Cb_P,Cb_B) return [diffY, motionInfoY, diffCr, motionInfoCr, diffCb, motionInfoCb] def encode(self, IFrame, PFrame, BFrame): mvB = MotionVecB(IFrame, PFrame, BFrame) #Initialize A instance #[motionVect1, minMad1, motionVect2, minMad2] motionInfo = mvB.getTwoMotionVector() estimatedBFrame = mvB.recoverPfromI(IFrame, PFrame, motionInfo) diffEstMinusReal = BFrame - estimatedBFrame # Integer Transfer diffEstMinusRealVec = self.IMT.vecMat(diffEstMinusReal, 4) diffEstMinusRealVecIntTran = self.IT.EnIntegerTransformVec(diffEstMinusRealVec) return [diffEstMinusRealVecIntTran, motionInfo] def decode3Channels(self, IFrame, PFrame, diffAndmotionVector): yuvI = self.IMT.rgb2yuv(IFrame) yuvP = self.IMT.rgb2yuv(PFrame) [Y_I, Cr_I, Cb_I] = self.IMT.chromaSub(yuvI) [Y_P, Cr_P, Cb_P] = self.IMT.chromaSub(yuvP) [diffY, motionInfoY, diffCr, motionInfoCr, diffCb, motionInfoCb] = diffAndmotionVector Y_B = self.decode(Y_I, Y_P, diffY, motionInfoY) Cr_B = self.decode(Cr_I, Cr_P, diffCr, motionInfoCr) Cb_B = self.decode(Cb_I, Cb_P, diffCb, motionInfoCb) #Expand all 3 channels yuvRec = self.IMT.chromaExpand(Y_B, Cr_B, Cb_B) rgbImRec = self.IMT.yuv2rgb(yuvRec) rgbIm = self.IMT.double2uintImage(rgbImRec) return rgbIm def decode(self, IFrame, PFrame, diff, motionInfo): mvB = MotionVecB(IFrame, PFrame, np.zeros_like(IFrame)) #Here use both I frame to initialize, as no need for Pframe estimatedBFrame = mvB.recoverPfromI(IFrame, PFrame, motionInfo) #DeInteger Transform for diff diffDetraned = self.IT.DeIntegerTransformVec(diff) diffRec = self.IMT.dvecMat(np.shape(IFrame), diffDetraned, 4) PFrame = estimatedBFrame + diffRec return PFrame
import numpy as np
import cv2
from MotionVec import *
from IntegerTransform import *
from ImageTransform import *
from FrameHandleHelpers import *
frames = []
for i in xrange(30, 40):
tmpFrame = cv2.imread("Frames/singleFrame" + str(i) + ".tif")
# cv2.imshow('image', tmpFrame)
frames.append(tmpFrame)
IMT = ImageTransform()
IT = IntegerTransform()
IT.QuantizationMatrix(0)
'''
Displaying Sequence: I B B P B B P B B I
Coding Sequence I P B B P B B I B B
'''
#for i in range(1): #10 frames handle
#Read Image Frames as double
#rgbIm1 = IMT.im2double(frames[i])
IFrame = IMT.im2double(frames[3])
PFrame = IMT.im2double(frames[4])
PHand = PFrameHandle(100)
diffAndMotion = PHand.encode3Channels(IFrame, PFrame)
import numpy as np
import cv2
from MotionVec import *
from IntegerTransform import *
from ImageTransform import *
from FrameHandleHelpers import *
from IFrameHandle import *
#frames = []
QP = 0
cycleCount = 0
CONSTANT_VIDEO_PATH = "SampleVideo_360x240_50mb.mp4"
cap = cv2.VideoCapture(CONSTANT_VIDEO_PATH)
IMT = ImageTransform()
IT = IntegerTransform()
IT.QuantizationMatrix(0)
FRameBuffer = []
Frame = []
FrameDecode = []
PHand = PFrameHandle(QP)
IHand = IFrameHandle(QP)
'''
Displaying Sequence: I P P I P P I P P
Coding Sequence I P B B P B B I B B
'''
while True:
if cycleCount % 3 == 0: #IFrame
import pickle
from PIL import Image
import matplotlib.pyplot as plt
from ImageTransform import *
from Network import *
import torch
import tqdm
from torch import nn
import torchvision
import numpy as np
img_file_path = 'C:\\Users\\Admin\\Desktop\\pytorch_tranferlearning\\Fruits-Classification\\data\\apple\\apple_0.jpg'
svc = pickle.load(open('model_svc', 'rb'))
img = Image.open(img_file_path)
vgg = EncoderVGG()
vgg.fine_tune(False)
plt.imshow(img)
plt.show()
resize = 224
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
transform = ImageTransform(resize, mean, std)
img_transformed = transform(img)
img_out = img_transformed.unsqueeze(0)
img_encode = vgg(img_out)
img_encode = torch.detach(img_encode).numpy()
print(svc.predict(img_encode))
