1. CFL stats & predictions

Podgorica Predators

The Predators have been performing exceptionally well this season, thanks to their robust defense and dynamic offense. Key player Marko Vukovic, known for his strategic plays and leadership on the field, is expected to be a game-changer.

Niksic Nomads

The Nomads have shown remarkable resilience, bouncing back from previous setbacks with improved tactics. Ivan Petrovic, their star quarterback, is anticipated to deliver a stellar performance.

Cetinje Champions

This team is renowned for its disciplined approach and cohesive teamwork. With Luka Jovanovic leading the charge as their captain, they are a formidable opponent.

Herceg Novi Heroes

The Heroes are known for their aggressive playstyle and quick adaptations during matches. Nikola Markovic's speed and agility make him a crucial asset.

Bar Blitzers

The Blitzers have been steadily climbing the ranks with their innovative strategies and youthful energy. Stefan Novakovic's exceptional passing skills are vital to their success.

Budva Battlers

The Battlers have a reputation for being tough competitors, often turning the tide with their relentless spirit. Their defense, led by Darko Simic, is particularly noteworthy.

Predators vs. Nomads: A Clash of Titans

This match is expected to be a tight contest with both teams eager to assert dominance. Betting experts suggest favoring the Predators due to their home advantage and strong defensive lineup.

• Pick: Podgorica Predators -1.5 points
• Odds: 1.85
• Prediction Reasoning: The Predators' home-field advantage and solid defense make them a safe bet.

Champions vs. Heroes: Tactical Showdown

This matchup will likely hinge on strategic plays and execution under pressure. The Champions' disciplined approach gives them a slight edge.

• Pick: Cetinje Champions -1 point
• Odds: 1.90
• Prediction Reasoning: Their cohesive teamwork and strong leadership from Jovanovic provide confidence in this pick.

Blitzers vs. Battlers: A Battle of Wits

This game promises to be an intense battle with both teams showcasing their strengths. The Blitzers' innovative strategies could give them the upper hand.

• Pick: Bar Blitzers +0.5 points
• Odds: 2.05
• Prediction Reasoning: The Blitzers' youthful energy and strategic plays make them a compelling choice.

Predators vs. Nomads: Analyzing the Dynamics

The Predators have been consistent throughout the season, maintaining a strong defensive record that has frustrated many opponents. Their ability to control the tempo of the game makes them a formidable force against the Nomads.

The Nomads, on the other hand, have shown significant improvement in their offensive strategies. Ivan Petrovic's leadership as quarterback has been pivotal in orchestrating successful plays. However, breaking through the Predators' defense will be a challenging task.

Tactical Insights:

• The Predators should focus on exploiting gaps in the Nomads' secondary defense.
• Nomads need to enhance their passing accuracy to counteract the Predators' defensive pressure.

Champions vs. Heroes: Strategic Edge

The Champions have built their reputation on discipline and strategic execution. Their ability to adapt to different game situations has been a key factor in their success.

The Heroes are known for their aggressive playstyle, often taking risks to gain an advantage. However, this approach can sometimes lead to costly mistakes against well-prepared teams like the Champions.

Tactical Insights:

• The Champions should leverage their defensive strength to disrupt the Heroes' offensive rhythm.
• The Heroes must capitalize on quick transitions to exploit any defensive lapses by the Champions.

Metric Analysis of Key Players

In football, player performance metrics provide valuable insights into individual contributions during matches. Below are detailed statistics for some of the key players expected to shine in tomorrow's games.

• Marko Vukovic (Podgorica Predators):

• Rushing Yards: Averaging over 85 yards per game, Vukovic's ability to break through defenses consistently makes him a critical asset for his team.

• Touchdowns: With six touchdowns this season, Vukovic's knack for finding the end zone under pressure highlights his clutch performance abilities.

• Passing Accuracy: At an impressive rate of over 68%, Vukovic’s precision as a quarterback enhances his team’s offensive efficiency significantly.

• Tackles Made: His versatility extends beyond offense; he has recorded multiple tackles in each game, showcasing his defensive prowess as well.

• Catch Percentage: His reliability as a receiver ensures that he successfully catches passes over 90% of attempts when targeted by teammates looking for scoring opportunities or crucial first downs.

