/**
* A função executa_comando é uma das funções mais importantes pois é ela que vai reagir aos comandos dados pelo utilizador.
* A função irá receber a linha de comando separa la em dois, no comando e nos argumentos do comando, e passa los para as funções associadas aos comandos.
* @param Tab Tabuleiro do jogo
* @param DIM dimensão do tabuleiro
* @param linha Recebe uma string que corresponde á linha lida da shell.
* @returns torna um inteiro que verifica se foi ou não bem sucedida a função.
*/
int executa_comando(char *linha,int *DIM,Elem **Tab) {
char cmd[1025];
char args[1025];
int nargs=sscanf(linha, "%s %[^\n]", cmd, args);
if((strcmp(cmd, "b") == 0 || strcmp(cmd, "p") == 0 || strcmp(cmd, "i") == 0))
return executaJogada(args,cmd,DIM,Tab);
if(strcmp(cmd, "cr") == 0 )
return executaCriaJogo(args,DIM,Tab);
if(strcmp(cmd,"gr")==0 )
return executaGravaJogo(args,DIM,Tab);
if(strcmp(cmd,"?")==0 && nargs==1)
return ajuda();
if(strcmp(cmd,"trp")==0 && nargs==1)
return trp(Tab,DIM);
if(strcmp(cmd,"snd")==0 && nargs==1)
return snd(Tab,DIM);
if(strcmp(cmd,"pis")==0 && nargs==1)
return pis(Tab,DIM);
if(strcmp(cmd,"pds")==0 && nargs==1)
return pds(Tab,DIM);
if(strcmp(cmd,"vb")==0 && nargs==1)
return vb(Tab,DIM);
if(strcmp(cmd,"vp")==0 && nargs==1)
return vp(Tab,DIM);
if(strcmp(cmd,"vl")==0 && nargs==1)
return vl(Tab,DIM);
if(strcmp(cmd,"q")==0)
exit(0);
return mensagem_de_erro(E_COMMAND);
}
kernel::ModelObjectsTemp MolecularDynamicsMover::do_get_inputs() const {
kernel::ParticleIndexes pis(md_->get_simulation_particle_indexes());
kernel::ModelObjectsTemp ret(pis.size());
for (unsigned int i=0; i< pis.size(); ++i) {
ret[i] = get_model()->get_particle(pis[i]);
}
return ret;
}
double RigidBodyUmbrella::unprotected_evaluate(DerivativeAccumulator
* accum) const {
if (accum) IMP_THROW("Derivatives not implemented", ModelException);
kernel::ParticleIndexes pis(1, pi_);
internal::Coord x(internal::get_coordinates_from_rbs(get_model(), pis,
ref_));
double d2 = internal::get_squared_distance(x, x0_, k_);
double score = 0.5 * alpha_ * d2;
return score;
}
Eigen::Vector3d Referential::compute_centroid() const {
// get rigid body member coordinates
RigidBody d(m_, pi_);
ParticleIndexes pis(d.get_member_particle_indexes());
Eigen::Matrix<double, Eigen::Dynamic, 3> coords(pis.size(), 3);
for (unsigned i = 0; i < pis.size(); i++) {
XYZ xyz(m_, pis[i]);
coords(i, 0) = xyz.get_x();
coords(i, 1) = xyz.get_y();
coords(i, 2) = xyz.get_z();
}
return coords.colwise().mean();
}
int main(int argc, char* argv[]) {
string datafile = argv[1];
string partitionfile = argv[2];
string outfile = argv[3];
SequenceAlignment* protdata = new FileSequenceAlignment(datafile);
if (protdata->GetNstate() != Naa) {
cerr << "error: should be protein datafile\n";
exit(1);
}
StateSpace* statespace = protdata->GetStateSpace();
int Nsite = protdata->GetNsite();
ifstream pis(partitionfile.c_str());
int Ngene;
pis >> Ngene;
int* genesize = new int[Ngene];
int* genefirst = new int[Ngene];
SequenceAlignment** genedata = new SequenceAlignment*[Ngene];
int count = 0;
for (int gene=0; gene<Ngene; gene++) {
pis >> genesize[gene];
genefirst[gene] = count;
count += genesize[gene];
genedata[gene] = new SequenceAlignment(protdata,genefirst[gene],genesize[gene]);
}
if (count != Nsite) {
cerr << "error: non matching total size\n";
cerr << "sum over genes: " << count << '\n';
cerr << "concatenation : " << Nsite << '\n';
exit(1);
}
cerr << "number of genes: " << Ngene << '\n';
ofstream os(argv[3]);
double* freq = new double[Naa];
for (int gene=0; gene<Ngene; gene++) {
genedata[gene]->GetEmpiricalFreq(freq);
os << gene;
for (int k=0; k<Naa; k++) {
os << '\t' << freq[k];
}
os << '\n';
}
}
void parser::parse_option( parser_input &pi ) {
if( pi.past_end() ) {
return;
}
pisaver<parser_input,0> pis(pi);
char *arg = pi.peek();
// std::cout << "arg: " << arg << "\n";
if( arg[0] != '-' ) {
throw std::runtime_error( "WARNING: expected option. bailing out." );
}
char opt = arg[1];
if( !std::isalnum(opt) ) {
throw std::runtime_error( "WARNING: bad option. bailing out." );
}
if( !m_options[opt] ) {
throw std::runtime_error( "WARNING: unknown option. bailing out." );
}
m_option_count[opt]++;
pi.next();
if( m_opt_has_argument[opt] ) {
if( m_opt_values[opt] != 0 ) {
if( m_opt_values[opt]->allow_empty() ) {
m_opt_values[opt]->set("1"); // HACK
} else {
if( pi.past_end() ) {
throw std::runtime_error( "WARNING: option expects argument. bailing out." );
}
m_opt_values[opt]->set(pi.peek());
pi.next();
}
}
}
pis.commit();
}
Eigen::Matrix3d Referential::compute_base() const {
RigidBody d(m_, pi_);
ParticleIndexes pis(d.get_member_particle_indexes());
if (pis.size() < 3)
IMP_THROW("rigid body must contain at least 3 xyzs", ModelException);
XYZ o(m_, pis[0]), x(m_, pis[1]), y(m_, pis[2]);
Eigen::Vector3d vo, e1, e2;
vo << o.get_x(), o.get_y(), o.get_z();
e1 << x.get_x(), x.get_y(), x.get_z();
e1 = e1 - vo;
e1.normalize();
e2 << y.get_x(), y.get_y(), y.get_z();
e2 = e2 - vo;
e2 = e2 - e2.dot(e1) * e1;
e2.normalize();
Eigen::Matrix3d retmat;
retmat << e1, e2, e1.cross(e2);
return retmat;
}
void Transformer::transform() {
// convert translation and rotation from local to global coords
Eigen::Quaterniond refq = ref_.get_rotation();
Eigen::Vector3d global_t(refq * t_);
Eigen::Quaterniond global_q(pick_positive(refq * q_ * refq.conjugate()));
// get rb centroid as a translation
Eigen::Vector3d centroid(Referential(m_, target_).get_centroid());
// transform each rigid member
RigidBody d(m_, target_);
ParticleIndexes pis(d.get_member_particle_indexes());
for (unsigned i = 0; i < pis.size(); i++) {
XYZ xyz(m_, pis[i]);
Eigen::Vector3d coords;
coords << xyz.get_x(), xyz.get_y(), xyz.get_z();
Eigen::Vector3d newcoords = global_q * (coords - centroid) + centroid
+ global_t;
xyz.set_x(newcoords(0));
xyz.set_y(newcoords(1));
xyz.set_z(newcoords(2));
}
// update rigid body
d.set_reference_frame_from_members(pis);
}
void demo_csgo::handle_protobuf(std::istream& is, int32_t data_length) {
google::protobuf::io::IstreamInputStream pis(&is, data_length);
google::protobuf::io::CodedInputStream pcis(&pis);
while(data_length > 0) {
uint32_t cmd;
uint32_t size;
if(!pcis.ReadVarint32(&cmd)) {
std::cout << "!pcis.ReadVarint32(&cmd)" << std::endl;
std::cin.ignore();
}
if(!pcis.ReadVarint32(&size)) {
std::cout << "!pcis.ReadVarint32(&size)" << std::endl;
std::cin.ignore();
}
data_length -= sizeof(cmd);
data_length -= sizeof(size);
google::protobuf::io::CodedInputStream::Limit limit = pcis.PushLimit(size);
if(!(NET_Messages_IsValid(cmd) || SVC_Messages_IsValid(cmd))) {
//std::cerr << "handle_protobuf(): !(NET_Messages_IsValid(cmd) || SVC_Messages_IsValid(cmd))" << std::endl;
//std::cerr << "cmd=" << std::dec << cmd << ",size=" << size << std::endl;
}
switch(cmd) {
case net_NOP: handle_netmessages<CNETMsg_NOP, net_NOP>(pcis); break;
case net_Disconnect: handle_netmessages<CNETMsg_Disconnect, net_Disconnect>(pcis); break;
case net_File: handle_netmessages<CNETMsg_File, net_File>(pcis); break;
case /* net_SplitScreenUser */ 3: std::cout << "handle_protobuf(): switch(3) not implemented" << std::endl; break; // handle_netmessages<CNETMsg_SplitScreenUser, net_SplitScreenUser>(pcis); break;
case net_Tick: handle_netmessages<CNETMsg_Tick, net_Tick>(pcis); break;
case net_StringCmd: handle_netmessages<CNETMsg_StringCmd, net_StringCmd>(pcis); break;
case net_SetConVar: handle_netmessages<CNETMsg_SetConVar, net_SetConVar>(pcis); break;
case net_SignonState: handle_netmessages<CNETMsg_SignonState, net_SignonState>(pcis); break;
case svc_ServerInfo: handle_netmessages<CSVCMsg_ServerInfo, svc_ServerInfo>(pcis); break;
case svc_SendTable: handle_netmessages<CSVCMsg_SendTable, svc_SendTable>(pcis); break;
case svc_ClassInfo: handle_netmessages<CSVCMsg_ClassInfo, svc_ClassInfo>(pcis); break;
case svc_SetPause: handle_netmessages<CSVCMsg_SetPause, svc_SetPause>(pcis); break;
case svc_CreateStringTable: handle_netmessages<CSVCMsg_CreateStringTable, svc_CreateStringTable>(pcis); break;
case svc_UpdateStringTable: handle_netmessages<CSVCMsg_UpdateStringTable, svc_UpdateStringTable>(pcis); break;
case svc_VoiceInit: handle_netmessages<CSVCMsg_VoiceInit, svc_VoiceInit>(pcis); break;
case svc_VoiceData: handle_netmessages<CSVCMsg_VoiceData, svc_VoiceData>(pcis); break;
case svc_Print: handle_netmessages<CSVCMsg_Print, svc_Print>(pcis); break;
case svc_Sounds: handle_netmessages<CSVCMsg_Sounds, svc_Sounds>(pcis); break;
case svc_SetView: handle_netmessages<CSVCMsg_SetView, svc_SetView>(pcis); break;
case svc_FixAngle: handle_netmessages<CSVCMsg_FixAngle, svc_FixAngle>(pcis); break;
case svc_CrosshairAngle: handle_netmessages<CSVCMsg_CrosshairAngle, svc_CrosshairAngle>(pcis); break;
case svc_BSPDecal: handle_netmessages<CSVCMsg_BSPDecal, svc_BSPDecal>(pcis); break;
case /* svc_SplitScreen */ 22: std::cout << "handle_protobuf(): switch(22) not implemented" << std::endl; break; // handle_netmessages<CSVCMsg_SplitScreen, svc_SplitScreen>(pcis); break;
case svc_UserMessage: handle_netmessages<CSVCMsg_UserMessage, svc_UserMessage>(pcis); break;
case /* svc_EntityMessage */ 24: std::cout << "handle_protobuf(): switch(24) not implemented" << std::endl; break; // handle_netmessages<CSVCMsg_EntityMessage, svc_EntityMessage>(pcis); break;
case svc_GameEvent: handle_netmessages<CSVCMsg_GameEvent, svc_GameEvent>(pcis); break;
case svc_PacketEntities: handle_netmessages<CSVCMsg_PacketEntities, svc_PacketEntities>(pcis); break;
case svc_TempEntities: handle_netmessages<CSVCMsg_TempEntities, svc_TempEntities>(pcis); break;
case svc_Prefetch: handle_netmessages<CSVCMsg_Prefetch, svc_Prefetch>(pcis); break;
case svc_Menu: handle_netmessages<CSVCMsg_Menu, svc_Menu>(pcis); break;
case svc_GameEventList: handle_netmessages<CSVCMsg_GameEventList, svc_GameEventList>(pcis); break;
case svc_GetCvarValue: handle_netmessages<CSVCMsg_GetCvarValue, svc_GetCvarValue>(pcis); break;
case /* svc_PacketReliable? */ 32: std::cout << "handle_protobuf(): switch(32) not implemented" << std::endl; break;
case /* svc_PaintmapData */ 33: std::cout << "handle_protobuf(): switch(33) not implemented" << std::endl; break; // handle_netmessages<CSVCMsg_PaintmapData, svc_PaintmapData>(pcis); break;
case /* svc_CmdKeyValues */ 34: std::cout << "handle_protobuf(): switch(34) not implemented" << std::endl; break; // handle_netmessages<CSVCMsg_CmdKeyValues, svc_CmdKeyValues>(pcis); break;
case /* svc_EncryptedData */ 35: break; std::cout << "handle_protobuf(): switch(35) not implemented" << std::endl; break; // handle_netmessages<CSVCMsg_EncryptedData, svc_EncryptedData>(pcis); break;
default:
std::cout << "handle_protobuf(): switch(" << std::dec << cmd << ") default" << std::endl;
std::cin.ignore();
break;
}
if(0 != pcis.BytesUntilLimit()) {
//std::cout << "handle_protobuf(): draining: " << pcis.BytesUntilLimit() << std::endl;
pcis.Skip(pcis.BytesUntilLimit());
}
pcis.PopLimit(limit);
data_length -= size;
}
}
db::MediaFile FileImporter::import(org::esb::io::File file) {
db::HiveDb & connection = *getContext()->database; //("sqlite3", org::esb::config::Config::get("db.url"));
db::MediaFile mediafile(connection);
FormatInputStream fis(&file);
if (!fis.isValid())return mediafile;
connection.begin();
PacketInputStream pis(&fis);
//int id = 0;
// try {
// db::MediaFile mfile=litesql::select<db::MediaFile>(db, db::MediaFile::Path==file.getFilePath() && db::MediaFile::Filename==file.getFileName()).one();
// id=mfile.id;
// } catch (litesql::NotFound ex) {
//org::esb::io::File tmpFile(file);
mediafile.filename = file.getFileName();
mediafile.path = file.getFilePath();
mediafile.filesize = (double) fis.getFileSize();
mediafile.streamcount = fis.getStreamCount();
mediafile.containertype = fis.getFormatContext()->iformat->name;
mediafile.duration = (double) fis.getFormatContext()->duration;
mediafile.starttime = (double) fis.getFormatContext()->start_time;
mediafile.bitrate = fis.getFormatContext()->bit_rate;
mediafile.update();
AVFormatContext *ctx = fis.getFormatContext();
for (int a = 0; a < mediafile.streamcount; a++) {
db::Stream stream(mediafile.getDatabase());
stream.streamindex = (int) a;
stream.streamtype = (int) ctx->streams[a]->codec->codec_type;
stream.codecid = (int) ctx->streams[a]->codec->codec_id;
stream.codecname = (const char*) ctx->streams[a]->codec->codec_name;
stream.frameratenum = ctx->streams[a]->r_frame_rate.num;
stream.framerateden = ctx->streams[a]->r_frame_rate.den;
stream.firstpts = (double) ctx->streams[a]->start_time;
stream.firstdts = (double) ctx->streams[a]->first_dts;
stream.duration = (double) ctx->streams[a]->duration;
stream.nbframes = (double) ctx->streams[a]->nb_frames;
stream.streamtimebasenum = ctx->streams[a]->time_base.num;
stream.streamtimebaseden = ctx->streams[a]->time_base.den;
stream.codectimebasenum = ctx->streams[a]->codec->time_base.num;
stream.codectimebaseden = ctx->streams[a]->codec->time_base.den;
stream.ticksperframe = ctx->streams[a]->codec->ticks_per_frame;
stream.width = ctx->streams[a]->codec->width;
stream.height = ctx->streams[a]->codec->height;
stream.gopsize = ctx->streams[a]->codec->gop_size;
stream.pixfmt = (int) ctx->streams[a]->codec->pix_fmt;
stream.bitrate = ctx->streams[a]->codec->bit_rate;
stream.samplerate = ctx->streams[a]->codec->sample_rate;
stream.samplefmt = (int) ctx->streams[a]->codec->sample_fmt;
stream.channels = ctx->streams[a]->codec->channels;
stream.bitspercodedsample = ctx->streams[a]->codec->bits_per_coded_sample;
stream.extradatasize = 0;
stream.extradatasize = ctx->streams[a]->codec->extradata_size;
// std::string data((char *)ctx->streams[a]->codec->extradata,ctx->streams[a]->codec->extradata_size);
if (stream.extradatasize > 0)
stream.extradata = litesql::Blob((char *) ctx->streams[a]->codec->extradata, ctx->streams[a]->codec->extradata_size);
stream.update();
const AVOption * option = NULL;
int max_offset = 0;
while (option = av_next_option(ctx->streams[a]->codec, option)) {
if (option->offset > 0) {
/*jump over depricated options*/
if (strcmp(option->name, "lpc_coeff_precision") == 0 ||
strcmp(option->name, "prediction_order_method") == 0 ||
strcmp(option->name, "min_partition_order") == 0 ||
strcmp(option->name, "max_partition_order") == 0 ||
strcmp(option->name, "lpc_type") == 0 ||
strcmp(option->name, "drc_scale") == 0 ||
strcmp(option->name, "lpc_passes") == 0
)continue;
max_offset = option->offset > max_offset ? option->offset : max_offset;
db::StreamParameter sp(stream.getDatabase());
sp.name = option->name;
int len = 1000;
char data[1000];
memset(&data, 0, 1000);
av_get_string(ctx->streams[a]->codec, option->name, NULL, data, len);
if (strlen(data) > 0) {
sp.val = std::string(data);
}
sp.update();
stream.params().link(sp);
}
}
LOGDEBUG("maxoffset=" << max_offset);
db::StreamParameter sp(stream.getDatabase());
sp.name = "codec_id";
sp.val = org::esb::util::StringUtil::toString(ctx->streams[a]->codec->codec_id);
sp.update();
stream.params().link(sp);
mediafile.streams().link(stream);
}
connection.commit();
return mediafile;
}
