// FitsLib.h
/**
<project name="Fits-Library">
<brief>A library for reading and manipulating FITS files.</brief>
<author>
	<email>haridas@jhu.edu</email>
	<name>Vivek Haridas</name>
	<company>Johns Hopkins University</company>
	<division>Department of Physics and Astronomy</division>
</author>

<summary>

<bold>FITS</bold> stands for flexible image transport system. 
<bold>FitsLib</bold> aims to provide an interface to the FITS file on the Dot Net Platform.
It is built as an object oriented wrapper around the CFITSIO library's interface to the FITS files.
<para/>

Even though this library should be accessible in all the Dot Net Languages, the main focus is on making it available for C-Sharp.
The documentation given here also tends to do the same.

<para/>
This library is intended to assist astronomers in writing webservices utilizing the immense amount of data available in the FITS files.
<para/>

The library provides an interface to the FITS files using a set of active and passive objects.
Active Objects access the file and passive objects contain the data accessed from the file.
The FitsLib namespace provides all the neccessary interfaces to access the FITS files.

<para/>

Look below in <bold>List of articles and samples</bold> for a brief tour of how to use the library and to access some of the samples.


</summary>
<seealso cref="articles">List of articles and samples</seealso>
<seealso href="http://heasarc.gsfc.nasa.gov/docs/heasarc/fits.html">FITS data format
</seealso>
<seealso href="http://heasarc.gsfc.nasa.gov/docs/software/fitsio/fitsio.html">CFITSIO
</seealso>



<revision date="Mar 29,2003">First documentation release. Examples and articles still left to be documented.</revision>
<revision date="Mar 31,2003">First articles added on basic FITS file operation.</revision>
<revision date="Apr 17,2003">String Access of FitsTable cells revised. Now you can access them directly as an ArrayList. No need to worry about unicode conversions.</revision>
<revision date="May 08,2003">Added new methods to read and write rectangular sections of image buffer.
Make sure you use the new createImageSectionBuffer to create a buffer for writing rectangular sections.</revision>
<revision date="May 27,2003">A bug fix for WriteSectionOfPixels. 
New examples for reading images, reading header key values, writing new fits tables and images.
Instructions for usage of the library in a WebService is also available.</revision>
<revision date="Jun 16,2003">Support for types LongLong (int64) , complex and double complex added.
Bug fix in column insertion routines. Source code split into many files.</revision>
<revision date="July 30,2003">Corrected memory leaks in FitsData and FitsImagePoint.
The String property of FitsData now returns an array of strings.
Added a new SafeArray property to FitsData. This means that you can access the data without an unsafe block.
</revision>
<revision date="Jan 08,2004">Added internal support to read and write long string header keywords. 
Also includes memory leak fixes in FitsTable. Added CreateColumnCells method in FitsTable interface. 
This can be used in writing columns of data into newly created tables.
</revision>
**/

#pragma once

using namespace System;

extern "C"
{
	#include "fitsio.h"
	#include "stdlib.h"
	
}

// Gets a non unicode char* from a string
//Used for internal purpose only
char* getcharfromString(String* str);

namespace FitsLib
{	
	/**
	<namespace name="FitsLib">
	<brief>Contains all the neccessary entities to access a FITS file.</brief>
	<summary>
	
	The library provides a set of active and a set of passive objects.
	The operations on an active object would be reflected on the FITS file being accessed.
	The passive objects are holders of data extracted from the file. 
	
	<para/>
	
	The active objects are Fits, FitsUnit, FitsImage, FitsTable, FitsUnitHeader, FitsColumnCollection and FitsTableElementCollection.
	
	<para/>
	
	Changes made on these objects would be reflected in the corresponding FITS file. 
	Changes made in passive objects such as FitsData would be reflected in the file only after they are explicitly written to the active objects.
	<para/>

	Look below for a code snippet of using the FitsLib library.
	<para/>
	
	<code><![CDATA[
			// A Function to look into the basic structure of a fits file.
		static void FitsLibOverlook(String strFile)
		{
			
			FileInfo fi = new FileInfo(strFile);
			Console.WriteLine("Contents of file " + fi.FullName);
            
			Fits f1 = FitsFactory.CreateFits();

			// Lets open a fits file
			f1.Open(strFile,FitsLib.FileMode.Read);

			// Get all the units in the file
			FitsUnitCollection allUnits = f1.Units;

			//How many units do we have
			int nUnits = allUnits.Count;

			Console.WriteLine("Number of units = " + nUnits);
            		
			// Lets go through each unit
			for(int i=1;i<=nUnits;i++)
			{
				Console.WriteLine("-----------------");

				Console.WriteLine("\tUnit " + i);

				// Get hold of an unit
				FitsUnit u = allUnits[i];

				// What type is it
				HduType ht = u.Type;
				Console.WriteLine("\tType of Unit is "+ ht);

				switch(ht)
				{
					case HduType.Image :
					{
						// Now that we know that it is an image, let us cast it into one.
						FitsImage im = (FitsImage)u;
						FitsImageInfo imInf = im.Info;

						//Lets get it's size, this is given by the farthest point in the image
						FitsImagePoint imSize = imInf.Size;

						Console.Write("\t\tType of image is " + imInf.Type);
						Console.WriteLine(" and is made of " + imSize.Dimensions + " Dimensions");
						Console.Write("\t\t\tSize = ");

						//How many dimensions in this image
						int nTotalDim = imSize.Dimensions;
						
						//Let us see the size in each dimension
						for(int nDim=0; nDim < nTotalDim; nDim++)
						{
							Console.Write(imSize[nDim] + " ; ");

						}
						Console.WriteLine();
					
					
					}break;
					case HduType.BinaryTable :
					{
						// Now that we know that it is an table, let us cast it into one.
						FitsTable tb = (FitsTable)u;

						Console.Write("\t\tRows " + tb.NumberOfRows);
						Console.Write(" ; Columns " + tb.NumberOfColumns + " ; ");

					}break;
					default:
					{
						// This could happen only for an ascii table.
						Console.WriteLine(" This looks like some unimplemented or unsupported unit");
					}break;
				}	  
			}
			Console.WriteLine("-----------------");
			Console.WriteLine("Thats it!");
			
			//Let's close the file
			f1.Close();
		}
		
		]]>			
	</code>
	</summary>
    <seealso cref="articles">List of articles and samples</seealso>

	**/
		
	__value public enum DataType
	{
	/**
	<enum name="DataType" access="public">
	<brief>The different Fits data types supported in the library.</brief>
	<summary>
		An enumeration of the data types supported for the operations on the fits files.
		All the data holding objects used in the Fitslib library essentianly have a DataType property.
		This property reflects the type of data the object holds.
	</summary>
	<remarks> Bit, Complex and DoubleComplex data types are not yet supported.
	</remarks>
	<seealso cref="FitsLib.FitsData">FitsData interface</seealso>
	<seealso cref="FitsLib.FitsDataInfo">FitsData interface</seealso>
	<seealso cref="FitsLib.FitsKeyValue">FitsKeyValue interface</seealso>
	**/
		Bit			=	TBIT,///<value name="Bit">
							///<brief>Not implemented</brief></value>
		Byte		=	TBYTE,///<value name="Byte"/>		
		Logical		=	TLOGICAL,///<value name="Logical"/>
		String		=   TSTRING,///<value name="String"/>
		Ushort		=   TUSHORT,///<value name="Ushort"/>
		Short		=   TSHORT,///<value name="Short"/>
		Uint		=   TUINT,///<value name="Uint"/>
		Int			=   TINT,///<value name="Int"/>
		Ulong		=   TULONG,///<value name="Ulong"/>
		Long		=   TLONG,///<value name="Long"/>
		Int32		=   TINT32BIT,///<value name="Int32"/>
		Float		=   TFLOAT,///<value name="Float"/>
		Double		=   TDOUBLE,///<value name="Double"/>
		Complex		=   TCOMPLEX,///<value name="Complex">
								 ///<brief>Not implemented</brief></value>
		DoubleComplex =	TDBLCOMPLEX,///<value name="DoubleComplex">
								 ///<brief>Not implemented</brief></value>
		LongLong = TLONGLONG///<value name="LongLong">
								 ///<brief>Not implemented</brief></value>
	///</enum>	
	};

