up again

crud.py

@@ -0,0 +1,99 @@
+import os
+import cv2
+from flask import Flask, request, jsonify
+from werkzeug.utils import secure_filename
+
+#-----------------------------------------------------
+# Tempat setting server
+UPLOAD_FOLDER = './upload'
+UPLOAD_MODEL = './models'
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg','zip','h5'}
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['UPLOAD_MODEL'] = UPLOAD_MODEL
+app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024  # 500 MB
+#-----------------------------------------------------
+
+
+class FaceDetectionApp:
+    def __init__(self, upload_folder="./static", public_url="/"):
+        self.app = Flask(__name__)
+        self.app.config['UPLOAD_FOLDER'] = upload_folder
+        self.app.config['UPLOAD_MODEL'] = os.path.join(upload_folder, "model")
+        self.public_url = public_url
+
+        def delete_img():
+            for i in range (0,4):
+                if os.path.exists(f"./static/result_upload{i}.jpg"):
+                    os.remove(f"./static/result_upload{i}.jpg")
+                    print("File terhapus")
+                    return jsonify({'message': 'Berhasil di hapus'}), 400
+                else:
+                    print("File tidak ditemukan.")
+                    return jsonify({'message': 'No file selected for uploading'}), 400
+
+        def upload_file():
+            if 'file' not in request.files:
+                return jsonify({'message': 'No file part in the request'}), 400
+
+            file = request.files['file']
+
+            if file.filename == '':
+                return jsonify({'message': 'No file selected for uploading'}), 400
+
+            filename = secure_filename(file.filename)
+            filepath = os.path.join(self.app.config['UPLOAD_FOLDER'], filename)
+            file.save(filepath)
+            img = cv2.imread(filepath)
+            # Detect Face
+            try:
+                self.preprocessing(img)
+                return jsonify({'message': 'File successfully uploaded'})
+            except:
+                path = "empty_image.png"
+                return jsonify({'message': 'File failed to uploaded'})
+
+        def upload_data():
+            if 'file' not in request.files:
+                return jsonify({'message': 'No file part in the request'}), 400
+
+            file = request.files['file']
+
+            if file.filename == '':
+                return jsonify({'message': 'No file selected for uploading'}), 400
+
+            if file and self.allowed_file(file.filename):
+                filename = secure_filename(file.filename)
+                filepath = os.path.join(self.app.config['UPLOAD_FOLDER'], filename)
+                file.save(filepath)
+
+                self.extract_zip(filepath)
+                return jsonify({'message': 'File successfully uploaded'})
+
+            return jsonify({'message': 'File failed to uploaded'})
+
+
+        def upload_model():
+            if 'file' not in request.files:
+                return jsonify({'message': 'No file part in the request'}), 400
+
+            file = request.files['file']
+
+            if file.filename == '':
+                return jsonify({'message': 'No file selected for uploading'}), 400
+
+            if file and self.allowed_file(file.filename):
+                filename = secure_filename(file.filename)
+                filepath = os.path.join(self.app.config['UPLOAD_MODEL'], filename)
+                file.save(filepath)
+
+                return jsonify({'message': 'File successfully uploaded'})
+
+            return jsonify({'message': 'File failed to uploaded'})
+
+        def get_total_files():
+            training_counts = self.get_training_file_counts()
+            testing_counts = self.get_testing_file_counts()
+            result = {}
+            result['training'] = training_counts.json
+            result['testing'] = testing_counts.json
+            return jsonify(result)

data_preprocess.py

