Border combined with segment. Done by Nikhil.

svn path=/; revision=265

diff --git a/Annotation/src/ie/dcu/apps/ist/views/SegmentationView.java b/Annotation/src/ie/dcu/apps/ist/views/SegmentationView.java
index ba2a5e2ac25eeaef388e1025dfdf4017e3ec7c90..593685f836f7453f5376f7d7f291f8b9aa647e50 100644 (file)
--- a/Annotation/src/ie/dcu/apps/ist/views/SegmentationView.java
+++ b/Annotation/src/ie/dcu/apps/ist/views/SegmentationView.java
@@ -246,16 +246,18 @@ public class SegmentationView extends Composite {
                item.setControl(assign);
                assign.addSelectionListener(new SelectionListener() {
         public void widgetSelected(SelectionEvent arg0) {
-               String lab = null;
-               if(comboLabel.getText().indexOf('{') != -1)
-               {
-                       lab = comboLabel.getText().substring(0,comboLabel.getText().indexOf('{')-1);
-               }
-               else
-               {
-                       lab = comboLabel.getText();
-               }
-               System.out.println("selected"+lab);
+               if(view.getContext().isEnabled())
+               {
+                       if(comboLabel.getText().indexOf('{') != -1)
+                       {
+                               view.getContext().getEnabledMask().segmentName = comboLabel.getText().substring(0,comboLabel.getText().indexOf('{')-1);
+                       }
+                       else
+                       {
+                               view.getContext().getEnabledMask().segmentName = comboLabel.getText();
+                       }
+               }
+               System.out.println("selected"+view.getContext().getEnabledMask().segmentName);
                execute(Tool.AssignButton, null);
                }
                @Override
@@ -872,10 +874,10 @@ public class SegmentationView extends Composite {
                setPainter(painter);
        }
        /*
-        Assign the label to the segment on clicking assign button and update the image segment. 
-        */
+       Assign the label to the segment on clicking assign button and update the image segment. 
+       */
        private void assignLabel() {
-               SegmentationPainter painter = painters.get("Foreground Only");
+               SegmentationPainter painter = painters.get("Combined");
                setPainter(painter);
        }
        

diff --git a/Annotation/src/ie/dcu/segment/SegmentationContext.java b/Annotation/src/ie/dcu/segment/SegmentationContext.java
index a3a205b8684928e14d329d7f36858c59f7731781..a04031fde82f471b242dff13ffcf3a9ca0372a15 100644 (file)
--- a/Annotation/src/ie/dcu/segment/SegmentationContext.java
+++ b/Annotation/src/ie/dcu/segment/SegmentationContext.java
@@ -154,7 +154,7 @@ public class SegmentationContext {
        }
        
        /**
-        * @return A {@link SegmentationObject} instance. Returns the latest mask which hasn't yet turned into an object.
+        * @return A {@link SegmentationMask} instance. Returns the latest mask which hasn't yet turned into an object.
         */
        public SegmentationMask getMask() {
                if (currentSegmentMask == null) {
@@ -199,6 +199,34 @@ public class SegmentationContext {
                }       
        }
        
+       /**
+        * @return A boolean value whether any mask is anabled or not. By default the last SegmentationMask created will have enabled status.
+        */
+       public boolean isEnabled() {
+               for(SegmentationMask SegmentMask : segmentationMaskObjects)
+               {
+                       if(SegmentMask.enabled = true)
+                       {
+                               return true;
+                       }
+               }
+               return false;
+       }
+       
+       /**
+        * @return A {@link SegmentationMask} instance. Returns the  mask which has enabled status.
+        */
+       public SegmentationMask getEnabledMask() {
+               for(SegmentationMask SegmentMask : segmentationMaskObjects)
+               {
+                       if(SegmentMask.enabled = true)
+                       {
+                               return SegmentMask;
+                       }
+               }
+               return currentSegmentMask;
+       }
+       
        /**
         * Returns the current image being segmented. This method returns an an SWT
         * Image instance, constructing it if it is not already available. The

diff --git a/Annotation/src/ie/dcu/segment/SegmentationMask.java b/Annotation/src/ie/dcu/segment/SegmentationMask.java
index 473f1f329eea985de3303b9f8cb58440ffb060e7..75591dee3090d7e4178af3ddfbd309c2cba71117 100644 (file)
--- a/Annotation/src/ie/dcu/segment/SegmentationMask.java
+++ b/Annotation/src/ie/dcu/segment/SegmentationMask.java
@@ -59,6 +59,9 @@ public class SegmentationMask extends ByteMatrix{
        //The layering number of the segmentation mask.
        public int layerNumber;
        
+       //The name(label) associated with each segment.
+       public String segmentName;
+       
        //Whether the segment needs to be enabled(highlighted) or not ?
        public boolean enabled;
        
@@ -75,6 +78,8 @@ public class SegmentationMask extends ByteMatrix{
                super(height, width);
                this.width = width;
                this.height = height;
+               this.layerNumber = ++numberOfLayers;
+               this.segmentName = "";
                clear();
        }
        

diff --git a/Annotation/src/ie/dcu/segment/painters/CombinedPainter.java b/Annotation/src/ie/dcu/segment/painters/CombinedPainter.java
index fee86945a35cd919845ecb0da1433d669cd9e330..ece842cc487429afdc99261b0ef882ecb7116496 100644 (file)
--- a/Annotation/src/ie/dcu/segment/painters/CombinedPainter.java
+++ b/Annotation/src/ie/dcu/segment/painters/CombinedPainter.java
@@ -15,7 +15,9 @@ public class CombinedPainter implements SegmentationPainter {
        public static final String NAME = "Combined";
        
        private ImageData maskData;
+       private ImageData maskBorderData;
        private Image maskImage;
+       private Image maskBorderImage;
 
        
        public String getName() {
@@ -44,12 +46,6 @@ public class CombinedPainter implements SegmentationPainter {
                        // For drawing all the disabled masks.
                        for(SegmentationMask segmentMask : ctx.getSegmentationMasks())
                        {
-                               // Skipping the enabled segment from painting. We will paint the enabled segment at last.
-                               /*if(segmentMask.layerNumber == 0)
-                               {
-                                       createVisibleMask(segmentMask,true);
-                                       gc.drawImage(maskImage, 0, 0);
-                               }*/
                                if(segmentMask.enabled == true)
                                {
                                        continue;
@@ -58,6 +54,8 @@ public class CombinedPainter implements SegmentationPainter {
                                {
                                        createVisibleMask(segmentMask,false);
                                        gc.drawImage(maskImage, 0, 0);
+                                       createVisibleMaskBorder(segmentMask);
+                                       gc.drawImage(maskBorderImage, 0, 0);
                                }
                        }
                }
@@ -72,17 +70,23 @@ public class CombinedPainter implements SegmentationPainter {
                                {
                                        createVisibleMask(segmentMask,true);
                                        gc.drawImage(maskImage, 0, 0);
+                                       createVisibleMaskBorder(segmentMask);
+                                       gc.drawImage(maskBorderImage, 0, 0);
                                }
                        }
                        // Current mask which has not yet been made into an object
                        createVisibleMask(ctx.getMask(),false);
                        gc.drawImage(maskImage, 0, 0);
+                       createVisibleMaskBorder(ctx.getMask());
+                       gc.drawImage(maskBorderImage, 0, 0);
                }
                // Very initial mask, which has not yet been turned into an object.
                else
                {
                        createVisibleMask(ctx.getMask(),true);
                        gc.drawImage(maskImage, 0, 0);
+                       createVisibleMaskBorder(ctx.getMask());
+                       gc.drawImage(maskBorderImage, 0, 0);
                }
                // Paint all annotations
                ctx.getAnnotations().paint(im);
@@ -144,7 +148,67 @@ public class CombinedPainter implements SegmentationPainter {
        maskImage = new Image(Display.getCurrent(), maskData);
        }
        
-
+       private void createVisibleMaskBorder(SegmentationMask mask) {
+               dispose();
+               
+               if (isNewMaskBorderDataRequired(mask.getBounds())) {
+                       maskBorderData = createMaskBorderData(mask.getBounds());
+               } 
+               
+               // Set pixels
+               byte[] buff = new byte[maskBorderData.width];
+               for (int y = 0, i = 0; y < mask.height-1; y++) {
+                       for (int x = 0; x < mask.width-1; x++) {
+                               // Make transparent
+                               buff[x] = 0;
+                               
+                               // Current pixel
+                               byte pix1 = mask.values[i];
+                               
+                               // Neighbor to right & neighbor below
+                               byte pix2 = mask.values[i+1];
+                               byte pix3 = mask.values[i+mask.width];
+                               
+                               // Set pixel if either neighbor is different
+                               if (pix1 != pix2 || pix1 != pix3) {
+                                       buff[x] = 1;
+                               }
+                               
+                               // Next pixel
+                               i++;
+                       }
+                       
+                       if (mask.width != 0) {
+                               // Last pixel in row
+                               byte pix1 = mask.values[i];
+                               byte pix2 = mask.values[i+mask.width];
+                               buff[mask.width-1] = (pix1 != pix2) ? (byte) 1 : 0;
+                               
+                               // Next row
+                               i++;
+                       }
+                       
+                       // Blit pixels
+                       maskBorderData.setPixels(0, y, buff.length, buff, 0);
+               }
+               
+               // Last row
+               if (mask.height != 0) {
+                       int yoff = (mask.height - 1) * mask.width;
+                       for (int x = 0; x < mask.width-1; x++) {
+                               byte pix1 = mask.values[x+yoff];
+                               byte pix2 = mask.values[x+yoff+1];
+                               buff[x] = (pix1 != pix2) ? (byte) 1 : 0;
+                       }
+                       
+                       // Blit
+                       maskBorderData.setPixels(0, mask.height-1, buff.length, buff, 0);
+               }
+               
+               // Create new mask
+               maskBorderImage = new Image(Display.getCurrent(), maskBorderData);
+       }
+       
        private boolean isNewMaskDataRequired(Rectangle bounds) {
                if (maskData == null) {
                        return true;
@@ -152,12 +216,20 @@ public class CombinedPainter implements SegmentationPainter {
                        return maskData.width != bounds.width || maskData.height != bounds.height;
                }
        }
-
+       
+       private boolean isNewMaskBorderDataRequired(Rectangle bounds) {
+               if (maskBorderData == null) {
+                       return true;
+               } else {
+                       return maskBorderData.width != bounds.width || maskBorderData.height != bounds.height;
+               }
+       }
 
        private static ImageData createMaskData(Rectangle bounds) {
                RGB[] colors = new RGB[] {
                        new RGB(128,128,128),
-                       new RGB(255,255,255),
+                       //new RGB(255,255,255),
+                       new RGB(255,180,180),
                        new RGB(0, 0, 0)
                };
                
@@ -174,7 +246,26 @@ public class CombinedPainter implements SegmentationPainter {
                return data;
        }
 
-
+       private static ImageData createMaskBorderData(Rectangle bounds) {
+               RGB[] colors = new RGB[] {
+                       new RGB(255,255,255),
+                       new RGB(0,255,0)
+               };
+               
+               // Create binary indexed palette
+               PaletteData palette = new PaletteData(colors);
+               
+               // Create 1 bit indexed image 
+               ImageData data = new ImageData(
+                               bounds.width, bounds.height, 1, palette);
+               
+               // Set transparent pixel
+               data.transparentPixel = 0;
+               
+               // Create and return the image
+               return data;
+       }
+       
        public void dispose() {
                // Dispose mask
                if (maskImage != null) {
@@ -183,5 +274,11 @@ public class CombinedPainter implements SegmentationPainter {
                        }
                        maskImage = null;
                }
+               if (maskBorderImage != null) {
+                       if (!maskBorderImage.isDisposed()) {
+                               maskBorderImage.dispose();
+                       }
+                       maskBorderImage = null;
+               }
        }
 }