Articles on ganimtron_10's Blog

Google Summer of Code Final Work Product

praneethshetty10@gmail.com (ganimtron_10) — Fri, 25 Aug 2023 17:22:22 +0000

Google Summer of Code Final Work Product

Name: Praneeth Shetty
Organisation: Python Software Foundation
Sub-Organisation: FURY
Project: FURY - Update user interface widget + Explore new UI Framework

Proposed Objectives

SpinBoxUI
Scrollbar as Independent Element
FileDialog
TreeUI
AccordionUI
ColorPickerUI

Stretch Goals:

Exploring new UI Framework
Implementing Borders for UI elements

Objectives Completed

SpinBoxUI:

The SpinBoxUI element is essential for user interfaces as it allows users to pick a numeric value from a set range. While we had an active pull request (PR) to add this element, updates in the main code caused conflicts and required further changes for added features. At one point, we noticed that text alignment wasn't centered properly within the box due to a flaw. To fix this, we began a PR to adjust the alignment, but it turned into a larger refactoring of the TextBlock2D, a core component connected to various parts. This was a complex task that needed careful handling. After sorting out the TextBlock2D, we returned to the SpinBoxUI and made a few tweaks. Once we were confident with the changes, the PR was successfully merged after thorough review and testing.

Pull Requests:

SpinBoxUI (Merged) - https://github.com/fury-gl/fury/pull/499

TextBlock2D Refactoring:

This was a significant aspect of the GSoC period and occupied a substantial portion of the timeline. The process began when we observed misaligned text in the SpinBoxUI, as previously discussed. The root cause of the alignment issue was the mispositioning of the text actor concerning the background actor. The text actor's independent repositioning based on justification conflicted with the static position of the background actor, leading to the alignment problem.

To address this, the initial focus was on resolving the justification issue. However, as the work progressed, we recognized that solely adjusting justification would not suffice. The alignment was inherently linked to the UI's size, which was currently retrieved only when a valid scene was present. This approach lacked scalability and efficiency, as it constrained size retrieval to scene availability.

To overcome these challenges, we devised a solution involving the creation of a bounding box around the TextBlock2D. This bounding box would encapsulate the size information, enabling proper text alignment. This endeavor spanned several weeks of development, culminating in a finalized solution that underwent rigorous testing before being merged.

As a result of this refactoring effort, the TextBlock2D now offers three distinct modes:

Fully Static Background: This mode requires background setup during initialization.
Dynamic Background: The background dynamically scales based on the text content.
Auto Font Scale Mode: The font within the background box automatically scales to fill the available space.

An issue has been identified with TextBlock2D where its text actor aligns with the top boundary of the background actor, especially noticeable with letters like "g," "y," and "j". These letters extend beyond the baseline of standard alphabets, causing the text box to shift upwards.

However, resolving this matter is complex. Adjusting the text's position might lead to it touching the bottom boundary, especially in font scale mode, resulting in unexpected positioning and transformations. To address this, the plan is to defer discussions about this matter until after GSoC, allowing for thorough consideration and solutions.

For more detailed insights into the individual steps and nuances of this process, you can refer to the comprehensive weekly blog post provided below. It delves into the entire journey of this TextBlock2D refactoring effort.

Pull Requests:

Fixing Justification Issue - 1st Draft (Closed) - https://github.com/fury-gl/fury/pull/790
Adding BoundingBox and fixing Justification (Merged) - https://github.com/fury-gl/fury/pull/803
Adding getters and setter for properties (Merged) - https://github.com/fury-gl/fury/pull/830
Text Offset PR (Closed) - https://github.com/fury-gl/fury/pull/837

ScrollbarUI as Independent Element:

We initially planned to make the scrollbar independent based on PR #16. The main goal was to avoid redundancy by not rewriting the scrollbar code for each element that requires it, such as the FileMenu2D. However, upon further analysis, we realized that elements like the FileMenu2D and others utilize the Listbox2D, which already includes an integrated scrollbar. We also examined other UI libraries and found that they also have independent scrollbars but lack a proper use case. Typically, display containers like Listbox2D are directly used instead of utilizing an independent scrollbar.

Based on these findings, we have decided to close all related issues and pull requests for now. If the need arises in the future, we can revisit this topic.

Topic: - https://github.com/fury-gl/fury/discussions/816

Other Objectives

Reviewing & Merging:

