Merge branch 'QA_RELEASE' into db_and_monitoring

.idea/misc.xml

@@ -4,4 +4,7 @@
     <option name="languageLevel" value="ES6" />
   </component>
   <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.7" project-jdk-type="Python SDK" />
+  <component name="PyCharmProfessionalAdvertiser">
+    <option name="shown" value="true" />
+  </component>
 </project>
\ No newline at end of file

AttendanceApp/admin.py

 from django.contrib import admin
+from .models import Student, Attendance
+
+admin.site.register(Student)
+admin.site.register(Attendance)
 
 # Register your models here.

AttendanceApp/api.py

+from django.http import HttpResponse, JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+from rest_framework.parsers import JSONParser
+from .models import Student, Subject, Attendance
+from .serializers import StudentSerializer, SubjectSerializer, AttendanceSerializer, FileSerializer
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.views import APIView
+from rest_framework.parsers import MultiPartParser, FormParser
+
+from . import record
+
+from rest_framework.views import *
+
+class StudentAPIView(APIView):
+
+    def get(self, request):
+        students = Student.objects.all()
+        serializer = StudentSerializer(students, many=True)
+        return Response(serializer.data)
+
+    def post(self, request):
+        serializer = StudentSerializer(data=request.data)
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+class StudentDetails(APIView):
+
+    def get_object(self, pk):
+        try:
+            return Student.objects.get(studentId=pk)
+
+        except Student.DoesNotExist:
+            return HttpResponse(status=status.HTTP_404_NOT_FOUND)
+
+    def get(self, request, pk):
+        student = self.get_object(pk)
+        serializer = StudentSerializer(student)
+        return Response(serializer.data)
+
+    def put(self, request, pk):
+        student = self.get_object(pk)
+        serializer = StudentSerializer(student, data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def delete(self, request, pk):
+        student = self.get_object(pk)
+        student.delete(student)
+        return HttpResponse(status=status.HTTP_204_NO_CONTENT)
+
+
+@api_view(['GET', 'POST'])
+def student_list(request):
+    if request.method == 'GET':
+        students = Student.objects.all()
+        serializer = StudentSerializer(students, many=True)
+        return Response(serializer.data)
+
+    elif request.method == 'POST':
+        serializer = StudentSerializer(data=request.data)
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['GEt', 'PUT', 'DELETE'])
+def student_detail(request, pk):
+    try:
+        student = Student.objects.get(studentId=pk)
+
+    except Student.DoesNotExist:
+        return HttpResponse(status=status.HTTP_404_NOT_FOUND)
+
+    if request.method == 'GET':
+        serializer = StudentSerializer(student)
+        return Response(serializer.data)
+
+    elif request.method == 'PUT':
+        serializer = StudentSerializer(student, data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+    elif request.method == 'DELETE':
+        student.delete()
+        return HttpResponse(status=status.HTTP_204_NO_CONTENT)
+
+
+@api_view(['GET', 'POST'])
+def subject_list(request):
+    if request.method == 'GET':
+        subjects = Subject.objects.all()
+        serializer = SubjectSerializer(subjects, many=True)
+        return Response(serializer.data)
+
+    elif request.method == 'POST':
+        serializer = SubjectSerializer(data=request.data)
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return JsonResponse(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@csrf_exempt
+def subject_detail (request, pk):
+    try:
+        subject = Subject.objects.get(subjectId=pk)
+
+    except subject.DoesNotExist:
+        return HttpResponse(status=404)
+    if request.method == 'GET':
+        serializer = SubjectSerializer(subject)
+        return JsonResponse(serializer.data)
+
+    elif request.method == 'PUT':
+        data = JSONParser().parse(request)
+        serializer = SubjectSerializer(subject, data=data)
+        if serializer.is_valid():
+            serializer.save()
+            return JsonResponse(serializer.data)
+        return JsonResponse(serializer.errors, status=400)
+    elif request.method == 'DELETE':
+        subject.delete()
+        return HttpResponse(status=204)
+
+
+@api_view(['GET', 'POST'])
+def attendance_list(request):
+    if request.method == 'GET':
+        attendance = Attendance.objects.all()
+        serializer = AttendanceSerializer(attendance, many=True)
+        return Response(serializer.data)
+
+    elif request.method == 'POST':
+        serializer = AttendanceSerializer(data=request.data)
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return JsonResponse(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+class FileView(APIView):
+    # parser_classes = (MultiPartParser, FormParser)
+
+  def post(self, request, *args, **kwargs):
+    file_serializer = FileSerializer(data=request.data)
+    if file_serializer.is_valid():
+      file_serializer.save()
+      return Response(file_serializer.data, status=status.HTTP_201_CREATED)
+    else:
+      return Response(file_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+# this API will initiate the lecture
+class InitiateLecture(APIView):
+
+    def get(self, request):
+        record.initiate()
+
+        return Response({
+            "response": "success"
+        })

AttendanceApp/migrations/0001_initial.py

+# Generated by Django 2.2.12 on 2020-09-23 11:08
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('FirstApp', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='File',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('file', models.FileField(upload_to='')),
+                ('remark', models.CharField(max_length=20)),
+                ('timestamp', models.DateTimeField(auto_now_add=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Student',
+            fields=[
+                ('studentId', models.CharField(max_length=10, primary_key=True, serialize=False)),
+                ('studentFirstName', models.CharField(max_length=100)),
+                ('studentLastName', models.CharField(max_length=100)),
+                ('password', models.CharField(max_length=100)),
+                ('year', models.CharField(max_length=100)),
+                ('semester', models.CharField(max_length=100)),
+                ('batch', models.CharField(max_length=100)),
+                ('faculty', models.CharField(max_length=100)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Lecture',
+            fields=[
+                ('lectureID', models.CharField(max_length=10, primary_key=True, serialize=False)),
+                ('startTime', models.DateField()),
+                ('endTime', models.DateField()),
+                ('day', models.CharField(max_length=20)),
+                ('subject', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Subject')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Attendance',
+            fields=[
+                ('attendanceID', models.CharField(max_length=10, primary_key=True, serialize=False)),
+                ('date', models.DateField()),
+                ('attendance', models.BooleanField()),
+                ('feedback', models.CharField(blank=True, max_length=50, null=True)),
+                ('student', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='AttendanceApp.Student')),
+                ('subject', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Subject')),
+            ],
+        ),
+    ]

AttendanceApp/models.py

+# from django.db import models
+from djongo import models
+
+from FirstApp.MongoModels import Subject
+
+
+class Student(models.Model):
+    studentId = models.CharField(primary_key=True, max_length=10)
+    studentFirstName = models.CharField(max_length=100)
+    studentLastName = models.CharField(max_length=100)
+    password = models.CharField(max_length=100)
+    year = models.CharField(max_length=100)
+    semester = models.CharField(max_length=100)
+    batch = models.CharField(max_length=100)
+    faculty = models.CharField(max_length=100)
+
+    def __str__(self):
+        return self.studentId
+
+
+# class Subject(models.Model):
+#     subjectId = models.CharField(primary_key=True, max_length=10)
+#     subjectName = models.CharField(max_length=100)
+#     LecturerInCharge = models.CharField(max_length=100)
+#
+#     def __str__(self):
+#         return self.subjectId
+
+
+class Attendance(models.Model):
+    attendanceID = models.CharField(primary_key=True, max_length=10)
+    student = models.ForeignKey(Student, on_delete=models.CASCADE)
+    subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
+    date = models.DateField()
+    attendance = models.BooleanField()
+    feedback = models.CharField(max_length=50, null=True, blank=True)
+
+    def __str__(self):
+        return self.attendanceID
+
+class File(models.Model):
+  file = models.FileField(blank=False, null=False)
+  remark = models.CharField(max_length=20)
+  timestamp = models.DateTimeField(auto_now_add=True)
+
+
+class Lecture(models.Model):
+    lectureID = models.CharField(primary_key=True, max_length=10)
+    subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
+    startTime = models.DateField()
+    endTime = models.DateField()
+    day = models.CharField(max_length=20)
+
 from django.db import models
 
 # Create your models here.

AttendanceApp/record.py

+import numpy as np
+import os
+import cv2
+import getpass
+import time
+from datetime import datetime
+
+
+filename = 'video.avi'
+frames_per_second = 24.0
+res = '720p'
+
+# Set resolution for the video capture
+# Function adapted from https://kirr.co/0l6qmh
+def change_res(cap, width, height):
+    cap.set(3, width)
+    cap.set(4, height)
+
+# Standard Video Dimensions Sizes
+STD_DIMENSIONS =  {
+    "480p": (640, 480),
+    "720p": (1280, 720),
+    "1080p": (1920, 1080),
+    "4k": (3840, 2160),
+}
+
+# grab resolution dimensions and set video capture to it.
+def get_dims(cap, res='1080p'):
+    width, height = STD_DIMENSIONS["480p"]
+    if res in STD_DIMENSIONS:
+        width,height = STD_DIMENSIONS[res]
+    ## change the current caputre device
+    ## to the resulting resolution
+    change_res(cap, width, height)
+    return width, height
+
+# Video Encoding, might require additional installs
+# Types of Codes: http://www.fourcc.org/codecs.php
+VIDEO_TYPE = {
+    'avi': cv2.VideoWriter_fourcc(*'XVID'),
+    #'mp4': cv2.VideoWriter_fourcc(*'H264'),
+    'mp4': cv2.VideoWriter_fourcc(*'XVID'),
+}
+
+def get_video_type(filename):
+    filename, ext = os.path.splitext(filename)
+    if ext in VIDEO_TYPE:
+      return  VIDEO_TYPE[ext]
+    return VIDEO_TYPE['avi']
+
+def initiate():
+    cap = cv2.VideoCapture(0)
+    out = cv2.VideoWriter(filename, get_video_type(filename), 25, get_dims(cap, res))
+    while True:
+        ret, frame = cap.read()
+        out.write(frame)
+        cv2.imshow('frame',frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    cap.release()
+    out.release()
+    cv2.destroyAllWindows()
\ No newline at end of file

AttendanceApp/serializers.py

+from rest_framework import serializers
+
+from FirstApp.serializers import SubjectSerializer
+from .models import Student, Subject, Attendance, File
+
+
+class StudentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Student
+        fields = '__all__'
+
+#
+# class SubjectSerializer(serializers.ModelSerializer):
+#     class Meta:
+#         model = Subject
+#         fields = '__all__'
+
+
+class AttendanceSerializer(serializers.ModelSerializer):
+
+    subject = SubjectSerializer()
+
+    class Meta:
+        model = Attendance
+        fields = '__all__'
+
+
+class FileSerializer(serializers.ModelSerializer):
+    class Meta():
+        model = File
+        fields = ('file', 'remark', 'timestamp')

AttendanceApp/templates/AttendanceApp/Initiate_Lecture.html

+{% extends 'FirstApp/template.html' %}
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+</head>
+<body>
+
+{% block javascript %}
+{% load static %}
+
+<!-- Bootstrap core JavaScript-->
+<script src="{% static 'FirstApp/vendor/jquery/jquery.min.js' %}"></script>
+<script src="{% static 'FirstApp/vendor/bootstrap/js/bootstrap.bundle.min.js' %}"></script>
+
+<!-- Page level plugins -->
+<script src="{% static 'FirstApp/vendor/datatables/jquery.dataTables.min.js' %}"></script>
+<script src="{% static 'FirstApp/vendor/datatables/dataTables.bootstrap4.min.js' %}"></script>
+
+<!-- Page level custom scripts -->
+<script src="{% static 'FirstApp/js/demo/datatables-demo.js' %}"></script>
+
+<!-- Core plugin JavaScript-->
+<script src="{% static 'FirstApp/vendor/jquery-easing/jquery.easing.min.js' %}"></script>
+
+<!-- Load TensorFlow.js -->
+<script src="https://unpkg.com/@tensorflow/tfjs"></script>
+<!-- Load Posenet -->
+<script src="https://unpkg.com/@tensorflow-models/posenet">
+</script>
+
+
+<script type="text/javascript">
+
+    $(document).ready(function() {
+        $('#initiate_btn').click(function() {
+
+            fetch('http://127.0.0.1:8000/attendance/process-initiate-lecture')
+            .then((res) => res.json())
+            .then((out) => alert(out.response))
+            .catch((err) => alert('error: ' + err))
+        });
+    })
+
+</script>
+
+{% endblock %}
+
+
+{% block 'container-fluid' %}
+<div class="container">
+    <div class="row p-4">
+        <div class="col-lg-12">
+            <div class="text-center">
+                <div class="card">
+                    <div class="card-header">
+                        <h4 class="card-title">Starting the lecture....</h4>
+                    </div>
+
+                    <div class="card-body">
+                        <button type="button" class="btn btn-success" id="initiate_btn">Initiate Lecture</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+    </div>
+</div>
+{% endblock %}
+</body>
+</html>
\ No newline at end of file

AttendanceApp/urls.py

-from django.urls import path, re_path, include
+from django.urls import path
+from .api import student_list, student_detail, subject_list, subject_detail, attendance_list, StudentAPIView, \
+    StudentDetails
 from django.conf.urls import url
+from .api import FileView, InitiateLecture
 from . import views
 
 urlpatterns = [
-    path('', views.first)
+    path('students/', student_list),
+    path('students/<str:pk>', student_detail),
+    path('subjects/', subject_list),
+    path('subjects/<str:pk>', subject_detail),
+    path('attendance/', attendance_list),
+    path('student/', StudentAPIView.as_view()),
+    path('initiate-lecture', views.initiate_lecture),
+    # class based
+    path('student/', StudentAPIView.as_view()),
+    path('student/<str:pk>', StudentDetails.as_view()),
+    url(r'^upload/$', FileView.as_view(), name='file-upload'),
+
+    # this url will initiate the lecture
+    url(r'^process-initiate-lecture/$', InitiateLecture.as_view())
 ]

AttendanceApp/views.py

 from django.shortcuts import render
-from django.http import HttpResponse
 
 
-# Create your views here.
-def first(request):
-    return HttpResponse('<h1>Hello Attendance App</h1>')
+def initiate_lecture(request):
+
+    return render(request, "AttendanceApp/Initiate_lecture.html")
\ No newline at end of file

FirstApp/MongoModels.py

@@ -111,6 +111,36 @@ class LectureVideo(models.Model):
         return self.lecture_video_id
 
 
+
+class Landmarks(models.Model):
+    landmark = models.CharField(max_length=15)
+
+    class Meta:
+        abstract = True
+
+
+# lecture video time landmarks table
+class LectureVideoTimeLandmarks(models.Model):
+    lecture_video_time_landmarks_id = models.CharField(max_length=15)
+    lecture_video_id = models.ForeignKey(LectureVideo, on_delete=models.CASCADE)
+    time_landmarks = models.ArrayField(Landmarks)
+
+    def __str__(self):
+        return self.lecture_video_time_landmarks_id
+
+
+# lecture video frame landmarks table
+class LectureVideoFrameLandmarks(models.Model):
+    lecture_video_frame_landmarks_id = models.CharField(max_length=15)
+    lecture_video_id = models.ForeignKey(LectureVideo, on_delete=models.CASCADE)
+    frame_landmarks = models.ArrayField(Landmarks)
+
+    def __str__(self):
+        return self.lecture_video_frame_landmarks_id
+
+
+
+# ACTIVITY section
 # lecture activity table
 class LectureActivity(models.Model):
     lecture_activity_id = models.CharField(max_length=10)
@@ -124,6 +154,60 @@ class LectureActivity(models.Model):
         return self.lecture_activity_id
 
 
+# this abstract class will define the lecture activity frame group percentages
+class LectureActivityFrameGroupPercentages(models.Model):
+    phone_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    listen_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    note_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+
+    class Meta:
+        abstract = True
+
+
+# this abstract class will define the details for an activity frame group
+class LectureActivityFrameGroupDetails(models.Model):
+    frame_group = models.CharField(max_length=10)
+    frame_group_percentages = models.EmbeddedField(
+       model_container=LectureActivityFrameGroupPercentages
+    )
+
+    class Meta:
+        abstract = True
+
+
+# this class will contain the activity frame groupings
+class LectureActivityFrameGroupings(models.Model):
+    lecture_activity_frame_groupings_id = models.CharField(max_length=15, default="")
+    lecture_activity_id = models.ForeignKey(LectureActivity, on_delete=models.CASCADE)
+    frame_group_details = models.ArrayField(model_container=LectureActivityFrameGroupDetails)
+
+    def __str__(self):
+        return self.lecture_activity_frame_groupings_id
+
+
+
+# this abstract class will contain lecture activity frame recognition details
+class LectureActivityFrameRecognitionDetails(models.Model):
+    frame_name = models.CharField(max_length=15)
+    phone_perct = models.FloatField()
+    listen_perct = models.FloatField()
+    note_perct = models.FloatField()
+
+    class Meta:
+        abstract = True
+
+
+# this class will contain lecture activity frame recognitions
+class LectureActivityFrameRecognitions(models.Model):
+    lecture_activity_frame_recognition_id = models.CharField(max_length=15)
+    lecture_activity_id = models.ForeignKey(LectureActivity, on_delete=models.CASCADE)
+    frame_recognition_details = models.ArrayField(LectureActivityFrameRecognitionDetails)
+
+    def __str__(self):
+        return self.lecture_activity_frame_recognition_id
+
+
+
 # EMOTIONS section
 # Lecture emotion report
 class LectureEmotionReport(models.Model):
@@ -141,8 +225,132 @@ class LectureEmotionReport(models.Model):
         return self.lecture_emotion_id
 
 
+# this abstract class will define the lecture emotion frame group percentages
+class LectureEmotionFrameGroupPercentages(models.Model):
+    happy_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    sad_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    angry_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    disgust_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    surprise_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    neutral_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+
+    class Meta:
+        abstract = True
+
+
+# this abstract class will define the details for an emotion frame group
+class LectureEmotionFrameGroupDetails(models.Model):
+    frame_group = models.CharField(max_length=10)
+    frame_group_percentages = models.EmbeddedField(
+       model_container=LectureEmotionFrameGroupPercentages
+    )
+
+    class Meta:
+        abstract = True
+
+
+# this class will contain the emotion frame groupings
+class LectureEmotionFrameGroupings(models.Model):
+    lecture_emotion_frame_groupings_id = models.CharField(max_length=15, default="")
+    lecture_emotion_id = models.ForeignKey(LectureEmotionReport, on_delete=models.CASCADE)
+    frame_group_details = models.ArrayField(model_container=LectureEmotionFrameGroupDetails)
+
+    def __str__(self):
+        return self.lecture_emotion_frame_groupings_id
+
+
+# this abstract class will contain lecture emotion frame recognition details
+class LectureEmotionFrameRecognitionDetails(models.Model):
+    frame_name = models.CharField(max_length=15)
+    happy_perct = models.FloatField()
+    sad_perct = models.FloatField()
+    angry_perct = models.FloatField()
+    surprise_perct = models.FloatField()
+    neutral_perct = models.FloatField()
+
+    class Meta:
+        abstract = True
+
+
+# this class will contain lecture emotion frame recognitions
+class LectureEmotionFrameRecognitions(models.Model):
+    lecture_emotion_frame_recognition_id = models.CharField(max_length=15)
+    lecture_emotion_id = models.ForeignKey(LectureEmotionReport, on_delete=models.CASCADE)
+    frame_recognition_details = models.ArrayField(LectureEmotionFrameRecognitionDetails)
+
+    def __str__(self):
+        return self.lecture_emotion_frame_recognition_id
+
+
+
+
 # POSE section
 # lecture pose estimation
-class LecturePoseEstimation(models.Model):
-    lecture_pose_id = models.CharField(max_length=10)
-    lecture_video_id = models.ForeignKey(LectureVideo, on_delete=models.CASCADE)
\ No newline at end of file
+class LectureGazeEstimation(models.Model):
+    lecture_gaze_id = models.CharField(max_length=10)
+    lecture_video_id = models.ForeignKey(LectureVideo, on_delete=models.CASCADE)
+    looking_up_and_right_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    looking_up_and_left_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    looking_down_and_right_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    looking_down_and_left_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    looking_front_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+
+    def __str__(self):
+        return self.lecture_gaze_id
+
+
+# this abstract class will define the lecture gaze frame group percentages
+class LectureGazeFrameGroupPercentages(models.Model):
+    upright_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    upleft_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    downright_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    downleft_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+    front_perct = models.DecimalField(default=0.0, max_digits=3, decimal_places=1)
+
+    class Meta:
+        abstract = True
+
+
+# this abstract class will define the details for a gaze frame group
+class LectureGazeFrameGroupDetails(models.Model):
+    frame_group = models.CharField(max_length=10)
+    frame_group_percentages = models.EmbeddedField(
+       model_container=LectureGazeFrameGroupPercentages
+    )
+
+    class Meta:
+        abstract = True
+
+
+# this class will contain the gaze frame groupings
+class LectureGazeFrameGroupings(models.Model):
+    lecture_gaze_frame_groupings_id = models.CharField(max_length=15, default="")
+    lecture_gaze_id = models.ForeignKey(LectureGazeEstimation, on_delete=models.CASCADE)
+    frame_group_details = models.ArrayField(model_container=LectureGazeFrameGroupDetails)
+
+    def __str__(self):
+        return self.lecture_gaze_frame_groupings_id
+
+
+
+# this abstract class will contain lecture gaze frame recognition details
+class LectureGazeFrameRecognitionDetails(models.Model):
+    frame_name = models.CharField(max_length=15)
+    upright_perct = models.FloatField()
+    upleft_perct = models.FloatField()
+    downright_perct = models.FloatField()
+    downleft_perct = models.FloatField()
+    front_perct = models.FloatField()
+
+    class Meta:
+        abstract = True
+
+
+# this class will contain lecture gaze frame recognitions
+class LectureGazeFrameRecognitions(models.Model):
+    lecture_gaze_frame_recognition_id = models.CharField(max_length=15)
+    lecture_gaze_id = models.ForeignKey(LectureGazeEstimation, on_delete=models.CASCADE)
+    frame_recognition_details = models.ArrayField(LectureGazeFrameRecognitionDetails)
+
+    def __str__(self):
+        return self.lecture_gaze_frame_recognition_id
\ No newline at end of file

FirstApp/admin.py

@@ -11,4 +11,5 @@ admin.site.register(LecturerSubject)
 admin.site.register(LecturerCredentials)
 admin.site.register(FacultyTimetable)
 admin.site.register(LectureVideo)
-admin.site.register(LectureActivity)
\ No newline at end of file
+admin.site.register(LectureActivity)
+admin.site.register(LectureGazeEstimation)
\ No newline at end of file

FirstApp/logic/face_detector.py

+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jul 29 17:52:00 2020
+
+@author: hp
+"""
+
+import cv2
+import numpy as np
+import os
+
+def get_face_detector(modelFile = "models/res10_300x300_ssd_iter_140000.caffemodel",
+                      configFile = "models/deploy.prototxt"):
+    """
+    Get the face detection caffe model of OpenCV's DNN module
+    
+    Parameters
+    ----------
+    modelFile : string, optional
+        Path to model file. The default is "models/res10_300x300_ssd_iter_140000.caffemodel".
+    configFile : string, optional
+        Path to config file. The default is "models/deploy.prototxt".
+
+    Returns
+    -------
+    model : dnn_Net
+
+    """
+
+    BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    CLASSIFIER_DIR = os.path.join(BASE_DIR, "FirstApp\\classifiers")
+
+    modelFile = os.path.join(CLASSIFIER_DIR, "res10_300x300_ssd_iter_140000.caffemodel")
+    configFile = os.path.join(CLASSIFIER_DIR, "deploy.prototxt")
+    model = cv2.dnn.readNetFromCaffe(configFile, modelFile)
+
+    return model
+
+def find_faces(img, model):
+    """
+    Find the faces in an image
+    
+    Parameters
+    ----------
+    img : np.uint8
+        Image to find faces from
+    model : dnn_Net
+        Face detection model
+
+    Returns
+    -------
+    faces : list
+        List of coordinates of the faces detected in the image
+
+    """
+    h, w = img.shape[:2]
+    blob = cv2.dnn.blobFromImage(cv2.resize(img, (300, 300)), 1.0,
+	(300, 300), (104.0, 177.0, 123.0))
+    model.setInput(blob)
+    res = model.forward()
+    faces = []
+    for i in range(res.shape[2]):
+        confidence = res[0, 0, i, 2]
+        if confidence > 0.5:
+            box = res[0, 0, i, 3:7] * np.array([w, h, w, h])
+            (x, y, x1, y1) = box.astype("int")
+            faces.append([x, y, x1, y1])
+    return faces
+
+def draw_faces(img, faces):
+    """
+    Draw faces on image
+
+    Parameters
+    ----------
+    img : np.uint8
+        Image to draw faces on
+    faces : List of face coordinates
+        Coordinates of faces to draw
+
+    Returns
+    -------
+    None.
+
+    """
+    for x, y, x1, y1 in faces:
+        cv2.rectangle(img, (x, y), (x1, y1), (0, 0, 255), 3)
+        
\ No newline at end of file

FirstApp/logic/face_landmarks.py

+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jul 29 19:47:08 2020
+
+@author: hp
+"""
+
+import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+import os
+
+
+def get_landmark_model():
+    """
+    Get the facial landmark model. 
+    Original repository: https://github.com/yinguobing/cnn-facial-landmark
+
+    Parameters
+    ----------
+    saved_model : string, optional
+        Path to facial landmarks model. The default is 'models/pose_model'.
+
+    Returns
+    -------
+    model : Tensorflow model
+        Facial landmarks model
+
+    """
+    # define the location of the pose model
+    BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    saved_model = os.path.join(BASE_DIR, "FirstApp\\classifiers\\pose_model")
+
+    model = keras.models.load_model(saved_model)
+    return model
+
+def get_square_box(box):
+    """Get a square box out of the given box, by expanding it."""
+    left_x = box[0]
+    top_y = box[1]
+    right_x = box[2]
+    bottom_y = box[3]
+
+    box_width = right_x - left_x
+    box_height = bottom_y - top_y
+
+    # Check if box is already a square. If not, make it a square.
+    diff = box_height - box_width
+    delta = int(abs(diff) / 2)
+
+    if diff == 0:                   # Already a square.
+        return box
+    elif diff > 0:                  # Height > width, a slim box.
+        left_x -= delta
+        right_x += delta
+        if diff % 2 == 1:
+            right_x += 1
+    else:                           # Width > height, a short box.
+        top_y -= delta
+        bottom_y += delta
+        if diff % 2 == 1:
+            bottom_y += 1
+
+    # Make sure box is always square.
+    assert ((right_x - left_x) == (bottom_y - top_y)), 'Box is not square.'
+
+    return [left_x, top_y, right_x, bottom_y]
+
+def move_box(box, offset):
+        """Move the box to direction specified by vector offset"""
+        left_x = box[0] + offset[0]
+        top_y = box[1] + offset[1]
+        right_x = box[2] + offset[0]
+        bottom_y = box[3] + offset[1]
+        return [left_x, top_y, right_x, bottom_y]
+
+def detect_marks(img, model, face):
+    """
+    Find the facial landmarks in an image from the faces
+
+    Parameters
+    ----------
+    img : np.uint8
+        The image in which landmarks are to be found
+    model : Tensorflow model
+        Loaded facial landmark model
+    face : list
+        Face coordinates (x, y, x1, y1) in which the landmarks are to be found
+
+    Returns
+    -------
+    marks : numpy array
+        facial landmark points
+
+    """
+
+    offset_y = int(abs((face[3] - face[1]) * 0.1))
+    box_moved = move_box(face, [0, offset_y])
+    facebox = get_square_box(box_moved)
+
+    # reassigning the facebox values
+    facebox[0] = facebox[0] if facebox[0] > 0 else 0
+    facebox[1] = facebox[1] if facebox[1] > 0 else 0
+    facebox[2] = facebox[2] if facebox[2] > 0 else 0
+    facebox[3] = facebox[3] if facebox[3] > 0 else 0
+
+    # draw a bounding box
+    cv2.rectangle(img, (facebox[0], facebox[1]), (facebox[2], facebox[3]), (0, 255, 0), 2)
+
+    face_img = img[facebox[1]: facebox[3],
+                     facebox[0]: facebox[2]]
+
+    marks = np.zeros((68, 2))
+
+    # if the list length is more than 0
+    if len(face_img) > 0:
+        face_img = cv2.resize(face_img, (128, 128))
+        face_img = cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB)
+
+        # # Actual detection.
+        predictions = model.signatures["predict"](
+            tf.constant([face_img], dtype=tf.uint8))
+
+        # Convert predictions to landmarks.
+        marks = np.array(predictions['output']).flatten()[:136]
+        marks = np.reshape(marks, (-1, 2))
+
+        marks *= (facebox[2] - facebox[0])
+        marks[:, 0] += facebox[0]
+        marks[:, 1] += facebox[1]
+        marks = marks.astype(np.uint)
+
+
+    # return marks
+
+    # return detected facial marks and face coordinates
+    return marks, facebox
+    
+
+
+def draw_marks(image, marks, color=(0, 255, 0)):
+    """
+    Draw the facial landmarks on an image
+
+    Parameters
+    ----------
+    image : np.uint8
+        Image on which landmarks are to be drawn.
+    marks : list or numpy array
+        Facial landmark points
+    color : tuple, optional
+        Color to which landmarks are to be drawn with. The default is (0, 255, 0).
+
+    Returns
+    -------
+    None.
+
+    """
+    for mark in marks:
+        cv2.circle(image, (mark[0], mark[1]), 2, color, -1, cv2.LINE_AA)
\ No newline at end of file

FirstApp/logic/pdf_file_generator.py

+import jinja2 as ji
+import pdfkit
+import os
+# from DemoProject import jinja2
+from integrated_slpes import jinja2
+
+def generate_pdf_file(object):
+
+    # templateLoader = jinja2.FileSystemLoader(searchpath="../")
+    BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    TEMPLATE_DIR = os.path.join(BASE_DIR, "FirstApp\\templates\\FirstApp")
+    HTML_PATH = os.path.join(TEMPLATE_DIR, "pdf_template_1.html")
+    PDF_DIRECTORY = os.path.join(BASE_DIR, "FirstApp\\files")
+    templateLoader = ji.FileSystemLoader(TEMPLATE_DIR)
+    new_env = jinja2.environment()
+    templateEnv = jinja2.Environment(loader=templateLoader)
+    TEMPLATE_FILE = "pdf_template.html"
+    template = templateEnv.get_template(TEMPLATE_FILE)
+
+    print('variables: ', templateEnv.globals['dict'])
+
+
+    # render the template
+    outputText = template.render(lecturer_name=object['lecturer_name'], subject=object['subject_name'], date=object['date'], static=new_env.globals['static'])
+    html_file = open(HTML_PATH, "w")
+    html_file.write(outputText)
+    html_file.close()
+
+    # create a new pdf file path
+    NEW_PDF_PATH = os.path.join(PDF_DIRECTORY, "activity.pdf")
+
+    asset_path = os.path.join('D:/SLIIT/Year 4/CDAP/project/2020-101/assets/FirstApp/css/sb-admin-2.min.css')
+    network_path = "file:/" + asset_path
+
+    # options = {'enable-local-file-access': network_path}
+    options = {'enable-local-file-access': asset_path, 'load-error-handling': 'ignore'}
+
+    # create a new pdf file
+    pdfkit.from_file(HTML_PATH, NEW_PDF_PATH, options=options)
+

FirstApp/logic/posenet_calculation.py

@@ -117,10 +117,6 @@ def calculate_pose_estimation_for_student(video_name, student, poses):
 
                 left_upper_x = 0 if (middle_x - fraction) < 0 else (middle_x - fraction)
 
-                print('head_y: ', head_y)
-                print('fraction: ', fraction)
-                print('distance: ', distance)
-                print('left_upper_x: ', left_upper_x)
 
                 # extract the new image
                 new_img = detection_img[head_y:head_y+fraction, left_upper_x:left_upper_x+distance]

FirstApp/logic/video_extraction.py

 import os
 import cv2
 import shutil
+import datetime
+
+from FirstApp.MongoModels import *
+from FirstApp.serializers import *
+from . import id_generator as ig
+
 
 def VideoExtractor(request):
 
@@ -68,3 +74,223 @@ def getExtractedFrames(request):
 
     else:
         return "No extracted frames were found"
+
+
+# this method will retrieve the time landmarks for a lecture video
+def getTimeLandmarks(video_name):
+    BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    VIDEO_PATH = os.path.join(BASE_DIR, "assets\\FirstApp\\videos\\{}".format(video_name))
+
+    # iteration
+    video = cv2.VideoCapture(VIDEO_PATH)
+    no_of_frames = video.get(cv2.CAP_PROP_FRAME_COUNT)
+    fps = int(video.get(cv2.CAP_PROP_FPS))
+    frame_count = 0
+
+    # calculating the duration in seconds
+    duration = int(no_of_frames / fps)
+
+    # define the number of time gaps required
+    THRESHOLD_GAP = 5
+
+    # calculating the real duration
+    real_duration = datetime.timedelta(seconds=(duration+THRESHOLD_GAP))
+
+    # defines the number of seconds included for a frame group
+    THRESHOLD_TIME = 10
+
+
+    # define an unit gap
+    unit_gap = int(duration / THRESHOLD_GAP)
+
+    initial_landmark = 0
+
+    # time_landmarks = ['0:00:00']
+    time_landmarks = []
+    time_landmarks_values = [0]
+
+    # loop through the threshold gap limit to define the time landmarks
+    for i in range(THRESHOLD_GAP):
+        initial_landmark += unit_gap
+        time_landmark = str(datetime.timedelta(seconds=initial_landmark))
+        time_landmark_value = initial_landmark
+        time_landmarks.append(time_landmark)
+        time_landmarks_values.append(time_landmark_value)
+
+    # append the final time
+    time_landmarks.append(str(real_duration))
+    time_landmarks_values.append(duration)
+
+    return time_landmarks
+
+
+# this method will retrieve the time landmarks for a lecture video
+def getFrameLandmarks(video_name, category):
+    BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    VIDEO_PATH = os.path.join(BASE_DIR, "assets\\FirstApp\\videos\\{}".format(video_name))
+
+    # iteration
+    video = cv2.VideoCapture(VIDEO_PATH)
+    no_of_frames = video.get(cv2.CAP_PROP_FRAME_COUNT)
+    int_no_of_frames = int(no_of_frames)
+    fps = int(video.get(cv2.CAP_PROP_FPS))
+
+    # list of categories
+    categories = ["Activity", "Emotion", "Gaze"]
+
+    # define the number of time gaps required
+    THRESHOLD_GAP = 5
+
+    # define a frame gap
+    frame_gap = int(int_no_of_frames / THRESHOLD_GAP)
+
+    initial_frame_landmark = 0
+
+    # define frame landmarks
+    frame_landmarks = [0]
+    # frame_landmarks = []
+
+    # loop through the threshold gap limit to define the time landmarks
+    for i in range(THRESHOLD_GAP):
+        initial_frame_landmark += frame_gap
+
+        frame_landmarks.append(initial_frame_landmark)
+
+    # append the final frame
+    frame_landmarks.append(int_no_of_frames)
+
+    # defining the frame group dictionary
+    frame_group_list = []
+
+    # creating frame group names
+    for landmark in frame_landmarks:
+        index = frame_landmarks.index(landmark)
+        j = index + 1
+
+        # if the next index is within the range of the list
+        if j < len(frame_landmarks):
+            next_value = frame_landmarks[j]
+
+            group_name = "{}-{}".format(landmark, next_value)
+
+            # append to the list
+            frame_group_list.append(group_name)
+
+
+    # define a dictionary to hold the frame groups
+    frame_group_dict = {}
+
+    # checking for the category
+    if category == categories[0]:
+        # loop through the group names to create a dictionary
+        for name in frame_group_list:
+            frame_group_dict[name] = {'phone_count': 0, 'listen_count': 0, 'note_count': 0, 'detection_count': 0}
+
+    elif category == categories[1]:
+        # loop through the group names to create a dictionary
+        for name in frame_group_list:
+            frame_group_dict[name] = {'happy_count': 0, 'sad_count': 0, 'angry_count': 0, 'surprise_count': 0, 'neutral_count': 0, 'detection_count': 0}
+
+    elif category == categories[2]:
+        # loop through the group names to create a dictionary
+        for name in frame_group_list:
+            frame_group_dict[name] = {'upright_count': 0, 'upleft_count': 0, 'downright_count': 0, 'downleft_count': 0,
+                                      'front_count': 0, 'detection_count': 0}
+
+    return frame_landmarks, frame_group_dict
+
+
+
+# this section will handle some database operations
+def save_time_landmarks(video_name):
+
+    last_lec_video_time_landmarks = LectureVideoTimeLandmarks.objects.order_by('lecture_video_time_landmarks_id').last()
+    new_lecture_video_time_landmarks_id = "LVTL00001" if (last_lec_video_time_landmarks is None) else \
+            ig.generate_new_id(last_lec_video_time_landmarks.lecture_video_time_landmarks_id)
+
+
+    # retrieve lecture video details
+    lec_video = LectureVideo.objects.filter(video_name=video_name)
+    lec_video_ser = LectureVideoSerializer(lec_video, many=True)
+    lec_video_id = lec_video_ser.data[0]['id']
+
+
+    # save the landmark details in the db
+    time_landmarks = getTimeLandmarks(video_name)
+
+    db_time_landmarks = []
+
+    # loop through the time landmarks
+    for landmark in time_landmarks:
+        landmark_obj = Landmarks()
+        landmark_obj.landmark = landmark
+
+        db_time_landmarks.append(landmark_obj)
+
+
+    new_lec_video_time_landmarks = LectureVideoTimeLandmarks()
+    new_lec_video_time_landmarks.lecture_video_time_landmarks_id = new_lecture_video_time_landmarks_id
+    new_lec_video_time_landmarks.lecture_video_id_id = lec_video_id
+    new_lec_video_time_landmarks.time_landmarks = db_time_landmarks
+
+    new_lec_video_time_landmarks.save()
+
+
+# this method will save frame landmarks to the database
+def save_frame_landmarks(video_name):
+
+    # retrieve the previous lecture video frame landmarks details
+    last_lec_video_frame_landmarks = LectureVideoFrameLandmarks.objects.order_by(
+        'lecture_video_frame_landmarks_id').last()
+    new_lecture_video_frame_landmarks_id = "LVFL00001" if (last_lec_video_frame_landmarks is None) else \
+        ig.generate_new_id(last_lec_video_frame_landmarks.lecture_video_frame_landmarks_id)
+
+    frame_landmarks, frame_group_dict = getFrameLandmarks(video_name, "Activity")
+
+
+    # retrieve lecture video details
+    lec_video = LectureVideo.objects.filter(video_name=video_name)
+    lec_video_ser = LectureVideoSerializer(lec_video, many=True)
+    lec_video_id = lec_video_ser.data[0]['id']
+
+
+    # save the frame landmarks details into db
+    db_frame_landmarks = []
+
+    for landmark in frame_landmarks:
+        landmark_obj = Landmarks()
+        landmark_obj.landmark = landmark
+
+        db_frame_landmarks.append(landmark_obj)
+
+
+    new_lec_video_frame_landmarks = LectureVideoFrameLandmarks()
+    new_lec_video_frame_landmarks.lecture_video_frame_landmarks_id = new_lecture_video_frame_landmarks_id
+    new_lec_video_frame_landmarks.lecture_video_id_id = lec_video_id
+    new_lec_video_frame_landmarks.frame_landmarks = db_frame_landmarks
+
+    new_lec_video_frame_landmarks.save()
+
+    # now return the frame landmarks and the frame group dictionary
+    return frame_landmarks, frame_group_dict
+
+
+# this method will retrieve the frame landmarks from the database
+def get_frame_landmarks(video_name):
+
+    frame_landmarks = []
+
+    # retrieve frame landmarks from db
+    lec_video_frame_landmarks = LectureVideoFrameLandmarks.objects.filter(lecture_video_id__video_name=video_name)
+    lec_video_frame_landmarks_ser = LectureVideoFrameLandmarksSerializer(lec_video_frame_landmarks, many=True)
+    lec_video_frame_landmarks_data = lec_video_frame_landmarks_ser.data[0]
+
+    retrieved_frame_landmarks = lec_video_frame_landmarks_data["frame_landmarks"]
+
+    # creating a new list to display in the frontend
+    for landmark in retrieved_frame_landmarks:
+        frame_landmarks.append(landmark['landmark'])
+
+
+    # now return the frame landmarks
+    return frame_landmarks
\ No newline at end of file

FirstApp/migrations/0002_registeruser_video_videometa.py

+# Generated by Django 2.2.11 on 2020-03-16 12:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='RegisterUser',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('firstName', models.CharField(max_length=20)),
+                ('lastName', models.CharField(max_length=30)),
+                ('email', models.CharField(max_length=30)),
+                ('password', models.CharField(max_length=50)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Video',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100)),
+                ('path', models.CharField(max_length=100)),
+                ('duration', models.CharField(max_length=100)),
+                ('hours', models.IntegerField()),
+                ('minutes', models.IntegerField()),
+                ('seconds', models.IntegerField()),
+            ],
+        ),
+        migrations.CreateModel(
+            name='VideoMeta',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('fps', models.IntegerField()),
+                ('frame_count', models.IntegerField()),
+                ('happy_count', models.IntegerField()),
+                ('sad_count', models.IntegerField()),
+                ('angry_count', models.IntegerField()),
+                ('neutral_count', models.IntegerField()),
+                ('surprise_count', models.IntegerField()),
+                ('happy_perct', models.IntegerField()),
+                ('sad_perct', models.IntegerField()),
+                ('angry_perct', models.IntegerField()),
+                ('neutral_perct', models.IntegerField()),
+                ('surprise_perct', models.IntegerField()),
+            ],
+        ),
+    ]

FirstApp/migrations/0003_lectureemotionreport.py

+# Generated by Django 2.2.11 on 2020-05-10 15:32
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0002_registeruser_video_videometa'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LectureEmotionReport',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_id', models.CharField(max_length=10)),
+                ('happy_perct', models.FloatField()),
+                ('sad_perct', models.FloatField()),
+                ('angry_perct', models.FloatField()),
+                ('surprise_perct', models.FloatField()),
+                ('disgust_perct', models.FloatField()),
+                ('neutral_perct', models.FloatField()),
+            ],
+        ),
+    ]

FirstApp/migrations/0004_lecture.py

+# Generated by Django 2.2.11 on 2020-05-11 16:58
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0003_lectureemotionreport'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Lecture',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('date', models.DateTimeField(auto_created=True)),
+                ('lecture_id', models.CharField(max_length=10)),
+            ],
+        ),
+    ]

