//------------------------------------------------------------------------+
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
// = FileName	:   T3DimArray类
// = Version	:   ver1.0
// = Author		:   xlc,cet
// = CreateDate	:   2011-06-23
// = Description:   分区大小模板类声明和实现
// = Maintainers: 
//                  
//------------------------------------------------------------------------+
#ifndef _T3DIMARRAY_H_
#define _T3DIMARRAY_H_

#ifndef __QUADRANTINFO_H__
#include "QuadrantInfo.h"
#endif

template<class T>
class T3DimArray
{
public:

	T3DimArray();
	~T3DimArray();
	T3DimArray<T>& operator= (const T3DimArray &arr);

public:

	// 将三维分成8个区域
	enum QUADRANT
	{
		kNONE	= -1,   // 无法确定
		kXYZ	= 0,	// X，Y，Z轴同为正向的区域
		k_XYZ	= 1,	// X轴负向，Y，Z轴同为正向的区域
		k_X_YZ	= 2,	// Z轴正向，X，Y轴同为负向的区域
		kX_YZ	= 3,	// Y轴负向，X，Z轴同为正向的区域
		kXY_Z	= 4,	// Z轴负向，X，Y轴同为正向的区域
		k_XY_Z	= 5,	// Y轴正向，X，Z轴同为负向的区域
		k_X_Y_Z = 6,	// X，Y，Z轴同为负向的区域
		kX_Y_Z  = 7,	// X轴正向，Y，Z轴同为负向的区域
	};

	//初始化内存单元
	inline void InitArray(int nX = 0, int nY = 0, int nZ = 0, int nXSize = 0,int nYSize = 0,int nZSize = 0);
	//设置分区表最小点(分区表原点)
	inline void SetOri(int nX, int nY, int nZ);
	//添加分区
	void AddArray(int nX, int nY, int nZ, int nXSize,int nYSize,int nZSize);
	//设置(nX,nY,nZ)单元内容
	void SetValue(int nX,int nY,int nZ,const T& val);
	//获取(nX,nY,nZ)单元内容
	T* GetValue(int nX,int nY,int nZ) const;
	//释放
	void Release();
	//创建
	void Create();
	//是否创建标记
	bool IsCreated()const;
	//分区表X方向长度
	inline int GetXSize() const;
	//分区表Y方向长度
	inline int GetYSize() const;
	//分区表Z方向长度
	inline int GetZSize() const; 
	//获取原点
	inline void GetOrigin(int &nX, int &nY, int &nZ) const;
	//获取某一区域索引最小值和最大值(内部索引)
	void GetXYZ(int &nMinX, int &nMinY, int &nMinZ, int &nMaxX, int &nMaxY, int &nMaxZ, int nQuadrant) const;
	//获取某一区域xyz索引的值(内部索引)
	T* GetValue(int nX, int nY, int nZ, int nQuadrant) const;

private:

	//释放某一区域的数组资源
	void Release(T ***m_pArray, int nQuadrant);
	// 根据xyz值创建数组
	void CreateArray(T*** &pArr, int nMinX, int nMinY, int nMinZ, int nMaxX, int nMaxY, int nMaxZ);
	// 处理根据基点索引和size确定索引值
	int GetIndex(int nBaseIndex, int nSize) const;
	// 根据xyz值确定区域(不包括在xyz轴上的点)
	int GetQuadrant(int nX, int nY, int nZ) const;
	// 判断点是否在区域内
	bool IsInQuadrant(int nX, int nY, int nZ, int nQuadrant) const;
	// 根据xyz获取区域指针
	T*** GetQuadrantPtr(int nX, int nY, int nZ) const;
	// 获取当前对象的数据
	void GetCurData(std::map<int,QuadrantInfo<T> > &data);
	// 复制
	void Copy(const T3DimArray &arr, int nQuadrant);

private:
	int m_nXSize;			//分区表X方向长度
	int m_nYSize;			//分区表Y方向长度
	int m_nZSize;			//分区表Z方向长度
	int m_nXOri;			//分区表最小点X坐标
	int m_nYOri;			//分区表最小点Y坐标
	int m_nZOri;			//分区表最小点Z坐标

