Follow this link to skip to the main content

claraty Namespace Reference
[Data Structure]


Classes

struct  GUID_1394
class  N_2D_Array
class  N_2D_Array_Iterator
class  N_2D_Array_const_Iterator
class  N_1D_Array
class  Bits
class  Camera
class  Camera_Group
class  A_Camera
class  Camera_Model
struct  Camera_Image_Properties
class  Camera_Image
class  A_Camera_Model
class  FDM
class  FDM_Node
class  FDM_Stream
class  FDM_Untyped_Node
class  FDM_Map
class  FDM_Array
class  FDM_Singleton
class  Parse_Tree_Data
class  Parse_Tree
class  FDM_Parse_Tree
class  File_FDM_Parse_Tree
class  XML_Out
class  Device
class  Device_Group
class  Power_Switch
class  N_3D_Object
class  Bounding_Shape
class  Composite_Bounding_Shape
class  Image
class  Image_IO
class  Image_IO_Pgm_Simple
class  RGB_Image_IO
class  Image_IO_Factory
class  Image_Op
class  Convolve_Op
class  Rescale_Op
class  Gradient_Op
class  Transform_Op
class  Resample_Op
class  Non_Maxima_Sup_Op
class  Gamma_Op
class  DIO
class  DIO_impl
class  CDIO
class  DIO_null
class  DIO_sim
class  AO
class  AO_impl
class  AI
class  AI_impl
class  AI_impl_null
class  Matrix
class  Vector
class  Matrix_NxM
class  Unit_Vector
class  Matrix_LU
class  Matrix_SVD
class  Mechanism_Model
struct  Inertia
class  Mass_Properties
class  Display_Graphics
class  ME_Body
class  Joint_Limits
class  Joint_Stiffness
class  Joint_Constraint
class  ME_Joint
class  Frame
class  Mechanism_Model_IO
class  Mass_Properties_IO
class  N_3D_Object_IO
class  Bounding_Shape_IO
class  Display_Graphics_IO
class  ME_Body_IO
class  ME_Joint_IO
class  Frame_IO
class  Transform_IO
struct  Nelder_Mead_Ptr_Fun
class  N_1D_Function_Solver
class  ND_Function_Minimizer
struct  cl_simple_function
struct  cl_unary_function
struct  cl_binary_function
class  cl_binder2nd
class  cl_binder
struct  cl_plus
struct  cl_minus
struct  cl_multiplies
struct  cl_divides
struct  cl_min_op
struct  cl_max_op
struct  cl_round
struct  cl_left_shift
struct  cl_right_shift
struct  cl_bit_and
struct  cl_bit_or
struct  cl_bit_xor
struct  cl_bit_not
struct  cl_abs_op
struct  cl_sumsq_op
struct  cl_rms_op
struct  cl_lessthan_op
struct  cl_lessthan_equal_op
struct  cl_greaterthan_op
struct  cl_greaterthan_equal_op
struct  VFunctor0
struct  VFunctor0_const
struct  VFunctor1
struct  VFunctor2
class  Semaphore
class  Timer
class  BG_Task
class  bg_helper
class  bg_void_helper
class  bg
class  bg< void >
class  auto_bg
class  auto_bg< void >
struct  big_8
class  Parameter_Parser
class  PID_Controller
class  Point
class  N_2D_Point
class  Point_Cloud
class  N_2DOF_Planar_Arm
struct  queue_timeout
class  Q_Handle_Base
class  Q_Handle
class  Smart_Queue_Base
class  Smart_Queue
class  RGB_Color
class  RGB_Image
class  Exception
class  Stereovision
class  String_Rep
struct  string_change_suffix_fn
struct  string_has_suffix_fn
struct  string_has_suffix_chfn
class  Arglist
class  Trajectory
class  Trapezoidal_Trajectory
class  Multi_Segment_Trajectory
class  HTrans
class  QTrans
struct  Base_Trans
class  Trans
struct  Base_Quaternion
class  Quaternion
struct  Base_RMatrix
class  RMatrix
struct  Mapped_Pixel_Evaluator
class  Tsai_Camera_Model
class  Factory
struct  no_op
class  single_instance
class  Reference_Count
 Reference_Count class for reference counting. More...
class  ref_counter
class  Auto_Ref
class  const_Auto_Ref
class  Simple_Pseudo_Random_Number
class  Mersenne_Twist_Pseudo_Random_Number
class  Pseudo_Random_Number
class  Wheel_Locomotor_Model
class  Wheel_Model

Typedefs

typedef N_2D_Array< double > N_2D_Array_d
typedef N_1D_Array< double > N_1D_Array_d
typedef N_2D_Point< float > Pixel_Coord
typedef Point< float > Ray
typedef Matrix< double > Matrix_d
typedef Vector< double > Vector_i
typedef Point< double > Point_d
typedef Point< float > Point_f
typedef Point< int > Point_i
typedef N_2D_Point< double > N_2D_Point_d
typedef N_2D_Point< float > N_2D_Point_f
typedef N_2D_Point< int > N_2D_Point_i
typedef Point_Cloud< double > Point_Cloud_d
typedef std::binary_function<
std::string, std::string,
std::string > 		string_function
typedef Trans< double, RMatrix<
double > > 		Transform
typedef Transform Location

Enumerations

enum  MATRIX_TYPE { IDENTITY }
enum  Vector_Orientation { ROW_VECTOR, COL_VECTOR }
enum  Abs_Rel { ABSOLUTE = 0, RELATIVE }
enum  ROTATION_TYPE {
  RX, RY, RZ, EULER_ZYZ,
  EULER_XYZ, EULER_ZYX, RPY, ANGLE_AXIS,
  OTHER_ROT_TYPE
}

Functions

ostream & operator<< (ostream &s, const GUID_1394 &guid)
std::ostream & operator<< (std::ostream &s, const GUID_1394 &guid)
template<class T>
std::ostream & operator<< (std::ostream &os, const N_2D_Array< T > &m)
template<typename T>
bool io_object (FDM_Untyped_Node node, N_2D_Array< T > &rhs)
template<class T>
std::ostream & operator<< (std::ostream &os, const N_1D_Array< T > &v)
ostream & operator<< (ostream &ostr, const Bits &rhs)
static unsigned long _maskbit (size_t pos)
static unsigned long _maskbits (size_t pos, size_t n)
Bits operator & (const Bits &lhs, const Bits &rhs)
Bits operator| (const Bits &lhs, const Bits &rhs)
Bits operator^ (const Bits &, const Bits &)
std::ostream & operator<< (std::ostream &ostr, const Bits &rhs)
std::ostream & operator<< (std::ostream &os, const Camera &rhs)
std::istream & operator>> (std::istream &is, Camera &rhs)
std::ostream & operator<< (std::ostream &os, const Camera_Group &rhs)
std::istream & operator>> (std::istream &is, Camera_Group &rhs)
ostream & operator<< (ostream &os, const Camera_Image_Properties &rhs)
istream & operator>> (istream &is, Camera_Image_Properties &rhs)
std::ostream & operator<< (std::ostream &os, const Camera_Image_Properties &p)
template<typename Pixel_Type>
Camera_Image< Pixel_Type > rectify (const Camera_Image< Pixel_Type > &image)
template<typename Pixel_Type>
Camera_Image< Pixel_Type > rectify (Camera_Image< Pixel_Type > &image) throw (std::exception)
bool io_object (FDM_Map map, auto_ptr< Camera_Model > &model)
bool align_models (const Camera_Model &model1, const Camera_Model &model2, Camera_Model *&new_model1, Camera_Model *&new_model2, Map_Op &map1, Map_Op &map2)
 DEFINE_FACTORY_INIT (Camera_Model)
bool io_object (FDM_Map map, std::auto_ptr< Camera_Model > &model)
bool align_models (const Camera_Model &model1, const Camera_Model &model2, Camera_Model &new_model1, Camera_Model &new_model2, Map_Op &Map_op1, Map_Op &Map_op2)
std::ostream & operator<< (std::ostream &os, const Camera_Model &model)
 DECLARE_FACTORY_INIT (Camera_Model, factory)
bool io_object (FDM_Map map, std::auto_ptr< A_Camera_Model > &model)
std::istream & operator>> (std::istream &str, A_Camera_Model &m)
std::ostream & operator<< (std::ostream &str, const A_Camera_Model &m)
void fdm_error (const char *msg)
string pt_string_get_quoted (string &src, int quotechar)
string pt_string_quote (const string &src, int quotechar)
static bool read_string (istream &is, Parse_Tree &pt, const string &tchars)
static bool read_item (istream &is, Parse_Tree &pt, char &endchar, const string &tchars, bool skip_white=true)
static bool read_field (istream &is, std::string &label, Parse_Tree &pt, bool &finished)
ostream & operator<< (ostream &os, const Parse_Tree &pt)
istream & operator>> (istream &is, Parse_Tree &pt)
template<class C>
bool io_object (FDM_Untyped_Node node, C &c)
std::istream & operator>> (std::istream &is, Parse_Tree &pb)
std::ostream & operator<< (std::ostream &os, const Parse_Tree &pb)
template<class T>
static std::string object_to_string (const T &obj)
template<class T>
static bool string_to_object (T &obj, const std::string &str_in)
std::ostream & operator<< (std::ostream &os, const Device &rhs)
std::istream & operator>> (std::istream &is, Device &rhs)
std::ostream & operator<< (std::ostream &os, const Device_Group &rhs)
std::istream & operator>> (std::istream &is, Device_Group &rhs)
std::ostream & operator<< (std::ostream &os, N_3D_Object &n_3D_object)
std::ostream & operator<< (std::ostream &os, Bounding_Shape &bounding_shape)
std::ostream & operator<< (std::ostream &os, Composite_Bounding_Shape &composite_bounding_shape)
template<class T>
bool io_image (FDM_Map &map, Image< T > &rhs)
template<class T>
bool io_object (FDM_Untyped_Node node, Image< T > &rhs)
 DEFINE_FACTORY_INIT (Image_IO_Factory)
 DECLARE_FACTORY_INIT (Image_IO_Factory, factory)