FirstApp/migrations/0005_auto_20200513_1551.py

+# Generated by Django 2.2.11 on 2020-05-13 10:21
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0004_lecture'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Faculty',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('faculty_id', models.CharField(max_length=10)),
+                ('name', models.CharField(max_length=100)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Lecturer',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecturer_id', models.CharField(max_length=7)),
+                ('fname', models.TextField()),
+                ('lname', models.TextField()),
+                ('email', models.EmailField(max_length=254)),
+                ('telephone', models.CharField(max_length=10)),
+                ('faculty', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Faculty')),
+            ],
+        ),
+        migrations.AlterField(
+            model_name='lecture',
+            name='date',
+            field=models.DateTimeField(auto_created=True, default=None),
+        ),
+        migrations.CreateModel(
+            name='Subject',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('subject_code', models.TextField()),
+                ('name', models.TextField()),
+                ('year', models.IntegerField()),
+                ('faculty', models.ForeignKey(default={}, on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Faculty')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='LecturerSubject',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lec_subject_id', models.CharField(max_length=10)),
+                ('lecturer_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Lecturer')),
+                ('subjects', models.ManyToManyField(to='FirstApp.Subject')),
+            ],
+        ),
+    ]

FirstApp/migrations/0006_lecturercredentials.py

+# Generated by Django 2.2.11 on 2020-05-13 15:46
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0005_auto_20200513_1551'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LecturerCredentials',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('password', models.CharField(max_length=15)),
+                ('username', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Lecturer')),
+            ],
+        ),
+    ]

