001/*******************************************************************************
002 * This software is provided as a supplement to the authors' textbooks on digital
003 * image processing published by Springer-Verlag in various languages and editions.
004 * Permission to use and distribute this software is granted under the BSD 2-Clause
005 * "Simplified" License (see http://opensource.org/licenses/BSD-2-Clause).
006 * Copyright (c) 2006-2023 Wilhelm Burger, Mark J. Burge. All rights reserved.
007 * Visit https://imagingbook.com for additional details.
008 ******************************************************************************/
009package Ch08_Binary_Regions;
010
011import ij.IJ;
012import ij.ImagePlus;
013import ij.gui.GenericDialog;
014import ij.plugin.filter.PlugInFilter;
015import ij.process.ByteProcessor;
016import ij.process.ImageProcessor;
017import imagingbook.common.color.sets.BasicAwtColor;
018import imagingbook.common.geometry.basic.Pnt2d;
019import imagingbook.common.ij.DialogUtils;
020import imagingbook.common.ij.IjUtils;
021import imagingbook.common.ij.overlay.ColoredStroke;
022import imagingbook.common.ij.overlay.ShapeOverlayAdapter;
023import imagingbook.common.regions.BinaryRegion;
024import imagingbook.common.regions.RegionContourSegmentation;
025import imagingbook.common.util.GenericProperties.PropertyKey;
026import imagingbook.core.plugin.IjPluginName;
027import imagingbook.core.jdoc.JavaDocHelp;
028import imagingbook.sampleimages.GeneralSampleImage;
029
030import java.awt.geom.Line2D;
031import java.util.List;
032
033import static imagingbook.common.ij.IjUtils.noCurrentImage;
034import static imagingbook.common.math.Arithmetic.sqr;
035import static java.lang.Math.sqrt;
036
037/**
038 * <p>
039 * ImageJ plugin, shows each region's major axis as a vector scaled by the region's eccentricity. See Sec. 8.6 of [1]
040 * for additional details. Also demonstrates the use of the region property scheme, i.e., how to assign numeric
041 * properties to regions and retrieve them afterwards. Requires a binary image. Zero-value pixels are considered
042 * background, all other pixels are foreground. Display lookup tables (LUTs) are not considered. Results are drawn into
043 * a new image (pixel graphics), the original image is not modified. If no image is currently open, the plugin
044 * optionally loads a suitable sample image.
045 * </p>
046 * <p>
047 * [1] W. Burger, M.J. Burge, <em>Digital Image Processing &ndash; An Algorithmic Introduction</em>, 3rd ed, Springer
048 * (2022).
049 * </p>
050 *
051 * @author WB
052 * @version 2020/12/17
053 */
054@IjPluginName("Major Axis Demo")
055public class Major_Axis_Demo implements PlugInFilter, JavaDocHelp {     // TODO: convert to overlay display
056
057
058        static final PropertyKey<Double> dxKey = new PropertyKey<>("dx");
059        static final PropertyKey<Double> dyKey = new PropertyKey<>("dy");
060        static final PropertyKey<Double> ecc1Key = new PropertyKey<>("ecc1");
061        static final PropertyKey<Double> ecc2Key = new PropertyKey<>("ecc2");
062
063        
064        /** Scale of the axis length. */
065        public static double DrawingScale = 50;
066        /** Color for drawing overlay graphics. */
067        public static BasicAwtColor DrawingColor = BasicAwtColor.Blue;
068        /** Stroke width for drawing overlay graphics. */
069        public static double StrokeWidth = 0.5;
070        
071        private ImagePlus im;
072        
073        /**
074         * Constructor, asks to open a predefined sample image if no other image is currently open.
075         */
076        public Major_Axis_Demo() {
077                if (noCurrentImage()) {
078                        DialogUtils.askForSampleImage(GeneralSampleImage.ToolsSmall);
079                }
080        }
081        
082        @Override
083        public int setup(String arg, ImagePlus im) {
084                this.im = im;
085                return DOES_8G;
086        }
087
088        @Override
089        public void run(ImageProcessor ip) {
090                if (!IjUtils.isBinary(ip)) {
091                        IJ.showMessage("Plugin requires a binary image!");
092                        return;
093                }
094
095                if (!runDialog())
096                        return;
097
098
099                // perform region segmentation:
100                RegionContourSegmentation segmenter = new RegionContourSegmentation((ByteProcessor) ip);
101                List<BinaryRegion> regions = segmenter.getRegions(true);
102
103                // calculate and register certain region properties:
104                for (BinaryRegion r : regions) {
105                        calculateRegionProperties(r);
106                }
107                
108                // draw major axis vectors (scaled by eccentricity) as vector overlays
109                ShapeOverlayAdapter ola = new ShapeOverlayAdapter();
110                ola.setStroke(new ColoredStroke(StrokeWidth, DrawingColor.getColor()));
111                for (BinaryRegion r : regions) {
112                        if (r.getSize() > 10) {
113                                Pnt2d xc = r.getCenter();
114                                double x0 = xc.getX();
115                                double y0 = xc.getY();
116                                double x1 = x0 + DrawingScale * r.getProperty(dxKey);
117                                double y1 = y0 + DrawingScale * r.getProperty(dyKey);
118                                ola.addShape(xc.getShape(0.05 * DrawingScale));
119                                ola.addShape(new Line2D.Double(x0, y0, x1, y1));
120                        }
121                }
122                im.setOverlay(ola.getOverlay());
123        }
124        
125        private void calculateRegionProperties(BinaryRegion r) {
126                // calculate central moment mu11, mu20, mu02:
127                Pnt2d xctr = r.getCenter();
128                double xc = xctr.getX();
129                double yc = xctr.getY();
130                double mu11 = 0;
131                double mu20 = 0;
132                double mu02 = 0;
133                for (Pnt2d p : r) {
134                        double dx = (p.getX() - xc);
135                        double dy = (p.getY() - yc);
136                        mu11 = mu11 + dx * dy;
137                        mu20 = mu20 + dx * dx;
138                        mu02 = mu02 + dy * dy;
139                }
140                
141                double A = 2 * mu11;
142                double B = mu20 - mu02;
143                
144                double normAB = Math.sqrt(sqr(A) + sqr(B));
145                double scale = sqrt(2 * (sqr(A) + sqr(B) + B * sqrt(sqr(A) + sqr(B))));
146                
147                double dx = B + normAB;
148                double dy = A;
149                
150                r.setProperty(dxKey, dx / scale);
151                r.setProperty(dyKey, dy / scale);
152                
153                // calculate 2 versions of eccentricity:
154                double a = mu20 + mu02;
155                double b = Math.sqrt(Math.pow(mu20 - mu02, 2) + 4 * mu11 * mu11);
156                r.setProperty(ecc1Key, (a + b) / (a - b));
157                r.setProperty(ecc2Key, (Math.pow(mu20 - mu02,  2) + 4 * mu11 * mu11) / Math.pow(mu20 + mu02, 2));
158        }
159
160        // --------------------------------------------------------------------------
161
162        private boolean runDialog() {
163                GenericDialog gd = new GenericDialog(Region_Contours_Demo.class.getSimpleName());
164                gd.addHelp(getJavaDocUrl());
165                gd.addEnumChoice("Drawing color", DrawingColor);
166                gd.addNumericField("Stroke width", StrokeWidth, 1);
167
168                gd.showDialog();
169                if (gd.wasCanceled()) {
170                        return false;
171                }
172
173                DrawingColor = gd.getNextEnumChoice(BasicAwtColor.class);
174                StrokeWidth = gd.getNextNumber();
175                return true;
176        }
177
178}