static size_t compute_n_bits_total (DIO *dio_array, int n_dios)
template<class T>
Matrix< M_FLOAT > to_float (const Matrix< T > &tm)
template<class T>
const Matrix< T > operator * (const Matrix< T > &lhs, const Matrix< T > &rhs)
template<class M>
M elements (const M &lhs, char op, const M &rhs)
template<class T>
std::ostream & operator<< (std::ostream &os, const Matrix< T > &m)
template<class T1, class T2, class Op>
Vector< T1 > vector_transform (const Vector< T1 > &lhs, const Vector< T2 > &rhs, Op op)
template<class T1, class T2>
Vector< T1 > operator+ (const Vector< T1 > &lhs, const Vector< T2 > &rhs)
template<class T1, class T2>
Vector< T1 > operator- (const Vector< T1 > &lhs, const Vector< T2 > &rhs)
template<class T>
std::ostream & operator<< (std::ostream &os, const Vector< T > &v)
template<class T>
bool io_object (FDM_Untyped_Node node, Vector< T > &rhs)
template<class T, int NR1, int NC1, int NC2>
const Matrix_NxM< T, NR1,
NC2 > 		operator * (const Matrix_NxM< T, NR1, NC1 > &lhs, const Matrix_NxM< T, NC1, NC2 > &rhs)
template<class T, int Nrows, int Ncols>
bool io_object (FDM_Untyped_Node node, Matrix_NxM< T, Nrows, Ncols > &rhs)
template<class T1, class T2>
void match_orientations (const Vector< T1 > &lhs, const Matrix< T2 > &rhs)
template<class T1, class T2>
Vector< T1 > operator+ (const Vector< T1 > &lhs, const Matrix< T2 > &rhs)
template<class T1, class T2>
Vector< T1 > operator- (const Vector< T1 > &lhs, const Matrix< T2 > &rhs)
template<class T1, class T2>
Vector< T1 > operator+ (const Matrix< T1 > &lhs, const Vector< T2 > &rhs)
template<class T1, class T2>
Vector< T1 > operator- (const Matrix< T1 > &lhs, const Vector< T2 > &rhs)
template<class T1, class T2>
Matrix< T1 > operator * (const Vector< T1 > &lhs, const Vector< T2 > &rhs)
template<class T1, class T2>
Vector< T1 > operator * (const Matrix< T1 > &lhs, const Vector< T2 > &rhs)
template<class T1, class T2>
Vector< T1 > operator * (const Vector< T1 > &lhs, const Matrix< T2 > &rhs)
template<class T>
Vector< T > cross (const Vector< T > &a, const Vector< T > &b)
template<class T>
double norm (const Vector< T > &a)
template<class T>
T sum (const Vector< T > &a)
template<class T>
Matrix< T > cat_col (const Matrix< T > &A, const Matrix< T > &B)
template<class T>
Matrix< T > cat_row (const Matrix< T > &A, const Matrix< T > &B)
template<class T>
std::ostream & operator<< (std::ostream &os, const Unit_Vector< T > &n)
template<class T>
bool io_object (FDM_Untyped_Node node, Unit_Vector< T > &rhs)
template<class T>
Matrix< M_FLOAT > inverse (const Matrix< T > &tm)
template<class T>
Matrix_NxM< T, 2, 2 > inverse (const Matrix_NxM< T, 2, 2 > &m)
template<class T>
Matrix_NxM< T, 3, 3 > inverse (const Matrix_NxM< T, 3, 3 > &m)
Vector< int > LU_decompose (Matrix< M_FLOAT > &a, int &sgn)
template<class T>
T det (const Matrix< T > &m)
template<class T>
void matrix_cholesky (const Matrix< T > &A, Matrix< T > &L)
template<class T>
void matrix_cholesky_backsubstitute (const Matrix< T > &L, const Matrix< T > &B, Matrix< T > &X)
template<class T>
void matrix_solve_symposdef (const Matrix< T > &A, const Matrix< T > &B, Matrix< T > &X)
std::ostream & operator<< (std::ostream &os, Mechanism_Model &mm)
std::ostream & operator<< (std::ostream &os, Mass_Properties &mass_properties)
std::ostream & operator<< (std::ostream &os, Display_Graphics &display_graphics)
std::ostream & operator<< (std::ostream &os, ME_Body &me_body)
std::ostream & operator<< (std::ostream &os, ME_Joint &me_joint)
std::ostream & operator<< (std::ostream &os, Frame &frame)
template<class BinOp, class T>
cl_binder2nd< BinOp > cl_bind2nd (const BinOp &op, const T &v)
template<class UnaryOp, class T>
cl_binder< UnaryOp > cl_bind (const UnaryOp &op, const T &arg)
template<class In, class Out, class UnaryOp>
Out cl_transform (In first, In last, Out res, UnaryOp op)
template<class In, class In2, class Out, class BinOp>
Out cl_transform (In first1, In last, In2 first2, Out res, BinOp op)
template<class T, class In, class BinOp>
T cl_reduce (T identity, In first, In last, BinOp op)
template<class In, class In2, class T>
T cl_inner_product (In first, In last, In2 first2, T init)
template<class In, class T>
T cl_accumulate (In first, In last, T init)
template<class Container, class Op>
Container & cl_apply (Container &c, Op op)
template<class Op, class res_type>
std::auto_ptr< BG_Task > background (Op op, res_type &retval, bool detach=false)
template<class Op>
std::auto_ptr< BG_Task > background (Op op, bool detach=false)
template<class T, class R, class A, class B, class C, class D, class E, class F, class G, class H>
big_8< T, R, A, B, C, D, E,
F, G, H > 		compos8 (T *const obj, R(T::*func)(A, B, C, D, E, F, G, H), A a, B b, C c, D d, E e, F f, G g, H h)
template<typename T>
Point< T > operator+ (const Point< T > &, const Point< T > &v2)
template<typename T>
Point< T > operator- (const Point< T > &, const Point< T > &)
template<typename T>
Point< T > operator- (const Point< T > &)
template<typename T, typename T2>
Point< T > operator * (const Point< T > &, T2)
template<typename T, typename T2>
Point< T > operator * (T2, const Point< T > &)
template<typename T, typename T2>
Point< T > operator/ (const Point< T > &, T2)
template<typename T>
Point< T > normalize (const Point< T > &p)
template<typename T>
std::ostream & operator<< (std::ostream &os, const Point< T > &p)
template<typename T>
bool io_object (FDM_Untyped_Node node, Point< T > &rhs)
template<typename T>
bool cl_is_nan (const Point< T > &p)
template<typename T>
void cl_nan (Point< T > &p)
template<class T>
bool operator== (const N_2D_Point< T > &, const N_2D_Point< T > &)
template<class T>
N_2D_Point< T > operator+ (const N_2D_Point< T > &, const N_2D_Point< T > &)
template<class T>
N_2D_Point< T > operator- (const N_2D_Point< T > &, const N_2D_Point< T > &)
template<class T>
N_2D_Point< T > operator- (const N_2D_Point< T > &)
template<class T>
N_2D_Point< T > operator * (double, const N_2D_Point< T > &)
template<class T>
N_2D_Point< T > operator/ (const N_2D_Point< T > &, double)
template<class T>
N_2D_Point< T > operator * (const N_2D_Point< T > &v, double s)
template<typename elem_type>
std::ostream & operator<< (std::ostream &os, const N_2D_Point< elem_type > &p)
template<class T>
std::istream & operator>> (std::istream &is, N_2D_Point< T > &p)
template<class T>
bool io_object (FDM_Untyped_Node node, N_2D_Point< T > &rhs)
template<class T>
bool cl_isnan (const N_2D_Point< T > &pt)
template<class T>
void cl_setnan (N_2D_Point< T > &pt)
void memory_failure (void)
void abnormal_abort (int)
void division_by_zero (int)
void illegal_operation (int)
void ctrl_break (int)
void illegal_storage_access (int)
void request_termination (int)
unsigned int hex_to_int (char *)
int order (float x)
bool cl_isnan (float x)
bool cl_isnan (double x)
bool cl_isnan (unsigned char x)
bool cl_isnan (char x)
bool cl_isnan (unsigned short x)
bool cl_isnan (short x)
bool cl_isnan (unsigned int x)
bool cl_isnan (int x)
bool cl_isnan (unsigned long x)
bool cl_isnan (long x)
double cl_nan ()
float cl_nan_f ()
void cl_setnan (float &x)
void cl_setnan (double &x)
void cl_setnan (unsigned char &x)
void cl_setnan (char &x)
void cl_setnan (unsigned short &x)
void cl_setnan (short &x)
void cl_setnan (unsigned int &x)
void cl_setnan (int &x)
void cl_setnan (unsigned long &x)
void cl_setnan (long &x)
template<class T>
bool is_integral_type ()
template<>
bool is_integral_type< unsigned char > ()
template<>
bool is_integral_type< char > ()
template<>
bool is_integral_type< unsigned short > ()
template<>
bool is_integral_type< short > ()
template<>
bool is_integral_type< unsigned int > ()
template<>
bool is_integral_type< int > ()
template<>
bool is_integral_type< unsigned long > ()
template<>
bool is_integral_type< long > ()
template<>
bool is_integral_type< unsigned long long > ()
template<>
bool is_integral_type< long long > ()
template<class T>
bool is_floating_point_type ()
template<>
bool is_floating_point_type< float > ()
template<>
bool is_floating_point_type< double > ()
template<>
bool is_floating_point_type< long double > ()
template<class T>
bool is_numeric_type ()
template<class T>
T type_min_value ()
template<class T>
T type_max_value ()
template<>
float type_min_value< float > ()
template<>
float type_max_value< float > ()
template<>
double type_min_value< double > ()
template<>
double type_max_value< double > ()
template<>
char type_min_value< char > ()
template<>
short type_min_value< short > ()
template<>
int type_min_value< int > ()
template<>
long type_min_value< long > ()
template<>
long long type_min_value< long long > ()
template<class Result, class Src>
Result round_truncate_cast (const Src &src)
template<class Result, class Src>
Result round_cast (const Src &src)
template<class Src, class Dest>
void round_truncate_copy (const Src &src, Dest &dest)
void clear ()
void wait_clear ()
void thick_line ()
void thin_line ()
void page_header (const char *s)
void page_footer (int wait)
void header1 (const char *s)
void left_justify (const char *s)
void right_justify (const char *s)
void title (const char *s)
string string_strip (const string &src, const string &ignore)
string string_strip_front (const string &src, const string &ignore)
string string_strip_end (const string &src, const string &ignore)
string string_get_token (string &src, const string &delims, const string &tokchars)
string string_get_quoted (string &src, int quotechar)
string string_quote (const string &src, int quotechar)
vector< string > string_get_tokens (string &src, const string &delims, const string &tokchars)
bool string_eat_double (string &src, double &d, const string &ignore)
bool string_eat_long (string &src, long &d, const string &ignore)
bool string_eat_bool (string &src, bool &d, const string &ignore)
string string_change_suffix (const string &src, const string &newsuffix, const string &delim)
bool string_has_suffix (const string &src, const string &suffix)
bool string_has_suffix (const string &src, const char *suffix)
string string_suffix (const string &source, const string &delimeters)
string string_remove_suffix (const string &lhs, const string &suffix)
string string_vprintf (const char *fmt, va_list args)
string string_printf (const char *fmt,...)
bool string_is_flag (const string &x)
string string_remove_token (string &src, const string &delims)
string string_first_token (const string &src, const string &delims)
string string_last_token (const string &src, const string &delims)
vector< string > string_tokens (const string &src, const string &delims)
void string_chomp (string &src)
string string_right (const string &src, size_t len)
string string_left (const string &src, size_t len)
string string_find_and_replace (const string &src, const string &from, const string &to)
string string_find_and_replace_all (const string &src, const string &from, const string &to)
string string_find_and_replace_n (const string &src, const string &from, const string &to, int max_replacements)
std::string string_strip (const std::string &src, const std::string &ignore=" \t\n\r")
std::string string_strip_front (const std::string &src, const std::string &ignore=" \t\n\r")
std::string string_strip_end (const std::string &src, const std::string &ignore=" \t\n\r")
 DEF_STRING_FUNCTOR (string_strip)
 DEF_STRING_FUNCTOR (string_strip_front)
 DEF_STRING_FUNCTOR (string_strip_end)
std::string string_get_token (std::string &src, const std::string &delims=" \t\n\r", const std::string &tokchars="")
std::vector< std::string > string_get_tokens (std::string &src, const std::string &delims=" \t\n\r", const std::string &tokchars="")
bool string_eat_double (std::string &src, double &d, const std::string &ignore=" \t\n\r")
bool string_eat_long (std::string &src, long &d, const std::string &ignore=" \t\n\r")
bool string_eat_bool (std::string &src, bool &d, const std::string &ignore=" \t\n\r")
std::string string_change_suffix (const std::string &src, const std::string &newsuffix, const std::string &delim=".")
bool string_has_suffix (const std::string &src, const std::string &suffix)
bool string_has_suffix (const std::string &src, const char *suffix)
std::string string_suffix (const std::string &source, const std::string &delimeters=".")
std::string string_remove_suffix (const std::string &lhs, const std::string &suffix)
 DEF_STRING_FUNCTOR (string_remove_suffix)
std::string string_get_quoted (std::string &src, int quotechar='\"')
std::string string_quote (const std::string &src, int quotechar='\"')
template<class I>
std::string string_join (I begin, I end, const std::string &delim)
template<class T>
std::string output_to_string (const T &value)
std::string string_join (const std::vector< std::string > &tokens, const std::string &delim)
bool string_is_flag (const std::string &x)
std::string string_first_token (const std::string &src, const std::string &delims=" \t\n\r")
std::string string_last_token (const std::string &src, const std::string &delims=" \t\n\r")
std::vector< std::string > string_tokens (const std::string &src, const std::string &delims=" \t\n\r")
void string_chomp (std::string &src)
std::string string_right (const std::string &src, size_t len)
std::string string_left (const std::string &src, size_t len)
std::string string_find_and_replace (const std::string &src, const std::string &from, const std::string &to)
std::string string_find_and_replace_n (const std::string &src, const std::string &from, const std::string &to, int max_replacements)
std::string string_find_and_replace_all (const std::string &src, const std::string &from, const std::string &to)
std::string string_remove_token (std::string &src, const std::string &delims=" \t\n\r")
template<class T>
void string_from_type (std::string &out_string, T &type_value, unsigned int precision=10)
ostream & operator<< (ostream &os, const Trapezoidal_Trajectory &traj)
ostream & operator<< (ostream &os, const Multi_Segment_Trajectory &traj)
std::ostream & operator<< (std::ostream &os, const Trajectory &traj)
template<class T>
std::ostream & operator<< (std::ostream &os, const HTrans< T > &h)
template<class T>
HTrans< T > inverse (const HTrans< T > &q)
template<class T>
std::ostream & operator<< (std::ostream &os, const QTrans< T > &q)
template<class T>
QTrans< T > inverse (const QTrans< T > &q)
template<class T1, class Rotation_Type1>
Trans< T1, Rotation_Type1 > inverse (const Trans< T1, Rotation_Type1 > &q)
template<class T2, class Rotation_Type2>
std::ostream & operator<< (std::ostream &os, const Trans< T2, Rotation_Type2 > &tt)
template<class T>
std::ostream & operator<< (std::ostream &os, const Quaternion< T > &q)
template<class T>
RMatrix< T > inverse (RMatrix< T > r)
template<class T>
const RMatrix< T > operator * (const RMatrix< T > &lhs, const RMatrix< T > &rhs)
template<class T>
const Point< T > operator * (const RMatrix< T > &lhs, const Point< T > &rhs)
template<class T>
std::ostream & operator<< (std::ostream &os, const RMatrix< T > &m)
template<class T>
const Matrix< T > operator * (const RMatrix< T > &lhs, const Matrix< T > &rhs)
template<class T>
const Matrix< T > operator * (const Matrix< T > &lhs, const RMatrix< T > &rhs)
template<class T>
bool io_object (FDM_Untyped_Node node, RMatrix< T > &rhs)
 DEFINE_BUILDER_INIT (Tsai_Camera_Model)
Ray operator * (const Matrix< float > &m, const Ray &r)
ostream & operator<< (ostream &os, const Tsai_Camera_Model &model)
istream & operator>> (istream &is, Tsai_Camera_Model &model)
 DECLARE_BUILDER_INIT (Camera_Model, Tsai_Camera_Model, factory, Tsai_Camera_Model::build)
std::istream & operator>> (std::istream &str, Tsai_Camera_Model &m)
std::ostream & operator<< (std::ostream &str, const Tsai_Camera_Model &m)

Variables

const size_t MAX_BITS = sizeof(unsigned long) * 8
const int NUMBER_OF_3D_OBJECT_DIMENSIONS = 3
static DIO_null dio_null (MAX_BITS)
const bool INVERT_LOGIC = true
const bool INVERT_SIGNAL = true

Detailed Description

A base class for all image file operation (saving/loading) implementations. Image_IO defines a abstract load and save methods that implementations must implement. It also supports setting and getting of filenames. Future implementations will support other functions common to image formats (saving information with tags, compression, etc.). The load and save functions are defined with explicit image instantiations so they can be made virtual and overridden by the extending classes.

Typedef Documentation

typedef Transform claraty::Location

Definition at line 44 of file transform.h.