	T ***m_pArrayXYZ;		//X，Y，Z轴同为正向的区域
	T ***m_pArray_XYZ;		//X轴负向，Y，Z轴同为正向的区域
	T ***m_pArray_X_YZ;		//Z轴正向，X，Y轴同为负向的区域
	T ***m_pArrayX_YZ;		//Y轴负向，X，Z轴同为正向的区域
	T ***m_pArrayXY_Z;		//Z轴负向，X，Y轴同为正向的区域
	T ***m_pArray_XY_Z;		//Y轴正向，X，Z轴同为负向的区域
	T ***m_pArray_X_Y_Z;	//X，Y，Z轴同为负向的区域
	T ***m_pArrayX_Y_Z;		//X轴正向，Y，Z轴同为负向的区域

	bool m_bCreated;        //表是否以创建
};

template<class T>
T3DimArray<T>::T3DimArray()
{
	m_pArrayXYZ = NULL;
	m_pArray_XYZ = NULL;
	m_pArray_X_YZ = NULL;
	m_pArrayX_YZ = NULL;
	m_pArrayXY_Z = NULL;
	m_pArray_XY_Z = NULL;
	m_pArray_X_Y_Z = NULL;
	m_pArrayX_Y_Z = NULL;
	m_bCreated = false;
	InitArray();
}

template<class T>
T3DimArray<T>::~T3DimArray()
{
	if (m_bCreated)
	{
		Release();
	}
}

template<class T>
T3DimArray<T>& T3DimArray<T>::operator=( const T3DimArray &arr )
{
	if (!arr.m_bCreated)
	{
		return *this;
	}

	if (this == &arr)
	{
		return *this;
	}
	
	// 删除原有资源
	if(m_bCreated)
	{
		Release();
	}

	// 重建表
	m_nXSize = arr.m_nXSize;
	m_nYSize = arr.m_nYSize;
	m_nZSize = arr.m_nZSize;
	m_nXOri = arr.m_nXOri;
	m_nYOri = arr.m_nYOri;
	m_nZOri = arr.m_nZOri;
	Create();

	// 复制
	Copy(arr, kXYZ);
	Copy(arr, k_XYZ);
	Copy(arr, k_X_YZ);
	Copy(arr, kX_YZ);
	Copy(arr, kXY_Z);
	Copy(arr, k_XY_Z);
	Copy(arr, k_X_Y_Z);
	Copy(arr, kX_Y_Z);
	return *this;
}

template<class T>
void T3DimArray<T>::InitArray( int nX /*= 0*/, int nY /*= 0*/, int nZ /*= 0*/, int nXSize /*= 0*/,int nYSize /*= 0*/,int nZSize /*= 0*/ )
{
	m_nXOri = nX;
	m_nYOri = nY;
	m_nZOri = nZ;
	m_nXSize = nXSize;
	m_nYSize = nYSize;
	m_nZSize = nZSize;
}

template<class T>
void T3DimArray<T>::SetOri( int nX, int nY, int nZ )
{
	m_nXOri = nX;
	m_nYOri = nY;
	m_nZOri = nZ;
}

template<class T>
void T3DimArray<T>::AddArray( int nX, int nY, int nZ, int nXSize,int nYSize,int nZSize )
{
	// 检查区域是否未变化
	if (nX == m_nXOri && nY == m_nYOri && nZ == m_nZOri
		&& nXSize == m_nXSize && nYSize == m_nYSize && nZSize == m_nZSize)
	{
		return;
	}


	// 获得原来的数据
	std::map<int,QuadrantInfo<T> > mapOrgin;
	GetCurData(mapOrgin);
	
	// 设置新数据
	m_nXOri = nX;
	m_nYOri = nY;
	m_nZOri = nZ;
	m_nXSize = nXSize;
	m_nYSize = nYSize;
	m_nZSize = nZSize;

	// 重建表
	m_pArrayXYZ = NULL;
	m_pArray_XYZ = NULL;
	m_pArray_X_YZ = NULL;
	m_pArrayX_YZ = NULL;
	m_pArrayXY_Z = NULL;
	m_pArray_XY_Z = NULL;
	m_pArray_X_Y_Z = NULL;
	m_pArrayX_Y_Z = NULL;
	Create();

	// 获得新数据
	std::map<int,QuadrantInfo<T> > mapNew;
	GetCurData(mapNew);

	// 将原有数据存入改变后的容器呢
	int nQuadrant = -1; 
	T*** pOrigin = NULL;
	T*** pNew = NULL;
	std::map<int,QuadrantInfo<T> >::iterator it1, it2;
	for (it1 = mapOrgin.begin(); it1 != mapOrgin.end(); it1++)
	{
		it2 = mapNew.find(it1->first);
		if (it2 != mapNew.end())
		{
			it2->second.CopyData(it1->second);
		}
	}

	 // 删除原有资源
	for (it1 = mapOrgin.begin(); it1 != mapOrgin.end(); it1++)
	{
		it1->second.Delete();
	}
}