Ivan Petrovic (Niksic Nomads): Key Offensive Contributor

• Rushing Attempts:Ivan Petrovic leads his team with an average of around ten rushing attempts per game; this persistent drive keeps opposing defenses guessing while maintaining momentum for his squad.

• Total Yards Gained:Petrovic’s all-around capabilities allow him to accumulate approximately one hundred yards per match through both rushing efforts combined with successful passing plays directed toward teammates who convert these opportunities into gains on field advancement or touchdowns scored against adversaries’ lines respectively throughout ongoing contests throughout this season so far!

• Tackles Avoided:A testament to his agility; he evades tackles at an impressive rate which often results in substantial gains or even big plays during high-pressure situations within games!

• Sacks Allowed:In terms of defensive pressure faced by him during games; Ivan maintains composure under duress allowing minimal sacks which further emphasizes his resilience as an athlete on CFL Montenegro fields!

• Fumble Recovery Rate:Ivan exhibits exceptional ball security evidenced by only one fumble lost all season thus far – indicative of his concentration levels under competitive circumstances!

Luka Jovanovic (Cetinje Champions): Defensive Leader

• Tackles Made:Luka Jovanovic consistently leads his team in tackles made per game; averaging over eight successful tackles which underscores his effectiveness at halting opposing players’ advances consistently throughout each contest!

• Sacks Recorded:Jovanovic’s ability not only disrupts offensive lines but also puts pressure directly on quarterbacks leading them towards making hurried decisions or turnovers – evidenced by three sacks this season alone!

• Catch Interceptions:In addition to stopping runs effectively; he showcases excellent aerial awareness intercepting passes meant for rival receivers thus thwarting potential scoring threats posed by adversaries’ offenses!

• Tackle Assists Recorded:Jovanovic’s instinctive positioning often results in additional defensive stops through coordinated efforts alongside teammates who capitalize on opportunities created due partly because of his initial disruption against offensive drives aimed at gaining territory against Cetinje champions’ side defensively speaking!

• Fumble Recovery Success Rate:Holding onto ball possession is critical – Jovanovic boasts impressive fumble recovery stats contributing significantly towards maintaining advantageous field positions during gameplay scenarios across various matchups played within CFL Montenegro league structures!

Nikola Markovic (Herceg Novi Heroes): Speed Demon

• Average Yards per Carry:Nikola Markovic excels at maximizing each carry opportunity; averaging nearly eight yards per attempt which often results in explosive plays that shift momentum dramatically within ongoing contests!

