void rePlayer::afterLoad()
{
btTransform transform; transform.setIdentity();
body->compoundShape->addChildShape(transform, new btSphereShape(0.7f));
observe(reRadial::shared()->input(), reM_KEY_PRESS);
observe(reRadial::shared()->input(), reM_KEY_UP);
observe(reRadial::shared(), reM_TIMER);
/*
btTransform transform; transform.setIdentity();
transform.setRotation(btQuaternion(0,glm::radians(90.0f),0));
transform.setOrigin(btVector3(0.3f,0,0));
body->compoundShape->addChildShape(transform, new btCapsuleShape(.3f, 1.0f));
transform.setOrigin(btVector3(-0.3f,0,0));
body->compoundShape->addChildShape(transform, new btCapsuleShape(.3f, 1.0f));
body->btBody->setCcdMotionThreshold(1e-7f);
body->btBody->setCcdSweptSphereRadius(0.5f);
body->btBody->setDamping(0.0f, 1.0f);
body->btBody->setAnisotropicFriction(btVector3(1,0,0));
*/
body->btBody->setAngularFactor(0);
body->btBody->setCcdMotionThreshold(0.01);
body->btBody->setCcdSweptSphereRadius(0.8f);
//body->btBody->setCenterOfMassTransform(btTransform::getIdentity());
//body->btBody->setDamping(0, 100000);
}
reViewport::reViewport(reViewportWidget* widget)
{
_trackMouse = true;
viewCamera = camera = new rePointCamera();
camera->name("Viewport");
camera->angles(reVec3(-45, -45, 0));
camera->distance(10);
this->widget = widget;
label = new reText();
label->font("fonts/arial.fnt");
label->text("Utku'dan selamlar!");
surface = new reSurfaceNode();
surface->renderables->add(label);
bottomLabel = new reText();
bottomLabel->font("fonts/arial.fnt");
bottomLabel->text("FPS");
bottomSurface = new reSurfaceNode();
bottomSurface ->renderables->add(bottomLabel);
observe(surface, reM_MOUSE_PRESS);
observe(surface, reM_MOUSE_RELEASE);
tracking = false;
perspective(true);
QAction* act;
contextMenu = new QMenu();
act = new QAction("Top", this); act->setData((int)Top);
connect(act, SIGNAL(triggered()), SLOT(camKindActionTiggered()));
contextMenu->addAction(act);
act = new QAction("Left", this); act->setData((int)Left);
connect(act, SIGNAL(triggered()), SLOT(camKindActionTiggered()));
contextMenu->addAction(act);
act = new QAction("Bottom", this); act->setData((int)Bottom);
connect(act, SIGNAL(triggered()), SLOT(camKindActionTiggered()));
contextMenu->addAction(act);
act = new QAction("Right", this); act->setData((int)Right);
connect(act, SIGNAL(triggered()), SLOT(camKindActionTiggered()));
contextMenu->addAction(act);
contextMenu->addSeparator();
act = new QAction("Perspective", this); act->setCheckable(true);
connect(act, SIGNAL(triggered(bool)), SLOT(perspectiveActionTriggered(bool)));
act->setChecked(perspective());
contextMenu->addAction(act);
cameraMenu = contextMenu->addMenu("Camera");
_overNode = 0;
renderer = new reRenderer();
}
void DoubleThresholdImageFilterITK::doubleThresholdImageFilterITK() {
insideValue_.setVolume(inport1_.getData());
outsideValue_.setVolume(inport1_.getData());
threshold1_.setVolume(inport1_.getData());
threshold2_.setVolume(inport1_.getData());
threshold3_.setVolume(inport1_.getData());
threshold4_.setVolume(inport1_.getData());
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::DoubleThresholdImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetInsideValue(insideValue_.getValue<T>());
filter->SetOutsideValue(outsideValue_.getValue<T>());
filter->SetThreshold1(threshold1_.getValue<T>());
filter->SetThreshold2(threshold2_.getValue<T>());
filter->SetThreshold3(threshold3_.getValue<T>());
filter->SetThreshold4(threshold4_.getValue<T>());
filter->SetFullyConnected(fullyConnected_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
// ---
void QGAMES::Scene::setMap (int nm)
{
if (nm == __MININT__)
{
if (_activeMap != NULL)
{
unObserve (_activeMap);
_activeMap -> setScene (NULL);
_activeMap = NULL;
}
}
else
{
QGAMES::Maps::const_iterator i = _maps.find (nm);
assert (i != _maps.end ());
if (_activeMap != NULL)
{
unObserve (_activeMap);
_activeMap -> setScene (NULL);
}
_activeMap = (*i).second;
_activeMap -> setScene (this);
observe (_activeMap);
}
}
static void preload_keys()
{
const gchar *plugin_keys;
if (ohm_plugin_p == NULL) {
OHM_ERROR("GConf: Ohm plugin was NULL!");
return;
}
plugin_keys = (char *) ohm_plugin_get_param(ohm_plugin_p, "keys");
if (plugin_keys != NULL) {
gchar **keys = NULL, **key_iter = NULL;
keys = g_strsplit(plugin_keys, GCONF_STRING_DELIMITER, 0);
for (key_iter = keys; *key_iter != NULL; key_iter++) {
observe(gconf_plugin_p, *key_iter);
}
g_strfreev(keys);
}
return;
}
Volume* DoubleThreshold::doubleThreshold(const VolumeBase* inputVolume, T t1, T t2, T t3, T t4) {
typedef itk::Image<T, 3> InputImageType;
typedef itk::Image<uint8_t, 3> OutputImageType;
typename InputImageType::Pointer p = voreenToITK<T>(inputVolume);
// define the fillhole filter
typedef itk::DoubleThresholdImageFilter<InputImageType, OutputImageType> DoubleThresholdFilterType;
// Create the filter
typename DoubleThresholdFilterType::Pointer threshold = DoubleThresholdFilterType::New();
// Setup the fillhole method
threshold->SetInput(p);
threshold->SetInsideValue(255);
threshold->SetOutsideValue(0);
threshold->SetThreshold1(t1);
threshold->SetThreshold2(t2);
threshold->SetThreshold3(t3);
threshold->SetThreshold4(t4);
observe(threshold.GetPointer());
// Run the filter
threshold->Update();
return ITKToVoreenCopy<uint8_t>(threshold->GetOutput());
}
int Resource::seize(Arrival* arrival, int amount) {
int status;
// serve now
if (room_in_server(amount, arrival->order.get_priority())) {
if (arrival->is_monitored()) {
arrival->set_start(this->name, sim->now());
arrival->set_activity(this->name, sim->now());
}
insert_in_server(sim->verbose, sim->now(), arrival, amount);
status = SUCCESS;
}
// enqueue
else if (room_in_queue(amount, arrival->order.get_priority())) {
if (arrival->is_monitored()) {
arrival->set_start(this->name, sim->now());
arrival->set_activity(this->name, 0);
}
insert_in_queue(sim->verbose, sim->now(), arrival, amount);
status = ENQUEUED;
}
// reject
else {
if (sim->verbose) verbose_print(sim->now(), arrival->name, "REJECT");
return REJECTED;
}
if (is_monitored()) observe(sim->now());
return status;
}
int Resource::post_release() {
// serve another
while (queue_count)
if (!try_serve_from_queue(sim->verbose, sim->now())) break;
if (is_monitored()) observe(sim->now());
return SUCCESS;
}
OCStackResult OCResource::observe(ObserveType observeType,
const QueryParamsMap& queryParametersMap, ObserveCallback observeHandler)
{
QualityOfService defaultQoS = OC::QualityOfService::NaQos;
checked_guard(m_clientWrapper.lock(), &IClientWrapper::GetDefaultQos, defaultQoS);
return result_guard(observe(observeType, queryParametersMap, observeHandler, defaultQoS));
}
FileSystemObserver::FileSystemObserver(boost::asio::io_service& ioService) {
try {
mDirectoryMonitor.reset(new boost::asio::dir_monitor(ioService));
observe();
} catch (const boost::exception& e) {
S_LOG_WARNING("Could not initialize file system observer; probably due to running out of file descriptors.");
}
}
// ---
QGAMES::TileLayer::TileLayer (int c, const std::string& n, const QGAMES::Tiles& t,
QGAMES::Map* m, const QGAMES::LayerProperties& p, bool oT)
: QGAMES::Layer (c, n, m, p),
_tiles (t)
{
if (oT) // If the tiles have to be observed...by default they aren't
for (QGAMES::Tiles::const_iterator i = _tiles.begin (); i != _tiles.end (); i++)
observe ((*i));
}
void SignedDanielssonDistanceMapImageFilterITK::signedDanielssonDistanceMapImageFilterITK() {
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typedef itk::Image<T, 3> OutputImageType2;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::SignedDanielssonDistanceMapImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetInsideIsPositive(insideIsPositive_.get());
filter->SetSquaredDistance(squaredDistance_.get());
filter->SetUseImageSpacing(useImageSpacing_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetDistanceMap());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
Volume* outputVolume2 = 0;
outputVolume2 = ITKToVoreenCopy<T>(filter->GetVoronoiMap());
if (outputVolume2) {
transferRWM(inport1_.getData(), outputVolume2);
transferTransformation(inport1_.getData(), outputVolume2);
outport2_.setData(outputVolume2);
} else
outport2_.setData(0);
}
// ---
void QGAMES::BoardElement::assignResource (QGAMES::BoardResource* rsce)
{
assert (rsce); // It has to be no null...
QGAMES::BoardResources::const_iterator i = _resources.find (rsce -> id ());
assert (i == _resources.end ()); // It has not to exist already...
_resources.insert (BoardResources::value_type (rsce -> id (), rsce));
observe (rsce); // The resource has to be observe...
whenAssignResource (rsce);
}
void DiscreteGaussianImageFilterITK::discreteGaussianImageFilterITK() {
maximumError_.setVolume(inport1_.getData());
maximumError_.setMinValue<T>(1.0f);
variance_.setVolume(inport1_.getData());
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<float, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::DiscreteGaussianImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetInternalNumberOfStreamDivisions(internalNumberOfStreamDivisions_.get());
filter->SetMaximumError(maximumError_.getValue<T>());
filter->SetVariance(variance_.getValue<T>());
filter->SetUseImageSpacing(useImageSpacing_.get());
filter->SetFilterDimensionality(filterDimensionality_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<float>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void BayesianClassifierImageFilterITK::bayesianClassifierImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType;
typedef itk::Image<uint8_t, 3> OutputImageType;
typedef itk::VectorImage<float, 3> VectorImageType;
typename InputImageType::Pointer p1 = voreenToITK<T>(inport1_.getData());
typedef itk::BayesianClassifierInitializationImageFilter<InputImageType> InitFilterType;
typename InitFilterType::Pointer initializer = InitFilterType::New();
initializer->SetInput(p1);
initializer->SetNumberOfClasses(numberOfClasses_.get());
try
{
initializer->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
//Filter define
typedef itk::BayesianClassifierImageFilter<VectorImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(0, initializer->GetOutput());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<uint8_t>(filter->GetOutput());
if (outputVolume1) {
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
}
else
outport1_.setData(0);
}
void IntensityWindowingImageFilterITK::intensityWindowingImageFilterITK() {
outputMinimum_.setVolume(inport1_.getData());
outputMaximum_.setVolume(inport1_.getData());
windowMinimum_.setVolume(inport1_.getData());
windowMaximum_.setVolume(inport1_.getData());
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::IntensityWindowingImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetOutputMinimum(outputMinimum_.getValue<T>());
filter->SetOutputMaximum(outputMaximum_.getValue<T>());
filter->SetWindowMinimum(windowMinimum_.getValue<T>());
filter->SetWindowMaximum(windowMaximum_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
// ---
void QGAMES::Scene::addCharacter (QGAMES::Character* c)
{
assert (c);
Entities::const_iterator i = _characteres.find (c -> id ());
if (i != _characteres.end ())
return;
observe (c); // To observe what happens in the character...
_entities.insert (Entities::value_type (c -> id (), c));
}
// ---
void QGAMES::Scene::addEntity (QGAMES::Entity* e)
{
assert (e);
Entities::const_iterator i = _entities.find (e -> id ());
if (i != _entities.end ())
return;
observe (e); // To observe what happens in the entity...
_entities.insert (Entities::value_type (e -> id (), e));
}
void OtsuThresholdImageFilterITK::otsuThresholdImageFilterITK() {
outsideValue_.setVolume(inport1_.getData());
outsideValue_.setMinValue<T>(0.0001f);
insideValue_.setVolume(inport1_.getData());
insideValue_.setMinValue<T>(0.0001f);
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::OtsuThresholdImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetNumberOfHistogramBins(numberOfHistogramBins_.get());
filter->SetOutsideValue(outsideValue_.getValue<T>());
filter->SetInsideValue(insideValue_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void CustomElementUpgradeCandidateMap::add(const CustomElementDescriptor& descriptor, Element* element)
{
observe(element);
UpgradeCandidateMap::AddResult result = m_upgradeCandidates.add(element, descriptor);
ASSERT(result.isNewEntry);
UnresolvedDefinitionMap::iterator it = m_unresolvedDefinitions.find(descriptor);
if (it == m_unresolvedDefinitions.end())
it = m_unresolvedDefinitions.add(descriptor, ElementSet()).iterator;
it->value.add(element);
}
// ---
QGAMES::Scene::Scene (int c, const QGAMES::Maps& m, const QGAMES::Scenes& cn,
const QGAMES::SceneProperties& p, const QGAMES::EntitiesPerLayer& ePL)
: QGAMES::Element (c),
_maps (m),
_connections (cn),
_properties (p),
_activeMap (NULL),
_entitiesPerLayer (ePL)
{
for (Maps::const_iterator i = _maps.begin (); i != _maps.end (); i++)
observe ((*i).second);
}
MyObserver( uintptr_t flag )
: tbb::task_scheduler_observer(theTestMode & tmLocalObservation ? true : false)
, m_flag(flag)
, m_dying(false)
{
m_leave_ticket.store<tbb::relaxed>(0);
++theNumObservers;
Reset();
// Local observer causes automatic scheduler initialization
// in the current thread, so here, we must postpone the activation.
if ( !(theTestMode & tmLocalObservation) )
observe(true);
}
// ---
QGAMES::BoardElement::BoardElement (int id, const QGAMES::BoardResources& rscs,
const QGAMES::BoardElementProperties& pts)
: QGAMES::Element (id),
_resources (rscs),
_properties ()
{
for (QGAMES::BoardResources::const_iterator i = _resources.begin ();
i != _resources.end (); i++)
{
observe ((*i).second); // The resources are initially observed by the element (owner)
(*i).second -> setBoardElementSimple (this); // ...the resource is assigned to this element
}
}
void NarrowBandThresholdSegmentationLevelSetImageFilterITK::narrowBandThresholdSegmentationLevelSetImageFilterITK() {
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<S, 3> InputImageType2;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
typename InputImageType2::Pointer p2 = voreenToITK<S>(inport2_.getData());
//Filter define
typedef itk::NarrowBandThresholdSegmentationLevelSetImageFilter<InputImageType1, InputImageType2> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetFeatureImage(p2);
filter->SetPropagationScaling(propagationScaling_.get());
filter->SetCurvatureScaling(curvatureScaling_.get());
filter->SetAdvectionScaling(advectionScaling_.get());
filter->SetMaximumRMSError(maximumRMSError_.get());
filter->SetNumberOfIterations(numberOfIterations_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void RelabelComponentImageFilterITK::relabelComponentImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::RelabelComponentImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetMinimumObjectSize(minimumObjectSize_.get());
observe(filter.GetPointer());
try
{
filter->Update();
numberOfObjects_.set(filter->GetNumberOfObjects());
originalNumberOfObjects_.set(filter->GetOriginalNumberOfObjects());
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void GradientRecursiveGaussianImageFilterITK::gradientRecursiveGaussianImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<itk::CovariantVector<double,3>, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::GradientRecursiveGaussianImageFilter<InputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetNormalizeAcrossScale(normalizeAcrossScale_.get());
filter->SetUseImageDirection(useImageDirection_.get());
filter->SetSigma(sigma_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKVec3ToVoreenVec3Copy<double>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void ScalarConnectedComponentImageFilterITK::scalarConnectedComponentImageFilterITK() {
distanceThreshold_.setVolume(inport1_.getData());
distanceThreshold_.setMinValue<T>(0.001f);
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::ScalarConnectedComponentImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetDistanceThreshold(distanceThreshold_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void Resource::set_capacity(int value) {
if (capacity == value) return;
int last = capacity;
capacity = value;
if (capacity > last || capacity < 0) {
// serve another
while (queue_count)
if (!try_serve_from_queue(sim->verbose, sim->now())) break;
} else if (capacity < last) {
while (server_count > capacity)
if (!try_free_server(sim->verbose, sim->now())) break;
}
if (is_monitored()) observe(sim->now());
}
void GradientAnisotropicDiffusionImageFilterITK::gradientAnisotropicDiffusionImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::GradientAnisotropicDiffusionImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetNumberOfIterations(numberOfIterations_.get());
filter->SetTimeStep(timeStep_.get());
filter->SetConductanceParameter(conductanceParameter_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void LabelOverlayImageFilterITK::labelOverlayImageFilterITK() {
backgroundValue_.setVolume(inport1_.getData());
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<S, 3> InputImageType2;
typedef itk::Image<itk::CovariantVector<uint8_t,3>, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
typename InputImageType2::Pointer p2 = voreenToITK<S>(inport2_.getData());
//Filter define
typedef itk::LabelOverlayImageFilter<InputImageType1, InputImageType2, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetLabelImage(p2);
filter->SetOpacity(opacity_.get());
filter->SetBackgroundValue(backgroundValue_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKVec3ToVoreenVec3Copy<uint8_t>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