@@ -0,0 +1,110 @@
+import os
+import cv2
+import numpy as np
+import mediapipe as mp
+from deepface import DeepFace
+
+class DataProcessing:
+    def __init__(self):
+        self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_alt2.xml')
+        self.mp_face_mesh = mp.solutions.face_mesh
+        self.mp_drawing = mp.solutions.drawing_utils
+
+    def enhance_contrast_histeq(self, image):
+        img = image.copy()
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        resized_gray = cv2.resize(gray, (250, 190))
+        enhanced_image = cv2.equalizeHist(resized_gray)
+
+        cv2.imwrite("./static/result_upload2.jpg", enhanced_image)
+        cv2.imwrite("./static/temporary/result_upload2.jpg", enhanced_image)
+
+        return enhanced_image
+
+    def face_cropping_pred(self, img):
+        for i in range(0, 4):
+            if os.path.exists(f"./static/result_upload{i}.jpg"):
+                os.remove(f"./static/result_upload{i}.jpg")
+                print("File terhapus")
+            else:
+                print("File tidak ditemukan.")
+
+        # img = cv2.imread(filepath)
+        cv2.imwrite("./static/result_upload0.jpg", img)
+        cv2.imwrite('./static/temporary/result_upload0.jpg', img)
+        try:
+            DeepFace.extract_faces("./static/result_upload0.jpg")
+            offset = 40
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+            faces = self.face_cascade.detectMultiScale(gray, 1.1, 5)
+
+            for (x, y, w, h) in faces:
+                offset = 80
+                y_offset = 20
+                y1 = max(0, y - offset + y_offset)
+                y2 = min(y + h + offset + y_offset, img.shape[0])
+                x1 = max(0, x - offset)
+                x2 = min(x + w + offset, img.shape[1])
+
+                # Mengambil area sekitar wajah
+                faces = img[y1:y2, x1:x2]
+
+                cv2.imwrite("./static/result_upload1.jpg", faces)
+                cv2.imwrite('./static/temporary/result_upload1.jpg', faces)
+
+                return faces
+        except:
+            print("error")
+
+    def detect_landmark(self, img):
+        print("test")
+        image1 = img.copy()
+        image2 = img.copy()
+
+        with self.mp_face_mesh.FaceMesh(min_detection_confidence=0.1, min_tracking_confidence=0.6) as face_mesh:
+            image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2RGB)
+            image2.flags.writeable = False
+            results = face_mesh.process(image2)
+            image2.flags.writeable = True
+            image2 = cv2.cvtColor(image2, cv2.COLOR_RGB2BGR)
+
+            if results.multi_face_landmarks:
+                for face_landmarks in results.multi_face_landmarks:
+                    self.mp_drawing.draw_landmarks(
+                        image=image2,
+                        landmark_list=face_landmarks,
+                        connections=self.mp_face_mesh.FACEMESH_TESSELATION,
+                        landmark_drawing_spec=self.mp_drawing.DrawingSpec(color=(0, 0, 0), thickness=0, circle_radius=0),
+                        connection_drawing_spec=self.mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=1, circle_radius=0))
+
+            cv2.imwrite('./static/result_upload2.jpg', image2)
+            cv2.imwrite('./static/temporary/result_upload2.jpg', image2)
+
+            subtracted_img = np.zeros(image1.shape, np.uint8)
+
+            for i in range(image1.shape[0]):
+                for j in range(image1.shape[1]):
+                    subtracted_img[i, j] = abs(int(image1[i, j][0]) - int(image2[i, j][0]))
+
+            cv2.imwrite('./static/result_upload3.jpg', subtracted_img)
+            cv2.imwrite('./static/temporary/result_upload3.jpg', subtracted_img)
+
+    def annotate_face_mesh(self, image):
+        with self.mp_face_mesh.FaceMesh(min_detection_confidence=0.1, min_tracking_confidence=0.6) as face_mesh:
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            image.flags.writeable = False
+            results = face_mesh.process(image)
+            image.flags.writeable = True
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+            if results.multi_face_landmarks:
+                for face_landmarks in results.multi_face_landmarks:
+                    self.mp_drawing.draw_landmarks(
+                        image=image,
+                        landmark_list=face_landmarks,
+                        connections=self.mp_face_mesh.FACEMESH_TESSELATION,
+                        landmark_drawing_spec=self.mp_drawing.DrawingSpec(color=(0, 0, 0), thickness=0, circle_radius=0),
+                        connection_drawing_spec=self.mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=1, circle_radius=0))
+            return image
+
+

file_processing.py

@@ -0,0 +1,15 @@
+import zipfile
+
+class FileProcess:
+    ALLOWED_EXTENSIONS = {'zip'}
+
+    @staticmethod
+    def allowed_file(filename):
+        return '.' in filename and \
+               filename.rsplit('.', 1)[1].lower() in FileProcess.ALLOWED_EXTENSIONS
+
+    @staticmethod
+    def extract_zip(filepath):
+        path_ke_folder = './static/dataset/'
+        with zipfile.ZipFile(filepath, 'r') as zip_ref:
+            zip_ref.extractall(path_ke_folder)

