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);
}
