grid_classify_supervised.cpp

这是一个GPS相关的程序

					}
				}
			}
		}

		//-------------------------------------------------
		for(iClass=0; iClass<m_pClasses->Get_Record_Count(); iClass++)
		{
			pClass	= m_pClasses->Get_Record(iClass);
			n		= pClass->asDouble(CLASS_N);

			for(iGrid=0; iGrid<m_pGrids->Get_Count(); iGrid++)
			{
				d	= pClass->asDouble	(CLASS_M + 2 * iGrid) / n;			// arithmetic mean
				pClass->Set_Value		(CLASS_M + 2 * iGrid, d);

				d	= pClass->asDouble	(CLASS_S + 2 * iGrid) / n - d * d;	// variance
				pClass->Set_Value		(CLASS_S + 2 * iGrid, sqrt(d));		// standard deviation
			}
		}

		//-------------------------------------------------
		if( m_pClasses->Get_Record_Count() > 1 )
		{
			CSG_Parameters	Parms;

			if( DataObject_Get_Parameters(m_pResult, Parms) && Parms("COLORS_TYPE") && Parms("LUT") )
			{
				CSG_Table	*pLUT	= Parms("LUT")->asTable();

				for(iClass=0; iClass<m_pClasses->Get_Record_Count(); iClass++)
				{
					if( (pClass = pLUT->Get_Record(iClass)) == NULL )
					{
						pClass	= pLUT->Add_Record();
						pClass->Set_Value(0, SG_GET_RGB(rand() * 255.0 / RAND_MAX, rand() * 255.0 / RAND_MAX, rand() * 255.0 / RAND_MAX));
					}

					pClass->Set_Value(1, m_pClasses->Get_Record(iClass)->asString(CLASS_ID));
					pClass->Set_Value(2, m_pClasses->Get_Record(iClass)->asString(CLASS_ID));
					pClass->Set_Value(3, iClass + 1);
					pClass->Set_Value(4, iClass + 1);
				}

				while( pLUT->Get_Record_Count() > m_pClasses->Get_Record_Count() )
				{
					pLUT->Del_Record(pLUT->Get_Record_Count() - 1);
				}

				Parms("COLORS_TYPE")->Set_Value(1);	// Color Classification Type: Lookup Table

				DataObject_Set_Parameters(m_pResult, Parms);
			}

			return( true );
		}
	}

	return( false );
}

