#include <Nsound/Mesh2D.h>

Public Member Functions
	Mesh2D (const float64 &sample_rate, uint32 width, uint32 height, const float64 &leak_gain, const float64 &tau, const float64 &delta=6.0, const float64 &gamma=8.0)
	Constructor. More...

	Mesh2D (const Mesh2D &copy)
	Copy Constructor. More...

	~Mesh2D ()
	Destructor. More...

void	clear ()
	Clears all MeshJunctions to zero. More...

float64	getEnergy () const
	Calculate total energy in the mesh. More...

Mesh2D &	operator= (const Mesh2D &rhs)
	Assignment operator. More...

Buffer	strike (const Buffer &x_pos, const Buffer &y_pos, const Buffer &velocity)
	Hit the mesh many times at different locations. More...

Buffer	strike (const float64 &x_pos, const float64 &y_pos, const float64 &velocity)
	Hit the mesh once. More...

void	setMeshDumping (boolean flag, const std::string &dirname=".", const std::string &prefix="mesh")
	Enables the dumping of mesh values to disk for use with mesh2blender.py. More...

Private Member Functions
void	allocMemory ()
	Allocates memory for the mesh. More...

void	freeMemory ()
	Frees memory from the mesh. More...

void	writeMeshMap ()
	Write to disk the mesh map, used with mesh2blender.py. More...

void	writeMeshFile (const std::string &mode)

MeshJunction *	mesh (uint32 x, uint32 y)

float64	tick (const float64 &x_pos, const float64 &y_pos, const float64 &velocity)
	Calculate one sample. More...

Private Attributes
float64	sample_rate_

uint32	X_

uint32	Y_
	The number of MeshJunctions columns. More...

float64	leak_gain_
	The number of MeshJunctions rows. More...

float64	tau_
	MeshJunction leak gain. More...

float64	delta_
	MeshJunction tau. More...

float64	gamma_
	MeshJunction delta. More...

MeshJunction **	mesh_
	MeshJunction gamma. More...

MeshJunction *	center_
	Array of pointers. More...

boolean	dump_mesh_
	Center MeshJunction where final sound is collected. More...

std::string	dirname_

std::string	prefix_

Detailed Description

WARNING: This is Experimental, you should not use this class as it may not be working or will change in future releases of Nsound.

Definition at line 51 of file Mesh2D.h.

Constructor & Destructor Documentation

Mesh2D::Mesh2D	(	const float64 &	sample_rate,
		uint32	width,
		uint32	height,
		const float64 &	leak_gain,
		const float64 &	tau,
		const float64 &	delta = `6.0`,
		const float64 &	gamma = `8.0`
	)

Constructor.

Definition at line 48 of file Mesh2D.cc.

References allocMemory(), and tau_.

     :
     sample_rate_(sample_rate),
     X_(width),
     Y_(height),
     leak_gain_(leak_gain),
     tau_(tau),
     delta_(delta),
     gamma_(gamma),
     mesh_(NULL),
     center_(NULL),
     dump_mesh_(false),
     dirname_("."),
     prefix_("mesh")
 {
     // Range check
     if(tau_ < 0.0)
     {
         tau_ = 1e-6;
     }
     else if(tau_ > 0.5)
     {
         tau_ = 0.5;
     }
 
     allocMemory();
 }

Mesh2D::Mesh2D ( const Mesh2D & copy )

Copy Constructor.

Definition at line 85 of file Mesh2D.cc.

     :
     sample_rate_(0.0),
     X_(0),
     Y_(0),
     leak_gain_(0.0),
     tau_(0.0),
     delta_(0.0),
     gamma_(0.0),
     mesh_(NULL),
     center_(NULL),
     dump_mesh_(false),
     dirname_("."),
     prefix_("mesh")
 {
     *this = copy;
 }

Mesh2D::~Mesh2D ( )

Destructor.

Definition at line 105 of file Mesh2D.cc.

References freeMemory().

 {
     freeMemory();
 }

Member Function Documentation

void Mesh2D::clear ( )

Clears all MeshJunctions to zero.

Definition at line 159 of file Mesh2D.cc.

References Nsound::MeshJunction::clear(), mesh_, X_, and Y_.

Referenced by strike().

 {
     for(uint32 i = 0; i < X_ * Y_; ++i)
     {
         mesh_[i]->clear();
     }
 }

float64 Mesh2D::getEnergy ( ) const

Calculate total energy in the mesh.

Definition at line 182 of file Mesh2D.cc.

References Nsound::MeshJunction::getVelocity(), mesh_, X_, and Y_.

 {
     float64 energy = 0.0;
 
     for(uint32 i = 0; i < X_ * Y_; ++i)
     {
         float64 v = mesh_[i]->getVelocity();
         energy +=  v * v;
     }
 
     return energy / static_cast<float64>(X_ * Y_);
 }