FirstApp/migrations/0007_auto_20200825_1658.py

+# Generated by Django 2.2.11 on 2020-08-25 11:28
+
+import FirstApp.MongoModels
+from django.db import migrations, models
+import django.db.models.deletion
+import djongo.models.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0006_lecturercredentials'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='lectureemotionreport',
+            old_name='lecture_id',
+            new_name='lecture_emotion_id',
+        ),
+        migrations.AlterField(
+            model_name='lectureemotionreport',
+            name='angry_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AlterField(
+            model_name='lectureemotionreport',
+            name='disgust_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AlterField(
+            model_name='lectureemotionreport',
+            name='happy_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AlterField(
+            model_name='lectureemotionreport',
+            name='neutral_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AlterField(
+            model_name='lectureemotionreport',
+            name='sad_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AlterField(
+            model_name='lectureemotionreport',
+            name='surprise_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.CreateModel(
+            name='LectureVideo',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_video_id', models.CharField(max_length=10)),
+                ('date', models.DateField()),
+                ('video_name', models.CharField(max_length=50)),
+                ('video_length', models.DurationField()),
+                ('lecturer', models.ForeignKey(default=0, on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Lecturer')),
+                ('subject', models.ForeignKey(default=0, on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Subject')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='LectureGazeEstimation',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_gaze_id', models.CharField(max_length=10)),
+                ('lecture_video_id',
+                 models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureVideo')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='LectureActivity',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_activity_id', models.CharField(max_length=10)),
+                ('talking_perct', models.DecimalField(decimal_places=1, default=0.0, max_digits=3)),
+                ('listening_perct', models.DecimalField(decimal_places=1, default=0.0, max_digits=3)),
+                ('writing_perct', models.DecimalField(decimal_places=1, default=0.0, max_digits=3)),
+                ('phone_perct', models.DecimalField(decimal_places=1, default=0.0, max_digits=3)),
+                ('lecture_video_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureVideo')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='FacultyTimetable',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('timetable_id', models.CharField(max_length=10)),
+                ('timetable', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.DateTimeTable)),
+                ('faculty', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.Faculty')),
+            ],
+        ),
+        migrations.AddField(
+            model_name='lectureemotionreport',
+            name='lecture_video_id',
+            field=models.ForeignKey(default=0, on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureVideo'),
+        ),
+    ]

FirstApp/migrations/0008_auto_20200825_1821.py

+# Generated by Django 2.2.11 on 2020-08-25 12:51
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0007_auto_20200825_1658'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='lecturegazeestimation',
+            name='looking_down_and_left_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AddField(
+            model_name='lecturegazeestimation',
+            name='looking_down_and_right_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AddField(
+            model_name='lecturegazeestimation',
+            name='looking_front_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AddField(
+            model_name='lecturegazeestimation',
+            name='looking_up_and_left_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+        migrations.AddField(
+            model_name='lecturegazeestimation',
+            name='looking_up_and_right_perct',
+            field=models.DecimalField(decimal_places=1, default=0.0, max_digits=3),
+        ),
+    ]