• Total Receptions:Beyond just running; Nikola contributes heavily via receiving duties securing passes successfully over thirty times throughout current campaign reflecting versatility across multiple facets of gameplay!stefan-georgescu/Robotics<|file_sep|>/ComputerVision/Assignments/Assignment_01/README.md # Assignment #1 ## Task #1: Image Denoising ### Description In this task you will implement image denoising using wavelets. ### Specification You will implement image denoising using wavelets. ### Implementation Your implementation should use: * Python; * Numpy; * OpenCV; * PyWavelets; * Matplotlib. You will use your implementation on two images: * [Image_01](../Images/Image_01.png); * [Image_02](../Images/Image_02.png). The denoising function should have signature: python def denoise_image(img_path: str, wavelet: str = 'db4', level: int = None, method: str = 'visushrink', noise_sigma: float = None) -> np.ndarray: where: * `img_path` - path where image is located; * `wavelet` - type of wavelet (default `'db4'`); * `level` - level of decomposition (default `None`, i.e., it will be automatically computed); * `method` - thresholding method (default `'visushrink'`); * `noise_sigma` - standard deviation of noise (default `None`, i.e., it will be automatically computed). For each image you should denoise it using all combinations of: * wavelets `'haar', 'db1', 'db2', 'db4', 'sym8', 'coif5', 'bior1', 'bior2', 'rbio1'`; * levels `1`, `2`, `5`, `10`; * methods `'hard', 'soft', 'heursure', 'visushrink', 'minmax'`. You should report PSNR value between original image and denoised one. You should also visualize original image (without noise), noisy image, denoised images using different parameters. ### Submission Submit your implementation (.py file), report (.pdf file), visualizations (.png files). ## Task #2: Image Filtering ### Description In this task you will implement image filtering using wavelets. ### Specification You will implement image filtering using wavelets. ### Implementation Your implementation should use: * Python; * Numpy; * OpenCV; * PyWavelets; * Matplotlib. You will use your implementation on two images: * [Image_01](../Images/Image_01.png); * [Image_02](../Images/Image_02.png). The filtering function should have signature: python def filter_image(img_path: str, filter_type: str = None, wavelet: str = 'db4', level: int = None, noise_sigma: float = None) -> np.ndarray: where: * `img_path` - path where image is located; * `filter_type` - type of filter (`'lowpass'`, `'highpass'`, `'bandpass'`, `'bandstop'`); * `wavelet` - type of wavelet (default `'db4'`); * `level` - level of decomposition (default `None`, i.e., it will be automatically computed); * `noise_sigma` - standard deviation of noise (default `None`, i.e., it will be automatically computed). For each image you should filter it using all combinations of: * filters `'lowpass', 'highpass', 'bandpass', 'bandstop'`; * wavelets `'haar', 'db1', 'db2', 'db4', 'sym8', 'coif5', 'bior1', 'bior2', 'rbio1'`; * levels `1`, `2`, `5`, `10`. You should also visualize original image (without noise), noisy image, filtered images using different parameters. ### Submission Submit your implementation (.py file), visualizations (.png files). <|file_sep|># Assignment #6 ## Task #1: Particle Filter ### Description In this task you will implement particle filter algorithm. ### Specification You will implement particle filter algorithm. ### Implementation Your implementation should use: * Python; * Numpy. Your particle filter implementation should have signature: python def particle_filter(observations, initial_particles, process_model, measurement_model, process_noise_std, measurement_noise_std) -> list: where: - observations - list containing observations at each time step; - initial_particles - list containing initial particles; - process_model - process model function that takes particles as input argument; - measurement_model - measurement model function that takes particles as input argument; - process_noise_std - standard deviation of process noise; - measurement_noise_std - standard deviation of measurement noise. The particle filter algorithm consists of four steps that are repeated at each time step: 1) Sample particles according to process model; python particles = process_model(particles) where: - particles - list containing particles before sampling; 2) Calculate weights based on measurements; python weights = measurement_model(particles) where: - particles - list containing sampled particles; - weights - list containing weights after calculating based on measurements; 3) Resample particles based on weights; python particles = resample_particles(particles) where: - particles - list containing sampled particles before resampling; 4) Calculate estimated position based on weighted average; python estimated_position = weighted_average(particles) where: - particles - list containing resampled particles; - estimated_position - estimated position after calculating based on weighted average. The particle filter algorithm should return estimated positions at each time step. You should also visualize estimated positions at each time step. ### Submission Submit your implementation (.py file), visualizations (.png files). <|repo_name|>stefan-georgescu/Robotics<|file_sep|>/ComputerVision/Assignments/Assignment_06/README.md # Assignment #6 ## Task #1: Dense Optical Flow ### Description In this task you will implement dense optical flow algorithm. ### Specification You will implement dense optical flow algorithm. ### Implementation Your implementation should use: * Python; * OpenCV; * Matplotlib. Your dense optical flow algorithm implementation should have signature: python def dense_optical_flow(prev_frame, next_frame, method='farneback') -> np.ndarray: where: - prev_frame - previous frame; - next_frame - next frame; - method - method used ('farneback'); The dense optical flow algorithm consists of three steps: 1) Convert frames from BGR color space into grayscale color space; python prev_gray = cv.cvtColor(prev_frame,cv.COLOR_BGR2GRAY) next_gray = cv.cvtColor(next_frame,cv.COLOR_BGR2GRAY) where: - prev_gray - previous frame converted from BGR color space into grayscale color space; - next_gray - next frame converted from BGR color space into grayscale color space; 2) Calculate dense optical flow using Farneback method; python flow = cv.calcOpticalFlowFarneback(prev_gray,next_gray,None, pyr_scale=0.5,#pyramid scale levels=3,#number pyramid layers winsize=15,#average window size iterations=3,#iterations per pyramid layer poly_n=5,#size polynomial expansion poly_sigma=1.2,#standard deviation flags=0) where: - flow -