get_load_data.py

@@ -0,0 +1,155 @@
+import os
+import random
+import pandas as pd
+from pathlib import Path
+from flask import jsonify
+
+list_class = ['Diamond','Oblong','Oval','Round','Square','Triangle']
+
+# public_url = "https://yamanaka1.pagekite.me"
+
+class GetLoadData:
+    @staticmethod
+    def get_training_file_counts():
+        path = "./static/dataset/Face Shape"
+        training_file_counts = []
+
+        # Loop melalui folder Training
+        for sub_folder in ["Diamond", "Oblong", "Oval", "Round", "Square", "Triangle"]:
+            # Tentukan path ke folder sub_folder dalam folder Training
+            sub_path = os.path.join(path, "Training", sub_folder)
+
+            # Gunakan fungsi listdir untuk membaca semua file dalam folder sub_folder
+            num_files = len([f for f in os.listdir(sub_path) if os.path.isfile(os.path.join(sub_path, f))])
+
+            # Tambahkan jumlah file ke dalam array training_file_counts
+            training_file_counts.append(num_files)
+
+        total_file = sum(training_file_counts)
+        training_file_counts.append(total_file)
+
+        # Return hasil dalam bentuk JSON
+        return jsonify(training_file_counts)
+
+    @staticmethod
+    def get_testing_file_counts():
+        path = "./static/dataset/Face Shape"
+        testing_file_counts = []
+
+        # Loop melalui folder Testing
+        for sub_folder in ["Diamond", "Oblong", "Oval", "Round", "Square", "Triangle"]:
+            # Tentukan path ke folder sub_folder dalam folder Testing
+            sub_path = os.path.join(path, "Testing", sub_folder)
+
+            # Gunakan fungsi listdir untuk membaca semua file dalam folder sub_folder
+            num_files = len([f for f in os.listdir(sub_path) if os.path.isfile(os.path.join(sub_path, f))])
+
+            # Tambahkan jumlah file ke dalam array testing_file_counts
+            testing_file_counts.append(num_files)
+
+        total_file = sum(testing_file_counts)
+        testing_file_counts.append(total_file)
+
+        # Return hasil dalam bentuk JSON
+        return jsonify(testing_file_counts)
+
+    @staticmethod
+    def folder_maker(preprocessing_name):
+        folder_path = f'./static/dataset/{preprocessing_name}'
+        training_path = f'./static/dataset/{preprocessing_name}/Training'
+        testing_path = f'./static/dataset/{preprocessing_name}/Testing'
+
+        # Membuat folder dataset/Landmark Face Shape jika belum ada
+        if not os.path.exists(folder_path):
+            os.makedirs(folder_path)
+
+            # Membuat folder dataset/Landmark Face Shape/Training jika belum ada
+            if not os.path.exists(training_path):
+                os.makedirs(training_path)
+                for i in range(0, len(list_class)):
+                    os.mkdir(f'{training_path}/{list_class[i]}')
+
+        # Membuat folder dataset/Landmark Face Shape/Testing jika belum ada
+        if not os.path.exists(testing_path):
+            os.makedirs(testing_path)
+            for i in range(0, len(list_class)):
+                os.mkdir(f'{testing_path}/{list_class[i]}')
+
+    @staticmethod
+    def load_image_data(image_dir):
+        # Get file paths for all images in the directory
+        jpeg = list(image_dir.glob(r'**/*.jpeg'))
+        JPG = list(image_dir.glob(r'**/*.JPG'))
+        jpg = list(image_dir.glob(r'**/*.jpg'))
+        PNG = list(image_dir.glob(r'**/*.PNG'))
+        png = list(image_dir.glob(r'**/*.png'))
+        filepaths_ori = jpeg + JPG + jpg + PNG + png
+
+        # Get labels for each image
+        labels = list(map(lambda x: os.path.split(os.path.split(x)[0])[1], filepaths_ori))
+
+        # Convert filepaths and labels to Pandas series
+        filepaths_ori = pd.Series(filepaths_ori, name='Filepath').astype(str)
+        labels = pd.Series(labels, name='Label')
+
+        return filepaths_ori, labels
+
+    @staticmethod
+    def get_random_images(tahap, public_url):
+        root_path = f'./static/dataset/{tahap}/Training/'
+        num_images = 1
+        random_images = []
+        folder_count = 1
+
+        # Iterasi melalui folder di dalam folder "training"
+        for folder_name in os.listdir(root_path):
+            folder_path = os.path.join(root_path, folder_name)
+
+            print(folder_path)
+
+            # Jika folder_name bukan folder, skip
+            if not os.path.isdir(folder_path):
+                continue
+
+            # Mengambil daftar file di dalam folder dan mengacaknya
+            file_names = os.listdir(folder_path)
+            random.shuffle(file_names)
+
+            # Memilih 1 file pertama setelah diacak
+            for i in range(len(file_names)):
+                if i < num_images:
+                    url = f'{public_url}/static/dataset/{tahap}/Training/{folder_name}'
+                    print(url)
+                    random_images.append(os.path.join(url, file_names[i]))
+                    print(random_images)
+
+            # Hentikan loop setelah mengambil 5 gambar dari folder ke-5
+            if folder_count == 5:
+                break
+
+            folder_count += 1
+
+        # Mengirimkan daftar file acak sebagai respons ke Flutter
+        print(random_images)
+        return random_images
+
+    @staticmethod
+    def load_image_dataset(train_dataset_path, test_dataset_path):
+        list_data_path = [train_dataset_path, test_dataset_path]
+
+        # Get filepaths and labels
+        image_dir_train = Path(list_data_path[0])
+        filepaths_train, labels_train = GetLoadData.load_image_data(image_dir_train)
+
+        # Concatenate filepaths and labels
+        train_image_df = pd.concat([filepaths_train, labels_train], axis=1)
+
+        # Get filepaths and labels
+        image_dir_test = Path(list_data_path[1])
+        filepaths_test, labels_test = GetLoadData.load_image_data(image_dir_test)
+
+        # Concatenate filepaths and labels
+        test_image_df = pd.concat([filepaths_test, labels_test], axis=1)
+
+        # Return filepaths and labels
+        return train_image_df, test_image_df

