Environment friendly Human Posture Estimation

Introduction

Inside the area of pc imaginative and prescient, Human Posture Estimation stands as a fascinating discipline with functions extending from elevated actuality and gaming to mechanical autonomy and healthcare. This text sheds gentle on the complexities of human posture estimation, its significance, basic advances, and placing functions.

Posture estimation, an intriguing discipline inside pc imaginative and prescient, contains recognizing key focuses on an individual’s physique to get it and analyze their pose. Our goal is to carry this innovation into the area of yoga, allowing us to consequently acknowledge and classify yoga postures from photos.

Studying Goal

• Acquire a deep understanding of human pose estimation rules and their significance in pc imaginative and prescient.
• Comprehend how human pose estimation know-how enhances yoga observe with customized steering and real-time suggestions.
• Develop sensible expertise in implementing human pose estimation algorithms for yoga functions utilizing Python and related libraries.

This text was revealed as part of the Information Science Blogathon.

Understanding Human Pose Estimation

Human Pose Estimation is a pc imaginative and prescient job that entails representing the orientation of an individual graphically. This method, leveraging model-based approaches, identifies and classifies poses of human physique components and joints in pictures or movies. The important thing lies in capturing a set of coordinates defining joints like wrists, shoulders, and knees, which collectively describe an individual’s pose.

Significance of Human Pose Estimation

The detection of individuals has developed with machine studying algorithms, enabling computer systems to know human physique language by pose detection and monitoring. This know-how has turn out to be commercially viable, impacting numerous industries equivalent to safety, enterprise intelligence, well being and security, and leisure. Notably, within the period of the coronavirus pandemic, real-time pose detection aids in implementing social distancing measures.

Distinction Between 2D and 3D Human Posture Estimation

Two main strategies exist are 2D Posture Estimation and 3D Posture Estimation. The earlier gauges physique joint areas in 2D house, whereas the final talked about modifications a 2D image right into a 3D protest by anticipating an additional Z-dimension. 3D pose estimation, although difficult, permits for correct spatial positioning in representations.

Kinds of Human Pose Estimation Fashions

Human Pose Estimation fashions fall into three essential varieties:

• Skeleton-based Mannequin: Represents the skeletal construction, used for each 3D and 2D pose estimation.
• Contour-based Mannequin: Focuses on 2D pose estimation, emphasizing the physique’s look and form.
• Quantity-based Mannequin: Employed for 3D pose estimation, makes use of 3D human physique fashions and poses.

Backside-Up vs. Prime-Down Strategies of Pose Estimation

Strategies for human pose estimation are broadly categorised into two approaches: bottom-up and top-down. Backside-up evaluates every physique joint individually, whereas top-down employs a physique detector first and determines joints inside found bounding containers.

Understanding the workings of human pose estimation entails delving into the fundamental construction, mannequin structure overview, and numerous approaches for pose estimation. The method encompasses absolute pose estimation, relative pose estimation, and their mixture.

A number of open-source libraries facilitate human pose estimation:

• OpenPose: A multi-person system supporting 2D and 3D pose estimation.
• PoseDetection: Constructed on TensorFlow.js, providing real-time pose estimation fashions.
• DensePose: Maps human pixels from 2D RGB pictures to a 3D surface-based mannequin.
• AlphaPose: An actual-time multi-person pose estimation library utilizing a top-down method.
• HRNet (Excessive-Decision Internet): Appropriate for high-accuracy key level heatmap prediction.

Enhanced Human Pose Estimation: A Easy and Environment friendly Method

Allow us to now start with easy human pose estimation code by following sure steps.

Step 1: Setting the Stage

To kick off our journey, we have to arrange our surroundings by putting in the mandatory libraries. OpenCV, NumPy, and MediaPipe are important for our undertaking. Execute the next command to put in them:

!pip set up opencv-python mediapipe

We’ve introduce MediaPipe on this article, an open-source framework developed by Google for constructing machine studying pipelines targeted on pc imaginative and prescient duties. MediaPipe simplifies the implementation of advanced visible functions, providing pre-trained fashions for human pose estimation that may be built-in with minimal effort. Its cross-platform functionality ensures constant efficiency on cell units, net functions, and desktops, whereas its design for real-time processing permits for fast video enter evaluation.

