void umbralizarImagen(Matriz &m, int coefInicial, int coefFinal, double umbral) {
	// El par (x0, y0) indica el primer elemento de la diagonal actual
	int x0 = 0;
	int y0 = 0;

	// El par (x, y) indica el coeficiente actual
	int x = x0;
	int y = y0;

	for(int i = 0; i < m.filas() * m.columnas(); i++) {
		// Umbralizo el coeficiente actual
		if(coefInicial <= i && i <= coefFinal) {
			if(abs(m.elem(y, x)) < umbral) m.elem(y, x) = 0;
		}

		// Avanzo al siguiente elemento de la diagonal
		x--;
		y++;

		// Verifico si llegué al final de la diagonal actual
		if(x < 0 || y >= m.filas()) {
			// Avanzo a la siguiente diagonal
			if(x0 < m.columnas() - 1) x0++;
			else y0++;

			// Avanzo al primer elemento de la nueva diagonal
			x = x0;
			y = y0;
		}
	}
}
void agregarRuidoImpulsivo(Matriz &m, const double p) {
	int max, min;
	unsigned seed = chrono::system_clock::now().time_since_epoch().count();
	std::default_random_engine generator(seed);
	std::uniform_real_distribution<double> distribution(0.0,1.0);
	if(m.columnas() == 1) {
		max = m.max();
		min = m.min();
	}
	else {
		max = 255;
		min = 0;
	}
	for(int i = 0;i < m.filas(); i++) {
		for(int j = 0;j < m.columnas(); j++) {
			double randNum = distribution(generator);
			if(randNum < p) {
				m.elem(i,j) = max;
			}
			else if(randNum >= 1 - p) {
				m.elem(i,j) = min;
			}
		}
	}
}
Transformacion Transformacion::rotZ(float ang)
//en Z
{
	Matriz g;
	g.setelem(0,0,(float)cos(DEG2RAD(ang)));
    g.setelem(0,1,(float)-sin(DEG2RAD(ang)));
	g.setelem(1,0,-g.elem(0,1));
	g.setelem(1,1,g.elem(0,0));

	return append(g);
}
Transformacion Transformacion::rotY(float ang)
//en Y
{
	Matriz g;
	g.setelem(0,0,(float)cos(DEG2RAD(ang)));
    g.setelem(0,2,(float)sin(DEG2RAD(ang)));
	g.setelem(2,0,-g.elem(0,2));
	g.setelem(2,2,g.elem(0,0));

	return append(g);
}
Transformacion Transformacion::rotX(float ang)
//en X
{
	Matriz g;
	g.setelem(1,1,(float)cos(DEG2RAD(ang)));
    g.setelem(1,2,(float)-sin(DEG2RAD(ang)));
	g.setelem(2,1,-g.elem(1,2));
	g.setelem(2,2,g.elem(1,1));

	return append(g);
}
Bloque::Bloque(Matriz c1, Matriz c2, Matriz c3, Matriz c4)
//Contruye el bloque con las matrices como columnas
{
	int i,k;

	for(i=0;i<4;i++)
		for(k=0;k<4;k++){
			e[i][0][k]=c1.elem(k,i);
			e[i][1][k]=c2.elem(k,i);
			e[i][2][k]=c3.elem(k,i);
			e[i][3][k]=c4.elem(k,i);
	}
}
void agregarRuidoAditivo(Matriz &m, const double mu, const double sigma) {
	unsigned seed = chrono::system_clock::now().time_since_epoch().count();
	default_random_engine generator(seed);
  	normal_distribution<double> distribution(mu,sigma);
	for(int i = 0; i < m.filas(); i++) {
		for(int j = 0; j < m.columnas(); j++) {
			//cout << "Que larga: " << distribution(generator) << endl;
			if(m.columnas() == 1) {
				m.elem(i,j) += distribution(generator);
			} else {
				m.elem(i,j) += floor(distribution(generator));
			}
		}
	}
}
Bloque Bloque::setlayer(int k, const Matriz &m)
//Cambia la capa por la matriz m
{
	for(int i=0; i<4; i++)
		for(int j=0; j<4; j++) e[i][j][k]=m.elem(i,j);
	return (*this);
}
Transformacion Transformacion::operator =(const Matriz &m)
//Asignacion de transformaciones
{
	int i,j;
	for(i=0;i<4;i++)
		for(j=0;j<4;j++) e[i][j]=m.elem(i,j);
	return *this;
}
Matriz Matriz::operator =(const Matriz &m)
//Asignacion de matrices
{
	int i,j;
	for(i=0;i<4;i++)
		for(j=0;j<4;j++) e[i][j]=m.elem(i,j);
	return *this;
}
Matriz Matriz::operator *(const Matriz &m)const
//Producto de matrices. Devuelve una nueva matriz
{
	int i,j,k;
	Matriz pr=Matriz(Real4(),Real4(),Real4(),Real4()); //Todo ceros

	for(i=0;i<4;i++)
		for(j=0;j<4;j++)
			for(k=0;k<4;k++)
				pr.setelem(i,j,pr.elem(i,j)+e[i][k]*m.elem(k,j));
	return pr;
}
Transformacion Transformacion::operator *(const Matriz &m)const
//Devuelve el producto de las dos matrices
{
	int i,j,k;
	Transformacion pr;
	pr= Matriz(Real4(),Real4(),Real4(),Real4()); 

	for(i=0;i<4;i++)
		for(j=0;j<4;j++)
			for(k=0;k<4;k++)
				pr.setelem(i,j,pr.elem(i,j)+e[i][k]*m.elem(k,j));
	return pr;
}
Exemple #13
0
Matriz::Matriz(Matriz& M, int p, int q){
	//~ _b = 1;
	_p = p;
	_q = q;
	_fil = M.Filas();
	_col = M.Columnas();
	valores =  new double*[_fil]; // puntero a puntero de arrays
	for(int i=0; i < _fil; i++){
		valores[i] = new double [p+q+1]; //fila i tiene a lo sumo p+q+1 elementos
		valores[i] += p;				 //	offset de cada fila (?)
	}
	
	for (int i=0;i < _fil; i++){
		int ip = max(i - p, 0);			//p de la Fila 
		int iq = min(i + q, _fil-1);			//q de la fila
		for(int j = ip;j <= iq;j++){		//recorro todas las posiciones que quiero !=0
			valores[i][j-i] = M.elem(i,j);			//relacion de como esta almacenado el valor entre la esparsa y la que no lo es;
			//~ cout << valores[i][j-i] << endl;
		}
	}
	
};
void umbralizarIntervaloSonido(Matriz &m, const int coefInicial, const int coefFinal, const double k) {
	for(int i = coefInicial; i <= coefFinal; i++) {
		if(abs(m.elem(i,0)) < k) m.elem(i,0) = 0;
	}
}
void atenuarIntervaloSonido(Matriz &m, const int coefInicial, const int coefFinal, const double k) {
	for(int i = coefInicial; i <= coefFinal; i++) {
		m.elem(i,0) *= k;
	}
}