FirstApp/migrations/0009_lectureactivityframegroupings.py

+# Generated by Django 2.2.11 on 2020-10-08 17:02
+
+import FirstApp.MongoModels
+from django.db import migrations, models
+import django.db.models.deletion
+import djongo.models.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0008_auto_20200825_1821'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LectureActivityFrameGroupings',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_activity_frame_groupings_id', models.CharField(default='', max_length=15)),
+                ('frame_group_details', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.LectureActivityFrameGroupDetails)),
+                ('lecture_activity_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureActivity')),
+            ],
+        ),
+    ]

FirstApp/migrations/0010_lecturevideoframelandmarks_lecturevideotimelandmarks.py

+# Generated by Django 2.2.11 on 2020-10-09 09:10
+
+import FirstApp.MongoModels
+from django.db import migrations, models
+import django.db.models.deletion
+import djongo.models.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0009_lectureactivityframegroupings'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LectureVideoTimeLandmarks',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_video_time_landmarks_id', models.CharField(max_length=15)),
+                ('time_landmarks', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.Landmarks)),
+                ('lecture_video_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureVideo')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='LectureVideoFrameLandmarks',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_video_frame_landmarks_id', models.CharField(max_length=15)),
+                ('frame_landmarks', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.Landmarks)),
+                ('lecture_video_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureVideo')),
+            ],
+        ),
+    ]

