matrix.h

图像分割算法

			{
				output << "ROW" << right << setw(rowNoWidth) << i+1 << "|";
				for(int j=0;j<m.Columns();j++)
				{
					output << right << setw(columnWidth) << m.ElemNC(i,j);
				}
				output << endl;
			}
		}
		else
		{
			int groups = m.Columns()/columnMax;
			int leftover = m.Columns() % columnMax;
			for(int k=0; k<groups; k++)
			{
				output << endl;
				output << "----------------------" << endl;
				output << "Columns " << k*columnMax+1 << " through " << k*columnMax+columnMax-1+1 << endl;
				output << "----------------------" << endl;
				for(int i=0;i<m.Rows();i++)
				{
					output << "ROW" << right << setw(rowNoWidth) << i+1 << "|";
					for(int j=columnMax*k;j<columnMax*(k+1);j++)
					{
						output << right << setw(columnWidth) << m.ElemNC(i,j);
					}
					output << endl;
				}
			}
			if(leftover > 0)
			{
				output << endl;
				output << "----------------------" << endl;
				output << "Columns " << groups*columnMax+1 << " through " << groups*columnMax+leftover-1+1 << endl;
				output << "----------------------" << endl;
				for(int i=0;i<m.Rows();i++)
				{
					output << "ROW" << right << setw(rowNoWidth) << i+1 << "|";
					for(int j=groups*columnMax;j<groups*columnMax+leftover;j++)
					{
						output << right << setw(columnWidth) << m.ElemNC(i,j);
					}
					output << endl;
				}
			}
		}
		output << "=======================" << endl;
		output << endl;
		
		return output;
	}


	T& Coor(const int x, const int y);
	T& CoorNC(const int x, const int y); // No bounds check
	T& Elem(const int _row, const int _col);
	T& ElemNC(const int _row, const int _col); // No bounds check
	T& Elem(const int i);
	T& ElemNC(const int i); // No bounds check

	T& operator() (const int i);
	T& operator() (const int i, const int j);
	Vector<T>& operator[] (const int i);
	
	/// \brief returns a new Matrix using the slice rectangle.
	//Matrix<T> operator() (const int row1, const int row2, const int col1, const int col2);
	SubMatrix<T> operator() (const int row1, const int row2, const int col1, const int col2);

	/// \brief returns a new Matrix using the slice rectangle.
	//Matrix<T> operator() (string str1, string str2);
	SubMatrix<T> operator() (string str1, string str2);
	Vector<T> operator() (string str);

	/// Matrix to Matrix multiplication
	friend Matrix<T> operator& (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::MMultiply(m1, m2);
	}
	
	/// Matrix to column Vector multiplication
	friend Matrix<T> operator& (Matrix<T>& m1, Vector<T>& m2)
	{
		return Matrix<T>::MMultiply(m1, m2);
	}

	/// Row Vector to Matrix multiplication
	friend Matrix<T> operator& (Vector<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::MMultiply(m1, m2);
	}


	// Boolean operations
	friend Matrix<int> operator&& (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::And(m1, m2);
	}

	friend Matrix<int> operator|| (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Or(m1, m2);
	}

	friend Matrix<int> operator< (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Lt(m1, m2);
	}

	friend Matrix<int> operator> (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Gt(m1, m2);
	}

	friend Matrix<int> operator<= (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Le(m1, m2);
	}

	friend Matrix<int> operator>= (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Ge(m1, m2);
	}

	friend Matrix<int> operator== (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Eq(m1, m2);
	}

	friend Matrix<int> operator!= (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Ne(m1, m2);
	}


	// Boolean operations with value type
	friend Matrix<int> operator&& (Matrix<T>& m, T v)
	{
		return Matrix<T>::And(m, v);
	}
	friend Matrix<int> operator&& (T v, Matrix<T>& m)
	{
		return Matrix<T>::And(m, v);
	}

	friend Matrix<int> operator|| (Matrix<T>& m, T v)
	{
		return Matrix<T>::Or(m, v);
	}
	friend Matrix<int> operator|| (T v, Matrix<T>& m)
	{
		return Matrix<T>::Or(m, v);
	}

	friend Matrix<int> operator< (Matrix<T>& m, T v)
	{
		return Matrix<T>::Lt(m, v);
	}
	friend Matrix<int> operator< (T v, Matrix<T>& m)
	{
		return Matrix<T>::Gt(m, v);
	}

	friend Matrix<int> operator> (Matrix<T>& m, T v)
	{
		return Matrix<T>::Gt(m, v);
	}
	friend Matrix<int> operator> (T v, Matrix<T>& m)
	{
		return Matrix<T>::Lt(m, v);
	}

	friend Matrix<int> operator<= (Matrix<T>& m, T v)
	{
		return Matrix<T>::Le(m, v);
	}
	friend Matrix<int> operator<= (T v, Matrix<T>& m)
	{
		return Matrix<T>::Ge(m, v);
	}

	friend Matrix<int> operator>= (Matrix<T>& m, T v)
	{
		return Matrix<T>::Ge(m, v);
	}
	friend Matrix<int> operator>= (T v, Matrix<T>& m)
	{
		return Matrix<T>::Le(m, v);
	}

	friend Matrix<int> operator== (Matrix<T>& m, T v)
	{
		return Matrix<T>::Eq(m, v);
	}
	friend Matrix<int> operator== (T v, Matrix<T>& m)
	{
		return Matrix<T>::Eq(m, v);
	}

	friend Matrix<int> operator!= (Matrix<T>& m, T v)
	{
		return Matrix<T>::Ne(m, v);
	}
	friend Matrix<int> operator!= (T v, Matrix<T>& m)
	{
		return Matrix<T>::Ne(m, v);
	}