template<class T>
void T3DimArray<T>::SetValue( int nX,int nY,int nZ,const T& val )
{
	T*** pRes = GetQuadrantPtr(nX, nY, nZ); 
	if (pRes != NULL)
	{
		pRes[abs(nX) - 1][abs(nY) - 1][abs(nZ) - 1] = val;
	}
}

template<class T>
T* T3DimArray<T>::GetValue( int nX,int nY,int nZ ) const
{
	T* pRet = NULL;
	T*** pRes = GetQuadrantPtr(nX, nY, nZ);
	if (pRes != NULL)
	{
		pRet = &pRes[abs(nX) - 1][abs(nY) - 1][abs(nZ) - 1];
	}
	return pRet;
}

template<class T>
void T3DimArray<T>::Release()
{
	m_bCreated = false;
	Release(m_pArrayXYZ, kXYZ);
	Release(m_pArray_XYZ, k_XYZ);
	Release(m_pArray_X_YZ, k_X_YZ);
	Release(m_pArrayX_YZ, kX_YZ);
	Release(m_pArrayXY_Z, kXY_Z);
	Release(m_pArray_XY_Z, k_XY_Z);
	Release(m_pArray_X_Y_Z, k_X_Y_Z);
	Release(m_pArrayX_Y_Z, kX_Y_Z);
	m_pArrayXYZ = NULL;
	m_pArray_XYZ = NULL;
	m_pArray_X_YZ = NULL;
	m_pArrayX_YZ = NULL;
	m_pArrayXY_Z = NULL;
	m_pArray_XY_Z = NULL;
	m_pArray_X_Y_Z = NULL;
	m_pArrayX_Y_Z = NULL;
}

template<class T>
void T3DimArray<T>::Create()
{
	m_bCreated = true;
	// 按各分区创建数组 
	int nMinX = 0, nMinY = 0, nMinZ = 0; // 某区域索引最小值
	int nMaxX = 0, nMaxY = 0, nMaxZ = 0; // 某区域索引最大值

	// X，Y，Z轴同为正向的区域
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, kXYZ);
	CreateArray(m_pArrayXYZ, nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ);

	// X轴负向，Y，Z轴同为正向的区域
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, k_XYZ);
	CreateArray(m_pArray_XYZ, nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ);

	// Z轴正向，X，Y轴同为负向的区域
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, k_X_YZ);
	CreateArray(m_pArray_X_YZ, nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ);

	// Y轴负向，X，Z轴同为正向的区域
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, kX_YZ);
	CreateArray(m_pArrayX_YZ, nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ);

	// Z轴负向，X，Y轴同为正向的区域
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, kXY_Z);
	CreateArray(m_pArrayXY_Z, nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ);

	// Y轴正向，X，Z轴同为负向的区域
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, k_XY_Z);
	CreateArray(m_pArray_XY_Z, nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ);

	// X，Y，Z轴同为负向的区域
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, k_X_Y_Z);
	CreateArray(m_pArray_X_Y_Z, nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ);

	// X轴正向，Y，Z轴同为负向的区域
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, kX_Y_Z);
	CreateArray(m_pArrayX_Y_Z, nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ);
}

template<class T>
int T3DimArray<T>::GetXSize() const
{
	return m_nXSize;
}

template<class T>
int T3DimArray<T>::GetYSize() const
{
	return m_nYSize;
}

template<class T>
int T3DimArray<T>::GetZSize() const
{
	return m_nZSize;
}

template<class T>
void T3DimArray<T>::GetOrigin( int &nX, int &nY, int &nZ ) const
{
	nX = m_nXOri;
	nY = m_nYOri;
	nZ = m_nZOri;
}

template<class T>
void T3DimArray<T>::Release(T ***m_pArray, int nQuadrant)
{
	if (m_pArray != NULL)
	{
		int nMinX = 0, nMinY = 0, nMinZ = 0; // 某区域索引最小值
		int nMaxX = 0, nMaxY = 0, nMaxZ = 0; // 某区域索引最大值
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, nQuadrant);

		// 删除z
		for (int x = nMinX; x < nMaxX + 1; x++)
		{
			for (int y = nMinY; y < nMaxY + 1; y++)
			{
				delete[] m_pArray[x][y];
			}
		}

		// 删除y
		for (x = nMinX; x < nMaxX + 1; x++)
		{
			delete[] m_pArray[x];
		}

		// 删除x
		delete[] m_pArray;
	}
}