FirstApp/migrations/0011_lectureemotionframegroupings_lecturegazeframegroupings.py

+# Generated by Django 2.2.11 on 2020-10-09 16:58
+
+import FirstApp.MongoModels
+from django.db import migrations, models
+import django.db.models.deletion
+import djongo.models.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0010_lecturevideoframelandmarks_lecturevideotimelandmarks'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LectureGazeFrameGroupings',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_gaze_frame_groupings_id', models.CharField(default='', max_length=15)),
+                ('frame_group_details', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.LectureGazeFrameGroupDetails)),
+                ('lecture_gaze_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureGazeEstimation')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='LectureEmotionFrameGroupings',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_emotion_frame_groupings_id', models.CharField(default='', max_length=15)),
+                ('frame_group_details', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.LectureEmotionFrameGroupDetails)),
+                ('lecture_emotion_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureEmotionReport')),
+            ],
+        ),
+    ]

FirstApp/migrations/0012_lectureactivityframerecognitions.py

+# Generated by Django 2.2.11 on 2020-10-16 17:07
+
+import FirstApp.MongoModels
+from django.db import migrations, models
+import django.db.models.deletion
+import djongo.models.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0011_lectureemotionframegroupings_lecturegazeframegroupings'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LectureActivityFrameRecognitions',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_activity_frame_recognition_id', models.CharField(max_length=15)),
+                ('frame_recognition_details', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.LectureActivityFrameRecognitionDetails)),
+                ('lecture_activity_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureActivity')),
+            ],
+        ),
+    ]

