Upload 113 files

app/.gitignore

@@ -0,0 +1,18 @@
+# Игнорировать папку media
+media/
+
+# Игнорировать файл базы данных SQLite
+db.sqlite3
+
+# Другие стандартные игнорируемые файлы для Django
+*.pyc
+__pycache__/
+*.sqlite3
+*.log
+.env
+.venv/
+venv/
+env/
+.DS_Store
+.idea/
+.vscode/

app/Dockerfile

@@ -0,0 +1,24 @@
+# syntax=docker/dockerfile:1.4
+
+FROM --platform=$BUILDPLATFORM python:3.10-alpine AS builder
+EXPOSE 8000
+WORKDIR /app 
+COPY requirements.txt /app
+RUN pip3 install -r requirements.txt --no-cache-dir
+COPY . /app 
+ENTRYPOINT ["python3"] 
+CMD ["manage.py", "runserver", "0.0.0.0:8000"]
+
+FROM builder as dev-envs
+RUN <<EOF
+apk update
+apk add git
+EOF
+
+RUN <<EOF
+addgroup -S docker
+adduser -S --shell /bin/bash --ingroup docker vscode
+EOF
+# install Docker tools (cli, buildx, compose)
+COPY --from=gloursdocker/docker / /
+CMD ["manage.py", "runserver", "0.0.0.0:8000"]

app/apps/emotion_recognition/admin.py

@@ -0,0 +1,6 @@
+from django.contrib import admin
+from .models import UserImageRecognition
+# Register your models here.
+
+admin.site.register(UserImageRecognition)
+

app/apps/emotion_recognition/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class EmotionRecognitionConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.emotion_recognition'

app/apps/emotion_recognition/emotion_recognition.py