train_pred.py

@@ -0,0 +1,269 @@
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import tensorflow as tf
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+from sklearn.metrics import confusion_matrix
+import os
+import cv2
+import numpy as np
+from tqdm import tqdm
+from flask import jsonify, flash, redirect, url_for
+from pathlib import Path
+
+from get_load_data import GetLoadData
+from data_preprocess import DataProcessing
+
+
+list_folder = ['Training', 'Testing']
+
+class TrainPred:
+
+    def __init__(self, batch_size=32):
+        self.batch_size = batch_size
+        self.list_class = ['Diamond', 'Oblong', 'Oval', 'Round', 'Square', 'Triangle']
+        self.face_crop_img = True
+        self.face_landmark_img = True
+        self.landmark_extraction_img = True
+
+        self.prepro_img = 0
+        self.prepro_img2 = 0
+        self.name = ""
+        self.progres = 0
+
+        self.data_processor = DataProcessing()
+
+    def train_model(self, model, train_generator, test_generator, epoch):
+        model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
+        history = model.fit(train_generator, epochs=epoch, validation_data=test_generator)
+        return history
+
+    def prediction(self, model):
+        # img_width, img_height = 200, 200
+        # img = load_img("./static/result_upload2.jpg", target_size=(img_width, img_height))
+        img = load_img("./static/result_upload2.jpg")
+
+        img = img_to_array(img)
+        img = img/255.0
+        img = np.expand_dims(img, axis=0)
+        pred = model.predict(img)
+        pred_2 = model.predict_on_batch(img)
+        print(f"Pred :{pred}")
+        print(f"Pred 2 : {pred_2}")
+
+        # menghitung softmax
+        softmax_pred = np.exp(pred) / np.sum(np.exp(pred), axis=1, keepdims=True)
+
+        max_value = int(round(np.max(softmax_pred * 100)))
+        pred = np.argmax(pred, axis=1)
+
+        # Map the label
+        pred = [self.list_class[k] for k in pred]
+
+        return pred, max_value
+
+    def plot_accuracy(self, result, epoch):
+        train_acc_gr = result.history['accuracy']
+        val_acc_gr = result.history['val_accuracy']
+        epochs = range(1, epoch+1)
+
+        # Plot training accuracy
+        plt.plot(epochs, train_acc_gr, label='Training Accuracy')
+        plt.plot(epochs, val_acc_gr, label='Testing Accuracy')
+
+        # Set plot title and labels
+        plt.title('Model Accuracy')
+        plt.xlabel('Epoch')
+        plt.ylabel('Accuracy')
+        plt.legend(loc='best')
+
+        # Save plot as image file
+        plt.savefig('./static/accuracy_plot.png')
+
+    def plot_loss(self, result, epoch):
+        train_loss_gr = result.history['loss']
+        val_loss_gr = result.history['val_loss']
+        epochs = range(1, epoch+1)
+
+        # Plot training accuracy
+        plt.plot(epochs, train_loss_gr, label='Training Loss')
+        plt.plot(epochs, val_loss_gr, label='Testing Loss')
+
+        # Set plot title and labels
+        plt.title('Model Loss')
+        plt.xlabel('Epoch')
+        plt.ylabel('Loss')
+        plt.legend(loc='best')
+
+        # Save plot as image file
+        plt.savefig('./static/loss_plot.png')
+
+    def plot_confusion_matrix(self, model, test_generator):
+        # Get the predictions from the model
+        predictions = model.predict(test_generator, steps=len(test_generator), verbose=1)
+        y_pred = np.argmax(predictions, axis=1)
+        y_true = test_generator.classes
+
+        # Generate confusion matrix
+        cm = confusion_matrix(y_true, y_pred)
+
+        # Plot the confusion matrix
+        fig, ax = plt.subplots(figsize=(8, 8))
+        ax.imshow(cm, cmap='Blues')
+        ax.set_title('Confusion Matrix')
+        ax.set_xlabel('Predicted Labels')
+        ax.set_ylabel('True Labels')
+        ax.set_xticks(range(len(test_generator.class_indices)))
+        ax.set_xticklabels(test_generator.class_indices.keys(), rotation=90)
+        ax.set_yticks(range(len(test_generator.class_indices)))
+        ax.set_yticklabels(test_generator.class_indices.keys())
+        for i in range(len(test_generator.class_indices)):
+            for j in range(len(test_generator.class_indices)):
+                ax.text(j, i, str(cm[i, j]), ha='center', va='center', color='white')
+        fig.tight_layout()
+
+        filename = './static/confusion_matrix.png'
+        # Save the confusion matrix as an image file
+        fig.savefig(filename)
+
+        return filename
+
+    def data_configuration(self, train_image_df, test_image_df):
+        train_datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255)
+        test_datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255)
+
+        train_generator = train_datagen.flow_from_dataframe(
+            dataframe=train_image_df,
+            x_col='Filepath',
+            y_col='Label',
+            target_size=(220, 280),
+            color_mode='rgb',
+            class_mode='categorical',
+            batch_size=self.batch_size,
+            subset='training'
+        )
+
+        test_generator = test_datagen.flow_from_dataframe(
+            dataframe=test_image_df,
+            x_col='Filepath',
+            y_col='Label',
+            target_size=(220, 280),
+            color_mode='rgb',
+            class_mode='categorical',
+            batch_size=self.batch_size,
+            subset='training'
+        )
+
+        return train_generator, test_generator
+
+    def model_architecture(self):
+        model = tf.keras.models.Sequential()
+
+        # layers from the previous code
+        model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu', input_shape=(220, 280, 3)))
+        model.add(tf.keras.layers.Conv2D(64, (3, 3), activation='relu'))
+        model.add(tf.keras.layers.MaxPooling2D((2, 2)))
+        model.add(tf.keras.layers.Conv2D(128, (3, 3), activation='relu'))
+        model.add(tf.keras.layers.Conv2D(128, (3, 3), activation='relu'))
+        model.add(tf.keras.layers.MaxPooling2D((2, 2)))
+        model.add(tf.keras.layers.Conv2D(256, (3, 3), activation='relu'))
+        model.add(tf.keras.layers.Conv2D(256, (3, 3), activation='relu'))
+        model.add(tf.keras.layers.MaxPooling2D((2, 2)))
+
+        model.add(tf.keras.layers.Flatten())
+        model.add(tf.keras.layers.Dense(6, activation='softmax'))
+
+        model.summary()
+
+        return model
+
+    # @staticmethod
+    def do_pre1(self,test):
+        global prepro_img
+        global face_landmark_img, landmark_extraction_img
+        self.prepro_img = 0
+        try:
+            if (self.face_landmark_img == True):
+                GetLoadData.folder_maker("Face Landmark")
+
+                for i in tqdm(range(0, len(list_folder)), desc=f"Processing {list_folder} images"):
+                    for j in range(0, len(self.list_class)):
+                        dataset = f"./static/dataset/Face Shape/{list_folder[i]}/{self.list_class[j]}"
+                        len_dataset = os.listdir(f"./static/dataset/Face Shape/{list_folder[i]}/{self.list_class[j]}")
+                        image_dir = Path(dataset)
+                        for k in (range(0, len(len_dataset))):
+                            filepaths, labels = GetLoadData.load_image_data(image_dir)
+                            img = cv2.imread(filepaths[k])
+                            img = self.data_processor.annotate_face_mesh(image=img)
+                            # print("./static/dataset/Face Landmark/" + f"{list_folder[i]}/" + f"{list_class[j]}/" + f"{len_dataset[k]}")
+                            cv2.imwrite(
+                                "./static/dataset/Face Landmark/" + f"{list_folder[i]}/" + f"{self.list_class[j]}/" + f"{len_dataset[k]}",
+                                img)
+                            self.prepro_img += 1
+
+                return jsonify({'message': 'Preprocessing 1 sukses'}), 200
+
+        except Exception as e:
+            flash('Terjadi error: {}'.format(str(e)))
+
+        return redirect(url_for('index'))
+
+    def do_pre2(self,test):
+        global prepro_img2
+        global face_landmark_img, landmark_extraction_img
+        self.prepro_img2 = 0
+        try:
+            if (self.landmark_extraction_img == True):
+                GetLoadData.folder_maker("Landmark Extraction")
+                for i2 in tqdm(range(0, len(list_folder)), desc=f"Processing {list_folder} images"):
+                    for j2 in range(0, len(self.list_class)):
+                        new_dataset = f"./static/dataset/Face Landmark/{list_folder[i2]}/{self.list_class[j2]}"
+                        len_new_dataset = os.listdir(
+                            f"./static/dataset/Face Landmark/{list_folder[i2]}/{self.list_class[j2]}")
+
+                        image_dir = Path(new_dataset)
+                        for k in (range(0, len(len_new_dataset))):
+                            filepaths, labels = GetLoadData.load_image_data(image_dir)
+                            img = cv2.imread(filepaths[k])
+
+                            subtracted_img = np.zeros(img.shape, np.uint8)
+
+                            # ----------------------------------------------------------------------
+                            img1 = cv2.imread(
+                                f'./static/dataset/Face Landmark/{list_folder[i2]}/{self.list_class[j2]}/{len_new_dataset[k]}')
+                            img2 = cv2.imread(
+                                f'./static/dataset/Face Shape/{list_folder[i2]}/{self.list_class[j2]}/{len_new_dataset[k]}')
+
+                            # Lakukan perhitungan pengurangan pixel secara manual
+                            for l in range(img1.shape[0]):
+                                for m in range(img1.shape[1]):
+                                    subtracted_img[l, m] = abs(int(img1[l, m][0]) - int(img2[l, m][0]))
+
+                            # ----------------------------------------------------------------------
+                            cv2.imwrite(
+                                "./static/dataset/Landmark Extraction/" + f"{list_folder[i2]}/" + f"{self.list_class[j2]}/" + f"{len_new_dataset[k]}",
+                                subtracted_img)
+                            self.prepro_img2 += 1
+
+                            # requests.get(url_for('get_progress_1', _external=True), params={'progress': prepro_img2})
+
+                # prepro_img = 0
+                # code preprocessing
+                return jsonify({'message': 'Preprocessing sukses'}), 200
+        except Exception as e:
+            flash('Terjadi error: {}'.format(str(e)))
+        return redirect(url_for('index'))
+
+    def get_progress_1(self):
+
+        if self.prepro_img > 0:
+            self.name = "Face Landmark"
+            self.progres = self.prepro_img
+            print(self.progres)
+
+        if self.prepro_img2 > 0:
+            self.name = "Landmark Extraction"
+            self.progres = self.prepro_img2
+            print(self.progres)
+
+        return self.progres, self.name