#==============================================================================
#
# Project:   SharpImage
# Module:    BinaryThresholdAsLabel.py
# Language:  IronPython
# Author:    Dan Mueller
# Date:      $Date: 2007-07-06 10:57:00 +1000 (Fri, 06 Jul 2007) $
# Revision:  $Revision: 2 $
#
# Copyright (c) Queensland University of Technology (QUT) 2007.
# All rights reserved.
#
# This software is distributed WITHOUT ANY WARRANTY; without even
# the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
# PURPOSE.  See the above copyright notices for more information.
#
#==============================================================================

# Import the base script class
import BinaryThresholdWithForm
from BinaryThresholdWithForm import *

# Add reference and import required libraries
clr.AddReference("ManagedITK.ResizeFilters")
from itk import *

class BinaryThresholdAsLabelScript(BinaryThresholdWithFormScript):
    # -------------------------------------------------------------------------
    Name = "BinaryThresholdAsLabel"
    Help = """This filter produces an output image whose pixels are either one
              of two values (OutsideValue or InsideValue), depending on whether or not the
              corresponding input image pixel lies between the two thresholds (Lower and Upper).
              Values equal to either threshold is considered to be between the thresholds.
              The Lower and Upper parameters are specified using sliders.
              During the thresholding the resultant image is displayed as a label on the
              specified ImageToLabel."""
    Parameters = """(pixel) InsideValue = the output value if between thresholds. (255)
                    (pixel) OutsideValue = the output value if outside thresholds. (0)
                    (double) SliderMinimum = the minimum slider value. (min)
                    (double) SliderMaximum = the maximum slider value. (max)
                    (double) Increment = slider value increment. (1.0)
                    (string) ImageToLabel = Name search pattern of the open image to label.
                    (Color) LabelColor = the color of the label. (Color.FromArgb(128,255,0,0))"""
    InputRenderer = None
    LabelIndex = 1
    LabelColor = Color.FromArgb(128, 255, 0, 0)
    LabelImage = None
    ImageToLabel = None
    Default = None
    # -------------------------------------------------------------------------

    def GetRenderer(self):
        """ Returns the renderer for the image to label. """
        # Check that we have not already found the renderer
        result = self.Renderer
        if (result != None):
            return result

        # Check the image to label
        if (self.Default != None):
            self.ImageToLabel = self.Default
        if (self.ImageToLabel == None or self.ImageToLabel.Length == 0):
            self.ImageToLabel = self.InputRenderer.Inputs[0].Name

        # Find the renderer
        for renderer in self.ParentApplication.Renderers:
            if (renderer != None and renderer.Inputs.Count > 0):
                if (renderer.Inputs[0].Name.ToLower().Contains( self.ImageToLabel.ToLower() )):
                    result = renderer

        # Check we found the renderer
        if (result == None):
            raise ArgumentException( "A valid image to label must be provided." )
        else:
            return result

    def GetInputAsSlice(self):
        imageIn = self.InputRenderer.Inputs[0]
        if (imageIn.Dimension == 2):
            # No need to extract slice
            return imageIn
        else:
            # Extract the slice
            imageOut = itkImage.New( imageIn.PixelType, 2 )
            filterExtract = itkExtractImageFilter.New( imageIn, imageOut )
            filterExtract.RemoveAllObservers( )
            filterExtract.SetInput( imageIn )
            filterExtract.ExtractSlice( 2, self.Renderer.Slice )
            filterExtract.Update( )
            filterExtract.GetOutput( imageOut);
            imageIn.DisconnectPipeline( )
            imageOut.DisconnectPipeline( )
            self.DisposeOfObject( filterExtract )
            return imageOut

    def GetInput(self):
        return self.InputRenderer.Inputs[0]

    def Initialise(self):
        """ Initialise the environment for running this script. """
        try:
            # Get a reference to the renderer to the label
            # NOTE: self.Renderer is a reference to the image to label renderer
            self.InputRenderer = self.ParentApplication.CurrentRenderer
            self.Renderer = self.GetRenderer( )
            self.Renderer.Focus( )

            # Add a dummy input to the renderer
            self.SetupInsideOutsideValues( )
            image = self.Renderer.Inputs[0]
            self.LabelIndex = self.Renderer.Inputs.Count
            self.LabelImage = itkImage.New( itkPixelType.UC, image.Dimension )
            self.LabelImage.SetRegions( image.LargestPossibleRegion )
            #self.LabelImage.Spacing = image.Spacing
            #self.LabelImage.Origin = image.Origin
            self.LabelImage.Allocate( )
            self.LabelImage.FillBuffer( 0 )
            lut = siGdiLookupTable( )
            lut.SetTableRange( self.LabelImage, 256 )
            lut.SetTableToSingleColor( self.InsideValue.ValueAsD, self.LabelColor )
            self.Renderer.AddInputAsLabel( self.LabelImage, lut )
            
            # Initialise the base class
            BinaryThresholdWithFormScript.Initialise( self )

        except Exception, ex:
            self.HandleException( ex )
            self.FinishedWork( False )
            ScriptObject.Finalise( self )

    def Finalise(self):
        """ Finalise the environment after running this script. """
        """ NOTE: This function is invoked on the main UI thread. """
        self.Renderer.Inputs.Remove( self.LabelImage )
        self.DisposeOfObject( self.LabelImage )
        self.InputRenderer.Show( self.ParentApplication )
        BinaryThresholdWithFormScript.Finalise( self )

    def ShowOutputAsCurrentSlice(self):
        """ Show self.Output as label in the Renderer. """
        self.Renderer.InputsAsSlice[self.LabelIndex] = self.Output
        self.Renderer.InitialiseInputsAsSlice( )
        self.Renderer.Repaint( )

    def ShowOutputAsImage(self):
        """ Show self.Output as an image in a new Renderer. """
        self.Renderer.InitialiseInputs( )
        self.Renderer.Repaint( )
        self.Renderer.Focus( )
        self.ParentApplication.ShowImageInNewRenderer( self.Output )