typedef Matrix<double> claraty::Matrix_d

Definition at line 67 of file matrix.h.

typedef N_1D_Array<double> claraty::N_1D_Array_d

Definition at line 45 of file 1d_array.h.

typedef N_2D_Array<double> claraty::N_2D_Array_d

Definition at line 49 of file 2d_array.h.

typedef N_2D_Point< double > claraty::N_2D_Point_d

Definition at line 47 of file 2d_point.h.

typedef N_2D_Point< float > claraty::N_2D_Point_f

Definition at line 50 of file 2d_point.h.

typedef N_2D_Point< int > claraty::N_2D_Point_i

Definition at line 51 of file 2d_point.h.

typedef N_2D_Point<float> claraty::Pixel_Coord

Definition at line 34 of file camera_model.h.

typedef Point_Cloud<double> claraty::Point_Cloud_d

Definition at line 34 of file point_cloud.h.

typedef Point<double> claraty::Point_d

Definition at line 57 of file point.h.

typedef Point<float> claraty::Point_f

Definition at line 60 of file point.h.

typedef Point<int> claraty::Point_i

Definition at line 61 of file point.h.

typedef Point<float> claraty::Ray

Definition at line 38 of file camera_model.h.

typedef std::binary_function<std::string, std::string, std::string> claraty::string_function

Definition at line 52 of file string_util.h.

typedef Trans<double, RMatrix<double> > claraty::Transform

Definition at line 40 of file transform.h.

typedef Vector<double> claraty::Vector_i

Definition at line 68 of file matrix.h.

Enumeration Type Documentation

enum claraty::Abs_Rel

Enumerator:
ABSOLUTE 
RELATIVE 

Definition at line 120 of file share.h.

00120 {ABSOLUTE=0, RELATIVE};

enum claraty::MATRIX_TYPE

Enumerator:
IDENTITY 

Definition at line 61 of file matrix.h.

00061 {IDENTITY};

enum claraty::ROTATION_TYPE

Enumerator:
RX 
RY 
RZ 
EULER_ZYZ 
EULER_XYZ 
EULER_ZYX 
RPY 
ANGLE_AXIS 
OTHER_ROT_TYPE 

Definition at line 60 of file rotation_matrix.h.

00060              {
00061   RX,
00062   RY,
00063   RZ,
00064   EULER_ZYZ,
00065   EULER_XYZ,
00066   EULER_ZYX,
00067   RPY,
00068   ANGLE_AXIS,
00069   OTHER_ROT_TYPE}

enum claraty::Vector_Orientation

Enumerator:
ROW_VECTOR 
COL_VECTOR 

Definition at line 60 of file vector.h.

00060 { ROW_VECTOR, COL_VECTOR };

Function Documentation

static unsigned long claraty::_maskbit ( size_t  pos  )  [static]

Definition at line 160 of file bits.h.

Referenced by claraty::Bits::Bits(), claraty::Bits::clr_bit(), claraty::Bits::reference::operator bool(), claraty::Bits::reference::operator=(), claraty::Bits::operator[](), claraty::Bits::reference::operator~(), claraty::Bits::set_bit(), claraty::Bits::test(), claraty::Bits::reference::toggle(), and claraty::Bits::toggle_bit().

00161 {
00162   // only one mask bit at pos is 1;
00163   // mask[pos]=1; all other bits = 0
00164   //
00165   return (static_cast<unsigned long>(1) << pos);
00166 }

static unsigned long claraty::_maskbits ( size_t  pos,
size_t  n 
) [static]

Definition at line 169 of file bits.h.

Referenced by claraty::Bits::clr_bits(), and claraty::Bits::set_bits().

00170 {
00171   // n mask bits starting from pos are 1;
00172   // mask[pos] = ... = mask[pos+n-1] = 1; all other bits = 0
00173   //
00174   return (~(~static_cast<unsigned long>(0) << n)) << pos;
00175 }

void claraty::abnormal_abort ( int  i  ) 

Exceptional handlers for signal. This is called when an abnormal abort occurs

Parameters:
[in] i 

Definition at line 70 of file share.cc.

00071 {
00072   cerr << "abnormal termination: signal handler SIGABRT raised " 
00073             << i << endl;
00074   exit(3);
00075 }

bool claraty::align_models ( const Camera_Model &  model1,
const Camera_Model &  model2,
Camera_Model &  new_model1,
Camera_Model &  new_model2,
Map_Op &  Map_op1,
Map_Op &  Map_op2 
)

bool claraty::align_models ( const Camera_Model &  model1,
const Camera_Model &  model2,
Camera_Model *&  new_model1,
Camera_Model *&  new_model2,
Map_Op &  map1,
Map_Op &  map2 
)

Align_models is the function that does epipolar alignment with another camera. Two new camera models are produced as the output, as well as two rectify_op objects which can be used to warp images from this camera model and the other camera model into the new ones. Typically this operation would both remove lens distortion ("linearize" the models) and warp the images to make epipolar lines horizontal and at the same y-coordinate ("align" the models). This function should return true if the alignment can happen, and false otherwise (if for example the camera model types are incompatible).

Definition at line 289 of file camera_model.cc.

00295 { 
00296   return false; 
00297 }

template<class Op>
std::auto_ptr<BG_Task> claraty::background ( Op  op,
bool  detach = false 
)

Definition at line 239 of file background_thread.h.

00239                                                             {
00240   return std::auto_ptr<BG_Task>(new bg<void>(op, detach));
00241 }

template<class Op, class res_type>
std::auto_ptr<BG_Task> claraty::background ( Op  op,
res_type &  retval,
bool  detach = false 
)

Definition at line 233 of file background_thread.h.

00234                                                        {
00235   return std::auto_ptr<BG_Task>(new bg<res_type>(op, retval, detach));
00236 }

template<class T>
Matrix<T> claraty::cat_col ( const Matrix< T > &  A,
const Matrix< T > &  B 
)

Concatenates the columns of the matrix B to the matrix A and returns the result (for A (n x m) and B (p x q), returns a matrix of size n x m+q) Requires the number of rows (n and p) to be equal.

Definition at line 300 of file matrix_operator.h.

References claraty::N_2D_Array< T >::get_num_of_cols(), and claraty::N_2D_Array< T >::get_num_of_rows().

00300                                                           {
00301 
00302   Matrix<T> R(A.get_num_of_rows(), A.get_num_of_cols()+B.get_num_of_cols());
00303 
00304   if(A.get_num_of_rows() != B.get_num_of_rows()) {
00305     std::cout << "cat_col: matrix number of rows do not much" << std::endl;
00306   }
00307 
00308   for(int r=0; r<A.get_num_of_rows(); r++) {
00309     for(int c=0; c<A.get_num_of_cols(); c++) {
00310       R(r,c) = A(r,c);
00311     }
00312     for(int c=0; c<B.get_num_of_cols(); c++) {
00313       R(r,A.get_num_of_cols()+c) = B(r,c);
00314     }
00315   }
00316 
00317   return R;
00318 }

Here is the call graph for this function:

template<class T>
Matrix<T> claraty::cat_row ( const Matrix< T > &  A,
const Matrix< T > &  B 
)

Concatenates the rows of the matrix B to the matrix A and returns the result (for A (n x m) and B (p x q), returns a matrix of size n+p x m) Requires the number of cols (m and q) to be equal.

Definition at line 327 of file matrix_operator.h.

References claraty::N_2D_Array< T >::get_num_of_cols(), and claraty::N_2D_Array< T >::get_num_of_rows().

00327                                                           {
00328 
00329   Matrix<T> R(A.get_num_of_rows()+B.get_num_of_rows(),
00330               A.get_num_of_cols());
00331 
00332   if(A.get_num_of_cols() != B.get_num_of_cols()) {
00333     std::cout << "cat_row: matrix number of cols do not much" << std::endl;
00334   }
00335 
00336   for(int c=0; c<A.get_num_of_cols(); c++) {
00337     for(int r=0; r<A.get_num_of_rows(); r++) {
00338       R(r,c) = A(r,c);
00339     }
00340     for(int r=0; r<B.get_num_of_rows(); r++) {
00341       R(A.get_num_of_rows()+r,c) = B(r,c);
00342     }
00343   }
00344 
00345   return R;
00346 }

Here is the call graph for this function:

template<class In, class T>
T claraty::cl_accumulate ( In  first,
In  last,
T  init 
)

Definition at line 189 of file functor.h.

Referenced by claraty::Matrix< T >::average(), and claraty::Matrix< T >::sum().

00190 {
00191   for ( ; first != last; ++first)
00192     init += *first;
00193   return init;
00194 }

template<class Container, class Op>
Container& claraty::cl_apply ( Container &  c,
Op  op 
)

Definition at line 236 of file functor.h.

References cl_transform().

Referenced by claraty::Matrix< uint16_t >::scalar_apply().

00236                                          {
00237   cl_transform(c.begin(), c.end(), c.begin(), op);
00238   return c;
00239 }

Here is the call graph for this function:

template<class UnaryOp, class T>
cl_binder<UnaryOp> claraty::cl_bind ( const UnaryOp &  op,
const T &  arg 
) [inline]

Definition at line 102 of file functor.h.

00103 {
00104   return cl_binder<UnaryOp>(op, arg);
00105 }

template<class BinOp, class T>
cl_binder2nd<BinOp> claraty::cl_bind2nd ( const BinOp &  op,
const T &  v 
) [inline]

Definition at line 86 of file functor.h.

Referenced by claraty::Matrix< uint16_t >::scalar_apply().

00087 {
00088   return cl_binder2nd<BinOp>(op, v);
00089 }

template<class In, class In2, class T>
T claraty::cl_inner_product ( In  first,
In  last,
In2  first2,
T  init 
)

Definition at line 181 of file functor.h.

Referenced by operator *().

00182 {
00183   for ( ; first != last; ++first, ++first2)
00184     init += *first * *first2;
00185   return init;
00186 }

template<typename T>
bool claraty::cl_is_nan ( const Point< T > &  p  )  [inline]

Definition at line 854 of file point.h.

References claraty::Point< T >::x(), claraty::Point< T >::y(), and claraty::Point< T >::z().

00855 {
00856   return ( cl_is_nan(p.x()) || 
00857            cl_is_nan(p.y()) || 
00858            cl_is_nan(p.z()) );
00859 }

Here is the call graph for this function:

bool claraty::cl_isnan ( long  x  )  [inline]

Definition at line 71 of file math_limits.h.

00071                              {
00072   return 0;
00073 }

bool claraty::cl_isnan ( unsigned long  x  )  [inline]

Definition at line 67 of file math_limits.h.

00067                                       {
00068   return 0;
00069 }

bool claraty::cl_isnan ( int  x  )  [inline]

Definition at line 63 of file math_limits.h.

00063                             {
00064   return 0;
00065 }

bool claraty::cl_isnan ( unsigned int  x  )  [inline]

Definition at line 59 of file math_limits.h.

00059                                      {
00060   return 0;
00061 }

bool claraty::cl_isnan ( short  x  )  [inline]

Definition at line 55 of file math_limits.h.

00055                               {
00056   return 0;
00057 }

bool claraty::cl_isnan ( unsigned short  x  )  [inline]

Definition at line 51 of file math_limits.h.

00051                                        {
00052   return 0;
00053 }

bool claraty::cl_isnan ( char  x  )  [inline]

Definition at line 47 of file math_limits.h.

00047                              {
00048   return 0;
00049 }

bool claraty::cl_isnan ( unsigned char  x  )  [inline]

Definition at line 43 of file math_limits.h.

00043                                       {
00044   return 0;
00045 }

bool claraty::cl_isnan ( double  x  )  [inline]

Definition at line 39 of file math_limits.h.

00039                                {
00040   return x != x;
00041 }

bool claraty::cl_isnan ( float  x  )  [inline]

Definition at line 35 of file math_limits.h.

00035                               {
00036   return x != x;
00037 }

template<class T>
bool claraty::cl_isnan ( const N_2D_Point< T > &  pt  )  [inline]

Definition at line 801 of file 2d_point.h.

References claraty::N_2D_Point< T >::x(), and claraty::N_2D_Point< T >::y().

00801                                               {
00802   return cl_isnan(pt.x()) || cl_isnan(pt.y());
00803 }

Here is the call graph for this function:

double claraty::cl_nan (  )  [inline]

Definition at line 75 of file math_limits.h.

00075                        {
00076   static double ret= sqrt(-1.0);
00077   return ret;
00078 }

template<typename T>
void claraty::cl_nan ( Point< T > &  p  )  [inline]

Definition at line 867 of file point.h.

References claraty::Point< T >::x(), claraty::Point< T >::y(), and claraty::Point< T >::z().

Referenced by cl_setnan().

00867                                 {
00868   T nan;
00869   cl_nan( nan );
00870   p.x( nan );
00871   p.y( nan );
00872   p.z( nan );
00873 }

Here is the call graph for this function:

float claraty::cl_nan_f (  )  [inline]

Definition at line 80 of file math_limits.h.

Referenced by cl_setnan().

00080                         {
00081   static float ret= sqrt(-1.0f);
00082   return ret;
00083 }

template<class T, class In, class BinOp>
T claraty::cl_reduce ( T  identity,
In  first,
In  last,
BinOp  op 
) [inline]

Definition at line 133 of file functor.h.

00134 {
00135   for ( ; first != last; ++first)
00136     identity= op(identity, *first);
00137   return identity;
00138 }

void claraty::cl_setnan ( long &  x  )  [inline]

Definition at line 100 of file math_limits.h.

00100 {x= 0;}

void claraty::cl_setnan ( unsigned long &  x  )  [inline]

Definition at line 99 of file math_limits.h.

00099 {x= 0;}

