radon | open source , cloud-native MySQL database | Database library

An option is to use a for loop

This would help:

My compliments on such an extensive report. Your issue lies probably in this weird setup you've got going on.

Apply the & to the boolean tests, before indexing:

Try this.

• avoid using the static constructor for this.
• create the start() method to get out of static context
• then create an array of all zeros.
• read in the values and convert as appropriate.
• invoke the constructor with the arguments. Those not supplied in the line will be zero.

The code that you have posted is a pretty good example of filtered backprojection (FBP) and I believe could be useful to people who wanted to learn the basis of FBP. One can use the function iradon(...) in MATLAB (see here) to perform FBP using a variety of filters. In your case of course, the point is to learn the basis of the central slice theorem and so finding a short cut is not the point. I have also learned a lot and refreshed my knowledge through answering to your question!

Now your code has been perfectly commented and describes the steps that need to be taken. There are a couple of subtle [programming] issues that need to be fixed so that the code works just fine.

First, your image representation in Fourier domain may end up having a missing array due to floor(diagDim/2) depending on the size of the sinogram. I would change this to round(diagDim/2) to have complete dataset in fimg. Be aware that this may lead to an error for certain sinogram sizes if not handled correctly. I would encourage you to visualize fimg to understand what that missing array is and why it matters.

Second issue is that your sinogram needs to be transposed to be consistent with your algorithm. Hence an addition of sino = sino'. Again, I do encourage you to try the code without this to see what happens! Note that zero padding must be happened along the views to avoid artifacts due to aliasing. I will demonstrate an example for this in this answer.

Third and most importantly, imContrib is a temporary holder for an array along fimg. Therefore, it must maintain the same size as fimg, so

Rotating a single line in a 2D discrete image is really hard. You always end up with a rough approximation, interpolation doesn't help much.

The process you intend to follow is (I've added the filtering):

• For each projection in the Radon transform:
  • apply the FFT
  • apply the wedge filter
  • write this as a row though the origin of a 2D complex image
  • rotate this image to match the orientation of the projection
  • accumulate the result in an output frequency-domain image by summation
• Apply the 2D IFFT to the frequency-domain image to obtain the reconstructed image

Because we know that the IFFT operation commutes with the summation, it is possible to move the IFFT operation into the loop:

• For each projection in the Radon transform:
  • apply the FFT
  • apply the wedge filter
  • write this as a row though the origin of a 2D complex image
  • rotate this image to match the orientation of the projection
  • Apply the 2D IFFT
  • accumulate the result in an output spatial-domain image by summation

Also the rotation and the IFFT operations commute, so the above is identical to:

• For each projection in the Radon transform:
  • apply the FFT
  • apply the wedge filter
  • write this as a row though the origin of a 2D complex image
  • Apply the 2D IFFT
  • rotate this image to match the orientation of the projection
  • accumulate the result in an output spatial-domain image by summation

In this latter case, we are rotating a spatial-domain image that is smooth; it is not a single line drawn in an otherwise empty image, it is a fully band-limited function that can be interpolated into properly. The rotation result is much better in this case.

This latter process is almost the same as what the back projection algorithm does. We can further realize that the 2D IFFT of an image with a single row of data through the origin (the rest of the image is all zero) is the same as taking a 1D IFFT, and replicating that across all rows of the image. This saves quite a bit of computation.

Here is some code. The first method would be (a few fixes from OP's code, but the output is still not recognizable!):

If you are using Radon as a flake8 plugin, you can append # noqa R701 to the line with the function definition.

If you are using Radon standalone, there is no mechanism to skip a function or code block based on comments or any other markup - so, it is not possible.

I made a plunker with a working solution: https://plnkr.co/edit/QyAglTqoVx8k5RhZbenV?p=preview

Yeah, it needs put NaamOfAtoom(AtoomNum) inside that berekenen() function to fill that Atoomnaam variable, and change the switch.

Basically, when you did that switch, the cases are numbers, but AtoomNum is a string (you can type letter also), so it didn't entered any case options. So was equivalent to 12 === '12' returning false. switch is strict comparing === instead of only ==.

Adding a parseInt(number) solved switch part.