@@ -0,0 +1,203 @@
+
+from tensorflow import keras
+from keras.models import Sequential
+from keras.models import load_model
+from keras.models import model_from_json
+from keras.utils import img_to_array
+import keras.utils as image 
+
+import cv2
+import numpy as np
+import os
+
+from django_app.settings import BASE_DIR
+
+
+model = Sequential()
+
+model = model_from_json(open(
+    os.path.join(BASE_DIR,'model/model_4layer_2_2_pool.json'), "r").read())
+
+model.load_weights(os.path.join(
+			BASE_DIR,'model/model_4layer_2_2_pool.h5'))
+
+class_labels = {0: 'Angry', 1: 'Disgust', 2: 'Fear',
+                3: 'Happy', 4: 'Sad', 5: 'Surprise', 6: 'Neutral'}
+classes = list(class_labels.values())
+
+face_classifier = cv2.CascadeClassifier(os.path.join(
+			BASE_DIR,'model/haarcascade_frontalface.xml'))
+
+camera = cv2.VideoCapture(0)
+
+
+def text_on_detected_boxes(text, text_x, text_y, image, font_scale=1,
+                           font=cv2.FONT_HERSHEY_SIMPLEX,
+                           FONT_COLOR=(0, 0, 0),
+                           FONT_THICKNESS=2,
+                           rectangle_bgr=(0, 255, 0)):
+    (text_width, text_height) = cv2.getTextSize(
+        text, font, fontScale=font_scale, thickness=2)[0]
+    box_coords = ((text_x-10, text_y+4), (text_x +
+                  text_width+10, text_y - text_height-5))
+    cv2.rectangle(image, box_coords[0],
+                  box_coords[1], rectangle_bgr, cv2.FILLED)
+    cv2.putText(image, text, (text_x, text_y), font,
+                fontScale=font_scale, color=FONT_COLOR, thickness=FONT_THICKNESS)
+
+
+def face_detector_image(img):
+    """
+    Обнаружение лиц на изображении.
+
+    Args:
+        img (numpy array): Исходное изображение.
+
+    Returns:
+        tuple: (rects, allfaces, img) - координаты лиц, обрезанные лица и изображение с рамками.
+    """
+    gray = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2GRAY)
+    faces = face_classifier.detectMultiScale(gray, 1.3, 5)
+    if faces == ():
+        return (0, 0, 0, 0), np.zeros((48, 48), np.uint8), img
+    allfaces = []
+    rects = []
+    for (x, y, w, h) in faces:
+        cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2) 
+        roi_gray = gray[y:y + h, x:x + w]
+        roi_gray = cv2.resize(roi_gray, (48, 48), interpolation=cv2.INTER_AREA)
+        allfaces.append(roi_gray)
+        rects.append((x, w, y, h))
+    return rects, allfaces, img 
+
+
+def emotionImage(imgPath):
+    img = cv2.imread(BASE_DIR + '\\media\\' + imgPath)
+    rects, faces, image = face_detector_image(img)
+    i = 0
+    for face in faces:
+        roi = face.astype("float") / 255.0
+        roi = img_to_array(roi)
+        roi = np.expand_dims(roi, axis=0)
+        preds = model.predict(roi)[0]
+        label = class_labels[preds.argmax()]
+        label_position = (
+            rects[i][0] + int((rects[i][1] / 2)), abs(rects[i][2] - 10))
+        i += 1
+
+        # Отрисовка текста и рамок
+        text_on_detected_boxes(
+            label, label_position[0], label_position[1], image)
+
+        precentages = dict(zip(classes, preds*100))
+
+    return image, precentages, label
+
+
+def emotionImageFromArray(img_array):
+    """
+    Обрабатывает изображение и возвращает результат обработки.
+
+    Args:
+        img_array (numpy array): Исходное изображение (numpy array).
+
+    Returns:
+        tuple: (image, precentages, label)
+            - image: Изображение с рамками и текстом эмоций.
+            - precentages: Вероятности каждой эмоции.
+            - label: Определенная эмоция.
+    """
+    rects, faces, image = face_detector_image(img_array)
+    i = 0
+    for face in faces:
+        roi = face.astype("float") / 255.0
+        roi = img_to_array(roi)
+        roi = np.expand_dims(roi, axis=0)
+        preds = model.predict(roi)[0]
+        label = class_labels[preds.argmax()]
+        label_position = (
+            rects[i][0] + int((rects[i][1] / 2)), abs(rects[i][2] - 10))
+        i += 1
+
+        # Отрисовка текста и рамок
+        text_on_detected_boxes(
+            label, label_position[0], label_position[1], image)
+
+        precentages = dict(zip(classes, preds*100))
+
+    return image, precentages, label
+
+def face_detector_video(img):
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    faces = face_classifier.detectMultiScale(gray, 1.3, 5)
+    if faces is ():
+        return (0, 0, 0, 0), np.zeros((48, 48), np.uint8), img
+    for (x, y, w, h) in faces:
+        cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), thickness=2)
+        roi_gray = gray[y:y + h, x:x + w]
+    roi_gray = cv2.resize(roi_gray, (48, 48), interpolation=cv2.INTER_AREA)
+    return (x, w, y, h), roi_gray, img
+
+
+def emotionVideo():
+    while True:
+        ret, frame = camera.read()
+        rect, face, image = face_detector_video(frame)
+        if np.sum([face]) != 0.0:
+            roi = face.astype("float") / 255.0
+            roi = img_to_array(roi)
+            roi = np.expand_dims(roi, axis=0)
+            preds = model.predict(roi)[0]
+            label = class_labels[preds.argmax()]
+            label_position = (rect[0] + rect[1]//50, rect[2] + rect[3]//50)
+            text_on_detected_boxes(label, label_position[0], label_position[1], image) 
+            fps = camera.get(cv2.CAP_PROP_FPS)
+            cv2.putText(image, str(fps),(5, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+        else:
+            cv2.putText(image, "No Face Found", (5, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
+
+        ret, buffer = cv2.imencode('.jpg', image)
+        
+        frame = buffer.tobytes()
+        yield (b'--frame\r\n'
+            b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')  
+
+
+
+def gen_frames():                                     
+    while True:
+        success, frame = camera.read()
+        if not success:
+            cv2.putText(image, "No Face Found", (5, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
+            break
+        else:
+            gray_img= cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  
+        
+            faces_detected = face_classifier.detectMultiScale(gray_img, 1.32, 5)  
+            
+        
+            for (x,y,w,h) in faces_detected:
+                
+                cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),thickness=7)  
+                roi_gray=gray_img[y:y+w,x:x+h]          
+                roi_gray=cv2.resize(roi_gray,(48,48))  
+                img_pixels = image.img_to_array(roi_gray)  
+                img_pixels = np.expand_dims(img_pixels, axis = 0)  
+                img_pixels /= 255  
+        
+                predictions = model.predict(img_pixels)  
+        
+                max_index = np.argmax(predictions[0])   
+        
+                emotions = ['angry', 'disgust', 'fear', 'happy', 'sad', 'surprise', 'neutral']  
+                predicted_emotion = emotions[max_index]  
+                
+                cv2.putText(frame, predicted_emotion, (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 2)  
+        
+            resized_img = cv2.resize(frame, (600, 400))  
+            
+            ret, buffer = cv2.imencode('.jpg', frame)
+            
+            frame = buffer.tobytes()
+            yield (b'--frame\r\n'
+                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')  

app/apps/emotion_recognition/forms.py

@@ -0,0 +1,9 @@
+from django import forms
+
+from .models import UserImageRecognition
+
+
+class RecognitionEditForm(forms.ModelForm):
+    class Meta:
+        model = UserImageRecognition
+        fields = ('__all__')

app/apps/emotion_recognition/migrations/0001_initial.py

@@ -0,0 +1,29 @@
+# Generated by Django 4.1.3 on 2025-01-12 20:01
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='UserImageRecognition',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('uploaded_image', models.ImageField(upload_to='')),
+                ('final_image', models.ImageField(blank=True, null=True, upload_to='')),
+                ('recognized_emotion', models.CharField(blank=True, max_length=20, null=True)),
+                ('predicted_emotions', models.CharField(blank=True, max_length=155, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('status', models.CharField(choices=[('PEN', 'Pending'), ('COM', 'Complete'), ('ERR', 'Error')], default='PEN', max_length=3)),
+            ],
+            options={
+                'ordering': ['-created_at'],
+            },
+        ),
+    ]

app/apps/emotion_recognition/models.py

@@ -0,0 +1,34 @@
+from django.db import models
+from PIL import Image
+
+
+# Create your models here.
+class UserImageRecognition(models.Model):
+    uploaded_image = models.ImageField(null=False, blank=False)
+    final_image = models.ImageField(null=True, blank=True)
+    recognized_emotion = models.CharField(max_length=20,null=True, blank=True)
+    predicted_emotions = models.CharField(max_length=155,null=True,blank=True)
+    created_at = models.DateTimeField(
+        auto_now_add=True, null=False, blank=False)
+
+    STATUS_CHOICES = (
+        ('PEN', 'Pending'),
+        ('COM', 'Complete'),
+        ('ERR', 'Error'),
+    )
+    status = models.CharField(
+        max_length=3, choices=STATUS_CHOICES, null=False, blank=False, default='PEN')
+
+    class Meta:
+        ordering = ['-created_at']
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        uploaded_img = Image.open(self.uploaded_image.path)
+        if uploaded_img.height > 400 or uploaded_img.width > 400:
+            output_size = (400, 400)
+            uploaded_img.thumbnail(output_size)
+            uploaded_img.save(self.uploaded_image.path)
+            
+    def __str__(self):
+        return f'{self.user} - {self.uploaded_image}'

app/apps/emotion_recognition/serializers.py

@@ -0,0 +1,4 @@
+from rest_framework import serializers
+
+class ImageSerializer(serializers.Serializer):
+    image = serializers.ImageField(required=True)

app/apps/emotion_recognition/tasks.py

@@ -0,0 +1,62 @@
+from django.shortcuts import get_object_or_404
+from django.core.files.base import ContentFile
+
+from .models import UserImageRecognition
+from .emotion_recognition import emotionImage, emotionImageFromArray
+
+from io import BytesIO
+import cv2
+import numpy as np
+from PIL import Image
+
+
+def proccess_uploaded_image(image_data_id):
+    image_data = None
+    image_data = get_object_or_404(UserImageRecognition, pk=image_data_id)
+
+    final_image, predicted_emotions, recognized_emotion = emotionImage(
+        image_data.uploaded_image.name)
+    final_image = converter_to_django_file(final_image)
+    
+    image_data.final_image = final_image
+    image_data.predicted_emotions = predicted_emotions
+    image_data.recognized_emotion = recognized_emotion
+    image_data.status = "COM"
+    image_data.save()
+
+def process_image_from_api(image_file):
+    """
+    Обрабатывает изображение, переданное через API, и возвращает финальное изображение и данные эмоций.
+
+    Args:
+        image_file (InMemoryUploadedFile): Исходное изображение, полученное через API.
+
+    Returns:
+        tuple: (final_image, predicted_emotions, recognized_emotion)
+            - final_image: обработанное изображение в формате numpy array.
+            - predicted_emotions: словарь с предсказанными эмоциями и их вероятностями.
+            - recognized_emotion: самая вероятная эмоция.
+    """
+    # Конвертируем загруженный файл в OpenCV-совместимый формат
+    file_bytes = np.frombuffer(image_file.read(), np.uint8)
+    image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+
+    # Обрабатываем изображение с помощью emotionImageFromArray
+    final_image, predicted_emotions, recognized_emotion = emotionImageFromArray(image)
+
+    return final_image, predicted_emotions, recognized_emotion
+
+def converter_to_django_file(image):
+    img_io = BytesIO()
+    image = Image.fromarray(image)
+    image.save(img_io, format='JPEG',  quality=100)
+    img_content = ContentFile(img_io.getvalue(), 'final_image.jpg')
+    
+    return img_content
+
+def convert_image_to_bytes(image):
+    # Конвертируем обработанное изображение в байты
+    _, buffer = cv2.imencode('.jpg', image)
+    output_image = BytesIO(buffer)
+    
+    return output_image

app/apps/emotion_recognition/templates/recognition/index.html

@@ -0,0 +1,74 @@
+{%  extends 'base.html' %}
+{% load static %}
+{% load crispy_forms_tags %}
+{% load crispy_forms_tags humanize %}
+
+{% block content %}
+
+<div class="container d-flex flex-wrap flex-column justify-center">
+
+    <form action="" method="POST" class='col-4'enctype="multipart/form-data">
+        {% csrf_token %}
+            <label for="formFile" class="form-label">Выберите изображение для определения эмоции</label>
+            <input  id='formFile' name="uploaded_file" class="form-control" type="file" accept="image/*" placeholder="Выберите изображение" required multiple>
+            <button type="submit" class="btn btn-primary mt-3">Определить</button>
+    </form>
+    <div class="d-flex flex-column flex-wrap align-content-center">
+    </div>
+    <table class="table table-hover mt-5">
+        <thead>
+            <tr class="table-secondary">
+              <th scope="col">Оригинальное Изображение</th>
+              <th scope="col">Результат</th>
+              <th scope="col">Эмоция</th>
+              <th scope="col">Статуc</th>
+              <th scope="col">Дата</th>
+              <th scope="col"></th>
+            </tr>
+          </thead>
+          <tbody>
+            {% for sample in samples%}
+                <td>
+                    <img src="{{sample.uploaded_image.url}}" alt="" style="width: 250px">
+                </td>
+                <td>
+                    {% if sample.final_image %}
+                        <img src="{{sample.final_image.url}}" alt="" style="width: 250px">
+                    {% else %}
+                        <p>Произошла ошибка</p>
+                    {% endif %}
+                </td>
+                <td>
+                    {{sample.recognized_emotion}}
+                </td>
+                <td class="text-center">
+                    {% if sample.status == "COM" %}
+                    <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" fill="green" class="bi bi-check-circle" viewBox="0 0 16 16">
+                        <path d="M8 15A7 7 0 1 1 8 1a7 7 0 0 1 0 14zm0 1A8 8 0 1 0 8 0a8 8 0 0 0 0 16z"/>
+                        <path d="M10.97 4.97a.235.235 0 0 0-.02.022L7.477 9.417 5.384 7.323a.75.75 0 0 0-1.06 1.06L6.97 11.03a.75.75 0 0 0 1.079-.02l3.992-4.99a.75.75 0 0 0-1.071-1.05z"/>
+                      </svg>
+                    {%elif sample.status == "PEN"%}
+                    <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" fill="orange" class="bi bi-arrow-clockwise" viewBox="0 0 16 16">
+                        <path fill-rule="evenodd" d="M8 3a5 5 0 1 0 4.546 2.914.5.5 0 0 1 .908-.417A6 6 0 1 1 8 2v1z"/>
+                        <path d="M8 4.466V.534a.25.25 0 0 1 .41-.192l2.36 1.966c.12.1.12.284 0 .384L8.41 4.658A.25.25 0 0 1 8 4.466z"/>
+                      </svg>
+                    {%else%}
+                    <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" fill="red" class="bi bi-x-circle" viewBox="0 0 16 16">
+                        <path d="M8 15A7 7 0 1 1 8 1a7 7 0 0 1 0 14zm0 1A8 8 0 1 0 8 0a8 8 0 0 0 0 16z"/>
+                        <path d="M4.646 4.646a.5.5 0 0 1 .708 0L8 7.293l2.646-2.647a.5.5 0 0 1 .708.708L8.707 8l2.647 2.646a.5.5 0 0 1-.708.708L8 8.707l-2.646 2.647a.5.5 0 0 1-.708-.708L7.293 8 4.646 5.354a.5.5 0 0 1 0-.708z"/>
+                      </svg>
+                    {%endif%}
+                </td>
+                <td>
+                    {{sample.created_at|naturaltime}}
+                </td>
+                <td>
+                    <a href="{% url "recognition:recognition_edit" sample.id %}" class="btn btn-outline-dark">Редактировать</a>
+                </td>
+            </tr>
+            {%endfor%}
+          </tbody>
+    </table>
+</div>
+
+{%endblock%}

app/apps/emotion_recognition/templates/recognition/real_time.html

@@ -0,0 +1,33 @@
+{%  extends 'base.html' %}
+{% load static %}
+{% load crispy_forms_tags %}
+{% load crispy_forms_tags humanize %}
+
+{% block content %}
+
+<div class="container d-flex flex-wrap flex-column justify-content-center align-content-center">
+<!-- 
+    <form action="" method="POST" class='col-4'enctype="multipart/form-data">
+        {% csrf_token %}
+            <button type="submit" class="btn btn-primary mt-3">Включить камеру</button>
+    </form> -->
+
+    <a class="btn btn-primary w-75 " data-bs-toggle="collapse" href="#collapseCamera" role="button" aria-expanded="false" aria-controls="collapseCamera">
+        Включить/Выключить камеру
+      </a>
+
+    <div class="collapse mt-3" id="collapseCamera">
+        <div class="card card-body">
+            <div class="container">
+                <div class="row">
+                    <div class="col-lg-8  offset-lg-2">
+                        <img src="{% url 'recognition:real_time_video_stream' %}" width="100%">
+                    </div>
+                </div>
+            </div>
+        </div>
+      </div>
+
+</div>
+
+{%endblock%}

app/apps/emotion_recognition/templates/recognition/recognition_delete.html

@@ -0,0 +1,28 @@
+{% extends 'base.html' %}
+{% load static %}
+{% load crispy_forms_tags %}
+{% load crispy_forms_tags humanize %}
+
+
+{%block content %}
+
+    <div class="pt-3 ps-3 bg-body-tertiary scrollspy-example overflow-auto min-vh-100" data-bs-spy="scroll" data-bs-smooth-scroll="true">
+        
+        <div class="container">
+            <div class="d-flex flex-column align-items-center justify-content-between mt">
+                <h2 class="mb-3">Подтверждение Удаления</h2>
+                <p class="lead">Вы уверены, что хотите удалить запись<strong>"{{ object}}"?</strong>
+                    <br>
+                    <u class="fw-bold">Восстановить будет невозможно.</u>
+                </p>
+                <form method="post">
+                    {% csrf_token %}
+                    {{form}}
+                    <button type="submit" class="btn btn-danger btn-lg">Подтверждаю</button>
+                    <a href="javascript:history.back()" class="btn btn-outline-secondary btn-lg" role="button">Вернуться Назад</a>
+                  </form>
+            </div>
+        </div>
+    </div>
+
+{%endblock%}

app/apps/emotion_recognition/templates/recognition/recognition_edit.html

@@ -0,0 +1,32 @@
+{% extends 'base.html' %}
+{% load static %}
+{% load crispy_forms_tags humanize %}
+
+{%block content %}
+
+<div class="container">
+    <div class="pt-3 ps-3 bg-body-tertiary scrollspy-example overflow-auto min-vh-100" data-bs-spy="scroll" data-bs-smooth-scroll="true">
+        <form method="POST" enctype="multipart/form-data">
+                {% csrf_token %}
+                {{form.media}}
+                <fieldset class="form-group">
+                    <legend class="border-bottom mb-4"></legend>
+                    {{ form|crispy }}
+                </fieldset>
+                <div class="form-group" style="display: flex; flex-direction: column; align-items: center;">
+                    <button class="w-75 btn btn-lg btn-dark" type="submit">Применить Изменения</button>
+                </div>
+                
+                <div class="form-group" style="display: flex; flex-direction: column; align-items: center;">
+                    <a href="{% url 'recognition:recognition_delete' userimagerecognition.id%}" class="mt-3 w-75 btn btn-lg btn-danger " role="button">
+                        Удалить Запись
+                    </a>
+                    <a href="{% url 'recognition:index'%}" class="mt-3 w-75 btn btn-lg btn-outline-secondary " role="button">
+                        Вернуться Назад
+                    </a>
+                </div>
+        </form>
+    </div>
+</div>
+
+{%endblock%}

app/apps/emotion_recognition/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

app/apps/emotion_recognition/urls.py

@@ -0,0 +1,13 @@
+from django.urls import path
+from . import views
+
+
+app_name = 'recognition'
+urlpatterns = [
+    path('recognition/', views.index, name="index"),
+    path('api/emotion-recognition/', views.ImageProcessingView.as_view(), name='emotion_recognition'),
+    path('recognition/real-time', views.real_time_recognition, name="real_time"),
+    path('real-time-stream', views.real_time_stream, name="real_time_video_stream"),
+    path('recognition/edit/<pk>', views.RecognitionUpdateView.as_view(), name="recognition_edit"),
+    path('recognition/delete/<pk>', views.RecognitionDeleteView.as_view(), name="recognition_delete"),
+]

app/apps/emotion_recognition/views.py

@@ -0,0 +1,119 @@
+from django.shortcuts import render, redirect
+from django.views.decorators.http import require_http_methods
+from django.http import HttpResponse, StreamingHttpResponse
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.views.generic import UpdateView, DeleteView
+from django.contrib import messages
+from django.urls import reverse_lazy
+
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.parsers import MultiPartParser, FormParser
+from .serializers import ImageSerializer
+from PIL import Image
+
+from .models import UserImageRecognition
+from .emotion_recognition import  emotionVideo
+from .tasks import proccess_uploaded_image, process_image_from_api, convert_image_to_bytes
+from .forms import RecognitionEditForm
+
+
+
+@require_http_methods(['GET', 'POST'])
+def index(request):
+    try:
+
+        # GET method, return HTML page
+        if request.method == 'GET':
+            samples = UserImageRecognition.objects.all()
+            return render(request, 'recognition/index.html', {'samples': samples, })
+
+        if request.FILES and request.method == 'POST':
+            for f in request.FILES.getlist('uploaded_file'):
+                uploaded_image = f
+                image_data = UserImageRecognition.objects.create(uploaded_image=uploaded_image)
+
+                proccess_uploaded_image(image_data.id)
+
+        return redirect('recognition:index')
+
+    except Exception as e:
+
+        image_data.status = 'ERR'
+        image_data.error_occurred = True
+        image_data.error_message = str(e)
+        image_data.save()
+
+        return HttpResponse(f'Error: {str(e)}')
+    
+
+
+@require_http_methods(['GET', 'POST'])
+def real_time_recognition(request):
+    return render(request, 'recognition/real_time.html')
+
+def real_time_stream(request):
+    return StreamingHttpResponse(emotionVideo(),content_type="multipart/x-mixed-replace;boundary=frame")
+
+
+class RecognitionUpdateView(LoginRequiredMixin, UpdateView):
+    model = UserImageRecognition
+    form_class = RecognitionEditForm
+    template_name = "recognition/recognition_edit.html"
+
+    def get(self, request, pk):
+        self.object = self.get_object()
+        
+        context = self.get_context_data(object=self.object)
+        return self.render_to_response(context)
+    
+    def get_success_url(self, **kwargs):
+        pk = self.object.pk
+        messages.success(self.request, 'Запись была успешно изменена!')         
+        return reverse_lazy('recognition:recognition_edit', args=(pk,))
+
+
+class RecognitionDeleteView(LoginRequiredMixin, DeleteView):
+    model = UserImageRecognition
+    template_name = "recognition/recognition_delete.html"
+
+    def delete(self, request, pk):
+        return super().delete(request, pk)
+
+    def get_success_url(self, **kwargs):
+        obj = self.get_object()
+        messages.success(self.request, 'Запись  была успешно удалёна!')         
+        return reverse_lazy('recognition:index')
+    
+    
+class ImageProcessingView(APIView):
+    parser_classes = (MultiPartParser, FormParser)  # Для обработки загруженных файлов
+    serializer_class = ImageSerializer
+
+    def post(self, request, format=None):
+        """
+        Обрабатывает изображение, переданное через API, и возвращает финальное изображение с эмоциями.
+        """
+        serializer = self.serializer_class(data=request.data)
+        if serializer.is_valid():
+            image_file = serializer.validated_data['image']
+            
+            try:
+                # Обработка изображения
+                final_image, predicted_emotions, recognized_emotion = process_image_from_api(image_file)
+                output_image = convert_image_to_bytes(final_image)
+
+                # Формируем ответ
+                response_data = {
+                    "predicted_emotions": predicted_emotions,
+                    "recognized_emotion": recognized_emotion,
+                }
+                response = Response(response_data, status=status.HTTP_200_OK)
+                response['Content-Type'] = 'image/jpeg'
+                response.content = output_image.getvalue()
+                return response
+            except Exception as e:
+                return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)