as_position.hxx

股票控件源代码

// Header for position.

// A position vector in three-dimensional cartesian space is 
// subject to transformations and certain vector operators.  This 
// class is distinct from the vector class, which is a displacement 
// and thus origin independent.


#if !defined( POSITION_CLASS )
#define POSITION_CLASS
#include "as_vector.hxx"

class vector;
class unit_vector;
class matrix;
class transf;



class  position {

	double coord[ 3 ];	// x, y and z coordinates of the position


	// Scale the object space. 
	// This requires care, and so the operator is private.

	friend  position operator*( position const &, double );

public:

	// Force creation of all positions to be by constructor.

	position() {}


	// Construct a position from three doubles.

	position( double xi, double yi, double zi ) {
		coord[ 0 ] = xi;
		coord[ 1 ] = yi;
		coord[ 2 ] = zi;
	}


	// Construct a position from an array of three doubles.

	position( double p[ 3 ] ) {
		coord[ 0 ] = p[ 0 ];
		coord[ 1 ] = p[ 1 ];
		coord[ 2 ] = p[ 2 ];
	}


	// Copy a position

	position( position const &p ) {
		coord[ 0 ] = p.coord[ 0 ];
		coord[ 1 ] = p.coord[ 1 ];
		coord[ 2 ] = p.coord[ 2 ];
	}


	// Extract a coordinate value.

	double x() const
		{ return coord[ 0 ]; }
	double y() const
		{ return coord[ 1 ]; }
	double z() const
		{ return coord[ 2 ]; }

	double coordinate( int i ) const
		{ return coord[ i ]; }

	// Extract a coordinate value for update.

	double &x()
		{ return coord[ 0 ]; }
	double &y()
		{ return coord[ 1 ]; }
	double &z()
		{ return coord[ 2 ]; }

	double &coordinate( int i )
		{ return coord[ i ]; }

 	// Set coordinate values.

 	void set_x( double new_x ) { coord[ 0 ] = new_x; }
 	void set_y( double new_y ) { coord[ 1 ] = new_y; }
 	void set_z( double new_z ) { coord[ 2 ] = new_z; }

 	void set_coordinate( int i, double new_c )
		{ coord[ i ] = new_c; }
 
	// Position operators

	// Get displacement, i.e. a vector, as difference of two positions.

   friend  vector operator-( position const &, position const & );


	// Translate a position by a vector.

	friend  position operator+( position const &, vector const & );
	friend  position operator+( vector const &, position const & );
	position const &operator+=( vector const & );

	friend  position operator-( position const &, vector const & );
	position const &operator-=( vector const & );


	// Scalar product of position with vector.

	friend  double operator%( position const &, vector const & );
	friend  double operator%( vector const &, position const & );


	// Cross product of a position with a unit vector.

	friend  position operator*( position const &, unit_vector const & );
	friend  position operator*( unit_vector const &, position const & );


	// Transform a position.

	friend  position operator*( matrix const &, position const & );
	friend  position operator*( position const &, matrix const & );
	position const &operator*=( matrix const & );

	friend  position operator*( position const &, transf const & );
	friend  position operator*( position const &p, transf const *t );
	position const &operator*=( transf const & );


	// Interpolate between two positions. The parameter gives the
	// proportion of the segment between p1 and p2. In fact, the
	// parameter can be < 0 or > 1, in which case the function
	// extrapolates.

	friend  position interpolate( double,
						position const &, position const & );

	// STI let: add some general functions

	// Determine if 2 positions are equal, given some resolution
	friend  logical same_point( position const& pos1, position const& pos2, 
		const double res = resabs )
	{
		if((pos1.x() == pos2.x())&&(pos1.y()==pos2.y()))
			return 1;
		return 0;
	}

	// STI let: end

	// Output details of a position.

};

// STI let (7/96): global inline operators
// Determine if 2 positions are within resabs of each other
inline logical operator==( position const &p1, position const &p2 )
	{ return same_point( p1, p2, resabs ); }
inline logical operator!=( position const &p1, position const &p2 )
	{ return !same_point( p1, p2, resabs ); }
// STI let: end

#endif