void claraty::cl_setnan ( int &  x  )  [inline]

Definition at line 98 of file math_limits.h.

00098 {x= 0;}

void claraty::cl_setnan ( unsigned int &  x  )  [inline]

Definition at line 97 of file math_limits.h.

00097 {x= 0;}

void claraty::cl_setnan ( short &  x  )  [inline]

Definition at line 96 of file math_limits.h.

00096 {x= 0;}

void claraty::cl_setnan ( unsigned short &  x  )  [inline]

Definition at line 95 of file math_limits.h.

00095 {x= 0;}

void claraty::cl_setnan ( char &  x  )  [inline]

Definition at line 94 of file math_limits.h.

00094 {x= 0;}

void claraty::cl_setnan ( unsigned char &  x  )  [inline]

Definition at line 93 of file math_limits.h.

00093 {x= 0;}

void claraty::cl_setnan ( double &  x  )  [inline]

Definition at line 89 of file math_limits.h.

References cl_nan().

00089                                  {
00090   x=  cl_nan();
00091 }

Here is the call graph for this function:

void claraty::cl_setnan ( float &  x  )  [inline]

Definition at line 85 of file math_limits.h.

References cl_nan_f().

00085                                 {
00086   x=  cl_nan_f();
00087 }

Here is the call graph for this function:

template<class T>
void claraty::cl_setnan ( N_2D_Point< T > &  pt  )  [inline]

Definition at line 806 of file 2d_point.h.

References claraty::N_2D_Point< T >::x(), and claraty::N_2D_Point< T >::y().

00806                                          {
00807   cl_setnan(pt.x());
00808   cl_setnan(pt.y());
00809 }

Here is the call graph for this function:

template<class In, class In2, class Out, class BinOp>
Out claraty::cl_transform ( In  first1,
In  last,
In2  first2,
Out  res,
BinOp  op 
) [inline]

Definition at line 123 of file functor.h.

00124 {
00125   for ( ; first1 != last; ++first1, ++first2, ++res)
00126     *res = op(*first1, *first2);
00127   return res;
00128 }

template<class In, class Out, class UnaryOp>
Out claraty::cl_transform ( In  first,
In  last,
Out  res,
UnaryOp  op 
) [inline]

Definition at line 115 of file functor.h.

Referenced by claraty::Matrix< T >::abs(), cl_apply(), claraty::Matrix< uint16_t >::operator+=(), claraty::Matrix< uint16_t >::operator-=(), and claraty::Matrix< uint16_t >::scalar_apply().

00116 {
00117   for ( ; first != last; ++first, ++res)
00118     *res = op(*first);
00119   return res;
00120 }

void claraty::clear (  )  [inline]

Definition at line 47 of file display.h.

Referenced by pug::xml_parser::create(), page_header(), pug::xml_parser::parse(), pug::xml_parser::parse_file(), title(), and wait_clear().

00048 {
00049   system("clear");
00050 }

template<class T, class R, class A, class B, class C, class D, class E, class F, class G, class H>
big_8<T, R, A, B, C, D, E, F, G, H> claraty::compos8 ( T *const  obj,
R(T::*)(A, B, C, D, E, F, G, H)  func,
A  a,
B  b,
C  c,
D  d,
E  e,
F  f,
G  g,
H  h 
)

Definition at line 277 of file background_thread.h.

00279 {
00280   return big_8<T, R, A, B, C, D, E, F, G, H>
00281     (obj, func, a, b, c, d, e, f, g, h);
00282 }

static size_t claraty::compute_n_bits_total ( DIO *  dio_array,
int  n_dios 
) [static]

Definition at line 304 of file composite_digital_io.cc.

00305 {
00306   int _n_bits_total  = 0;
00307  
00308   for (int i=0; i<n_dios; ++i)
00309     _n_bits_total += dio_array[i].bit_size();
00310  
00311   return _n_bits_total;
00312 }

template<class T>
Vector<T> claraty::cross ( const Vector< T > &  a,
const Vector< T > &  b 
)

Returns the cross product: a x b

Definition at line 255 of file matrix_operator.h.

References claraty::Vector< T >::get_num_of_cols().

00255                                                         {
00256 
00257   Vector<T> c(3);
00258 
00259   if((a.get_num_of_cols() != 3) || (b.get_num_of_cols() != 3)) {
00260     std::cout << "cross (vector cross product): vector size must be 3." << std::endl;
00261     return c;
00262   }
00263 
00264   c(0) = a(1)*b(2) - a(2)*b(1);
00265   c(1) = a(2)*b(0) - a(0)*b(2);
00266   c(2) = a(0)*b(1) - a(1)*b(0);
00267 
00268   return c;
00269 }

Here is the call graph for this function:

void claraty::ctrl_break ( int   ) 

Definition at line 105 of file share.cc.

00106 {
00107   cerr << "user break: signal handler SIGINT raised " 
00108             << i << endl;
00109   exit(1);
00110 }

claraty::DECLARE_BUILDER_INIT ( Camera_Model  ,
Tsai_Camera_Model  ,
factory  ,
Tsai_Camera_Model::build   
)

claraty::DECLARE_FACTORY_INIT ( Image_IO_Factory  ,
factory   
)

claraty::DECLARE_FACTORY_INIT ( Camera_Model  ,
factory   
)

claraty::DEF_STRING_FUNCTOR ( string_remove_suffix   ) 

claraty::DEF_STRING_FUNCTOR ( string_strip_end   ) 

claraty::DEF_STRING_FUNCTOR ( string_strip_front   ) 

claraty::DEF_STRING_FUNCTOR ( string_strip   ) 

claraty::DEFINE_BUILDER_INIT ( Tsai_Camera_Model   ) 

claraty::DEFINE_FACTORY_INIT ( Image_IO_Factory   ) 

claraty::DEFINE_FACTORY_INIT ( Camera_Model   ) 

template<class T>
T claraty::det ( const Matrix< T > &  m  ) 

Definition at line 55 of file matrix_determinant.h.

References claraty::Matrix_LU< T >::det(), claraty::N_2D_Array< T >::is_square(), and to_float().

Referenced by inverse().

00056 {
00057   double d;
00058   if (!m.is_square()) {
00059     std::cerr << "matrix error: cannot compute determinant of a non-square martrix"
00060          << std::endl;
00061     return 0.0;
00062   }
00063   else {
00064     Matrix<M_FLOAT> fm =  to_float(m);
00065 
00066     Matrix_LU<M_FLOAT> a_lu(fm);
00067     d = a_lu.det();
00068   } // else
00069   return (T) d;
00070 }

Here is the call graph for this function:

void claraty::division_by_zero ( int  i  ) 

Exceptional handler for signal.

Parameters:
[in] i 

Definition at line 84 of file share.cc.

00085 {
00086   cerr << "math error: division by zero; signal SIGFPE raised " 
00087             << i << endl;
00088   exit(1);
00089 }

template<class M>
M claraty::elements ( const M &  lhs,
char  op,
const M &  rhs 
)

Definition at line 408 of file matrix.h.

00409 {
00410   typedef typename M::value_type T;
00411 
00412   if (lhs.nrows() != rhs.nrows() || lhs.ncols() != rhs.ncols()) {
00413     std::cerr << "Matrix elements '"<< op << "' -- matrix sizes don't match"
00414          << std::endl;
00415     return lhs;
00416   }
00417 
00418   M result = lhs;
00419 
00420   switch (op) {
00421   case '+': 
00422     std::transform(result.begin(), result.end(), rhs.begin(), result.begin(), 
00423                    std::plus<T>());
00424     break;
00425   case '-': 
00426     std::transform(result.begin(), result.end(), rhs.begin(), result.begin(), 
00427                    std::minus<T>());
00428     break;
00429   case '*': 
00430     std::transform(result.begin(), result.end(), rhs.begin(), result.begin(), 
00431                    std::multiplies<T>());
00432     break;
00433   case '/': 
00434     std::transform(result.begin(), result.end(), rhs.begin(), result.begin(), 
00435                    std::divides<T>());
00436     break;
00437   default:
00438     std::cerr << "Matrix error: element operation '" << op << "' not defined"
00439          << std::endl;
00440   }
00441   return result;
00442 }

void claraty::fdm_error ( const char *  msg  ) 

FDM Error Message

Parameters:
[in] msg The error message to be displayed.
Returns:
void

Definition at line 45 of file fdm.cc.

Referenced by claraty::FDM_Stream::_ref_node(), and claraty::FDM_Stream::_unwind_to_node().

00046 {
00047   cerr << "Error in FDM: " << msg << "\n";
00048   assert(0);
00049 }

void claraty::header1 ( const char *  s  )  [inline]

Definition at line 109 of file display.h.

References thin_line().

00110 {
00111   std::cout << s << "\n";
00112   thin_line();
00113 }

Here is the call graph for this function:

unsigned int claraty::hex_to_int ( char *   ) 

Definition at line 142 of file share.cc.

References sum().

00143 {
00144   // This function converts a string that has a hex number embedded in it
00145   // to an int
00146   
00147   char *ptr_begin, *ptr_end;
00148   unsigned short  i, hex_len, k, temp=0;
00149   unsigned int    sum=0, factor=1;
00150   
00151   // strlwr(hex_string);
00152   ptr_begin= strstr(hex_string,"0x");
00153   ptr_end  = strstr(ptr_begin," ");
00154   if (!ptr_end) ptr_end = strchr(ptr_begin,'\n');
00155   if (!ptr_end) ptr_end = strchr(ptr_begin,'\0');
00156   hex_len  = ptr_end-ptr_begin;
00157   if (!ptr_begin)
00158     cerr << "Conversion error: hex number not found" << endl;
00159   else {       
00160     i=ptr_begin-hex_string;
00161     for (k=i+hex_len-1;k>i+1;k--)
00162       {
00163         switch(hex_string[k]) {
00164         case 'a':temp=10;break;
00165         case 'b':temp=11;break;
00166         case 'c':temp=12;break;
00167         case 'd':temp=13;break;
00168         case 'e':temp=14;break;
00169         case 'f':temp=15;break;
00170         default:
00171           if (hex_string[k]<'0' || hex_string[k]>'9')
00172             cerr << "Error: unidentifiable hex character!" << endl;
00173           else {
00174             char temp1[]={hex_string[k],'\0'};
00175             temp=atoi(temp1);}
00176         } // switch
00177         sum+=temp*factor;
00178         factor*=16;
00179       } // for k loop
00180   }  // if valid ptr
00181   return sum;
00182 }

Here is the call graph for this function:

void claraty::illegal_operation ( int  i  ) 

Illegal

Parameters:
[in] i 

Definition at line 98 of file share.cc.

00099 {
00100   cerr << "Illegal operation: signal SIGILL raised " << i << endl;
00101   exit(1);
00102 }

void claraty::illegal_storage_access ( int   ) 

Definition at line 113 of file share.cc.

00114 {
00115   cerr << "illegal storage access: signal handler SIGEGV raised "
00116             << i << endl;
00117   exit(1);
00118 }

template<class T>
RMatrix<T> claraty::inverse ( RMatrix< T >  r  ) 

Definition at line 196 of file rotation_matrix.h.

References claraty::RMatrix< T >::transpose().

00196 {return r.transpose();}

Here is the call graph for this function:

template<class T1, class Rotation_Type1>
Trans<T1, Rotation_Type1> claraty::inverse ( const Trans< T1, Rotation_Type1 > &  q  )  [inline]

friend inverse function

Parameters:
[in] q Transform that is to be inverted.
Returns:
Transfrom that has been inverted.

Definition at line 177 of file trans.h.

References claraty::Base_Trans< T, Rotation_Type >::_p, and claraty::Base_Trans< T, Rotation_Type >::_r.

00178 {
00179   Trans<T1,Rotation_Type1> result(q);
00180   result._r = result._r.reverse();     
00181   result._p = result._r * q._p;
00182   
00183   // Negate the position, done this way for efficiency
00184   //
00185   result._p(0) = -result._p(0);
00186   result._p(1) = -result._p(1);
00187   result._p(2) = -result._p(2);
00188   return result;
00189 }

template<class T>
QTrans<T> claraty::inverse ( const QTrans< T > &  q  )  [inline]

friend inverse function

Parameters:
[in] q Trans to be inverted
Returns:
Trans that has been inverted

Definition at line 214 of file qtrans.h.

References inverse().

00215 {
00216   return inverse(static_cast< Trans<T, Quaternion<T> > > (q));
00217 }

Here is the call graph for this function:

template<class T>
HTrans<T> claraty::inverse ( const HTrans< T > &  q  )  [inline]

friend inverse function

Parameters:
[in] q Trans to be inverted
Returns:
Trans that has been inverted

Definition at line 205 of file htrans.h.

References inverse().

00206 {
00207   return inverse(static_cast< Trans<T,RMatrix<T> > > (q));
00208 }

Here is the call graph for this function:

template<class T>
Matrix_NxM<T, 3, 3> claraty::inverse ( const Matrix_NxM< T, 3, 3 > &  m  ) 

Definition at line 105 of file matrix_inverse.h.

References det(), and EPSILON.

