Blog - Posts tagged Sunkit-image

Sunkit-Image: Final GSOC Report

2019-08-24T00:00:00+00:00

This project developed several image processing algorithms and manipulation routines for sunkit-image, an affiliated Python package of the Sunpy Project. The rigorous analysis of solar images is of paramount importance to the Heliophysics community as this can reveal more information on solar features and events, which in turn can affect the Earth. This project brought selected solar image processing algorithms under the umbrella of a new library.

GSOC 2019: Project Goals

There were four major goals as listed on the OpenAstronomy website.

These included: * Implement the Normalizing Radial Gradient Filter * Port the Multi-scale Gaussian Normalization * Implement the OCCULT-2 algorithm for coronal loop tracing * Implement Soft Morphological filtering of the solar images

Project Goals Completed

Implement the Normalizing Radial Gradient Filter Normalizing Radial Gradient Filter is an algorithm designed to enhance features off the solar limb in a solar image. It normalizes the radial gradient i.e., the sharp decrease in intensity values in images as the pixels increase in radial distance from the Sun’s centre which helps in visualizing the coronal structures. This has been completed and merged along with its sister algorithm the Fourier Normalizing Radial Gradient Filter. The code for this can be found on this PR.
Port the Multi-scale Gaussian Normalization Any solar image contains information distributed over a very wide range of spatial scales which can be mostly hidden due to the variation of intensity values in an image. Processing such an image to unveil that hidden information is therefore very important. Multi-scale Gaussian Normalisation effectively normalizes the pixel values locally at different scales by convolving with different widths of Gaussian kernels and can reduce noise locally revealing any hidden features. The algorithm was successfully implemented and the code has already been merged.
Implement the OCCULT-2 algorithm Oriented Coronal CUrved Loop Tracing (OCCULT) is an algorithm designed to automatically trace out coronal loops in an image. It traces out loops starting at the maximum flux position and then moving in a bidirectional fashion from that point. The code, documentation and examples are complete and can be found here, it is waiting for further reviews and will be merged shortly (< 2 weeks).
Implement the Soft Morphological filtering The soft morphological filter approach to removing cosmic ray hits in a solar image uses image morphology operators and genetic algorithms. However, a similar package called Astroscrappy that also removes cosmic ray hits was found. We found that the algorithm used by Astroscrappy had more citations as compared to the Soft Morphological filtering and in our tests, it produced good results on solar data. So it was decided that the Soft Morphological filtering will not be implemented and rather a detailed example on how to use Astroscrappy on solar data was written here.

Further Project Work

These tasks were not part of the main GSoC project goals but were worked upon during the GSoC project.

Fourier Linear Correlation Tracking An existing C library was wrapped using Cython to enable Python calls to a Fourier Linear Correlation Tracking (FLCT) C library along with the tests and documentation for the wrapper. This algorithm aims at finding out the 2D flow field between two images. This work is complete and under review. However, as the C code is licenced under GPL v2 and sunkit-image is under BSD, we are waiting on permissions from the original authors before this can be merged or if it needs to be spun into a separate library.
Fourier Normalizing Radial Gradient Filter This was implemented as a run-up to GSoC and the tests and example were written during the coding period. This was merged along with the Normalizing Radial Gradient Filter.
Noise Level Estimation There was a preexisting noise estimation class in sunkit-image and it was decided that this was to be converted into a series of functions. Most of this task had already taken care of in PR 22, however, the original author was unable to finish this work and so this was completed in a new pull request and was merged.

Part 7: The End Arrives

2019-08-19T00:00:00+00:00

It has now been twelve weeks since I began this journey and finally, the curtains on this arduous and breathtaking adventure have been begun to fall. This week it will be last week as an official Google Summer of Code and this will be my final post as a student. I can feel the nostalgia gripping me.

Well, this has been one of the most productive summers which helped me gain a lot of new skills and make new connections and I would really like to thank Google and Sunpy for giving me this opportunity. I would also like to thank my mentors Nabil and Jack for being the constant support which I needed throughout the length of the program.

This post mainly serves as a summary of all the progress which has been made in the Sunkit-Image project since the commencement of the summer of code. Speaking statistically, I had opened five pull requests adding four independent algorithms and image processing techniques along with a pull request solely dedicated to documentation. This included their documentation, testing, and examples how to use them which overall amounted to be about 3,000 lines of code written by me.

