mario/IMCtermite
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

imc_raw + imc_channels: channel extraction from blocks and environment

Browse Source
This commit is contained in:
Mario Fink 2021-02-11 15:49:11 +01:00
parent 1596ca15b5
commit acd55194a5
4 changed files with 135 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
lib/imc_channel.hpp
View File

@ -4,6 +4,7 @@
#define IMCCHANNEL
#include <sstream>
#include "imc_datatype.hpp"
//---------------------------------------------------------------------------//
@ -59,25 +60,113 @@ namespace imc
<<std::setw(width)<<std::left<<"NOuuid:"<<NOuuid_<<"\n";
return ss.str();
}
// get JSON info string
std::string get_json()
{
std::stringstream ss;
ss<<"{"<<"\"uuid\":\""<<uuid_
<<"\",\"CBuuid\":\""<<CBuuid_
<<"\",\"CGuuid\":\""<<CGuuid_
<<"\",\"CCuuid\":\""<<CCuuid_
<<"\",\"CNuuid\":\""<<CNuuid_
<<"\",\"CDuuid\":\""<<CDuuid_
<<"\",\"CTuuid\":\""<<CTuuid_
<<"\",\"Cbuuid\":\""<<Cbuuid_
<<"\",\"CPuuid\":\""<<CPuuid_
<<"\",\"CRuuid\":\""<<CRuuid_
<<"\",\"CSuuid\":\""<<CSuuid_
<<"\",\"NTuuid\":\""<<NTuuid_
<<"\",\"NOuuid\":\""<<NOuuid_
<<"\"}";
return ss.str();
}
};
// actual result and (meta)data of channel
struct channel_data
// given a list of numeric objects, join it into a string
template<typename dt>
std::string joinvec(std::vector<dt> myvec, unsigned long int limit = 10)
{
std::stringstream ss;
ss<<"[";
if ( myvec.size() <= limit )
{
for ( dt el: myvec ) ss<<el<<",";
}
else
{
unsigned long int heals = (unsigned long int)(limit/2.);
for ( unsigned long int i = 0; i < heals; i++ ) ss<<myvec[i]<<",";
ss<<"...";
for ( unsigned long int i = myvec.size()-heals; i < myvec.size(); i++ )
{
ss<<myvec[i]<<",";
}
}
std::string sumstr = ss.str();
if ( sumstr.size() > 1 ) sumstr.pop_back();
sumstr += std::string("]");
return sumstr;
}
// channel
struct channel
{
// associated environment of blocks and map of blocks
channel_env chnenv_;
const std::map<std::string,imc::block>* blocks_;
// collect meta-data of channels according to env,
// just everything valueable in here
std::string uuid_;
std::string name_;
std::string yunit_;
std::string xunit_;
std::string yname_, yunit_;
imc::datatype dattyp_;
std::string xname_, xunit_;
std::vector<imc::datatype> ydata_;
std::vector<imc::datatype> xdata_;
// provide JSON sttring of metadata
// group reference the channel belongs to
std::string group_uuid_, group_name_;
// constructor takes channel's block environment
channel(channel_env chnenv, std::map<std::string,imc::block>* blocks):
chnenv_(chnenv), blocks_(blocks)
{
std::vector<imc::parameter> prms = blocks->at(chnenv_.CNuuid_).get_parameters();
name_ = blocks->at(chnenv_.CNuuid_).get_parameter(prms[6]);
}
// get info string
std::string get_info(int width = 20)
{
std::stringstream ss;
ss<<"uuid:"<<std::setw(width)<<std::left<<uuid_<<"\n"
<<"name:"<<std::setw(width)<<std::left<<name_<<"\n"
<<"yname:"<<std::setw(width)<<std::left<<yname_<<"\n"
<<"yunit:"<<std::setw(width)<<std::left<<yunit_<<"\n"
<<"xname:"<<std::setw(width)<<std::left<<xname_<<"\n"
<<"xunit:"<<std::setw(width)<<std::left<<xunit_<<"\n"
<<"group:"<<std::setw(width)<<std::left<<group_name_<<"\n"
<<"aff. blocks:"<<std::setw(width)<<std::left<<chnenv_.get_json()<<"\n";
return ss.str();
}
// provide JSON string of metadata
std::string get_json()
{
std::stringstream ss;
ss<<""<<"\n";
ss<<"{"<<"\"uuid\":\""<<uuid_
<<"\",\"name\":\""<<name_
<<"\",\"yname\":\""<<yname_
<<"\",\"yunit\":\""<<yunit_
<<"\",\"xname\":\""<<xname_
<<"\",\"xunit\":\""<<xunit_
<<"\",\"group\":\""<<group_name_
<<"\",\"ydata\":\""<<imc::joinvec<imc::datatype>(ydata_)
<<"\",\"xdata\":\""<<imc::joinvec<imc::datatype>(xdata_)
<<"\",\"aff. blocks\":\""<<chnenv_.get_json()
<<"\"}";
return ss.str();
}

8
lib/imc_object.hpp
View File

@ -75,7 +75,7 @@ namespace imc
};
// group definition (corresponds to key CB)
struct group
struct groupobj
{
unsigned long int group_index_;
std::string name_;
@ -400,7 +400,7 @@ namespace imc
};
// channel (corresponds to key CN)
struct channel
struct channelobj
{
unsigned long int group_index_; // corresponds to group-index in CB key
bool index_bit_; // true = 1: digital, false = 0: analog
@ -538,7 +538,7 @@ namespace imc {
{
format fmt_; // 0
keygroup kyg_; // 1
group grp_; // 2
groupobj grp_; // 2
text txt_; // 3
datafield dtf_; // 4
abscissa abs_; // 5
@ -546,7 +546,7 @@ namespace imc {
packaging pkg_; // 7
buffer bfr_; // 8
range rng_; // 9
channel chn_; // 10
channelobj chn_; // 10
data dat_; // 11
origin_data org_; // 12
triggertime trt_; // 13

37
lib/imc_raw.hpp
View File

@ -33,8 +33,8 @@ namespace imc
// check computational complexity for parsing blocks
unsigned long int cplxcnt_;
// list groups and channels with their affiliate blocks
std::map<std::string,imc::channel_env> channel_envs_;
// list groups and channels (including their affiliate blocks)
std::map<std::string,imc::channel> channels_;
public:
@ -224,11 +224,13 @@ namespace imc
if ( blk.get_key().name_ == "CS" || blk.get_key().name_ == "CC"
|| blk.get_key().name_ == "CG" || blk.get_key().name_ == "CB" )
{
// provide UUID for channel
chnenv.uuid_ = chnenv.CNuuid_;
channel_envs_.insert(
std::pair<std::string,imc::channel_env>(chnenv.CNuuid_,chnenv)
// create channel object and add it to the map of channels
channels_.insert( std::pair<std::string,imc::channel>
(chnenv.CNuuid_,imc::channel(chnenv,&mapblocks_))
);
std::cout<<chnenv.get_info()<<"\n";
// reset channel uuid
chnenv.CNuuid_.clear();
@ -293,6 +295,31 @@ namespace imc
return cplxcnt_;
}
// get list of channels with metadata
std::vector<std::string> get_channels()
{
std::vector<std::string> chns;
for ( std::map<std::string,imc::channel>::iterator it = channels_.begin();
it != channels_.end(); ++it)
{
chns.push_back(it->second.get_json());
}
return chns;
}
// get particular channel including data by its uuid
imc::channel get_channel(std::string uuid)
{
if ( channels_.count(uuid) )
{
return channels_.at(uuid);
}
else
{
throw std::runtime_error(std::string("channel does not exist:") + uuid);
}
}
// list a particular type of block
std::vector<imc::block> list_blocks(imc::key mykey)
{

23
src/main.cpp
View File

@ -180,26 +180,11 @@ int main(int argc, char* argv[])
std::cout<<"computational complexity: "<<imcraw.computational_complexity()
<<"/"<<imcraw.buffer_size()<<"\n\n";
// list specific blocks
// std::vector<imc::block> CBblocks = imcraw.list_blocks(imc::keys.at("CB"));
// for ( auto blk: CBblocks ) std::cout<<blk.get_info()<<"\n";
// std::vector<imc::block> CGblocks = imcraw.list_blocks(imc::keys.at("CG"));
// for ( auto blk: CGblocks ) std::cout<<blk.get_info()<<"\n";
// std::vector<imc::block> CCblocks = imcraw.list_blocks(imc::keys.at("CC"));
// for ( auto blk: CCblocks ) std::cout<<blk.get_info()<<"\n";
// std::vector<imc::block> CNblocks = imcraw.list_blocks(imc::keys.at("CN"));
// for ( auto blk: CNblocks ) std::cout<<blk.get_info()<<"\n";
// std::vector<imc::block> CSblocks = imcraw.list_blocks(imc::keys.at("CS"));
// for ( auto blk: CSblocks ) std::cout<<blk.get_info()<<"\n";
// std::vector<imc::block> groups = imcraw.list_groups();
// for ( auto blk: groups ) std::cout<<blk.get_info()<<"\n";
// list channels
std::cout<<"list of channels:\n";
std::vector<std::string> channels = imcraw.get_channels();
for ( auto el: channels ) std::cout<<el<<"\n";
// std::vector<std::string> channels = imcraw.list_channels();
// for ( auto chn: channels )
// {
// std::cout<<chn<<"\n";
// imc::channel_tab chtab = imcraw.get_channel(chn);
// }
}
return 0;