//---------------------------------------------------------
bool CGrid_Classify_Supervised::Finalise(void)
{
	if( m_bNormalise )
	{
		for(int iClass=0; iClass<m_pClasses->Get_Record_Count(); iClass++)
		{
			CSG_Table_Record	*pClass	= m_pClasses->Get_Record(iClass);

			for(int iGrid=0; iGrid<m_pGrids->Get_Count(); iGrid++)
			{
				double	d,
					s	= sqrt(m_pGrids->asGrid(iGrid)->Get_Variance()),
					m	=      m_pGrids->asGrid(iGrid)->Get_ArithMean();

				d	= pClass->asDouble	(CLASS_M + 2 * iGrid);
				pClass->Set_Value		(CLASS_M + 2 * iGrid, s * d + m);

				d	= pClass->asDouble	(CLASS_S + 2 * iGrid);
				pClass->Set_Value		(CLASS_S + 2 * iGrid, s * d);
			}
		}
	}

	if( m_pProbability )
	{
		DataObject_Set_Colors(m_pProbability, 100, SG_COLORS_WHITE_GREEN);
	}

	return( true );
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
CSG_Table_Record * CGrid_Classify_Supervised::Get_Class(const SG_Char *Identifier)
{
	CSG_Table_Record	*pClass	= NULL;

	if( m_pClasses && Identifier )
	{
		int		i;

		for(i=0; i<m_pClasses->Get_Record_Count(); i++)
		{
			pClass	= m_pClasses->Get_Record(i);

			if( !SG_STR_CMP(pClass->asString(CLASS_ID), Identifier) )
			{
				return( pClass );
			}
		}

		//-------------------------------------------------
		pClass	= m_pClasses->Add_Record();

		pClass->Set_Value(CLASS_NR	, m_pClasses->Get_Record_Count());
		pClass->Set_Value(CLASS_ID	, Identifier);
		pClass->Set_Value(CLASS_N	, 0.0);

		for(i=CLASS_M; i<m_pClasses->Get_Field_Count(); i++)
		{
			pClass->Set_Value(i, 0.0);
		}
	}

	return( pClass );
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
bool CGrid_Classify_Supervised::Set_Minimum_Distance(void)
{
	int		x, y, iClass, iGrid, iMin;
	double	dMin, d, e, **m;

	//-----------------------------------------------------
	m		= (double **)SG_Malloc(sizeof(double *) * m_pClasses->Get_Record_Count());
	m[0]	= (double  *)SG_Malloc(sizeof(double  ) * m_pClasses->Get_Record_Count() * m_pGrids->Get_Count());

	for(iClass=0; iClass<m_pClasses->Get_Record_Count(); iClass++)
	{
		m[iClass]	= m[0] + iClass * m_pGrids->Get_Count();

		for(iGrid=0; iGrid<m_pGrids->Get_Count(); iGrid++)
		{
			m[iClass][iGrid]	= m_pClasses->Get_Record(iClass)->asDouble(CLASS_M + 2 * iGrid);
		}
	}

	//-----------------------------------------------------
	for(y=0; y<Get_NY() && Set_Progress(y); y++)
	{
		for(x=0; x<Get_NX(); x++)
		{
			if( !m_pResult->is_NoData(x, y) )
			{
				for(iClass=0, dMin=-1.0; iClass<m_pClasses->Get_Record_Count(); iClass++)
				{
					for(iGrid=0, d=0.0; iGrid<m_pGrids->Get_Count(); iGrid++)
					{
						e	= GET_GRID_VALUE(x, y, iGrid) - m[iClass][iGrid];
						d	+= e*e;
					}

					if( dMin < 0.0 || dMin > d )
					{
						dMin	= d;
						iMin	= iClass;
					}
				}

				if( dMin >= 0.0 )
				{
					m_pResult->Set_Value(x, y, iMin + 1);
				}
			}
		}
	}

	//-----------------------------------------------------
	SG_Free(m[0]);
	SG_Free(m);

	return( true );
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
bool CGrid_Classify_Supervised::Set_Maximum_Likelihood(void)
{
	int		x, y, iClass, iGrid, iMax;
	double	dMax, d, e, **a, **b, **m;

	//-----------------------------------------------------
	a		= (double **)SG_Malloc(sizeof(double *) * m_pClasses->Get_Record_Count());
	a[0]	= (double  *)SG_Malloc(sizeof(double  ) * m_pClasses->Get_Record_Count() * m_pGrids->Get_Count());
	b		= (double **)SG_Malloc(sizeof(double *) * m_pClasses->Get_Record_Count());
	b[0]	= (double  *)SG_Malloc(sizeof(double  ) * m_pClasses->Get_Record_Count() * m_pGrids->Get_Count());
	m		= (double **)SG_Malloc(sizeof(double *) * m_pClasses->Get_Record_Count());
	m[0]	= (double  *)SG_Malloc(sizeof(double  ) * m_pClasses->Get_Record_Count() * m_pGrids->Get_Count());

	for(iClass=0; iClass<m_pClasses->Get_Record_Count(); iClass++)
	{
		a[iClass]	= a[0] + iClass * m_pGrids->Get_Count();
		b[iClass]	= b[0] + iClass * m_pGrids->Get_Count();
		m[iClass]	= m[0] + iClass * m_pGrids->Get_Count();

		for(iGrid=0; iGrid<m_pGrids->Get_Count(); iGrid++)
		{
			d					= m_pClasses->Get_Record(iClass)->asDouble(CLASS_S + 2 * iGrid);	// standard deviation
			a[iClass][iGrid]	=  1.0 / sqrt(d*d * 2.0 * M_PI);
			b[iClass][iGrid]	= -1.0 /     (d*d * 2.0);
			m[iClass][iGrid]	= m_pClasses->Get_Record(iClass)->asDouble(CLASS_M + 2 * iGrid);	// arithmetic mean
		}
	}

	//-----------------------------------------------------
	for(y=0; y<Get_NY() && Set_Progress(y); y++)
	{
		for(x=0; x<Get_NX(); x++)
		{
			if( !m_pResult->is_NoData(x, y) )
			{
				for(iClass=0, dMax=0.0; iClass<m_pClasses->Get_Record_Count(); iClass++)
				{
					for(iGrid=0, d=1.0; iGrid<m_pGrids->Get_Count(); iGrid++)
					{
						e	 = GET_GRID_VALUE(x, y, iGrid) - m[iClass][iGrid];
						d	*= a[iClass][iGrid] * exp(b[iClass][iGrid] * e*e);
					}

					if( dMax < d )
					{
						dMax	= d;
						iMax	= iClass;
					}
				}

				if( (dMax = 100.0 * pow(dMax, 1.0 / m_pGrids->Get_Count())) < m_ML_Threshold )
				{
					m_pResult->Set_Value(x, y, 0.0);
				}
				else
				{
					m_pResult->Set_Value(x, y, iMax + 1);
				}

				if( m_pProbability )
				{
					m_pProbability->Set_Value(x, y, dMax);
				}
			}
		}
	}

	//-----------------------------------------------------
	SG_Free(a[0]);
	SG_Free(a);
	SG_Free(b[0]);
	SG_Free(b);
	SG_Free(m[0]);
	SG_Free(m);

	return( true );
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------