mesh_conv Namespace Reference

Namespaces
namespace	exception
namespace	implicit
namespace	mesh
namespace	object
Classes
class	MC_connectivity_index
	class of indexed connectivity stored as a vector More...
class	MC_curve
	class of 3D curve extending the MC_v3d_vector class. Ordering is important. More...
class	comparator_less_double_int
class	MC_double_vector
	A container class for a vector of double. More...
class	MC_double_vector_vector
	Container class for MC_double_vector. More...
class	MC_helper_stl
	Helper class to deal with stl container. More...
class	MC_int_pair
	Container class for pair of int. More...
class	MC_int_pair_less
	a class to ordonnate the MC_int_pair More...
class	MC_int_pair_unique
class	MC_int_pair_unique_less
	a comparator functor More...
class	comparator_less_int_int
class	MC_int_vector
	A container class for a vector of int. More...
class	MC_int_vector_vector
	Container class for MC_int_vector. More...
class	MC_io_obj
	Helper class to read and write mesh in a obj format. More...
class	MC_io_off
	Helper class to read and write mesh in a off format. More...
class	MC_matrix
	exception class for matrix More...
class	MC_mesh_fast_draw
	Mesh class for fast draw in OpenGL. More...
class	MC_mesh_index_vector
	mesh class containing connectivity and point_set based on vector More...
class	MC_mesh_index_vector_draw
	A class of indexed mesh with color, normal and texture ready to be (slowly) drawable but with easily access. More...
class	MC_navigator_tool
	Container class for the viewer, does not need to be weel written. More...
class	MC_opengl_drawer
	Class of drawer in Opengl. More...
class	MC_polygon
	Container class for a polygon. More...
class	MC_polygon_less
class	MC_quaternion
	Class of quaternion. More...
class	MC_segment
	A class to manipulate segments given by two points of R3. More...
class	MC_string_converter
	A helper class to manipulate string (token, convert, ...). More...
class	MC_string_tokenizer
	Helper class to tokenize easily a string. More...
class	MC_file_helper
	helper class with files More...
class	MC_trackball
	A container class to deal with a trackball. More...
class	MC_triangle
	Container class for a triangle. More...
class	MC_v3d
	Basic class for 3D vector. More...
class	MC_v3d_less
	Comparator class for set and map. More...
class	MC_v3d_vector
	Container class for a vector of MC_v3d. More...
class	MC_v3d_vector_less
	Comparator class for set and map of MC_v3d_vector. More...
class	MC_v4d
	Basic class for 4D vector. More...
class	MC_v4d_less
	Comparator class for set and map. More...
class	MC_grid_3d
	container for a volumetric 3d cartesian grid More...
class	MC_grid_3d_scalar
	3D grid for scalar density (use float to save space) More...
class	MC_grid_3d_scalar_marching_cube
	helper to apply marching cube on a volume data More...
class	MC_grid_3d_scalar_slicer
	helper class to slice a MC_grid_3d More...
class	MC_grid_index_spatial_hashing
	regular grid to hash index position in space More...
class	MC_particle_engine
	Particle engine based on spheres. More...
class	MC_sphere_geometry
	Model for a geometric sphere. More...
class	MC_sphere_physic
	Physical particle model associated to a sphere. More...
Functions
std::ostream &	operator<< (std::ostream &output, const MC_double_vector &in)
MC_double_vector	operator<< (const MC_double_vector &vec, const double &value)
MC_double_vector	operator<< (const MC_double_vector &vec, const MC_double_vector &to_add)
MC_double_vector	operator- (const MC_double_vector &v)
MC_double_vector	operator+ (const MC_double_vector &vec, const double &to_add)
MC_double_vector	operator- (const MC_double_vector &vec, const double &to_sub)
MC_double_vector	operator* (const MC_double_vector &vec, const double &to_mult)
MC_double_vector	operator/ (const MC_double_vector &vec, const double &to_subdiv)
MC_double_vector	operator+ (const MC_double_vector &vec, const MC_double_vector &to_add)
MC_double_vector	operator- (const MC_double_vector &vec, const MC_double_vector &to_sub)
MC_double_vector	operator* (const MC_double_vector &vec, const MC_double_vector &to_mult)
MC_double_vector	operator/ (const MC_double_vector &vec, const MC_double_vector &to_subdiv)
MC_double_vector &	operator>> (std::istream &input, MC_double_vector &vec)
MC_int_vector	operator< (const MC_double_vector &vec, const double &val)
MC_int_vector	operator<= (const MC_double_vector &vec, const double &val)
MC_int_vector	operator> (const MC_double_vector &vec, const double &val)
MC_int_vector	operator>= (const MC_double_vector &vec, const double &val)
MC_int_vector	operator== (const MC_double_vector &vec, const double &val)
MC_int_vector	operator< (const double &val, const MC_double_vector &vec)
MC_int_vector	operator<= (const double &val, const MC_double_vector &vec)
MC_int_vector	operator> (const double &val, const MC_double_vector &vec)
MC_int_vector	operator>= (const double &val, const MC_double_vector &vec)
MC_int_vector	operator== (const double &val, const MC_double_vector &vec)
MC_v3d_vector	operator* (const MC_double_vector &to_mult, const MC_v3d &vec)
MC_v3d_vector	operator* (const MC_v3d &to_mult, const MC_double_vector &vec)
MC_v3d_vector	operator/ (const MC_v3d &vec, const MC_double_vector &to_subdiv)
MC_double_vector	operator* (const double &to_mult, const MC_double_vector &vec)
MC_double_vector_vector	operator<< (const MC_double_vector_vector &vec, const MC_double_vector &value)
MC_double_vector_vector	operator<< (const MC_double_vector_vector &vec, const MC_double_vector_vector &to_add)
std::ostream &	operator<< (std::ostream &stream, const MC_double_vector_vector &input)
MC_double_vector_vector	operator+ (const MC_double_vector_vector &vec, const double &to_add)
MC_double_vector_vector	operator- (const MC_double_vector_vector &vec, const double &to_add)
bool	operator== (const MC_int_pair &p0, const MC_int_pair &p1)
bool	operator!= (const MC_int_pair &p0, const MC_int_pair &p1)
std::ostream &	operator<< (std::ostream &stream, const MC_int_pair &p)
MC_int_pair	operator+ (const MC_int_pair &p, const int &a)
MC_int_pair	operator- (const MC_int_pair &p, const int &a)
bool	operator== (const MC_int_pair_unique &p0, const MC_int_pair_unique &p1)
bool	operator!= (const MC_int_pair_unique &p1, const MC_int_pair_unique &p2)
std::ostream &	operator<< (std::ostream &stream, const MC_int_pair_unique &_v)
std::ostream &	operator<< (std::ostream &output, const MC_int_vector &in)
MC_int_vector	operator<< (const MC_int_vector &vec, const int &value)
mesh_conv::MC_int_vector	operator<< (const mesh_conv::MC_int_vector &vec, const mesh_conv::MC_int_vector &to_add)
MC_int_vector	operator+ (const MC_int_vector &vec, const int &to_add)
MC_int_vector	operator- (const MC_int_vector &vec, const int &to_sub)
MC_int_vector	operator* (const MC_int_vector &vec, const int &to_mult)
MC_int_vector	operator/ (const MC_int_vector &vec, const int &to_subdiv)
MC_int_vector	operator+ (const MC_int_vector &vec, const MC_int_vector &to_add)
MC_int_vector	operator- (const MC_int_vector &vec, const MC_int_vector &to_sub)
MC_int_vector	operator* (const MC_int_vector &vec, const MC_int_vector &to_mult)
MC_int_vector	operator/ (const MC_int_vector &vec, const MC_int_vector &to_subdiv)
mesh_conv::MC_int_vector &	operator>> (std::istream &input, mesh_conv::MC_int_vector &vec)
MC_int_vector	operator< (const MC_int_vector &vec, const int &val)
MC_int_vector	operator<= (const MC_int_vector &vec, const int &val)
MC_int_vector	operator> (const MC_int_vector &vec, const int &val)
MC_int_vector	operator>= (const MC_int_vector &vec, const int &val)
MC_int_vector	operator== (const MC_int_vector &vec, const int &val)
MC_int_vector	operator< (const int &val, const MC_int_vector &vec)
MC_int_vector	operator<= (const int &val, const MC_int_vector &vec)
MC_int_vector	operator> (const int &val, const MC_int_vector &vec)
MC_int_vector	operator>= (const int &val, const MC_int_vector &vec)
MC_int_vector	operator== (const int &val, const MC_int_vector &vec)
MC_int_vector_vector	operator<< (const MC_int_vector_vector &vec, const MC_int_vector &value)
MC_int_vector_vector	operator<< (const MC_int_vector_vector &vec, const MC_int_vector_vector &to_add)
std::ostream &	operator<< (std::ostream &stream, const MC_int_vector_vector &input)
MC_int_vector_vector	operator+ (const MC_int_vector_vector &vec, const int &to_add)
MC_int_vector_vector	operator- (const MC_int_vector_vector &vec, const int &to_add)
std::ostream &	operator<< (std::ostream &stream, const MC_matrix &_M)
MC_matrix	operator+ (const MC_matrix &M1, const double &alpha)
MC_matrix	operator+ (const double &alpha, const MC_matrix &M1)
MC_matrix	operator- (const MC_matrix &M1, const double &alpha)
MC_matrix	operator- (const double &alpha, const MC_matrix &M1)
MC_matrix	operator* (const MC_matrix &M1, const double &alpha)
MC_matrix	operator* (const double &alpha, const MC_matrix &M1)
MC_matrix	operator/ (const MC_matrix &M1, const double &alpha)
MC_matrix	operator/ (const double &alpha, const MC_matrix &M1)
MC_matrix	operator+ (const MC_matrix &M1, const MC_matrix &M2)
MC_matrix	operator- (const MC_matrix &M1, const MC_matrix &M2)
MC_matrix	operator* (const MC_matrix &M1, const MC_matrix &M2)
MC_matrix	operator* (const MC_matrix &M1, const MC_v3d &V)
MC_double_vector	operator* (const MC_matrix &M1, const MC_double_vector &v)
MC_mesh_index_vector	operator+ (const MC_mesh_index_vector &vec, const MC_v3d &to_add)
MC_mesh_index_vector	operator- (const MC_mesh_index_vector &vec, const MC_v3d &to_sub)
MC_mesh_index_vector	operator+ (const MC_mesh_index_vector &vec, const MC_v3d_vector &to_add)
MC_mesh_index_vector	operator- (const MC_mesh_index_vector &vec, const MC_v3d_vector &to_sub)
MC_mesh_index_vector	operator* (const MC_mesh_index_vector &vec, const double &to_mult)
MC_mesh_index_vector	operator* (const double &to_mult, const MC_mesh_index_vector &vec)
MC_mesh_index_vector	operator/ (const MC_mesh_index_vector &vec, const double &to_subdiv)
MC_mesh_index_vector	operator* (const MC_matrix &M, const MC_mesh_index_vector &mesh)
MC_mesh_index_vector	operator<< (const MC_mesh_index_vector &vec0, const MC_mesh_index_vector &vec1)
MC_mesh_index_vector_draw	operator<< (const MC_mesh_index_vector_draw &vec0, const MC_mesh_index_vector_draw &vec1)
MC_mesh_index_vector_draw	operator* (const MC_matrix &M, const MC_mesh_index_vector_draw &mesh)
MC_mesh_index_vector_draw	operator* (const MC_mesh_index_vector_draw &mesh, const MC_matrix &M)
MC_mesh_index_vector_draw	operator* (const double &s, const MC_mesh_index_vector_draw &mesh)
MC_mesh_index_vector_draw	operator* (const MC_mesh_index_vector_draw &mesh, const double &s)
MC_mesh_index_vector_draw	operator+ (const MC_mesh_index_vector_draw &vec, const MC_v3d &to_add)
MC_mesh_index_vector_draw	operator- (const MC_mesh_index_vector_draw &vec, const MC_v3d &to_sub)
MC_mesh_index_vector_draw	operator+ (const MC_mesh_index_vector_draw &vec, const MC_v3d_vector &to_add)
MC_mesh_index_vector_draw	operator- (const MC_mesh_index_vector_draw &vec, const MC_v3d_vector &to_sub)
MC_mesh_index_vector_draw	operator+ (const MC_v3d &to_add, const MC_mesh_index_vector_draw &vec)
MC_mesh_index_vector_draw	operator- (const MC_v3d &to_sub, const MC_mesh_index_vector_draw &vec)
MC_mesh_index_vector_draw	operator+ (const MC_v3d_vector &to_add, const MC_mesh_index_vector_draw &vec)
MC_mesh_index_vector_draw	operator- (const MC_v3d_vector &to_sub, const MC_mesh_index_vector_draw &vec)
MC_mesh_index_vector_draw	operator/ (const MC_mesh_index_vector_draw &vec, const double &to_subdiv)
MC_quaternion	operator* (const MC_quaternion &q0, const MC_quaternion &q1)
MC_segment	operator+ (const MC_segment &s, const MC_v3d &x)
MC_segment	operator+ (const MC_v3d &x, const MC_segment &s)
MC_segment	operator* (const MC_segment &s, const double &a)
MC_segment	operator* (const double &a, const MC_segment &s)
std::ostream &	operator<< (std::ostream &stream, const MC_segment &s)
MC_v3d	operator+ (const MC_v3d &vec, const double &to_add)
MC_v3d	operator- (const MC_v3d &vec, const double &to_sub)
MC_v3d	operator* (const MC_v3d &vec, const double &to_mult)
MC_v3d	operator* (const double &to_mult, const MC_v3d &vec)
MC_v3d	operator/ (const MC_v3d &vec, const double &to_subdiv)
MC_v3d	operator+ (const MC_v3d &vec, const MC_v3d &to_add)
MC_v3d	operator- (const MC_v3d &vec, const MC_v3d &to_sub)
std::ostream &	operator<< (std::ostream &stream, const MC_v3d &v)
bool	operator>> (std::istream &stream, MC_v3d &vec)
MC_v3d	operator* (const MC_quaternion &q, const MC_v3d &vec)
bool	operator== (const MC_v3d &a1, const MC_v3d &a2)
bool	operator!= (const MC_v3d &a1, const MC_v3d &a2)
MC_v3d_vector	operator+ (const MC_v3d_vector &vec, const MC_v3d &to_add)
MC_v3d_vector	operator+ (const MC_v3d &to_add, const MC_v3d_vector &vec)
MC_v3d_vector	operator- (const MC_v3d_vector &vec, const MC_v3d &to_sub)
MC_v3d_vector	operator* (const MC_v3d_vector &vec, const double &to_mult)
MC_v3d_vector	operator/ (const MC_v3d_vector &vec, const double &to_subdiv)
MC_v3d_vector	operator+ (const MC_v3d_vector &vec, const MC_v3d_vector &to_add)
MC_v3d_vector	operator- (const MC_v3d_vector &vec, const MC_v3d_vector &to_sub)
std::ostream &	operator<< (std::ostream &output, const MC_v3d_vector &in)
MC_v3d_vector	operator<< (const MC_v3d_vector &vec, const MC_v3d &value)
MC_v3d_vector	operator<< (const MC_v3d_vector &vec, const MC_v3d_vector &value)
MC_v3d_vector	operator* (const MC_matrix &M, const MC_v3d_vector &vec)
MC_v3d_vector	operator* (const MC_double_vector w, const MC_v3d_vector &vec)
MC_v3d_vector	operator* (const MC_v3d_vector &vec, const MC_double_vector &w)
MC_v3d_vector	operator* (const double &to_mult, const MC_v3d_vector &vec)
MC_v4d	operator+ (const MC_v4d &vec, const double &to_add)
MC_v4d	operator- (const MC_v4d &vec, const double &to_sub)
MC_v4d	operator* (const MC_v4d &vec, const double &to_mult)
MC_v4d	operator* (const double &to_mult, const MC_v4d &vec)
MC_v4d	operator/ (const MC_v4d &vec, const double &to_subdiv)
MC_v4d	operator+ (const MC_v4d &vec, const MC_v4d &to_add)
MC_v4d	operator- (const MC_v4d &vec, const MC_v4d &to_sub)
std::ostream &	operator<< (std::ostream &stream, const MC_v4d &v)
MC_v4d &	operator>> (std::istream &stream, MC_v4d &vec)