Coming to the algorithms which got introduced in Sunkit:

Normalizing Radial Gradient Filter

This particular algorithm is designed to enhance offlimb features in a solar image. Though this was already present in Sunkit, it had some flaws and without any proper documentation and examples to it. I rectified the code wherever it was needed along with adding proper documentation and example to it.

Fourier Normalizing Radial Gradient Filter

This is an advanced version of the Normalizing Radial Gradient Filter aimed at the same task. This was implemented from scratch as a precursor to my application for GSOC to sunpy. I completed it when the coding period began and both the NRGF and the FNRGF were pushed in a single PR here. This has already been merged.

Multiscale Gaussian Normalization

Next, I moved on to the Multiscale Gaussian Normalization which is an algorithm designed to enhance features on the solar surface. It was fully implemented along with documentation and examples which can be found here. This too has been merged.

Soft Morphological Transform

The implementation of this particular algorithm did not take place because we found an Astroscrappy module which actually does the exact same thing using a different approach. So instead of doing a repeated work we decided to move on to something more useful. But, nevertheless an example describing how to use Astroscrappy was written.

Oriented Coronal Loop Tracing (OCCULT)

This is the part of the programme which took the longest time to code and debug. It is an algorithm to automatically trace out coronal loops in an image. This PRis complete with tests and documentation and is under review presently.

Fourier Local Correlation Tracking

A python wrapper was created for the FLCT C code such that it becomes usable in Python. This particular algorithm finds the 2D velocity flow field between an image. This too took almost a month to be completed and is under review now. You can have a look at the code here.

This mostly sums up what has been done during the coding period and I feel the four major goals which had to be achieved for the successful completion of the programme have been achieved. I do hope that I will successfully clear the final evaluation.

Hope you all enjoyed reading the glimpses of my journey through GSOC. It was a very nice and fascinating experience. I will still try to contribute to sunkit after the program ends. I do hope I get a second chance to be a part of this adventure again.

Part 6: Reaching the Summit

2019-08-05T00:00:00+00:00

If I describe my journey through Google Summer of Code as an arduous mountain climbing adventure then finally I have reached a point from where the summitis within reach.

But as they say — > # “The last stretch is the most difficult!!”

The past few weeks have been such a delight — they involved everything from episodes of frustration to moments of great joy!! I really have to thank my mentors — Nabil and Jack, for the level of confidence they have shown in me.

If you have been following my previous posts then you are very well aware of the one thing about which I have been talking, i.e. the Fourier Local Correlation Tracking.This has been the longest part of my project and it took me almost a month to conclude it (though it is still not merged). So, the last time when I left you we were searching for a bug in the wrapper code. But to our amazement, we could not find anyone in the wrapper code rather it was lurking in the most unexpected of places.

The C code had some IDL I/O routines involved with it to read and write binary “dat” files. We were aware that the IDL and C codes will read the arrays differently owing to the order in which they store arrays. IDL is column-major and C and Python are row-major. We thought that it can be taken care of by transposing the arrays but it was found that this was not the solution because both the codes were reading different values from the binary files and this was really baffling!!

Later, we realized that this was actually due to the order of operations. IDL was reading the binary file in column-major, unlike C which produced different results. So to fix this I wrote a few more Python functions wrapping the C read codes and also providing an option by which arrays read by IDL can also be used. This finally completed our code for FLCT and only the documentation and examples were left, which were later added.

On a separate note, I passed the second evaluation but after reading the above, I presume you already got to know about it ;-)

The most exciting part of this journey still awaits and I hope with the team with which I have been working with we will surely reach the summit. I hope you enjoyed this and would surely join us next time to see the conclusion of this saga. Until then, ciao!!!

Part 5: The Second Evaluation Awaits

2019-07-21T00:00:00+00:00

The fifth part of the ongoing series of my blog posts on my experience in the Google Summer of Code. I am working with Sunpy on their solar image processing toolkit, Sunkit-image. As of now two months have already and it has been an enriching experience. The second evaluation is also just around the corner and I am very hopeful that I will be able to clear it.

In this post, I describe the last two weeks of my work which was essentially only one week of work as I was on a vacation for a week. I had already discussed with my mentors regarding taking a vacation and they were fine with it if I could compensate for the lost time.