	 __value public enum FitsError
		{
			/**
			<enum name="FitsError" access="public">
			<brief>The different Fits errors reported in the library.</brief>
			<summary>
				An enumeration of the errors reported during the operations on the fits files.
				FitsException is thrown when an error occurs. FitsException has an Error property which reflects the
				error in terms of these enumerations. The ExtendedError property of FitsException gives a more precise reason for the error.
			</summary>
			<seealso cref="FitsLib.FitsException">FitsException class</seealso>			
			**/

			Success	= 1,///<value name="Success"/>
			Unknown,///<value name="Unknown"/>
			FileAlreadyOpen,///<value name="FileAlreadyOpen"/>
			FileOpen,///<value name="FileOpen"/>
			FileNotOpen,///<value name="FileNotOpen"/>
			FileCreate,///<value name="FileCreate"/>
			NotATable,///<value name="NotATable"/>
			InvalidDataType,///<value name="InvalidDataType">
								 ///<brief>The ExtendedError gives the actual underlying data type</brief></value>
			FileChangedAfterLoading,///<value name="FileChangedAfterLoading"/>
			CFitsIOError,///<value name="CFitsIOError">
								 ///<brief>The ExtendedError gives the actual error reported by CFITSIO</brief></value>
			FitsInconsistancy,///<value name="FitsInconsistancy"/>
			OperationNotSupported,///<value name="OperationNotSupported"/>
			OutOfRange,///<value name="OutOfRange"/>
			NotImplemented///<value name="NotImplemented">
								 ///<brief>The ExtendedError gives the unimplemented data type</brief></value>
		///</enum>
		};
	__value public enum HduType
	{
		/**
			<enum name="HduType" access="public">
			<brief>The different types of Fits data units.</brief>
			<summary>
				An enumeration of the different type of fits data units.
				Every FitsUnit has a Type property. 
				This helps in identifying whether it is a table or an image.
			</summary>
			<seealso cref="FitsLib.FitsUnit">FitsUnit interface</seealso>			
		**/
		Image = IMAGE_HDU,///<value name="Image"/>
		AsciiTable = ASCII_TBL,///<value name="AsciiTable"/>
		BinaryTable = BINARY_TBL,///<value name="BinaryTable"/>
		Any = ANY_HDU /* Not documenting, as this is not supposed to be used.*/

		///</enum>
	};

	__value public enum ImageType
	{
		/**
			<enum name="ImageType" access="public">
			<brief>The different formats in which a Fits Image is stored in file.</brief>
			<summary>
				An enumeration of the different formats of Fits Images.
				FitsImageInfo has a Type property, which reflects this. 
				This helps in identifying the format of the image in the corresponding
				FitsImage.
			</summary>
			<remarks>
				Note that although the values look similar to the DataType values, they are
				inherently different and are small in number when compared to them.
			</remarks>
			<seealso cref="FitsLib.DataType">DataType enum</seealso>		
			<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>			
			<seealso cref="FitsLib.FitsImageInfo">FitsImageInfo interface</seealso>			
		**/

		Byte = BYTE_IMG,///<value name="Byte"/>
		Short = SHORT_IMG,///<value name="Short"/>
		Float = FLOAT_IMG,///<value name="Float"/>
		Double = DOUBLE_IMG,///<value name="Double"/>
		Long = LONG_IMG,///<value name="Long"/>
		// FitsIO.h comments
		/* The following 2 codes are not true FITS         */
		/* datatypes; these codes are only used internally */
		/* within cfitsio to make it easier for users      */
		/* to deal with unsigned integers.                 */
		Ushort = USHORT_IMG,///<value name="Ushort"/>
		Ulong = ULONG_IMG///<value name="Ulong"/>
		
		///</enum>
	};

	__value public enum FileMode
	{
		/**
			<enum name="FileMode" access="public">
			<brief>The different modes of opening a Fits file.</brief>
			<summary>
				These are the different modes in which a FITS file can be opened.
				A Fits interface is used to open a FITS file. 
			</summary>
			<seealso cref="FitsLib.Fits">Fits interface</seealso>			
		**/

			Read = 1,///<value name="Read"/>
			ReadWrite,///<value name="ReadWrite"/>
			Create,///<value name="Create"/>
			CreateOverWrite///<value name="CreateOverWrite"/>

		///</enum>
	};	


	/*All Interfaces */

	/* Level 1 */

	/* Level 2 */

	
	public __gc __interface FitsDataInfo
	{/**
		<interface name="FitsDataInfo" access="public">
		<passive/>
		<brief>Provides Information about the content of a fits data holder.</brief>
		<summary>FitsDataInfo interface provides a way of accessing all 
		the neccessary information about data contained in a table cell, table column 
		or an image buffer.
		</summary>
		<seealso cref="FitsLib.FitsData">FitsData interface</seealso>			
		<seealso cref="FitsLib.FitsColumnInfo">FitsColumnInfo interface</seealso>			
	 **/
	public:
		
		__property FitsLib::DataType get_Type();
		/**
		<property name="Type" access="public" get="true">
		<brief>Gets the data type of the contained data.</brief> 
		
		<summary>
		This indicates the actual property of the data holder which contains data.
		</summary>
		
		<returns type="FitsLib.DataType"> The data type of the contained data.
		</returns>
		
		<remarks>Make sure of accessing the relavent member of FitsData.
		For example, If this property returned Byte then access FitsData.Byte for data.
		Accessing any other field inside the FitsData object would raise a null exception.
		</remarks>
		<seealso cref="FitsLib.FitsData">FitsData interface</seealso>			
		</property>
		**/

		__property long get_Length();
		/**
		<property name="Length" access="public" get="true">
		<brief>Get the length of the contents.</brief>
		<returns type="long">Length of the contents of the FitsData object.</returns>
		<summary>The contents of the FitsData object are arranged in an one 
		dimensional vector. This property gives the length of this vector.
		This is mainly used to access the length of a FitsImage's buffer after or before
		reading the image data.
		</summary>
		<remarks>Note that this is equivalent to the Repeat property, which is used to
		find the repeat count of a table cell's data vector.
		</remarks>
		<seealso cref="FitsLib.FitsDataInfo.Repeat">Repeat property</seealso>
		<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		<seealso cref="FitsLib.FitsData">FitsData interface</seealso>
		</property>
		**/

		
		__property long get_Repeat();
		/**
		<property name="Repeat" access="public" get="true">
		<brief>Get the repeat of the contents.</brief>
		<returns type="long">Repeat count of the contents of the FitsData object.</returns>
		<summary>The contents of the FitsData object are arranged in an one 
		dimensional vector. This property gives the repeat count of the elements in this
		vector. This is mainly used to find the repeat count of a table cell's data vector.
		</summary>
		<remarks>Note that this is equivalent to the Length property, which is used to access
		 the length of a FitsImage's buffer.
		</remarks>
		<seealso cref="FitsLib.FitsDataInfo.Length">Length property</seealso>
		<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		<seealso cref="FitsLib.FitsData">FitsData interface</seealso>
		</property>
		**/

        
		__property long get_UnitSize();
		/**
		<property name="UnitSize" access="public" get="true">
		<brief>Get the unit size of a single element in the contents.</brief>
		<returns type="long">Unit size of an element in the contents of the FitsData object.</returns>
		<summary>The contents of the FitsData object are arranged in an one 
		dimensional vector. This property gives the size of one elements in this
		vector. This is mainly used to find the size of one element a Image buffer's data vector.
		</summary>
		<remarks>Note that this is equivalent to the Width property, which is used to access
		 the width of an element in the FitsTable element's vector.
		</remarks>
		<seealso cref="FitsLib.FitsDataInfo.Width">Width property</seealso>
		<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		<seealso cref="FitsLib.FitsData">FitsData interface</seealso>
		</property>
		**/


      __property long get_Width();/* Same as UnitSize, but for Cells */
		/**
		<property name="Width" access="public" get="true">
		<brief>Get the width of a single element in the contents.</brief>
		<returns type="long">Width of an element in the contents of the FitsData object.</returns>
		<summary>The contents of the FitsData object are arranged in an one 
		dimensional vector. This property gives the width of one element in this
		vector. This is mainly used to find the width of one element a Table element's data vector.
		</summary>
		<remarks>Note that this is equivalent to the UnitSize property, which is used to access
		 the size of an element in the FitsImage's buffer.
		</remarks>
		<seealso cref="FitsLib.FitsDataInfo.UnitSize">UnitSize property</seealso>
		<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		<seealso cref="FitsLib.FitsData">FitsData interface</seealso>
		</property>
		**/	
		///</interface>
	};