Function Documentation

bool mesh_conv::operator!=	(	const MC_v3d &	a1,
		const MC_v3d &	a2
	)

Definition at line 254 of file MC_v3d.cpp.

00255     {return !(a1==a2);}

bool mesh_conv::operator!=	(	const MC_int_pair_unique &	p1,
		const MC_int_pair_unique &	p2
	)

Definition at line 36 of file MC_int_pair_unique.cpp.

00037     {return !(p1==p2);}

bool mesh_conv::operator!=	(	const MC_int_pair &	p0,
		const MC_int_pair &	p1
	)

Definition at line 20 of file MC_int_pair.cpp.

References mesh_conv::MC_int_pair::u0, and mesh_conv::MC_int_pair::u1.

00021     {
00022         if( ( (p0.u0==p1.u0) && (p0.u1==p1.u1) ) || ( (p0.u0==p1.u1) && (p0.u1==p1.u0) ))
00023             return false;
00024         return true;
00025     }

MC_v4d mesh_conv::operator*	(	const double &	to_mult,
		const MC_v4d &	vec
	)

Definition at line 62 of file MC_v4d.cpp.

00063 {return vec*to_mult;}

MC_v4d mesh_conv::operator*	(	const MC_v4d &	vec,
		const double &	to_mult
	)

Definition at line 60 of file MC_v4d.cpp.

00061 {return MC_v4d(vec[0]*to_mult,vec[1]*to_mult,vec[2]*to_mult,vec[3]*to_mult);}

MC_v3d_vector mesh_conv::operator*	(	const double &	to_mult,
		const MC_v3d_vector &	vec
	)

Definition at line 473 of file MC_v3d_vector.cpp.

00474     {return vec*to_mult;}

MC_v3d_vector mesh_conv::operator*	(	const MC_v3d_vector &	vec,
		const MC_double_vector &	w
	)

Definition at line 407 of file MC_v3d_vector.cpp.

00408     {return w*vec;}

MC_v3d_vector mesh_conv::operator*	(	const MC_double_vector	w,
		const MC_v3d_vector &	vec
	)

Definition at line 386 of file MC_v3d_vector.cpp.

References mesh_conv::MC_double_vector::first(), mesh_conv::MC_double_vector::size(), and mesh_conv::MC_v3d_vector::size().

00387     {
00388         int N=vec.size();
00389         MC_v3d_vector res(N);
00390 
00391         if(w.size()==1 && N!=1)
00392         {
00393             double dw=w.first();
00394             for(int k=0;k<N;++k)
00395                 res[k]=dw*vec[k];
00396             return res;
00397         }
00398         else if(w.size()==N)
00399         {
00400             for(int k=0;k<N;++k)
00401                 res[k]=w[k]*vec[k];
00402             return res;
00403         }
00404         else
00405         {std::cout<<"Error in MC_v3d_vector::operator*(MC_double_vector("<<w.size()<<"),MC_v3d_vector("<<vec.size()<<")), size are not compatible"<<std::endl;exit(-1);}
00406     }

Here is the call graph for this function:

MC_v3d_vector mesh_conv::operator*	(	const MC_matrix &	M,
		const MC_v3d_vector &	vec
	)

Definition at line 369 of file MC_v3d_vector.cpp.

References mesh_conv::MC_v3d_vector::size().

00370     {
00371         int N=vec.size();
00372         MC_v3d_vector new_vector(N);
00373         for(int k=0;k<N;++k)
00374         {new_vector[k]=M*vec[k];}
00375 
00376         return new_vector;
00377     }

Here is the call graph for this function:

MC_v3d_vector mesh_conv::operator*	(	const MC_v3d_vector &	vec,
		const double &	to_mult
	)

Definition at line 142 of file MC_v3d_vector.cpp.

References mesh_conv::MC_v3d_vector::resize(), and mesh_conv::MC_v3d_vector::size().

00143     {
00144         int N=vec.size();
00145         MC_v3d_vector new_vec;new_vec.resize(N);
00146         for(int k=0;k<N;++k)
00147             new_vec[k]=vec[k]*to_mult;
00148         return new_vec;
00149     }

Here is the call graph for this function:

MC_v3d mesh_conv::operator*	(	const MC_quaternion &	q,
		const MC_v3d &	vec
	)

