Posts tagged google
WEEK 12: The final straight
- 17 August 2024
Hello👋🏾 I’m Wachiou BOURAIMA, All good things must come to an end, and it’s with a mixture of satisfaction and nostalgia that I end this final week of my GSoC 2024 mission. It’s been an incredible journey, and I can’t wait to share the progress I’ve made in my final week.
WEEK 11: Resolving the Footer Issue and Addressing Sphinx Warnings
- 15 August 2024
Hello everyone,
welcome to the update for Week 11 of my Google Summer of Code (GSoC) 2024 journey. This week, I focused on finalizing the footer issue on the FURY website and tackling some Sphinx warnings related to attribute and property naming conflicts. Here’s a detailed look at what I accomplished and the challenges faced.
WEEK 10: Investigating Footer Deformation and Limited Progress on Warnings
- 15 August 2024
Welcome to the week 10 of my Google Summer of Code (GSoC) 2024 journey. This week, I focused on resolving an issue with the FURY website’s footer and made limited progress on fixing documentation warnings. Here’s a detailed overview of my activities and challenges.
WEEK 9: Fixing Sphinx Warnings and Investigating Web Footer Issues
- 13 August 2024
Hello everyone,
welcome to my Google Summer of Code (GSoC) 2024 journey! Week 9 was devoted to fixing Sphinx warnings caused by indentation errors in some docstrings of some examples in the auto_examples folder. I also started investigating why the footer of the FURY site distorts when you try to move the mouse over an element.
WEEK 8: Refining Lazy Loading Implementation and Simplifying Imports in FURY
- 12 August 2024
Hello everyone,
Welcome back to another update on my Google Summer of Code (GSoC) 2024 journey! This week, my mentor Serge Koudoro and I focused on refining the lazy loading feature and optimizing import statements within FURY’s examples modules.
WEEK 7: Fixing Sphinx Warnings in Blog Posts
- 06 August 2024
Hello everyone, Welcome back to another update on my GSoC 2024 journey. This week, my focus was primarily on addressing Sphinx warnings caused by typos in blog posts.
WEEK 6: Code reviews, relining and crush challenges
- 06 August 2024
Hello everyone, As my Google Summer of Code (GSoC) 2024 journey progresses, week6 has brought me a series of technical challenges and accomplishments. My main focus has been on code reviews, rebasing and commits squashing, with a few notable lessons learned along the way.
Week 6: UI Improvements and RAG performance evaluation
- 27 July 2024
Hi, I’m Robin and this is my blog about week 6.
WEEK 5: Implementing Lazy Loading in FURY with lazy_loader
- 06 July 2024
Welcome back to my Google Summer of Code (GSoC) 2024 journey! This week has been particularly exciting as I introduced a significant performance optimization feature: lazy loading. Here’s an overview of my progress and contributions.
Week 5: LLM Benchmarking & Architecture Modifications
- 01 July 2024
Hi, I’m Robin and this is my blog about week 5.
Week 4: Pipeline Improvements and Taking The Bot Public!
- 01 July 2024
Hi, I’m Robin and this is my blog about week 4.
WEEK 4: Updating Decorator, Exploring Lazy Loading, and Code Reviews
- 26 June 2024
Welcome again to my Google summer of code 2024 (GSoC’ 2024) journey 2024!.
This week, I focused on updating the warn_on_args_to_kwargs decorator, applying it across multiple modules, exploring lazy loading, and continuing with code reviews.
WEEK 3: Refinements and Further Enhancements
- 26 June 2024
Welcome to the fourth week of my Google Summer of Code (GSoC) 2024 journey!
This week I’ve been delving into the technical aspects of my project,
focusing on the consistent application of the warn_on_args_to_kwargs decorator and the initial implementation of lazy loading.
WEEK 2: Refinements and Further Enhancements
- 15 June 2024
Welcome back to my Google Summer of Code (GSoC) 2024 journey! This week has been dedicated to refining and improving the work done so far, with a particular focus on the keyword_only decorator.
Week 0: Community Bonding!
- 29 May 2024
Hi, I’m Robin and I’m a 2nd year CS undergrad from Vellore Institute of Technology, Chennai. During GSoC ‘24 my work will be to build an LLM chatbot which will help the community by answering their questions.
WEEK 0: The beginning of my journey in Google Summer of Code (GSoC) 2024
- 28 May 2024
Like any good start, this week I have the incredible opportunity to be welcomed into the community by the Core Team and my Mentor himself, during this session the Mentors welcomed us warmly and also congratulated us. They shared with us the rules respected during and after the GSoC program. This session made me feel comfortable and confident.
Week 12 : Experimenting with ODFs implementation
- 24 August 2023
There were different issues I needed to address for the ODF implementation. Even though I could not solve any of them completely, I did check each of the issues and made some progress. All the work in progress is being recorded in the following branch SH-for-ODF-impl, which when ready will be associated with a well-structured PR.
Week 12: Now That is (almost) a Wrap!
- 21 August 2023
Hello everyone, it’s time for another GSoC blogpost! Today, I am going to talk about some minor details I worked on last week on my project.
Week 12: FileDialog Quest Begins!
- 19 August 2023
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:
Week 11 : Adjusting ODF implementation and looking for solutions on issues found
- 16 August 2023
I continued to experiment with the ODF glyph implementation. Thanks to one of my mentors I figured out how to get the missing data corresponding to the SH coefficients \(a^l_m\) part of the function \(f(\theta, \phi)\) described here. I also was told to make sure to implement the correct SH basis since there are different definitions from the literature, I have to focus now in the one proposed by Descoteaux, described in this paper, which is labeled in DIPY as descoteaux07. To do this I had to make a small adjustment to the base implementation that I took as a reference, from which I obtained a first result using SH of order 4.
Week 11: A Refactor is Sometimes Needed
- 14 August 2023
Hello everyone, it’s time for another weekly blogpost! Today I am going to share some updates on the API refactoring I was working on with my mentors.
Week 11: Bye Bye SpinBox
- 12 August 2023
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.
Week 10 : Start of SH implementation experiments
- 08 August 2023
I started formally working on SH implementation. I was told to start first doing a simple program where I can modify in real-time the order \(l\) and degree \(m\), parameters corresponding to the Spherical Harmonics function \(Y^m_l(\theta,\phi)=\), based on previous work. That is just one part of the final ODF calculation, but here is what a first experimental script looks like.
Week 10: Its time for a Spin-Box!
- 05 August 2023
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.
Week 9: Tutorial done and polishing DTI uncertainty
- 31 July 2023
I addressed the comments from the tutorial of PR #818 related to how to display specific visualizations I wanted to make. I was suggested to use ShowManager to handle the zoom of the scene and also to use GridUI to display several actors at the same time for a visual quality comparison of the tensors. Below are some images generated for the tutorial that is almost done.
Week 9: It is Polishing Time!
- 31 July 2023
Hello everyone, it’s time for another weekly blogpost! Today, I am going to update you on my project’s latest changes.
Week 9: TextBlock2D is Finally Merged!
- 29 July 2023
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.
Week 8: Working on Ellipsoid Tutorial and exploring SH
- 25 July 2023
I mainly worked on the ellipsoid actor tutorial, as PR #791 is finally merged, so I was able to complete the tutorial by adding my implementation. In addition, during the weekly meeting, I received a good overview of the next issue I will be working on, which is using raymarching SDFs to display spherical harmonics (SH) for visualizing ODF glyphs for DTI. I got several ideas and resources which I can start experimenting with, such as Shadertoy and some base implementations from other FURY contributors. The main drawback when creating these objects is the amount of data required to create them, because depending on the SH order, the number of parameters that the function receives may vary, also unlike the tensors, which are represented only with a 3x3 matrix, here we could have more than 9 values associated with a single glyph, so passing the information from python to the shaders is not so trivial, besides requiring more resources as there is more information that needs to be processed. Some ideas I received were using matrixes instead of vectors, using templating, or even using texture to pass the data. I started to explore these options further, as well as to review in more detail the existing implementations of SH with raymarching, in order to understand them better.
Week 8: The Birth of a Versatile API
- 24 July 2023
Hello everyone, it’s time for another weekly blogpost! Today, I am going to tell you all about how is the KDE API development going, and to show you the potential this holds for the future!
Week 8: Another week with TextBlockUI
- 22 July 2023
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.
Week 7: Experimentation Done
- 17 July 2023
Hello everyone, welcome to another weekly blogpost! Let’s talk about the current status of my project (spoiler: it is beautiful).
Week 7: Adjustments on the Uncertainty Cones visualization
- 17 July 2023
I was told to refactor some parts of the uncertainty PR, since I was relying too much on DIPY functions which is not good because it makes maintenance more difficult as DIPY requires FURY for some functionalities. So I did some adjustments on the uncertainty function parameters and the corresponding tests, hopefully I managed to get with the most appropriate definition but I need to receive a first feedback to see how much I have to adjust the implementation. As I had to delete some relevant code lines inside the uncertainty calculation which consisted of preprocessing the data in order to define the necessary variables for the uncertainty formula, I was also suggested to make a tutorial of this new feature, so I can explain in detail how to obtain and adjust the necessary information, before passing it to the actor, and in general how and what is the purpose of this new function.
Week 7: Sowing the seeds for TreeUI
- 15 July 2023
This week, I focused on completing the TextBlock2D Bounding Box feature. However, 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.
Week 6: Things are Starting to Build Up
- 10 July 2023
Hello everyone, time for a other weekly blogpost! Today, I will show you my current progress on my project and latest activities.
Week 6: First draft of the Ellipsoid tutorial
- 10 July 2023
#PR 818: Tutorial on using ellipsoid actor to visualize tensor ellipsoids for DTI
Week 6: BoundingBox for TextBlock2D!
- 08 July 2023
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 PR #803.
Week 5: Preparing the data for the Ellipsoid tutorial
- 03 July 2023
During the weekly meeting with my mentors, there was a small discussion over the naming of the actor and its usage. On the one hand, although the purpose of the actor is to visualize diffusion tensor ellipsoids, the idea is that it can also be used for any other type of visualization that requires the use of ellipsoids, so in the end, we decided to keep the name ellipsoid as it is more generic. On the other hand, as there is already an actor made for the purpose of tensor visualization, namely tensor_slicer, it might not be obvious how and why one would use this new ellipsoid actor for this purpose, thus it was proposed to make a tutorial that can clarify this. The main difference between both actors relies on the quality and the amount of data that can be displayed, so the idea is to show the difference between both alternatives so the user can choose which one to use depending on their needs. To prepare the tutorial the first step was to add the data I will use on fury-data so I can then fetch and load the datasets I need to work on the tutorial.
Week 5: All Roads Lead to Rome
- 03 July 2023
Hello everyone, time for another weekly blogpost! Today, we will talk about taking different paths to reach your objective.
Week 5: Trying out PRs and Planning Ahead
- 01 July 2023
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:
Week 4: First draft of the DTI uncertainty visualization
- 27 June 2023
#PR 810: DTI uncertainty visualization
Week 4: Nothing is Ever Lost
- 26 June 2023
Welcome again to another weekly blogpost! Today, let’s talk about the importance of guidance throughout a project.
Week 4: Exam Preparations and Reviewing
- 24 June 2023
This week, amidst end-semester exams, I managed to accomplish a few notable tasks. Let’s dive into the highlights:
Week 3: Working on uncertainty and details of the first PR
- 19 June 2023
I made some adjustments to the ellipsoid actor definition, now called tensor. This was something discussed in the weekly meeting as the coming changes are related to this actor, the idea now is to have a tensor actor that allows choosing between displaying the tensor ellipsoids or the uncertainty cones (later on). I also worked on the uncertainty calculation, and the cone SDF for the visualization, so I plan to do a WIP PR next to start getting feedback on this new addition.
Week 3: Watch Your Expectations
- 19 June 2023
Hello everyone, it’s time for another weekly blogpost! This week, I will talk about how you should watch your expectations when working with any project.
Week 3: Resolving Combobox Icon Flaw and TextBox Justification
- 17 June 2023
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, PR #768 updated the set_visibility method of the UI class, ensuring that the icon change was applied correctly.
Week 2: The Importance of (good) Documentation
- 12 June 2023
Hello everybody, welcome to the week 2 of this project! I must admit I thought this would be simpler than it is currently being, but I forgot that when it comes to dealing with computer graphics’ applications, things never are. Below, some updates on what I have been up to for this past week.
Week 2: Making adjustments to the Ellipsoid Actor
- 12 June 2023
I made some minor adjustments to the last PR I submitted. Last time it was a draft since I was waiting for the weekly meeting to know how to proceed, but now it is ready. I am waiting for the review so I can make the necessary corrections and adjustments to merge this first PR soon.
Week 2: Tackling Text Justification and Icon Flaw Issues
- 11 June 2023
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.
Week 1: Ellipsoid actor implemented with SDF
- 05 June 2023
PR #791: Ellipsoid actor implemented with SDF
The FBO Saga - Week 1
- 05 June 2023
As mentioned in the last week’s blogpost, the goal for that week was to investigate VTK’s Framebuffer Object framework. An update on that is that indeed, VTK has one more low-level working FBO class that can be used inside FURY, however, they come with some issues that I will explain further below.
Week 1: Working with SpinBox and TextBox Enhancements
- 03 June 2023
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.
Week 0: Community Bounding Period
- 02 June 2023
Hello everyone, my name is Tania Castillo, I am close to finishing my degree in Computer Science and I think this is a great opportunity to put my learning and skills into practice. I will be working with FURY on improving the visualization of DTI tensors and HARDI ODFs glyphs by using well-known techniques in computer graphics.
The Beginning of Everything - Week 0
- 29 May 2023
Hello everyone, welcome to the beginning of my journey through GSoC 2023! I would like to thank everyone involved for the opportunity provided, it is an honour to be working side by side with professionals and so many experienced people from around the world.
Contribute to FURY via Google Summer of Code 2023
- 01 February 2023
FURY is participating in the Google Summer of Code 2023 under the umbrella of the Python Software Foundation.
Week 14: Keyframes animation is now a bit easier in FURY
- 28 September 2022
Separated the Timeline into a Timeline and an Animation. So, instead of having the Timeline do everything. It’s now more like doing animations in Blender and other 3D editing software where the timeline handles the playback of several animations #694.
Week 14 - Morphing is here!
- 28 September 2022
This week, I started with multiple actor support in skinning and managed to do it successfully. Here’s the preview using the BrainStem model.
Week 16 - Working with Rotations!
- 21 September 2022
Last week my mentors noticed that each DrawShape has its individual rotation_slider which increases redundancy and complexity in setting its visibility on and off. Instead, they suggested moving the rotation_slider to DrawPanel and keeping a common slider for all the shapes.
Week 13: Keyframes animation is now a bit easier in FURY
- 20 September 2022
Added the ability to have the ShowManager stored inside the Timeline. That way the user does not have to update and render the animations because it will be done internally.
Week 13 - Multi-bone skeletal animation support
- 15 September 2022
This week I fixed all the issues with skeletal animations, and we got to see our first render of skeletal animation :).
Week 15 - Highlighting DrawShapes
- 14 September 2022
This week I started with highlighting the shapes. As discussed earlier, I had two ways, but while implementing them, I found out both ways aren’t that good to continue with. The first way in which we thought of creating the scaled shapes in the background had an issue with the stacking. The border(blue rectangle) and the shape(grey rectangle) both seem to look like different shapes just grouped together as shown below.
Week 12 - Adding skeleton as actors and fix global transformation
- 08 September 2022
I started this week by fixing the segmentation fault for the skinning test. I could not fix this as of now.
Week 14 - Updating DrawPanel architecture
- 07 September 2022
This week I continued updating the DrawShape and DrawPanel.
Week 12: Adding new tutorials
- 07 September 2022
Restructured tutorials to be more readable and more focused on a specific topic.
Week 13 - Separating tests and fixing bugs
- 31 August 2022
This week I managed to fix the translation issue in PR #653. This was happening because of the calculation error while repositioning the shapes. Now it works as intended.
Week 11 - Multiple transformations support and adding tests
- 31 August 2022
As decided last week, I added support for multiple animations at the same timestamp. But this didn’t solve the animation problems of RiggedSimple model.
Week 11: Improving tutorials a little
- 30 August 2022
Fixed some issues in the hierarchical order animation support PR that we discussed during last week’s meeting (mostly naming issues).
Week 10 - Multi-node skinning support
- 25 August 2022
As we figured out that the SimpleSkin model is not animated as intended. This week I started working with that model;
I figured out that we need to apply the InverseBindMatrix to each timer callback. I had a hard time figuring out what inverse bind matrix actually does.
Here’s a good blog that answers that.
Week 12 - Fixing translating issues and updating tests
- 24 August 2022
I started with updating the tests for PR #623 as some of the tests weren’t covering all the aspects in the code.
Previously I was just creating the DrawShape and adding it to the scene but now I had to analyze the scene to see whether they were properly added or not.
Week 10: Supporting hierarchical animating
- 23 August 2022
Implemented hierarchical order support for animations using matrices in this PR.
Week 9 - First working skeletal animation prototype
- 17 August 2022
This week I had the first working example of skeletal animation ready. I was able to render the SimpleSkin model. Here’s a quick preview:
Week 11 - Creating a base for Freehand Drawing
- 17 August 2022
This week I tried to imitate the working of vtkImageTracer. Previously, I had created a small prototype for freehand drawing by adding points at the mouse position (which you can check out here). As mentioned, there were some drawback of this method. So to overcome these issues, I tried combining both methods. Considering points using the previous method and instead of adding points I tried creating lines between them which looks promising. Below you can see a demo.
Week 9: Animating primitives of the same actor
- 16 August 2022
Made two tutorials in this PR that show two approaches on how to animate primitives of the same FURY actor using the Timeline.
Week 8 - Fixing animation bugs
- 10 August 2022
This week I had to fix the transformation issue in glTF animation. As discussed in the last meeting, I disabled vertex transformation and applied the transformation after the actor was formed.
Week 10 - Understanding Codes and Playing with Animation
- 10 August 2022
I started working on the PR #645 created last week and tested a few more corner cases such as What happens if the maximum value is exceeded?? What if we give a value less than the minimum value range?? Most of these worked as intended.
Week 8: Back to the shader-based version of the Timeline
- 09 August 2022
First, I made some modifications to the main animation PR. Then as Filipi requested, I integrated the vertex shader that I was implementing a few weeks ago to work with the new improved version of the Timeline.
Week 9 - Grouping and Transforming Shapes
- 03 August 2022
I started this week by creating a quick PR #645 for the UI sliders. The sliders raised ZeroDivsionError when the min and max values were the same. To solve this, I handled the case where the value_range becomes zero and then manually set the handle position to zero.
Week 7: Billboard spheres and implementing interpolators using closures
- 01 August 2022
Restructured the keyframe animation interpolators using closures to be functions instead of classes #647. Now it is easier to implement new interpolators with the help of the functions existing in fury/animation/helpers.py. Also, now unit tests can be added for the latter functions.
Week 7 - Fixing bugs in animations
- 01 August 2022
This week I started with implementing scaling to the animation example.
Week 8 - Working on the polyline feature
- 27 July 2022
This week I started working on the polyline feature. After a lot of investigating and trying out different things, I found a way to call the dragging event manually without any prior click event. VTK actually captures the mouse movement using the MouseMoveEvent. This event is then modified by FURY to only be called after the click event. So I added a new callback to track the mouse movement and set the current canvas as an active prop because it is required to capture the drag event happening on it.
Week 6: Fixing the Timeline issues and equipping it with more features
- 25 July 2022
Improved the PlaybackPanel by adding speed control and the ability to loop the animation. Also, fixed the lagging issue of play and pause buttons and composed them into a single play/pause button.
Week 6 - Extracting the animation data
- 25 July 2022
This week, it was all about reading docs and extracting the animation data from buffers.
Week 7 - Working on Rotation PR and Trying Freehand Drawing
- 20 July 2022
I continued PR #623 and fixed the displacement of the shape from its original position when applying rotation. This was happening because most of the calculations resulted in float values, but as the pixel position were integers we had to explicitly convert these values into int. This conversion rounded off the values and as we call this function continuously, each time the round-off would happen, the shape would get displaced.
Week 5: Slerp implementation, documenting the Timeline, and adding unit tests
- 19 July 2022
Implemented Slerp (spherical linear interpolation) for rotation keyframes.
Week 5 - Creating PR for glTF exporter and fixing the loader
- 19 July 2022
Finalised the glTF export PR #630., adding tutorial, docs, and tests for all functions.
Week 6 - Supporting Rotation of the Shapes from the Center
- 13 July 2022
This week I started implementing a new feature to rotate the shapes from the center using RingSlider2D. I already had a rotate function that rotates the shape around its pivot vertex, so I updated it to support rotation from the center.
Week 4 - Finalizing glTF loader
- 12 July 2022
This week I had to travel back to my college since the summer vacations have ended. I had a coding session with Serge this week, we modified the exporter function and looked at some bugs I faced.
Week 4: Camera animation, interpolation in GLSL, and a single Timeline!
- 11 July 2022
Managed to implement a single Timeline using the Container class. So, instead of having two classes: Timeline and CompositeTimeline, now the Timeline can have multiple Timeline objects and controls them as in the code below.
Week 5 - Working on new features
- 06 July 2022
This week I tried to create a base for some upcoming new features. The first thing I updated was the Properties panel which I prototyped in Week 3. So previously, it was just displaying the properties but now after the update, it is able to modify the properties(such as color, position, and rotation) too. This was a quick change to test the callbacks.
Week 3: Redesigning the API, Implementing cubic Bezier Interpolator, and making progress on the GPU side!
- 04 July 2022
Redesigned the keyframe animations API to optimize having a lot of timelines by composing them into a parent Timeline called CompositeTimeline while maintaining playing individual timelines separately.
Week 3 - Fixing fetcher, adding tests and docs
- 04 July 2022
The first task for this week was to fix the glTF fetcher. We noticed that while running tests it reaches the API limit. So we decided to use a JSON file that contains the download URLs for all models.
Week 4 - Fixing the Clamping Issue
- 29 June 2022
Phew!! This week was a tedious week for me as parallelly my End-Sem exams also started. So as usual I started from where I left off last week, The Clamping Issue. As per the discussion with the mentors, we decided to use the AABB bounding box method to calculate the bounding box around the shape and then reposition or transform respectively, as now we had a fixed reference point. So after doing some calculations with the mouse positions and the bounding box points at last, I was able to clamp all the shapes successfully.
Week 2 - Improving Fetcher and Exporting glTF
- 29 June 2022
This week I worked primarily on the glTF fetcher and exporting scenes to a glTF file. I added tests and docstrings for all functions. I modified the fetch_gltf function to return the downloaded files. As we planned, the PR for the glTF fetcher was merged this week.
Week 2: Implementing non-linear and color interpolators
- 28 June 2022
Implemented some other general interpolators such as n-th degree spline and cubic spline interpolators. Also implemented HSV and LAB color interpolators.
Week 3 - Dealing with Problems
- 22 June 2022
This week was full of researching, playing around with things, prototyping ideas, etc. I started with last week’s clamping issue and managed to solve this issue while drawing shapes by clipping the mouse position according to canvas size, but it didn’t solve the problem with translating these shapes. I tried solving this using various approaches, but if one thing would get fixed, other things would raise a new error.
Week 1 - A Basic glTF Importer
- 20 June 2022
In the community bonding period I met with my mentor Serge Koudoro, along with other mentors in FURY and gsoc contributors. We discussed about my project and set up project timeline on github projects section. As my project (glTF Integration) and Keyframe animations were related so we discussed on that too.
Week 1: Implementing a basic Keyframe animation API
- 19 June 2022
During the community bonding period, we had weekly meetings in which I got to know the mentors better and bonded with Shivam and Praneeth, my fellow contributors. We talked about the importance of open-source contribution and discussed scientific visualization, how important it is and how it differs from game engines despite having some similarities. We also discussed how important the code review is and how to do a proper code review.
Week 2 - Improving DrawPanel UI
- 15 June 2022
This week I had to refactor and make my code cleaner along with some bug fixing, I started by adding tests and tutorials so that my changes could be tested by everyone. Then I separated the mode for selection so that it would be easy to select an individual element and work along with it. Once the selection mode was complete I started with the deletion of the elements.
Week 1 - Laying the Foundation of DrawPanel UI
- 08 June 2022
This week we started with our first technical meeting in which the weekly tasks were assigned. So I had to start with some background or canvas and draw a line using mouse clicks.
Pre-GSoC Journey
- 25 May 2022
Hello Guys!! I am Praneeth Shetty, currently pursuing Bachelor of Engineering in Computer Engineering, and here is my journey from where I started to the selection into GSoC22.
My Journey to GSoC 2022
- 24 May 2022
Hi! I’m Shivam, currently pursuing my bachelor’s (expected 2024) in Production and Industrial engineering from the Indian Institute of Technology (IIT) Roorkee.
My journey till getting accepted into GSoC22
- 23 May 2022
My name is Mohamed and I’m from Egypt. I am pursuing a Bachelor of Engineering in Computer Engineering and Automatic Control (expected: 2023), Tanta University, Egypt.
Contribute to FURY via Google Summer of Code 2022
- 01 February 2022
FURY is participating in the Google Summer of Code 2022 under the umbrella of the Python Software Foundation.
Google Summer of Code 2021 - Final Report - Bruno Messias
- 23 August 2021
We have changed some points of my project in the first meeting. Specifically, we focused the efforts into developing a streaming system using the WebRTC protocol that could be used in more generic scenarios than just the network visualization. In addition to that, we have opted to develop the network visualization for fury as a separated repository and package available here. The name Helios was selected for this new network visualization system based on the Fury rendering pipeline.
Tenth coding week!
- 16 August 2021
Welcome to the eleventh weekly check-in. I’ll be sharing my progress for the tenth week of coding.
Week#10: Accordion UI, Support for sprite sheet animations
- 09 August 2021
Below are the tasks that I worked on:
Ninth coding week!
- 09 August 2021
Welcome to the tenth weekly check-in. I’ll be sharing my progress for the ninth week of coding.
Week #09: Sphinx custom summary
- 02 August 2021
PR fury-gl/helios#22 : Helios Documentation Improvements. I’ve spent some time studying sphinx in order to discover how I could create a custom summary inside of a template module.
Eighth coding week!
- 02 August 2021
Welcome to the ninth weekly check-in. I’ll be sharing my progress for the eighth week of coding.
Weekly Check-In #8
- 26 July 2021
PR fury-gl/helios#18 (merged): Helios Documentation/
I’ve been working on Helios documentation. Now it’s available
online at https://fury-gl.github.io/helios-website 
Week #8: Code Cleanup, Finishing up open PRs, Continuing work on Tree2D
- 26 July 2021
This week I had to work on the open PRs specifically work on the bugs that were pointed out in last week’s meeting. Along side the bugs I had to continue the work on Tree2D UI element. Below is the detailed description of what I worked on this week:
Seventh week of coding!
- 26 July 2021
Welcome to the eighth weekly check-in. I’ll be sharing my progress for the seventh week of coding.
Weekly Check-In #7
- 19 July 2021
PR fury-gl/helios#16 (merged): Helios IPC network layout support for MacOs
Week #7: Finalizing the stalling PRs, finishing up Tree2D UI.
- 19 July 2021
This week I had limited tasks to do, mostly tasks related to existing PRs. Other than some minor fixes I had to implement some more things in Tree2D which included some minor UI fixes, some changes in tutorial, adding tests. Below is the detailed description of what I worked on this week:
Sixth week of coding!
- 19 July 2021
Welcome to the seventh weekly check-in. I’ll be sharing my progress for the sixth week of coding.
Week #6: Bug fixes, Working on Tree2D UI
- 12 July 2021
This week I had relatively few tasks and most of them were to fix some bugs/design flaws that were discussed in last week’s meeting. Other than that, I had to implement a few things in the Tree2D UI element that will be discussed in detail below. I also had to update some existing PRs in order to make things work well. Below are the list of things I worked on this week:
Network layout algorithms using IPC
- 12 July 2021
Hi all. In the past weeks, I’ve been focusing on developing Helios; the network visualization library for FURY. I improved the visual aspects of the network rendering as well as implemented the most relevant network layout methods.
Fifth week of coding!
- 12 July 2021
Welcome to the sixth weekly check-in. I’ll be sharing my progress for the fifth week of coding.
Weekly Check-In #5
- 05 July 2021
Before the 8c670c2 commit, for some versions of MacOs the streaming system was falling in a silent bug. I’ve spent a lot of time researching to found a cause for this. Fortunately, I could found the cause and the solution. This troublesome MacOs was falling in a silent bug because the SharedMemory Object was creating a memory resource with at least 4086 bytes independent if I’ve requested less than that. If we look into the MultiDimensionalBuffer Object (stream/tools.py) before the 8c670c2 commit we can see that Object has max_size parameter which needs to be updated if the SharedMemory was created with a “wrong” size.
Week #5: Rebasing all PRs w.r.t the UI restructuring, Tree2D, Bug Fixes
- 05 July 2021
The UI restructuring was finally merged this week. This means UI is now a submodule in itself and provides different UI elements based on their types which are, core, elements, containers and some helper methods/classes. So, this week my main tasks were to rebase and fix merge conflicts of my open PR’s. Other than that, I had to continue my work on Tree2D UI element and finish the remaining aspects of it. Also, I had to create an example demonstrating how to use the newly added UI element. Many use cases were discussed in the open meeting like, an image gallery which displays preview image on the title and when expanded reveals the full scale image. I am thinking of adding multiple examples for the Tree2D to brainstorm on its certain features. Also, I had this annoying bug in Panel2D which didn’t allow it to be resized from the bottom right corner. It was resizing from the top right corner. I had to address this bug as well. Below are the tasks in detail:
SOLID, monkey patching a python issue and network visualization through WebRTC
- 05 July 2021
These past two weeks I’ve spent most of my time in the Streaming System PR and the Network Layout PR . In this post I’ll focus on the most relevant things I’ve made for those PRs.
Fourth week of coding!
- 05 July 2021
Welcome to the fifth weekly check-in. I’ll be sharing my progress for the fourth week of coding.
Week #4: Adding Tree UI to the UI module
- 28 June 2021
This week I had very few tasks to do, almost all of them revolved around UI elements and adding stuff to the UI module. Earlier, it was pointed out that due to some design issues, importing certain modules into others caused circular imports which led to importing the specific modules inside a class/method which is not the best approach. This will be resolved as soon as the PR that fixes this issue is reviewed/merged in the codebase. In the meantime, all the PR’s related to UI will be on hold, which is why this I had few tasks this week. The tasks are described below in detail:
Third week of coding!
- 28 June 2021
Welcome to the fourth weekly check-in. I’ll be sharing my progress for the third week of coding.
Weekly Check-In #3
- 21 June 2021
PR fury-gl/fury#422 (merged): Integrated the 3d impostor spheres with the marker actor.
Week #3: Adapting GridLayout to work with UI
- 21 June 2021
This week my tasks revolved around layout and UI elements. The primary goal for this week was to adapt the GridLayout to work with different UI elements. Currently, GridLayout just supports vtk actors and not UI elements, my task was to modify the class to support UI elements. The other tasks for this week are described below in detail:
Second week of coding!
- 21 June 2021
Welcome to the third weekly check-in. I’ll be sharing my progress for the second week of coding.
First week of coding!
- 14 June 2021
Welcome to the second weekly check-in. I’ll be sharing my progress for the first week of coding.
Week #2: Feature additions in UI and IO modules
- 13 June 2021
This week I had to work on 3 PRs as well as some documentation. I really enjoyed this week’s work as the tasks were really interesting. The aim for these PRs were to actually add a couple of features in the UI as well as the IO module, which includes, adding support for border in Panel2D, adding support for network/URL images in load_image method in IO module, adding resizing Panel2D from bottom right corner, completing the document with layout solutions provided by Unity/Unreal engine. Below are the PRs that I worked on:
A Stadia-like system for data visualization
- 13 June 2021
Hi all! In this post I’ll talk about the PR #437.
Welcome to my GSoC Blog!
- 08 June 2021
Hi all! I’m Sajag Swami, a sophomore at Indian Institute of Technology, Roorkee. This summer, I will be working on adding a new functionality to FURY which shall enable users to visualise various types of proteins via different representations like Richardson aka Ribbon diagrams and molecular surface diagrams. As a part of my stretch goals, I’ll try to expand protein diagrams via other representations including:
Weekly Check-In #1
- 08 June 2021
Hi everyone! My name is Bruno Messias currently I’m a Ph.D student at USP/Brazil. In this summer I’ll develop new tools and features for FURY-GL. Specifically, I’ll focus into developing a system for collaborative visualization of large network layouts using FURY and VTK.
Week #1: Welcome to my weekly Blogs!
- 08 June 2021
Hi everyone! I am Antriksh Misri. I am a Pre-Final year student at MIT Pune. This summer, I will be working on Layout Management under FURY’s UI module as my primary goal. This includes addition of different classes under Layout Management to provide different layouts/arrangements in which the UI elements can be arranged. As my stretch goals, I will be working on a couple of UI components for FURY’s UI module. These 2D and 3D components will be sci-fi like as seen in the movie “Guardians of The Galaxy”. My objective for the stretch goals would be to develop these UI components with their respective test and tutorials such that it adds on to the UI module of FURY and doesn’t hinder existing functionalities/performance.
Google Summer of Code
- 09 March 2021
FURY is participating in the Google Summer of Code 2021 under the umbrella of the Python Software Foundation.
Part of the Journey is the end unless its Open Source!
- 23 August 2020
Hello and welcome to my final weekly check-in. Today officially marks the end of the coding period for GSoC 2020. I enjoyed every bit of it. This was a life-changing experience for me and now I observe and interpret everything from a different perspective altogether. I have grown into a better developer and a person since GSoC. I would like to thank all my mentors and especially Serge for his immense support and mentorship. I would love to contribute to fury even after GSoC is over but unfortunately my semester break is over so I won’t be as active as I was during the summer.
Wrecking Ball Simulation, Scrollbars Update, Physics Tutorials.
- 16 August 2020
Hello and welcome to my 12th weekly check-in. In this blog I will be discussing my progress with the wrecking ball simulation and my scrollbar separation work. Apart from this I have also finalized the physics simulation tutorials and have created a Pull Request to finally get it merged with the official repository. The official repository of my sub-org can be found here.
Chain Simulation, Scrollbar Refactor, Tutorial Update.
- 09 August 2020
Hello and welcome to my 11th weekly check-in. In this blog I will be discussing my progress with multiple topics related to physics and ui components. I was actively working on a couple of things, specifically Joint simulations in pyBullet and scrollbar UI component. I also took up the responsibility to complete an incomplete Pull Request which was pending for quite a while. The official repository of my sub-org can be found here.
Single Actor, Physics, Scrollbars.
- 02 August 2020
Hello and welcome to my 10th weekly check-in. Second evaluation ended this week and now we move on to our 3rd and final coding period. In today’s check-in I will be sharing my progress with the single actor physics simulation that I facing some issues with and I will also be discussing my future plans regarding UI components. The official repository of my sub-org, FURY can always be found here.
Tab UI, TabPanel2D, Tab UI Tutorial.
- 26 July 2020
Hello and welcome to my 9th weekly check-in. I will be sharing my progress with TabUI and its corresponding tutorial. The official repository of my sub-org, FURY can always be found here.
ComboBox2D, TextBlock2D, Clipping Overflow.
- 19 July 2020
Hello and welcome to my 8th weekly check-in. I will be sharing my progress with ComboBox2D and TextBlock2D UI components. After solving TextBlock2D sizing issue, I was finally able to complete the implementation of combo box. I also faced some problems while refactoring TextBlock2D. The official repository of my sub-org, FURY can always be found here.
Orientation, Sizing, Tab UI.
- 12 July 2020
Hello and welcome to my 7th weekly check-in. I will be sharing my progress with single actor physics simulation and TextBlock2D sizing issue which was pending for quite a while now. I will also be sharing my thoughts regarding the TAB UI component. The official repository of my sub-org, FURY can always be found here.
Translation, Reposition, Rotation.
- 05 July 2020
Hello and welcome to my 6th weekly check-in. The first evaluation period officially ends and I am very excited to move on to the second coding period. I will be sharing my progress with handling specific object’s properties among various multiple objects rendered by a single actor. I am mainly focusing on making it easier to translate, rotate and reposition a particular object, so that I can use them to render physics simulations more efficiently. The official repository of my sub-org, FURY can always be found here.
May the Force be with you!!
- 28 June 2020
Hello and welcome to my 5th weekly check-in, I will be sharing my progress of pyBullet Physics Engine Integration with FURY. The official repository of my sub-org, FURY can always be found here.
TextBlock2D Progress!!
- 21 June 2020
Hello and welcome to my 4th weekly check-in, I will be sharing my progress with TextBlock2D UI component. The official repository of my sub-org, FURY can always be found here.
ComboBox2D Progress!!
- 14 June 2020
Hello and welcome to my third weekly check-in, I will be sharing my progress with the project so far. In case you wondered, the sub-org that I am affiliated to is FURY. Make sure to check out the official repository here.
First week of coding!!
- 07 June 2020
Hello and welcome to my second weekly check-in, I will be sharing my progress for the first week of coding.
Welcome to my GSoC Blog!!!
- 30 May 2020
Hello Everyone, this is Soham Biswas currently in 2nd year pursuing my Bachelor’s(B.Tech) degree in Computer Science & Engineering from Institute of Engineering & Management, Kolkata. I have been selected for GSoC’ 20 at sub-org FURY under the umbrella organization of Python Software Foundation. I will be working on building sci-fi-like 2D and 3D interfaces and provide physics engine integration under project titled “Create new UI widgets & Physics Engine Integration”.
Weekly Check-in #1
- 30 May 2020
Hey everyone! This is my blog for this summer’s GSoC @ PSF I am Lenix Lobo, an undergraduate student from India, and this summer I will be working with project Fury under the umbrella of the Python Software foundation. I will be working on improving the current shader framework.
Google Summer of Code
- 05 January 2020
FURY is participating in the Google Summer of Code 2020 under the umbrella of the Python Software Foundation.