	[System::Reflection::DefaultMemberAttribute("KeyNameAt")]
	public __gc __interface FitsKeyNameCollection
	{
		/**
		<interface name="FitsKeyNameCollection" access="public">
		<brief>Collection of key names in a FitsUnit.</brief>
		<summary>This provides a way of accessing the names of all the keys in a fits unit header.
		Use it like an array of key names. The indexer helps in providing array like access.
		</summary>
		<seealso cref="FitsLib.FitsUnitHeader">FitsUnitHeader interface</seealso>
		**/

	public:
        
		
		__property System::String* get_KeyNameAt(int Index);
		/**
		<indexer name="KeyNameAt" access="public" get="true">
		<brief>Get the name of a key.</brief>
		<summary>This provides a way of accessing the key name collection as an array.</summary>
		<param name="Index" type="int">The key index whose name is to be retreived.</param>
		<returns type="System.String">The Key name.</returns>
		<remarks>Note that the index starts from 1 and not from 0.</remarks>
		</indexer>
		**/

		///</interface>
	};

	public __gc __interface FitsKeyValue
	{
	/**
		<interface name="FitsKeyValue" access="public">
		<passive/>
		<brief>Value stored in a key of a FitsUnit Header.</brief>
		<summary>This provides a way of accessing the value of a header key. 
		It also provides a way to access the comments and history of a key.
		</summary>
		<remarks>Fires an exception if the inherent type is different from the accesed value's type.
		One such case is when the Type of the data is DataType.Int and an access is made to the Float property.</remarks>
		<seealso cref="FitsLib.FitsUnitHeader">FitsUnitHeader interface</seealso>
	**/
	public:
		
		__property System::String* get_Comments();
		/**
			<property name="Comments" access="public" get="true">
			<brief>Get the comments of the key.</brief>
			<returns type="System.String">Comments of the key.</returns>
			</property>
		**/

		__property DataType get_Type();		 
		/**
			<property name="Type" access="public" get="true">
			<brief>Get the data type of the value.</brief>
			<returns type="FitsLib.DataType">The data type of the underlying value.</returns>
			<remarks>Accessing a data value other than that corresponding to stored type fires an exception.</remarks>
			</property>
		**/

		__property System::String* get_String();
		__property void set_String(System::String* value);
		/**
			<property name="String" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="System.String">The key value.</returns>
			</property>
		**/

		__property unsigned __int8 get_Byte();
		__property void set_Byte(unsigned __int8 value);
		/**
			<property name="Byte" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="byte">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		__property short get_Short();
		__property void set_Short(short value);
		/**
			<property name="Short" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="short">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		__property unsigned short get_Ushort();
		__property void set_Ushort(unsigned short value);
		/**
			<property name="Ushort" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="ushort">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		__property int get_Int();
		__property void set_Int(int value);
		/**
			<property name="Int" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="int">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		__property unsigned int get_Uint();
		__property void set_Uint(unsigned int value);
		/**
			<property name="Uint" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="uint">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		__property long get_Long();
		__property void set_Long(long value);
		/**
			<property name="Long" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="int">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		__property unsigned long get_Ulong();
		__property void set_Ulong(unsigned long value);
		/**
			<property name="Ulong" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="uint">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		__property float get_Float();
		__property void set_Float(float value);
		/**
			<property name="Float" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="float">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		__property double get_Double();
		__property void set_Double(double value);
		/**
			<property name="Double" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="double">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/
		  
		__property bool get_Logical();
		__property void set_Logical(bool value);		

		/**
			<property name="Logical" access="public" get="true" set="true">
			<brief>Get or set the value for a key.</brief>
			<returns type="bool">The key value.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsKeyValue.Type">Type property</seealso>
			</property>
		**/

		
		
	///</interface>
	};

	
	[System::Reflection::DefaultMemberAttribute("Coordinate")]
	public __gc __interface FitsImagePoint
	{
	/**
		<interface name="FitsImagePoint" access="public">
		<brief>A multi-dimensional co-ordinate inside a FitsImage.</brief>
		<summary>
		This provides a way of accessing the location of a point in terms of it's co-ordinates along each axis.
		Use it like an array of axes. The indexer helps in providing array like access.
		
		It is used in various activities such an image creation, image buffer access and image information extraction.
		</summary>
		<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
		<seealso cref="FitsLib.FitsImageInfo">FitsImageInfo interface</seealso>
		<seealso cref="FitsLib.Fits">Fits interface</seealso>
		<seealso cref="FitsLib.FitsFactory">FitsFactory class</seealso>
	**/
	public:
		__property long get_Coordinate(int Dim);
		__property void set_Coordinate(int Dim, long Value);
		/**
		<indexer name="Coordinate" access="public" get="true" set="true">
		<brief>Get or set the coordinate of a requested dimension of the point.</brief>
		<summary>This provides a way of accessing the Point as an array of axes.</summary>
		<param name="Dim" type="int">The zero based index of the dimension or the axes of the coordinate whose value is needed.</param>
		<returns type="long">The value of the coordinate.</returns>
		<remarks>
		Consider a 3 dimensional point P(x,y,z), access x with P[0], y with P[1] and so on.
		</remarks>
		</indexer>
		**/

		
		__property int get_Dimensions();
		/**
			<property name="Dimensions" access="public" get="true">
			<brief>Get the number of dimensions of a point.</brief>
			<returns type="int">The number of dimensions of the point.</returns>
			<remarks>If a point can be represented as P(x,y) then it returns 2.</remarks>
			</property>
		**/

		///</interface>
	};

