1212 lines
23 KiB
C++
1212 lines
23 KiB
C++
//------------------------------------------------------------------------+
|
||
// 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
|
||
|