Mesh2D & Mesh2D::operator= ( const Mesh2D & rhs )

Assignment operator.

Definition at line 225 of file Mesh2D.cc.

References allocMemory(), delta_, freeMemory(), gamma_, leak_gain_, tau_, X_, and Y_.

 {
     if(this == & rhs)
     {
         return *this;
     }
 
     leak_gain_ = rhs.leak_gain_;
     tau_       = rhs.tau_;
     delta_     = rhs.delta_;
     gamma_     = rhs.gamma_;
 
     freeMemory();
 
     X_ = rhs.X_;
     Y_ = rhs.Y_;
 
     allocMemory();
 
     return *this;
 }

Buffer Mesh2D::strike	(	const Buffer &	x_pos,
		const Buffer &	y_pos,
		const Buffer &	velocity
	)

Hit the mesh many times at different locations.

Definition at line 249 of file Mesh2D.cc.

References Nsound::Buffer::getLength(), and tick().

Referenced by main().

 {
     Buffer output;
 
     uint32 x_size = x_pos.getLength();
     uint32 y_size = y_pos.getLength();
 
     for(uint32 i = 0; i < velocity.getLength(); ++i)
     {
         output << tick(x_pos[i % x_size], y_pos[i % y_size], velocity[i]);
     }
 
     return output;
 }

Buffer Mesh2D::strike	(	const float64 &	x_pos,
		const float64 &	y_pos,
		const float64 &	velocity
	)

Hit the mesh once.

Definition at line 353 of file Mesh2D.cc.

References center_, clear(), Nsound::Generator::drawLine(), Nsound::MeshJunction::getVelocity(), sample_rate_, tick(), writeMeshFile(), and writeMeshMap().

 {
     Buffer output;
 
     clear();
 
     output << tick(x_pos, y_pos, velocity);
 
     writeMeshMap();
     writeMeshFile("w");
 
     for(uint32 i = 0; i < 44100; ++i)
     {
         output << tick(x_pos, y_pos, 0.0);
 
         writeMeshFile("a");
 
         center_->getVelocity();
     }
 
     // Shape the attack
     Generator gen(sample_rate_);
 
     Buffer attack = gen.drawLine(0.0025, 0.0, 1.0);
 
     return output * attack;
 }

void Mesh2D::setMeshDumping	(	boolean	flag,
		const std::string &	dirname = `"."`,
		const std::string &	prefix = `"mesh"`
	)

Enables the dumping of mesh values to disk for use with mesh2blender.py.

Definition at line 341 of file Mesh2D.cc.

References dirname_, dump_mesh_, and prefix_.

 {
     dump_mesh_ = flag;
     dirname_ = dirname;
     prefix_ = prefix;
 }

void Mesh2D::allocMemory ( )

private

Allocates memory for the mesh.

Definition at line 112 of file Mesh2D.cc.

References center_, delta_, gamma_, leak_gain_, mesh(), mesh_, Nsound::MeshJunction::setNeighborEast(), Nsound::MeshJunction::setNeighborNorth(), Nsound::MeshJunction::setNeighborSouth(), Nsound::MeshJunction::setNeighborWest(), tau_, X_, and Y_.

Referenced by Mesh2D(), and operator=().

 {
     mesh_ = new MeshJunction * [X_ * Y_];
 
     // Allocate new MeshJunctions
     for(uint32 i = 0; i < X_ * Y_; ++i)
     {
         mesh_[i] = new MeshJunction(leak_gain_, tau_, delta_, gamma_);
     }
 
     // Set neighbors.
     for(uint32 x = 0; x < X_; ++x)
     {
         for(uint32 y = 0; y < Y_; ++y)
         {
             // Set north neighbor.
             if(y + 1 < Y_)
             {
                 mesh(x,y)->setNeighborNorth(mesh(x,y+1));
             }
 
             // Set south neighbor.
             if(y >= 1)
             {
                 mesh(x,y)->setNeighborSouth(mesh(x,y-1));
             }
 
             // Set east neighbor.
             if(x + 1 < X_)
             {
                 mesh(x,y)->setNeighborEast(mesh(x+1,y));
             }
 
             // Set west neighbor.
             if(x >= 1)
             {
                 mesh(x,y)->setNeighborWest(mesh(x-1,y));
             }
         }
     }
 
     // Set the center pointer.
     center_ = mesh(X_ / 2, Y_ / 2);
 }

void Mesh2D::freeMemory ( )

private

Frees memory from the mesh.

Definition at line 169 of file Mesh2D.cc.

References mesh_, X_, and Y_.

Referenced by operator=(), and ~Mesh2D().

 {
     // delete junctions
     for(uint32 i = 0; i < X_ * Y_; ++i)
     {
         delete mesh_[i];
     }
 
     delete [] mesh_;
 }