template<class T>
void T3DimArray<T>::GetXYZ(int &nMinX, int &nMinY, int &nMinZ, int &nMaxX, int &nMaxY, int &nMaxZ, int nQuadrant) const
{
	// 其中最大值XYZ表示某区域索引最大值,最小值xyz表示在某区域的索引的最小值
	nMinX = 0;
	nMinY = 0;
	nMinZ = 0;
	nMaxX = 0;
	nMaxY = 0;
	nMaxZ = 0;
	switch(nQuadrant)
	{
	case kXYZ:		// X，Y，Z轴同为正向的区域
		{
			int nX = GetIndex(m_nXOri, m_nXSize), nY = GetIndex(m_nYOri, m_nYSize), nZ = GetIndex(m_nZOri, m_nZSize); // 长方体顶面右上点
			if (m_nXOri >= 0 && m_nYOri >= 0 && m_nZOri >= 0)										   // 长方体底面左下点在该区域内
			{
				nMinX = m_nXOri;
				nMinY = m_nYOri;
				nMinZ = m_nZOri;
				nMaxX = nX;
				nMaxY = nY;
				nMaxZ = nZ;
			}
			else if (nX >= 0 && nY >= 0 && nZ >= 0) // 长方体顶面右上点在该区域
			{
				nMaxX = nX;
				nMaxY = nY;
				nMaxZ = nZ; 
				if (m_nXOri < 0)
				{
					nMinX = 0;
				}
				else
				{
					nMinX = m_nXOri;
				}

				if (m_nYOri < 0)
				{
					nMinY = 0;
				} 
				else
				{
					nMinY = m_nYOri;
				}

				if (m_nZOri < 0)
				{
					nMinZ = 0;
				}
				else
				{
					nMinZ = m_nZOri;
				}
			}
			break;
		}
	case k_XYZ:		// X轴负向，Y，Z轴同为正向的区域
		{
			int nX1 = m_nXOri, nY1 = GetIndex(m_nYOri, m_nYSize), nZ1 = GetIndex(m_nZOri, m_nZSize); // 长方体顶面左上点
			int nX2 = GetIndex(m_nXOri, m_nXSize), nY2 = m_nYOri, nZ2 = m_nZOri;				     // 长方体底面右下点
			if (nX2 <= 0 && nY2 >= 0 && nZ2 >= 0)
			{
				nMinX = abs(nX2); 
				nMinY = abs(nY2);
				nMinZ = abs(nZ2);
				nMaxX = abs(nX1);
				nMaxY = abs(nY1);
				nMaxZ = abs(nZ1);
			}
			else if (nX1 <= 0 && nY1 >= 0 && nZ1 >= 0)
			{
				nMaxX = abs(nX1);
				nMaxY = abs(nY1);
				nMaxZ = abs(nZ1);

				if (nX2 > 0)
				{
					nMinX = 0;
				}
				else
				{
					nMinX = abs(nX2);
				}

				if (nY2 < 0)
				{
					nMinY = 0;
				}
				else
				{
					nMinY = nY2;
				}

				if (nZ2 < 0)
				{
					nMinZ = 0;
				}
				else
				{
					nMinZ = nZ2;
				}

			}
			break;
		}
	case k_X_YZ:	// Z轴正向，X，Y轴同为负向的区域
		{
			int nX1 = GetIndex(m_nXOri, m_nXSize), nY1 = GetIndex(m_nYOri, m_nYSize), nZ1 = m_nZOri; // 长方体底面右上点
			int nX2 = m_nXOri, nY2 = m_nYOri, nZ2 = GetIndex(m_nZOri, m_nZSize);				   // 长方体顶面左下点
			if (nX1 <= 0 && nY1 <= 0 && nZ1 >= 0)
			{
				nMinX = abs(nX1);
				nMinY = abs(nY1);
				nMinZ = abs(nZ1);
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
			}
			else if (nX2 <= 0 && nY2 <= 0 && nZ2 >= 0)
			{
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
				if (nX1 > 0)
				{
					nMinX = 0;
				}
				else
				{
					nMinX = abs(nX1);
				}

				if (nY1 > 0)
				{
					nMinY = 0;
				}
				else
				{
					nMinY = abs(nY1);
				}

				if (nZ1 < 0)
				{
					nMinZ = 0;
				}
				else
				{
					nMinZ = nZ1;
				}
			}

			break;
		}
	case kX_YZ:		// Y轴负向，X，Z轴同为正向的区域
		{
			int nX1 = m_nXOri, nY1 = GetIndex(m_nYOri, m_nYSize), nZ1 = m_nZOri;					// 长方体底面左上点
			int nX2 = GetIndex(m_nXOri, m_nXSize), nY2= m_nYOri, nZ2 = GetIndex(m_nZOri, m_nZSize);	// 长方体顶面右下点
			if (nX1 >= 0 && nY1 <= 0 && nZ1 >= 0)
			{
				nMinX = nX1;
				nMinY = nY1;
				nMinZ = nZ1;
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
			}
			else if (nX2 >= 0 && nY2 <= 0 && nZ2 >= 0)
			{
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
				if (nX1 < 0)
				{
					nMinX = 0;
				} 
				else
				{
					nMinX = nX1;
				}

				if (nY1 > 0)
				{
					nMinY = 0;
				} 
				else
				{
					nMinY = abs(nY1);
				}

				if (nZ1 < 0)
				{
					nMinZ = 0;
				}
				else 
				{
					nMinZ = nZ1;
				}
			}
			break;
		}
	case kXY_Z:		// Z轴负向，X，Y轴同为正向的区域
		{
			int nX1 = m_nXOri, nY1 = m_nYOri, nZ1 = GetIndex(m_nZOri, m_nZSize);					// 长方体顶面左下点
			int nX2 = GetIndex(m_nXOri, m_nXSize), nY2 = GetIndex(m_nYOri, m_nYSize), nZ2 = m_nZOri;  // 长方体底面右下点
			if (nX1 >= 0 && nY1 >= 0 && nZ1 <= 0)
			{
				nMinX = abs(nX1);
				nMinY = abs(nY1);
				nMinZ = abs(nZ1);
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);

			}
			else if (nX2 >= 0 && nY2 >= 0 && nZ2 <= 0)
			{
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
				if (nX1 < 0)
				{
					nMinX = 0;
				}
				else
				{
					nMinX = nX1;
				}

				if (nY1 < 0)
				{
					nMinY = 0;
				} 
				else
				{
					nMinY = nY1;
				}

				if (nZ1 > 0)
				{
					nMinZ = 0;
				} 
				else
				{
					nMinZ = abs(nZ1);
				}
			}
			break;
		}
	case k_XY_Z:	// Y轴正向，X，Z轴同为负向的区域
		{
			int nX1 = m_nXOri, nY1 =  GetIndex(m_nYOri, m_nYSize), nZ1 = GetIndex(m_nZOri, m_nZSize); // 长方体顶面左上点
			int nX2 = GetIndex(m_nXOri, m_nXSize), nY2 = m_nYOri, nZ2 = m_nZOri;					  // 长方体底面右下点
			if (nX1 >= 0 && nY1 <= 0 && nZ1 <= 0)
			{
				nMinX = abs(nX1);
				nMinY = abs(nY1);
				nMinZ = abs(nZ1);
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
			} 
			else if (nX2 >= 0 && nY2 <= 0 && nZ2 <= 0)
			{
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
				if (nX1 < 0)
				{
					nMinX = 0;
				}
				else
				{
					nMinX = abs(nX1);
				}

				if (nY1 > 0)
				{
					nMinY = 0;
				} 
				else
				{
					nMinY = abs(nY1);
				}

				if (nZ1 > 0)
				{
					nMinZ = 0;
				} 
				else
				{
					nMinZ = abs(nZ1);
				}
			}
			break;
		}
	case k_X_Y_Z:	// X，Y，Z轴同为负向的区域
		{
			int nX1 = GetIndex(m_nXOri, m_nXSize), nY1 = GetIndex(m_nYOri, m_nYSize), nZ1 = GetIndex(m_nZOri, m_nZSize);	// 长方体顶面右上点
			int nX2 = m_nXOri, nY2 = m_nYOri, nZ2 = m_nZOri;												// 长方体底面左下点
			if (nX1 <= 0 && nY1 <= 0 && nZ1 <= 0)
			{
				nMinX = abs(nX1);
				nMinY = abs(nY1);
				nMinZ = abs(nZ1);
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
			} 
			else if (nX2 <= 0 && nY2 <= 0 && nZ2 <= 0)
			{
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);

				if (nX1 > 0)
				{
					nMinX = 0;
				} 
				else
				{
					nMinX = abs(nX1);
				}

				if (nY1 > 0)
				{
					nMinY = 0;
				} 
				else
				{
					nMinY = abs(nY1);
				}

				if (nZ1 > 0)
				{
				    nMinZ = 0;
				} 
				else
				{
					nMinZ = abs(nZ1);
				}
			}
			break;
		}
	case kX_Y_Z:	// X轴正向，Y，Z轴同为负向的区域
		{
			int nX1 = m_nXOri, nY1 = GetIndex(m_nYOri, m_nYSize), nZ1 = GetIndex(m_nZOri, m_nZSize);  // 长方体顶面左上点
			int nX2 = GetIndex(m_nXOri, m_nXSize), nY2 = m_nYOri, nZ2 = m_nZOri;					// 长方体底面右下点
			if (nX1 >= 0 && nY1 <= 0 && nZ1 <= 0)
			{
				nMinX = abs(nX1);
				nMinY = abs(nY1);
				nMinZ = abs(nZ1);
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
			} 
			else if (nX2 >= 0 && nY2 <= 0 && nZ2 <= 0)
			{
				nMaxX = abs(nX2);
				nMaxY = abs(nY2);
				nMaxZ = abs(nZ2);
				if (nX1 < 0)
				{
					nMinX = 0;
				} 
				else
				{
					nMinX = abs(nX1);
				}

				if (nY1 > 0)
				{
					nMinY = 0;
				} 
				else
				{
					nMinY = abs(nY1);
				}

				if (nZ1 > 0)
				{
					nMinZ = 0;
				} 
				else
				{
					nMinZ = abs(nZ1);
				}
			}

			break;
		}
	default:
		{
			break;
		}
	}
}