Step 2: Import Vital Library

import math
import cv2
import numpy as np
from time import time
import mediapipe as mp
import matplotlib.pyplot as plt
from IPython.show import HTML

•  `math`: Supplies mathematical features for calculations.
• `cv2`: OpenCV library for pc imaginative and prescient duties like picture manipulation and processing.
• `numpy as np`: NumPy library for numerical computing with assist for arrays and matrices.
• `time`: Module for working with time, used right here to measure execution time.
• `mediapipe as mp`: MediaPipe framework for constructing notion pipelines for numerous media varieties.
• `matplotlib.pyplot as plt`: Matplotlib library for creating plots and visualizations.
• `IPython.show import HTML`: IPython module for displaying HTML content material throughout the pocket book.

Step 3: Initialze MediaPipe Bundle

Arrange MediaPipe’s Pose and Drawing utilities for pose detection and visualization.

# Initializing mediapipe pose class.
mp_pose = mp.options.pose

# Establishing the Pose operate.
pose = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.3, model_complexity=2)

# Initializing mediapipe drawing class, helpful for annotation.
mp_drawing = mp.options.drawing_utils 

• These strains initialize the mandatory parts from the MediaPipe framework for performing pose estimation duties.
• mp_pose = mp.options.pose initializes the MediaPipe Pose class, enabling pose estimation performance.
• pose = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.3, model_complexity=2) units up the Pose operate with particular parameters, equivalent to static picture mode, minimal detection confidence, and mannequin complexity.
• mp_drawing = mp.options.drawing_utils initializes the MediaPipe drawing utilities class, which gives features for annotating pictures with pose landmarks and connections, facilitating visualization of pose estimation outcomes.

Step 4: Load and Show Picture

Use OpenCV to load a picture and Matplotlib to show it.

sample_img  = cv2.imread('/content material/istockphoto-664637378-612x612.jpg')
plt.determine(figsize = [10,10])
plt.title("sample_Image")
plt.axis('off')
plt.imshow(sample_img[:,:,::-1]);plt.present()

• This code phase hundreds a pattern picture from a specified file path utilizing the OpenCV library (cv2.imread()).
• It then makes use of Matplotlib to show the loaded picture in a determine with a specified measurement (plt.determine(figsize=[10, 10])), title (plt.title(“Pattern Picture”)), and with out axis ticks (plt.axis(‘off’)).
• The picture is lastly proven utilizing plt.imshow() operate, which takes care of displaying the picture within the specified determine. The [:, :, ::-1] indexing is used to transform the picture from BGR to RGB format, as Matplotlib expects RGB pictures for show.

Step5: Detect and Print Landmarks

Convert the picture to RGB and use MediaPipe to detect pose landmarks. Print the primary two detected landmarks (e.g., NOSE, LEFT_EYE_INNER).

Keypoint_Identification

keypoint_Landmark

# Carry out pose detection after changing the picture into RGB format.
outcomes = pose.course of(cv2.cvtColor(sample_img, cv2.COLOR_BGR2RGB))

# Test if any landmarks are discovered.
if outcomes.pose_landmarks:
    
    # Iterate two instances as we solely wish to show first two landmarks.
    for i in vary(2):
        
        # Show the discovered normalized landmarks.
        print(f'{mp_pose.PoseLandmark(i).title}:n{outcomes.pose_landmarks.landmark[mp_pose.PoseLandmark(i).value]}') 

• This code phase performs pose detection on the pattern picture after changing it into RGB format utilizing OpenCV’s cv2.cvtColor() operate.
• It then checks if any pose landmarks are discovered within the picture utilizing the outcomes.pose_landmarks attribute.
• If landmarks are discovered, it iterates over the primary two landmarks and prints their names and coordinates.
• The landmark title is obtained utilizing mp_pose.PoseLandmark(i).title, and the coordinates are accessed utilizing outcomes.pose_landmarks.landmark[mp_pose.PoseLandmark(i).value].