FirstApp/migrations/0013_lectureemotionframerecognitions.py

+# Generated by Django 2.2.11 on 2020-10-17 14:01
+
+import FirstApp.MongoModels
+from django.db import migrations, models
+import django.db.models.deletion
+import djongo.models.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0012_lectureactivityframerecognitions'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LectureEmotionFrameRecognitions',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_emotion_frame_recognition_id', models.CharField(max_length=15)),
+                ('frame_recognition_details', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.LectureEmotionFrameRecognitionDetails)),
+                ('lecture_emotion_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureEmotionReport')),
+            ],
+        ),
+    ]

FirstApp/migrations/0014_lecturegazeframerecognitions.py

+# Generated by Django 2.2.11 on 2020-10-17 17:06
+
+import FirstApp.MongoModels
+from django.db import migrations, models
+import django.db.models.deletion
+import djongo.models.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('FirstApp', '0013_lectureemotionframerecognitions'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='LectureGazeFrameRecognitions',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('lecture_gaze_frame_recognition_id', models.CharField(max_length=15)),
+                ('frame_recognition_details', djongo.models.fields.ArrayField(model_container=FirstApp.MongoModels.LectureGazeFrameRecognitionDetails)),
+                ('lecture_gaze_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='FirstApp.LectureGazeEstimation')),
+            ],
+        ),
+    ]