00106 {
00107   Matrix_NxM<T, 3, 3> ret(m);
00108   T det =
00109       m(0,0) * (m(1,1) * m(2,2) - m(1,2) * m(2,1) )
00110     - m(0,1) * (m(1,0) * m(2,2) - m(1,2) * m(2,0) )
00111     + m(0,2) * (m(1,0) * m(2,1) - m(1,1) * m(2,1) );
00112 
00113   if (cl_abs(det) > EPSILON) {
00114     double s = 1.0 / det;
00115     ret(0,0) = (m(1,1) * m(2,2) - m(1,2) * m(2,1)) * s;
00116     ret(0,1) = (m(0,2) * m(2,1) - m(0,1) * m(2,2)) * s;
00117     ret(0,2) = (m(0,1) * m(1,2) - m(0,2) * m(1,1)) * s;
00118     ret(1,0) = (m(1,2) * m(2,0) - m(1,0) * m(2,2)) * s;
00119     ret(1,1) = (m(0,0) * m(2,2) - m(0,2) * m(2,0)) * s;
00120     ret(1,2) = (m(0,2) * m(1,0) - m(0,0) * m(1,2)) * s;
00121     ret(2,0) = (m(1,0) * m(2,1) - m(1,1) * m(2,0)) * s;
00122     ret(2,1) = (m(0,1) * m(2,0) - m(0,0) * m(2,1)) * s;
00123     ret(2,2) = (m(0,0) * m(1,1) - m(0,1) * m(1,0)) * s;
00124   }
00125   
00126   return ret;
00127 }

Here is the call graph for this function:

template<class T>
Matrix_NxM<T, 2, 2> claraty::inverse ( const Matrix_NxM< T, 2, 2 > &  m  ) 

Definition at line 86 of file matrix_inverse.h.

References det(), and EPSILON.

00087 {
00088   double det = m(0, 0) * m(1, 1) - m(0, 1) * m(1, 0);
00089   Matrix_NxM<T, 2, 2> inv(m);
00090 
00091   if (cl_abs(det) > EPSILON) {
00092     double s = 1.0 / det;
00093     inv(0, 0) = s * m(1, 1);
00094     inv(0, 1) = -s * m(0, 1);
00095     inv(1, 0) = -s * m(1, 0);
00096     inv(1, 1) = s * m(0, 0);  
00097   }
00098   
00099   return inv;    
00100 }

Here is the call graph for this function:

template<class T>
bool claraty::io_image ( FDM_Map &  map,
Image< T > &  rhs 
)

Definition at line 361 of file image.h.

References claraty::FDM_Map::field().

Referenced by claraty::Camera_Image< Pixel_Type >::io(), and io_object().

00362 {
00363   // First use io_matrix to do the normal matrix io, which we can pass
00364   // the same FDM_Map& to as we later use ourselves, then add the
00365   // interpolation field
00366   bool ok = io_matrix(map, (Matrix<T>&)(rhs));
00367 
00368   int interp;
00369   switch (rhs.get_interpolation_type()) {
00370   case Image<T>::BILINEAR:
00371     interp = 0;
00372     break;
00373   case Image<T>::NOINTERP:
00374     interp = 1;
00375     break;
00376   case Image<T>::CHECK_BOUNDS:
00377     interp = 2;
00378     break;
00379   default:  // could be uninitialized if we're reading into a new image
00380     interp = -1;
00381     break;
00382   }
00383 
00384   ok &= map.field("interpolation", interp);
00385 
00386   switch (interp) {
00387   case 0:
00388     rhs.set_interpolation_type(Image<T>::BILINEAR);
00389     break;
00390   case 1:
00391     rhs.set_interpolation_type(Image<T>::NOINTERP);
00392     break;
00393   case 2:
00394     rhs.set_interpolation_type(Image<T>::CHECK_BOUNDS);
00395     break;
00396   default:  // should never be undefined in serialized form
00397     ok = false;
00398     break;
00399   }
00400 
00401   T maxval = rhs.get_maximum_value();
00402   ok &= map.field("maximum_value", maxval);
00403   rhs.set_maximum_value(maxval);
00404 
00405   return ok;
00406 }

Here is the call graph for this function:

template<class T>
bool claraty::io_object ( FDM_Untyped_Node  node,
RMatrix< T > &  rhs 
)

Definition at line 764 of file rotation_matrix.h.

References claraty::FDM_Array::element(), claraty::FDM_Map::field(), claraty::FDM_Map::field_node(), and claraty::FDM_Map::is_read().

00765 {
00766   FDM_Map map(node);
00767 
00768   // Put Nrows and Ncols into the output if we are writing, or double
00769   // check that the rows and columns match what we expect if we are
00770   // reading
00771   int nr=3, nc=3;
00772   bool ok = true;
00773 
00774   ok &= map.field("nrows", nr);
00775   ok &= map.field("ncols", nc);
00776 
00777   FDM_Array a = map.field_node("elements");
00778 
00779   // If we're reading, make sure the dimensions match.  If not, read
00780   // the number of elements it said anyway, but throw them away
00781   if (map.is_read() && (nr!=3 || nc!=3)) {
00782     T ignore=0;
00783     for (int r = 0; r < nr; r++)
00784       for (int c = 0; c < nc; c++)
00785         a.element(ignore);
00786     ok = false;
00787   }
00788   else {
00789     // Either writing or reading and dimensions match
00790     for (int r = 0; r < nr; r++)
00791       for (int c = 0; c < nc; c++)
00792         ok &= a.element(rhs(r,c));
00793   }
00794   return ok;
00795 }

Here is the call graph for this function:

template<class T>
bool claraty::io_object ( FDM_Untyped_Node  node,
N_2D_Point< T > &  rhs 
)

Definition at line 792 of file 2d_point.h.

References claraty::FDM_Array::element().

00793 {
00794   FDM_Array a(node);
00795   bool ok = a.element(rhs(0));
00796   ok &= a.element(rhs(1));
00797   return ok;
00798 }

Here is the call graph for this function:

template<typename T>
bool claraty::io_object ( FDM_Untyped_Node  node,
Point< T > &  rhs 
)

Definition at line 838 of file point.h.

References claraty::FDM_Array::element().

00839 {
00840   FDM_Array a(node);
00841   bool ok = a.element(rhs(Point<T>::X));
00842   ok &= a.element(rhs(Point<T>::Y));
00843   ok &= a.element(rhs(Point<T>::Z));
00844   return ok;
00845 }

Here is the call graph for this function:

template<class T>
bool claraty::io_object ( FDM_Untyped_Node  node,
Unit_Vector< T > &  rhs 
)

Definition at line 166 of file unit_vector.h.

References claraty::FDM_Array::element(), claraty::Unit_Vector< T >::set(), claraty::Unit_Vector< T >::x(), claraty::Unit_Vector< T >::y(), and claraty::Unit_Vector< T >::z().

00167 {
00168   FDM_Array array(node);
00169 
00170   T x = rhs.x(), y = rhs.y(), z = rhs.z();
00171   bool ok = array.element(x);
00172   ok &= array.element(y);
00173   ok &= array.element(z);
00174   rhs.set(x, y, z);
00175   return ok;
00176 }

Here is the call graph for this function:

template<class T, int Nrows, int Ncols>
bool claraty::io_object ( FDM_Untyped_Node  node,
Matrix_NxM< T, Nrows, Ncols > &  rhs 
)

Definition at line 232 of file matrix_nxm.h.

References claraty::FDM_Array::element(), claraty::FDM_Map::field(), claraty::FDM_Map::field_node(), and claraty::FDM_Map::is_read().

00233 {
00234   FDM_Map map(node);
00235 
00236   // Put Nrows and Ncols into the output if we are writing, or double
00237   // check that the rows and columns match what we expect if we are
00238   // reading
00239   int nr=Nrows, nc=Ncols;
00240   bool ok = true;
00241 
00242   ok &= map.field("nrows", nr);
00243   ok &= map.field("ncols", nc);
00244 
00245   FDM_Array a = map.field_node("elements");
00246 
00247   // If we're reading, make sure the dimensions match.  If not, read
00248   // the number of elements it said anyway, but throw them away
00249   if (map.is_read() && (nr!=Nrows || nc!=Ncols)) {
00250     T ignore=0;
00251     for (int r = 0; r < nr; r++)
00252       for (int c = 0; c < nc; c++)
00253         a.element(ignore);
00254     ok = false;
00255   }
00256   else {
00257     // Either writing or reading and dimensions match
00258     for (int r = 0; r < nr; r++)
00259       for (int c = 0; c < nc; c++)
00260         ok &= a.element(rhs(r, c));
00261   }
00262   return ok;
00263 }

Here is the call graph for this function:

template<class T>
bool claraty::io_object ( FDM_Untyped_Node  node,
Vector< T > &  rhs 
)

Definition at line 390 of file vector.h.

References COL_VECTOR, claraty::FDM_Array::elements(), claraty::FDM_Map::field(), claraty::FDM_Map::field_node(), claraty::Vector< T >::get_orientation(), claraty::Vector< T >::get_size(), claraty::FDM_Map::is_read(), claraty::FDM_Map::peekfield(), claraty::FDM_Array::resizable_length(), claraty::Vector< T >::resize(), ROW_VECTOR, and claraty::Vector< T >::set_orientation().

00391 {
00392   FDM_Map map(node);
00393   const int latest_version = 1;
00394   unsigned int this_version = latest_version;
00395   bool oldver = false;
00396   bool ok;
00397   if (map.is_read() && !map.peekfield("version", this_version)) {
00398     unsigned int dummy_nrows;
00399     oldver = map.peekfield("nrows", dummy_nrows);
00400     if (oldver) {
00401       int nrows, ncols;
00402       ok = map.field("nrows", nrows);
00403       ok &= map.field("ncols", ncols);
00404       assert(nrows == 1);
00405       rhs.resize(ncols);
00406       rhs.set_orientation(ROW_VECTOR);
00407       FDM_Array a = map.field_node("elements");
00408       ok &= a.elements(rhs.begin(), rhs.end());
00409       return ok;
00410     }
00411   } else
00412     ok = map.field("version", this_version);
00413   
00414   FDM_Array arr = map.field_node("elements");
00415   int size = rhs.get_size();
00416   arr.resizable_length(size);
00417   if (map.is_read())     // don't resize unless we're reading
00418     rhs.resize(1, size);
00419   bool ret = arr.elements(rhs.begin(), rhs.end());
00420   Vector_Orientation o = rhs.get_orientation();
00421   char ch_orientation = o == ROW_VECTOR ? 'r' : 'c';
00422   ret &= map.field("orientation", ch_orientation);
00423   o = ch_orientation == 'r' ? ROW_VECTOR : COL_VECTOR;
00424   rhs.set_orientation(o);
00425   return ret;
00426 }

Here is the call graph for this function:

template<class T>
bool claraty::io_object ( FDM_Untyped_Node  node,
Image< T > &  rhs 
)

Definition at line 409 of file image.h.

References io_image().

00410 {
00411   FDM_Map map(node);
00412   return io_image(map, rhs);
00413 }

Here is the call graph for this function:

template<class C>
bool claraty::io_object ( FDM_Untyped_Node  node,
C &  c 
)

Definition at line 318 of file fdm.h.

00319 {
00320   return(c.io(node));
00321 }

bool claraty::io_object ( FDM_Map  map,
std::auto_ptr< A_Camera_Model > &  model 
)

bool claraty::io_object ( FDM_Map  map,
std::auto_ptr< Camera_Model > &  model 
)

bool claraty::io_object ( FDM_Map  map,
auto_ptr< Camera_Model > &  model 
)

Definition at line 220 of file camera_model.cc.

References claraty::Camera_Model::build_from_typename(), claraty::FDM_Map::field(), claraty::FDM_Map::is_read(), claraty::FDM_Map::is_write(), and claraty::FDM_Map::peekfield().

00221 {
00222   bool ok = true;
00223 
00224   if (map.is_read()) {
00225     // build the underlying pointer via the factory
00226     std::string type_name;
00227     ok &= map.peekfield("type", type_name);
00228     if (type_name == "none") {
00229       model.reset(NULL);
00230       return ok;
00231     }
00232     model.reset(Camera_Model::build_from_typename(type_name));
00233     if(model.get()==NULL) {
00234       cerr << "Unable to construct camera model of type " 
00235            << type_name << endl;
00236       return(false);
00237     }
00238   }
00239   if (map.is_write() && model.get() == NULL) {
00240     std::string type_name= "none";
00241     ok &= map.field("type", type_name);
00242     return ok;
00243   }
00244   ok &= model->io(map);
00245   return ok;
00246 }

Here is the call graph for this function:

template<typename T>
bool claraty::io_object ( FDM_Untyped_Node  node,
N_2D_Array< T > &  rhs 
)

Definition at line 833 of file 2d_array.h.

References claraty::N_2D_Array< T >::io().

Referenced by claraty::FDM_Stream::_io_object().

00834 {
00835   FDM_Map map(node);
00836 
00837   return(rhs.io(map, rhs));
00838 }

Here is the call graph for this function:

template<class T>
bool claraty::is_floating_point_type (  )  [inline]

Definition at line 137 of file math_limits.h.

00137 {return false;}

template<>
bool claraty::is_floating_point_type< double > (  )  [inline]

template<>
bool claraty::is_floating_point_type< float > (  )  [inline]

template<>
bool claraty::is_floating_point_type< long double > (  )  [inline]

template<class T>
bool claraty::is_integral_type (  )  [inline]

Definition at line 126 of file math_limits.h.

00126 {return false;}

template<>
bool claraty::is_integral_type< char > (  )  [inline]

template<>
bool claraty::is_integral_type< int > (  )  [inline]

template<>
bool claraty::is_integral_type< long > (  )  [inline]

template<>
bool claraty::is_integral_type< long long > (  )  [inline]

template<>
bool claraty::is_integral_type< short > (  )  [inline]

template<>
bool claraty::is_integral_type< unsigned char > (  )  [inline]

template<>
bool claraty::is_integral_type< unsigned int > (  )  [inline]

template<>
bool claraty::is_integral_type< unsigned long > (  )  [inline]

template<>
bool claraty::is_integral_type< unsigned long long > (  )  [inline]

template<>
bool claraty::is_integral_type< unsigned short > (  )  [inline]

template<class T>
bool claraty::is_numeric_type (  )  [inline]

Definition at line 140 of file math_limits.h.