	/* Level 3*/

	
	public __gc __interface FitsData
	{
	/**
		<interface name="FitsData" access="public">
		<brief>The main data container for all fits objects.</brief>
		<summary>
		This is one of the main objects in the context of data manipulations or extraction
		on a FITS file. A FitsTable cell is represented by a FitsData object as well as a
		FitsImage buffer. By their nature both are actually just vectors which hold data of
		one the fits supported data types.
		</summary>
		<remarks> While accessing data, any access to a type that is not stored 
		internaly will raise an exception. If the Info.Type property indicates a Float but you access an Int,
		you are expected to get an exception fired.</remarks>
		<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
	**/
	public: 
		
		 __property FitsDataInfo* get_Info();
		 /**
			<property name="Info" access="public" get="true">
			<brief>Get the information about the contents.</brief>
			<summary>This gives some important information about the data to be accessed.
			In case of unknown data being accesed, it is advised to check the type and size information
			of the data content before proceeding to read or write it.</summary>
			<returns type="FitsLib.FitsDataInfo">The object having information about the data content.</returns>
			</property>
		**/
		
		__property unsigned __int8* get_Byte();
		/**
			<property name="Byte" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="byte[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property short* get_Short();
		/**
			<property name="Short" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="short[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property unsigned short* get_Ushort();
		/**
			<property name="Ushort" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="ushort[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property int* get_Int();
		/**
			<property name="Int" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="int[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property unsigned int* get_Uint();
		/**
			<property name="Uint" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="uint[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property long* get_Long();
		/**
			<property name="Long" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="int[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property unsigned long* get_Ulong();
		/**
			<property name="Ulong" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="uint[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property float* get_Float();
		/**
			<property name="Float" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="float[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property double* get_Double();
		/**
			<property name="Double" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="double[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		
		__property System::String* get_String() __gc[];//Added Mar 13,2003, updated July 29,2003
		/**
			<property name="String" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector as strings. 
				Any change made here will be recorded. 
				Later the same can be used to write back to a table.
			</summary>
			<returns type="string[]">An array of strings.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property __int64* get_LongLong();
		/**
			<property name="LongLong" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="long[]">The data vector.</returns>
			<remarks>Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/

		__property float* get_Complex();
		/**
			<property name="Complex" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="float[]">The data vector. The vector is of twice the size as given by the Length property of the Info property.
			Consider the array to be made of the real followed by the imaginary part of the same complex number.
			</returns>
			<remarks> Say you have 5 complex numbers in a FitsData object <i>d</i>. Then <i>d.complex</i> will have 2 X <i>d.Info.Length</i> elements.
			The elements <i>d.complex[0], d.complex[2] .... d.complex[8]</i> correspond to the real parts of the five complex numbers and 
			the elements <i>d.complex[1], d.complex[3].... d.complex[9]</i> correspond to the imaginary parts of the five complex numbers.

			Also this property Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			<seealso cref="FitsLib.FitsDataInfo.Length">Info.Length property</seealso>
			</property>
		**/

		__property double* get_DoubleComplex();
		/**
			<property name="DoubleComplex" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector. 
				Any change made here will be recorded. 
				Later the same can be used to write back to an image or table.
			</summary>
			<returns type="double[]">The data vector. The vector is of twice the size as given by the Length property of the Info property.
			Consider the array to be made of the real followed by the imaginary part of the same complex number.
			</returns>
			<remarks> Say you have 5 complex numbers in a FitsData object <i>d</i>. Then <i>d.doublecomplex</i> will have 2 X <i>d.Info.Length</i> elements.
			The elements <i>d.doublecomplex[0], d.doublecomplex[2] .... d.doublecomplex[8]</i> correspond to the real parts of the five complex numbers and 
			the elements <i>d.doublecomplex[1], d.doublecomplex[3].... d.doublecomplex[9]</i> correspond to the imaginary parts of the five complex numbers.

			Also this property Fires an exception if the inherent type is different.</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			<seealso cref="FitsLib.FitsDataInfo.Length">Info.Length property</seealso>
			</property>
		**/

		__property System::Array* get_SafeArray();//Added July 30,2003
		/**
			<property name="SafeArray" access="public" get="true">
			<brief>Get the internal data vector.</brief>
			<summary>
				Gets access to a live copy of the data vector as an Array of objects.<br/> 
				Any change made here will be recorded. 
				Later the same can be used to write back to a table.<br/>
				Cast the returned data according to its data type.<br/>
			For example, If the actual data type of an element in the cell's vector is an integer, 
			then just cast it to <bold> (int[]) </bold>.<br/>
			Here is a small line of code :-
			<code><![CDATA[
				FitsData data = img.ReadStrechofPixels(st,end,DataType.Float);
				float[] buff = (float[]) data.SafeArray;
				//Now go ahead and use the contents of the float array or update its value.
				//It is a live copy of the FitsData's internal vector.
				buff[0] = 123.456;

				//Let us now write the data back on to the image
				img.WriteStrechofPixels(st,end,data);

					]]>			
			</code>
			</summary>
			<returns type="System::Array">An array of objects.</returns>
			<remarks>
			Fires an exception if the inherent type is different.
			</remarks>
			<seealso cref="FitsLib.FitsDataInfo.Type">Info.Type property</seealso>
			</property>
		**/
	
		///</interface>

	};

	[System::Reflection::DefaultMemberAttribute("get_Key")]
	public __gc __interface FitsUnitHeader
	{
	/**
		<interface name="FitsUnitHeader" access="public">
		<brief>The header of a FitsUnit.</brief>
		<summary>
		This provides a way of accesing the header keys of FitsUnit.
		It also behaves as a collection of keys. The indexer property helps in providing an
		array like access to the Header Keys.
		</summary>
		<seealso cref="FitsLib.FitsUnit">FitsUnit interface</seealso>
		
	**/
	public:

		__property FitsKeyNameCollection* get_KeyName();
		/**
			<property name="KeyName" access="public" get="true">
			<brief>Get the names of keys in the FitsUnit header.</brief>
			<summary>
				Access the names of all the keys in the header of a FitsUnit.
			</summary>
			<returns type="FitsLib.FitsKeyNameCollection">The collection of keynames.</returns>
						
			</property>
		**/

		__property int get_Count();
		/**
			<property name="Count" access="public" get="true">
			<brief>Get the count of the number of keys in the FitsUnit header.</brief>
			
			<returns type="int">The count of the number of keys in the header.</returns>
						
			</property>
		**/
		
		
		/**
			<indexer name="Key" access="public">
			<brief>Get the key value at a given index in the FitsUnit Header.</brief>
		**/
		__property FitsKeyValue* get_Key(int Index);
		/**
		
			<overload  get="true">
				<summary>
					This provides a way of accessing the Header as an array of keys.
				</summary>
				<param name="Index" type="int">
					The zero based index of the key whose value is needed.
				</param>
				<returns type="FitsLib.FitsKeyValue">The value of the key.</returns>
				<remarks>
					Index is zero based.
				</remarks>
			</overload>
		**/
		
		__property FitsKeyValue* get_Key(System::String* KeyName); // Assume String,as the user does not know
		/**
			<overload  get="true">
				<summary>
					This provides a way of accessing the Header as an array of keys.
				</summary>
				<param name="KeyName" type="System.String">
					The name of the key whose value is needed.
				</param>
				<returns type="FitsLib.FitsKeyValue">The value of the key.</returns>
				<remarks>
					The key value is assumed to be a string as the user didnot request a specific type.
				</remarks>
			</overload>
		**/

		__property FitsKeyValue* get_Key(System::String* KeyName,DataType type);
		__property void set_Key(System::String* KeyName,FitsKeyValue* Value); // Writing the datatype as in Value		
		
		/**
			<overload  get="true" set="true">
				<summary>
					This provides a way of accessing the Header as an array of keys.
				</summary>
				<param name="KeyName" type="System.String">
					The name of the key whose value is needed.
				</param>
				<param name="type" type="FitsLib.DataType">
					The data type in which the value is expected to be.
				</param>
				<returns type="FitsLib.FitsKeyValue">The value of the key.</returns>
				<remarks>
					While assigning a value, a null value will delete the key.
					If type of the key value is not known in advance, it is safe to access it as a string.
				</remarks>
			</overload>
		**/
		
		
		/**
			</indexer>
		**/
		
		// If the Value is NULL, it deletes the key

		void Copy(FitsUnitHeader* Src);
	/**
		<method name="Copy" access="public">
		<brief>Copy the header keys from another FitsUnit</brief>
		<summary>
		This provides a way of duplicating header keys into different FitsUnits.
		</summary>
		<returns type="void"></returns>
		<param name="Src" type="FitsLib.FitsUnitHeader">
			The Source FitsUnit header which has to be copied onto self.
		</param>
		<remarks>
			Even though, it can be done by manually inserting each key 
			from one header to other, this method is more efficient.
		</remarks>
		</method>
	**/

		///</interface>
	};

	public __gc __interface FitsImageInfo
	{
		/**
			<interface name="FitsImageInfo" access="public">
			<brief>The Image's information.</brief>
			<summary>This provides access to the image's information such as the size
			of the image and the Type of the underlying image buffer elements.</summary>
			<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
		**/
	public:
		__property FitsImagePoint* get_Size();
		/**
			<property name="Size" access="public" get="true">
			<brief>Gets the size of the Image.</brief>
			<summary>The size of the image is represented in terms of a point on the image.
			This is the farthest point from the origin in all dimensions. Thus it would contain
			the size of each dimension.
			</summary>
			<returns type="FitsLib.FitsImagePoint">
			The size of the image as the farthest point from the origin.
			</returns>
			</property>
		**/
		__property ImageType get_Type();
			/**
			<property name="Type" access="public" get="true">
			<brief>Gets the type of the Image.</brief>
			<summary>The type of the image informs us about the format in 
			which it is stored in the FITS file.
			</summary>
			<remarks>Note that the image's data buffer can be extracted in a different type 
			than the actual type of the image.</remarks>
			<returns type="FitsLib.ImageType">
			The type of the image as stored in the FITS file.
			</returns>
			</property>
		**/

		/// </interface>
	};