FirstApp/serializers.py

@@ -201,6 +201,52 @@ class LectureVideoSerializer(serializers.ModelSerializer):
         fields = '__all__'
 
 
+# lecture video time landmarks serializer
+class LectureVideoTimeLandmarksSerializer(serializers.ModelSerializer):
+
+    lecture_video_id = LectureVideoSerializer()
+    time_landmarks = serializers.SerializerMethodField()
+
+    def get_time_landmarks(self, obj):
+        return_data = []
+
+        for time_landmark in obj.time_landmarks:
+            landmark_details = {}
+            landmark_details["landmark"] = time_landmark.landmark
+
+            return_data.append(landmark_details)
+
+        return return_data
+
+
+    class Meta:
+        model = LectureVideoTimeLandmarks
+        fields = '__all__'
+
+# lecture video frame landmarks serializer
+class LectureVideoFrameLandmarksSerializer(serializers.ModelSerializer):
+
+    lecture_video_id = LectureVideoSerializer()
+    frame_landmarks = serializers.SerializerMethodField()
+
+    def get_frame_landmarks(self, obj):
+        return_data = []
+
+        for frame_landmark in obj.frame_landmarks:
+            landmark_details = {}
+            landmark_details["landmark"] = frame_landmark.landmark
+
+            return_data.append(landmark_details)
+
+        return return_data
+
+
+    class Meta:
+        model = LectureVideoFrameLandmarks
+        fields = '__all__'
+
+
+# Lecture activity serializer
 class LectureActivitySerializer(serializers.ModelSerializer):
 
     lecture_video_id = LectureVideoSerializer()
@@ -210,6 +256,64 @@ class LectureActivitySerializer(serializers.ModelSerializer):
         fields = '__all__'
 
 
+# Lecture Activity Frame Group Serializer
+class LectureActivityFrameGroupingsSerializer(serializers.ModelSerializer):
+
+    lecture_activity_id = LectureActivitySerializer()
+    frame_group_details = serializers.SerializerMethodField()
+
+    def get_frame_group_details(self, obj):
+        return_data = []
+
+        for frame_group in obj.frame_group_details:
+            group_details = {}
+            group_details["frame_group_percentages"] = {}
+
+            group_details["frame_group"] = frame_group.frame_group
+            group_details["frame_group_percentages"]["phone_perct"] = frame_group.frame_group_percentages.phone_perct
+            group_details["frame_group_percentages"]["listen_perct"] = frame_group.frame_group_percentages.listen_perct
+            group_details["frame_group_percentages"]["note_perct"] = frame_group.frame_group_percentages.note_perct
+
+            return_data.append(group_details)
+
+        return return_data
+
+    class Meta:
+        model = LectureActivityFrameGroupings
+        fields = '__all__'
+
+
+# lecture activity frame recognition serializer
+class LectureActivityFrameRecognitionsSerializer(serializers.ModelSerializer):
+
+    lecture_activity_id = LectureActivitySerializer()
+    frame_recognition_details = serializers.SerializerMethodField()
+
+    # this method will be used to serialize the 'frame_recogition_details' field
+    def get_frame_recognition_details(self, obj):
+
+        return_data = []
+
+        for frame_recognition in obj.frame_recognition_details:
+            recognition = {}
+
+            recognition["frame_name"] = frame_recognition.frame_name
+            recognition["phone_perct"] = frame_recognition.phone_perct
+            recognition["listen_perct"] = frame_recognition.listen_perct
+            recognition["note_perct"] = frame_recognition.note_perct
+
+            return_data.append(recognition)
+
+        # return the data
+        return return_data
+
+
+    class Meta:
+        model = LectureActivityFrameRecognitions
+        fields = '__all__'
+
+
+
 # EMOTIONS section
 # lecture emotions serailzier
 class LectureEmotionSerializer(serializers.ModelSerializer):
@@ -220,9 +324,146 @@ class LectureEmotionSerializer(serializers.ModelSerializer):
         fields = '__all__'
 
 