00140                               { 
00141   return is_integral_type<T>() ||
00142     is_floating_point_type<T>(); 
00143 }

void claraty::left_justify ( const char *  s  )  [inline]

Definition at line 119 of file display.h.

00120 {
00121   std::cout << s << "\n";
00122 }

template<class T1, class T2>
void claraty::match_orientations ( const Vector< T1 > &  lhs,
const Matrix< T2 > &  rhs 
)

Vector operations, which are dealt with explicitly because Vectors keep their column vs. row orientation internally.

Definition at line 142 of file matrix_operator.h.

References COL_VECTOR, claraty::Vector< T >::get_orientation(), claraty::N_2D_Array< T >::get_size(), claraty::N_2D_Array< T >::ncols(), claraty::Vector< T >::ncols(), claraty::Vector< T >::nrows(), claraty::N_2D_Array< T >::nrows(), and ROW_VECTOR.

Referenced by operator+(), and operator-().

00143 {
00144   assert((lhs.get_orientation() == ROW_VECTOR && rhs.nrows() == 1 &&
00145           lhs.ncols() == rhs.get_size()) ||
00146          (lhs.get_orientation() == COL_VECTOR && rhs.ncols() == 1 &&
00147           lhs.nrows() == rhs.get_size()));
00148 }

Here is the call graph for this function:

template<class T>
void claraty::matrix_cholesky_backsubstitute ( const Matrix< T > &  L,
const Matrix< T > &  B,
Matrix< T > &  X 
)

This step solves two linear systems where the coefficient matrix is triangular. The matrix passed in should be a lower triangular matrix such that LL' = A and A is the original symmetric positive definite coefficient matrix for the original linear system to be solved. Again, this is home grown code, NOT numerical recipes.

Parameters:
[in] L Input matrix.
[in] B Input matrix.
[out] X Resultant matrix.

Definition at line 141 of file matrix_cholesky.h.

References claraty::N_2D_Array< T >::get_num_of_cols(), claraty::N_2D_Array< T >::get_num_of_rows(), and sum().

Referenced by matrix_solve_symposdef().

00144 {
00145   int i, j, k;      // loop counters
00146   int nrows, ncols; // matrix size parameters
00147   double sum;       // accumulator
00148 
00149   // Get size of L, check that it's square
00150   nrows = L.get_num_of_rows();
00151   if (L.get_num_of_cols() != nrows){
00152     // not square
00153     std::cerr << "matrix_cholesky_backsubstitute: L not square" << std::endl;
00154   }
00155 
00156   // Check that L is lower triangular:
00157   for (i=0; i<nrows; i++){
00158     for (j=i+1; j<nrows; j++){
00159       if (fabs(L(i,j))>1e-15)
00160         std::cerr << "matrix_cholesky_backsubstitute: L not lower triangular" << std::endl;
00161     }
00162   }
00163 
00164   // Get number of columns of B, and make sure the number of rows of B
00165   // is the same as the number of rows (cols) of L.
00166   ncols = B.get_num_of_cols();
00167   if (B.get_num_of_rows()!=nrows){
00168     // size mismatch between L and B
00169     std::cerr << "matrix_cholesky_backsubstitute: size mismatch L and B" << std::endl;
00170   }
00171 
00172   // Solution vector should be same size as B.  This "=" will make
00173   // sure there is memory if there wasn't already, and makes sure they
00174   // are the same size.  There may be a faster way that doesn't clone
00175   // the data.
00176   X = B;
00177 
00178   // Backsubstitute to get the intermediate result Y (stored in X).
00179   // This operation can be done in place, and returns an intermediate
00180   // result to be used below.  Do one column at a time:
00181   for (k=0; k<ncols; k++){
00182     for (i=0; i<nrows; i++){
00183       sum = 0.0;
00184       for (j=0; j<i; j++){
00185         sum += L(i,j)*X(j,k);
00186       }
00187       X(i,k) = (B(i,k) - sum) / L(i,i);
00188     }
00189   }
00190 
00191   // Backsubstitute to get the final result X.  These can be done
00192   // in-place as well.  The RHS is now the result from above, and the
00193   // destination for the solution.  Do one column at a time, start at
00194   // the bottom and go up:
00195   for (k=0; k<ncols; k++){
00196     for (i=nrows-1; i>=0; i--){
00197       sum = 0.0;
00198       for (j=nrows-1; j>i; j--){
00199         sum += L(j,i)*X(j,k);
00200       }
00201       X(i,k) = (X(i,k) - sum) / L(i,i);
00202     }
00203   }
00204 }

Here is the call graph for this function:

template<class T>
void claraty::matrix_solve_symposdef ( const Matrix< T > &  A,
const Matrix< T > &  B,
Matrix< T > &  X 
)

Computes the Cholesky factor of a symmetric positive definite matrix. This function solves a linear system of equations in the form A*X=B (1) where A is symmetric and positive definite. The solver first computes the cholesky factor of A, LL' = A (2) turning the original problem into LL'X = B (3) Then the two systems are solved in turn to yield X: LY=B (4) L'X=Y (5) The solver makes one call to a fairly general cholesky factorization routine to compute (2) and then a call to a special purpose cholesky backsubstitution routine that solves both equations (4) and (5), returning X.

Definition at line 207 of file matrix_cholesky.h.

References matrix_cholesky(), and matrix_cholesky_backsubstitute().

00219                                                      :
00220  * LY=B     (4)
00221  * L'X=Y    (5)
00222  * The solver makes one call to a fairly general cholesky
00223  * factorization routine to compute (2) and then a call to a special
00224  * purpose cholesky backsubstitution routine that solves both
00225  * equations (4) and (5), returning X.
00226  */
00227 {
00228   // Cholesky factor
00229   Matrix<T> L;
00230 
00231   // Compute cholesky factor L
00232   matrix_cholesky(A,L);
00233 
00234   // Solve two linear systems using backsubstitution
00235   matrix_cholesky_backsubstitute( L, B, X );
00236   
00237   // Destroy L
00238   // <implicit>
00239 
00240 }

Here is the call graph for this function:

void claraty::memory_failure ( void   ) 

template<class T>
double claraty::norm ( const Vector< T > &  a  ) 

Returns the norm of vector a: |a|.

Definition at line 275 of file matrix_operator.h.

References claraty::Vector< T >::magnitude().

Referenced by pug::strwnorm().

00275                                 {
00276   return a.magnitude();
00277 }

Here is the call graph for this function:

template<typename T>
Point< T > claraty::normalize ( const Point< T > &  p  )  [inline]

Definition at line 722 of file point.h.

References claraty::Point< T >::length().

00723 {
00724   double len = p.length();
00725   return (len > Point<T>::_epsilon() ? p/len : Point<T>());
00726 }

Here is the call graph for this function:

template<class T>
static std::string claraty::object_to_string ( const T &  obj  )  [static]

Definition at line 257 of file fdm_parse_tree.h.

Referenced by Image_IO_Pnm_State::save(), and save_camera_image().

00257                                                 {
00258   return FDM_Parse_Tree::object_to_string(obj);
00259 }

Bits claraty::operator & ( const Bits &  lhs,
const Bits &  rhs 
) [inline]

Definition at line 833 of file bits.h.

00834 {
00835   Bits tmp = lhs;
00836 
00837   tmp &= rhs;
00838   return tmp;
00839 }

Ray claraty::operator * ( const Matrix< float > &  m,
const Ray &  r 
)

Definition at line 38 of file tsai_camera_model.cc.

References claraty::N_2D_Array< T >::get_num_of_cols(), and claraty::N_2D_Array< T >::get_num_of_rows().

00039 {
00040   Ray res;
00041 
00042   assert(m.get_num_of_rows() == 3);
00043   assert(m.get_num_of_cols() == 3);
00044 
00045   res(0) = m(0,0) * r(0) + m(0,1) * r(1) + m(0,2) * r(2);
00046   res(1) = m(1,0) * r(0) + m(1,1) * r(1) + m(1,2) * r(2);
00047   res(2) = m(2,0) * r(0) + m(2,1) * r(1) + m(2,2) * r(2);
00048 
00049   return res;
00050 }

Here is the call graph for this function:

template<class T>
const Matrix<T> claraty::operator * ( const Matrix< T > &  lhs,
const RMatrix< T > &  rhs 
)

Definition at line 700 of file rotation_matrix.h.

References claraty::Base_RMatrix< T >::_data, claraty::N_2D_Array< T >::ncols(), and claraty::N_2D_Array< T >::nrows().

00701 {
00702   Matrix<T> result(3,3);
00703   
00704   if ((lhs.ncols() != 3)||(lhs.nrows() != 3))
00705     return result;
00706   
00707   
00708   result(0,0) =   lhs(0,0) * rhs._data[0][0]
00709     + lhs(0,1) * rhs._data[1][0]
00710     + lhs(0,2) * rhs._data[2][0];
00711   
00712   result(0,1) =   lhs(0,0) * rhs._data[0][1]
00713     + lhs(0,1) * rhs._data[1][1]
00714     + lhs(0,2) * rhs._data[2][1];
00715   
00716   result(0,2) =   lhs(0,0) * rhs._data[0][2]
00717     + lhs(0,1) * rhs._data[1][2]
00718     + lhs(0,2) * rhs._data[2][2];
00719   
00720   
00721   result(1,0) =   lhs(1,0) * rhs._data[0][0]
00722     + lhs(1,1) * rhs._data[1][0]
00723     + lhs(1,2) * rhs._data[2][0];
00724   
00725   result(1,1) =   lhs(1,0) * rhs._data[0][1]
00726     + lhs(1,1) * rhs._data[1][1]
00727     + lhs(1,2) * rhs._data[2][1];
00728   
00729   result(1,2) =   lhs(1,0) * rhs._data[0][2]
00730     + lhs(1,1) * rhs._data[1][2]
00731     + lhs(1,2) * rhs._data[2][2];
00732   
00733   
00734   result(2,0) =   lhs(2,0) * rhs._data[0][0]
00735     + lhs(2,1) * rhs._data[1][0]
00736     + lhs(2,2) * rhs._data[2][0];
00737   
00738   result(2,1) =   lhs(2,0) * rhs._data[0][1]
00739     + lhs(2,1) * rhs._data[1][1]
00740     + lhs(2,2) * rhs._data[2][1];
00741   
00742   result(2,2) =   lhs(2,0) * rhs._data[0][2]
00743     + lhs(2,1) * rhs._data[1][2]
00744     + lhs(2,2) * rhs._data[2][2];
00745   return result;
00746 }

Here is the call graph for this function:

template<class T>
const Matrix<T> claraty::operator * ( const RMatrix< T > &  lhs,
const Matrix< T > &  rhs 
)

Definition at line 649 of file rotation_matrix.h.

References claraty::Base_RMatrix< T >::_data, claraty::N_2D_Array< T >::ncols(), and claraty::N_2D_Array< T >::nrows().

00650 {
00651   Matrix<T> result(3,3);
00652   
00653   if ((rhs.ncols() != 3)||(rhs.nrows() != 3))
00654     return result;
00655   
00656   
00657   result(0,0) =   lhs._data[0][0] * rhs(0,0)
00658     + lhs._data[0][1] * rhs(1,0)
00659     + lhs._data[0][2] * rhs(2,0);
00660   
00661   result(0,1) =   lhs._data[0][0] * rhs(0,1)
00662     + lhs._data[0][1] * rhs(1,1)
00663     + lhs._data[0][2] * rhs(2,1);
00664   
00665   result(0,2) =   lhs._data[0][0] * rhs(0,2)
00666     + lhs._data[0][1] * rhs(1,2)
00667     + lhs._data[0][2] * rhs(2,2);
00668   
00669   
00670   result(1,0) =   lhs._data[1][0] * rhs(0,0)
00671     + lhs._data[1][1] * rhs(1,0)
00672     + lhs._data[1][2] * rhs(2,0);
00673   
00674   result(1,1) =   lhs._data[1][0] * rhs(0,1)
00675     + lhs._data[1][1] * rhs(1,1)
00676     + lhs._data[1][2] * rhs(2,1);
00677   
00678   result(1,2) =   lhs._data[1][0] * rhs(0,2)
00679     + lhs._data[1][1] * rhs(1,2)
00680     + lhs._data[1][2] * rhs(2,2);
00681   
00682   
00683   result(2,0) =   lhs._data[2][0] * rhs(0,0)
00684     + lhs._data[2][1] * rhs(1,0)
00685     + lhs._data[2][2] * rhs(2,0);
00686   
00687   result(2,1) =   lhs._data[2][0] * rhs(0,1)
00688     + lhs._data[2][1] * rhs(1,1)
00689     + lhs._data[2][2] * rhs(2,1);
00690   
00691   result(2,2) =   lhs._data[2][0] * rhs(0,2)
00692     + lhs._data[2][1] * rhs(1,2)
00693     + lhs._data[2][2] * rhs(2,2);
00694   return result;
00695 }

Here is the call graph for this function:

template<class T>
const Point< T > claraty::operator * ( const RMatrix< T > &  lhs,
const Point< T > &  rhs 
)

Definition at line 752 of file rotation_matrix.h.

References claraty::Base_RMatrix< T >::_data.

00753 {
00754   Point<T> p;
00755   
00756   p(0) = lhs._data[0][0]*rhs(0) + lhs._data[0][1]*rhs(1) + lhs._data[0][2]*rhs(2);
00757   p(1) = lhs._data[1][0]*rhs(0) + lhs._data[1][1]*rhs(1) + lhs._data[1][2]*rhs(2);
00758   p(2) = lhs._data[2][0]*rhs(0) + lhs._data[2][1]*rhs(1) + lhs._data[2][2]*rhs(2);
00759   return p;
00760 }