void Mesh2D::writeMeshMap ( )

private

Write to disk the mesh map, used with mesh2blender.py.

Definition at line 269 of file Mesh2D.cc.

References dirname_, dump_mesh_, M_THROW, mesh(), prefix_, X_, and Y_.

Referenced by strike().

 {
     if(!dump_mesh_)
     {
         return;
     }
 
     std::stringstream ss;
 
     ss << dirname_ << "/" << prefix_ << "_map.txt";
 
     FILE * f_out = fopen(ss.str().c_str(), "w");
 
     if(!f_out)
     {
         M_THROW("Unable to open '" << ss.str().c_str() << "' for writing.");
         return;
     }
 
     for(int32 y = Y_ - 1; y >= 0; --y)
     {
         for(uint32 x = 0; x < X_; ++x)
         {
             if(mesh(x,y) != NULL)
             {
                 fprintf(f_out, " %5d", x + y * X_);
             }
             else
             {
                 fprintf(f_out, " -1");
             }
         }
         fprintf(f_out, "\n");
     }
     fclose(f_out);
 }

void Mesh2D::writeMeshFile ( const std::string & mode )

private

Definition at line 309 of file Mesh2D.cc.

References dirname_, dump_mesh_, M_THROW, mesh(), prefix_, X_, and Y_.

Referenced by strike().

 {
     if(!dump_mesh_)
     {
         return;
     }
 
     std::stringstream ss;
 
     ss << dirname_ << "/" << prefix_ << ".txt";
 
     FILE * f_out = fopen(ss.str().c_str(), mode.c_str());
 
     if(!f_out)
     {
         M_THROW("Unable to open '" << ss.str().c_str() << "' for writing.");
         return;
     }
 
     for(int32 y = Y_ - 1; y >= 0; --y)
     {
         for(uint32 x = 0; x < X_; ++x)
         {
             fprintf(f_out, "%6.3f ", mesh(x,y)->getVelocity());
         }
     }
     fprintf(f_out, "\n");
     fclose(f_out);
 }

MeshJunction * Mesh2D::mesh	(	uint32	x,
		uint32	y
	)

private

Definition at line 198 of file Mesh2D.cc.

References mesh_, and X_.

Referenced by allocMemory(), tick(), writeMeshFile(), and writeMeshMap().

 {
     // -----------------
     // || array index ||
     // ||  x, y       ||
     // -----------------
 
     // -----------------------
     // ||  9  || 10  || 11  ||
     // || 0,3 || 1,3 || 2,3 ||
     // -----------------------
     // ||  6  ||  7  ||  8  ||
     // || 0,2 || 1,2 || 2,2 ||
     // -----------------------
     // ||  3  ||  4  ||  5  ||
     // || 0,1 || 1,1 || 2,1 ||
     // -----------------------
     // ||  0  ||  1  ||  2  ||
     // || 0,0 || 1,0 || 2,0 ||
     // -----------------------
 
     return mesh_[y * X_ + x];
 }

float64 Mesh2D::tick	(	const float64 &	x_pos,
		const float64 &	y_pos,
		const float64 &	velocity
	)

private

Calculate one sample.

Definition at line 386 of file Mesh2D.cc.

References center_, Nsound::MeshJunction::getVelocity(), mesh(), mesh_, Nsound::MeshJunction::saveState(), Nsound::MeshJunction::strike(), Nsound::MeshJunction::updateVelocity(), X_, and Y_.

Referenced by strike().

 {
     float64 x_max = static_cast<float64>(X_);
     float64 y_max = static_cast<float64>(Y_);
 
     float64 x_strike = x_pos * x_max;
     float64 y_strike = y_pos * y_max;
 
     if(velocity > 0.0)
     {
         float64 dx = 0.5 / (X_ - 1);
 
         x_strike = 0.5 / 3.0;
         y_strike = 0.5 / 3.0;
 
         for(uint32 x = 2; x < X_; ++x)
         {
             for(uint32 y = 2; y < Y_; ++y)
             {
                 float64 x_pos = (static_cast<float64>(x) - 1.0) * dx;
                 float64 y_pos = (static_cast<float64>(y) - 1.0) * dx;
 
                 float64 xx = x_pos - x_strike;
                 xx *= xx;
 
                 float64 yy = y_pos - y_strike;
                 yy *= yy;
 
                 float64 power = velocity * std::exp(-200.0 * (xx + yy));
 
                 mesh(x, y)->strike(power);
             }
         }
     }
 
     for(uint32 i = 0; i < X_ * Y_; ++i)
     {
         mesh_[i]->saveState();
     }
 
     for(uint32 i = 0; i < X_ * Y_; ++i)
     {
         mesh_[i]->updateVelocity();
     }
 
     return center_->getVelocity();
 }