Now coming to the details of the work in the past week. I had been working on writing a python wrapper for FLCT C code. Fourier Linear Correlation Tracking is an algorithm which finds the 2D flow field between two images taken within a close interval to each other. I had earlier written the wrapper for the subroutines of the FLCT main code. During this week, I fixed the original wrapper for the subroutines and also implemented the main FLCT file, which makes FLCT available in python.

There are few errors hidden in my code as of yet which are being diligently hunted. Hopefully, the code would soon be bug-free. I am also working on the testing and documentation of the sub-package simultaneously. The entire wrapping has been done using Cython where the numpy arrays have been converted to C-compatible types like pointers or pointer to pointers.

Overall this particular section of work was very interesting. It was the first time I had used Cython and power which it provides to use of C codes in plain Python is amazing. The knowledge of this opens up various avenues of optimization in other python functions.

Hope you enjoyed reading this. Stay tuned for further updates!!!

Part 4: Weeks after the first evaluation

2019-07-07T00:00:00+00:00

This is part 4 of the ongoing series of my blog posts describing my journey as a Google Summer Of Code student working with Sunpy to develop Sunkit-image, an image processing toolbox for solar images.

In this installment, I describe the work in the two weeks following the first evaluation on June 24. It has finally been a month since I started this adventurous journey of Google Summer of Code. This past month helped me learn a lot of new stuff, methodologies and techniques. It really has been a fascinating experience for me. And when the results of the first evaluation came out I was filled with joy and happiness that I made it through the first hurdle.

Now, coming back to the progress I made during the last two weeks. I mostly spent my weeks working on two problems :

Soft Morphological Transform

Soft Morphological Transform is a routine which aims to remove cosmic ray hits from solar images. As per our earlier plan, we would implement this algorithm from scratch if and only if the “astroscrappy.detect_cosmics” did not work for solar images. So our first course of action was to validate the performance of the astroscrappy module for solar data and to our delight, it worked perfectly for solar data.

Images depicting the working of astroscrappy module. The left one is the input image whereas the right one is the output after using that module.

Once the module was found to be working I wrote an example about showcasing how to use it which can be found here.

Wrapping the FLCT C code into Python

Fourier Linear Correlation Tracking is an algorithm which finds the 2D flow field between two images taken close to each other. The FLCT code is already written in C and is publicly available. But to make this accessible in python I am wrapping it using Cython. As of now, I have wrapped the subroutines required for the FLCT code and the wrapping of the main code is underway. Hope to finish this in a couple of days before I go on a short vacation.

I hope you enjoyed reading this. Stay tuned for further updates and happenings in the coming weeks.

Part 3: The Debugging

2019-06-22T00:00:00+00:00

This is part 3 of the ongoing series of my blog posts describing my journey as a Google Summer Of Code student working with Sunpy to develop Sunkit-image, an image processing toolbox for solar images.

This particular part describes the work that has been done from 10th June to date. This part of the project was especially tricky involving lots of debugging. But, first I would like to begin on a positive note. My both the initial pull requests — one on the Fourier Normalizing Radial Gradient Filter and the other on Multiscale Gaussian Normalization were finally merged. It was such a delightful moment when your code gets accepted, I am sure all the coders reading this understand how I feel!! You can have a look at my pull requests here —

Now coming to the tricky part of the affairs. I spent these two weeks almost entirely on implementing the Oriented Coronal CUrved Loop Tracing (OCCULT-2) algorithm, which is aimed at automatic tracing of coronal loops. The initial implementation of the algorithm was relatively easy but then the complications started to manifest themselves. The major issue was the paper describing the algorithm and the code written by the author in IDL had some differences. So figuring out why those changes were made was a very tiring job.

Those modifications were finally incorporated in the python code but still, my implementation is not performing the way it should. So it is clear that there are some bugs still present. So began the process of bug hunting. Being such a complex algorithm find those hidden bugs was a challenge. I had many of “Eureka” moments which later turned out to be false alarms. There were a few moments when I actually got frustrated and thought of moving to something else. But I stuck to it, hoping I will find it soon.

The hunt for the culprit is still on though. I was able to fix many other minor bugs in this entire endeavour but the mighty one is still elusive. I am still working on it and hope to locate it soon enough.