template<class T>
void T3DimArray<T>::CreateArray(T*** &pArr, int nMinX, int nMinY, int nMinZ, int nMaxX, int nMaxY, int nMaxZ)
{
	pArr = NULL;
	if (nMaxZ - nMinZ < 0 || nMaxY - nMinY < 0 || nMaxX - nMinX < 0)
	{
		return;
	}

	pArr = new T**[nMaxX + 1];
	for (int i = 0; i < nMaxX + 1; i++)		// 初始化指针
	{
		pArr[i] = NULL;
	}

	for (int x = nMinX; x < nMaxX + 1; x++)
	{
		pArr[x] = new T*[nMaxY + 1];
		for(i = 0; i < nMaxY + 1; i++)  // 初始化指针
		{
			pArr[x][i] = NULL;
		}
	}

	for (x = nMinX; x < nMaxX + 1; x++)
	{
		for (int y = nMinY; y < nMaxY + 1; y++)
		{
			pArr[x][y] = new T[nMaxZ + 1];
		}
	}
}

template<class T>
int T3DimArray<T>::GetIndex(int nBaseIndex, int nSize) const
{
	int nIndex = 0;
	if (nBaseIndex < 0 && abs(nBaseIndex) + 1 < nSize)
	{
		nIndex = nBaseIndex + nSize - 1; // 减2因有两个为0的索引（分别在两个区域内） 考虑到扩充时原表的索引需完全在新表中的误差 还是减1
	}
	else if (nBaseIndex < 0 && abs(nBaseIndex) >= nSize)
	{
		nIndex = nBaseIndex + nSize + 1;
	}
	else
	{
		nIndex = nBaseIndex + nSize - 1;
	}
	return nIndex;
}