	public __gc __interface FitsColumnInfo
	{
		/**
			<interface name="FitsColumnInfo" access="public">
			<brief>The FitsColumns's information.</brief>
			<summary>This provides access to the column's information such as the name of
			of the column and the information about the underlying data elements.</summary>
			<seealso cref="FitsLib.FitsColumn">FitsColumn interface</seealso>
		**/

	public:
		__property int get_Index();
		/**
			<property name="Index" access="public" get="true">
			<brief>Gets the column number.</brief>
			<returns type="int">
			The column number as stored in the table of the FITS file.
			</returns>
			</property>
		**/
		__property System::String* get_Name();
		/**
			<property name="Name" access="public" get="true">
			<brief>Gets the column name.</brief>
			<returns type="System.String">
			The column name as stored in the table of the FITS file.
			</returns>
			</property>
		**/
		
		__property FitsDataInfo* get_Data();
		/**
			<property name="Data" access="public" get="true">
			<brief>Gets the information about data content.</brief>
			<returns type="FitsLib.FitsDataInfo">
			The information about the data content of the column.
            </returns>
			<remarks>This information can be different from the information in the FITS file.
			This could happen when the user has forced the column to loaded as a different type than the
			underlying type.
			</remarks>
			</property>
		**/
		
		///</interface>
	};


	// Level 4

	public __gc __interface FitsUnit
	{
	/**
		<interface name="FitsUnit" access="public">
		<brief>A Fits Data unit.</brief>
		<summary>This provides access to a particular data unit in a FITS file.
		This can be casted into a FitsTable or a FitsImage depending on it's type.
		</summary>
		<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		<seealso cref="FitsLib.Fits">Fits interface</seealso>
	**/
	public:
		

			__property HduType get_Type();
		/**
			<property name="Type" access="public" get="true">
			<brief>Gets the type of the Data unit.</brief>
			<summary>The type of the data unit informs us whether it is an image or a table.
			</summary>
			<remarks>This information can be used to decide whether to cast a given FitsUnit to FitsImage or FitsTable.</remarks>
			<returns type="FitsLib.HduType">
			The type of the header data unit as stored in the FITS file.
			</returns>
			</property>
		**/
			__property int get_Index();
		/**
			<property name="Index" access="public" get="true">
			<brief>Gets the Data unit number.</brief>
			<returns type="int">
			The data unit number as stored in the FITS file.
			</returns>
			</property>
		**/
			__property FitsUnitHeader* get_Header();
		/**
			<property name="Header" access="public" get="true">
			<brief>Gets the header of the FitsUnit.</brief>
			<summary>The header gives a way of accessing the keys stored in a FitsUnit.
			</summary>
			<returns type="FitsLib.FitsUnitHeader">
			The header of the data unit as stored in the FITS file.
			</returns>
			</property>
		**/

		///</interface>
	};

	public __gc __interface FitsImage
	{
	/**
		<interface name="FitsImage" access="public">
		<brief>A Fits Image.</brief>
		<summary>This provides access to a particular image in a FITS file.
		Operations supported on an image include reading and writing of the buffers.
		New buffers compatible with a given image can also be created.
		</summary>
		<seealso cref="FitsLib.FitsUnit">FitsUnit interface</seealso>		
	**/

	public:
		__property FitsImageInfo* get_Info();
		/**
			<property name="Info" access="public" get="true">
			<brief>Get the information about the contents.</brief>
			<summary>This gives some important information about the image to be accessed.
			In case of unknown image being accesed, it is advised to check the type and size information
			of the image content before proceeding to read or write it.</summary>
			<returns type="FitsLib.FitsImageInfo">The object having information about the image's content.</returns>
			</property>
		**/

		FitsData* ReadStrechOfPixels(FitsImagePoint* Start,FitsImagePoint* End,DataType BufferType);
		/**
		<method name="ReadStrechOfPixels" access="public">
			<brief>Read a portion of the image's buffer</brief>
			<summary>
			This provides a way to extract the data buffer of a FitsImage.
			</summary>
			<returns type="FitsLib.FitsData">
			The object containing the portion of image buffer requested.
			</returns>
			<param name="Start" type="FitsLib.FitsImagePoint">
				The starting point for the buffer to be extracted.
				For this to be same as starting point of the image, specify the point to be
				(1,1,..) as coordinates are 1 based.  
			</param>
			<param name="End" type="FitsLib.FitsImagePoint">
				The ending point for the buffer to be extracted.
				For this to be same as ending point of the image, just pass a copy of the image's size, 
				which is the most extreme point from the origin.  
			</param>
			<param name="BufferType" type="FitsLib.DataType">
				The data type of the elements for the buffer to be extracted.			
			</param>
		</method>
		**/
		

		void WriteStrechOfPixels(FitsImagePoint* Start,FitsImagePoint* End,FitsData* Buffer);
		/**
		<method name="WriteStrechOfPixels" access="public">
			<brief>Write a portion of the image's buffer</brief>
			<summary>
			This provides a way to write into a FitsImage.
			</summary>
			<returns type="void"></returns>
			<param name="Start" type="FitsLib.FitsImagePoint">
				The starting point of the image buffer to be written.
				For this to be same as starting point of the image, specify the point to be
				(1,1,..) as coordinates are 1 based.  
			</param>
			<param name="End" type="FitsLib.FitsImagePoint">
				The ending point for the image buffer to be written.
				For this to be same as ending point of the image, just pass a copy of the image's size, 
				which is the most extreme point from the origin.  
			</param>
			<param name="Buffer" type="FitsLib.FitsData">
				The buffer to be written.			
			</param>
		</method>
		**/

		FitsData* ReadSectionOfPixels(FitsImagePoint* Start,FitsImagePoint* End,DataType BufferType);
		/**
		<method name="ReadSectionOfPixels" access="public">
			<brief>Read a rectangular section of the image's buffer</brief>
			<summary>
			This provides a way to extract the data buffer of a FitsImage.
			</summary>
			<returns type="FitsLib.FitsData">
			The object containing the portion of image buffer requested.
			</returns>
			<param name="Start" type="FitsLib.FitsImagePoint">
				The starting point for the buffer to be extracted.
				For this to be same as starting point of the image, specify the point to be
				(1,1,..) as coordinates are 1 based.  
			</param>
			<param name="End" type="FitsLib.FitsImagePoint">
				The ending point for the buffer to be extracted.
				For this to be same as ending point of the image, just pass a copy of the image's size, 
				which is the most extreme point from the origin.  
			</param>
			<param name="BufferType" type="FitsLib.DataType">
				The data type of the elements for the buffer to be extracted.			
			</param>
		</method>
		**/

		void WriteSectionOfPixels(FitsImagePoint* Start,FitsImagePoint* End,FitsData* Buffer);
		/**
		<method name="WriteSectionOfPixels" access="public">
			<brief>Write a rectangular section of the image's buffer</brief>
			<summary>
			This provides a way to write into a FitsImage.
			The contents of the buffer provided will be written into a rectangular section of the image.
			The rectangle is defined by the Start and End points.
			</summary>
			<returns type="void"></returns>
			<param name="Start" type="FitsLib.FitsImagePoint">
				The starting point of the image buffer to be written.
				For this to be same as starting point of the image, specify the point to be
				(1,1,..) as coordinates are 1 based.  
			</param>
			<param name="End" type="FitsLib.FitsImagePoint">
				The ending point for the image buffer to be written.
				For this to be same as ending point of the image, just pass a copy of the image's size, 
				which is the most extreme point from the origin.  
			</param>
			<param name="Buffer" type="FitsLib.FitsData">
				The buffer to be written.			
			</param>
		</method>
		**/

		// Clean Buffer big enough to hold data from Start to End of this image
		
		
		/**
			<method name="CreateImageBuffer" access="public">
			<brief>Create a clean image buffer</brief>
		**/
			
		FitsData* CreateImageBuffer(DataType Type,FitsImagePoint* Start,FitsImagePoint* End);
		
			/**	<overload>
			<summary>
			This provides a way of creating image buffer compatible with the image.
			The buffer created will be clean.
			</summary>
			<returns type="FitsLib.FitsData">
			The object containing a clean image buffer requested.
			</returns>
			<param name="Type" type="FitsLib.DataType">
				The data type of the elements in the buffer.			
			</param>
			<param name="Start" type="FitsLib.FitsImagePoint">
				The starting point of the image buffer.
				For this to be same as starting point of the image, specify the point to be
				(1,1,..) as coordinates are 1 based.  
			</param>
			<param name="End" type="FitsLib.FitsImagePoint">
				The ending point for the image buffer.
				For this to be same as ending point of the image, just pass a copy of the image's size, 
				which is the most extreme point from the origin.  
			</param>
			
			</overload>
			**/
			
			
			FitsData* CreateImageBuffer(DataType Type,long Length);
			/**	
			<overload>
				<summary>
				This provides a way of creating image buffer compatible with the image.
				The buffer created will be clean.
				</summary>
				<returns type="FitsLib.FitsData">
				The object containing a clean image buffer requested.
				</returns>
				<param name="Type" type="FitsLib.DataType">
					The data type of the elements in the buffer.			
				</param>
				<param name="Length" type="int">
					The length of the image buffer.
				</param>
			
			</overload>
		</method>
		**/

			FitsData* CreateImageSectionBuffer(DataType Type,FitsImagePoint* Start,FitsImagePoint* End);		
			/**
			<method name="CreateImageSectionBuffer" access="public">
			<brief>Create a clean rectangular image buffer</brief>
			<summary>
			This provides a way of creating a rectangular image buffer compatible with the image.
			The buffer created will be clean and big enough to hold the rectangular section.
			</summary>
			<returns type="FitsLib.FitsData">
			The object containing a clean image buffer requested.
			</returns>
			<param name="Type" type="FitsLib.DataType">
				The data type of the elements in the buffer.			
			</param>
			<param name="Start" type="FitsLib.FitsImagePoint">
				The starting point of the image buffer.
				For this to be same as starting point of the image, specify the point to be
				(1,1,..) as coordinates are 1 based.  
			</param>
			<param name="End" type="FitsLib.FitsImagePoint">
				The ending point for the image buffer.
				For this to be same as ending point of the image, just pass a copy of the image's size, 
				which is the most extreme point from the origin.  
			</param>
			</method>
			**/

			///</interface>
	};

