void QmitkMatchPointRegistrationManipulator::OnStoreBtnPushed()
{
mitk::MAPRegistrationWrapper::Pointer newRegWrapper = mitk::MAPRegistrationWrapper::New();
MAPRegistrationType::Pointer newReg = MAPRegistrationType::New();
newRegWrapper->SetRegistration(newReg);
::map::core::RegistrationManipulator<MAPRegistrationType> manipulator(newReg);
::map::core::PreCachedRegistrationKernel<3, 3>::Pointer kernel = ::map::core::PreCachedRegistrationKernel<3, 3>::New();
kernel->setTransformModel(m_InverseCurrentTransform);
::map::core::PreCachedRegistrationKernel<3, 3>::Pointer kernel2 = ::map::core::PreCachedRegistrationKernel<3, 3>::New();
kernel2->setTransformModel(m_InverseCurrentTransform->GetInverseTransform());
manipulator.setInverseMapping(kernel);
manipulator.setDirectMapping(kernel2);
if (this->m_Controls.radioSelectedReg->isChecked())
{ //compine registration with selected pre registration as baseline
typedef ::map::core::RegistrationCombinator<MAPRegistrationType, MAPRegistrationType> CombinatorType;
CombinatorType::Pointer combinator = CombinatorType::New();
newReg = combinator->process(*m_SelectedPreReg,*newReg);
newRegWrapper->SetRegistration(newReg);
}
mitk::DataNode::Pointer spResultRegistrationNode = mitk::generateRegistrationResultNode(
this->m_Controls.lbNewRegName->text().toStdString(), newRegWrapper, "org.mitk::manual_registration",
mitk::EnsureUID(m_SelectedMovingNode->GetData()), mitk::EnsureUID(m_SelectedTargetNode->GetData()));
this->GetDataStorage()->Add(spResultRegistrationNode);
if (m_Controls.checkMapEntity->checkState() == Qt::Checked)
{
QmitkMappingJob* pMapJob = new QmitkMappingJob();
pMapJob->setAutoDelete(true);
pMapJob->m_spInputData = this->m_SelectedMovingNode->GetData();
pMapJob->m_InputDataUID = mitk::EnsureUID(m_SelectedMovingNode->GetData());
pMapJob->m_spRegNode = spResultRegistrationNode;
pMapJob->m_doGeometryRefinement = false;
pMapJob->m_spRefGeometry = this->m_SelectedTargetNode->GetData()->GetGeometry()->Clone().GetPointer();
pMapJob->m_MappedName = this->m_Controls.lbNewRegName->text().toStdString() + std::string(" mapped moving data");
pMapJob->m_allowUndefPixels = true;
pMapJob->m_paddingValue = 100;
pMapJob->m_allowUnregPixels = true;
pMapJob->m_errorValue = 200;
pMapJob->m_InterpolatorLabel = "Linear Interpolation";
pMapJob->m_InterpolatorType = mitk::ImageMappingInterpolator::Linear;
connect(pMapJob, SIGNAL(Error(QString)), this, SLOT(OnMapJobError(QString)));
connect(pMapJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
Qt::BlockingQueuedConnection);
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pMapJob);
}
void MainWindow::editInsertImage()
{
ImageToolDialog dialog(this);
if (dialog.exec() == QDialog::Accepted) {
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.insertImageLink(dialog.alternateText(), dialog.imageSourceLink(), dialog.optionalTitle());
}
}
void MainWindow::editInsertTable()
{
TableToolDialog dialog;
if (dialog.exec() == QDialog::Accepted) {
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.insertTable(dialog.rows(), dialog.columns(),
dialog.alignments(), dialog.tableCells());
}
}
int main(int /*argc*/, char ** /*argv*/) {
BaseApp app;
ProgramObject program;
auto mainWindow = app.getMainWindow();
std::string prefix = app.getResourceDir() + "Shaders/Examples/e06_ModelLoader/";
PerspectiveCamera cam;
OrbitManipulator manipulator(&cam);
manipulator.setupCallbacks(app);
NodeShared root;
GLuint query[2];
app.addInitCallback([&]() {
auto vs = compileShader(GL_VERTEX_SHADER, Loader::text(prefix + "phong.vert"));
auto fs = compileShader(GL_FRAGMENT_SHADER, Loader::text(prefix + "phong.frag"));
program = createProgram(vs, fs);
root = Loader::scene(app.getResourceDir() + "Models/sponza/sponza.fbx");
glCreateQueries(GL_TIMESTAMP, 2, query);
SDL_GL_SetSwapInterval(0);
});
app.addResizeCallback([&](int w, int h) {
glViewport(0, 0, w, h);
cam.setAspect(float(w) / float(h));
});
app.addDrawCallback([&]() {
glQueryCounter(query[0], GL_TIMESTAMP);
glClearColor(0.2, 0.2, 0.2, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
//bunny
program.use();
program.setMatrix4fv("p", value_ptr(cam.getProjection()));
program.setMatrix4fv("v", value_ptr(cam.getView()));
drawNode(program, root);
glQueryCounter(query[1], GL_TIMESTAMP);
GLuint64 time1, time2;
glGetQueryObjectui64v(query[0], GL_QUERY_RESULT, &time1);
glGetQueryObjectui64v(query[1], GL_QUERY_RESULT, &time2);
std::string s = "fps: " + std::to_string(1e9 / (time2 - time1)) + " (" + std::to_string(ImGui::GetIO().Framerate) + ")";
label(s, 0, 0, 300, 100);
});
return app.run();
}
void MarkdownEditor::keyPressEvent(QKeyEvent *e)
{
// Ctrl+Right Arrow
if ((e->key() == Qt::Key_Right) && (e->modifiers() & Qt::ControlModifier)) {
MarkdownManipulator manipulator(this);
manipulator.increaseHeadingLevel();
e->accept();
return;
}
// Ctrl+Left Arrow
if ((e->key() == Qt::Key_Left) && (e->modifiers() & Qt::ControlModifier)) {
MarkdownManipulator manipulator(this);
manipulator.decreaseHeadingLevel();
e->accept();
return;
}
QPlainTextEdit::keyPressEvent(e);
}
void MainWindow::editDecreaseHeaderLevel()
{
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.decreaseHeadingLevel();
}
void MainWindow::editBlockquote()
{
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.formatTextAsQuote();
}
void MainWindow::editHardLinebreak()
{
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.appendToLine(" \n");
}
void MainWindow::editCenterParagraph()
{
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.wrapCurrentParagraph("->", "<-");
}
opengl_object& operator<<( opengl_object& (*manipulator)( opengl_object& ))
{
manipulator( *this);
return *this;
}
void MainWindow::editEmphasize()
{
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.wrapSelectedText("*");
}
void MainWindow::editStrong()
{
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.wrapSelectedText("**");
}
result statement::operator<<(result (*manipulator)(statement &st))
{
return manipulator(*this);
}
statement &statement::operator<<(void (*manipulator)(statement &st))
{
manipulator(*this);
return *this;
}
int main(int /*argc*/, char ** /*argv*/) {
BaseApp app;
ProgramObject programEnv, program;
auto mainWindow = app.getMainWindow();
PerspectiveCamera cam;
OrbitManipulator manipulator(&cam);
manipulator.setupCallbacks(app);
manipulator.setZoom(3);
GLuint diffuseTexture;
GLuint specularTexture;
GLuint vao;
GLuint vaoEmpty;
GLuint vbo;
int32_t sphereSizeX = 20;
int32_t sphereSizeY = 20;
app.addInitCallback([&]() {
std::string prefix = app.getResourceDir() + "Shaders/Tutorial/";
auto vs = compileShader(GL_VERTEX_SHADER,
"#version 450\n",
Loader::text(prefix + "uv.vp"));
auto fs = compileShader(GL_FRAGMENT_SHADER,
"#version 450\n",
Loader::text(prefix + "lighting.vp"),
Loader::text(prefix + "uv.fp"));
program = createProgram(vs, fs);
std::string texPrefix = app.getResourceDir() + "Textures/Tutorial/";
diffuseTexture = Loader::texture(texPrefix + "earth.png");
specularTexture = Loader::texture(texPrefix + "earth_s.png");
glCreateBuffers(1, &vbo);
const uint32_t floatsPerVertex = 6;
const uint32_t vertiesPerFace = 6;
float*vertices = new float[sphereSizeX*sphereSizeY*vertiesPerFace*floatsPerVertex];
for (int32_t y = 0; y<sphereSizeY; ++y) {
for (int32_t x = 0; x<sphereSizeX; ++x) {
for (uint32_t k = 0; k<vertiesPerFace; ++k) {
const int32_t xOffset[] = { 0,1,0,0,1,1 };
const int32_t yOffset[] = { 0,0,1,1,0,1 };
float u = (float)(x + xOffset[k]) / sphereSizeX;
float v = (float)(y + yOffset[k]) / sphereSizeY;
float xAngle = -u*glm::two_pi<float>();
float yAngle = v*glm::pi<float>();
uint32_t faceId = y*sphereSizeX + x;
uint32_t faceVertex = faceId*vertiesPerFace + k;
vertices[faceVertex*floatsPerVertex + 0] = glm::cos(xAngle)*glm::sin(yAngle);
vertices[faceVertex*floatsPerVertex + 1] = -glm::cos(yAngle);
vertices[faceVertex*floatsPerVertex + 2] = glm::sin(xAngle)*glm::sin(yAngle);
vertices[faceVertex*floatsPerVertex + 3] = 1;
vertices[faceVertex*floatsPerVertex + 4] = u;
vertices[faceVertex*floatsPerVertex + 5] = v;
}
}
}
glNamedBufferData(vbo, sizeof(float)*sphereSizeX*sphereSizeY*vertiesPerFace*floatsPerVertex, vertices, GL_STATIC_DRAW);
delete[]vertices;
glCreateVertexArrays(1, &vao);
glEnableVertexArrayAttrib(vao, 0);
glVertexArrayAttribFormat(vao, 0, 4, GL_FLOAT, 0, 0);
glVertexArrayVertexBuffer(vao, 0, vbo, 0, sizeof(float)*floatsPerVertex);
glEnableVertexArrayAttrib(vao, 1);
glVertexArrayAttribFormat(vao, 1, 2, GL_FLOAT, 0, 0);
glVertexArrayVertexBuffer(vao, 1, vbo, sizeof(float) * 4, sizeof(float)*floatsPerVertex);
glClearColor(0, 0, 0, 1);
glDisable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
});
app.addResizeCallback([&](int w, int h) {
glViewport(0, 0, w, h);
cam.setAspect(float(w) / float(h));
});
app.addDrawCallback([&]() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
program.use();
glBindTextureUnit(0, diffuseTexture);
glBindTextureUnit(1, specularTexture);
program.setMatrix4fv("p", value_ptr(cam.getProjection()));
program.setMatrix4fv("v", value_ptr(cam.getView()));
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, sphereSizeX*sphereSizeY * 6);
glBindVertexArray(0);
});
return app.run();
}
Log& operator<< (const Manipulator<ArgType> &manipulator) { return manipulator(*this); }
void QmitkMatchPointRegistrationManipulator::InitSession()
{
this->m_InverseCurrentTransform = TransformType::New();
this->m_InverseCurrentTransform->SetIdentity();
this->m_DirectCurrentTransform = TransformType::New();
this->m_DirectCurrentTransform->SetIdentity();
this->m_CurrentRegistrationWrapper = mitk::MAPRegistrationWrapper::New();
m_CurrentRegistration = MAPRegistrationType::New();
this->m_CurrentRegistrationWrapper->SetRegistration(m_CurrentRegistration);
::map::core::RegistrationManipulator<MAPRegistrationType> manipulator(m_CurrentRegistration);
::map::core::PreCachedRegistrationKernel<3, 3>::Pointer kernel = ::map::core::PreCachedRegistrationKernel<3, 3>::New();
manipulator.setDirectMapping(::map::core::NullRegistrationKernel < 3, 3 >::New());
if (this->m_Controls.radioNewReg->isChecked())
{ //new registration
kernel->setTransformModel(m_InverseCurrentTransform);
manipulator.setInverseMapping(kernel);
//init to map the image centers
auto movingCenter = m_SelectedMovingNode->GetData()->GetTimeGeometry()->GetCenterInWorld();
auto targetCenter = m_SelectedTargetNode->GetData()->GetTimeGeometry()->GetCenterInWorld();
auto offset = targetCenter - movingCenter;
m_DirectCurrentTransform->SetOffset(offset);
m_DirectCurrentTransform->GetInverse(m_InverseCurrentTransform);
}
else
{ //use selected pre registration as baseline
itk::CompositeTransform < ::map::core::continuous::ScalarType, 3>::Pointer compTransform = itk::CompositeTransform < ::map::core::continuous::ScalarType, 3>::New();
const map::core::RegistrationKernel<3, 3>* preKernel = dynamic_cast<const map::core::RegistrationKernel<3, 3>*>(&this->m_SelectedPreReg->getInverseMapping());
compTransform->AddTransform(preKernel->getTransformModel()->Clone());
compTransform->AddTransform(this->m_InverseCurrentTransform);
kernel->setTransformModel(compTransform);
manipulator.setInverseMapping(kernel);
}
m_Controls.comboCenter->setCurrentIndex(0);
this->ConfigureTransformCenter(0);
//set bounds of the translation slider widget to have sensible ranges
auto currenttrans = m_DirectCurrentTransform->GetTranslation();
this->m_Controls.slideTransX->setMinimum(currenttrans[0] - 250);
this->m_Controls.slideTransY->setMinimum(currenttrans[1] - 250);
this->m_Controls.slideTransZ->setMinimum(currenttrans[2] - 250);
this->m_Controls.slideTransX->setMaximum(currenttrans[0] + 250);
this->m_Controls.slideTransY->setMaximum(currenttrans[1] + 250);
this->m_Controls.slideTransZ->setMaximum(currenttrans[2] + 250);
//reinit view
mitk::RenderingManager::GetInstance()->InitializeViews(m_SelectedTargetNode->GetData()->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
//generate evaluation node
mitk::RegEvaluationObject::Pointer regEval = mitk::RegEvaluationObject::New();
regEval->SetRegistration(this->m_CurrentRegistrationWrapper);
regEval->SetTargetNode(this->m_SelectedTargetNode);
regEval->SetMovingNode(this->m_SelectedMovingNode);
this->m_EvalNode = mitk::DataNode::New();
this->m_EvalNode->SetData(regEval);
mitk::RegEvaluationMapper2D::SetDefaultProperties(this->m_EvalNode);
this->m_EvalNode->SetName(HelperNodeName);
this->m_EvalNode->SetBoolProperty("helper object", true);
this->GetDataStorage()->Add(this->m_EvalNode);
this->m_Controls.evalSettings->SetNode(this->m_EvalNode);
this->m_activeManipulation = true;
};
void MainWindow::editStrikethrough()
{
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.wrapSelectedText("~~");
}
void MainWindow::editInlineCode()
{
MarkdownManipulator manipulator(ui->plainTextEdit);
manipulator.wrapSelectedText("`");
}
/**
* Output stream operator.
* @note The definition is included here with declaration, because I
* could not get the compilation work if it were at end of file.
* @param stream The stream to put the output into
* @param manipulator The manipulator that will manipulate the stream
* @return The output stream to allow chain use of the operator
*/
friend std::ostream &operator<<(std::ostream &stream,
const ManipulatorTwo &manipulator)
{
return manipulator(stream);
}