+# Lecture emotion Frame Group Serializer
+class LectureEmotionFrameGroupingsSerializer(serializers.ModelSerializer):
+
+    lecture_emotion_id = LectureEmotionSerializer()
+    frame_group_details = serializers.SerializerMethodField()
+
+    def get_frame_group_details(self, obj):
+        return_data = []
+
+        for frame_group in obj.frame_group_details:
+            group_details = {}
+            group_details["frame_group_percentages"] = {}
+
+            group_details["frame_group"] = frame_group.frame_group
+            group_details["frame_group_percentages"]["happy_perct"] = frame_group.frame_group_percentages.happy_perct
+            group_details["frame_group_percentages"]["sad_perct"] = frame_group.frame_group_percentages.sad_perct
+            group_details["frame_group_percentages"]["angry_perct"] = frame_group.frame_group_percentages.angry_perct
+            group_details["frame_group_percentages"]["disgust_perct"] = frame_group.frame_group_percentages.disgust_perct
+            group_details["frame_group_percentages"]["surprise_perct"] = frame_group.frame_group_percentages.surprise_perct
+            group_details["frame_group_percentages"]["neutral_perct"] = frame_group.frame_group_percentages.neutral_perct
+
+            return_data.append(group_details)
+
+        return return_data
+
+
+    class Meta:
+        model = LectureEmotionFrameGroupings
+        fields = '__all__'
+
+
+
+# lecture emotion frame recognition serializer
+class LectureEmotionFrameRecognitionsSerializer(serializers.ModelSerializer):
+
+    lecture_emotion_id = LectureEmotionSerializer()
+    frame_recognition_details = serializers.SerializerMethodField()
+
+    # this method will be used to serialize the 'frame_recogition_details' field
+    def get_frame_recognition_details(self, obj):
+
+        return_data = []
+
+        for frame_recognition in obj.frame_recognition_details:
+            recognition = {}
+
+            recognition["frame_name"] = frame_recognition.frame_name
+            recognition["happy_perct"] = frame_recognition.happy_perct
+            recognition["sad_perct"] = frame_recognition.sad_perct
+            recognition["angry_perct"] = frame_recognition.angry_perct
+            recognition["surprise_perct"] = frame_recognition.surprise_perct
+            recognition["neutral_perct"] = frame_recognition.neutral_perct
+
+            return_data.append(recognition)
+
+        # return the data
+        return return_data
+
+
+    class Meta:
+        model = LectureEmotionFrameRecognitions
+        fields = '__all__'
+
+
+
 # lecture video meta serializer
 class VideoMetaSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = VideoMeta
         fields = '__all__'
+
+# lecture gaze serializer
+class LectureGazeEstimationSerializer(serializers.ModelSerializer):
+
+    lecture_video_id = LectureVideoSerializer()
+
+    class Meta:
+        model = LectureGazeEstimation
+        fields = '__all__'
+
+
+# Lecture emotion Frame Group Serializer
+class LectureGazeFrameGroupingsSerializer(serializers.ModelSerializer):
+
+    lecture_gaze_id = LectureGazeEstimationSerializer()
+    frame_group_details = serializers.SerializerMethodField()
+
+    def get_frame_group_details(self, obj):
+        return_data = []
+
+        for frame_group in obj.frame_group_details:
+            group_details = {}
+            group_details["frame_group_percentages"] = {}
+
+            group_details["frame_group"] = frame_group.frame_group
+            group_details["frame_group_percentages"]["upright_perct"] = frame_group.frame_group_percentages.upright_perct
+            group_details["frame_group_percentages"]["upleft_perct"] = frame_group.frame_group_percentages.upleft_perct
+            group_details["frame_group_percentages"]["downright_perct"] = frame_group.frame_group_percentages.downright_perct
+            group_details["frame_group_percentages"]["downleft_perct"] = frame_group.frame_group_percentages.downleft_perct
+            group_details["frame_group_percentages"]["front_perct"] = frame_group.frame_group_percentages.front_perct
+
+            return_data.append(group_details)
+
+        return return_data
+
+
+    class Meta:
+        model = LectureGazeFrameGroupings
+        fields = '__all__'
+
+
+
+# lecture emotion frame recognition serializer
+class LectureGazeFrameRecognitionsSerializer(serializers.ModelSerializer):
+
+    lecture_gaze_id = LectureGazeEstimationSerializer()
+    frame_recognition_details = serializers.SerializerMethodField()
+
+    # this method will be used to serialize the 'frame_recogition_details' field
+    def get_frame_recognition_details(self, obj):
+
+        return_data = []
+
+        for frame_recognition in obj.frame_recognition_details:
+            recognition = {}
+
+            recognition["frame_name"] = frame_recognition.frame_name
+            recognition["upright_perct"] = frame_recognition.upright_perct
+            recognition["upleft_perct"] = frame_recognition.upleft_perct
+            recognition["downright_perct"] = frame_recognition.downright_perct
+            recognition["downleft_perct"] = frame_recognition.downleft_perct
+            recognition["front_perct"] = frame_recognition.front_perct
+
+            return_data.append(recognition)
+
+        # return the data
+        return return_data
+
+
+    class Meta:
+        model = LectureGazeFrameRecognitions
+        fields = '__all__'
\ No newline at end of file

FirstApp/templates/FirstApp/charts.html

@@ -3,6 +3,8 @@
 
 <head>
 
+  {% load static %}
+
   <meta charset="utf-8">
   <meta http-equiv="X-UA-Compatible" content="IE=edge">
   <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
@@ -12,11 +14,11 @@
   <title>SB Admin 2 - Charts</title>
 
   <!-- Custom fonts for this template-->
-  <link href="vendor/fontawesome-free/css/all.min.css" rel="stylesheet" type="text/css">
+  <link href="{% static 'FirstApp/vendor/fontawesome-free/css/all.min.css' %}" rel="stylesheet" type="text/css">
   <link href="https://fonts.googleapis.com/css?family=Nunito:200,200i,300,300i,400,400i,600,600i,700,700i,800,800i,900,900i" rel="stylesheet">
 
   <!-- Custom styles for this template-->
-  <link href="css/sb-admin-2.min.css" rel="stylesheet">
+  <link href="{% static 'FirstApp/css/sb-admin-2.min.css' %}" rel="stylesheet">
 
 </head>
 

LectureSummarizingApp/ExtractKeySentences.py

+import nltk
+read_lines = [line.rstrip('\n') for line in open("audioToText01.txt", "r")]
+sentences_list = []
+sentence_list = nltk.sent_tokenize(read_lines)
+word_search = "important"
+sentences_with_word = []
+for sentence in sentences_list:
+    if sentence.count(word_search)>0:
+        sentences_with_word.append(sentence)
+
+words_search = ["exam", "assignment"]
+word_sentence_dictionary = {"exam":[],"assignment":[]}
+
+for word in words_search:
+    sentences_with_word = []
+    for sentence in sentences_list:
+        if sentence.count(word)>0:
+            sentences_with_word.append(sentence)
+            word_sentence_dictionary[word] = sentences_with_word
\ No newline at end of file

LectureSummarizingApp/admin.py

@@ -4,4 +4,7 @@ from django.contrib import admin
 from LectureSummarizingApp.models import *
 
 admin.site.register(LectureAudio)
+admin.site.register(LectureAudioNoiseRemoved)
+admin.site.register(LectureSpeechToText)
+admin.site.register(LectureNotices)
 admin.site.register(LectureAudioSummary)

LectureSummarizingApp/audioToText01.txt

+error
\ No newline at end of file

LectureSummarizingApp/migrations/0003_auto_20200923_0002.py

+# Generated by Django 2.2.12 on 2020-09-22 18:32
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('LectureSummarizingApp', '0002_lectureaudionoiseremoved'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='lectureaudionoiseremoved',
+            old_name='lecture_audio_id',
+            new_name='lecture_audio_noise_removed_id',
+        ),
+    ]

test_branch.txt

+This is a sample text file
\ No newline at end of file