Definition at line 228 of file MC_v3d.cpp.

References mesh_conv::MC_quaternion::conjugated(), and mesh_conv::MC_v4d::set_v3d().

00229     {
00230         MC_quaternion q_b=q.conjugated();
00231         MC_quaternion v_quat;
00232         v_quat.set_v3d(vec);
00233 
00234         MC_quaternion result = q*v_quat*q_b;
00235         return MC_v3d(result[0],result[1],result[2]);
00236     }

Here is the call graph for this function:

MC_v3d mesh_conv::operator*	(	const double &	to_mult,
		const MC_v3d &	vec
	)

Definition at line 71 of file MC_v3d.cpp.

00072 {return vec*to_mult;}

MC_v3d mesh_conv::operator*	(	const MC_v3d &	vec,
		const double &	to_mult
	)

Definition at line 69 of file MC_v3d.cpp.

00070 {return MC_v3d(vec[0]*to_mult,vec[1]*to_mult,vec[2]*to_mult);}

MC_segment mesh_conv::operator*	(	const double &	a,
		const MC_segment &	s
	)

Definition at line 259 of file MC_segment.cpp.

00260     {return s*a;}

MC_segment mesh_conv::operator*	(	const MC_segment &	s,
		const double &	a
	)

Definition at line 257 of file MC_segment.cpp.

00258     {return MC_segment(s[0]*a,s[1]*a);}

MC_quaternion mesh_conv::operator*	(	const MC_quaternion &	q0,
		const MC_quaternion &	q1
	)

Definition at line 69 of file MC_quaternion.cpp.

References mesh_conv::MC_v3d::cross(), mesh_conv::MC_v3d::dot(), and mesh_conv::MC_v4d::set_v3d().

00070     {
00071         MC_quaternion q2;
00072         double w0=q0[3],w1=q1[3];
00073         MC_v3d v0=MC_v3d(q0[0],q0[1],q0[2]);
00074         MC_v3d v1=MC_v3d(q1[0],q1[1],q1[2]);
00075 
00076         q2[3]=w0*w1-v0.dot(v1);
00077         q2.set_v3d(w0*v1+w1*v0-v0.cross(v1));
00078 
00079         return q2;
00080     }

Here is the call graph for this function:

MC_mesh_index_vector_draw mesh_conv::operator*	(	const MC_mesh_index_vector_draw &	mesh,
		const double &	s
	)

Definition at line 165 of file MC_mesh_index_vector_draw.cpp.

00166     {return s*mesh;}

MC_mesh_index_vector_draw mesh_conv::operator*	(	const double &	s,
		const MC_mesh_index_vector_draw &	mesh
	)

Definition at line 159 of file MC_mesh_index_vector_draw.cpp.

References mesh_conv::MC_mesh_index_vector::point_set().

00160     {
00161         MC_mesh_index_vector_draw m1=mesh;
00162         m1.point_set()=s*m1.point_set();
00163         return m1;
00164     }

Here is the call graph for this function:

MC_mesh_index_vector_draw mesh_conv::operator*	(	const MC_mesh_index_vector_draw &	mesh,
		const MC_matrix &	M
	)

Definition at line 157 of file MC_mesh_index_vector_draw.cpp.

00158     {return M*mesh;}

MC_mesh_index_vector_draw mesh_conv::operator*	(	const MC_matrix &	M,
		const MC_mesh_index_vector_draw &	mesh
	)

Definition at line 151 of file MC_mesh_index_vector_draw.cpp.

References mesh_conv::MC_mesh_index_vector::point_set().

00152     {
00153         MC_mesh_index_vector_draw m1=mesh;
00154         m1.point_set()=M*m1.point_set();
00155         return m1;
00156     }

Here is the call graph for this function:

MC_mesh_index_vector mesh_conv::operator*	(	const MC_matrix &	M,
		const MC_mesh_index_vector &	mesh
	)

Definition at line 122 of file MC_mesh_index_vector.cpp.

References mesh_conv::MC_mesh_index_vector::connectivity(), and mesh_conv::MC_mesh_index_vector::point_set().

00123     {return MC_mesh_index_vector(M*mesh.point_set(),mesh.connectivity());}

Here is the call graph for this function:

MC_mesh_index_vector mesh_conv::operator*	(	const double &	to_mult,
		const MC_mesh_index_vector &	vec
	)

Definition at line 104 of file MC_mesh_index_vector.cpp.

00105     {return vec*to_mult;}

MC_mesh_index_vector mesh_conv::operator*	(	const MC_mesh_index_vector &	vec,
		const double &	to_mult
	)

Definition at line 102 of file MC_mesh_index_vector.cpp.

References mesh_conv::MC_mesh_index_vector::connectivity(), and mesh_conv::MC_mesh_index_vector::point_set().

00103     {return MC_mesh_index_vector(vec.point_set()*to_mult,vec.connectivity());}

Here is the call graph for this function:

MC_double_vector mesh_conv::operator*	(	const MC_matrix &	M1,
		const MC_double_vector &	v
	)

Definition at line 1237 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::add_col(), mesh_conv::MC_matrix::size(), mesh_conv::MC_double_vector::size(), mesh_conv::MC_matrix::size_2(), and mesh_conv::MC_matrix::to_vec().

01238 {
01239     if(M1.size_2()!=v.size())
01240     {std::cout<<"Error in MC_matrix::operator*(const MC_matrix& M1,const MC_double_vector& v), size are not compatible : ["<<M1.size()<<"]x"<<v.size()<<std::endl;exit(-1);}
01241 
01242     MC_matrix m;m.add_col(v);
01243     return (M1*m).to_vec();
01244 }

Here is the call graph for this function:

MC_matrix mesh_conv::operator*	(	const MC_matrix &	M1,
		const MC_v3d &	V
	)

Definition at line 669 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00670 {
00671   MC_matrix vec(V);
00672 
00673   
00674   if(M1.size_2()==4)
00675     vec(3,0)=1; //automatic add the 1 value
00676 
00677 
00678   if(M1.size_2()==3 || M1.size_2()==4) 
00679     {return M1*vec;}
00680   else {std::cout<<"Error in MC_matrix::operator*(MC_matrix,MC_v3d), size of Matrix ("<<M1.size_1()<<","<<M1.size_2()<<") are not compatible"<<std::endl;exit(-1);}
00681   
00682 }

Here is the call graph for this function:

MC_matrix mesh_conv::operator*	(	const MC_matrix &	M1,
		const MC_matrix &	M2
	)

Definition at line 576 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00577 {
00578   if(M1.size_2()!=M2.size_1())
00579     {std::cout<<"Error in MC_matrix::operator*(matrix,matrix), size are not compatible ("<<M1.size_1()<<","<<M1.size_2()<<") x ("<<M2.size_1()<<","<<M2.size_2()<<")"<<std::endl;exit(-1);}
00580   
00581   MC_matrix temp(M1.size_1(),M2.size_2());
00582   int k=0,N=M1.size_2();
00583   int k1=0,k2=0;
00584   int N1=M1.size_1(),N2=M2.size_2();
00585   for(k1=0;k1<N1;k1++)
00586     for(k2=0;k2<N2;k2++)
00587       for(k=0;k<N;k++)
00588         temp(k1,k2) += M1(k1,k)*M2(k,k2);
00589 
00590   return temp;
00591 }

Here is the call graph for this function:

MC_matrix mesh_conv::operator*	(	const double &	alpha,
		const MC_matrix &	M1
	)

Definition at line 515 of file MC_matrix.cpp.

00516 {return M1*alpha;}

MC_matrix mesh_conv::operator*	(	const MC_matrix &	M1,
		const double &	alpha
	)

Definition at line 505 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00506 {
00507   MC_matrix temp=M1;
00508   int k1=0,k2=0;
00509   int N1=M1.size_1(),N2=M1.size_2();
00510   for(k1=0;k1<N1;k1++)
00511     for(k2=0;k2<N2;k2++)
00512       temp(k1,k2)*=alpha;
00513   return temp;
00514 }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator*	(	const MC_int_vector &	vec,
		const MC_int_vector &	to_mult
	)