The left image is an image of the solar surface showing some very prominent loops. The right image shows the output of my code. My code is being able to trace the loops but the loops are not being traced continuously rather there are traced in parts having breaks in between them. This is the major bug in the code which I am unable to find out till now.

I am still on my schedule and have some more days to tackle this issue and I am confident that I can make it work.

Hope you enjoyed this. Join me again in the coming weeks to see what comes out of this algorithm and all the other cool things I would be working on.

Vatsalya Chaubey

Part 2: The Dive

2019-06-09T00:00:00+00:00

The Coding Period of the Google Summer of Code officially began on 27th May 2019 — for me, it was the day when the “Dive” into the realm of code began.

This post is the second post in the series of posts I am writing every two weeks to describe my journey as a student in Google Summer of Code Programme working for Sunpy for their solar image processing toolkit, Sunkit-Image.

Why do I call it a dive, you might wonder? Imagine a man on a boat in the middle of a lake, rowing it towards the far shore. He has just started his journey and was hoping he could make it to the other side without getting himself wet, more than that was necessary. This is was my condition at the starting of the coding period.

You will still ask where is the dive then. Rest assured I am coming to it. The man is not alone on the boat as you might think. There are two more people on it. Both of them are excellent swimmers and want that man to learn to swim.

One cannot learn to swim without ever entering into the water.

This is the dive.They encourage the man to go into the water at the same time supporting him, saving him from drowning. Now I hope you understand where I am taking this.

The man on the boat is I, the two other people on the boat are my GSOC mentors — Jack and Nabil, the water is the complexities of the algorithms and the lake itself is the Google Summer of Code.

The first two weeks have been just like the way as I have described above — filled with “first-time” moments which were a little intimidating once, but with the help of everyone — my mentors, the Sunpy community everything is going on smoothly.

Now coming to what has been done in these two weeks —

Implemented the Multi-scale Gaussian Normalization

Multi-scale Gaussian Normalization (MGN) is an algorithm to enhance the images of solar surface and limb. This is a complex algorithm. During these two weeks, I wrote the algorithm along with the tests and examples for it.

An input image to the MGN algorithm

The output of MGN for the above image

Completed the Fourier Normalizing Radial Gradient Filter

I have written the code for this algorithm before GSOC officially began but there was still a lot to do. During the past weeks, I wrote more tests and examples, fixed the documentation. Along with this I also worked on the Normalizing Radial Gradient Filter adding tests, examples and documentation fixes.

An input image

The output of the NRGF filter

The output of the FNRGF filter

Implemented the OCCULT-2 algorithm

Oriented Coronal CUrved Loop Tracing (OCCULT) is an algorithm to automatically trace out the loops on the solar surface and the corona. I have just written the code as of now without any testing. I cannot provide any output image because the code has not been validated and checked. This is one of the trickiest algorithms and it took me almost a week to understand it fully but I am confident that it will take some more time before it is completed.

The work to be done in the coming weeks —

Make both the pull requests on MGN and FNRGF ready to be merged.
Work on the OCCULT-2 code, perform extensive testing on the code and make sure that everything is working fine.

I hope you enjoyed reading it. Stay tuned for more exciting stories.

Vatsalya Chaubey

Part 1: The Community Bonding Period

2019-05-26T00:00:00+00:00

In this series of posts, I describe my journey as a Google Summer of Code student. These posts would mostly include my work during the weeks and the experience I gained from it. Such posts would come up every two weeks from now so stay tuned.

The official coding period of Google Summer of Code is preceded by almost a month-long “Community Bonding Period.”During this period a student is expected to interact with the community and understand what is expected of him/her during the summer. It is a very crucial period, during which plan for the entire summer is laid out.

I am working with the SunPy organization on their sunkit-image project which is an image processing library for solar images. The sunpy community is great, made up of an awesome bunch of people. Everyone is working hard and just by observing them I learned a lot.

SunPy Logo

I had some interactions with them before being selected for the program but after the results came out they have increased and will go on increasing further. The first piece of information which I received after being selected was from Open Astronomy which the umbrella organization for sunpy. The mail had all the guidelines which needed to be followed throughout the summer.