template<class T>
int T3DimArray<T>::GetQuadrant(int nX, int nY, int nZ) const
{
	if (nX > 0 && nY > 0 && nZ > 0)
	{
		return kXYZ;
	}

	if (nX < 0 && nY > 0 && nZ > 0)
	{
		return k_XYZ;
	}

	if (nX < 0 && nY < 0 && nZ > 0)
	{
		return k_X_YZ;
	}

	if (nX > 0 && nY < 0 && nZ > 0)
	{
		return kX_YZ;
	}

	if (nX > 0 && nY > 0 && nZ < 0)
	{
		return kXY_Z;
	}

	if (nX < 0 && nY > 0 && nZ < 0)
	{
		return k_XY_Z;
	}

	if (nX < 0 && nY < 0 && nZ < 0)
	{
		return k_X_Y_Z;
	}

	if (nX > 0 && nY < 0 && nZ < 0)
	{
		return kX_Y_Z;
	}

	return kNONE;
}

template<class T>
bool T3DimArray<T>::IsInQuadrant(int nX, int nY, int nZ, int nQuadrant) const
{
	nX = abs(nX) - 1;
	nY = abs(nY) - 1;
	nZ = abs(nZ) - 1;
	int nMinX = 0, nMinY = 0, nMinZ = 0;
	int nMaxX = 0, nMaxY = 0, nMaxZ = 0;
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, nQuadrant);
	if (nMinX <= nX && nMaxX >= nX
		&& nMinY <= nY && nMaxY >= nY
		&& nMinZ <= nZ && nMaxZ >= nZ)
	{
		return true;
	}

	return false;
}

