void Object::removeObserver(Object& observer, EventID eventID) { if (!REGISTRY.contains(&observer)) { CLOG(TRACE, "EventSystem") << "Attempted to remove destroyed Observer " << observer << " for EventID 0x" << std::setbase(16) << std::setfill('0') << std::setw(8) << eventID << std::setw(0) << std::setbase(10) << ", ignoring"; return; } size_t removalCount = 0; if (eventID == EventID::All) { for (auto& eventObservers : m_eventObservers) { auto& observersSet = eventObservers.second; removalCount += observersSet.erase(&observer); } CLOG(TRACE, "EventSystem") << "Removed Observer " << observer << " for all Events"; } else { auto& observersSet = getObservers(eventID); Assert("EventSystem", (observersSet.size() > 0), "\nReason:\tattempted to remove an observer on event with no observers." << "\nSubject:\t" << *this << "\nObserver:\t" << observer << "\nEvent:\t" << eventID); removalCount = observersSet.erase(&observer); CLOG(TRACE, "EventSystem") << "Removed Observer " << observer << " for EventID 0x" << std::setbase(16) << std::setfill('0') << std::setw(8) << eventID << std::setw(0) << std::setbase(10); } if (removalCount == 0) { std::stringstream ss; ss << "Event " << eventID; CLOG(TRACE, "EventSystem") << "Tried to remove Observer " << observer << " of Subject " << *this << ", but it was not registered for " << ((eventID == EventID::All) ? "any Events" : ss.str()); } Registration e; e.state = Registration::State::Unregistered; e.subject = this; for (int i = 0; i < removalCount; i++) { observer.onEvent_NV(e); } }
uint32_t Config::startFrame() { // Get time, in milliseconds. Can be used for animation purposes. frame_data.data.timestamp = getTime(); // Set viewer head position and orientation eq::Matrix4f head_matrix = eq::Matrix4f::IDENTITY; // DO HEAD TRACKING HERE // If you want to do fancy stuff like head tracking, this is // the place you would want to do it. Just adjust head_matrix // accordingly head_matrix.set_translation( frame_data.data.camera_pos[0], frame_data.data.camera_pos[1], frame_data.data.camera_pos[2]); eq::Observer *first_observer = getObservers().at(0); first_observer->setHeadMatrix(head_matrix); // Commit new version of updated frame data const eq::uint128_t version = frame_data.commit(); // Start this frame with the committed frame data return eq::Config::startFrame(version); }
//--------------------------------------------------------------------------- // update running entities (init/exit/runtime change) //--------------------------------------------------------------------------- bool Config::_updateRunning( const bool canFail ) { if( _state == STATE_STOPPED ) return true; LBASSERT( _state == STATE_RUNNING || _state == STATE_INITIALIZING || _state == STATE_EXITING ); if( !_connectNodes() && !canFail ) return false; _startNodes(); _updateCanvases(); const bool result = _updateNodes( canFail ); _stopNodes(); // Don't use visitor, it would get confused with modified child vectors _deleteEntities( getCanvases( )); _deleteEntities( getLayouts( )); _deleteEntities( getObservers( )); const Nodes& nodes = getNodes(); for( Nodes::const_iterator i = nodes.begin(); i != nodes.end(); ++i ) { const Pipes& pipes = (*i)->getPipes(); for( Pipes::const_iterator j = pipes.begin(); j != pipes.end(); ++j ) { const Windows& windows = (*j)->getWindows(); _deleteEntities( windows ); } } return result; }
void VolumeCollection::notifyVolumeAdded(const VolumeHandle* handle) { const vector<VolumeCollectionObserver*> observers = getObservers(); for (size_t i=0; i<observers.size(); ++i) observers[i]->volumeAdded(this, handle); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void BFReconstructionEngine::writeMRCFile(const std::string& mrcFile, uint16_t cropStart, uint16_t cropEnd) { /* Write the output to the MRC File */ std::stringstream ss; ss.str(""); ss << "Writing MRC file to '" << mrcFile << "'"; notify(ss.str(), 0, Observable::UpdateProgressMessage); MRCWriter::Pointer mrcWriter = MRCWriter::New(); mrcWriter->setOutputFile(mrcFile); mrcWriter->setGeometry(m_Geometry); mrcWriter->setAdvParams(m_AdvParams); mrcWriter->setXDims(cropStart, cropEnd); mrcWriter->setYDims(0, m_Geometry->N_y); mrcWriter->setZDims(0, m_Geometry->N_z); mrcWriter->setObservers(getObservers()); mrcWriter->execute(); if(mrcWriter->getErrorCondition() < 0) { ss.str(""); ss << "Error writing MRC file\n '" << mrcFile << "'" << std::endl; setErrorCondition(mrcWriter->getErrorCondition()); notify(ss.str(), 0, Observable::UpdateErrorMessage); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void BFReconstructionEngine::writeAvizoFile(const std::string& file, uint16_t cropStart, uint16_t cropEnd) { // std::cout << "Writing Avizo file " << file << std::endl; /* Write the output to the Avizo File */ std::stringstream ss; ss.str(""); ss << "Writing Avizo file to '" << file << "'"; notify(ss.str(), 0, Observable::UpdateProgressMessage); AvizoUniformCoordinateWriter::Pointer writer = AvizoUniformCoordinateWriter::New(); writer->setOutputFile(file); writer->setGeometry(m_Geometry); writer->setAdvParams(m_AdvParams); writer->setTomoInputs(m_TomoInputs); writer->setXDims(cropStart, cropEnd); writer->setYDims(0, m_Geometry->N_y); writer->setZDims(0, m_Geometry->N_z); writer->setObservers(getObservers()); writer->setWriteBinaryFile(true); writer->execute(); if(writer->getErrorCondition() < 0) { ss.str(""); ss << "Error writing Avizo file\n '" << file << "'" << std::endl; setErrorCondition(writer->getErrorCondition()); notify(ss.str(), 0, Observable::UpdateErrorMessage); } }
const eq::Matrix4f& Config::_getHeadMatrix() const { const eq::Observers& observers = getObservers(); if( observers.empty( )) return eq::Matrix4f::IDENTITY; return observers[0]->getHeadMatrix(); }
// Note: real applications would use one tracking device per observer void Config::_setHeadMatrix( const eq::Matrix4f& matrix ) { const eq::Observers& observers = getObservers(); for( eq::Observers::const_iterator i = observers.begin(); i != observers.end(); ++i ) { (*i)->setHeadMatrix( matrix ); } }
void Render::notifyUpdate() { const std::vector<IUpdatable*> observers = getObservers(); std::vector<IUpdatable*>::const_iterator iter = observers.begin(); for (; iter != observers.end(); ++iter) { (*iter)->udpate(); } }
void TemplatePropertyTimeline<Camera>::redo() { lastChanges_.push_back(timeline_); timeline_ = new CameraPropertyTimelineState(lastUndos_.back()->getKeyValues()); lastUndos_.pop_back(); const std::vector<TimelineObserver*> timelineObservers = getObservers(); std::vector<TimelineObserver*>::const_iterator it; for (it = timelineObservers.begin(); it != timelineObservers.end(); ++it) (*it)->timelineChanged(); }
void Config::_setFocusMode( const eq::FocusMode mode ) { const eq::Observers& observers = getObservers(); for( eq::ObserversCIter i = observers.begin(); i != observers.end(); ++i ) (*i)->setFocusMode( mode ); std::ostringstream stream; stream << "Set focus mode to " << mode; _setMessage( stream.str( )); }
bool DroidObjectImplementation::sendConversationStartTo(SceneObject* player) { if (!player->isPlayerCreature() || isDead()) return false; if (player != getLinkedCreature().get()) return false; BaseDroidModuleComponent* m = getModule("personality_chip"); if (m == NULL) { return false; } DroidPersonalityModuleDataComponent* personality = dynamic_cast<DroidPersonalityModuleDataComponent*>(m); if (personality == NULL) { return false; } if (personality->getPersonalityConversationTemplate() == 0) { return false; } //Face player. faceObject(player); PatrolPoint current(coordinates.getPosition(), getParent().get()); broadcastNextPositionUpdate(¤t); CreatureObject* playerCreature = cast<CreatureObject*>( player); StartNpcConversation* conv = new StartNpcConversation(playerCreature, getObjectID(), ""); player->sendMessage(conv); SortedVector<ManagedReference<Observer*> > observers = getObservers(ObserverEventType::STARTCONVERSATION); for (int i = 0; i < observers.size(); ++i) { if (dynamic_cast<ConversationObserver*>(observers.get(i).get()) != NULL) { return true; } } //Create conversation observer. ConversationObserver* conversationObserver = ConversationManager::instance()->getConversationObserver(personality->getPersonalityConversationTemplate()); if (conversationObserver != NULL) { //Register observers. registerObserver(ObserverEventType::CONVERSE, conversationObserver); registerObserver(ObserverEventType::STARTCONVERSATION, conversationObserver); registerObserver(ObserverEventType::SELECTCONVERSATION, conversationObserver); registerObserver(ObserverEventType::STOPCONVERSATION, conversationObserver); } else { error("Could not create conversation observer."); return false; } return true; }
void Config::_changeFocusDistance( const float delta ) { const eq::Observers& observers = getObservers(); for( eq::ObserversCIter i = observers.begin(); i != observers.end(); ++i ) { eq::Observer* observer = *i; observer->setFocusDistance( observer->getFocusDistance() + delta ); std::ostringstream stream; stream << "Set focus distance to " << observer->getFocusDistance(); _setMessage( stream.str( )); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GenerateSurfaceMeshConnectivity::execute() { int err = 0; std::stringstream ss; setErrorCondition(err); VoxelDataContainer* m = getVoxelDataContainer(); if(NULL == m) { setErrorCondition(-999); notifyErrorMessage("The Voxel DataContainer Object was NULL", -999); return; } setErrorCondition(0); dataCheck(false, 1, 1, 1); if (getErrorCondition() < 0) { return; } // We need the vertex->Triangle Lists to build the Triangle Neighbor lists so if either // of those are true then build the vertex->triangle lists if (m_GenerateVertexTriangleLists == true || m_GenerateTriangleNeighbors == true) { notifyStatusMessage("Generating Vertex Triangle List"); getSurfaceMeshDataContainer()->buildMeshVertLinks(); } if (m_GenerateTriangleNeighbors == true) { notifyStatusMessage("Generating Face Neighbors List"); getSurfaceMeshDataContainer()->buildMeshFaceNeighborLists(); } if (m_GenerateEdgeIdList == true) { // There was no Edge connectivity before this filter so delete it when we are done with it GenerateUniqueEdges::Pointer conn = GenerateUniqueEdges::New(); ss.str(""); ss << getMessagePrefix() << " |->Generating Unique Edge Ids |->"; conn->setMessagePrefix(ss.str()); conn->setObservers(getObservers()); conn->setVoxelDataContainer(getVoxelDataContainer()); conn->setSurfaceMeshDataContainer(getSurfaceMeshDataContainer()); conn->setSolidMeshDataContainer(getSolidMeshDataContainer()); conn->execute(); if(conn->getErrorCondition() < 0) { setErrorCondition(conn->getErrorCondition()); return; } } /* Let the GUI know we are done with this filter */ notifyStatusMessage("Complete"); }
void Config::_adjustEyeBase( const float delta ) { const eq::Observers& observers = getObservers(); for( eq::ObserversCIter i = observers.begin(); i != observers.end(); ++i ) { eq::Observer* observer = *i; observer->setEyeBase( observer->getEyeBase() + delta ); std::ostringstream stream; stream << "Set eye base to " << observer->getEyeBase(); _setMessage( stream.str( )); } }
// Note: real applications would use one tracking device per observer void Config::_setHeadMatrix( const eq::Matrix4f& matrix ) { const eq::Observers& observers = getObservers(); for( eq::ObserversCIter i = observers.begin(); i != observers.end(); ++i ) { (*i)->setHeadMatrix( matrix ); } eq::Vector3f trans; matrix.get_translation( trans ); std::ostringstream stream; stream << "Observer at " << trans; _setMessage( stream.str( )); }
void PropertyOwner::removeProperty(Property* prop) { tgtAssert(prop, "Null pointer passed"); if (!getProperty(prop->getID())) { LERROR(getName() << ": Property '" << prop->getID() << "' cannot be removed, it does not exist"); } // inform the observers to prepare property removal // thus all links can be removed in the processornetwork std::vector<PropertyOwnerObserver*> observers = getObservers(); for (size_t i = 0; i < observers.size(); ++i) observers[i]->preparePropertyRemoval(prop); prop->setOwner(0); properties_.erase(find(properties_.begin(), properties_.end(), prop)); }
DeleteKeyValueReturn TemplatePropertyTimeline<Camera>::deleteKeyValue(const PropertyKeyValue<Camera>* keyvalue) { timelineChanged_ = true; lastChanges_.push_back(timeline_->clone()); undoObserver_->animationChanged(this); DeleteKeyValueReturn temp = timeline_->deleteKeyValue(keyvalue); const std::vector<TimelineObserver*> timelineObservers = getObservers(); std::vector<TimelineObserver*>::const_iterator it; for (it = timelineObservers.begin(); it != timelineObservers.end(); ++it) (*it)->timelineChanged(); return temp; }
bool TemplatePropertyTimeline<Camera>::changeValueOfKeyValue(Camera value, const PropertyKeyValue<Camera>* keyvalue) { tgtAssert(property_, "No property"); timelineChanged_ = true; std::string errorMsg; if (!property_->isValidValue(value, errorMsg)) return false; bool temp = timeline_->changeValueOfKeyValue(value, keyvalue); const std::vector<TimelineObserver*> timelineObservers = getObservers(); std::vector<TimelineObserver*>::const_iterator it; for (it = timelineObservers.begin(); it != timelineObservers.end(); ++it) (*it)->timelineChanged(); return temp; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void BFReconstructionEngine::writeReconstructionFile(const std::string& filepath) { // Write the Reconstruction out to a file RawGeometryWriter::Pointer writer = RawGeometryWriter::New(); writer->setGeometry(m_Geometry); writer->setFilePath(filepath); writer->setAdvParams(m_AdvParams); writer->setObservers(getObservers()); writer->execute(); if (writer->getErrorCondition() < 0) { setErrorCondition(writer->getErrorCondition()); notify("Error Writing the Raw Geometry", 100, Observable::UpdateProgressValueAndMessage); } }
void Config::_adjustEyeBase( const float delta ) { const eq::Observers& observers = getObservers(); for( eq::ObserversCIter i = observers.begin(); i != observers.end(); ++i ) { eq::Observer* observer = *i; observer->setEyePosition( eq::EYE_LEFT, observer->getEyePosition( eq::EYE_LEFT ) + eq::Vector3f( -delta, 0.f, 0.f )); observer->setEyePosition( eq::EYE_RIGHT, observer->getEyePosition( eq::EYE_RIGHT ) + eq::Vector3f( delta, 0.f, 0.f )); std::ostringstream stream; stream << "Set eyes to " << observer->getEyePosition( eq::EYE_LEFT ) << ", " << observer->getEyePosition( eq::EYE_RIGHT ); _setMessage( stream.str( )); } }
void Animation::processorAdded(const Processor *processor) { // called if a new processor is added to the rendernetwork AnimatedProcessor* proc = new AnimatedProcessor(const_cast<Processor*>(processor)); processors_.push_back(proc); // registration of this class for undo / redo at the new propertytimelines const std::vector<PropertyTimeline*>& timelines = proc->getPropertyTimelines(); std::vector<PropertyTimeline*>::const_iterator it2; for (it2 = timelines.begin(); it2 != timelines.end(); ++it2) { (*it2)->registerUndoObserver(this); } // inform animationobservers of the new processor const std::vector<AnimationObserver*> observer = getObservers(); std::vector<AnimationObserver*>::const_iterator it; for (it = observer.begin(); it != observer.end(); ++it) { (*it)->animatedProcessorAdded(proc); } }
void TemplatePropertyTimeline<Camera>::resetTimeline() { timelineChanged_ = true; lastChanges_.push_back(timeline_); undoObserver_->animationChanged(this); tgt::Camera cam = property_->get(); /* Camera* node0 = new Camera(cam->getPosition(), cam->getFocus(), cam->getUpVector(), cam->getStrafe()); node0->setNodeIdentifier("Node 0"); node0->setDirection(node0->getStrafe()); */ Camera node0 = Camera(cam); timeline_ = new CameraPropertyTimelineState(new PropertyKeyValue<Camera>(node0,0)); const std::vector<TimelineObserver*> timelineObservers = getObservers(); std::vector<TimelineObserver*>::const_iterator it; for (it = timelineObservers.begin(); it != timelineObservers.end(); ++it) { (*it)->timelineChanged(); } }
// ----------------------------------------------------------------------------- // Read the Input data from the supplied data file // ----------------------------------------------------------------------------- int BFReconstructionEngine::readInputData() { TomoFilter::Pointer dataReader = TomoFilter::NullPointer(); std::string extension = MXAFileInfo::extension(m_TomoInputs->sinoFile); if(extension.compare("bin") == 0) { dataReader = RawSinogramInitializer::NewTomoFilter(); } else // if(extension.compare("mrc") == 0 || extension.compare("ali") == 0) { // We are going to assume that the user has selected a valid MRC file to get this far so we are just going to try // to read the file as an MRC file which may really cause issues but there does not seem to be any standard file // extensions for MRC files. dataReader = MRCSinogramInitializer::NewTomoFilter(); } // { // setErrorCondition(-1); // notify("A supported file reader for the input file was not found.", 100, Observable::UpdateErrorMessage); // return -1; // } dataReader->setTomoInputs(m_TomoInputs); dataReader->setSinogram(m_Sinogram); dataReader->setAdvParams(m_AdvParams); dataReader->setObservers(getObservers()); dataReader->setVerbose(getVerbose()); dataReader->setVeryVerbose(getVeryVerbose()); dataReader->execute(); if(dataReader->getErrorCondition() < 0) { std::stringstream ss; ss << "Error reading the input file: '" << m_TomoInputs->sinoFile << "'. MBIR currently considers .bin as a raw binary file " << "and any other file as an MRC input file. If this is NOT the case for your data consider contacting the developers " << " of this software."; notify(ss.str(), 100, Observable::UpdateErrorMessage); setErrorCondition(dataReader->getErrorCondition()); return -1; } return 0; }
const PropertyKeyValue<Camera>* TemplatePropertyTimeline<Camera>::newKeyValue(float time) { time = floor(time * 10000.f) / 10000.f; if (time > duration_) { timelineChanged_ = false; return 0; } lastChanges_.push_back(timeline_->clone()); undoObserver_->animationChanged(this); const PropertyKeyValue<Camera>* kv = timeline_->newKeyValue(time); const std::vector<TimelineObserver*> timelineObservers = getObservers(); std::vector<TimelineObserver*>::const_iterator it; for (it = timelineObservers.begin(); it != timelineObservers.end(); ++it) { (*it)->timelineChanged(); } return kv; }
void TemplatePropertyTimeline<TransFunc*>::resetTimeline() { timelineChanged_ = true; lastChanges_.push_back(timeline_); undoObserver_->animationChanged(this); TransFunc* func = property_->get(); if (func) func = func->clone(); else { func = new TransFuncIntensity(); property_->set(func->clone()); } timeline_ = new TransFuncPropertyTimelineState(new PropertyKeyValue<TransFunc*>(func,0)); const std::vector<TimelineObserver*> timelineObservers = getObservers(); std::vector<TimelineObserver*>::const_iterator it; for (it = timelineObservers.begin(); it != timelineObservers.end(); ++it) { (*it)->timelineChanged(); } }
// ----------------------------------------------------------------------------- // Initialize the Geometry data from a rough reconstruction // ----------------------------------------------------------------------------- int BFReconstructionEngine::initializeRoughReconstructionData() { InitialReconstructionInitializer::Pointer geomInitializer = InitialReconstructionInitializer::NullPointer(); std::string extension = MXAFileInfo::extension(m_TomoInputs->initialReconFile); if (m_TomoInputs->initialReconFile.empty() == true) { // This will just initialize all the values to Zero (0) or a DefaultValue Set by user geomInitializer = InitialReconstructionInitializer::New(); } else if (extension.compare("bin") == 0 ) { // This will read the values from a binary file geomInitializer = InitialReconstructionBinReader::NewInitialReconstructionInitializer(); } else if (extension.compare("mrc") == 0) { notify("We are not dealing with mrc volume files.", 0, Observable::UpdateErrorMessage); return -1; } else { notify("Could not find a compatible reader for the initial reconstruction data file. The program will now end.", 0, Observable::UpdateErrorMessage); return -1; } geomInitializer->setSinogram(m_Sinogram); geomInitializer->setTomoInputs(m_TomoInputs); geomInitializer->setGeometry(m_Geometry); geomInitializer->setAdvParams(m_AdvParams); geomInitializer->setObservers(getObservers()); geomInitializer->setVerbose(getVerbose()); geomInitializer->setVeryVerbose(getVeryVerbose()); geomInitializer->execute(); if(geomInitializer->getErrorCondition() < 0) { notify("Error reading Initial Reconstruction Data from File", 100, Observable::UpdateProgressValueAndMessage); setErrorCondition(geomInitializer->getErrorCondition()); return -1; } return 0; }
void Object::addObserver(Object& observer, EventID eventID) { if (!REGISTRY.contains(&observer)) { CLOG(WARNING, "EventSystem") << "Attempted to add destroyed Observer " << observer << " for EventID 0x" << std::setbase(16) << std::setfill('0') << std::setw(8) << eventID << std::setw(0) << std::setbase(10) << ", skipping"; return; } if (eventID == EventID::All) { for (auto& pair : m_eventObservers) { addObserver(observer, pair.first); } } else { Assert("EventSystem", !observerIsObservingEvent(observer, eventID), "\nReason:\tattempted to add an observer for an event it is already observing." << "\nSubject:\t" << *this << "\nObserver:\t" << observer << "\nEvent:\t" << eventID); auto& observersSet = getObservers(eventID); observersSet.insert(&observer); Registration e; e.state = Registration::State::Registered; e.subject = this; CLOG(TRACE, "EventSystem") << "Added Observer " << observer << " for EventID 0x" << std::setbase(16) << std::setfill('0') << std::setw(8) << eventID << std::setw(0) << std::setbase(10); observer.onEvent_NV(e); } }
//--------------------------------------------------------------------------- // init //--------------------------------------------------------------------------- bool Config::_init( const uint128_t& initID ) { LBASSERT( _state == STATE_STOPPED ); _state = STATE_INITIALIZING; _currentFrame = 0; _finishedFrame = 0; _initID = initID; for( auto compound : _compounds ) compound->init(); for( auto observer : getObservers( )) observer->init(); for( auto canvas : getCanvases( )) canvas->init(); const auto& layouts = getLayouts(); for( auto layout : layouts ) for( auto view : layout->getViews( )) view->init(); // any of the above entities might have been updated commit(); if( !_updateRunning( false )) return false; // Needed to set up active state for first LB update for( CompoundsCIter i = _compounds.begin(); i != _compounds.end(); ++i ) (*i)->update( 0 ); // Update equalizer properties in views UpdateEqualizersVisitor updater; accept( updater ); _needsFinish = false; _state = STATE_RUNNING; return true; }
void VolumeList::notifyVolumeChanged(const VolumeBase* handle) { const vector<VolumeListObserver*> observers = getObservers(); for (size_t i=0; i<observers.size(); ++i) observers[i]->volumeChanged(this, handle); }