I also contacted my mentors, Nabil Frejiand Jack Irelandto discuss how things should proceed and we decided to stick to our earlier timeline. Though I have been unable to talk to them directly over a video call due to some unavoidable circumstances, I will soon make up for it as our weekly video calls will begin soon as the coding period starts.

During the coding period, I mainly focused on completing the tests for a function which I had previously written but it proved quite challenging. I wrote a few completely new tests and for the others, I did some modifications (adding a radial profile to the test data). First of all, I had never done unit testing before so writing tests and making them run was something I found tricky. I still have not figured it out completely but I am still working on it. I learned about tox, for unit testing in python and how continuous integration works. One major mistake which I had committed earlier and because of which my code failed on continuous integration was not keeping up my local sunpy in sync with the sunpy master. This problem never came to my notice and it was only after Nabil pointed it out that I realized it. This made me understand how interconnected sunpy is with sunkit-image, which I had failed to grasp upon previously.

Thankfully, all the above fiasco occurred in the bonding period which helped me realize my mistakes. I learnt how important is to be working on the latest development version and the power of unit testing and continuous integration. It taught me that no code should be pushed before thoroughly testing it and so making good tests is extremely important.

I look forward to the coding period where I can put to use whatever I learned during the bonding period, it really has been an eye-opener. I hope that I can contribute to sunkit-image and the final results of this summer would be fruitful.

Vatsalya Chaubey

The Road To Google Summer Of Code

2019-05-18T00:00:00+00:00

We have been taught from our childhoods that nothing can be earned without toiling hard, to achieve something we need to sacrifice something. The same mantra applies to Google Summer of Code or as we fondly know it, GSOC.

I am a second-year student of the Indian Institute of Technology, Bhubaneswar and am selected in the Summer of Code project on Developing Sunkit Image, a solar image processing library in Python. This project is hosted by Sunpy, under Open Astronomy. This blog post is written to serve as a guide to future applicants, who find themselves overwhelmed by GSOC. Most of us (engineering students) in India have heard about Google’s flagship programme for college students, the Summer Of Code. I too was a part of the same herd, having ambitions to be a part of the programme but with no proper plans and knowledge.

Getting into it requires proper planning and execution. There are a few major steps involved —

Selection of the project
Interactions with the community
Completing the stipulated prerequisite tasks
Drafting a good proposal
Getting feedback on the proposal from the members of the organization
Rewriting it!! (Very important)
Finally, hoping that luck favours you.

Selecting the project

Choosing the project which is right for you is very important. Always choose something that intrigues you rather than doing something just because others are doing it. I chose sunkit image because it combined both my interest in image processing and my love for astronomy. But finding a particular project in the vast ocean of projects is a tedious task.

I started exploring the organizations even before they were officially announced. I looked at the organizations who have been a part of GSOC for the past years as they were more likely to be present the next year too. After much digging, I found sunkit-image in Sunpy.

Sunpy Logo

Tip: If you like a particular organization explore their GSOC webpages way before the projects are officially announced. This is because most organizations list their projects on their website before sending it to Google.

Initiate Contact

Contact the organization and the mentors as early as possible. Be formal in your conversations and follow every rules or guideline for interaction as listed on the website. Don’t be timid and shy and ask them questions if you stuck somewhere.

Prerequisite Tasks

It is very important that you fulfil all the criteria of selection for an organization. Most of the organizations ask you to open a pull request to judge your coding skills, make sure that you write that PR well enough. It is your only chance to impress your mentors with your work. Get feedback on your work and refine it to suit the needs of the problem.

Proposal

The proposal is the thing which highlights what you have done till now and what you want to do ahead. Take time in writing it. Follow the organization’s guideline while writing a proposal, include everything that you have done till now, include small snippets of code which you have written preferably as Github gists. And most importantly come up with a suitable timeline for the summer — what work will be completed when.

Secondly, get feedback on your proposal from your seniors, friends and the mentors of the particular project. Most of the mentors will be very helpful and provide you with suggestions and improvements for your proposal. Make sure to add those changes in your proposal.

After all this work sit back and wait for the results. You have done your part and let destiny unfold. While waiting for the results don’t just stop, keep in touch with the organizations, solving some minor issues.

PS: This is my first blog post on Medium. Hope to write a few more. If you have any suggestions or remarks feel free to point it out.