template<class T>
const RMatrix< T > claraty::operator * ( const RMatrix< T > &  lhs,
const RMatrix< T > &  rhs 
)

Definition at line 603 of file rotation_matrix.h.

References claraty::Base_RMatrix< T >::_data.

00604 {
00605   RMatrix<T> result;
00606   
00607   result._data[0][0] =    lhs._data[0][0] * rhs._data[0][0]
00608                         + lhs._data[0][1] * rhs._data[1][0]
00609                         + lhs._data[0][2] * rhs._data[2][0];
00610   
00611   result._data[0][1] =    lhs._data[0][0] * rhs._data[0][1]
00612                         + lhs._data[0][1] * rhs._data[1][1]
00613                         + lhs._data[0][2] * rhs._data[2][1];
00614   
00615   result._data[0][2] =    lhs._data[0][0] * rhs._data[0][2]
00616                         + lhs._data[0][1] * rhs._data[1][2]
00617                         + lhs._data[0][2] * rhs._data[2][2];
00618   
00619   
00620   result._data[1][0] =    lhs._data[1][0] * rhs._data[0][0]
00621                         + lhs._data[1][1] * rhs._data[1][0]
00622                         + lhs._data[1][2] * rhs._data[2][0];
00623   
00624   result._data[1][1] =    lhs._data[1][0] * rhs._data[0][1]
00625                         + lhs._data[1][1] * rhs._data[1][1]
00626                         + lhs._data[1][2] * rhs._data[2][1];
00627   
00628   result._data[1][2] =    lhs._data[1][0] * rhs._data[0][2]
00629                         + lhs._data[1][1] * rhs._data[1][2]
00630                         + lhs._data[1][2] * rhs._data[2][2];
00631   
00632   result._data[2][0] =    lhs._data[2][0] * rhs._data[0][0]
00633                         + lhs._data[2][1] * rhs._data[1][0]
00634                         + lhs._data[2][2] * rhs._data[2][0];
00635   
00636   result._data[2][1] =    lhs._data[2][0] * rhs._data[0][1]
00637                         + lhs._data[2][1] * rhs._data[1][1]
00638                         + lhs._data[2][2] * rhs._data[2][1];
00639   
00640   result._data[2][2] =    lhs._data[2][0] * rhs._data[0][2]
00641                         + lhs._data[2][1] * rhs._data[1][2]
00642                         + lhs._data[2][2] * rhs._data[2][2];
00643   return result;
00644 }

template<class T>
N_2D_Point<T> claraty::operator * ( const N_2D_Point< T > &  v,
double  s 
) [inline]

Definition at line 663 of file 2d_point.h.

00664 {
00665     return N_2D_Point<T>(v(0)*s, v(1)*s);
00666 }

template<class T>
N_2D_Point< T > claraty::operator * ( double  ,
const N_2D_Point< T > &   
) [inline]

Definition at line 676 of file 2d_point.h.

00677 {
00678   return N_2D_Point<T>( (T)(v(0)*s), 
00679                               (T)(v(1)*s) );
00680 }

template<typename T, typename T2>
Point<T> claraty::operator * ( T2  ,
const Point< T > &   
)

template<typename T, typename T2>
Point<T> claraty::operator * ( const Point< T > &  ,
T2   
)

template<class T1, class T2>
Vector<T1> claraty::operator * ( const Vector< T1 > &  lhs,
const Matrix< T2 > &  rhs 
)

Definition at line 228 of file matrix_operator.h.

References cl_inner_product(), claraty::N_2D_Array< T >::column_iterator(), claraty::Vector< T >::get_orientation(), claraty::Vector< T >::get_size(), claraty::N_2D_Array< T >::get_size(), claraty::N_2D_Array< T >::ncols(), claraty::N_2D_Array< T >::nrows(), and ROW_VECTOR.

00229 {
00230   if (lhs.get_orientation() != ROW_VECTOR) {
00231     if (rhs.get_size() == 1) // 1x1 matrix is same as scalar in this case
00232       return lhs * rhs(0, 0);
00233     std::cerr << "Vector * Matrix: for outer product, you must use column Vector "
00234       "times row Vector" << std::endl;
00235     assert(lhs.get_orientation() == ROW_VECTOR);
00236   }
00237   int sz = lhs.get_size();
00238   assert(sz == rhs.nrows());
00239   Vector<T1> ret(rhs.ncols(), ROW_VECTOR);
00240   //  const T1* lhs_data = lhs.begin();
00241   //  const T1* lhs_end = lhs.end();
00242   typename Vector<T1>::const_iterator lhs_data = lhs.begin();
00243   typename Vector<T1>::const_iterator lhs_end = lhs.end();
00244   for (int c = 0; c < rhs.ncols(); c++)
00245     ret[c] =
00246       cl_inner_product(lhs_data, lhs_end, rhs.column_iterator(c), T1(0));
00247   return ret;
00248 }

Here is the call graph for this function:

template<class T1, class T2>
Vector<T1> claraty::operator * ( const Matrix< T1 > &  lhs,
const Vector< T2 > &  rhs 
)

Definition at line 207 of file matrix_operator.h.

References cl_inner_product(), COL_VECTOR, claraty::Vector< T >::get_orientation(), claraty::N_2D_Array< T >::get_row_pointer(), claraty::Vector< T >::get_size(), claraty::N_2D_Array< T >::ncols(), and claraty::N_2D_Array< T >::nrows().

00208 {
00209   if (rhs.get_orientation() != COL_VECTOR) {
00210     std::cerr << "Matrix * Vector: for outer product, you must use column Vector "
00211       "times row Vector" << std::endl;
00212     assert(rhs.get_orientation() == COL_VECTOR);
00213   }
00214   int sz = lhs.ncols();
00215   assert(sz == rhs.get_size());
00216   Vector<T1> ret(lhs.nrows(), COL_VECTOR);
00217   //  const T2 *rhs_data = rhs.begin();
00218   typename Vector<T2>::const_iterator rhs_data = rhs.begin();
00219   for (int r = 0; r < lhs.nrows(); r++)
00220     ret[r] =
00221       cl_inner_product(lhs.get_row_pointer(r), lhs.get_row_pointer(r) + sz,
00222                        rhs_data, T1(0));
00223   return ret;
00224 }

Here is the call graph for this function:

template<class T1, class T2>
Matrix<T1> claraty::operator * ( const Vector< T1 > &  lhs,
const Vector< T2 > &  rhs 
)

Definition at line 188 of file matrix_operator.h.

References claraty::Vector< T >::dot(), claraty::Vector< T >::get_orientation(), claraty::Vector< T >::get_size(), and ROW_VECTOR.

00189 {
00190   assert(lhs.get_size() == rhs.get_size() &&
00191          lhs.get_orientation() != rhs.get_orientation());
00192   if (lhs.get_orientation() == ROW_VECTOR) {
00193     Matrix<T1> ret(1, 1);
00194     ret(0, 0) = lhs.dot(rhs);
00195     return ret;
00196   }
00197   int sz = lhs.get_size();
00198   Matrix<T1> ret(sz, sz);
00199   for (int r = 0; r < sz; r++)
00200     for (int c = 0; c < sz; c++)
00201       ret(r, c) = lhs[r] * rhs[c];
00202   return ret;
00203 }

Here is the call graph for this function:

template<class T, int NR1, int NC1, int NC2>
const Matrix_NxM<T, NR1, NC2> claraty::operator * ( const Matrix_NxM< T, NR1, NC1 > &  lhs,
const Matrix_NxM< T, NC1, NC2 > &  rhs 
)

Definition at line 214 of file matrix_nxm.h.

References sum().

00216 {
00217   Matrix_NxM<T, NR1, NC2> result(T(0));
00218   for (int i = 0; i < NR1; ++i) {
00219     for (int j = 0;j < NC2; ++j) {
00220       T& sum = result(i, j);
00221       for (int k = 0; k < NC1; ++k)
00222         sum += lhs(i, k) * rhs(k, j);
00223     }
00224   }
00225   return result;
00226 }

Here is the call graph for this function:

template<class T>
const Matrix<T> claraty::operator * ( const Matrix< T > &  lhs,
const Matrix< T > &  rhs 
)

Definition at line 355 of file matrix.h.

References claraty::N_2D_Array< T >::column_iterator(), claraty::N_2D_Array< T >::get_num_of_cols(), claraty::N_2D_Array< T >::get_num_of_rows(), claraty::N_2D_Array< T >::get_row_pointer(), claraty::N_2D_Array< T >::ncols(), and claraty::N_2D_Array< T >::nrows().

00356 {
00357   if (lhs.ncols() == rhs.nrows()) {
00358     Matrix<T> result(lhs.get_num_of_rows(), rhs.get_num_of_cols());
00359     N_2D_Array_Iterator<T> it_res = result.begin();
00360 
00361     for (int i = 0; i < lhs.get_num_of_rows(); ++i) {
00362       for (int j = 0; j < rhs.get_num_of_cols(); ++j, ++it_res) {
00363         const T *p_lhs = lhs.get_row_pointer(i);
00364         N_2D_Array_const_Iterator<T> it_rhs = rhs.column_iterator(j);
00365         *it_res = 0;
00366         for (int k = 0; k < rhs.get_num_of_rows(); ++k, ++p_lhs, ++it_rhs)
00367           *it_res += (*p_lhs) * (*it_rhs);
00368       }
00369     }
00370     return result;
00371   } else {
00372     std::cerr << "Attempted to multiply matrices of incompatible sizes" << std::endl;
00373     return lhs;
00374   }
00375 }

Here is the call graph for this function:

template<class T>
N_2D_Point< T > claraty::operator+ ( const N_2D_Point< T > &  ,
const N_2D_Point< T > &   
) [inline]

Definition at line 574 of file 2d_point.h.

00575 {
00576   return N_2D_Point<T>( v0(0)+v1(0), v0(1)+v1(1) );
00577 }

template<typename T>
Point<T> claraty::operator+ ( const Point< T > &  ,
const Point< T > &  v2 
)

template<class T1, class T2>
Vector<T1> claraty::operator+ ( const Matrix< T1 > &  lhs,
const Vector< T2 > &  rhs 
)

Definition at line 171 of file matrix_operator.h.

00172 {
00173   return rhs + lhs;
00174 }

template<class T1, class T2>
Vector<T1> claraty::operator+ ( const Vector< T1 > &  lhs,
const Matrix< T2 > &  rhs 
)

Definition at line 151 of file matrix_operator.h.

References claraty::N_2D_Array< T >::begin(), claraty::Vector< T >::get_orientation(), claraty::Vector< T >::get_size(), and match_orientations().

00152 {
00153   match_orientations(lhs, rhs);
00154   Vector<T1> ret(lhs.get_size(), lhs.get_orientation());
00155   std::transform(lhs.begin(), lhs.end(), rhs.begin(), ret.begin(),
00156                  std::plus<T1>());
00157   return ret;
00158 }

Here is the call graph for this function:

template<class T1, class T2>
Vector<T1> claraty::operator+ ( const Vector< T1 > &  lhs,
const Vector< T2 > &  rhs 
)

Definition at line 343 of file vector.h.

References vector_transform().

00344 {
00345   return vector_transform(lhs, rhs, std::plus<T1>());
00346 }

Here is the call graph for this function:

template<class T>
N_2D_Point< T > claraty::operator- ( const N_2D_Point< T > &   )  [inline]

Definition at line 599 of file 2d_point.h.

00600 { 
00601   return N_2D_Point<T>( -v(0), -v(1)); 
00602 }

template<class T>
N_2D_Point< T > claraty::operator- ( const N_2D_Point< T > &  ,
const N_2D_Point< T > &   
) [inline]

Definition at line 587 of file 2d_point.h.

00588 {
00589   return N_2D_Point<T>(v0(0)-v1(0), v0(1)-v1(1));
00590 }

template<typename T>
Point< T > claraty::operator- ( const Point< T > &   )  [inline]

Definition at line 894 of file point.h.

00895 {
00896   return Point<T>( -p(Point<T>::X), 
00897                    -p(Point<T>::Y), 
00898                    -p(Point<T>::Z) ); 
00899 }

template<typename T>
Point<T> claraty::operator- ( const Point< T > &  ,
const Point< T > &   
)

template<class T1, class T2>
Vector<T1> claraty::operator- ( const Matrix< T1 > &  lhs,
const Vector< T2 > &  rhs 
)

Definition at line 177 of file matrix_operator.h.

References claraty::N_2D_Array< T >::begin(), claraty::N_2D_Array< T >::end(), claraty::Vector< T >::get_orientation(), claraty::Vector< T >::get_size(), and match_orientations().

00178 {
00179   match_orientations(rhs, lhs);
00180   Vector<T1> ret(rhs.get_size(), rhs.get_orientation());
00181   std::transform(lhs.begin(), lhs.end(), rhs.begin(), ret.begin(),
00182                  std::minus<T1>());
00183   return ret;
00184 }

Here is the call graph for this function:

template<class T1, class T2>
Vector<T1> claraty::operator- ( const Vector< T1 > &  lhs,
const Matrix< T2 > &  rhs 
)

Definition at line 161 of file matrix_operator.h.

References claraty::N_2D_Array< T >::begin(), claraty::Vector< T >::get_orientation(), claraty::Vector< T >::get_size(), and match_orientations().

00162 {
00163   match_orientations(lhs, rhs);
00164   Vector<T1> ret(lhs.get_size(), lhs.get_orientation());
00165   std::transform(lhs.begin(), lhs.end(), rhs.begin(), ret.begin(),
00166                  std::minus<T1>());
00167   return ret;
00168 }

Here is the call graph for this function:

template<class T1, class T2>
Vector<T1> claraty::operator- ( const Vector< T1 > &  lhs,
const Vector< T2 > &  rhs 
)

