#include "stdafx.h"
#include "TGPLine2d.h"



using namespace TchSubExport;
using namespace TchSubPrivate;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ACRX_DXF_DEFINE_MEMBERS(ATSLandform, ATSEntity, AcDb::kDHL_CURRENT,
						AcDb::kMReleaseCurrent,  1, ATS_LANDFORM, "ATS_LANDFORM图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbLandform);

const Adesk::UInt8 TDbLandform::g_nVersion = 2;
AcCmColor GetGradientColor(int minColor,int maxColor,double minData,double maxData,double data)
{
	COLORREF color0=acedGetRGB(minColor),color1=acedGetRGB(maxColor);
	double r0=GetRValue(color0),r1=GetRValue(color1);
	double g0=GetGValue(color0),g1=GetGValue(color1);
	double b0=GetBValue(color0),b1=GetBValue(color1);
	double dr=r1-r0,dg=g1-g0,db=b1-b0;
	double dm=maxData-minData;
	AcCmColor c;
	if(dm<1E-6)
		c.setColorIndex(minColor);
	else
	{
		double dc=(data-minData)/dm;
		Adesk::UInt8 r=(Adesk::UInt8)(r0+dr*dc);
		Adesk::UInt8 g=(Adesk::UInt8)(g0+dg*dc);
		Adesk::UInt8 b=(Adesk::UInt8)(b0+db*dc);
		c.setRGB(r,g,b);
	}
	return c;
}
TDbLandform::TDbLandform():m_nMinColor(9),m_nMaxColor(1),m_nDistX(_AS_SYS_UNIT(5000)),m_nDistY(_AS_SYS_UNIT(5000)),m_nCMFlag(0)//ok
{
}
void TDbLandform::CreateLandform(GLandform&land)const
{
	GPLine2D *pCurve=new GPLine2D;
	XPoly2D2GPLine2D(m_polyOutline,*pCurve);
	land.Append(pCurve);
	for(long i=0;i<m_lstEqHeightCurve.Length();i++)
	{
		pCurve=new GPLine2D;
		XPoly2D2GPLine2D(m_lstEqHeightCurve[i],*pCurve);
		land.Append(pCurve);
	}
}
const TCHAR* TDbLandform::GetDefaultLayer()const
{
	return LAY_GROUND;
}

double TDbLandform::GetElevation()const//ok
{
	if(m_polyOutline.Length()>0)
		return m_polyOutline[0].z;
	else
		return 0;
}
void TDbLandform::SetOutline(const XPoly2D& poly)
{
	assertWriteEnabled();
	m_polyOutline=poly;
}
void TDbLandform::AppendPoly(const XPoly2D& poly)//ok
{
	assertWriteEnabled();
	m_lstEqHeightCurve.Append(new XPoly2D(poly));
}
BOOL TDbLandform::Has2D() const//ok
{
	assertReadEnabled();
	return (m_nCMFlag&CMF_NO2D)==0;
}
void TDbLandform::SetHas2D(BOOL bHas)//ok
{
	assertWriteEnabled();
    if(!bHas) 
        m_nCMFlag |= CMF_NO2D;
    else
        m_nCMFlag &= ~CMF_NO2D;
}
BOOL TDbLandform::Has3D() const//ok
{
	assertReadEnabled();
	return (m_nCMFlag&CMF_NO3D)==0;
}
void TDbLandform::SetHas3D(BOOL bHas)//ok
{
	assertWriteEnabled();
    if(!bHas) 
        m_nCMFlag |= CMF_NO3D;
    else
        m_nCMFlag &= ~CMF_NO3D;
}
void TDbLandform::SetNoGrid3D(BOOL bTrue)
{
	assertWriteEnabled();
	if(bTrue)
		m_nCMFlag|=_CMF_NO_GRID3D;
	else
		m_nCMFlag&=~_CMF_NO_GRID3D;
}//ok
void TDbLandform::SetHasCurve3D(BOOL bTrue)
{
	assertWriteEnabled();
	if(bTrue)
		m_nCMFlag|=_CMF_HAS_CURVE3D;
	else
		m_nCMFlag&=~_CMF_HAS_CURVE3D;
}//ok
void TDbLandform::SetNoCurve2D(BOOL bTrue)
{
	assertWriteEnabled();
	if(bTrue)
		m_nCMFlag|=_CMF_NO_CURVE2D;
	else
		m_nCMFlag&=~_CMF_NO_CURVE2D;
}//ok
void TDbLandform::SetSqFit(BOOL bTrue)
{
	assertWriteEnabled();
	if(bTrue)
		m_nCMFlag|=_CMF_SQFIT;
	else
		m_nCMFlag&=~_CMF_SQFIT;
}//ok
void TDbLandform::SetGradient3D(BOOL bTrue)
{
	assertWriteEnabled();
	if(bTrue)
		m_nCMFlag|=_CMF_GRADIENT3D;
	else
		m_nCMFlag&=~_CMF_GRADIENT3D;
}//ok

void TDbLandform::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)//ok
{
    assertWriteEnabled();
    TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbLandform *pSrc=TDbLandform::cast(pSrcEntity);
    if(pSrc)
	{
		m_nCMFlag=pSrc->m_nCMFlag;
    }
}
BOOL TDbLandform::IsValid() const//ok
{
    if(!TDbEntity::IsValid())
		return FALSE;

	GLandform land;
	CreateLandform(land);
	return land.IsValid();
}
Acad::ErrorStatus TDbLandform::dwgInFields (AcDbDwgFiler* pFiler)//ok
{
    assertWriteEnabled();

    Acad::ErrorStatus es = TDbEntity::dwgInFields(pFiler);
    if(es != Acad::eOk) return es;

    Adesk::UInt8  nVer;
    pFiler->readItem(&nVer);
    if(nVer>g_nVersion) 
       return Acad::eMakeMeProxy;

	m_lstEqHeightCurve.Reset();
	ReadPoly2D(pFiler,m_polyOutline);
	double nElev=0;
	pFiler->readDouble(&nElev);
	m_polyOutline.SetElevation(nElev);
	Adesk::Int32 num=0;
	pFiler->readInt32(&num);
	for(long i=0;i<num;i++)
	{
		XPoly2D* pNew=new XPoly2D;
		ReadPoly2D(pFiler,*pNew);
		pFiler->readDouble(&nElev);
		pNew->SetElevation(nElev);

		m_lstEqHeightCurve.Append(pNew);
	}

	pFiler->readItem(&m_nMinColor);
	pFiler->readItem(&m_nMaxColor);
	pFiler->readItem(&m_nDistX);
	pFiler->readItem(&m_nDistY);
	pFiler->readItem(&m_nCMFlag);

    return pFiler->filerStatus();
}
Acad::ErrorStatus TDbLandform::dwgOutFields(AcDbDwgFiler* pFiler) const//ok
{
    assertReadEnabled();
    Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
    if(es != Acad::eOk) return es;
   
	pFiler->writeItem(g_nVersion);

	WritePoly2D(pFiler,m_polyOutline);
	pFiler->writeDouble(GetElevation());
	Adesk::Int32 num=m_lstEqHeightCurve.Length();
	pFiler->writeInt32(num);
	for(long i=0;i<num;i++)
	{
		const XPoly2D& poly=m_lstEqHeightCurve[i];
		WritePoly2D(pFiler,poly);
		double nElev=poly[0].z;
		pFiler->writeDouble(nElev);
	}

	pFiler->writeItem(m_nMinColor);
	pFiler->writeItem(m_nMaxColor);
	pFiler->writeItem(m_nDistX);
	pFiler->writeItem(m_nDistY);
	pFiler->writeItem(m_nCMFlag);

    return pFiler->filerStatus();
}
Acad::ErrorStatus TDbLandform::dxfInFields (AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();
    Acad::ErrorStatus es=TDbEntity::dxfInFields(pFiler);
    if(es!=Acad::eOk)    
		return es;

    if (!pFiler->atSubclassData(_T("TDbLandform")))
        return Acad::eBadDxfSequence;

    return pFiler->filerStatus();
}
Acad::ErrorStatus TDbLandform::dxfOutFields(AcDbDxfFiler* pFiler) const
{
   Acad::ErrorStatus es;

   es = TDbEntity::dxfOutFields(pFiler);
   assert(es == Acad::eOk);

   es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbLandform"));

   return es;
}
Acad::ErrorStatus TDbLandform::subGetClassID(CLSID* pClsid) const
{
    return Acad::eOk;
}
void TDbLandform::UnionScale(double nScale)
{
	assertWriteEnabled();
	AcGeMatrix3d mat;
	mat.setToScaling(nScale);
	m_polyOutline.TransformBy(mat);
	for(long i=0;i<m_lstEqHeightCurve.Length();i++)
		m_lstEqHeightCurve[i]->TransformBy(mat);
	m_nDistX*=nScale;
	m_nDistY*=nScale;
}

