uuc3dlib/uuc3d.hpp

Go to the documentation of this file.

#ifndef UUC3D_38DHJWTOANTQ
#define UUC3D_38DHJWTOANTQ

// vim:set tabstop=4 cindent:

// Author: Geert-Jan Giezeman <geert@cs.uu.nl>
// Copyright: Utrecht University, 2011

#include "basic_io.hpp"
#include <string>
#include <vector>
#include <boost/scoped_ptr.hpp>

namespace UuIcsC3d
{

    struct PreconditionError
    {
    };

    struct OpenError
    {
        OpenError(std::string const &filename)
            : m_filename(filename) {}
        std::string filename() const {return m_filename;}
    private:
        std::string m_filename;
    };

    struct ContentError
    {
        ContentError(std::string const &msg, std::string const &filename)
            : m_msg(msg), m_filename(filename) {}
        std::string filename() const {return m_filename;}
        std::string msg() const {return m_msg;}
    private:
        std::string m_msg;
        std::string m_filename;
    };

}

namespace UuIcsC3d
{

//      typedef uint16_t unsigned16_t;
        typedef unsigned short unsigned16_t;

    typedef unsigned char Block[512];

        struct HeaderEvent {
                std::string label;
                bool displayed;
                float time;
        };

        struct Header {
                int trajectory_count;
                int analog_per_frame;
                int first_frame;
                int last_frame;
                int max_interpolation_gap;
                float scaling_factor;
                int data_start_block;
                int analog_samples_per_frame;
                float frame_rate;
                bool has_label_and_range;
                int label_and_range_block;
                std::vector<HeaderEvent> events;
        };

    struct GroupParamCommon
    {
        GroupParamCommon(): m_id(0) {}
        GroupParamCommon(bool locked, int id, std::string const &name,
                                std::string const &description)
            : m_locked(locked),m_id(id), m_name(name),
              m_description(description) {}
        int id() const
        { return m_id; }
        void set_id(int id)
        { m_id = id; }
                bool is_locked() const
                { return m_locked; }
                void set_locked(bool value)
                { m_locked = value; }
        std::string name() const
        { return m_name; }
        void set_name(std::string name)
        { m_name = name; }
        std::string description() const
        { return m_description; }
        void set_description(std::string const &description)
        { m_description = description; }
    protected:
                bool m_locked;
        int m_id;
        std::string m_name;
        std::string m_description;
    };

    struct Parameter: GroupParamCommon
    {
        enum DataType {DtChar=-1, DtByte=1, DtShort=2, DtFloat=4};
                Parameter() {}
        Parameter(bool locked, int id, std::string name, int data_type,
            std::vector<int> const &dimension_size,
                        unsigned char const*data_start, unsigned char const*data_end,
            std::string const &description, boost::shared_ptr<BasicIO> io);

        DataType data_type() const { return m_data_type; }
        std::vector<int> bounds() const { return m_dimension_size; }
        unsigned char get_byte(std::vector<int> const &index) const;
        unsigned char get_byte(int i1) const;
        unsigned char get_the_byte() const;
        char get_char(std::vector<int> const &index) const;
        char get_char(int i1) const;
        char get_the_char() const;
                bool contains_string() const;
        std::string get_string(std::vector<int> const &index) const;
                std::string get_string(int i1) const;
        std::string get_the_string() const;
        int get_short(std::vector<int> const &index) const;
        int get_short(int i1) const;
        int get_the_short() const;
        unsigned get_ushort(std::vector<int> const &index) const;
        unsigned get_ushort(int i1) const;
        unsigned get_the_ushort() const;
        float get_float(std::vector<int> const &index) const;
        float get_float(int i1) const;
        float get_the_float() const;
                int representation_size() const;
                std::vector<unsigned char> const &raw_data() const
                { return m_data;}
        bool check_index(std::vector<int> const &index) const;
        bool check_string_index(std::vector<int> const &index) const;

                void set_the_ushort(unsigned16_t val);
                void set_ushort(int i1, unsigned16_t val);
                void set_strings(std::vector<std::string> const &strings, char pad);
    private:
        int get_offset(int data_size, std::vector<int> const &index) const;
                int get_string_offset(std::vector<int> const &index) const;
        DataType m_data_type;
        std::vector<int> m_dimension_size;
                std::vector<unsigned char> m_data;
                boost::shared_ptr<BasicIO> m_io; // decoder of binary data, appropriate for input file
    };

    struct Group: GroupParamCommon
    {
        Group()  {}
        Group(int id)
            : GroupParamCommon(false, id, std::string(), std::string()) {}
        Group(bool locked, int id, std::string name,
                                std::string const &description)
            : GroupParamCommon(locked, id, name, description) {}
        void add_parameter(Parameter const &param);
        bool has_parameter(std::string const &name) const;
        Parameter const &get_parameter(std::string const &name) const;
        Parameter &get_parameter(std::string const &name);
                Parameter const *get_parameter_checked(std::string const &name) const;
                Parameter *get_parameter_checked(std::string const &name);
                std::vector<Parameter> const &the_parameters() const
                { return m_parameters;}
                int total_representation_size() const;
                int group_representation_size() const;
    private:
        std::vector<Parameter> m_parameters;
    };

