Merge remote-tracking branch 'origin/QA_RELEASE' into summarization_changes

# Conflicts:
#	FirstApp/views.py

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)
+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

@@ -12,3 +12,4 @@ admin.site.register(LecturerCredentials)
 admin.site.register(FacultyTimetable)
 admin.site.register(LectureVideo)
 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>
 

FirstApp/urls.py

@@ -41,6 +41,9 @@ urlpatterns = [
     # tables view
     path('tables', views.tables),
 
+    # test view (delete later)
+    path('test', views.test),
+
     url(r'^register', views.RegisterViewSet),
     # re_path('video/?video_name<str:video_name>', views.video),
     url(r'^teachers/', views.teachersList.as_view()),
@@ -75,7 +78,6 @@ urlpatterns = [
     # timetable API
     url(r'^timetable', api.FacultyTimetableViewSet.as_view()),
 
-
     ##### VIDEO Section #####
 
     # lecture video API
@@ -84,6 +86,8 @@ urlpatterns = [
     # lecture video API (to retrieve a lecture)
     url(r'^get-lecture-video/$', api.GetLectureVideoViewSet.as_view()),
 
+    # lecture video API (to retrieve a lecture)
+    url(r'^get-lecture-video-for-home/$', api.GetLectureVideoViewSetForHome.as_view()),
 
     ##### ACTIVITIES API #####
 
@@ -112,6 +116,9 @@ urlpatterns = [
     url(r'^get-lecture-activity-individual-student-evaluation/$',
         api.GetLectureActivityIndividualStudentEvaluation.as_view()),
 
+    # lecture activity report generation
+    url(r'^lecture-activity-report-generation/$',
+        api.GenerateActivityReport.as_view()),
 
     ###### EMOTION Section #####
     # getting lecture emotion record availability
@@ -133,7 +140,6 @@ urlpatterns = [
     # lecture emotion detection for frames API (to retrieve detections for each frame in lecture video)
     url(r'^get-lecture-emotion-for-frame/$', api.GetLectureEmotionRecognitionsForFrames.as_view()),
 
-
     ###### POSE Section #####
     # lecture video API (for Pose estimation)
     url(r'^get-lecture-video-for-pose/$', api.GetLectureVideoForPose.as_view()),
@@ -147,6 +153,41 @@ urlpatterns = [
     # lecture video individual student process pose estimation API (for Pose estimation)
     url(r'^process-lecture-video-individual-pose-estimation', api.ProcessIndividualStudentPoseEstimation.as_view()),
 
+
+    ##### GAZE Section #####
+    # lecture video Gaze estimation
+    url(r'^get-lecture-video-gaze-estimation-availability/$', api.GetLectureGazeEstimationAvailaibility.as_view()),
+
+    # process a lecture Gaze estimation
+    url(r'^process-lecture-gaze-estimation/$', api.ProcessLectureGazeEstimation.as_view()),
+
+    # retrieve a Lecture Gaze estimation
+    url(r'^get-lecture-gaze-estimation/$', api.GetLectureGazeEstimationViewSet.as_view()),
+
+    # lecture gaze estimation for frames API (to retrieve detections for each frame in lecture video)
+    url(r'^get-lecture-gaze-estimation-for-frame/$', api.GetLectureGazeEstimationForFrames.as_view()),
+
+
+    #####===== DATA VISUALIZATION =====#####
+
+    ##### VIEW STUDENT BEHAVIOR SUMMARY SECTION #####
+
+    # retrieves student behavior summary for specified time period
+    url(r'^get-student-behavior-summary-for-period/$', api.GetStudentBehaviorSummaryForPeriod.as_view()),
+
+    # retrieves lecture video summary time landmarks
+    url(r'^get-lecture-video-summary-time-landmarks/$', api.GetLectureVideoSummaryTimeLandmarks.as_view()),
+
+    # retrieves lecture activity summary
+    url(r'^get-lecture-activity-summary/$', api.GetLectureActivitySummary.as_view()),
+
+    # retrieves lecture activity summary
+    url(r'^get-lecture-emotion-summary/$', api.GetLectureEmotionSummary.as_view()),
+
+    # retrieves lecture activity summary
+    url(r'^get-lecture-gaze-summary/$', api.GetLectureGazeSummary.as_view()),
+
+
     # routers
     # path('', include(router.urls)),
     path('api-auth/', include('rest_framework.urls', namespace='rest_framework'))

integrated_slpes/jinja2.py

+from django.templatetags.static import static
+from django.urls import reverse
+
+from jinja2 import Environment
+
+
+def environment(**options):
+    env = Environment(**options)
+    env.globals.update({
+        'static': static,
+        'url': reverse,
+    })
+    return env
\ No newline at end of file