template<class T>
T*** T3DimArray<T>::GetQuadrantPtr(int nX, int nY, int nZ) const
{
	T*** pRet = NULL;
	int nQuarant = GetQuadrant(nX, nY, nZ);
	switch(nQuarant)
	{
	case kXYZ:
		{
			if (IsInQuadrant(nX, nY, nZ , kXYZ))
			{
				pRet = m_pArrayXYZ;
			}
			break;
		}
	case k_XYZ:
		{
			if (IsInQuadrant(nX, nY, nZ , k_XYZ))
			{
				pRet = m_pArray_XYZ;
			}
			break;
		}
	case k_X_YZ:
		{
			if (IsInQuadrant(nX, nY, nZ , k_X_YZ))
			{
				pRet = m_pArray_X_YZ;
			}
			break;
		}
	case kX_YZ:
		{
			if (IsInQuadrant(nX, nY, nZ , kX_YZ))
			{
				pRet = m_pArrayX_YZ;
			}
			break;
		}
	case kXY_Z:
		{
			if (IsInQuadrant(nX, nY, nZ , kXY_Z))
			{
				pRet = m_pArrayXY_Z;
			}
			break;
		}
	case k_XY_Z:
		{
			if (IsInQuadrant(nX, nY, nZ , k_XY_Z))
			{
				pRet = m_pArray_XY_Z;
			}
			break;
		}
	case k_X_Y_Z:
		{
			if (IsInQuadrant(nX, nY, nZ , k_X_Y_Z))
			{
				pRet = m_pArray_X_Y_Z;
			}
			break;
		}
	case kX_Y_Z:
		{
			if (IsInQuadrant(nX, nY, nZ , kX_Y_Z))
			{
				pRet = m_pArrayX_Y_Z;
			}
			break;
		}
	default:
		{
			break;
		}
	}

	return pRet;
}

template<class T>
void T3DimArray<T>::GetCurData(std::map<int,QuadrantInfo<T> > &data)
{
	data.clear();
	int nMinX = 0, nMinY = 0, nMinZ = 0; // 某区域索引最小值
	int nMaxX = 0, nMaxY = 0, nMaxZ = 0; // 某区域索引最大值
	QuadrantInfo<T> info;
	if (m_pArrayXYZ != NULL)
	{
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, kXYZ);
		info.SetMinXYZ(nMinX, nMinY, nMinZ);
		info.SetMaxXYZ(nMaxX, nMaxY, nMaxZ);
		info.SetPtr(m_pArrayXYZ);
		data.insert(std::make_pair(kXYZ, info));
	}

	if (m_pArray_XYZ != NULL)
	{
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, k_XYZ);
		info.SetMinXYZ(nMinX, nMinY, nMinZ);
		info.SetMaxXYZ(nMaxX, nMaxY, nMaxZ);
		info.SetPtr(m_pArray_XYZ);
		data.insert(std::make_pair(k_XYZ, info));
	}

	if (m_pArray_X_YZ != NULL)
	{
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, k_X_YZ);
		info.SetMinXYZ(nMinX, nMinY, nMinZ);
		info.SetMaxXYZ(nMaxX, nMaxY, nMaxZ);
		info.SetPtr(m_pArray_X_YZ);
		data.insert(std::make_pair(k_X_YZ, info));
	}


	if (m_pArrayX_YZ != NULL)
	{
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, kX_YZ);
		info.SetMinXYZ(nMinX, nMinY, nMinZ);
		info.SetMaxXYZ(nMaxX, nMaxY, nMaxZ);
		info.SetPtr(m_pArrayX_YZ);
		data.insert(std::make_pair(kX_YZ, info));
	}

	if (m_pArrayXY_Z != NULL)
	{
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, kXY_Z);
		info.SetMinXYZ(nMinX, nMinY, nMinZ);
		info.SetMaxXYZ(nMaxX, nMaxY, nMaxZ);
		info.SetPtr(m_pArrayXY_Z);
		data.insert(std::make_pair(kXY_Z, info));
	}

	if (m_pArray_XY_Z != NULL)
	{
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, k_XY_Z);
		info.SetMinXYZ(nMinX, nMinY, nMinZ);
		info.SetMaxXYZ(nMaxX, nMaxY, nMaxZ);
		info.SetPtr(m_pArray_XY_Z);
		data.insert(std::make_pair(k_XY_Z, info));
	}

	if (m_pArray_X_Y_Z != NULL)
	{
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, k_X_Y_Z);
		info.SetMinXYZ(nMinX, nMinY, nMinZ);
		info.SetMaxXYZ(nMaxX, nMaxY, nMaxZ);
		info.SetPtr(m_pArray_X_Y_Z);
		data.insert(std::make_pair(k_X_Y_Z, info));
	}

	if (m_pArrayX_Y_Z != NULL)
	{
		GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, kX_Y_Z);
		info.SetMinXYZ(nMinX, nMinY, nMinZ);
		info.SetMaxXYZ(nMaxX, nMaxY, nMaxZ);
		info.SetPtr(m_pArrayX_Y_Z);
		data.insert(std::make_pair(kX_Y_Z, info));
	}
}