    class Content
    {
                Header m_header;
                boost::shared_ptr<BasicIO> m_io; 
        std::vector<Group> m_groups;
                void parse_params(std::vector<unsigned char> const &);
        std::string m_filename;
    public:
                Content();
        void open(std::string const &filename);
        Header const &header() const 
        {return m_header;};
        Header &header() 
        {return m_header;};
        boost::shared_ptr<BasicIO> io() const
        { return m_io;}
        //std::string group_name(int gid) const;
        bool has_group(std::string const &name) const;
        Group const &get_group(std::string const &name) const;
        Group &get_group(std::string const &name);
        Group const *get_group_checked(std::string const &name) const;
        Group *get_group_checked(std::string const &name);
                std::vector<Group> const & the_groups() const { return m_groups;}
                std::string filename() const { return m_filename; }
    };

    Content open_c3d_file(char const *filename);
    Content open_c3d_file(std::string const &filename);

        struct FileInfo1 {
                int data_startblock0;
                int frame_count;
                int points_per_frame;
                int analog_channels;
                int samples_per_frame;
                int frame_size;
                float point_scale;
                bool is_integer;
        };

}

namespace UuIcsC3d
{


        struct DataPoint3d {
                enum Status { Generated=1, Measured=2, Invalid=64};
          private:
                float m_coords[3];
                float m_residual;
                char m_mask; // (bits 0-6 can indicate a camera)
                Status m_type;
                unsigned16_t m_flags;
          public:
                typedef float const (&CTripleF)[3];
                DataPoint3d(): m_residual(-1), m_mask(0), m_type(Invalid), m_flags(0)
                        {m_coords[0]=0; m_coords[1]=0;m_coords[2]=0;}

                void set_value(float x, float y, float z, unsigned f,
                                                Status v = Generated);
                void set_value(float const*in_coordinates, unsigned f,
                                                Status v = Generated);
                void set_value(double const*in_coordinates, unsigned f,
                                                Status v = Generated);
                void invalidate() { m_type = Invalid; }
                void set_mask(char mask)
                { m_mask = mask;}
                void set_residual(float r)
                { m_residual = r;}


                Status status() const {return m_type;}
                bool is_valid() const { return m_type==Generated || m_type==Measured; }
                CTripleF coordinates() const {return m_coords;}
                float x() const { return m_coords[0];}
                float y() const { return m_coords[1];}
                float z() const { return m_coords[2];}
                unsigned flags() const {return m_flags;}
                char mask() const {return m_mask;}
                float residual() const {return m_residual;}
        };

        struct FrameData {
                std::vector<DataPoint3d> points;
                std::vector< std::vector<float> > analog_data; 
        };

        struct SpacePaddedString {
                SpacePaddedString() :m_size(0) {}
                SpacePaddedString(std::string const &str):m_val(str) {compute_size();}
                std::string complete() const {return m_val;}
                std::string stripped() const {return m_val.substr(0, m_size);}
                void set(std::string const &str) {m_val = str; compute_size(); }
        private:
                std::string m_val;
                std::string::size_type m_size;
                void compute_size();
        };

        class C3dFile;

        class C3dFileInfo {
                Content m_content;
                FileInfo1 m_fi1;
                std::vector<SpacePaddedString> m_labels;
        public:

                C3dFileInfo();
                C3dFileInfo(std::string const &filename);


                bool is_valid() const; 
                int frame_count() const { return m_fi1.frame_count; }
                int points_per_frame() const { return m_fi1.points_per_frame; }
                std::vector<SpacePaddedString> point_labels() const
                { return m_labels; }
                int analog_channels() const { return m_fi1.analog_channels; }
                int analog_samples_per_frame() const { return m_fi1.samples_per_frame; }
                std::auto_ptr<C3dFile> open() const;


                void set_param_blocks(int c) ;
                void set_frame_count(int) ;
                void set_points_per_frame(int) ;
                void set_analog_samples_per_frame(int) ;
                void set_analog_channels(int) ;
                void set_point_labels(std::vector<std::string> const &labels,
                                                char pad = ' ');


                Content const &content() const { return m_content; }
                FileInfo1 const &fi1() const { return m_fi1; }
        };

        class C3dFile {
                C3dFile(C3dFile const &in); // not implemented: no copying
                struct Impl;
                boost::scoped_ptr<Impl> m_impl;
        public:
                C3dFile(C3dFileInfo const &fi);
                ~C3dFile();
                void get_frame_data(FrameData &data, int frame_no) const;
                DataPoint3d get_point(int frame_no, int point_no) const;
        };

        bool write_with_same_header(std::string const &fn, C3dFileInfo const &fi,
                                        std::vector<FrameData> const &data);

//      bool write(std::string const &fn, C3dFileInfo const &fi, std::vector<FrameData> const &data, UuIcsC3d::BasicIO const* encoder);
        bool write(std::string const &fn, C3dFileInfo fi, std::vector<FrameData> const &data, UuIcsC3d::BasicIO const* encoder);

}

#endif // UUC3D_38DHJWTOANTQ