void OnlineViewerServerImpl::load(string name, string url)
{
string filepath;
QRegExp filePattern("(\\w+)://(.+)");
if(filePattern.exactMatch(url.c_str())){
string protocol = filePattern.cap(1).toStdString();
if(protocol == "file"){
filepath = filePattern.cap(2).toStdString();
} else {
mv->putln(
fmt(_("OnlineViewer: The model file at \"%1%\" cannot be read. %2% protocol is not supported."))
% url % protocol);
return;
}
} else {
filepath = url;
}
// search for registered body items
BodyItemInfo* info = findInfo(name);
if(info && info->bodyItem->filePath() == filepath){
info->needToSelectLogItem = true;
// mv->putln(fmt(_("OnlineViewer: \"%1%\" at \"%2%\" has already been loaded.")) % name % url);
return;
}
// search for existing body items
RootItem* rootItem = RootItem::instance();
ItemList<BodyItem> bodyItems;
bodyItems.extractChildItems(rootItem);
for(int i=0; i < bodyItems.size(); ++i){
BodyItemPtr bodyItem = bodyItems[i];
if(bodyItem->name() == name && bodyItem->filePath() == filepath){
registerBodyItem(bodyItem);
return;
}
}
// load a new body item
BodyItemPtr bodyItem = new BodyItem();
mv->putln(fmt(_("OnlineViewer: Loading \"%1%\" at \"%2%\"."))
% name % url);
mv->flush();
if(!bodyItem->load(filepath)){
mv->putln(fmt(_("OnlineViewer: Loading \"%1%\" failed.")) % name);
} else {
bodyItem->setName(name);
ItemList<WorldItem> worldItems;
if(worldItems.extractChildItems(rootItem)){
worldItems.front()->addChildItem(bodyItem);
} else {
rootItem->addChildItem(bodyItem);
}
ItemTreeView::instance()->checkItem(bodyItem, true);
registerBodyItem(bodyItem);
}
}
bool EditableSceneBodyImpl::storeProperties(Archive& archive)
{
ListingPtr states = new Listing();
ItemList<BodyItem> bodyItems;
bodyItems.extractChildItems(RootItem::instance());
for(size_t i=0; i < bodyItems.size(); ++i){
BodyItem* bodyItem = bodyItems[i];
EditableSceneBody* sceneBody = bodyItem->existingSceneBody();
if(sceneBody){
ValueNodePtr id = archive.getItemId(bodyItem);
if(id){
EditableSceneBodyImpl* impl = sceneBody->impl;
MappingPtr state = new Mapping();
state->insert("bodyItem", id);
state->write("showCenterOfMass", impl->isCmVisible);
state->write("showZmp", impl->isZmpVisible);
states->append(state);
}
}
}
if(!states->empty()){
archive.insert("editableSceneBodies", states);
return true;
}
return false;
}
void SimulationBar::forEachSimulator(boost::function<void(SimulatorItem* simulator)> callback, bool doSelect)
{
MessageView* mv = MessageView::instance();
/*
ItemList<SimulatorItem> simulators =
ItemTreeView::mainInstance()->selectedItems<SimulatorItem>();
*/
ItemList<SimulatorItem> simulators =
ItemTreeView::mainInstance()->selectedItems<SimulatorItem>();
if(simulators.empty()){
simulators.extractChildItems(RootItem::instance());
if(simulators.empty()){
mv->notify(_("There is no simulator item."));
} else if(simulators.size() > 1){
simulators.clear();
mv->notify(_("Please select a simulator item to simulate."));
} else {
if(doSelect){
ItemTreeView::instance()->selectItem(simulators.front());
}
}
}
typedef map<WorldItem*, SimulatorItem*> WorldToSimulatorMap;
WorldToSimulatorMap worldToSimulator;
for(int i=0; i < simulators.size(); ++i){
SimulatorItem* simulator = simulators.get(i);
WorldItem* world = simulator->findOwnerItem<WorldItem>();
if(world){
WorldToSimulatorMap::iterator p = worldToSimulator.find(world);
if(p == worldToSimulator.end()){
worldToSimulator[world] = simulator;
} else {
p->second = 0; // skip if multiple simulators are selected
}
}
}
for(int i=0; i < simulators.size(); ++i){
SimulatorItem* simulator = simulators.get(i);
WorldItem* world = simulator->findOwnerItem<WorldItem>();
if(!world){
mv->notify(format(_("%1% cannot be processed because it is not related with a world."))
% simulator->name());
} else {
WorldToSimulatorMap::iterator p = worldToSimulator.find(world);
if(p != worldToSimulator.end()){
if(!p->second){
mv->notify(format(_("%1% cannot be processed because another simulator"
"in the same world is also selected."))
% simulator->name());
} else {
callback(simulator);
}
}
}
}
}
void CollisionSeq::readCollisionData(int nFrames, const Listing& values)
{
/*
WorldItem* worldItem = collisionSeqItem_->findOwnerItem<WorldItem>();
if(!worldItem)
return;
*/
WorldItem* worldItem = 0;
RootItem* rootItem = RootItem::instance();
ItemList<WorldItem> worldItems;
if(worldItems.extractChildItems(rootItem)){
worldItem = worldItems.front();
}
if(!worldItem)
return;
for(int i=0; i < nFrames; ++i){
const Mapping& frameNode = *values[i].toMapping();
const Listing& linkPairs = *frameNode.findListing("LinkPairs");
Frame f = frame(i);
f[0] = std::make_shared<CollisionLinkPairList>();
for(int j=0; j<linkPairs.size(); j++){
CollisionLinkPairPtr destLinkPair = std::make_shared<CollisionLinkPair>();
const Mapping& linkPair = *linkPairs[j].toMapping();
string body0name = linkPair["body0"].toString();
string body1name = linkPair["body1"].toString();
string link0name = linkPair["link0"].toString();
string link1name = linkPair["link1"].toString();
BodyItem* body0Item = worldItem->findChildItem<BodyItem>(body0name);
Body* body0=0;
Body* body1=0;
Link* link0=0;
Link* link1=0;
if(body0Item){
body0 = body0Item->body();
link0 = body0->link(link0name);
}
BodyItem* body1Item = worldItem->findChildItem<BodyItem>(body1name);
if(body1Item){
body1 = body1Item->body();
link1 = body1->link(link1name);
}
destLinkPair->body[0] = body0;
destLinkPair->link[0] = link0;
destLinkPair->body[1] = body1;
destLinkPair->link[1] = link1;
const Listing& collisions = *linkPair.findListing("Collisions");
for(int k=0; k<collisions.size(); k++){
destLinkPair->collisions.push_back(Collision());
Collision& destCol = destLinkPair->collisions.back();
const Listing& collision = *collisions[k].toListing();
destCol.point = Vector3(collision[0].toDouble(), collision[1].toDouble(), collision[2].toDouble());
destCol.normal = Vector3(collision[3].toDouble(), collision[4].toDouble(), collision[5].toDouble());
destCol.depth = collision[6].toDouble();
}
f[0]->push_back(destLinkPair);
}
}
}
void WorldItemImpl::updateColdetBodyInfos(vector<ColdetBodyInfo>& infos)
{
infos.clear();
ItemList<BodyItem> bodyItems;
bodyItems.extractChildItems(self);
for(auto bodyItem : bodyItems){
if(bodyItem->isCollisionDetectionEnabled()){
infos.push_back(ColdetBodyInfo(bodyItem));
}
}
}
void OpenHRPOnlineViewerItemImpl::updatesub(const WorldState& state)
{
if(!worldItem){
RootItem* rootItem = RootItem::instance();
ItemList<WorldItem> worldItems;
if(worldItems.extractChildItems(rootItem)){
worldItem = worldItems.front();
} else {
worldItem = new WorldItem();
worldItem->setName("World");
rootItem->addChildItem(worldItem);
ItemTreeView::instance()->checkItem(worldItem, true);
}
worldItemConnections.add(
worldItem->sigDisconnectedFromRoot().connect(
boost::bind(&OpenHRPOnlineViewerItemImpl::onWorldItemDetachedFromRoot, this)));
}
if(!collisionSeqItem){
collisionSeqItem = worldItem->findChildItem<CollisionSeqItem>(collisionLogName);
if(!collisionSeqItem){
collisionSeqItem = new CollisionSeqItem();
collisionSeqItem->setTemporal();
collisionSeqItem->setName(collisionLogName);
worldItem->addChildItem(collisionSeqItem);
}
resetCollisionLogItem(collisionSeqItem);
needToSelectCollisionLogItem = true;
}
if(needToSelectCollisionLogItem){
ItemTreeView::instance()->selectItem(collisionSeqItem, true);
needToSelectCollisionLogItem = false;
}
const CollisionSeqPtr& colSeq = collisionSeqItem->collisionSeq();
int frame = colSeq->frameOfTime(state.time);
int lastFrame = std::max(0, std::min(frame, colSeq->numFrames()));
colSeq->setNumFrames(frame + 1);
CollisionLinkPairListPtr collisionPairs = boost::make_shared<CollisionLinkPairList>();
updateCollision(state, collisionPairs.get());
for(int i=lastFrame; i <= frame; ++i){
CollisionSeq::Frame collisionPairs0 = colSeq->frame(i);
collisionPairs0[0] = collisionPairs;
}
forEachBody(state, boost::bind(&OpenHRPOnlineViewerItemImpl::updateLog, this, _1, _2, _3, _4));
}
static void forEachTargetBodyItem(boost::function<void(BodyItem*)> callback)
{
ItemTreeView* itemTreeView = ItemTreeView::instance();
ItemList<BodyItem> bodyItems;
bodyItems.extractChildItems(RootItem::instance());
for(int i=0; i < bodyItems.size(); ++i){
BodyItem* bodyItem = bodyItems.get(i);
bool isTarget = itemTreeView->isItemSelected(bodyItem);
if(!isTarget){
WorldItem* worldItem = bodyItem->findOwnerItem<WorldItem>();
if(worldItem && itemTreeView->isItemSelected(worldItem)){
isTarget = true;
}
}
if(isTarget){
callback(bodyItem);
}
}
}
/**
\todo use cache of the cloned scene graph nodes
*/
void VisionRenderer::initializeScene(const vector<SimulationBody*>& simBodies)
{
sceneGroup = new SgGroup;
#ifndef CNOID_REFERENCED_USE_ATOMIC_COUNTER
simImpl->cloneMap.clear();
#endif
// create scene bodies
for(size_t i=0; i < simBodies.size(); ++i){
SceneBody* sceneBody = new SceneBody(simBodies[i]->body());
#ifndef CNOID_REFERENCED_USE_ATOMIC_COUNTER
sceneBody->cloneShapes(simImpl->cloneMap);
#endif
sceneBodies.push_back(sceneBody);
sceneGroup->addChild(sceneBody);
}
if(simImpl->shootAllSceneObjects){
WorldItem* worldItem = simImpl->self->findOwnerItem<WorldItem>();
if(worldItem){
ItemList<> items;
items.extractChildItems(worldItem);
for(size_t i=0; i < items.size(); ++i){
Item* item = items.get(i);
SceneProvider* sceneProvider = dynamic_cast<SceneProvider*>(item);
if(sceneProvider && !dynamic_cast<BodyItem*>(item)){
SgNode* scene = sceneProvider->getScene(simImpl->cloneMap);
if(scene){
sceneGroup->addChild(scene);
}
}
}
}
}
}