Definition at line 350 of file vector.h.

References vector_transform().

00351 {
00352   return vector_transform(lhs, rhs, std::minus<T1>());
00353 }

Here is the call graph for this function:

template<class T>
N_2D_Point< T > claraty::operator/ ( const N_2D_Point< T > &  ,
double   
) [inline]

Definition at line 702 of file 2d_point.h.

References claraty::N_2D_Point< T >::x(), and claraty::N_2D_Point< T >::y().

00703 {
00704   return N_2D_Point<T>( v.x()/s, v.y()/s );
00705 }

Here is the call graph for this function:

template<typename T, typename T2>
Point<T> claraty::operator/ ( const Point< T > &  ,
T2   
)

std::ostream& claraty::operator<< ( std::ostream &  str,
const Tsai_Camera_Model &  m 
)

ostream& claraty::operator<< ( ostream &  os,
const Tsai_Camera_Model &  model 
)

Definition at line 386 of file tsai_camera_model.cc.

References claraty::FDM_Parse_Tree::write_object().

00387 {
00388   FDM_Parse_Tree::write_object(model, os);
00389   return(os);
00390 }

Here is the call graph for this function:

template<class T>
std::ostream& claraty::operator<< ( std::ostream &  os,
const RMatrix< T > &  m 
)

Definition at line 555 of file rotation_matrix.h.

References claraty::XML_Out::get_indentation_space(), and claraty::XML_Out::is_xml_output_on().

00556 {
00557   //  const Matrix<T> tmp(3,3, &rmatrix(0,0));
00558   //  os << tmp; 
00559   //  return os;
00560   
00561   //   Matrix<T> mat(m);
00562   //   os << mat;
00563   //   return os;
00564   
00565   // Set up the spacing for the indentation of the fields in the file
00566   std::string spacing = "";
00567   spacing.append(XML_Out::get_indentation_space(), ' ');
00568   
00569   long oldPrecision;
00570   if (XML_Out::is_xml_output_on())
00571     {
00572       T roll, pitch, yaw;
00573       m.get_rpy_angles(roll, pitch, yaw);
00574       os << spacing << "<Rotation ";
00575       os << "type = \"RPY\" "; 
00576       os << "angle1 = \"" << std::setw(8) << roll << "\" ";
00577       os << "angle2 = \"" << std::setw(8) << pitch << "\" ";
00578       os << "angle3 = \"" << std::setw(8) << yaw << "\" />\n";
00579     }
00580   else
00581     {
00582       os << "size: (3,3)" << std::endl;
00583       os.setf(std::ios::showpoint);
00584       
00585       oldPrecision = os.precision();
00586       os.precision(4);
00587       for (int i=0; i < 3; ++i) {
00588         os << "[ ";
00589         for (int j=0; j < 3; ++j) {
00590           os << " " << std::setw(8) << m._data[i][j];
00591         }
00592         os << " ]" << std::endl;
00593       }
00594       os.precision(oldPrecision);
00595     }
00596   return os;
00597 }

Here is the call graph for this function:

template<class T>
std::ostream& claraty::operator<< ( std::ostream &  os,
const Quaternion< T > &  q 
)

Definition at line 875 of file quaternion.h.

References claraty::XML_Out::get_indentation_space(), and claraty::XML_Out::is_xml_output_on().

00876 {
00877   // Set up the spacing for the indentation of the fields in the file
00878   std::string spacing = "";
00879   spacing.append(XML_Out::get_indentation_space(), ' ');
00880   std::ios::fmtflags oldBase;
00881   int oldPrecision;
00882   
00883   os.setf(std::ios::showpoint);
00884   
00885   if (sizeof(T)==1)
00886     {
00887       oldBase = os.setf(std::ios::hex, std::ios::basefield);
00888     } 
00889   else
00890     {
00891       oldPrecision = os.precision();
00892       os.precision(4);
00893     }
00894   
00895   if (XML_Out::is_xml_output_on())
00896     {
00897       os << spacing << "<Quaternion ";
00898       os << "qi = \"" << std::setw(8) << q(0) << "\" ";
00899       os << "qj = \"" << std::setw(8) << q(1) << "\" ";
00900       os << "qk = \"" << std::setw(8) << q(2) << "\" ";
00901       os << "qs = \"" << std::setw(8) << q(3) << "\" />\n";
00902     }
00903   else
00904     {
00905       os << "Quaternion: [ ";
00906       for (int j=0; j < 4; ++j)
00907           os << "   " << ((sizeof(T)==1) ? (int) q(j) : q(j));
00908       
00909       os << " ]" << std::endl;
00910       }
00911   
00912   if (sizeof(T)==1) 
00913     os.setf(oldBase, std::ios::basefield);
00914   else
00915     os.precision(oldPrecision);
00916   return os;
00917 }

Here is the call graph for this function:

template<class T2, class Rotation_Type2>
std::ostream& claraty::operator<< ( std::ostream &  os,
const Trans< T2, Rotation_Type2 > &  tt 
) [inline]

friend operator ostream out

Parameters:
[in] os ostream reference
[in] tt Trans to be out-putted
Returns:
ostream with output

Definition at line 203 of file trans.h.

References claraty::Base_Trans< T, Rotation_Type >::_p, claraty::Base_Trans< T, Rotation_Type >::_r, and claraty::XML_Out::is_xml_output_on().

00205 {
00206   std::ios::fmtflags oldBase;
00207   int oldPrecision;
00208   
00209   //os.setf(std::ios::showbase);
00210   os.unsetf(std::ios::showpoint);
00211   os.unsetf(std::ios::scientific);
00212   
00213   if (sizeof(T2)==1) {
00214     oldBase = os.setf(std::ios::hex, std::ios::basefield);
00215   } 
00216   else {
00217     oldPrecision = os.precision();
00218     os.precision(4);
00219   }
00220   
00221   if (XML_Out::is_xml_output_on())
00222       {
00223         os << tt._p;
00224         os << tt._r;
00225       }
00226     else
00227       {
00228         os << "Trans:[";
00229         os << tt._p;
00230         os << tt._r;
00231         os << " ]";
00232       }
00233 
00234   if (sizeof(T2)==1) 
00235     os.setf(oldBase, std::ios::basefield);
00236   else
00237     os.precision(oldPrecision);
00238   
00239   return os;
00240 }

Here is the call graph for this function:

template<class T>
std::ostream& claraty::operator<< ( std::ostream &  os,
const QTrans< T > &  q 
)

Definition at line 134 of file qtrans.h.

References claraty::Base_Trans< T, Rotation_Type >::_p, claraty::Base_Trans< T, Rotation_Type >::_r, claraty::XML_Out::get_indentation_space(), and claraty::XML_Out::is_xml_output_on().

00135 {
00136   // Set up the spacing for the indentation of the fields in the file
00137   std::string spacing = "";
00138   spacing.append(XML_Out::get_indentation_space(), ' ');
00139   
00140   std::ios::fmtflags oldBase;
00141   int oldPrecision;
00142   
00143   //os.setf(std::ios::showbase);
00144   os.unsetf(std::ios::showpoint);
00145   os.unsetf(std::ios::scientific);
00146   
00147   if (sizeof(T)==1) {
00148     oldBase = os.setf(std::ios::hex, std::ios::basefield);
00149   } 
00150   else {
00151     oldPrecision = os.precision();
00152     os.precision(4);
00153   }
00154   
00155   if (XML_Out::is_xml_output_on())
00156     {
00157       os << spacing << "<Position ";
00158       os << "x = \"" << std::setw(8) << q._p(0) << "\" ";
00159       os << "y = \"" << std::setw(8) << q._p(1) << "\" ";
00160       os << "z = \"" << std::setw(8) << q._p(2) << "\" />\n";
00161       os << spacing << "<Quaternion ";
00162       os << "qi = \"" << std::setw(8) << q._r(0) << "\" ";
00163       os << "qj = \"" << std::setw(8) << q._r(1) << "\" ";
00164       os << "qk = \"" << std::setw(8) << q._r(2) << "\" ";
00165       os << "qs = \"" << std::setw(8) << q._r(3) << "\" />\n";
00166     }
00167   else
00168     {
00169       
00170       os << "QTrans:[";
00171       os << "x:" << std::setw(8) << q._p(0) << "   "
00172          << "y:" << std::setw(8) << q._p(1) << "   "
00173          << "z:" << std::setw(8) << q._p(2) << "   "
00174          << "qi:" << std::setw(8) << q._r(0) << "   "  
00175          << "qj:" << std::setw(8) << q._r(1) << "   " 
00176          << "qk:" << std::setw(8) << q._r(2) << "   " 
00177          << "qk:" << std::setw(8) << q._r(3)    
00178          << " ]" << std::endl;
00179     }
00180   
00181   if (sizeof(T)==1) 
00182     os.setf(oldBase, std::ios::basefield);
00183   else
00184     os.precision(oldPrecision);
00185   
00186   return os;
00187 }

Here is the call graph for this function:

template<class T>
std::ostream& claraty::operator<< ( std::ostream &  os,
const HTrans< T > &  h 
)

Definition at line 122 of file htrans.h.

References claraty::XML_Out::get_indentation_space(), and claraty::XML_Out::is_xml_output_on().

00123 {
00124   // Set up the spacing for the indentation of the fields in the file
00125   std::string spacing = "";
00126   spacing.append(XML_Out::get_indentation_space(), ' ');
00127   
00128   std::ios::fmtflags oldBase;
00129   int oldPrecision;
00130   T   pitch, yaw, roll;
00131   
00132   h._r.get_rpy_angles(roll, pitch, yaw);
00133   
00134   //os.setf(std::ios::showbase);
00135   os.unsetf(std::ios::showpoint);
00136   os.unsetf(std::ios::scientific);
00137   
00138   if (sizeof(T)==1) {
00139     oldBase = os.setf(std::ios::hex, std::ios::basefield);
00140   } 
00141   else {
00142     oldPrecision = os.precision();
00143     os.precision(4);
00144   }
00145   
00146   if (XML_Out::is_xml_output_on())
00147     {
00148       os << spacing  << "<Position ";
00149       os << "x = \"" << std::setw(8) << h._p(0) << "\" ";
00150       os << "y = \"" << std::setw(8) << h._p(1) << "\" ";
00151       os << "z = \"" << std::setw(8) << h._p(2) << "\" />\n";
00152       T roll, pitch, yaw;
00153       h.get_rpy_angles(roll, pitch, yaw);
00154       os << spacing << "<Three_Angle_Set ";
00155       os << "type = RPY "; 
00156       os << "angle = \"" << std::setw(8) << roll << "\" ";
00157       os << "angle = \"" << std::setw(8) << pitch << "\" ";
00158       os << "angle = \"" << std::setw(8) << yaw << "\" />\n";
00159     }
00160   else
00161     {
00162       os << "HTrans:[";
00163       os << "x:" << std::setw(8) << h._p(0) << "   "
00164          << "y:" << std::setw(8) << h._p(1) << "   "
00165          << "z:" << std::setw(8) << h._p(2) << "   "
00166          << "roll(rx):"  << std::setw(8) << roll << "   "  
00167          << "pitch(ry):" << std::setw(8) << pitch  << "   " 
00168          << "yaw(rz):"   << std::setw(8) << yaw    
00169          << " ]";
00170     }
00171   
00172   if (sizeof(T)==1) 
00173     os.setf(oldBase, std::ios::basefield);
00174   else
00175     os.precision(oldPrecision);
00176   
00177   return os;
00178 }

Here is the call graph for this function:

std::ostream& claraty::operator<< ( std::ostream &  os,
const Trajectory &  traj 
) [inline]

------------------------------------------------------------------------- serializes the trajectory parameters to an os stream for display, transport or storage

Definition at line 403 of file trajectory.h.

References claraty::Trajectory::is_started().

00404 {
00405   os << "%" << std::setw(80) << std::setfill('-') << " " << std::setfill(' ') << std::endl;
00406   os << "%[Trajectory]" << std::endl;
00407   os << "% Started (y/n): " << (traj.is_started() ? "yes" : "no") << std::endl;
00408   return os;
00409 }

Here is the call graph for this function:

ostream& claraty::operator<< ( ostream &  os,
const Multi_Segment_Trajectory &  traj 
)

------------------------------------------------------------------------- serializes the trajectory parameters to an os stream for display, transport or storage

Definition at line 419 of file multi_segment_trajectory.cc.

References claraty::Multi_Segment_Trajectory::_high, claraty::Multi_Segment_Trajectory::_low, claraty::Multi_Segment_Trajectory::_nvia, claraty::Multi_Segment_Trajectory::_q, claraty::Multi_Segment_Trajectory::_q_ddot, claraty::Multi_Segment_Trajectory::_qjk_dot, claraty::Multi_Segment_Trajectory::_tjk, and claraty::Multi_Segment_Trajectory::_tk.

00421 {
00422    const int& n = traj._nvia;
00423 
00424    os << "[Multi_Segment_Trajectory <segment>]" << std::endl
00425       << "Number of Via Points: " << n   << std::endl
00426       << "Number of Segments:   " << n-1 << std::endl
00427       << "Trajectory duration:  " << traj._high[n-2]+0.5*traj._tk[n-1] << std::endl
00428       << "Segment times" << std::endl;
00429    for(int i = 0; i < n-1; i++) {
00430       // display segment time boundaries
00431       os << "segment " << i << ": "
00432          << "[" 
00433          << traj._low[i] << ", "
00434          << traj._high[i]
00435          << "]" << std::endl;
00436    }
00437 
00438    os << std::endl << "Segment data" << std::endl;
00439    for(int i = 0; i < n; i++) {
00440       os << "q" << i+1 << " = " << traj._q[i] << std::endl;
0044