	[System::Reflection::DefaultMemberAttribute("CellAt")]
	public __gc __interface FitsTableElementCollection
	{

		/**
		<interface name="FitsTableElementCollection" access="public">
		<brief>Collection of elements in a FitsTable.</brief>
		<summary>This provides a way of accessing the elements of a FitsTable.
		Use it like an two dimensional array of elements. The indexer helps in providing array like access.
		</summary>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		**/

	public:
		/**
			<indexer name="CellAt" access="public">
			<brief>Get the table element at a given location.</brief>
		**/
		__property FitsData* get_CellAt(int Row,int Column);
		__property void set_CellAt(int Row,int Column,FitsData* Cell);
		/**
			<overload  get="true" set="true">
				<summary>
					This provides a way of accessing the table element as an array of rows and columns of cells.
				</summary>
				<param name="Row" type="int">
					The one based index of the row whose element is needed.
				</param>
				<param name="Column" type="int">
					The one based index of the column whose element is needed.
				</param>
				<returns type="FitsLib.FitsData">The requested element of the table.</returns>
				<remarks>
					Index is one based.
				</remarks>
			</overload>
		**/

		__property FitsData* get_CellAt(int Row,System::String* Column);
		__property void set_CellAt(int Row,System::String* Column,FitsData* Cell);
		/**
			<overload  get="true" set="true">
				<summary>
					This provides a way of accessing the table element as an array of rows and columns of cells.
				</summary>
				<param name="Row" type="int">
					The one based index of the row whose element is needed.
				</param>
				<param name="Column" type="System.String">
					The name of the column whose element is needed.
				</param>
				<returns type="FitsLib.FitsData">The requested element of the table.</returns>
				<remarks>
					Index is one based.
				</remarks>
			</overload>
		**/

		__property FitsData* get_CellAt(int Row,int Column,DataType type);
		/**
			<overload  get="true">
				<summary>
					This provides a way of accessing the table element as an array of rows and columns of cells.
				</summary>
				<param name="Row" type="int">
					The one based index of the row whose element is needed.
				</param>
				<param name="Column" type="int">
					The one based index of the column whose element is needed.
				</param>
				<param name="type" type="FitsLib.DataType">
					The data type in which the element is needed.
				</param>
				<returns type="FitsLib.FitsData">The requested element of the table.</returns>
				<remarks>
					Index is one based.
				</remarks>
			</overload>
		**/
		
		__property FitsData* get_CellAt(int Row,System::String* Column,DataType type);
		/**
			<overload  get="true">
				<summary>
					This provides a way of accessing the table element as an array of rows and columns of cells.
				</summary>
				<param name="Row" type="int">
					The one based index of the row whose element is needed.
				</param>
				<param name="Column" type="System.String">
					The name of the column whose element is needed.
				</param>
				<param name="type" type="FitsLib.DataType">
					The data type in which the element is needed.
				</param>
				<returns type="FitsLib.FitsData">The requested element of the table.</returns>
				<remarks>
					Index is one based.
				</remarks>
			</overload>
		</indexer>
		**/
		
	///</interface>
	};

	[System::Reflection::DefaultMemberAttribute("ColumnInfoAt")]
	public __gc __interface FitsColumnInfoCollection
	{
		/**
		<interface name="FitsColumnInfoCollection" access="public">
		<brief>Collection of information of all columns in a FitsTable.</brief>
		<summary>
		This provides a way of accessing the information of the contents of any column in a FitsTable.
		Use it like an array of column informations. The indexer helps in providing array like access.
		</summary>
		<remarks>
		This is a faster way of accessing information of more than one column.
		</remarks>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		**/
		///<indexer name="ColumnInfoAt" access="public">
		///<brief>Gets the information for a given column.</brief>
		__property FitsColumnInfo* get_ColumnInfoAt(System::String* Name);
		/**
			<overload  get="true">
				<summary>
					This provides a way of accessing the column informations as an array of columns.
				</summary>
				<param name="Name" type="System.String">
					The name of the column whose information is needed.
				</param>				
				<returns type="FitsLib.FitsColumnInfo">The requested column's information.</returns>				
			</overload>
		**/
		__property FitsColumnInfo* get_ColumnInfoAt(int Index);
		/**
			<overload  get="true">
				<summary>
					This provides a way of accessing the column informations as an array of columns.
				</summary>
				<param name="Index" type="int">
					The index of the column whose information is needed.
				</param>				
				<returns type="FitsLib.FitsColumnInfo">The requested column's information.</returns>				
			</overload>
		**/
		///</indexer>

		///</interface>
	};

	[System::Reflection::DefaultMemberAttribute("Cell")]
	public __gc __interface FitsColumnCells
	{
		/**
		<interface name="FitsColumnCells" access="public">
		<brief>Collection of all cells in a column of the FitsTable.</brief>
		<summary>
		This provides a way of accessing the cells of a given column in a FitsTable.
		Use it like an array of cells. The indexer helps in providing array like access.
		</summary>
		<remarks>
		This is a faster way of accessing information of more than one cell of the same column.
		</remarks>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		**/
	public:
		__property FitsData* get_Cell(long Row);
		__property void set_Cell(long Row,FitsData* Cell);
		/**
		<indexer name="Cell" access="public" get="true" set="true">
		<brief>Gets a cell in the column.</brief>
		<summary>This provides a way of accessing the column as an array of cells.</summary>
		<param name="Row" type="int">The row index of the cell.</param>
		<returns type="FitsLib.FitsData">The table element.</returns>
		<remarks>Note that the index starts from 1 and not from 0.</remarks>
		</indexer>
		**/

		__property long get_Count();
		/**
			<property name="Count" access="public" get="true">
			<brief>Get the count of the number of Cells in the Column.</brief>
			
			<returns type="int">The count of the cells in the Column.</returns>
						
			</property>
		**/


		///</interface>
	};