Output:

NOSE:
x: 0.7144814729690552
y: 0.3049055337905884
z: -0.1483774036169052
visibility: 0.9999918937683105
LEFT_EYE_INNER:
x: 0.7115224599838257
y: 0.2835153341293335
z: -0.13594578206539154
visibility: 0.9999727010726929

Step6: Draw Landmarks on Picture

Create a replica of the picture, draw detected landmarks utilizing MediaPipe utilities, and show it.

# Create a replica of the pattern picture to attract landmarks on.
img_copy = sample_img.copy()

# Test if any landmarks are discovered.
if outcomes.pose_landmarks:
    
    # Draw Pose landmarks on the pattern picture.
    mp_drawing.draw_landmarks(picture=img_copy, landmark_list=outcomes.pose_landmarks, connections=mp_pose.POSE_CONNECTIONS)
       
    # Specify a measurement of the determine.
    fig = plt.determine(figsize = [10, 10])

    # Show the output picture with the landmarks drawn, additionally convert BGR to RGB for show. 
    plt.title("Output")
    plt.axis('off')
    plt.imshow(img_copy[:,:,::-1])
    plt.present()

• This code phase creates a replica of the pattern picture to protect the unique picture whereas drawing landmarks on a separate picture.
• It checks if any pose landmarks are discovered within the outcomes.
• If landmarks are discovered, it attracts the landmarks on the copied picture utilizing mp_drawing.draw_landmarks().
• The scale of the determine for displaying the output picture is specified utilizing plt.determine(figsize=[10, 10]).
• Lastly, it shows the output picture with landmarks drawn utilizing plt.imshow(). The [:,:,::-1] indexing is used to transform the picture from BGR to RGB format for correct show with Matplotlib.

Step 7: 3D Pose Visualization

Use MediaPipe’s plot_landmarks() to visualise the detected landmarks in 3D.

# Plot Pose landmarks in 3D.
mp_drawing.plot_landmarks(outcomes.pose_world_landmarks, mp_pose.POSE_CONNECTIONS)

• This code phase plots the pose landmarks in 3D house utilizing MediaPipe’s plot_landmarks() operate.
• It takes outcomes.pose_world_landmarks as enter, which represents the pose landmarks in world coordinates.
• mp_pose.POSE_CONNECTIONS specifies the connections between completely different landmarks, serving to to visualise the skeletal construction.

Step 8: Customized Pose Detection Operate

For customized pose detection we are going to use detectpose(). This operate performs pose detection, shows outcomes, and optionally returns landmarks.

def detectPose(picture, pose, show=True):
    '''
    This operate performs pose detection on a picture.
    Args:
        picture: The enter picture with a distinguished particular person whose pose landmarks must be detected.
        pose: The pose setup operate required to carry out the pose detection.
        show: A boolean worth that's if set to true the operate shows the unique enter picture, the resultant picture, 
                 and the pose landmarks in 3D plot and returns nothing.
    Returns:
        output_image: The enter picture with the detected pose landmarks drawn.
        landmarks: A listing of detected landmarks transformed into their unique scale.
    '''
    
    # Create a replica of the enter picture.
    output_image = picture.copy()
    
    # Convert the picture from BGR into RGB format.
    imageRGB = cv2.cvtColor(picture, cv2.COLOR_BGR2RGB)
    
    # Carry out the Pose Detection.
    outcomes = pose.course of(imageRGB)
    
    # Retrieve the peak and width of the enter picture.
    top, width, _ = picture.form
    
    # Initialize a listing to retailer the detected landmarks.
    landmarks = []
    
    # Test if any landmarks are detected.
    if outcomes.pose_landmarks:
    
        # Draw Pose landmarks on the output picture.
        mp_drawing.draw_landmarks(picture=output_image, landmark_list=outcomes.pose_landmarks,
                                  connections=mp_pose.POSE_CONNECTIONS)
        
        # Iterate over the detected landmarks.
        for landmark in outcomes.pose_landmarks.landmark:
            
            # Append the landmark into the record.
            landmarks.append((int(landmark.x * width), int(landmark.y * top),
                                  (landmark.z * width)))
    
    # Test if the unique enter picture and the resultant picture are specified to be displayed.
    if show:
    
        # Show the unique enter picture and the resultant picture.
        plt.determine(figsize=[22,22])
        plt.subplot(121);plt.imshow(picture[:,:,::-1]);plt.title("Authentic Picture");plt.axis('off');
        plt.subplot(122);plt.imshow(output_image[:,:,::-1]);plt.title("Output Picture");plt.axis('off');
        
        # Additionally Plot the Pose landmarks in 3D.
        mp_drawing.plot_landmarks(outcomes.pose_world_landmarks, mp_pose.POSE_CONNECTIONS)
        
    # In any other case
    else:
        
        # Return the output picture and the discovered landmarks.
        return output_image, landmarks