In this phase, my focus was not on specific coding but rather on facilitating the completion of ongoing PRs. Here are two instances where I played a role:

CardUI PR:
I assisted with the CardUI PR by aiding in the rebase process and reviewing the changes. The CardUI is a simple UI element consisting of an image and a description, designed to function like a flash card. I worked closely with my mentor to ensure a smooth rebase and review process.
- CardUI (Merged) - https://github.com/fury-gl/fury/pull/398
ComboBox Issue:
There was an issue with the ComboBox2D functionality, where adding it to a TabUI caused all elements to open simultaneously, which shouldn't be the case. I tested various PRs addressing this problem and identified a suitable solution. I then helped the lead in reviewing the PR that fixed the issue, which was successfully merged.
- ComboBox Flaw (Merged) - https://github.com/fury-gl/fury/pull/768

Updating Broken Website Links:

I addressed an issue with malfunctioning links in the Scientific Section of the website. The problem emerged from alterations introduced in PR #769. These changes consolidated demos and examples into a unified "auto_examples" folder, and a toml file was utilized to retrieve this data and construct examples. However, this led to challenges with the paths employed in website generation. My responsibility was to rectify these links, ensuring they accurately direct users to the intended content.

Updating Broken Links (Merged) - https://github.com/fury-gl/fury/pull/820

Objectives in Progress

FileDialogUI:

An existing FileDialog PR by Soham (#294) was worked upon. The primary task was to rebase the PR to match the current UI structure, resolving compatibility concerns with the older base. In PR #832, we detailed issues encompassing resizing FileDialog and components, addressing text overflow, fixing ZeroDivisionError, and correcting ListBox2D item positioning. The PR is complete with comprehensive testing and documentation. Presently, it's undergoing review, and upon approval, it will be prepared for integration.

Soham's FileDialog (Closed) - https://github.com/fury-gl/fury/pull/294
FileDialogUI (Under Review) - https://github.com/fury-gl/fury/pull/832

TreeUI:

Continuing Antriksh's initial PR for TreeUI posed some challenges. Antriksh had set the foundation, and I picked up from there. The main issue was with the visibility of TreeUI due to updates in the set_visibility method of Panel2D. These updates affected how TreeUI was displayed, and after investigating the actors involved, it was clear that the visibility features had changed. This took some time to figure out, and I had a helpful pair programming session with my mentor, Serge, to narrow down the problem. Now, I've updated the code to address this issue. However, I'm still a bit cautious about potential future problems. The PR is now ready for review.

TreeUI (In Progress) - https://github.com/fury-gl/fury/pull/821

GSoC Weekly Blogs

My blog posts can be found at FURY website and Python GSoC blog.

Timeline

Date	Description	Blog Post Link
Week 0 (27-05-2023)	Community Bounding Period	FURY - Python
Week 1 (03-06-20223)	Working with SpinBox and TextBox Enhancements	FURY - Python
Week 2 (10-06-2023)	Tackling Text Justification and Icon Flaw Issues	FURY - Python
Week 3 (17-06-2023)	Resolving Combobox Icon Flaw and TextBox Justification	FURY - Python
Week 4 (24-06-2023)	Exam Preparations and Reviewing	FURY - Python
Week 5 (01-07-2023)	Trying out PRs and Planning Ahead	FURY - Python
Week 6 (08-07-2023)	BoundingBox for TextBlock2D!	FURY - Python
Week 7 (15-07-2023)	Sowing the seeds for TreeUI	FURY - Python
Week 8 (22-07-2023)	Another week with TextBlockUI	FURY - Python
Week 9 (29-07-2023)	TextBlock2D is Finally Merged!	FURY - Python
Week 10 (05-08-2023)	Completing the Initial Version of AccordionUI	FURY - Python
Week 11 (12-08-2023)	TreeUI Updates and Code Revisions	FURY - Python
Week 12 (19-08-2023)	Wrapping Things Up	FURY - Python

Week 12: FileDialog Quest Begins!

praneethshetty10@gmail.com (ganimtron_10) — Sun, 20 Aug 2023 16:13:23 +0000

What did you do this week?

During this week, I initiated my work on the FileDialog PR, which had been started by Soham. The initial version of the FileDialog can be found at #294. To start, I focused on rebasing the PR. Since this PR was based on an older version, there were some updates to the overall UI structure that needed to be addressed for compatibility. While handling this, I identified a set of issues that I documented in the current PR #832. These mainly revolved around:

1. Resizing FileDialog and realted components.

2. Rectifying the text overflow problem.

3. Dealing with a ZeroDivisionError.

4. Fixing the positioning of items in the ListBox2D.

I systematically approached each of these challenges:

Resizing FileMenu and Related Components: This was a fairly complex task since it involved intricate dependencies, such as the FileDialog relying on the FileMenu, which, in turn, was dependent on ListBox2D and Panel2D resizing. To make the process manageable, I decided to progress incrementally in a seperate PR a bit later.

Text Overflow Issue: The problem with text overflow was rooted in our previous approach, which involved executing these actions only when the TextBlock2D had a scene property. Although this approach suited the previous version of TextBlock2D, the recent refactoring led to the removal of this property. The scene was previously utilized to determine the text actor's size. However, we had new methodologies to calculate these sizes, which are detailed in #803.

Addressing ZeroDivisionError: The ZeroDivisionError emerged when the total number of values were same as the number of slots. The issue lay in the separation of these values for calculating the scrollbar's height parameter. Unfortunately, this calculation error occurred when this would return us zero while updating the scrollbar. To counter this, I implemented a conditional check to ascertain whether the value is zero or not.

Correcting ListBox2D Item Positioning: Another challenge I encountered related to the improper positioning of ListBox2D item's background. When a slot was not visible, its background was resized to zero, and visibility was set to off. Consequently, during the calculation of updated positions, the height was considered zero, leading to mispositioning. I resolved this by refraining from resizing and solely toggling visibility, achieving the desired result.

Did you get stuck anywhere?

Among the challenges I faced, one notable instance involved addressing the visibility issue in TreeUI. Despite my attempts at various solutions, none yielded the desired outcome. The TreeUI exhibited either full visibility or no visibility at all. In this situation, I sought guidance from my mentor to find a viable solution.

What is coming up next?

The FileDialog implementation is nearly finalized, and my plan is to work on any review, feedback or suggestions that might arise. Following this, I will shift my attention towards addressing the TreeUI.

Week 11: Bye Bye Spinbox

praneethshetty10@gmail.com (ganimtron_10) — Tue, 15 Aug 2023 13:41:51 +0000

What did you do this week?

Building upon the progress of the previous week, a major milestone was reached with the merging of PR #830. This PR added essential "getters" and "setters" for the new features of TextBlock, making it easier to handle changes. This, in turn, facilitated the integration of SpinBoxUI with the updated TextBlock.

However, while working on SpinBoxUI, a critical issue emerged. As SpinBoxUI allows users to input characters and symbols into an editable textbox, it posed a risk of program crashes due to invalid inputs. To counter this, I introduced a validation check to ensure that the input was a valid number. If valid, the input was converted; otherwise, it reverted to the previous value. After thorough testing and review, PR #499 was successfully merged.

Meanwhile, a concern with the textbox's behavior was identified when SpinBoxUI was scaled to a larger size. Specifically, the text occasionally touched the top or bottom boundary, creating an overflow appearance. Although initial solutions were attempted, the complexity of the issue required further consideration. This issue has been documented in more detail in Issue #838, where it is marked as a low-priority item.

Did you get stuck anywhere?

The challenge of the week centered around addressing the textbox's overflow behavior in SpinBoxUI.

What is coming up next?

Looking ahead, the focus remains on refining the FileDialog component, as the significant progress with TextBlock and SpinBoxUI prepares us to shift attention to other aspects of development.

Week 10: Its time for a Spin-Box!

praneethshetty10@gmail.com (ganimtron_10) — Mon, 07 Aug 2023 18:37:49 +0000

What did you do this week?

This week, my focus shifted to the SpinBoxUI after wrapping up work on TextBlock2D. SpinBoxUI is a component that allows users to select a value by spinning through a range. To ensure a smooth transition, I made adjustments in SpinBoxUI to align it with the recent updates in TextBlock2D. To make things even clearer and more user-friendly, I initiated a continuous code improvement process. I introduced setters and getters that enable easier customization of TextBlock2D's new features, such as auto_font_scale and dynamic_bbox. These tools simplify the process of adjusting these settings, and you can see the ongoing changes in pull request #830.

Simultaneously, I worked on improving the FileDialog component. Since the FileDialog PR was based on an older version, it required updates to match the recent developments in TextBlock2D. This involved restructuring the code and making sure that everything worked smoothly together. You can checkout the progress here at PR #832.

Did you get stuck anywhere?

Thankfully, this week was quite smooth sailing without any major roadblocks.

What is coming up next?

Looking ahead, my plan is to finalize the integration of the updated TextBlock and SpinBoxUI components. This entails making sure that everything works seamlessly together and is ready for the next stages of development.

Week 9: TextBlock2D is Finally Merged!

praneethshetty10@gmail.com (ganimtron_10) — Mon, 31 Jul 2023 14:16:09 +0000

What did you do this week?

Continuing from the previous week, it seemed like we were almost done with the TextBlock2D, but there remained a final task of addressing conflicting issues. Being a core part of the UI, TextBlock2D had a few compatibility problems with certain other UI elements.

The default behavior of TextBox2D now includes a dynamic bounding box, which scales automatically based on the contained text. Users can customize this option through a simple flag setting. However, this change affected some UI elements like ComboBox2d, which relied on the default textbox size. Consequently, I had to make updates to ensure compatibility. Additionally, the default initialization of the TextBlock2D was completely static, which led to the possibility of the text extending beyond the background and failing certain tests. To tackle this, I made adjustments to the overflow helper function in the test_elements.py file. After a few tweaks and issue resolutions, the PR was ready for review and was successfully merged after passing the review process.

Did you get stuck anywhere?

I encountered some peculiar test failures that were indirectly related to the TextBlock2D which at first glance didn't came up. Although after some debugging and a thorough line-by-line analysis, I managed to identify and resolve them.

What is coming up next?

My next priority will be completing the SpinBoxUI now that the TextBlock2D is fixed and successfully integrated.

Week 8: Another week with TextBlockUI

praneethshetty10@gmail.com (ganimtron_10) — Tue, 25 Jul 2023 15:19:10 +0000

What did you do this week?

This week, I delved deeper into the TextBlock2D Bounding Box PR to address the challenges with tests and offsetting issues. In a pair programming session with my mentor, we discovered that the offsetting background problem stemmed from the dynamic nature of the bounding box. The issue arose when the RingSlider2D component began with an initial text size larger than the current text, which changed as the value was adjusted between 0-100%. This resulted in problems with offsetting and shrinking the bounding box. To resolve this, we decided to make the dynamic bounding box an optional feature.

Now, the TextBlock2D component offers three main features:

Completely static background
Dynamic bounding box scaled according to the text
Font scaling based on the bounding box

After tweaking and testing, all the features work seamlessly.

Did you get stuck anywhere?

The pair programming session with my mentor proved to be immensely helpful, as It guided me through the whole week.

What is coming up next?

I will dedicate time to further enhancing the TreeUI. My focus will be on updating tree nodes and ensuring proper node positioning during movement.

Week 7: Sowing the seeds for TreeUI

praneethshetty10@gmail.com (ganimtron_10) — Mon, 17 Jul 2023 15:08:39 +0000

What did you do this week?

TextBlock2D Bounding Box was nearly complete but the tests were failing due to automatic background resizing based on content and improper text actor alignment during setup. I encountered difficulties while positioning the text, which caused the text to appear offset and led to test failures.

Text background greater than the actual maximum size:

Text offset from center:

Additionally, I reviewed PR #814 and noticed that after PR #769, all demos and examples were merged into a single folder, which affected the paths used in the Scientific Domain Section. To address this, I created PR #820 to redirect the links to the correct path.

As I faced issues with the TextBlock2D PR, I took the opportunity to rebase and continue working on the TreeUI PR since there were no updates from the author.

Did you get stuck anywhere?

While fixing the issues with the tests for the TextBlock2D bounding box, I encountered a weird behavior in text positioning when using the center alignment. The output varied depending on the sequence of repositioning.

What is coming up next?

I will continue working on the TreeUI and resolve the TextBlock2D error to ensure both PRs progress smoothly.

Week 6: BoundingBox for TextBlock2D!

praneethshetty10@gmail.com (ganimtron_10) — Mon, 10 Jul 2023 18:33:09 +0000

What did you do this week?

This week, I worked on improving the TextBlock2D component in the UI system. I started from scratch to address alignment and scaling issues. When resizing the TextBlock2D, the text alignment and justification with the background rectangle were inconsistent. To resolve this, I introduced a new "boundingbox" property that calculates the text bounding box based on its content. Additionally, I separated the scaling mode from the resizing action with the new "auto_font_scale" property, enabling automatic font scaling according to the bounding box. This will provide better alignment, justified text, and smoother font scaling for the TextBlock2D component. Try it out at #803.

As discussed last week, we also made a decision regarding the scrollbar. After exploring different use cases, we concluded that creating an independent scrollbar is not necessary at the moment. Therefore, we will close the related pull requests. You can find out more about it here.

Did you get stuck anywhere?

Implementing the bounding box feature took some extra time as I needed to carefully consider its impact on other UI elements that rely on the TextBlock2D component.

What is coming up next?

Next, I will focus on completing the TextBlock2D Bounding Box PR, which will also indirectly finalize the Spinbox PR.

Week 5: Testing out PRs and Planning Ahead

praneethshetty10@gmail.com (ganimtron_10) — Mon, 03 Jul 2023 05:20:55 +0000

What did you do this week?

Due to ongoing exams, my productivity was limited this week. However, I managed to find some time to explore and review a few PRs submitted by contributors:

1. Ellipsoid PR #791: This PR focuses on creating a new ellipsoid actor defined with SDF and raymarching techniques.

2. Website Improvement PR #812: This PR includes changes for the new compatibility section on the FURY home page.

Towards the end of the week, I had a meeting with my mentor. We discussed the current status of ongoing PRs and identified action points to focus on in the upcoming weeks. This discussion provided clarity on the challenges faced with certain PRs and issues.

Did you get stuck anywhere?

Fortunately, I didn't encounter any major roadblocks or challenges that hindered my progress this week.

What is coming up next?

With the action points provided by my mentor, I will be dedicating the next week to completing those tasks.

Week 4: Exam Preparations and Reviewing

praneethshetty10@gmail.com (ganimtron_10) — Sun, 25 Jun 2023 18:10:01 +0000

What did I do this week?

This week, amidst end-semester exams, I managed to accomplish a few notable tasks. Let's dive into the highlights:

1. Merging CardUI: The PR #398 introduced the CardUI to the UI system of FURY. After a successful review and test check, it was merged into the codebase

2. Revisiting PR #540: I restarted working on PR #540 as I wasn't satisfied with the previous approach when I checked it for rebasing. I took the opportunity to update the code and ensure that the unit tests passed successfully. Although there are a few issues remaining in the tests, I am determined to resolve them and move forward with the implementation. This PR aims to improve the usage of the numpy_to_vtk_image_data utility function.

3. Independent Scrollbar Consideration: We are currently evaluating the necessity of making the Scrollbar an independent element. While currently, it is primarily used by the ListBox2D, we are exploring various use cases to determine if there are other scenarios where the Scrollbar can be employed independently. This evaluation will help us make an informed decision about its future implementation.

Did I get stuck anywhere?

No, fortunately, I didn't encounter any major obstacles or challenges during my tasks this week.

What is coming up next?

Once the exams are over, I am eagerly looking forward to making a full comeback to development. My immediate plans include addressing the remaining issues in PR #540 and completing the pending tasks. I will also catch up on any missed discussions and sync up with the team to align our goals for the upcoming weeks.

Week 3: Resolving Combobox Icon Flaw and TextBox Justification

praneethshetty10@gmail.com (ganimtron_10) — Sun, 18 Jun 2023 19:49:26 +0000

What did you do this week?

This week, I tackled the ComboBox2D icon flaw, which was addressed using Pull Request (PR) #576. The problem arose when we added a ComboBox2D to the TabUI. The TabUI would propagate the set_visibility = true for all its child elements, causing the combobox to appear on the screen without the icon change. To fix this issue, #768 updated the set_visibility method of the UI class, ensuring that the icon change was applied correctly.

Next, I focused on the textbox justification. As discussed in our meeting, I added a new property called boundingbox to the TextBlock2D. However, I encountered a problem when resizing the TextBlock2D. The `vtkTextActor` property would switch from `SetTextScaleModeToNone` to `SetTextScaleModeToProp` , which would scale the font according to the position1 (lower left corner) and position2 (upper right corner) of the UI. This inconsistency in font scaling resulted in misaligned text actors. I spent some time investigating this issue, and you can find my progress in the ongoing PR #803.

Additionally, I started working on creating a Scrollbar component by inheriting the LineSlider2D. I made adjustments to the position and other attributes to make it function as a scrollbar. However, I encountered some confusion regarding how to separate the scrollbar component from other elements and determine what should be included in the scrollbar itself.

Did you get stuck anywhere?

I faced a challenge while working on the text justification. It took me several days to identify the root cause of the occasional malfunctioning of the TextBlock2D. Atlast, I found out the reason behind the issue.

What is coming up next?

Next week, I have several tasks lined up. Firstly, I will be working on the CardUI PR #398. Additionally, I plan to complete the segregation of the scrollbar component, ensuring its independence and clarity. Lastly, I will be working on issue #540, which involves updating the use of the `numpy_to_vtk_image_data` utility function.

Week 2: Tackling Text Justification and Icon Flaw Issues

praneethshetty10@gmail.com (ganimtron_10) — Sun, 11 Jun 2023 20:18:31 +0000

What did you do this week?

This week, I continued tweaking the text justification PR #790 and encountered a new issue when combining both justification and vertical_justification. The problem arose because the vertical_justification did not take into account the applied justification, resulting in unexpected behavior. I focused on resolving this issue by ensuring that both justifications work together correctly. Additionally, during the weekly meeting, we discussed the problem and decided to introduce new properties such as boundaries and padding to enhance the functionality of the text justification feature.

Furthermore, I started working on PR #576, which aimed to address the flaw in the icon of the combobox. While investigating this issue, I discovered related problems and PRs, including #562, #731, and #768. The main challenge was related to the propagation of the set_visibility feature of the UI, causing the combobox to automatically open its options. To overcome this issue, I requested the author of PR #768 to rebase their pull request as it can be a solution for the issue.

Did you get stuck anywhere?

A significant portion of my time was dedicated to resolving the text justification issue when both justification types were combined. It required careful analysis and adjustments to ensure the desired behavior.

What is coming up next?

For the upcoming week, I have the following plans:

1. Work on modifying the text justification implementation to address any remaining issues and ensure compatibility with other features.
2. Begin the implementation of the scrollbar class from scratch to provide a robust and customizable scrollbar element.
3. Focus on completing the resolution of the icon flaw issue by collaborating with the relevant stakeholders and ensuring the necessary modifications are made.

Week 1: Working with SpinBox and TextBox Enhancements

praneethshetty10@gmail.com (ganimtron_10) — Thu, 08 Jun 2023 04:24:27 +0000

What did you do this week?

This week, my focus was on reviewing pull requests (PRs) and issues related to the user interface (UI) of the project. I meticulously went through each PR and issue, identifying those specifically associated with UI improvements. To streamline the process, I categorized them accordingly under the UI category. One of the key tasks was PR #499, which involved the implementation of SpinBoxUI. After rebasing the PR, I identified an alignment issue with the textbox component.

To resolve this issue, I started by investigating the root cause. I discovered that the alignment was initially based on the position of the parent UI, which caused the text to extend beyond the boundaries of the textbox. To rectify this, I devised a solution where I calculated the background size of the textbox and adjusted the text's position accordingly. By aligning the text with the calculated size, I ensured a proper and visually appealing alignment within the textbox.

To provide a clear understanding of the improvement, I have prepared a comparison of the textbox alignment before and after the modifications:

Before:

After:

Did you get stuck anywhere?

Fortunately, I didn't encounter any significant challenges this week.

What is coming up next?

Looking ahead, here's what I have planned for the upcoming week:

Completing PR #790 - Fixing Textbox Alignment
Wrapping up PR #499 - SpinBoxUI
Initiating PR #576 - Icon Flaw in ComboBox

GSoC 2023: Community Bonding Period

praneethshetty10@gmail.com (ganimtron_10) — Fri, 02 Jun 2023 15:05:15 +0000

Hello All!

I'm thrilled to announce that I'll be participating in Google Summer of Code (GSoC) for yet another year. To catch a glimpse of my previous journey, check out my experiences here.

During the community bonding period, we had our first GSoC meet, where we got acquainted with the program's rules and regulations. It was an excellent opportunity to virtually meet my fellow contributors and discuss our upcoming projects. Excitement filled the air as we exchanged ideas and set goals for the summer ahead.

Stay tuned for updates on my GSoC project as I share my progress, challenges, and breakthroughs along the way. I'm grateful for the opportunity to be part of this remarkable community and can't wait to witness the incredible projects that will unfold during GSoC 2023.