	// Level 5

	[System::Reflection::DefaultMemberAttribute("Unit")]
	public __gc __interface FitsUnitCollection
	{
	/**
		<interface name="FitsUnitCollection" access="public">
		<brief>Collection of all the tables and images in a FITS file.</brief>
		<summary>
		This provides a way of accessing a table or an image at a given location in a FITS file.
		Use it like an array of data units. The indexer helps in providing array like access.
		</summary>
		<remarks>
			The unit retrieved can be later casted to a FitsImage or FitsTable according to it's type.
		</remarks>
		<seealso cref="FitsLib.Fits">Fits interface</seealso>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		<seealso cref="FitsLib.FitsImage">FitsImage interface</seealso>
	**/
		public:
			
			__property FitsUnit* get_Unit(int Index);
			/**
				<indexer name="Unit" access="public" get="true">
				<brief>Gets a data unit in the file.</brief>
				<summary>This provides a way of accessing the file as an array of data units.</summary>
				<param name="Index" type="int">The index of the data unit.</param>
				<returns type="FitsLib.FitsUnit">The data unit.</returns>
				<remarks>Note that the index starts from 1 and not from 0.</remarks>
				</indexer>
			**/


			__property int get_Count(void);
			/**
			<property name="Count" access="public" get="true">
			<brief>Get the count of the number of data units in the file.</brief>
			
			<returns type="int">The count of the data units in the file.</returns>
						
			</property>
		**/


		///</interface>
	};

	[System::Reflection::DefaultMemberAttribute("ColumnCells")]
	__gc public __interface FitsColumnCollection
	{
	/**
		<interface name="FitsColumnCollection" access="public">
		<brief>Collection of all the columns in a FitsTable.</brief>
		<summary>
		This provides a way of accessing an entire column in a table.
		Use it like an array of columns. The indexer helps in providing array like access.
		</summary>
		<remarks>
			This provides a faster approach to retrieve multiple cells from the same column than individual cell
			access through FitsUnitCollection.
		</remarks>
		<seealso cref="FitsLib.FitsTable">FitsTable interface</seealso>
		<seealso cref="FitsLib.FitsTable.FitsUnitCollection">FitsUnitCollection interface</seealso>
	**/
	public:

		/**
			<indexer name="ColumnCells" access="public">
			<brief>Gets the entire column.</brief>
		**/

		__property FitsColumnCells* get_ColumnCells(int Column);
		__property void set_ColumnCells(int Column,FitsColumnCells* ColumnCells);
		/**
			<overload  get="true" set="true">
				<summary>
					This provides a way of accessing the tables as array of columns	of cells.
				</summary>
				<param name="Column" type="int">
					The one based index of the column to be accessed.
				</param>
				<returns type="FitsLib.FitsColumnCells">The requested column of the table.</returns>
				<remarks>
					Index is one based.
				</remarks>
			</overload>
		**/

		__property FitsColumnCells* get_ColumnCells(System::String* Column);
		__property void set_ColumnCells(System::String* Column,FitsColumnCells* ColumnCells);
		/**
			<overload  get="true" set="true">
				<summary>
					This provides a way of accessing the tables as array of columns	of cells.
				</summary>
				<param name="Column" type="System.String">
					The name of the column to be accessed.
				</param>
				<returns type="FitsLib.FitsColumnCells">The requested column of the table.</returns>				
			</overload>
		**/

		__property FitsColumnCells* get_ColumnCells(int Column,DataType type);
		/**
			<overload  get="true">
				<summary>
					This provides a way of accessing the tables as array of columns	of cells.
				</summary>
				<param name="Column" type="int">
					The one based index of the column to be accessed.
				</param>
				<param name="type" type="FitsLib.DataType">
					The expected data type of the column elements.
				</param>
				<returns type="FitsLib.FitsColumnCells">The requested column of the table.</returns>
				<remarks>
					Index is one based.
				</remarks>
			</overload>
		**/

		__property FitsColumnCells* get_ColumnCells(System::String* Column,DataType type);
		/**
			<overload  get="true">
				<summary>
					This provides a way of accessing the tables as array of columns	of cells.
				</summary>
				<param name="Column" type="System.String">
					The name of the column to be accessed.
				</param>
				<param name="type" type="FitsLib.DataType">
					The expected data type of the column elements.
				</param>
				<returns type="FitsLib.FitsColumnCells">The requested column of the table.</returns>
				<remarks>
					Index is one based.
				</remarks>
			</overload>
		</indexer>
		**/
		
	///</interface>
	};


	// Level 6

	public __gc __interface FitsTable	
	{
		/**
		<interface name="FitsTable" access="public">
		<brief>A Fits Table.</brief>
		<summary>This provides access to a particular table in a FITS file.
		Operations supported on an table include accessing cells or columns of cells,
		insertion of new columns or rows and accessing information about any column.
		New cells compatible with a given column can also be created.
		</summary>
		<seealso cref="FitsLib.FitsUnit">FitsUnit interface</seealso>		
		**/
	public:
		
		
		__property long get_NumberOfRows();
		/**
			<property name="NumberOfRows" access="public" get="true">
			<brief>Gets the number of rows in the table.</brief>
			<returns type="int">The number of rows in the table.</returns>
			</property>
		**/
		__property int get_NumberOfColumns();
		/**
			<property name="NumberOfColumns" access="public" get="true">
			<brief>Gets the number of columns in the table.</brief>
			<returns type="int">The number of columns in the table.</returns>
			</property>
		**/

		
		__property FitsColumnInfoCollection* get_ColumnInfo();
		/**
			<property name="ColumnInfo" access="public" get="true">
			<brief>Gets the collection of information of columns in the table.</brief>
			<returns type="FitsLib.FitsColumnInfoCollection">The collection of information of columns in the table.</returns>
			</property>
		**/

		__property FitsColumnCollection* get_Column();
		/**
			<property name="Column" access="public" get="true">
			<brief>Gets the collection of columns in the table.</brief>
			<returns type="FitsLib.FitsColumnCollection">The collection of columns in the table.</returns>
			</property>
		**/

		__property FitsTableElementCollection* get_Cell();
		/**
			<property name="Cell" access="public" get="true">
			<brief>Gets the collection of all cells in the table.</brief>
			<returns type="FitsLib.FitsTableElementCollection">The collection of all cells in the table.</returns>
			</property>
		**/


		void InsertColumn(int At, System::String* Name, DataType type, int Repeat);
		/**
		<method name="InsertColumn" access="public">
		<brief>Insert a new column</brief>
		<summary>
		This provides a way of inserting a new column of required configuration into the table.
		</summary>
		<returns type="void"></returns>
		<param name="At" type="int">
			The column after which the new column has to be inserted.
		</param>
		<param name="Name" type="System.String">
			The name of the new column.
		</param>
		<param name="type" type="FitsLib.DataType">
			The data type of elements in a cell of the column.			
		</param>
		<param name="Repeat" type="int">
			The repeat count of elements in a cell of the column.
			When DataType is String, the Repeat is the maximum number of charchters in the string.
		</param>
		</method>
		**/
		void InsertRows(long At, long Count);
		/**
		<method name="InsertRows" access="public">
		<brief>Insert new rows</brief>
		<summary>
		This provides a way of inserting new rows into the table.
		</summary>
		<returns type="void"></returns>
		<param name="At" type="int">
			The row after which the new row has to be inserted.
		</param>
		<param name="Count" type="int">
			The number of rows to be inserted.
		</param>
		</method>
		**/

		int GetColumnIndex(System::String* Name);
		/**
		<method name="GetColumnIndex" access="public">
		<brief>Get the index of a column</brief>
		<summary>
		This provides a way of accessing the index of a column in the table.
		</summary>
		<returns type="int">1 based index of the column.</returns>
		<param name="Name" type="System.String">
			The name of the column.
		</param>
		</method>
		**/

		/**
		<method name="CreateFitsCell" access="public">
		<brief>Create a table cell.</brief>
		**/
		FitsData* CreateFitsCell(int Column);		
		/**
		<overload>
		<returns type="FitsLib.FitsData">The cell created.</returns>
		<param name="Column" type="int">
			The index of the column for which the cell is being created.
		</param>
		</overload>
		**/

		FitsData* CreateFitsCell(System::String* Column);
		/**
		<overload>
		<returns type="FitsLib.FitsData">The cell created.</returns>
		<param name="Column" type="System.String">
			The name of the column for which the cell is being created.
		</param>
		</overload>
		**/

		FitsData* CreateFitsCell(int Column,DataType type);		
		/**
		<overload>
		<returns type="FitsLib.FitsData">The cell created.</returns>
		<param name="Column" type="int">
			The index of the column for which the cell is being created.
		</param>
		<param name="type" type="FitsLib.DataType">
			The data type of the cell being created.
		</param>
		</overload>
		**/
		FitsData* CreateFitsCell(System::String* Column,DataType type);		
		/**
		<overload>
		<returns type="FitsLib.FitsData">The cell created.</returns>
		<param name="Column" type="System.String">
			The name of the column for which the cell is being created.
		</param>
		<param name="type" type="FitsLib.DataType">
			The data type of the cell being created.
		</param>
		</overload>
		**/

        	
		///	</method>

		FitsColumnCells* CreateColumnCells(int Column);
		/**
			<method name="CreateColumnCells" access="public">
			<brief>Create a new holder for writing All Rows in a Column.</brief>
			<param name="Column" type="int">
				The index of column for which the cells holder is required.
			</param>
			<returns type="FitsLib.FitsColumnCells">The holder for all cells in a column.</returns>
			</method>
		**/
		
	///</interface>
	};

