GSoC Report : Week 5, 6

The last two weeks have been a little too hectic. I have been working on writing the source code for classes from Python side, and they are nearing the completion.

This is the week for midterm evaluations, and as per the timeline, I was supposed to completely finish the python part by now. Although most of the stuff is complete, I have one or two days work to be left to be done.
I have finished with Shape, and VisualizationFrame classes. Also yesterday I just finished writing complete code for Camera classes.
There were two instances for Camera, one is PerspectiveCamera, and other is Orthographic Camera.

The Camera class is inherited from VisualizationFrame class, which would make it inherit the generation of simulation data. This has very much utility for the fact that we can attach a camera to any moving object in our system, and hence we have  moving cameras, which is an aide for the effective visualizations.

Another approach we have been thinking upon is the possibility of applying multiple cameras to a system, which can effectively be tied upon different moving objects. and they can be switched by a keystroke in the browser.
It would be kinda cool to see an animation from one camera, and then we can switch it to a different camera, in between the animation, without any extra pain, with a keystroke.

Anyways the priority is to get the basic functionality up, and then we can add these and many other features, as time permits.

Another concept which requires a little brainstorming is the Lighting. I am thinking of letting user choose where and what type of lights they want in their system.

These lights can be added in Scene class. and most probably they can also be inherited from VisualizationFrame class, giving them also the capability of motion, rather than static lights.

GSoC Report Week 4

Week four is over, and it has been an exhaustive week. I had been working parallely on two instances of project, which are equally relevant.
One is to write a complete extended illustrative example, which involved simulating a three link conical pendulum.
The current work on this problem can be checked here:


The problem is a quick implementation of the whole project, and a very naive one. It has some dirty code, and some hacks, which would need addressing during the implementations in the actual project.

The example is in a stable state, and I have been able to produce static visualizations. With a small change in Javascripts. It can be readily converted to animations.
I have created some instances of classes, according API, with only basic functionality, which has helped in bringing the illustrative example(three link conical pendulum) to life.
The python part of the example is complete, as I have been able to create the JSON file containing the simulation data from the problem.
As far as javascript part is concerned, Only thing left is to animate the visualization by properly reading the simulation data from the JSON object and applying it to the static visualizations.
The simulation data is being stored in the form of a (4 by 4) transformation matrices, which are then mapped to a visualization frame.
the frame will be calling the animation matrices from the javascript side and render them.

There has been certain issues on converting the symbolic transformation matrices to the numpy, or numerical matrices. I tried using lambdify, but ran into some problems.It seems that lambdify doesnt work properly with the time dependent symbols, i.e it works fine on symbols like:
'a', but fails on 'a(t)'.

Right now for the example I am using SymPy's evalf method, with substitutions for the symbols.
But it is not considered as efficient as lambdify, so I need to figure out the way to resolve the problem.

The other part which I am working is to write the unittests for the project. It is getting a bit delayed,
and I am two or three days behind the stipulated timeline. I am hoping to cover it up in the coming two weeks, before the midterm evaluations.
The tests seems to be coming much easier, once I have done the three link pendulum example.
The example has helped me a lot in determining how different classes should be working, so I am a little more confident on the implementations.
It is also because I have already implemented the basic functionality of nearly all classes, I just need to flesh them out, provide some more functionality to them, and they would be ready to be merged into the  master.

In a nutshell, this week has been  a little exhaustive, but now I feel running towards my milestone at a much better pace.

Cheers

GSoC Report Week 3

So, week three has also came to an end.
Main considerations for this week were to write some unit tests, which would be determining the way main coding is to be done.
As per the timeline,  all tests for Python side, should be complete by the coming week, i.e. which has started from today.

As for now, I have almost completed tests for Shape class, and I have written some tests for VisualizationFrame. After that I would focus on tests for Scene class, which would act as a manager class, for holding and manipulating JSON data from the Python side, as well as be able to display output in IPython output cells, as well as fire up a server in case of Python interpreter.

Scene and VisualizationFrame are very important classes for this package. They make up the majority of the API for the visualization implementations.
Also there has been a little confusion on the extent of modularity the package would/should provide.

Hopefully in a few days things would be more clear, so that I would be able to write tests more exhaustively according to the same.

Anyways regarding general stuff, the summer period is amazing, and I am getting good responses from my mentor, and also huge support from the community people. So, it makes things easier to do, when we have so much people to help out there, which is also one of the perks of the open source environment.

Cheers

GSoC Report Week 2

So, week two has also ended.

I have found several ideas and new features to implement from various people in the community.
We have finished fleshing out the API, although a few things need to be fleshed out.

As recommended from my mentor, I would be doing test-driven development for the project.

We have discussed the base classes , and the coming two weeks would be dedicated to writing sole tests for the classes, related to python part of the project.
As a part of improvised timeline, we have decided to keep this month of July, for coding the python side of the project, and after midterm evaluations,. I would be working on the Javascripts.

The interaction between the Python and Javascripts would take place with the JSON objects, either written in the form of JSON Objects or as written to files.

This approach would help to provide required level of modularity to the project.
Another major approach to modularity is to make the visualization module(from python side) independent of the mechanics package, i.e. it need not know whether the visualization data comes from sympy.physics.mechanics, or from any other software which could provide the output in the form desired tby the module.
Although the focus is to make the project as mechanics friendly as possible, but still trying to maintain the modularity, and every major API decision is being taken with this point in view.

This week, I will focus on writing some tests, and commit them to the repo.

Cheers