// Add matrix to another matrix
	friend Matrix<T> operator+ (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Add(m1, m2);
	}

	friend Matrix<T> operator- (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Subtract(m1, m2);
	}

	friend Matrix<T> operator* (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Multiply(m1, m2);
	}

	friend Matrix<T> operator/ (Matrix<T>& m1, Matrix<T>& m2)
	{
		return Matrix<T>::Divide(m1, m2);
	}


// Add value to another matrix
	friend Matrix<T> operator+ (Matrix<T>& m, T v)
	{
		return Matrix<T>::Add(m, v);
	}

	friend Matrix<T> operator+ (T v, Matrix<T>& m)
	{
		return Matrix<T>::Add(m, v);
	}

	friend Matrix<T> operator- (Matrix<T>& m, T v)
	{
		return Matrix<T>::Subtract(m, v);
	}

	friend Matrix<T> operator- (T v, Matrix<T>& m)
	{
		return Matrix<T>::Subtract(v, m);
	}

	friend Matrix<T> operator* (Matrix<T>& m, T v)
	{
		return Matrix<T>::Multiply(m, v);
	}

	friend Matrix<T> operator* (T v, Matrix<T>& m)
	{
		return Matrix<T>::Multiply(m, v);
	}

	friend Matrix<T> operator/ (Matrix<T>& m, T v)
	{
		return Matrix<T>::Divide(m, v);
	}

	friend Matrix<T> operator/ (T v, Matrix<T>& m)
	{
		return Matrix<T>::Divide(v, m);
	}




// Add inline
	Matrix<T>& operator+= (Matrix<T>& m);
	Matrix<T>& operator-= (Matrix<T>& m);
	Matrix<T>& operator*= (Matrix<T>& m);
	Matrix<T>& operator/= (Matrix<T>& m);

	Matrix<T>& operator+= (T v);
	Matrix<T>& operator-= (T v);
	Matrix<T>& operator*= (T v);
	Matrix<T>& operator/= (T v);

	
// TYPE CONVERSIONS
	//Matrix(Array<T> &m);
	Matrix(Vector<T> &m);
	Matrix(SubMatrix<T> &m);


};

#include "./Matrix.inl"



}; //namespace


#endif