	// Level 7

	public __gc __interface Fits // For Outside World
	{
		/**
		<interface name="Fits" access="public">
		<brief>A FITS file object.</brief>
		<summary>This provides access to a operate on a FITS file.
		Operations supported include accessing tables, images, headers and addition of new tables and images.
		</summary>
		<seealso cref="FitsLib.FitsFactory">FitsFactory class</seealso>		
		**/
	public:
		
		// File IO operations
			void Open(System::String* FileName,FileMode Mode); // should load Brief info on all units too
			/**
			<method name="Open" access="public">
			<brief>Opens a FITS file</brief>
			<returns type="void"></returns>
			<param name="FileName" type="System.String">
				The name of the file.
			</param>
			<param name="Mode" type="FitsLib.FileMode">
				The mode of opening the file.
			</param>
			</method>
			**/
			void Close();
			/**
			<method name="Close" access="public">
			<brief>Close a FITS file</brief>
			<returns type="void"></returns>
			</method>
			**/

		// Adding new Units
			FitsImage* AddNewImage(ImageType type,FitsImagePoint* Size);
			/**
			<method name="AddNewImage" access="public">
			<brief>Add a new image to a fits file</brief>
			<returns type="FitsLib.FitsImage">The new image added into the file.</returns>
			<param name="type" type="FitsLib.ImageType">
				The type of the image to be inserted.
			</param>
			<param name="Size" type="FitsLib.FitsImagePoint">
				The size of the image expressed as the extreme point in all dimensions.
			</param>
			</method>
			**/

			FitsTable* AddNewTable(HduType TableType);
			/**
			<method name="AddNewTable" access="public">
			<brief>Add a new table to a fits file</brief>
			<returns type="FitsLib.FitsTable">The new table added into the file.</returns>
			<param name="TableType" type="FitsLib.TableType">
				The type of the table to be inserted.
			</param>
			<remarks>Creation of new Ascii table is not supported.
			</remarks>
			</method>
			**/

			FitsUnit* CopyUnit(FitsUnit* Src);// Should check case where src and desst are same file
			/**
			<method name="CopyUnit" access="public">
			<brief>Copy a table or image from another file</brief>
			<returns type="FitsLib.FitsUnit">The new unit copied into the file.</returns>
			<param name="Src" type="FitsLib.FitsUnit">
				The source image or table.
			</param>
			</method>
			**/
			__property FitsUnitCollection* get_Units();
			/**
			<property name="Units" access="public" get="true">
			<brief>Gets the collection of all tables and images in the file.</brief>
			<returns type="FitsLib.FitsUnitCollection">The collection of all tables and images.</returns>
			</property>
		**/

		///</interface>			
	};


	/*All Classes*/
	/* Level 1*/

	// <summary>
	// Exception thrown on invalid or failed operations on Fits files
	// </summary>
	// <see cref='System::Exception'/>

	public __gc class FitsException : public System::Exception
	{	
		/**
		<class name="FitsException" access="public">
		<brief>Exceptions raised in FitsLib operations.</brief>
		<summary>These are exceptions thrown on invalid or failed operations on Fits files.
		</summary>
		<seealso cref="FitsLib.FitsError">FitsError enum.</seealso>		
		**/
	public:
		// constructor
		FitsException(FitsError Err,int exErr);
		/**
			<method name="FitsException" access="public">
			<brief>Class Constructor.</brief>
			<returns type="void"></returns>
			<param name="Err" type="FitsLib.FitsError">
				The error code.
			</param>
			<param name="exErr" type="int">
				The extended error code, which makes it more precise to locate the error.
			</param>
			</method>
		**/
		
		// Get the String representing the error
		System::String* ToString();
		/**
			<method name="ToString" access="public">
			<brief>The error represented as a string.</brief>
			<returns type="System.String">The error string. This includes full details of the error.</returns>
			</method>
		**/

		// <value>Get the errorcode</value>
		// <see cref="FitsLib::FitsError"/>

        __property FitsError get_Error();
		/**
			<property name="Error" access="public" get="true">
			<brief>Gets the error code.</brief>
			<returns type="FitsLib.FitsError">The error code.</returns>
			</property>
		**/

		// <value>Get the extended errorcode</value>
		__property int get_ExtendedError();
		/**
			<property name="ExtendedError" access="public" get="true">
			<brief>Gets the extended error code.</brief>
			<returns type="int">The extended error code.</returns>
			</property>
		**/

		static bool IsFitsException(System::Exception* e);
		/**
			<method name="IsFitsException" access="public static">
			<brief>Verifies whether a given exception is FitsException.</brief>
			<returns type="bool">True for FitsException and False otherwise.</returns>
			<remarks>
				This is an useful function in checking for a FitsException whenever an exception is fired.
			</remarks>
			</method>
		**/

	protected:
		int m_nExtendedError;
		FitsError m_obError;

		///</class>
	};
	

	public __gc class FitsFactory
	{
		/**
		<class name="FitsFactory" access="public">
		<brief>A factory for creating new interface objects.</brief>
		<summary>The factory helps in creating new interface to a fits file. It also provides methods to create an Image Point,
		a header key value.
		It also provides a method to convert unicode strings to Fits Strings. 
		This is useful in writing back string data into the FITS files.
		</summary>
		**/

	public:
		static Fits* CreateFits();
		/**
			<method name="CreateFits" access="public static">
			<brief>Create a new interface to a FITS File.</brief>
			<returns type="FitsLib.Fits">An interface to access FITS files.</returns>
			</method>
		**/

		static FitsImagePoint* CreateImagePoint(int Dimensions);
		/**
			<method name="CreateImagePoint" access="public static">
			<brief>Create a new Fits Image point.</brief>
			<param name="Dimensions" type="int">
				The dimensions of the image for which the point is being created.
			</param>
			<returns type="FitsLib.FitsImagePoint">An image point.</returns>
			</method>
		**/

		static FitsKeyValue* CreateKeyValue(DataType type);
		/**
			<method name="CreateKeyValue" access="public static">
			<brief>Create a new Fits Unit Header's key value.</brief>
			<param name="type" type="FitsLib.DataType">
				The data type of the key value being created.
			</param>
			<returns type="FitsLib.FitsKeyValue">The key value created.</returns>
			</method>
		**/
			
		
	///</class>
	};
///</namespace> <!--FitsLib -->   
}

/**
</project> <!--FitsLib -->
**/