/*=============================================================================
  
  NOTE: THIS FILE IS A HANDMADE WRAPPER FOR THE ManagedITK PROJECT.

  Project:   ManagedITK
  Program:   Insight Segmentation & Registration Toolkit
  Module:    itkManagedImageRegion.cxx
  Language:  C++/CLI
  Author:    Dan Mueller
  $Date: 2007-04-11 16:26:16 +1000 (Wed, 11 Apr 2007) $
  $Revision: 128 $

  Copyright (c) Queensland University of Technology (QUT) 2007.
  All rights reserved.
  
  Portions of this code are covered under the ITK and VTK copyright.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.

  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.
  
=============================================================================*/

#pragma once
#pragma warning( disable : 4635 ) // Disable warnings about XML doc comments

#ifndef __itkManagedImageRegion_cxx
#define __itkManagedImageRegion_cxx

// Include some managed files
#include "itkManagedSize.cxx"
#include "itkManagedIndex.cxx"
#include "itkManagedContinuousIndex.cxx"

// Use some managed namespaces
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::IO;
using namespace System::Reflection;
using namespace System::ComponentModel;
using namespace System::Diagnostics;

namespace itk
{

///<summary>
///This class is a managed replacement for itk::ImageRegion.
///</summary>
///<remarks>
///ImageRegion is an class that represents some structured portion or
///piece of an Image. The ImageRegion is represented with an index and
///a size in each of the n-dimensions of the image. (The index is the
///corner of the image, the size is the lengths of the image in each of
///the topological directions.)
///</remarks>
public ref class itkImageRegion
{

private:
	itkSize^ m_Size;
	itkIndex^ m_Index;

public:
    ///<summary>Default constructor.</summary>
	itkImageRegion (  ) { }

    ///<summary>Constructor taking an existing size and index.</summary>
    ///<param name="size">The size to set within the new image region.</param>
    ///<param name="index">The index to set within the new image region.</param>
	itkImageRegion ( itkSize^ size, itkIndex^ index ) 
	{
		if (size->Dimension != index->Dimension)
			throw gcnew ArgumentException( "The size and index of the image region must have the same dimensionality." );
		
		this->m_Size = size;
		this->m_Index = index;
	}

	///<summary>Get the dimensionality of the region.</summary>
	property virtual unsigned int Dimension 
	{ 
		unsigned int get() { return this->m_Size->Dimension; }
	}

	///<summary>Get/set the size of the image region.</summary>
	property virtual itkSize^ Size 
	{ 
		itkSize^ get() { return this->m_Size; }
		void set( itkSize^ size ) { this->m_Size = size; } 
	}

	///<summary>Get/set the index of the image region.</summary>
	property virtual itkIndex^ Index 
	{ 
		itkIndex^ get() { return this->m_Index; }
		void set( itkIndex^ index ) { this->m_Index = index; } 
	}

	///<summary>Test if an index is inside the image region.</summary>
    ///<returns>True if inside, false otherwise.</returns>
	bool IsInside ( itkIndex^ index )
	{
		for(unsigned int i=0; i<index->Length; i++)
        {
			if ( index[i] < this->Index[i] ) 
			  return false;
			if ( index[i] >= this->Index[i] + this->Size[i] ) 
			  return false;
        }
		return true;
	}

	///<summary>Test if a continuous index is inside the image region.</summary>
    ///<returns>True if inside, false otherwise.</returns>
	bool IsInside ( itkContinuousIndex^ cindex )
	{
		for (unsigned int i=0; i<cindex->Length; i++)
        {
			if ( cindex[i] < this->Index[i] ) 
				return false;
			if ( cindex[i] >= (this->Index[i] + this->Size[i]) )
				return false;
        }
		return true;
	}

	///<summary>
	///Pad an image region by the specified radius uniformly in all dimensions.
	///</summary>
	void PadByRadius( System::Int32 radius )
	{
		array<System::Int32>^ radiusArray = gcnew array<System::Int32>( this->Dimension );
		for (unsigned int i=0; i < this->Dimension; ++i)
			radiusArray[i] = radius;
		this->PadByRadius( radiusArray );
	}

	///<summary>
	///Pad an image region by the specified radius.
	///</summary>
	void PadByRadius( itkSize^ radius )
	{
		this->PadByRadius( radius->Data );
	}

	///<summary>
	///Pad an image region by the specified radius.
	///</summary>
	void PadByRadius( array<System::Int32>^ radius )
	{
		for (unsigned int i = 0; i < this->Dimension; i++)
		{
			m_Size[i]  += 2 * radius[i];
			m_Index[i] -= radius[i];
		}  
	}

	///<summary>
	///Crop a region by another region. If this region is outside of the crop,
	///this method returns false and does not modify the region. Otherwise,
	///this method returns true and the region ismodified to reflect the crop.
    ///</summary>
	bool Crop ( itkImageRegion^ region )
	{
		System::Int32 crop;
		unsigned int i;
		bool cropPossible = (this->Dimension == region->Dimension);

		// Can we crop?
		for (i = 0; i < region->Dimension && cropPossible; i++)
		{
			// Is left edge of current region to the right of the right edge
			// of the region to crop with? (if so, we cannot crop)
			if ( m_Index[i] >= region->Index[i] + region->Size[i] )
				cropPossible = false;

			// If right edge of the current region to the left of the left
			// edge of the region to crop with? (if so, we cannot crop)
			if ( m_Index[i] + m_Size[i] <= region->Index[i] )
				cropPossible = false;
		}

		// If we cannot crop, return without changing anythin
		if (!cropPossible)
			return cropPossible;

		// We can crop, so crop
		for (i=0; i < region->Dimension; i++)
		{
			// First check the start index
			if (m_Index[i] < region->Index[i])
			{
				// How much do we need to adjust
				crop = region->Index[i] - m_Index[i];

				// Adjust the start index and the size of the current region
				m_Index[i] += crop;
				m_Size[i] -= crop;
			}

			// Now check the final size
			if ( m_Index[i] + m_Size[i] > region->Index[i] + region->Size[i] )
			{
				// How much do we need to adjust
				crop = m_Index[i] + m_Size[i] - region->Index[i] - region->Size[i];

				// Adjust the size
				m_Size[i] -= crop;
			}
		}

		return cropPossible;
	}

	///<summary>Returns a string representation of the itkImageRegion.</summary>
	///<returns>A string representation in the format "Index=[XXX,XXX,..] Size=[XXX,XXX,..]".</returns>
	virtual String^ ToString() override
    {
		return "Index=" + this->Index->ToString() + " Size=" + this->Size->ToString();
	}

}; // end ref class

} // end namespace itk

#endif