• This operate detectPose() performs pose detection on an enter picture utilizing MediaPipe’s Pose mannequin.
• It takes three parameters: picture (the enter picture), pose (the pose setup operate), and show (a boolean indicating whether or not to show the outcomes).
• It copies the enter picture to protect the unique and converts the picture from BGR to RGB format, as required by MediaPipe.
• It detects poses on the transformed picture and attracts the detected landmarks on the output picture utilizing mp_drawing.draw_landmarks().
• The operate additionally retrieves the peak and width of the enter picture and initializes an empty record to retailer the detected landmarks.
• If the show parameter is ready to True, it shows the unique enter picture, the output picture with landmarks drawn, and plots the landmarks in 3D house utilizing mp_drawing.plot_landmarks().
• If show is False, it returns the output picture with landmarks drawn and the detected landmarks record.

Step 9: Pattern Execution

Run pose detection on a brand new pattern picture utilizing the detectPose() operate.

# Learn one other pattern picture and carry out pose detection on it.
picture = cv2.imread('/content material/HD-wallpaper-yoga-training-gym-pose-woman-yoga-exercises.jpg')
detectPose(picture, pose, show=True)

• This code phase reads one other pattern picture from the desired file path.
• It then calls the detectPose() operate to carry out pose detection on the picture utilizing the beforehand initialized pose setup.
• Setting the show parameter to True directs the operate to point out the unique enter picture, the resultant picture with drawn landmarks, and the 3D plot of landmarks.

Step 10: Pose Classification (Optionally available)

The following step entails defining a operate to categorise poses like Warrior, Tree, and so on., primarily based on joint angles.

Warrior-Pose, T-Pose, Tree-Pose, Unknown