//修改原因：移动、复制等操作，坡地的标高不随基点标高变化而变，这与平板等建筑其他对象都不同，造成坡地与其他模型同时移动后相对位置发生变化
//by fxj 090826
Acad::ErrorStatus TDbLandform::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	if(!IsValid())
		return Acad::eOk;

//	double nElev=m_polyOutline[0l]->z;
	m_polyOutline.TransformBy(xform);
//	m_polyOutline.SetElevation(nElev);
	for(long i=0;i<m_lstEqHeightCurve.Length();i++)
	{
//		nElev=(*m_lstEqHeightCurve[i])[0l]->z; 
		m_lstEqHeightCurve[i]->TransformBy(xform);
//		m_lstEqHeightCurve[i]->SetElevation(nElev);
	}
	return Acad::eOk;
}
Acad::ErrorStatus TDbLandform::subGetOsnapPoints(AcDb::OsnapMode       osnapMode, 
                         INT_PTR                   gsSelectionMark, 
                         const AcGePoint3d&    ptPick, 
                         const AcGePoint3d&    lastPoint, 
                         const AcGeMatrix3d&   viewXform, 
                         AcGePoint3dArray&     snapPoints, 
                         AcDbIntArray&     geomIds) const
{
    Acad::ErrorStatus es=Acad::eOk;
	AcDbCurve *pCurve=m_polyOutline.AsAcDbCurve();
	if(pCurve!=NULL)
	{
		es = pCurve->getOsnapPoints(osnapMode, gsSelectionMark, ptPick,
			lastPoint, viewXform, snapPoints, geomIds);
		delete pCurve;
	}

    return es;
}
Acad::ErrorStatus TDbLandform::subGetGripPoints(AcGePoint3dArray&  gripPoints,
                                             AcDbIntArray&  osnapModes,
                                             AcDbIntArray&  geomIds) const
{
	double nElev=GetElevation();
	for(long i=0;i<m_polyOutline.Length();i++)
	{
		XPoint pt=m_polyOutline[i];
		gripPoints.append(AcGePoint3d(pt.x,pt.y,nElev));
	}
    return Acad::eOk;
}
Acad::ErrorStatus TDbLandform::subMoveGripPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
    assertWriteEnabled();
	AcGeMatrix3d mat;
	mat.setTranslation(offset);
	return subTransformBy(mat);
}
Acad::ErrorStatus TDbLandform::GetGripText(int i, CString &cs) const
{
    Acad::ErrorStatus es=Acad::eOk;
    cs=_T("移动");
    return es;
}
Acad::ErrorStatus TDbLandform::ExplodeOrDraw2d(XExplodeDraw &dc) const//ok
{
	if(Has2D())
	{
		double minHeight,maxHeight;
		minHeight=maxHeight=GetElevation();
		for(long i=0;i<m_lstEqHeightCurve.Length();i++)
		{
			double e=m_lstEqHeightCurve[i][0].z;
			if(e<minHeight)
				minHeight=e;
			if(e>maxHeight)
				maxHeight=e;
		}
		maxHeight+=_AS_SYS_UNIT(1000);


		TMasterProperties prop;
		dc.BackUpProperties(prop);

		//绘制外边界
		AcDbCurve* pCurve=m_polyOutline.AsAcDbCurve();
		if(pCurve!=NULL)
		{
			prop.SetTo(pCurve);
			pCurve->setColor(GetGradientColor(m_nMinColor,m_nMaxColor,minHeight,maxHeight,m_polyOutline[0].z));
			dc.DrawEntity(*pCurve);
			delete pCurve;
		}

		//绘制等高线
		if(HasCurve2D())
		{
			for(i=0;i<m_lstEqHeightCurve.Length();i++)
			{
				AcDbCurve* pCurve=m_lstEqHeightCurve[i].AsAcDbCurve();
				if(pCurve!=NULL)
				{
					prop.SetTo(pCurve);
					pCurve->setColor(GetGradientColor(m_nMinColor,m_nMaxColor,minHeight,maxHeight,m_lstEqHeightCurve[i][0].z));
					dc.DrawEntity(*pCurve);
					delete pCurve;
				}
			}
		}

		dc.RestoreProperties(prop);	
	}
	return Acad::eOk;
}
Acad::ErrorStatus TDbLandform::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	if(Has3D())
	{
		double minHeight,maxHeight;
		minHeight=maxHeight=GetElevation();
		for(long i=0;i<m_lstEqHeightCurve.Length();i++)
		{
			double e=m_lstEqHeightCurve[i][0].z;
			if(e<minHeight)
				minHeight=e;
			if(e>maxHeight)
				maxHeight=e;
		}
		maxHeight+=_AS_SYS_UNIT(1000);

		TMasterProperties prop;
		dc.BackUpProperties(prop);

		//绘制曲面
		GLandform land;
		CreateLandform(land);
		if(land.IsValid()&&UP_ZEROD(m_nDistX)&&UP_ZEROD(m_nDistY))
		{
			GObjectList mlines;
			land.CreateGridData(m_nDistX,m_nDistY,mlines,IsSqFit()?1:0);

			AcDbVoidPtrArray entSet;
			for(mlines.MoveToFirst();!mlines.IsOut();mlines.MoveToNext())
			{
				GMLine2D& mline2D=(GMLine2D&)mlines.GetCurPData();

				//分解三维凸多边形
				GPoint pt0=mline2D[0];
				for(long i=1;i<(mline2D.GetVertexNum()-1);i++)
				{
					GPoint pt1=mline2D[i];
					GPoint pt2=mline2D[i+1];
					if(mline2D.GetVertexNum()==3)
						entSet.append(new AcDbFace(GP3AP(pt0),GP3AP(pt1),GP3AP(pt2),Adesk::kTrue,Adesk::kTrue,Adesk::kFalse,Adesk::kTrue));
					else if(i==1)
						entSet.append(new AcDbFace(GP3AP(pt0),GP3AP(pt1),GP3AP(pt2),Adesk::kTrue,Adesk::kTrue,Adesk::kFalse,Adesk::kFalse));
					else if(i==mline2D.GetVertexNum()-2)
						entSet.append(new AcDbFace(GP3AP(pt0),GP3AP(pt1),GP3AP(pt2),Adesk::kFalse,Adesk::kTrue,Adesk::kFalse,Adesk::kTrue));
					else
						entSet.append(new AcDbFace(GP3AP(pt0),GP3AP(pt1),GP3AP(pt2),Adesk::kFalse,Adesk::kTrue,Adesk::kFalse,Adesk::kFalse));
				}
			}

			for(long i=0;i<entSet.length();i++)
			{
				AcDbFace *pEnt=(AcDbFace*)entSet[i];
				AcDbExtents ext;
				pEnt->getGeomExtents(ext);
				prop.SetTo(pEnt);
				if((m_nCMFlag&_CMF_GRADIENT3D)!=0)
					pEnt->setColor(GetGradientColor(m_nMinColor,m_nMaxColor,minHeight,maxHeight,(ext.minPoint().z+ext.maxPoint().z)/2));
				if((m_nCMFlag&_CMF_NO_GRID3D)!=0)
				{
					pEnt->makeEdgeInvisibleAt(0);
					pEnt->makeEdgeInvisibleAt(1);
					pEnt->makeEdgeInvisibleAt(2);
					pEnt->makeEdgeInvisibleAt(3);
				}
				dc.DrawEntity(*pEnt);
			}
			ReleaseEntSet(entSet);
		}


		//绘制等高线
		if(HasCurve3D())
		{
			//绘制外边界
			AcDbCurve* pCurve=m_polyOutline.AsAcDbCurve();
			if(pCurve!=NULL)
			{
				prop.SetTo(pCurve);
				pCurve->setColor(GetGradientColor(m_nMinColor,m_nMaxColor,minHeight,maxHeight,m_polyOutline[0].z));
				dc.DrawEntity(*pCurve);
				delete pCurve;
			}			

			//内等高线
			for(i=0;i<m_lstEqHeightCurve.Length();i++)
			{
				AcDbCurve* pCurve=m_lstEqHeightCurve[i].AsAcDbCurve();
				if(pCurve!=NULL)
				{
					prop.SetTo(pCurve);
					pCurve->setColor(GetGradientColor(m_nMinColor,m_nMaxColor,minHeight,maxHeight,m_lstEqHeightCurve[i][0].z));
					dc.DrawEntity(*pCurve);
					delete pCurve;
				}
			}
		}

		dc.RestoreProperties(prop);	
	}
	return Acad::eOk;
}
void TDbLandform::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
    lstInfo.Append(new TObjInfoUnit(_T("对象类型"),  _T("坡面")));
}

void InitDbLandform(BOOL bTrue)
{
    if(bTrue) 
	{
        TDbLandform::rxInit();
        acrxBuildClassHierarchy();
        TDbLandform::InitMatchProtocol(TRUE);
    } 
	else 
	{
        TDbLandform::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbLandform::desc());
    }
}