static gint
progress_end_cb(GWEN_GUI *gwen_gui, guint32 id)
{
GncGWENGui *gui = GETDATA_GUI(gwen_gui);
Progress *progress;
g_return_val_if_fail(gui, -1);
g_return_val_if_fail(id == g_list_length(gui->progresses), -1);
ENTER("gui=%p, id=%d", gui, id);
if (gui->state != RUNNING)
{
/* Ignore finishes of progresses we do not track */
LEAVE("not running anymore");
return 0;
}
/* Hide progress */
progress = (Progress*) gui->progresses->data;
hide_progress(gui, progress);
/* Remove progress from stack and free memory */
gui->progresses = g_list_delete_link(gui->progresses, gui->progresses);
free_progress(progress, NULL);
if (!gui->progresses)
{
/* top-level progress finished */
set_finished(gui);
}
LEAVE(" ");
return 0;
}
void ts::scene::Loading_sequence::async_load(const action::Stage* stage)
{
loaded_scene_ = Scene();
exception_ptr_ = nullptr;
stage_ = stage;
set_finished(false);
set_loading(true);
scene_loader_.set_completion_handler([this]()
{
load_scripts_if_ready();
});
scene_loader_.set_state_change_handler([this](Scene_loader_state new_state)
{
state_change(to_string(new_state));
});
audio_loader_.set_completion_handler([this]()
{
load_scripts_if_ready();
});
scene_loader_.async_load(stage, resource_store_->video_settings());
audio_loader_.async_load(stage, resource_store_->audio_settings());
}
FakeWmtsReply(const QcTileSpec & tile_spec)
: QcWmtsReply(tile_spec)
{
if (!m_bytes.size()) {
QFile file("../wmts.jpg"); // Fixme
file.open(QIODevice::ReadOnly);
m_bytes = file.readAll();
}
set_map_image_data(m_bytes);
set_map_image_format("jpg");
set_finished(true);
}
void StraightMovement::update() {
Movement::update();
if(!is_suspended()) {
uint32_t now = System::now();
bool current_move_y = move_y != 0 && now >= next_move_date_y;
bool current_move_x = move_x != 0 && now >= next_move_date_x;
while(current_move_x || current_move_y) {
// save current coordinates.
Rectangle old_xy(get_x(), get_y());
if(current_move_x) { // time to move in x direction.
if(current_move_y) { // time to move in y direction.
if(next_move_date_x <= next_move_date_y) { // we first move in x direction.
update_x();
if(now >= next_move_date_y) {
update_y();
}
} else {
update_y(); // we first move in y direciton.
if(now >= next_move_date_x) {
update_x();
}
}
} else { // we only move in x direction.
update_x();
}
} else { // we only move in y direction.
update_y();
}
if(get_entity() != NULL && !finished) {
// movement is successful old coordinates have changed.
bool success = (get_x() != old_xy.get_x() || get_y() != old_xy.get_y()
&& (move_x != 0 || move_y != 0));
// no movement notify obstacle.
if(!success) {
notify_obstacle_reached();
set_finished();
}
}
// check if we continue wit movement.
now = System::now();
current_move_x = move_x != 0 && now >= next_move_date_x;
current_move_y = move_y != 0 && now >= next_move_date_y;
}
}
}
void ts::scene::Loading_sequence::async_load(const cup::Stage_data& stage_data, action::Stage_interface* stage_interface)
{
set_loading(true);
set_finished(false);
auto stage_loader_callback = [this](const action::Stage* stage)
{
async_load(stage);
stage_loader_ = nullptr;
};
stage_loader_ = stage_interface->async_load_stage(stage_data, stage_loader_callback);
}
void ts::scene::Loading_sequence::handle_completion()
{
if (completion_handler_)
{
set_finished(true);
try
{
loaded_scene_.script_conductor = script_loader_.transfer_result();
}
catch (...)
{
exception_ptr_ = std::current_exception();
}
auto completion_handler = std::move(completion_handler_);
completion_handler();
}
}
//#################### PUBLIC METHODS ####################
void CTIPFBuilder::execute()
{
typedef itk::Image<short,3> GradientMagnitudeImage;
typedef itk::Image<int,3> HounsfieldImage;
typedef itk::Image<float,3> RealImage;
typedef itk::Image<unsigned char,3> WindowedImage;
HounsfieldImage::Pointer hounsfieldImage = (*m_volume)->base_image();
//~~~~~~~
// STEP 1
//~~~~~~~
set_status("Preprocessing image...");
// Construct the windowed image.
WindowedImage::Pointer windowedImage = (*m_volume)->windowed_image(m_segmentationOptions.windowSettings);
if(is_aborted()) return;
// Cast the input image (whether Hounsfield or windowed) to make its pixels real-valued.
RealImage::Pointer realImage;
switch(m_segmentationOptions.inputType)
{
case CTSegmentationOptions::INPUTTYPE_HOUNSFIELD:
{
typedef itk::CastImageFilter<HounsfieldImage,RealImage> CastFilter;
CastFilter::Pointer castFilter = CastFilter::New();
castFilter->SetInput(hounsfieldImage);
castFilter->Update();
realImage = castFilter->GetOutput();
break;
}
case CTSegmentationOptions::INPUTTYPE_WINDOWED:
{
typedef itk::CastImageFilter<WindowedImage,RealImage> CastFilter;
CastFilter::Pointer castFilter = CastFilter::New();
castFilter->SetInput(windowedImage);
castFilter->Update();
realImage = castFilter->GetOutput();
break;
}
default:
{
throw Exception("Unknown CT segmentation input type"); // this should never happen
}
}
if(is_aborted()) return;
// Smooth this real image using anisotropic diffusion filtering.
typedef itk::GradientAnisotropicDiffusionImageFilter<RealImage,RealImage> ADFilter;
for(int i=0; i<m_segmentationOptions.adfIterations; ++i)
{
ADFilter::Pointer adFilter = ADFilter::New();
adFilter->SetInput(realImage);
adFilter->SetConductanceParameter(1.0);
adFilter->SetNumberOfIterations(1);
adFilter->SetTimeStep(0.0625);
adFilter->Update();
realImage = adFilter->GetOutput();
if(is_aborted()) return;
increment_progress();
}
// Calculate the gradient magnitude of the smoothed image.
typedef itk::GradientMagnitudeImageFilter<RealImage,GradientMagnitudeImage> GMFilter;
GMFilter::Pointer gmFilter = GMFilter::New();
gmFilter->SetInput(realImage);
gmFilter->SetUseImageSpacingOff();
gmFilter->Update();
GradientMagnitudeImage::Pointer gradientMagnitudeImage = gmFilter->GetOutput();
if(is_aborted()) return;
increment_progress();
//~~~~~~~
// STEP 2
//~~~~~~~
set_status("Running watershed...");
// Run the watershed algorithm on the gradient magnitude image.
typedef MeijsterRoerdinkWatershed<GradientMagnitudeImage::PixelType,3> WS;
WS ws(gradientMagnitudeImage, ITKImageUtil::make_6_connected_offsets());
if(is_aborted()) return;
increment_progress();
//~~~~~~~
// STEP 3
//~~~~~~~
set_status("Creating initial partition forest...");
boost::shared_ptr<CTImageLeafLayer> leafLayer(new CTImageLeafLayer(hounsfieldImage, windowedImage, gradientMagnitudeImage));
if(is_aborted()) return;
boost::shared_ptr<CTImageBranchLayer> lowestBranchLayer = IPF::make_lowest_branch_layer(leafLayer, ws.calculate_groups());
if(is_aborted()) return;
m_ipf.reset(new IPF(leafLayer, lowestBranchLayer));
increment_progress();
//~~~~~~~
// STEP 4
//~~~~~~~
set_status("Creating rooted MST for lowest branch layer...");
RootedMST<int> mst(*lowestBranchLayer);
if(is_aborted()) return;
increment_progress();
//~~~~~~~
// STEP 5
//~~~~~~~
set_status("Running waterfall...");
// Iteratively run a Nicholls waterfall pass on the MST until the forest is built.
typedef WaterfallPass<int>::Listener WaterfallPassListener;
NichollsWaterfallPass<int> waterfallPass;
boost::shared_ptr<WaterfallPassListener> listener = make_forest_building_waterfall_pass_listener(m_ipf);
waterfallPass.add_listener(listener);
while(mst.node_count() != 1 && m_ipf->highest_layer() < m_segmentationOptions.waterfallLayerLimit)
{
m_ipf->clone_layer(m_ipf->highest_layer());
if(is_aborted()) return;
waterfallPass.run(mst);
if(is_aborted()) return;
}
set_finished();
}
/**
* @brief Updates the position of the object controlled by this movement.
*
* This function is called repeatedly.
*/
void StraightMovement::update() {
if (!is_suspended()) {
uint32_t now = System::now();
bool x_move_now = x_move != 0 && now >= next_move_date_x;
bool y_move_now = y_move != 0 && now >= next_move_date_y;
while (x_move_now || y_move_now) { // while it's time to move
// save the current coordinates
Rectangle old_xy(get_x(), get_y());
if (x_move_now) {
// it's time to make an x move
if (y_move_now) {
// but it's also time to make a y move
if (next_move_date_x <= next_move_date_y) {
// x move first
update_x();
if (now >= next_move_date_y) {
update_y();
}
}
else {
// y move first
update_y();
if (now >= next_move_date_x) {
update_x();
}
}
}
else {
update_x();
}
}
else {
update_y();
}
if (!is_suspended() && get_entity() != NULL && !finished) {
// the movement was successful if the entity's coordinates have changed
// and the movement was not stopped
bool success = (get_x() != old_xy.get_x() || get_y() != old_xy.get_y())
&& (x_move != 0 || y_move != 0);
if (!success) {
notify_obstacle_reached();
}
}
now = System::now();
if (!finished && max_distance != 0 && Geometry::get_distance(initial_xy.get_x(),
initial_xy.get_y(), get_x(), get_y()) >= max_distance) {
set_finished();
}
else {
x_move_now = x_move != 0 && now >= next_move_date_x;
y_move_now = y_move != 0 && now >= next_move_date_y;
}
}
}
// Do this at last so that Movement::update() knows whether we are finished.
Movement::update();
}
//#################### PUBLIC METHODS ####################
void CTLowestLayersBuilder::execute()
{
typedef itk::Image<short,3> GradientMagnitudeImage;
typedef itk::Image<int,3> HounsfieldImage;
typedef itk::Image<float,3> RealImage;
typedef itk::Image<unsigned char,3> WindowedImage;
HounsfieldImage::Pointer hounsfieldImage = (*m_volume)->base_image();
//~~~~~~~
// STEP 1
//~~~~~~~
set_status("Preprocessing image...");
// Construct the windowed image.
WindowedImage::Pointer windowedImage = (*m_volume)->windowed_image(m_segmentationOptions.windowSettings);
if(is_aborted()) return;
// Cast the input image (whether Hounsfield or windowed) to make its pixels real-valued.
RealImage::Pointer realImage;
switch(m_segmentationOptions.inputType)
{
case CTSegmentationOptions::INPUTTYPE_HOUNSFIELD:
{
typedef itk::CastImageFilter<HounsfieldImage,RealImage> CastFilter;
CastFilter::Pointer castFilter = CastFilter::New();
castFilter->SetInput(hounsfieldImage);
castFilter->Update();
realImage = castFilter->GetOutput();
break;
}
case CTSegmentationOptions::INPUTTYPE_WINDOWED:
{
typedef itk::CastImageFilter<WindowedImage,RealImage> CastFilter;
CastFilter::Pointer castFilter = CastFilter::New();
castFilter->SetInput(windowedImage);
castFilter->Update();
realImage = castFilter->GetOutput();
break;
}
default:
{
throw Exception("Unknown CT segmentation input type"); // this should never happen
}
}
if(is_aborted()) return;
// Smooth this real image using anisotropic diffusion filtering.
typedef itk::GradientAnisotropicDiffusionImageFilter<RealImage,RealImage> ADFilter;
for(int i=0; i<m_segmentationOptions.adfIterations; ++i)
{
ADFilter::Pointer adFilter = ADFilter::New();
adFilter->SetInput(realImage);
adFilter->SetConductanceParameter(1.0);
adFilter->SetNumberOfIterations(1);
adFilter->SetTimeStep(0.0625);
adFilter->Update();
realImage = adFilter->GetOutput();
if(is_aborted()) return;
increment_progress();
}
// Calculate the gradient magnitude of the smoothed image.
typedef itk::GradientMagnitudeImageFilter<RealImage,GradientMagnitudeImage> GMFilter;
GMFilter::Pointer gmFilter = GMFilter::New();
gmFilter->SetInput(realImage);
gmFilter->SetUseImageSpacingOff();
gmFilter->Update();
GradientMagnitudeImage::Pointer gradientMagnitudeImage = gmFilter->GetOutput();
if(is_aborted()) return;
increment_progress();
//~~~~~~~
// STEP 2
//~~~~~~~
set_status("Running watershed...");
// Run the watershed algorithm on the gradient magnitude image.
typedef MeijsterRoerdinkWatershed<GradientMagnitudeImage::PixelType,3> WS;
WS ws(gradientMagnitudeImage, ITKImageUtil::make_6_connected_offsets());
if(is_aborted()) return;
increment_progress();
//~~~~~~~
// STEP 3
//~~~~~~~
set_status("Creating lowest forest layers...");
m_leafLayer.reset(new CTImageLeafLayer(hounsfieldImage, windowedImage, gradientMagnitudeImage));
if(is_aborted()) return;
m_lowestBranchLayer = IPF::make_lowest_branch_layer(m_leafLayer, ws.calculate_groups());
if(is_aborted()) return;
set_finished();
}