def classifyPose(landmarks, output_image, show=False):
    '''
    This operate classifies yoga poses relying upon the angles of assorted physique joints.
    Args:
        landmarks: A listing of detected landmarks of the particular person whose pose must be categorised.
        output_image: A picture of the particular person with the detected pose landmarks drawn.
        show: A boolean worth that's if set to true the operate shows the resultant picture with the pose label 
        written on it and returns nothing.
    Returns:
        output_image: The picture with the detected pose landmarks drawn and pose label written.
        label: The categorised pose label of the particular person within the output_image.

    '''
    
    # Initialize the label of the pose. It isn't identified at this stage.
    label="Unknown Pose"

    # Specify the colour (Pink) with which the label shall be written on the picture.
    shade = (0, 0, 255)
    
    # Calculate the required angles.
    #----------------------------------------------------------------------------------------------------------------
    
    # Get the angle between the left shoulder, elbow and wrist factors. 
    left_elbow_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value],
                                      landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value],
                                      landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value])
    
    # Get the angle between the appropriate shoulder, elbow and wrist factors. 
    right_elbow_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value],
                                       landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value],
                                       landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value])   
    
    # Get the angle between the left elbow, shoulder and hip factors. 
    left_shoulder_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value],
                                         landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value],
                                         landmarks[mp_pose.PoseLandmark.LEFT_HIP.value])

    # Get the angle between the appropriate hip, shoulder and elbow factors. 
    right_shoulder_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value],
                                          landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value],
                                          landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value])

    # Get the angle between the left hip, knee and ankle factors. 
    left_knee_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.LEFT_HIP.value],
                                     landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value],
                                     landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value])

    # Get the angle between the appropriate hip, knee and ankle factors 
    right_knee_angle = calculateAngle(landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value],
                                      landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value],
                                      landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value])
    
    #----------------------------------------------------------------------------------------------------------------
    
    # Test if it's the warrior II pose or the T pose.
    # As for each of them, each arms ought to be straight and shoulders ought to be on the particular angle.
    #----------------------------------------------------------------------------------------------------------------
    
    # Test if the each arms are straight.
    if left_elbow_angle > 165 and left_elbow_angle < 195 and right_elbow_angle > 165 and right_elbow_angle < 195:

        # Test if shoulders are on the required angle.
        if left_shoulder_angle > 80 and left_shoulder_angle < 110 and right_shoulder_angle > 80 and right_shoulder_angle < 110:

    # Test if it's the warrior II pose.
    #----------------------------------------------------------------------------------------------------------------

            # Test if one leg is straight.
            if left_knee_angle > 165 and left_knee_angle < 195 or right_knee_angle > 165 and right_knee_angle < 195:

                # Test if the opposite leg is bended on the required angle.
                if left_knee_angle > 90 and left_knee_angle < 120 or right_knee_angle > 90 and right_knee_angle < 120:

                    # Specify the label of the pose that's Warrior II pose.
                    label="Warrior II Pose" 
                        
    #----------------------------------------------------------------------------------------------------------------
    
    # Test if it's the T pose.
    #----------------------------------------------------------------------------------------------------------------
    
            # Test if each legs are straight
            if left_knee_angle > 160 and left_knee_angle < 195 and right_knee_angle > 160 and right_knee_angle < 195:

                # Specify the label of the pose that's tree pose.
                label="T Pose"

    #----------------------------------------------------------------------------------------------------------------
    
    # Test if it's the tree pose.
    #----------------------------------------------------------------------------------------------------------------
    
    # Test if one leg is straight
    if left_knee_angle > 165 and left_knee_angle < 195 or right_knee_angle > 165 and right_knee_angle < 195:

        # Test if the opposite leg is bended on the required angle.
        if left_knee_angle > 315 and left_knee_angle < 335 or right_knee_angle > 25 and right_knee_angle < 45:

            # Specify the label of the pose that's tree pose.
            label="Tree Pose"
                
    #----------------------------------------------------------------------------------------------------------------
    
    # Test if the pose is assessed efficiently
    if label != 'Unknown Pose':
        
        # Replace the colour (to inexperienced) with which the label shall be written on the picture.
        shade = (0,0,255)  
    
    # Write the label on the output picture. 
    cv2.putText(output_image, label, (10, 30),cv2.FONT_HERSHEY_PLAIN, 2, shade, 5)
    
    # Test if the resultant picture is specified to be displayed.
    if show:
    
        # Show the resultant picture.
        plt.determine(figsize=[10,10])
        plt.imshow(output_image[:,:,::-1]);plt.title("Output Picture");plt.axis('off');
        
    else:
        
        # Return the output picture and the categorised label.
        return output_image, label

# Learn a pattern picture and carry out pose classification on it.
picture = cv2.imread('/content material/amp-1575527028-- triangle pose.jpg')
output_image, landmarks = detectPose(picture, pose, show=False)
if landmarks:
    classifyPose(landmarks, output_image, show=True)

• This code phase reads a pattern picture from the desired file path.
• It then calls the detectPose() operate to carry out pose detection on the picture utilizing the beforehand initialized pose setup.
• If the show parameter is False, the operate skips displaying the outcomes.
• If the picture comprises detected landmarks, the operate calls classifyPose() to categorise the pose primarily based on these landmarks and show the end result.

# Learn a pattern picture and carry out pose classification on it.
picture = cv2.imread('/content material/warrior2.jpg')
output_image, landmarks = detectPose(picture, pose, show=False)
if landmarks:
    classifyPose(landmarks, output_image, show=True)

