As an Addition:

on the left side of the Image I made a schematic drawing where the blue or red dots represents the center pixel in their 3x3 pixel neighborhood. blue means it's no junction pixel, red means it is. then the rows show the number of neighbor pixels and the columns show how many of the 8-connected neighbors are edge pixels. The right side shows the according pixel representation of the skeleton.

I've used the 3x3 mean filter approach in the past - I think it's a very good way, depending on your skeletonization.  After applying the filter you need to use the original to mask it (maybe with imageCalculator and AND... or MIN), to get rid of non-zero filtered pixel values that were zero in the skeleton image.

To make your life marginally easier, you might want to fix the maximum of the skeletonized binary image to 9 (Process -> Math -> Max...), then the output after your mean filter should directly provide the number of 'on' neighbours for each pixel (including the pixel itself in the count).

Depending on the connectivity of your skeleton, a simple threshold > 3 might give you the junctions (and value > 0 and < 3 give you end points), although this may also end up giving you small clusters where you'd rather have single pixels.  Implementing the threshold with the help of Process -> Find Maxima... may help - the noise tolerance is effectively your threshold, and you can set the output to be Point Selection or Single Points.

(These suggestions are largely untested...)

I did this

thresh = 3; // number of minimal neighbors

setBatchMode(true);

rename("skeleton");

run("Duplicate...", "title=mean");

run("Smooth");

imageCalculator("AND", "mean","skeleton");

run("Multiply...", "value=0.0353"); // 255 divided by 9 ~ 0.0353

run("Find Maxima...", "noise=3 output=[Point Selection] exclude light");

getSelectionCoordinates(x,y);

selectWindow("mean"); close();

selectWindow("skeleton");

for(i=0; i

Hi again Martin!

Your thinking was good, and so were Peter's suggestions.

But since you are getting a taste for image processing (which is really fun to do!), you will encounter more and more problems because general packages such as ImageJ, are too slow for the things you want to do or they just don't support it.

I recommend you invest some time in learning C or C++ programming, and move to ITK or OpenCV. Even Matlab or Octave is too slow when you want to get/set individual pixels.

Well, just a suggestion...

Glad it worked!

Lambert’s suggestions is a good one if you will have time to focus primarily/exclusively on image analysis, although I would like to add that the issue with the implementation speed of your initial approach is most likely the use of ImageJ’s macro language - which is *extremely* slow for pixel-by-pixel operations. If you stick with ImageJ, eventually you’ll want to write plugins in Java, which will run enormously faster. All the hard work of the macro command

run("Multiply...", "value=0.0353”);

is performed by an ImageJ plugin written in Java, so is far faster. But until then you can get a lot done with creative macros.

For me, my PhD work sped up hugely when I switched to MATLAB from ImageJ, but afterwards I turned back to ImageJ because it makes it infinitely easier to share algorithms with others and make them interactive. Now I work with ultra large 2D images (20-40 GB per image), happily processing them using Java with good speed (e.g. detecting & measuring hundreds of thousands of cells in < 5 mins).  I still use MATLAB from time to time to 'think' though, or for visualization.

If I understand correctly (please correct if not!), Lambert works mostly in medical imaging, where I get the impression C/C++ is almost essential. It would also be a valuable skill when working with (fluorescence) microscopy images, but I would say that if you don't already know C/C++ then it's better to learn Java first - and then, if you like, Python or MATLAB. These are the languages that most of the popular open source tools for microscopy image analysis are written to be extended with.

Finally, it seems to be true that brilliantly-written C/C++ will probably win on speed most of the time, but I’ve often seen Java or MATLAB outperform image analysis written in C/C++ by an order of magnitude because of a better implementation or algorithm… so the main thing is to be good at whichever you use :-)

Thanks for your answers! :-) I will definitively give it a try with imageJ plugins. I certainly will also have a look into ITK or OpenCV. Thanks for your tips, I'm very happy since I never really had an introduction into imaging, except for some tutorials I found online and I think I still miss some basics even though your ImageJ documentation was very useful in order to understand a lot of basics. So, if you have literature that you would recommend, I would appreciate it very much. Maybe some introduction on how to develop ImageJ plugins or ITK? I used to program a bit in C++, but it's been a while and I would need to get used to it again.

Hi Martin,

Ah, if you have some C++ then you’re already in a good position. The first image analysis course I attended was the one I taught, and I also just picked up a bit over time while working on projects. From memory, the two main books I used were:

- Digital Image Processing by Gonzalez & Woods (there is also a MATLAB variant with Steve Eddins, who also has a very good image processing blog) - I liked it, but found the mathematical approach hard to get started with

- an old German copy of the ImageJ book by Burger & Burge - even with my poor German it was sometimes easier to understand because it used code as much as maths

But in general I think the best way to learn, at least for me, is by writing code, and reading / modifying / optimizing code from others. The ability to open even most built-in MATLAB functions helped me a lot to see how they are implemented, and a good IDE and debugger that lets you set breakpoints within running code and check the values of variables is also hugely valuable (I use Eclipse for Java, with ImageJ’s sourced added to the build path - let me know if you would like any help setting this up, as it’s not entirely easy the first time).

Thanks a lot Girish

Image J has done well by me for binary images and pixel approximation. A combination of drawing out or "overlaying" the original or "outlined" image over the binary is a method of gauging some of your accuracy initially. Then as long as your calibration for the images in the field remains the same you could use the output for pixel coordinates on the 2d plane pretty accurately. Perhaps a 3d analysis is something you could approximate if you had points of reference on each of your samples. My knowledge of development is minimal yet but that would be my approach with a wireless tracking plug in (Fabrice Cordelieres's was what I have used). Hope this was helpful! 

Hi Martin,

From my experience, ImageJ is fast enough, but you have to work directly in Java and write plugins. I have implemented neighboorhood-based segmentation algorithms in the past with good performance.