183 wiersze
3.3 KiB
C++
183 wiersze
3.3 KiB
C++
/* libsegl - Sebas Extended GL Library
|
|
* Collection of Opengl/3D-Math helpers
|
|
*
|
|
* Copyright (c) 2008 by Sebastian Lohff, seba@seba-geek.de
|
|
* http://www.seba-geek.de
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "matrix.h"
|
|
|
|
namespace segl {
|
|
|
|
Matrix::Matrix(int _m, int _n) {
|
|
m = _m;
|
|
n = _n;
|
|
allocate();
|
|
}
|
|
|
|
Matrix::Matrix(int _m, int _n, const float **src) {
|
|
m = _m;
|
|
n = _n;
|
|
allocate();
|
|
copyFromSource(src);
|
|
}
|
|
|
|
Matrix::Matrix(Punkt3D d) {
|
|
m = 3;
|
|
n = 1;
|
|
allocate();
|
|
c[0][0] = d.x;
|
|
c[1][0] = d.y;
|
|
c[2][0] = d.z;
|
|
}
|
|
|
|
Matrix::Matrix(const Matrix& mat) {
|
|
m = mat.m;
|
|
n = mat.n;
|
|
allocate();
|
|
copyFromSource(mat.getMatrix());
|
|
}
|
|
|
|
void Matrix::allocate() {
|
|
c = new float*[m];
|
|
for(int i=0; i<m; i++) {
|
|
c[i] = new float[n];
|
|
for(int t=0; t<n; t++)
|
|
c[i][t] = 0;
|
|
}
|
|
}
|
|
|
|
void Matrix::copyFromSource(const float** src) {
|
|
for(int i=0; i<m; i++) {
|
|
for(int t=0; t<n; t++)
|
|
c[i][t] = src[i][t];
|
|
}
|
|
}
|
|
|
|
const float **Matrix::getMatrix() const {
|
|
return (const float**)c;
|
|
}
|
|
|
|
bool Matrix::set(float d, int _m, int _n) {
|
|
if(_m>=m||_n>=n)
|
|
return false;
|
|
c[_m][_n] = d;
|
|
return true;
|
|
}
|
|
|
|
float Matrix::get(int _m, int _n) {
|
|
if(_m>=m||_n>=n)
|
|
return 0.0f;
|
|
|
|
return c[_m][_n];
|
|
}
|
|
|
|
Matrix Matrix::operator*(const Matrix &d) {
|
|
|
|
if(n!=d.m)
|
|
return Matrix(1,1);
|
|
Matrix erg(m, d.n);
|
|
|
|
|
|
for(int a=0; a<m; a++) {
|
|
for(int b=0; b<d.n; b++) {
|
|
float zerg = 0.0f;
|
|
for(int _c=0; _c<n; _c++) {
|
|
zerg += c[a][_c] * d.c[_c][b];
|
|
}
|
|
erg.c[a][b] = zerg;
|
|
}
|
|
}
|
|
|
|
return erg;
|
|
}
|
|
|
|
Matrix& Matrix::operator=(const Matrix& mat) {
|
|
if(mat.m<=m&&mat.n<=n) {
|
|
copyFromSource(mat.getMatrix());
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Matrix Matrix::operator+(const float &f) {
|
|
Matrix tmp(*this);
|
|
for(int i=0; i<m; i++) {
|
|
for(int j=0; j<n; j++) {
|
|
tmp.c[i][j] += f;
|
|
}
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
Matrix Matrix::operator-(const float &f) {
|
|
Matrix tmp(*this);
|
|
for(int i=0; i<m; i++) {
|
|
for(int j=0; j<n; j++) {
|
|
tmp.c[i][j] -= f;
|
|
}
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
Matrix Matrix::operator*(const float &f) {
|
|
Matrix tmp(*this);
|
|
for(int i=0; i<m; i++) {
|
|
for(int j=0; j<n; j++) {
|
|
tmp.c[i][j] *= f;
|
|
}
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
Matrix Matrix::operator/(const float &f) {
|
|
Matrix tmp(*this);
|
|
for(int i=0; i<m; i++) {
|
|
for(int j=0; j<n; j++) {
|
|
tmp.c[i][j] /= f;
|
|
}
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
int Matrix::getM() const {
|
|
return m;
|
|
}
|
|
|
|
int Matrix::getN() const {
|
|
return n;
|
|
}
|
|
|
|
void Matrix::print(std::string s) const {
|
|
std::cout << "Matrix " << s << "(" << m << "," << n << ")" << std::endl;
|
|
for(int a=0; a<m; a++) {
|
|
for(int b=0; b<n; b++) {
|
|
std::cout << std::setw(15) << c[a][b];
|
|
}
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
|
|
Matrix::~Matrix() {
|
|
for(int i=0; i<m; i++) {
|
|
delete[](c[i]);
|
|
}
|
|
delete[](c);
|
|
}
|
|
|
|
} // namespace segl
|