Definition at line 304 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::first(), mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00305   {
00306     if(to_mult.size()==1)
00307       return vec*to_mult.first();
00308     else
00309       {
00310         if(vec.size()!=to_mult.size())
00311           {std::cout<<"Error in MC_int_vector::operator*(MC_int_vector,MC_int_vector), size are not compatible "<<vec.size()<<";"<<to_mult.size()<<std::endl;exit(-1);}
00312         
00313 
00314         int N=vec.size();
00315         MC_int_vector new_vec=MC_int_vector::zeros(N);
00316         for(int k=0;k<N;++k)
00317           new_vec[k]=vec[k]*to_mult[k];
00318         return new_vec;
00319       }
00320   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator*	(	const MC_int_vector &	vec,
		const int &	to_mult
	)

Definition at line 217 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00218   {
00219    int N=vec.size();
00220     MC_int_vector new_vec=MC_int_vector::zeros(N);
00221     for(int k=0;k<N;k++)
00222       new_vec[k]=vec[k]*to_mult;
00223     return new_vec;
00224   }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator*	(	const double &	to_mult,
		const MC_double_vector &	vec
	)

Definition at line 691 of file MC_double_vector.cpp.

00692     {return vec*to_mult;}

MC_v3d_vector mesh_conv::operator*	(	const MC_v3d &	to_mult,
		const MC_double_vector &	vec
	)

Definition at line 590 of file MC_double_vector.cpp.

00591    {return vec*to_mult;}

MC_v3d_vector mesh_conv::operator*	(	const MC_double_vector &	to_mult,
		const MC_v3d &	vec
	)

Definition at line 582 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size().

00583    {
00584        int N=to_mult.size();
00585        MC_v3d_vector res(N);
00586        for(int k=0;k<N;++k)
00587            res[k]=vec*to_mult[k];
00588        return res;
00589    }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator*	(	const MC_double_vector &	vec,
		const MC_double_vector &	to_mult
	)

Definition at line 287 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::first(), mesh_conv::MC_double_vector::size(), and mesh_conv::MC_double_vector::zeros().

00288   {
00289       if(to_mult.size()==1)
00290           return vec*to_mult.first();
00291       else
00292       {
00293           if(vec.size()!=to_mult.size())
00294           {std::cout<<"Error in MC_double_vector::operator*(MC_double_vector,MC_double_vector), size are not compatible "<<vec.size()<<";"<<to_mult.size()<<std::endl;exit(-1);}
00295 
00296 
00297           int N=vec.size();
00298           MC_double_vector new_vec=MC_double_vector::zeros(N);
00299           for(int k=0;k<N;++k)
00300               new_vec[k]=vec[k]*to_mult[k];
00301           return new_vec;
00302       }
00303   }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator*	(	const MC_double_vector &	vec,
		const double &	to_mult
	)

Definition at line 200 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_double_vector::zeros().

00201   {
00202       int N=vec.size();
00203       MC_double_vector new_vec=MC_double_vector::zeros(N);
00204       for(int k=0;k<N;k++)
00205           new_vec[k]=vec[k]*to_mult;
00206       return new_vec;
00207   }

Here is the call graph for this function:

MC_v4d mesh_conv::operator+	(	const MC_v4d &	vec,
		const MC_v4d &	to_add
	)

Definition at line 73 of file MC_v4d.cpp.

00074 {return MC_v4d(vec[0]+to_add[0],vec[1]+to_add[1],vec[2]+to_add[2],vec[3]+to_add[3]);}

MC_v4d mesh_conv::operator+	(	const MC_v4d &	vec,
		const double &	to_add
	)

Definition at line 56 of file MC_v4d.cpp.

00057 {return MC_v4d(vec[0]+to_add,vec[1]+to_add,vec[2]+to_add,vec[3]+to_add);}

MC_v3d_vector mesh_conv::operator+	(	const MC_v3d_vector &	vec,
		const MC_v3d_vector &	to_add
	)

Definition at line 162 of file MC_v3d_vector.cpp.

References mesh_conv::MC_v3d_vector::first(), mesh_conv::MC_v3d_vector::size(), and mesh_conv::MC_v3d_vector::zeros().

00163     {
00164         if(to_add.size()==1)
00165             return vec+to_add.first();
00166         else
00167         {
00168             if(vec.size()!=to_add.size())
00169             {std::cout<<"Error in MC_v3d_vector::operator+(MC_v3d_vector,MC_v3d_vector), size are not compatible "<<vec.size()<<";"<<to_add.size()<<std::endl;exit(-1);}
00170 
00171 
00172             int N=vec.size();
00173             MC_v3d_vector new_vec=MC_v3d_vector::zeros(N);
00174             for(int k=0;k<N;++k)
00175                 new_vec[k]=vec[k]+to_add[k];
00176             return new_vec;
00177         }
00178     }

Here is the call graph for this function:

MC_v3d_vector mesh_conv::operator+	(	const MC_v3d &	to_add,
		const MC_v3d_vector &	vec
	)

Definition at line 133 of file MC_v3d_vector.cpp.

00133 {return vec+to_add;}

MC_v3d_vector mesh_conv::operator+	(	const MC_v3d_vector &	vec,
		const MC_v3d &	to_add
	)

Definition at line 125 of file MC_v3d_vector.cpp.

References mesh_conv::MC_v3d_vector::resize(), and mesh_conv::MC_v3d_vector::size().

00126     {
00127         int N=vec.size();
00128         MC_v3d_vector new_vec;new_vec.resize(N);
00129         for(int k=0;k<N;++k)
00130             new_vec[k]=vec[k]+to_add;
00131         return new_vec;
00132     }

Here is the call graph for this function:

MC_v3d mesh_conv::operator+	(	const MC_v3d &	vec,
		const MC_v3d &	to_add
	)

Definition at line 82 of file MC_v3d.cpp.

00083 {return MC_v3d(vec[0]+to_add[0],vec[1]+to_add[1],vec[2]+to_add[2]);}

MC_v3d mesh_conv::operator+	(	const MC_v3d &	vec,
		const double &	to_add
	)

Definition at line 65 of file MC_v3d.cpp.

00066 {return MC_v3d(vec[0]+to_add,vec[1]+to_add,vec[2]+to_add);}

MC_segment mesh_conv::operator+	(	const MC_v3d &	x,
		const MC_segment &	s
	)

Definition at line 255 of file MC_segment.cpp.

00256     {return s+x;}

MC_segment mesh_conv::operator+	(	const MC_segment &	s,
		const MC_v3d &	x
	)

Definition at line 253 of file MC_segment.cpp.

00254     {return MC_segment(s[0]+x,s[1]+x);}

MC_mesh_index_vector_draw mesh_conv::operator+	(	const MC_v3d_vector &	to_add,
		const MC_mesh_index_vector_draw &	vec
	)

Definition at line 182 of file MC_mesh_index_vector_draw.cpp.

00183     {return vec+to_add;}

MC_mesh_index_vector_draw mesh_conv::operator+	(	const MC_v3d &	to_add,
		const MC_mesh_index_vector_draw &	vec
	)

Definition at line 178 of file MC_mesh_index_vector_draw.cpp.

00179     {return vec+to_add;}

MC_mesh_index_vector_draw mesh_conv::operator+	(	const MC_mesh_index_vector_draw &	vec,
		const MC_v3d_vector &	to_add
	)

Definition at line 173 of file MC_mesh_index_vector_draw.cpp.

References mesh_conv::MC_mesh_index_vector::point_set().

00174     {MC_mesh_index_vector_draw res=vec;res.point_set()+=to_add;return res;}

Here is the call graph for this function:

MC_mesh_index_vector_draw mesh_conv::operator+	(	const MC_mesh_index_vector_draw &	vec,
		const MC_v3d &	to_add
	)

Definition at line 169 of file MC_mesh_index_vector_draw.cpp.

References mesh_conv::MC_mesh_index_vector::point_set().

00170     {MC_mesh_index_vector_draw res=vec;res.point_set()+=to_add;return res;}

Here is the call graph for this function:

MC_mesh_index_vector mesh_conv::operator+	(	const MC_mesh_index_vector &	vec,
		const MC_v3d_vector &	to_add
	)

Definition at line 98 of file MC_mesh_index_vector.cpp.

References mesh_conv::MC_mesh_index_vector::connectivity(), and mesh_conv::MC_mesh_index_vector::point_set().

00099     {return MC_mesh_index_vector(vec.point_set()+to_add,vec.connectivity());}

Here is the call graph for this function:

MC_mesh_index_vector mesh_conv::operator+	(	const MC_mesh_index_vector &	vec,
		const MC_v3d &	to_add
	)

Definition at line 94 of file MC_mesh_index_vector.cpp.

References mesh_conv::MC_mesh_index_vector::connectivity(), and mesh_conv::MC_mesh_index_vector::point_set().

00095     {return MC_mesh_index_vector(vec.point_set()+to_add,vec.connectivity());}

Here is the call graph for this function:

MC_matrix mesh_conv::operator+	(	const MC_matrix &	M1,
		const MC_matrix &	M2
	)

Definition at line 552 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::M, mesh_conv::MC_double_vector::size(), mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00553 {
00554   if(M1.size_1()!=M2.size_1() || M1.size_2()!=M2.size_2())
00555     {std::cout<<"Error in MC_matrix::operator+(matrix,matrix), size are not compatible ("<<M1.size_1()<<","<<M1.size_2()<<")!=("<<M2.size_1()<<","<<M2.size_2()<<std::endl;exit(-1);}
00556   
00557   MC_matrix temp(M1.size_1(),M1.size_2());
00558   int k=0,N=M1.M.size();
00559   for(k=0;k<N;k++)
00560     temp.M[k] = M1.M[k]+M2.M[k];
00561   return temp;
00562 }

Here is the call graph for this function:

MC_matrix mesh_conv::operator+	(	const double &	alpha,
		const MC_matrix &	M1
	)

Definition at line 481 of file MC_matrix.cpp.

00482 {return M1+alpha;}

MC_matrix mesh_conv::operator+	(	const MC_matrix &	M1,
		const double &	alpha
	)

Definition at line 471 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00472 {
00473   MC_matrix temp=M1;
00474   int k1=0,k2=0;
00475   int N1=M1.size_1(),N2=M1.size_2();
00476   for(k1=0;k1<N1;k1++)
00477     for(k2=0;k2<N2;k2++)
00478       temp(k1,k2)+=alpha;
00479   return temp;
00480 }

Here is the call graph for this function:

MC_int_vector_vector mesh_conv::operator+	(	const MC_int_vector_vector &	vec,
		const int &	to_add
	)

Definition at line 167 of file MC_int_vector_vector.cpp.

References mesh_conv::MC_int_vector_vector::resize(), and mesh_conv::MC_int_vector_vector::size().

00168     {
00169 
00170         int N=vec.size();
00171         MC_int_vector_vector res;res.resize(N);
00172         for(int k=0;k<N;++k)
00173             res[k]=vec[k]+to_add;
00174         return res;
00175     }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator+	(	const MC_int_vector &	vec,
		const MC_int_vector &	to_add
	)

Definition at line 268 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::first(), mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00269   {
00270     if(to_add.size()==1)
00271       return vec+to_add.first();
00272     else if(vec.size()==1)
00273         return to_add+static_cast<int>(vec.first());
00274     else
00275       {
00276         if(vec.size()!=to_add.size())
00277           {std::cout<<"Error in MC_int_vector::operator+(MC_int_vector,MC_int_vector), size are not compatible "<<vec.size()<<";"<<to_add.size()<<std::endl;exit(-1);}
00278         
00279 
00280         int N=vec.size();
00281         MC_int_vector new_vec=MC_int_vector::zeros(N);
00282         for(int k=0;k<N;++k)
00283           new_vec[k]=vec[k]+to_add[k];
00284         return new_vec;
00285       }
00286   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator+	(	const MC_int_vector &	vec,
		const int &	to_add
	)

Definition at line 201 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00202   {
00203     int N=vec.size();
00204     MC_int_vector new_vec=MC_int_vector::zeros(N);
00205     for(int k=0;k<N;k++)
00206       new_vec[k]=vec[k]+to_add;
00207     return new_vec;
00208   }

Here is the call graph for this function:

MC_int_pair mesh_conv::operator+	(	const MC_int_pair &	p,
		const int &	a
	)

Definition at line 79 of file MC_int_pair.cpp.

00080     {return MC_int_pair(p[0]+a,p[1]+a);}

MC_double_vector_vector mesh_conv::operator+	(	const MC_double_vector_vector &	vec,
		const double &	to_add
	)

Definition at line 171 of file MC_double_vector_vector.cpp.

References mesh_conv::MC_double_vector_vector::resize(), and mesh_conv::MC_double_vector_vector::size().

00172     {
00173 
00174         int N=vec.size();
00175         MC_double_vector_vector res;res.resize(N);
00176         for(int k=0;k<N;++k)
00177             res[k]=vec[k]+to_add;
00178         return res;
00179     }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator+	(	const MC_double_vector &	vec,
		const MC_double_vector &	to_add
	)

Definition at line 253 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::first(), mesh_conv::MC_double_vector::size(), and mesh_conv::MC_double_vector::zeros().

00254   {
00255     if(to_add.size()==1)
00256       return vec+to_add.first();
00257     else
00258       {
00259         if(vec.size()!=to_add.size())
00260           {std::cout<<"Error in MC_double_vector::operator+(MC_double_vector,MC_double_vector), size are not compatible "<<vec.size()<<";"<<to_add.size()<<std::endl;exit(-1);}
00261         
00262 
00263         int N=vec.size();
00264         MC_double_vector new_vec=MC_double_vector::zeros(N);
00265         for(int k=0;k<N;++k)
00266           new_vec[k]=vec[k]+to_add[k];
00267         return new_vec;
00268       }
00269   }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator+	(	const MC_double_vector &	vec,
		const double &	to_add
	)

Definition at line 181 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_double_vector::zeros().

00182   {
00183     int N=vec.size();
00184     MC_double_vector new_vec=MC_double_vector::zeros(N);
00185     for(int k=0;k<N;k++)
00186       new_vec[k]=vec[k]+to_add;
00187     return new_vec;
00188   }

Here is the call graph for this function:

MC_v4d mesh_conv::operator-	(	const MC_v4d &	vec,
		const MC_v4d &	to_sub
	)

Definition at line 75 of file MC_v4d.cpp.

00076 {return MC_v4d(vec[0]-to_sub[0],vec[1]-to_sub[1],vec[2]-to_sub[2],vec[3]-to_sub[3]);}

MC_v4d mesh_conv::operator-	(	const MC_v4d &	vec,
		const double &	to_sub
	)

Definition at line 58 of file MC_v4d.cpp.

00059 {return MC_v4d(vec[0]-to_sub,vec[1]-to_sub,vec[2]-to_sub,vec[3]-to_sub);}

MC_v3d_vector mesh_conv::operator-	(	const MC_v3d_vector &	vec,
		const MC_v3d_vector &	to_sub
	)

Definition at line 179 of file MC_v3d_vector.cpp.

References mesh_conv::MC_v3d_vector::first(), mesh_conv::MC_v3d_vector::size(), and mesh_conv::MC_v3d_vector::zeros().

00180     {
00181         if(to_sub.size()==1)
00182             return vec-to_sub.first();
00183         else
00184         {
00185             if(vec.size()!=to_sub.size())
00186             {std::cout<<"Error in MC_v3d_vector::operator-(MC_v3d_vector,MC_v3d_vector), size are not compatible "<<vec.size()<<";"<<to_sub.size()<<std::endl;exit(-1);}
00187 
00188 
00189             int N=vec.size();
00190             MC_v3d_vector new_vec=MC_v3d_vector::zeros(N);
00191             for(int k=0;k<N;++k)
00192                 new_vec[k]=vec[k]-to_sub[k];
00193             return new_vec;
00194         }
00195     }

Here is the call graph for this function:

MC_v3d_vector mesh_conv::operator-	(	const MC_v3d_vector &	vec,
		const MC_v3d &	to_sub
	)

Definition at line 134 of file MC_v3d_vector.cpp.

References mesh_conv::MC_v3d_vector::resize(), and mesh_conv::MC_v3d_vector::size().

00135     {
00136         int N=vec.size();
00137         MC_v3d_vector new_vec;new_vec.resize(N);
00138         for(int k=0;k<N;++k)
00139             new_vec[k]=vec[k]-to_sub;
00140         return new_vec;
00141     }

Here is the call graph for this function:

MC_v3d mesh_conv::operator-	(	const MC_v3d &	vec,
		const MC_v3d &	to_sub
	)

Definition at line 84 of file MC_v3d.cpp.

00085 {return MC_v3d(vec[0]-to_sub[0],vec[1]-to_sub[1],vec[2]-to_sub[2]);}

MC_v3d mesh_conv::operator-	(	const MC_v3d &	vec,
		const double &	to_sub
	)

Definition at line 67 of file MC_v3d.cpp.

00068 {return MC_v3d(vec[0]-to_sub,vec[1]-to_sub,vec[2]-to_sub);}

MC_mesh_index_vector_draw mesh_conv::operator-	(	const MC_v3d_vector &	to_sub,
		const MC_mesh_index_vector_draw &	vec
	)

Definition at line 184 of file MC_mesh_index_vector_draw.cpp.

00185     {return vec+to_sub;}

MC_mesh_index_vector_draw mesh_conv::operator-	(	const MC_v3d &	to_sub,
		const MC_mesh_index_vector_draw &	vec
	)

Definition at line 180 of file MC_mesh_index_vector_draw.cpp.

00181     {return vec+to_sub;}

MC_mesh_index_vector_draw mesh_conv::operator-	(	const MC_mesh_index_vector_draw &	vec,
		const MC_v3d_vector &	to_sub
	)

Definition at line 175 of file MC_mesh_index_vector_draw.cpp.

References mesh_conv::MC_mesh_index_vector::point_set().

00176     {MC_mesh_index_vector_draw res=vec;res.point_set()-=to_sub;return res;}

Here is the call graph for this function:

MC_mesh_index_vector_draw mesh_conv::operator-	(	const MC_mesh_index_vector_draw &	vec,
		const MC_v3d &	to_sub
	)

Definition at line 171 of file MC_mesh_index_vector_draw.cpp.

References mesh_conv::MC_mesh_index_vector::point_set().

00172     {MC_mesh_index_vector_draw res=vec;res.point_set()-=to_sub;return res;}

Here is the call graph for this function:

MC_mesh_index_vector mesh_conv::operator-	(	const MC_mesh_index_vector &	vec,
		const MC_v3d_vector &	to_sub
	)

Definition at line 100 of file MC_mesh_index_vector.cpp.

References mesh_conv::MC_mesh_index_vector::connectivity(), and mesh_conv::MC_mesh_index_vector::point_set().

00101     {return MC_mesh_index_vector(vec.point_set()-to_sub,vec.connectivity());}

Here is the call graph for this function:

MC_mesh_index_vector mesh_conv::operator-	(	const MC_mesh_index_vector &	vec,
		const MC_v3d &	to_sub
	)

Definition at line 96 of file MC_mesh_index_vector.cpp.

References mesh_conv::MC_mesh_index_vector::connectivity(), and mesh_conv::MC_mesh_index_vector::point_set().

00097     {return MC_mesh_index_vector(vec.point_set()-to_sub,vec.connectivity());}

Here is the call graph for this function:

MC_matrix mesh_conv::operator-	(	const MC_matrix &	M1,
		const MC_matrix &	M2
	)

Definition at line 564 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::M, mesh_conv::MC_double_vector::size(), mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00565 {
00566   if(M1.size_1()!=M2.size_1() || M1.size_2()!=M2.size_2())
00567     {std::cout<<"Error in MC_matrix::operator-(matrix,matrix), size are not compatible ("<<M1.size_1()<<","<<M1.size_2()<<")!=("<<M2.size_1()<<","<<M2.size_2()<<std::endl;exit(-1);}
00568   
00569   MC_matrix temp(M1.size_1(),M1.size_2());
00570   int k=0,N=M1.M.size();
00571   for(k=0;k<N;k++)
00572     temp.M[k] = M1.M[k]-M2.M[k];
00573   return temp;
00574 }

Here is the call graph for this function:

MC_matrix mesh_conv::operator-	(	const double &	alpha,
		const MC_matrix &	M1
	)

Definition at line 494 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00495 {
00496   MC_matrix temp=M1;
00497   int k1=0,k2=0;
00498   int N1=M1.size_1(),N2=M1.size_2();
00499   for(k1=0;k1<N1;k1++)
00500     for(k2=0;k2<N2;k2++)
00501       temp(k1,k2)=alpha-M1(k1,k2);
00502   return temp;
00503 }

Here is the call graph for this function:

MC_matrix mesh_conv::operator-	(	const MC_matrix &	M1,
		const double &	alpha
	)

Definition at line 484 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00485 {
00486   MC_matrix temp=M1;
00487   int k1=0,k2=0;
00488   int N1=M1.size_1(),N2=M1.size_2();
00489   for(k1=0;k1<N1;k1++)
00490     for(k2=0;k2<N2;k2++)
00491       temp(k1,k2)-=alpha;
00492   return temp;
00493 }

Here is the call graph for this function:

MC_int_vector_vector mesh_conv::operator-	(	const MC_int_vector_vector &	vec,
		const int &	to_add
	)

Definition at line 176 of file MC_int_vector_vector.cpp.

References mesh_conv::MC_int_vector_vector::resize(), and mesh_conv::MC_int_vector_vector::size().

00177     {
00178         int N=vec.size();
00179         MC_int_vector_vector res(N);res.resize(N);
00180         for(int k=0;k<N;++k)
00181             res[k]=vec[k]-to_add;
00182         return res;
00183     }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator-	(	const MC_int_vector &	vec,
		const MC_int_vector &	to_sub
	)

Definition at line 287 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::first(), mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00288   {
00289     if(to_sub.size()==1)
00290       return vec-to_sub.first();
00291     else
00292       {
00293         if(vec.size()!=to_sub.size())
00294           {std::cout<<"Error in MC_int_vector::operator-(MC_int_vector,MC_int_vector), size are not compatible "<<vec.size()<<";"<<to_sub.size()<<std::endl;exit(-1);}
00295         
00296 
00297         int N=vec.size();
00298         MC_int_vector new_vec=MC_int_vector::zeros(N);
00299         for(int k=0;k<N;++k)
00300           new_vec[k]=vec[k]-to_sub[k];
00301         return new_vec;
00302       }
00303   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator-	(	const MC_int_vector &	vec,
		const int &	to_sub
	)

Definition at line 209 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00210   {
00211     int N=vec.size();
00212     MC_int_vector new_vec=MC_int_vector::zeros(N);
00213     for(int k=0;k<N;k++)
00214       new_vec[k]=vec[k]-to_sub;
00215     return new_vec;
00216   }

Here is the call graph for this function:

MC_int_pair mesh_conv::operator-	(	const MC_int_pair &	p,
		const int &	a
	)

Definition at line 81 of file MC_int_pair.cpp.

00082     {return MC_int_pair(p[0]-a,p[1]-a);}

MC_double_vector_vector mesh_conv::operator-	(	const MC_double_vector_vector &	vec,
		const double &	to_add
	)

Definition at line 180 of file MC_double_vector_vector.cpp.

References mesh_conv::MC_double_vector_vector::resize(), and mesh_conv::MC_double_vector_vector::size().

00181     {
00182         int N=vec.size();
00183         MC_double_vector_vector res(N);res.resize(N);
00184         for(int k=0;k<N;++k)
00185             res[k]=vec[k]-to_add;
00186         return res;
00187     }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator-	(	const MC_double_vector &	vec,
		const MC_double_vector &	to_sub
	)

Definition at line 270 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::first(), mesh_conv::MC_double_vector::size(), and mesh_conv::MC_double_vector::zeros().

00271   {
00272       if(to_sub.size()==1)
00273           return vec-to_sub.first();
00274       else
00275       {
00276           if(vec.size()!=to_sub.size())
00277           {std::cout<<"Error in MC_double_vector::operator-(MC_double_vector,MC_double_vector), size are not compatible "<<vec.size()<<";"<<to_sub.size()<<std::endl;exit(-1);}
00278         
00279 
00280           int N=vec.size();
00281           MC_double_vector new_vec=MC_double_vector::zeros(N);
00282           for(int k=0;k<N;++k)
00283               new_vec[k]=vec[k]-to_sub[k];
00284           return new_vec;
00285       }
00286   }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator-	(	const MC_double_vector &	vec,
		const double &	to_sub
	)

Definition at line 189 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_double_vector::zeros().

00190   {
00191     int N=vec.size();
00192     MC_double_vector new_vec=MC_double_vector::zeros(N);
00193     for(int k=0;k<N;k++)
00194       new_vec[k]=vec[k]-to_sub;
00195     return new_vec;
00196   }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator- ( const MC_double_vector & v )

Definition at line 171 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::resize(), and mesh_conv::MC_double_vector::size().

00172   {
00173     MC_double_vector opposite;
00174     int N=v.size();
00175     opposite.resize(N);
00176     for(int k=0;k<N;++k)
00177       opposite[k]=-v[k];
00178     return opposite;
00179   }

Here is the call graph for this function:

MC_v4d mesh_conv::operator/	(	const MC_v4d &	vec,
		const double &	to_subdiv
	)

Definition at line 65 of file MC_v4d.cpp.

00066 {
00067     double epsilon=0.000001;
00068     if(fabs(to_subdiv)<epsilon)
00069     {std::cout<<"Error in MC_v4d("<<vec<<"/"<<to_subdiv<<", divide by zero"<<std::endl;exit(-1);}
00070 
00071     return MC_v4d(vec[0]/to_subdiv,vec[1]/to_subdiv,vec[2]/to_subdiv,vec[3]/to_subdiv);
00072 }

MC_v3d_vector mesh_conv::operator/	(	const MC_v3d_vector &	vec,
		const double &	to_subdiv
	)

Definition at line 150 of file MC_v3d_vector.cpp.

References mesh_conv::MC_v3d_vector::resize(), and mesh_conv::MC_v3d_vector::size().

00151     {
00152         double epsilon=0.000001;
00153         if(fabs(to_subdiv)<epsilon)
00154         {std::cout<<"Error in MC_v3d_vector("<<vec<<"/"<<to_subdiv<<", divide by zero"<<std::endl;exit(-1);}
00155 
00156         int N=vec.size();
00157         MC_v3d_vector new_vec;new_vec.resize(N);
00158         for(int k=0;k<N;++k)
00159             new_vec[k]=vec[k]/to_subdiv;
00160         return new_vec;
00161     }

Here is the call graph for this function:

MC_v3d mesh_conv::operator/	(	const MC_v3d &	vec,
		const double &	to_subdiv
	)

Definition at line 74 of file MC_v3d.cpp.

00075 {
00076     double epsilon=0.000000001;
00077     if(fabs(to_subdiv)<epsilon)
00078     {std::cout<<"Error in MC_v3d("<<vec<<"/"<<to_subdiv<<", divide by zero"<<std::endl;exit(-1);}
00079 
00080     return MC_v3d(vec[0]/to_subdiv,vec[1]/to_subdiv,vec[2]/to_subdiv);
00081 }

MC_mesh_index_vector_draw mesh_conv::operator/	(	const MC_mesh_index_vector_draw &	vec,
		const double &	to_subdiv
	)

Definition at line 187 of file MC_mesh_index_vector_draw.cpp.

References mesh_conv::MC_mesh_index_vector::point_set().

00188     {MC_mesh_index_vector_draw res=vec;res.point_set()/=to_subdiv;return res;}

Here is the call graph for this function:

MC_mesh_index_vector mesh_conv::operator/	(	const MC_mesh_index_vector &	vec,
		const double &	to_subdiv
	)

Definition at line 106 of file MC_mesh_index_vector.cpp.

References mesh_conv::MC_mesh_index_vector::connectivity(), and mesh_conv::MC_mesh_index_vector::point_set().

00107     {return MC_mesh_index_vector(vec.point_set()/to_subdiv,vec.connectivity());}

Here is the call graph for this function:

MC_matrix mesh_conv::operator/	(	const double &	alpha,
		const MC_matrix &	M1
	)

Definition at line 532 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00533 {
00534   double epsilon=0.000001;
00535   
00536   double current=0.0;
00537   MC_matrix temp=M1;
00538   int k1=0,k2=0;
00539   int N1=M1.size_1(),N2=M1.size_2();
00540   for(k1=0;k1<N1;k1++)
00541     for(k2=0;k2<N2;k2++)
00542       {
00543         current = M1(k1,k2);
00544         if(abs(current)<epsilon)
00545           {std::cout<<"Error in MC_matrix::operator/("<<alpha<<"), value too small at ("<<k1<<","<<k2<<")"<<std::endl;exit(-1);}
00546 
00547         temp(k1,k2)=alpha/current;
00548       }
00549   return temp;
00550 }

Here is the call graph for this function:

MC_matrix mesh_conv::operator/	(	const MC_matrix &	M1,
		const double &	alpha
	)

Definition at line 517 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00518 {
00519 
00520     double epsilon=0.000001;
00521     if(abs(alpha)<epsilon)
00522     {std::cout<<"Error in MC_matrix::operator/("<<alpha<<"), value too small"<<std::endl;exit(-1);}
00523 
00524     MC_matrix temp=M1;
00525     int k1=0,k2=0;
00526     int N1=M1.size_1(),N2=M1.size_2();
00527     for(k1=0;k1<N1;k1++)
00528         for(k2=0;k2<N2;k2++)
00529             temp(k1,k2)/=alpha;
00530     return temp;
00531 }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator/	(	const MC_int_vector &	vec,
		const MC_int_vector &	to_subdiv
	)

Definition at line 321 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::first(), mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00322   {
00323     if(to_subdiv.size()==1)
00324       return vec/to_subdiv.first();
00325     else
00326       {
00327         if(vec.size()!=to_subdiv.size())
00328           {std::cout<<"Error in MC_int_vector::operator/(MC_int_vector,MC_int_vector), size are not compatible "<<vec.size()<<";"<<to_subdiv.size()<<std::endl;exit(-1);}
00329         
00330 
00331         int N=vec.size();
00332         MC_int_vector new_vec=MC_int_vector::zeros(N);
00333         for(int k=0;k<N;++k)
00334           {
00335             int current=to_subdiv[k];
00336             if(current==0)
00337               {std::cout<<"Error in MC_int_vector::operator/(MC_int_vector,MC_int_vector), int value at index"<<k<<" is 0"<<std::endl;exit(-1);}
00338             new_vec[k]=vec[k]/current;
00339           }
00340         return new_vec;
00341       }
00342 
00343   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator/	(	const MC_int_vector &	vec,
		const int &	to_subdiv
	)

Definition at line 225 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00226   {
00227     if(to_subdiv==0)
00228       {std::cout<<"Error in MC_int_vector::operator/(MC_int_vector,int), int value is 0"<<std::endl;exit(-1);}
00229     int N=vec.size();
00230     MC_int_vector new_vec=MC_int_vector::zeros(N);
00231     for(int k=0;k<N;k++)
00232       new_vec[k]=vec[k]/to_subdiv;
00233     return new_vec;
00234   }

Here is the call graph for this function:

MC_v3d_vector mesh_conv::operator/	(	const MC_v3d &	vec,
		const MC_double_vector &	to_subdiv
	)

Definition at line 592 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size().

00593    {
00594        double epsilon=0.000001;
00595 
00596        int N=to_subdiv.size();
00597        MC_v3d_vector res(N);
00598        for(int k=0;k<N;++k)
00599        {
00600            if(fabs(to_subdiv[k])>epsilon)
00601                res[k]=vec/to_subdiv[k];
00602            else
00603            {std::cout<<"Error in MC_v3d_vector::operator/("<<vec<<" MC_double_vector), at position "<<k<<", value MC_double_vector["<<k<<"] is zero"<<std::endl;exit(-1);}
00604        }
00605        return res;
00606    }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator/	(	const MC_double_vector &	vec,
		const MC_double_vector &	to_subdiv
	)

Definition at line 304 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::first(), mesh_conv::MC_double_vector::size(), and mesh_conv::MC_double_vector::zeros().

00305   {
00306     if(to_subdiv.size()==1)
00307       return vec/to_subdiv.first();
00308     else
00309       {
00310         if(vec.size()!=to_subdiv.size())
00311           {std::cout<<"Error in MC_double_vector::operator/(MC_double_vector,MC_double_vector), size are not compatible "<<vec.size()<<";"<<to_subdiv.size()<<std::endl;exit(-1);}
00312         
00313 
00314         int N=vec.size();
00315         MC_double_vector new_vec=MC_double_vector::zeros(N);
00316         for(int k=0;k<N;++k)
00317           {
00318             double current=to_subdiv[k];
00319             double epsilon=0.0000001;
00320             if(fabs(current)<epsilon)
00321               {std::cout<<"Error in MC_double_vector::operator/(MC_double_vector,MC_double_vector), int value at index"<<k<<" is 0"<<std::endl;exit(-1);}
00322             new_vec[k]=vec[k]/current;
00323           }
00324         return new_vec;
00325       }
00326 
00327   }

Here is the call graph for this function:

MC_double_vector mesh_conv::operator/	(	const MC_double_vector &	vec,
		const double &	to_subdiv
	)

Definition at line 208 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_double_vector::zeros().

00209   {
00210       double epsilon=0.0000000001;
00211       if(fabs(to_subdiv)<epsilon)
00212       {std::cout<<"Error in MC_double_vector::operator/(MC_double_vector,double), double value is 0"<<std::endl;exit(-1);}
00213       int N=vec.size();
00214       MC_double_vector new_vec=MC_double_vector::zeros(N);
00215       for(int k=0;k<N;k++)
00216           new_vec[k]=vec[k]/to_subdiv;
00217       return new_vec;
00218   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator<	(	const int &	val,
		const MC_int_vector &	vec
	)

Definition at line 555 of file MC_int_vector.cpp.

00556   {return vec>val;}

MC_int_vector mesh_conv::operator<	(	const MC_int_vector &	vec,
		const int &	val
	)

Definition at line 509 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00510   {
00511       int N=vec.size();
00512       MC_int_vector res=MC_int_vector::zeros(N);
00513       for(int k=0;k<N;k++)
00514           if(vec[k]<val)
00515               res[k]=1;
00516       return res;
00517   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator<	(	const double &	val,
		const MC_double_vector &	vec
	)

Definition at line 541 of file MC_double_vector.cpp.

00542   {return vec>val;}

MC_int_vector mesh_conv::operator<	(	const MC_double_vector &	vec,
		const double &	val
	)

Definition at line 494 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_int_vector::zeros().

00495   {
00496       int N=vec.size();
00497       MC_int_vector res=MC_int_vector::zeros(N);
00498       for(int k=0;k<N;k++)
00499           if(vec[k]<val)
00500               res[k]=1;
00501       return res;
00502   }

Here is the call graph for this function:

std::ostream& mesh_conv::operator<<	(	std::ostream &	stream,
		const MC_v4d &	v
	)

Definition at line 112 of file MC_v4d.cpp.

00113 {
00114     stream<<"("<<v[0]<<","<<v[1]<<","<<v[2]<<","<<v[3]<<")";
00115     return stream;
00116 }

MC_v3d_vector mesh_conv::operator<<	(	const MC_v3d_vector &	vec,
		const MC_v3d_vector &	value
	)

Definition at line 338 of file MC_v3d_vector.cpp.

00339     {return MC_v3d_vector(vec).add(value);}

MC_v3d_vector mesh_conv::operator<<	(	const MC_v3d_vector &	vec,
		const MC_v3d &	value
	)

Definition at line 335 of file MC_v3d_vector.cpp.

00336     {return MC_v3d_vector(vec).add(value);}

std::ostream& mesh_conv::operator<<	(	std::ostream &	output,
		const MC_v3d_vector &	in
	)

Definition at line 258 of file MC_v3d_vector.cpp.

References mesh_conv::MC_v3d_vector::size().

00259     {
00260         int N=in.size();
00261         for(int k=0;k<N;++k)
00262             output<<in[k];
00263         return output;
00264     }

Here is the call graph for this function:

std::ostream& mesh_conv::operator<<	(	std::ostream &	stream,
		const MC_v3d &	v
	)

Definition at line 121 of file MC_v3d.cpp.

00122 {
00123     stream<<"("<<v[0]<<","<<v[1]<<","<<v[2]<<")";
00124     return stream;
00125 }

std::ostream& mesh_conv::operator<<	(	std::ostream &	stream,
		const MC_segment &	s
	)

Definition at line 262 of file MC_segment.cpp.

00263     {stream<<"["<<s[0]<<" ; "<<s[1]<<"]";return stream;}

MC_mesh_index_vector_draw mesh_conv::operator<<	(	const MC_mesh_index_vector_draw &	vec0,
		const MC_mesh_index_vector_draw &	vec1
	)

Definition at line 114 of file MC_mesh_index_vector_draw.cpp.

References mesh_conv::MC_mesh_index_vector_draw::alpha(), mesh_conv::MC_mesh_index_vector_draw::color(), mesh_conv::MC_mesh_index_vector::connectivity(), mesh_conv::MC_mesh_index_vector_draw::normal(), mesh_conv::MC_mesh_index_vector::point_set(), mesh_conv::MC_v3d_vector::size(), mesh_conv::MC_mesh_index_vector_draw::texture(), mesh_conv::MC_mesh_index_vector_draw::texture_connectivity(), and mesh_conv::MC_mesh_index_vector::vertex_number().

00115     {
00116         MC_mesh_index_vector_draw new_vec;
00117 
00118         new_vec.point_set()=vec0.point_set()<<vec1.point_set();
00119         new_vec.color()=vec0.color()<<vec1.color();
00120         new_vec.texture()=vec0.texture()<<vec1.texture();
00121         new_vec.texture_connectivity()=vec0.texture_connectivity()<<(vec1.texture_connectivity()+vec0.texture().size());
00122         new_vec.alpha()=vec0.alpha()<<vec1.alpha();
00123         new_vec.normal()=vec0.normal()<<vec1.normal();
00124         new_vec.connectivity()=vec0.connectivity()<<(vec1.connectivity()+vec0.vertex_number());
00125 
00126         return new_vec;
00127     }

Here is the call graph for this function:

MC_mesh_index_vector mesh_conv::operator<<	(	const MC_mesh_index_vector &	vec0,
		const MC_mesh_index_vector &	vec1
	)

Definition at line 1057 of file MC_mesh_index_vector.cpp.

References mesh_conv::MC_mesh_index_vector::connectivity(), mesh_conv::MC_mesh_index_vector::point_set(), and mesh_conv::MC_mesh_index_vector::vertex_number().

01058     {
01059         MC_mesh_index_vector new_vec;
01060 
01061         new_vec.point_set()=vec0.point_set()<<vec1.point_set();
01062         new_vec.connectivity()=vec0.connectivity()<<(vec1.connectivity()+vec0.vertex_number());
01063 
01064         return new_vec;
01065     }

Here is the call graph for this function:

std::ostream& mesh_conv::operator<<	(	std::ostream &	stream,
		const MC_matrix &	_M
	)

Definition at line 189 of file MC_matrix.cpp.

References mesh_conv::MC_matrix::size_1(), and mesh_conv::MC_matrix::size_2().

00190 {
00191   int k_1=0,k_2=0;
00192   int N_1=_M.size_1(),N_2=_M.size_2();
00193   for(k_1=0;k_1<N_1;k_1++)
00194     {
00195       for(k_2=0;k_2<N_2;k_2++)
00196         stream<<_M(k_1,k_2)<<" ";
00197       stream<<std::endl;
00198     }
00199   return stream;
00200 }

Here is the call graph for this function:

std::ostream& mesh_conv::operator<<	(	std::ostream &	stream,
		const MC_int_vector_vector &	input
	)

Definition at line 158 of file MC_int_vector_vector.cpp.

References mesh_conv::MC_int_vector_vector::size().

00159     {
00160         int N=input.size();
00161         for(int k=0;k<N-1;k++)
00162             stream<<"("<<input[k]<<"); ";
00163         if(N>0)
00164             stream<<"("<<input[N-1]<<")";
00165         return stream;
00166     }

Here is the call graph for this function:

MC_int_vector_vector mesh_conv::operator<<	(	const MC_int_vector_vector &	vec,
		const MC_int_vector_vector &	to_add
	)

Definition at line 60 of file MC_int_vector_vector.cpp.

00061     {return MC_int_vector_vector(vec).add(to_add);}

MC_int_vector_vector mesh_conv::operator<<	(	const MC_int_vector_vector &	vec,
		const MC_int_vector &	value
	)

Definition at line 51 of file MC_int_vector_vector.cpp.

00052     {return MC_int_vector_vector(vec).add(value);}

mesh_conv::MC_int_vector mesh_conv::operator<<	(	const mesh_conv::MC_int_vector &	vec,
		const mesh_conv::MC_int_vector &	to_add
	)

Definition at line 101 of file MC_int_vector.cpp.

00102   {return MC_int_vector(vec).add(to_add);}

MC_int_vector mesh_conv::operator<<	(	const MC_int_vector &	vec,
		const int &	value
	)

Definition at line 68 of file MC_int_vector.cpp.

00069   {return MC_int_vector(vec).add(value);}

std::ostream& mesh_conv::operator<<	(	std::ostream &	output,
		const MC_int_vector &	in
	)

Definition at line 44 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size().

00045   {
00046     int N=in.size();
00047     for(int k=0;k<N;k++)
00048       output<<in[k]<<" ";
00049     return output;
00050   }

Here is the call graph for this function:

std::ostream& mesh_conv::operator<<	(	std::ostream &	stream,
		const MC_int_pair_unique &	_v
	)

Definition at line 64 of file MC_int_pair_unique.cpp.

00065     {
00066         stream<<"("<<_v[0]<<","<<_v[1]<<")";
00067         return stream;
00068     }

std::ostream& mesh_conv::operator<<	(	std::ostream &	stream,
		const MC_int_pair &	p
	)

Definition at line 34 of file MC_int_pair.cpp.

00035     {
00036         stream<<"("<<p[0]<<","<<p[1]<<")";
00037         return stream;
00038     }

std::ostream& mesh_conv::operator<<	(	std::ostream &	stream,
		const MC_double_vector_vector &	input
	)

Definition at line 162 of file MC_double_vector_vector.cpp.

References mesh_conv::MC_double_vector_vector::size().

00163     {
00164         int N=input.size();
00165         for(int k=0;k<N-1;k++)
00166             stream<<"("<<input[k]<<"); ";
00167         if(N>0)
00168             stream<<"("<<input[N-1]<<")";
00169         return stream;
00170     }

Here is the call graph for this function:

MC_double_vector_vector mesh_conv::operator<<	(	const MC_double_vector_vector &	vec,
		const MC_double_vector_vector &	to_add
	)

Definition at line 64 of file MC_double_vector_vector.cpp.

00065     {return MC_double_vector_vector(vec).add(to_add);}

MC_double_vector_vector mesh_conv::operator<<	(	const MC_double_vector_vector &	vec,
		const MC_double_vector &	value
	)

Definition at line 55 of file MC_double_vector_vector.cpp.

00056     {return MC_double_vector_vector(vec).add(value);}

MC_double_vector mesh_conv::operator<<	(	const MC_double_vector &	vec,
		const MC_double_vector &	to_add
	)

Definition at line 107 of file MC_double_vector.cpp.

00108   {return MC_double_vector(vec).add(to_add);}

MC_double_vector mesh_conv::operator<<	(	const MC_double_vector &	vec,
		const double &	value
	)

Definition at line 73 of file MC_double_vector.cpp.

00074   {return MC_double_vector(vec).add(value);}

std::ostream& mesh_conv::operator<<	(	std::ostream &	output,
		const MC_double_vector &	in
	)

Definition at line 49 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size().

00050   {
00051     int N=in.size();
00052     for(int k=0;k<N;k++)
00053       output<<in[k]<<" ";
00054     return output;
00055   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator<=	(	const int &	val,
		const MC_int_vector &	vec
	)

Definition at line 557 of file MC_int_vector.cpp.

00558   {return vec>=val;}

MC_int_vector mesh_conv::operator<=	(	const MC_int_vector &	vec,
		const int &	val
	)

Definition at line 518 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00519   {
00520       int N=vec.size();
00521       MC_int_vector res=MC_int_vector::zeros(N);
00522       for(int k=0;k<N;k++)
00523           if(vec[k]<=val)
00524               res[k]=1;
00525       return res;
00526   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator<=	(	const double &	val,
		const MC_double_vector &	vec
	)

Definition at line 543 of file MC_double_vector.cpp.

00544   {return vec>=val;}

MC_int_vector mesh_conv::operator<=	(	const MC_double_vector &	vec,
		const double &	val
	)

Definition at line 503 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_int_vector::zeros().

00504   {
00505       int N=vec.size();
00506       MC_int_vector res=MC_int_vector::zeros(N);
00507       for(int k=0;k<N;k++)
00508           if(vec[k]<=val)
00509               res[k]=1;
00510       return res;
00511   }

Here is the call graph for this function:

bool mesh_conv::operator==	(	const MC_v3d &	a1,
		const MC_v3d &	a2
	)

Definition at line 247 of file MC_v3d.cpp.

00248     {
00249         MC_v3d_less L;
00250         if(L(a1,a2)==false && L(a2,a1)==false)
00251             return true;
00252         return false;
00253     }

MC_int_vector mesh_conv::operator==	(	const int &	val,
		const MC_int_vector &	vec
	)

Definition at line 563 of file MC_int_vector.cpp.

00564   {return vec==val;}

MC_int_vector mesh_conv::operator==	(	const MC_int_vector &	vec,
		const int &	val
	)

Definition at line 545 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00546   {
00547       int N=vec.size();
00548       MC_int_vector res=MC_int_vector::zeros(N);
00549       for(int k=0;k<N;k++)
00550           if(vec[k]==val)
00551               res[k]=1;
00552       return res;
00553   }

Here is the call graph for this function:

bool mesh_conv::operator==	(	const MC_int_pair_unique &	p0,
		const MC_int_pair_unique &	p1
	)

Definition at line 30 of file MC_int_pair_unique.cpp.

References mesh_conv::MC_int_pair_unique::u0, and mesh_conv::MC_int_pair_unique::u1.

00031     {
00032         if( ( (p0.u0==p1.u0) && (p0.u1==p1.u1) ) )
00033             return false;
00034         return true;
00035     }

bool mesh_conv::operator==	(	const MC_int_pair &	p0,
		const MC_int_pair &	p1
	)

Definition at line 13 of file MC_int_pair.cpp.

References mesh_conv::MC_int_pair::u0, and mesh_conv::MC_int_pair::u1.

00014     {
00015         if( ( (p0.u0==p1.u0) && (p0.u1==p1.u1) ) || ( (p0.u0==p1.u1) && (p0.u1==p1.u0) ))
00016             return true;
00017         return false;
00018     }

MC_int_vector mesh_conv::operator==	(	const double &	val,
		const MC_double_vector &	vec
	)

Definition at line 549 of file MC_double_vector.cpp.

00550   {return vec==val;}

MC_int_vector mesh_conv::operator==	(	const MC_double_vector &	vec,
		const double &	val
	)

Definition at line 530 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_int_vector::zeros().

00531   {
00532       int N=vec.size();
00533       MC_int_vector res=MC_int_vector::zeros(N);
00534       double epsilon=0.0000001;
00535       for(int k=0;k<N;k++)
00536           if(fabs(vec[k]-val)<epsilon)
00537               res[k]=1;
00538       return res;
00539   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator>	(	const int &	val,
		const MC_int_vector &	vec
	)

Definition at line 559 of file MC_int_vector.cpp.

00560   {return vec<val;}

MC_int_vector mesh_conv::operator>	(	const MC_int_vector &	vec,
		const int &	val
	)

Definition at line 527 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00528   {
00529       int N=vec.size();
00530       MC_int_vector res=MC_int_vector::zeros(N);
00531       for(int k=0;k<N;k++)
00532           if(vec[k]>val)
00533               res[k]=1;
00534       return res;
00535   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator>	(	const double &	val,
		const MC_double_vector &	vec
	)

Definition at line 545 of file MC_double_vector.cpp.

00546   {return vec<val;}

MC_int_vector mesh_conv::operator>	(	const MC_double_vector &	vec,
		const double &	val
	)

Definition at line 512 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_int_vector::zeros().

00513   {
00514       int N=vec.size();
00515       MC_int_vector res=MC_int_vector::zeros(N);
00516       for(int k=0;k<N;k++)
00517           if(vec[k]>val)
00518               res[k]=1;
00519       return res;
00520   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator>=	(	const int &	val,
		const MC_int_vector &	vec
	)

Definition at line 561 of file MC_int_vector.cpp.

00562   {return vec<=val;}

MC_int_vector mesh_conv::operator>=	(	const MC_int_vector &	vec,
		const int &	val
	)

Definition at line 536 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::size(), and mesh_conv::MC_int_vector::zeros().

00537   {
00538       int N=vec.size();
00539       MC_int_vector res=MC_int_vector::zeros(N);
00540       for(int k=0;k<N;k++)
00541           if(vec[k]>=val)
00542               res[k]=1;
00543       return res;
00544   }

Here is the call graph for this function:

MC_int_vector mesh_conv::operator>=	(	const double &	val,
		const MC_double_vector &	vec
	)

Definition at line 547 of file MC_double_vector.cpp.

00548   {return vec<=val;}

MC_int_vector mesh_conv::operator>=	(	const MC_double_vector &	vec,
		const double &	val
	)

Definition at line 521 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::size(), and mesh_conv::MC_int_vector::zeros().

00522   {
00523       int N=vec.size();
00524       MC_int_vector res=MC_int_vector::zeros(N);
00525       for(int k=0;k<N;k++)
00526           if(vec[k]>=val)
00527               res[k]=1;
00528       return res;
00529   }

Here is the call graph for this function:

MC_v4d& mesh_conv::operator>>	(	std::istream &	stream,
		MC_v4d &	vec
	)

Definition at line 134 of file MC_v4d.cpp.

References mesh_conv::MC_string_tokenizer::tokenize().

00135     {
00136         int current_position=0;
00137         std::string temp_string;
00138         while(current_position<4 && stream.good())
00139         {
00140             if(stream>>temp_string)
00141             {
00142                 std::vector <std::string> v_token=MC_string_tokenizer::tokenize(temp_string,",;() ");
00143 
00144                 for(unsigned int k=0;current_position<4 && k<v_token.size();++k)
00145                 {
00146                     bool is_converted=false;
00147                     double temp_value=MC_string_converter::value_of<double>(v_token[k],&is_converted);
00148                     if(is_converted==true)
00149                         vec[current_position++]=temp_value;
00150                 }
00151             }
00152         }
00153         return vec;
00154     }

Here is the call graph for this function:

bool mesh_conv::operator>>	(	std::istream &	stream,
		MC_v3d &	vec
	)

Definition at line 143 of file MC_v3d.cpp.

References mesh_conv::MC_string_tokenizer::tokenize().

00144     {
00145         int current_position=0;
00146         std::string temp_string;
00147         while(current_position<3 && stream.good())
00148         {
00149             if(stream>>temp_string)
00150             {
00151                 std::vector <std::string> v_token=MC_string_tokenizer::tokenize(temp_string,",;() ");
00152 
00153                 for(unsigned int k=0;current_position<3 && k<v_token.size();++k)
00154                 {
00155                     bool is_converted=false;
00156                     double temp_value=MC_string_converter::value_of<double>(v_token[k],&is_converted);
00157                     if(is_converted==true)
00158                         vec[current_position++]=temp_value;
00159                 }
00160             }
00161         }
00162         return 0;
00163     }

Here is the call graph for this function:

mesh_conv::MC_int_vector& mesh_conv::operator>>	(	std::istream &	input,
		mesh_conv::MC_int_vector &	vec
	)

Definition at line 496 of file MC_int_vector.cpp.

References mesh_conv::MC_int_vector::add().

00497   {
00498       while(input.good())
00499       {
00500           int temp=0;
00501           input>>temp;
00502           if(input.good())
00503               vec.add(temp);
00504       }
00505       return vec;
00506   }

Here is the call graph for this function:

MC_double_vector& mesh_conv::operator>>	(	std::istream &	input,
		MC_double_vector &	vec
	)

Definition at line 481 of file MC_double_vector.cpp.

References mesh_conv::MC_double_vector::add().

00482   {
00483       while(input.good())
00484       {
00485           double temp=0;
00486           input>>temp;
00487           if(input.good())
00488               vec.add(temp);
00489       }
00490       return vec;
00491   }

Here is the call graph for this function:

mesh_conv Namespace Reference

Namespaces

Classes

Functions

Function Documentation