• This code phase reads a pattern picture from the desired file path.
• It then calls the detectPose() operate to carry out pose detection on the picture utilizing the beforehand initialized pose setup.
• The show parameter is ready to False, indicating that the operate mustn’t show the outcomes.
• If landmarks are detected within the picture, it calls the classifyPose() operate to categorise the pose primarily based on the detected landmarks and show the end result.

Functions of Human Pose Estimation

Human pose estimation finds functions in various domains:

Health and Wellness Trade

• Personalised Steering: Pose detection functions information customers by yoga periods, providing real-time suggestions on their pose alignment.
• Progress Monitoring: Programs monitor customers’ progress, suggesting modifications or developments tailor-made to particular person talent ranges.

Trade-Stage Functions

• Company Wellness Applications: Firms can combine yoga pose detection, enhancing worker well being by wellness packages and stress discount.

Healthcare

• Posture Correction: Pose detection aids in correcting posture throughout rehabilitation workout routines, making certain right motion execution.
• Distant Monitoring: Healthcare professionals remotely monitor sufferers’ yoga periods, providing digital help and adjusting routines as wanted.

Sports activities Coaching

• Flexibility and Power Coaching: Pose detection in sports activities coaching packages profit athletes requiring flexibility and power, boosting total efficiency.

Training

• Interactive Studying: Pose detection enhances the interactive and accessible studying of yoga for college students in instructional establishments.
• Talent Evaluation: Lecturers assess college students’ yoga expertise utilizing know-how, providing focused steering for enchancment.

Leisure and Gaming

• Immersive Experiences: VR or AR functions create immersive yoga experiences with digital instructors guiding customers by poses.
• Interactive Gaming: Pose detection in health video games makes train pleasant and motivating for customers.

Ergonomics in Trade

• Desk Yoga Periods: Integrating pose detection into office wellness packages affords quick yoga periods, enhancing posture and decreasing stress for workers.
• Ergonomic Assessments: Employers use pose detection to evaluate ergonomic features of workstations, selling higher well being amongst workers.

Person Advantages

• Appropriate Kind: Quick suggestions on the shape reduces the danger of accidents, making certain customers acquire most advantages from yoga practices.
• Comfort: Customers can observe yoga at their comfort, guided by digital instructors or functions, eliminating the necessity for bodily lessons.
• Motivation: Actual-time progress monitoring and suggestions inspire for customers to remain per their yoga routines.

Conclusion

The mixing of human pose detection with yoga poses transcends various sectors, revolutionizing wellness and health. From customized steering and progress monitoring within the health business to enhancing rehabilitation and bodily remedy in healthcare, this know-how affords a flexible vary of functions. In sports activities coaching, it contributes to athletes’ flexibility and power, whereas in schooling, it brings interactive and assessable yoga studying experiences.

The office advantages from desk yoga periods and ergonomic assessments, selling worker well-being. Customers, guided by digital instructors, get pleasure from right type suggestions, comfort, and motivation, fostering a more healthy and extra environment friendly method to yoga practices. This transformative mixture of antiquated practices with cutting-edge innovation clears the best way for an all-encompassing well-being insurgency.

Key Takeaways

• Human Posture Estimation, a discipline inside pc imaginative and prescient, contains recognizing key focuses on an individual’s physique to get it and analyze their pose.
• Human posture estimation has assorted functions, extending from wellness and wellness to healthcare, sports activities preparation, instruction, amusement, and dealing surroundings ergonomics.
• Consolidating posture discovery innovation into Yoga Hone affords purchasers customized path, real-time enter, superior following, consolation, and inspiration, driving them to maneuver ahead with well-being and more adept exercises.
• The mixing of human pose detection with yoga observe represents a big development in wellness know-how, paving the best way for a complete well-being revolution.

Regularly Requested Questions

The media proven on this article isn’t owned by Analytics Vidhya and is used on the Creator’s discretion.

Hiya there! I am Soumyadarshan Sprint, a passionate and enthusiastic particular person in relation to information science and machine studying. I am always exploring new subjects and methods on this discipline, all the time striving to broaden my data and expertise. The truth is, upskilling myself is not only a interest, however a lifestyle for me.