functions.cpp

图像分割算法

	Vector<double> Powx(Vector<double>& m1, const double m2)
	{
		Vector<double> temp(m1.Length());
		vdPowx(m1.Length(), m1.Data(), m2, temp.Data());
		return temp;
	}
	
	Matrix<float> Powx(Matrix<float>& m1, const float m2)
	{
		Matrix<float> temp(m1.Rows(), m1.Columns());
		vsPowx(m1.Length(), m1.Data(), m2, temp.Data());
		return temp;
	}
	
	Matrix<double> Powx(Matrix<double>& m1, const double m2)
	{
		Matrix<double> temp(m1.Rows(), m1.Columns());
		vdPowx(m1.Length(), m1.Data(), m2, temp.Data());
		return temp;
	}
	
	
	Vector<float>& PowxI(Vector<float>& m1, const float m2)
	{
		vsPowx(m1.Length(), m1.Data(), m2, m1.Data());
		return m1;
	}
	
	Vector<double>& PowxI(Vector<double>& m1, const double m2)
	{
		vdPowx(m1.Length(), m1.Data(), m2, m1.Data());
		return m1;
	}
	
	Matrix<float>& PowxI(Matrix<float>& m1, const float m2)
	{
		vsPowx(m1.Length(), m1.Data(), m2, m1.Data());
		return m1;
	}
	
	Matrix<double>& PowxI(Matrix<double>& m1, const double m2)
	{
		vdPowx(m1.Length(), m1.Data(), m2, m1.Data());
		return m1;
	}
	
	
	
	
	// Exponent of elements
	Vector<float> Exp(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsExp(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Exp(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdExp(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Exp(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsExp(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Exp(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdExp(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& ExpI(Vector<float>& m)
	{
		vsExp(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& ExpI(Vector<double>& m)
	{
		vdExp(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& ExpI(Matrix<float>& m)
	{
		vsExp(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& ExpI(Matrix<double>& m)
	{
		vdExp(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	
	// Ln of elements
	Vector<float> Ln(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsLn(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Ln(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdLn(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Ln(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsLn(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Ln(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdLn(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& LnI(Vector<float>& m)
	{
		vsLn(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& LnI(Vector<double>& m)
	{
		vdLn(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& LnI(Matrix<float>& m)
	{
		vsLn(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& LnI(Matrix<double>& m)
	{
		vdLn(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Log10 of elements
	Vector<float> Log10(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsLog10(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Log10(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdLog10(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Log10(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsLog10(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Log10(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdLog10(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& Log10I(Vector<float>& m)
	{
		vsLog10(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& Log10I(Vector<double>& m)
	{
		vdLog10(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& Log10I(Matrix<float>& m)
	{
		vsLog10(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& Log10I(Matrix<double>& m)
	{
		vdLog10(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	
	// Cos of elements
	Vector<float> Cos(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsCos(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Cos(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdCos(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Cos(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsCos(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Cos(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdCos(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& CosI(Vector<float>& m)
	{
		vsCos(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& CosI(Vector<double>& m)
	{
		vdCos(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& CosI(Matrix<float>& m)
	{
		vsCos(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& CosI(Matrix<double>& m)
	{
		vdCos(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Sin of elements
	Vector<float> Sin(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsSin(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Sin(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdSin(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Sin(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsSin(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Sin(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdSin(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& SinI(Vector<float>& m)
	{
		vsSin(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& SinI(Vector<double>& m)
	{
		vdSin(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& SinI(Matrix<float>& m)
	{
		vsSin(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& SinI(Matrix<double>& m)
	{
		vdSin(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Tan of elements
	Vector<float> Tan(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsTan(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Tan(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdTan(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Tan(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsTan(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Tan(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdTan(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& TanI(Vector<float>& m)
	{
		vsTan(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& TanI(Vector<double>& m)
	{
		vdTan(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& TanI(Matrix<float>& m)
	{
		vsTan(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& TanI(Matrix<double>& m)
	{
		vdTan(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Acos of elements
	Vector<float> Acos(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsAcos(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Acos(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdAcos(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Acos(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsAcos(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Acos(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdAcos(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& AcosI(Vector<float>& m)
	{
		vsAcos(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& AcosI(Vector<double>& m)
	{
		vdAcos(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& AcosI(Matrix<float>& m)
	{
		vsAcos(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& AcosI(Matrix<double>& m)
	{
		vdAcos(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Asin of elements
	Vector<float> Asin(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsAsin(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Asin(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdAsin(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Asin(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsAsin(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Asin(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdAsin(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& AsinI(Vector<float>& m)
	{
		vsAsin(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& AsinI(Vector<double>& m)
	{
		vdAsin(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& AsinI(Matrix<float>& m)
	{
		vsAsin(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& AsinI(Matrix<double>& m)
	{
		vdAsin(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Atan of elements
	Vector<float> Atan(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsAtan(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Atan(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdAtan(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Atan(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsAtan(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Atan(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdAtan(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& AtanI(Vector<float>& m)
	{
		vsAtan(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& AtanI(Vector<double>& m)
	{
		vdAtan(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& AtanI(Matrix<float>& m)
	{
		vsAtan(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& AtanI(Matrix<double>& m)
	{
		vdAtan(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Atan2 of elements
	Vector<float> Atan2(Vector<float>& m1, Vector<float>& m2)
	{
		if(m1.Length() != m2.Length())
		{
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
			Utility::RunTimeError("Vector lengths are not the same!");
		}