Differences

This shows you the differences between two versions of the page.

--- documents:120206pyip_cooking:python_imagej_cookbook [2025/10/05 17:42] – [Union of multiple ROIs] kota
+++ documents:120206pyip_cooking:python_imagej_cookbook [2025/10/05 22:53] (current) – [Converting Java array types] kota
@@ Line 719: / Line 719: @@
 ==== ImagePlus Array ====
-Some arguments ask for an array of specific type. Since Python array is not java array, {{http://onlamp.com/pub/a/python/2002/04/11/jythontips.html?page=2|one should generate a Java array}}. For this, you could use jarray package.
+Some arguments ask for an array of a specific type. Since Python array is not Java array, {{https://www.tutorialspoint.com/jython/jython_using_java_collection_types.htm|one should generate a Java array}}. For this, you could use the jarray package.
 <code python linenums:1>
 import jarray
@@ Line 748: / Line 748: @@
 </code>
+==== Java native 2D Array from Python2D ====
+To initialize a Java native 2D array (e.g. float[][]), create a Python 2D array first, then convert it to a Java 2D array using jarray. See the example code below.
+<code python>
+import jarray
+import java.lang.Class
+#prepare 3x2 matrix
+py2Dlist = [[float(0)]*2]*3
+print(py2Dlist)
+# [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]]
+print(type(py2Dlist))
+# <type 'list'>
+java2Dlist = jarray.array(py2Dlist,java.lang.Class.forName("[F"))
+print (java2Dlist)
+# array([F, [array('f', [0.0, 0.0]), array('f', [0.0, 0.0]), array('f', [0.0, 0.0])])
+print(type(java2Dlist))
+# <type 'array.array'>
+print(java2Dlist[1][1])
+#0.0
+</code>
+"java.lang.Class.forName("[F")" is the reflection, and the name of the Java native float class is "[F".
+==== Creating floating point processor image ====
+Java float 2D array can also be made using jarray.zeros (like numpy.zeros).
+Here is an example of creating a floating-point image from 2D array.
+<code python linenums:1>
+from jarray import zeros
+from ij import ImagePlus
+from ij.process import FloatProcessor
+#generate 200 x 100 floating point matrix
+matrix2D = [zeros(100, 'f')]*200
+# check the generated matrix
+print(matrix2D)
+#[array('f', [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ...
+rows = len(matrix2D)
+cols = len(matrix2D[0])
+print("rows {} cols {}".format(rows, cols))
+#rows 200 cols 100
+# instantiate FP image
+fp = FloatProcessor(matrix2D)
+#check created FP image
+print("image width {} height {}".format(fp.getWidth(), fp.getHeight()))
+ImagePlus('fp', fp).show()
+</code>
+In short, as simple as:
+<code python linenums:1>
+from jarray import zeros
+from ij import ImagePlus
+from ij.process import FloatProcessor
+matrix2D = [zeros(100, 'f')]*200
+ImagePlus('fp', FloatProcessor(matrix2D)).show()
+</code>
 ==== Converting Java array types ====
-Sometimes we need to convert the type of Java array e.g. double[] to int[]. For this, there is no magic trick and need to run a loop. Below is a code fragment.
+Sometimes we need to convert the type of Java array e.g. double[] to int[]. In Java we can do this by a for-loop with casting from float to int, but in Jython we can use the map function.
 <code:py>
+from ij import IJ
 from ij.process import StackStatistics
 import jarray
+imp = IJ.getImage() #stack
 stackstats = StackStatistics(imp)
-histD = stackstats.histogram()
+histD = stackstats.histogram() #double[] returned, taken as floats in python
-hist = jarray.zeros(len(histD), 'i')
+print(type(histD[0]))
-for i in range(len(histD)):
-    hist[i] = int(histD[i])
+hist = map(int, histD)
+histInt = jarray.array(hist, 'i')
+print(type(histInt[0])) #Java int[]
 </code>
@@ Line 1208: / Line 1283: @@
 # here is only listing mean intensity of ROIs
 # if you want more, see
-# http://rsbweb.nih.gov/ij/developer/api/ij/process/ImageStatistics.html
+# http://imagej.net/ij/developer/api/ij/process/ImageStatistics.html
 for r in ra:
 	ip.setRoi(r)
@@ Line 1233: / Line 1308: @@
 ==== Union of multiple ROIs ====
-For combining multiple ROIs, {{http://rsbweb.nih.gov/ij/developer/api/ij/gui/ShapeRoi.html|ShapeRoi}} class is useful.
+For combining multiple ROIs, [[http://imagej.net/ij/developer/api/ij/gui/ShapeRoi.html|ShapeRoi]] class is useful.
 <code python linenums:1>
@@ Line 1654: / Line 1729: @@
 </code>
-For more explanation about this processing, see [[http://rsbweb.nih.gov/ij/developer/api/ij/plugin/filter/GaussianBlur.html|the explanation in javadoc]].
+For more explanation about this processing, see [[http://imagej.net/ij/developer/api/ij/plugin/filter/GaussianBlur.html|the explanation in javadoc]].
 ==== Background Subtraction (Rolling Ball) ====
@@ Line 2552: / Line 2627: @@
 The code below shows how to measure spherical 3D ROI in an image. We first create 3 3D spheres and then use them for measuring the mean pixel intensity of those 3D ROIs within a synthetic gradient 3D image.
-<code:py>
+<code py>
 from ij import IJ, ImagePlus
 from mcib3d.geom import ObjectCreator3D
@@ Line 2583: / Line 2658: @@
 print "Obj3: ",obj3.getPixMeanValue(ima)
 </code>
+===== Plugin: Ridge Detection =====
+[[https://imagej.net/plugins/ridge-detection|RidgDetection Plugin]] is a Hessian Matrix-based detection of linear/curved filaments, lines. Quite robust outcome.
+[[https://github.com/thorstenwagner/ij-ridgedetection/tree/master|The GitHub repo is here]]. Measurements of the lengths of detexted lines are also a part of the plugin, but this part is not included in the code above.
+<code python linenums:1>
+from ij import IJ
+from ij.process import ImageConverter
+from ij.plugin.frame import RoiManager
+from ij.gui import PolygonRoi
+from de.biomedical_imaging.ij.steger import Lines, Position, Junctions, LinesUtil
+from org.apache.commons.lang3.mutable import MutableInt
+import jarray
+import java.lang.Class
+# parameter settings
+sigma = 2.8 #estimated radius of structure
+high = 4.0 #eigenvalue upper threshold
+low = 2.0 #eigenvalue lower threshold
+minLength = 0.0 #length filter
+maxLength = 0.0 #length filter
+doCorrectPosition = False
+doEstimateWidth = False
+doExtendLine = False
+mode = LinesUtil.MODE_LIGHT #white signal with black back
+# start processing
+imp = IJ.getImage()
+imp32=imp.duplicate()
+ImageConverter(imp32).convertToGray32()
+in_img = imp32.getProcessor()
+cols = in_img.getWidth()
+rows = in_img.getHeight()
+imgpxls2 = in_img.getPixels() #alredy float
+# prepare output data variables
+contours = Lines(in_img.getSliceNumber())
+resultJunction = Junctions(in_img.getSliceNumber())
+hnum_cont = MutableInt()
+# detection
+p = Position()
+p.detect_lines(imgpxls2, cols, rows, contours, \\
+	hnum_cont, sigma, low, high, mode, doEstimateWidth, \\
+		doCorrectPosition, doExtendLine, resultJunction)
+# visualization of results
+rm = RoiManager.getInstance()
+if (rm is None):
+	rm = RoiManager()
+else:
+	rm.reset()
+for c in contours:
+	pr = PolygonRoi(c.getXCoordinates(), \\
+		c.getYCoordinates(), \\
+			PolygonRoi.POLYLINE)
+	rm.addRoi(pr)
+rm.runCommand(imp, 'Show All')
+</code>