template<class T>
void T3DimArray<T>::Copy( const T3DimArray &arr, int nQuadrant )
{
	T*** pRes = NULL;
	switch(nQuadrant)
	{
	case kXYZ:
		{
			pRes = m_pArrayXYZ;
			break;
		}
	case k_XYZ:
		{
			pRes = m_pArray_XYZ;
			break;
		}
	case kX_YZ:
		{
			pRes = m_pArrayX_YZ;
			break;
		}
	case k_X_YZ:
		{
			pRes = m_pArray_X_YZ;
			break;
		}
	case kXY_Z:
		{
			pRes = m_pArrayXY_Z;
			break;
		}
	case k_XY_Z:
		{
			pRes = m_pArray_XY_Z;
			break;
		}
	case kX_Y_Z:
		{
			pRes = m_pArrayX_Y_Z;
			break;
		}
	case k_X_Y_Z:
		{
			pRes = m_pArray_X_Y_Z;
			break;
		}
	default:
		{
			return;
		}
	}

	int nMinX = 0, nMinY = 0, nMinZ = 0; // 某区域索引最小值
	int nMaxX = 0, nMaxY = 0, nMaxZ = 0; // 某区域索引最大值
	GetXYZ(nMinX, nMinY, nMinZ, nMaxX, nMaxY, nMaxZ, nQuadrant);
	for (int x = nMinX; x <= nMaxX; x++)
	{
		for(int y = nMinY; y <= nMaxY; y++)
		{
			for (int z = nMinZ; z <= nMaxZ; z++)
			{
				T* pT = arr.GetValue(x, y, z, nQuadrant);
				if (pT != NULL)
				{
					pRes[x][y][z] = *pT;
				}
			}

		}
	}
}

template<class T>
T* T3DimArray<T>::GetValue( int nX, int nY, int nZ, int nQuadrant ) const
{
	T*** pRes = NULL;
	switch(nQuadrant)
	{
	case kXYZ:
		{
			pRes = m_pArrayXYZ;
			break;
		}
	case k_XYZ:
		{
			pRes = m_pArray_XYZ;
			break;
		}
	case kX_YZ:
		{
			pRes = m_pArrayX_YZ;
			break;
		}
	case k_X_YZ:
		{
			pRes = m_pArray_X_YZ;
			break;
		}
	case kXY_Z:
		{
			pRes = m_pArrayXY_Z;
			break;
		}
	case k_XY_Z:
		{
			pRes = m_pArray_XY_Z;
			break;
		}
	case kX_Y_Z:
		{
			pRes = m_pArrayX_Y_Z;
			break;
		}
	case k_X_Y_Z:
		{
			pRes = m_pArray_X_Y_Z;
			break;
		}
	default:
		{
			return NULL;
		}
	}

	T* pRet = NULL;
	if (pRes != NULL)
	{
		pRet = &pRes[nX][nY][nZ];
	}

	return pRet;
}

//是否创建标记
template<class T>
bool T3DimArray<T>::IsCreated()const
{
	return m_bCreated;
}
#endif