TransitionDialog.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package
 * @author
 * @date
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
#include "TransitionDialog.h"
 
#include <QComboBox>
#include <QFileDialog>
#include <QLineEdit>
#include <QMessageBox>
 
#include <ArmarXGui/gui-plugins/StatechartEditorPlugin/view/dialogs/ui_TransitionDialog.h>
 
#include "../../../ObserverPropertiesPlugin/ObserverItemModel.h"
 
namespace armarx
{
 
    TransitionDialog::TransitionDialog(statechartmodel::TransitionCPtr transition,
                                       statechartmodel::StatePtr state,
                                       QStringList profileNames,
                                       Ice::CommunicatorPtr ic,
                                       VariantInfoPtr variantInfo,
                                       QWidget* parent) :
        QDialog(parent),
        ui(new Ui::TransitionDialog),
        transition(transition),
        parentState(state),
        ic(ic),
        variantInfo(variantInfo),
        profileNames(profileNames)
    {
        ui->setupUi(this);
        setup();
    }
 
    TransitionDialog::~TransitionDialog()
    {
        delete ui;
    }
 
    statechartmodel::ParameterMappingList
    TransitionDialog::getMappingToNextStateInput() const
    {
        return ui->inputTableMapping->getMapping();
    }
 
    statechartmodel::ParameterMappingList
    TransitionDialog::getMappingToParentStateLocal() const
    {
        return ui->parentLocalMapping->getMapping();
    }
 
    statechartmodel::ParameterMappingList
    TransitionDialog::getMappingToParentStateOutput() const
    {
        return ui->parentOutputMapping->getMapping();
    }
 
    size_t
    TransitionDialog::LevenshteinEditDistance(const std::string& s1, const std::string& s2)
    {
        // from https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#C++
        const std::size_t len1 = s1.size(), len2 = s2.size();
        std::vector<std::vector<unsigned int>> d(len1 + 1, std::vector<unsigned int>(len2 + 1));
 
        d[0][0] = 0;
        for (unsigned int i = 1; i <= len1; ++i)
        {
            d[i][0] = i;
        }
        for (unsigned int i = 1; i <= len2; ++i)
        {
            d[0][i] = i;
        }
 
        for (unsigned int i = 1; i <= len1; ++i)
            for (unsigned int j = 1; j <= len2; ++j)
                // note that std::min({arg1, arg2, arg3}) works only in C++11,
                // for C++98 use std::min(std::min(arg1, arg2), arg3)
                d[i][j] = std::min({d[i - 1][j] + 1,
                                    d[i][j - 1] + 1,
                                    d[i - 1][j - 1] + (s1[i - 1] == s2[j - 1] ? 0 : 1)});
        return d[len1][len2];
    }
 
    void
    TransitionDialog::setup()
    {
        //    ui->editEventName->setText(transition->eventName);
        //    ui->editEventName->setFocus();
        ui->labelEventName->setText(transition->eventName);
 
        if (!transition->destinationState)
        {
            ui->labelDestinationState->setText("Transition is detached");
            return;
        }
 
 
        if (transition->sourceState)
        {
            ui->labelSourceState->setText(transition->sourceState->getInstanceName());
            setWindowTitle("Edit Transition " + transition->eventName + " [" +
                           transition->sourceState->getInstanceName() + " -> " +
                           transition->destinationState->getInstanceName() + "]");
        }
        else
        {
            ui->labelSourceState->setText("This is the initial transition to the start state");
            setWindowTitle("Edit Initial Transition  -> " +
                           transition->destinationState->getInstanceName());
        }
 
        ui->labelDestinationState->setText(transition->destinationState->getInstanceName());
 
 
        statechartmodel::StateParameterMap destDict;
 
        if (transition->destinationState->getType() != eFinalState)
        {
            if (transition->destinationState->getStateClass())
            {
                destDict = transition->destinationState->getStateClass()->getInputParameters();
            }
            else
            {
                QMessageBox::warning(this,
                                     "Transition Editing Error",
                                     "Transition editing not possible because destination state is "
                                     "not loaded - load statechart group of destination state.");
                return;
            }
        }
        else
        {
            destDict = transition->destinationState->getParent()->getOutputParameters();
        }
 
        ui->inputTableMapping->setup(destDict,
                                     transition->mappingToNextStatesInput,
                                     transition,
                                     parentState,
                                     profileNames,
                                     ic,
                                     variantInfo);
 
        if (transition->sourceState)
        {
            ui->tabWidget->setTabEnabled(1, true);
            ui->tabWidget->setTabEnabled(2, true);
            ui->parentLocalMapping->hideColumn(TransitionMappingTable::eMappingRequired);
            ui->parentOutputMapping->hideColumn(TransitionMappingTable::eMappingRequired);
            ui->parentLocalMapping->setup(parentState->getLocalParameters(),
                                          transition->mappingToParentStatesLocal,
                                          transition,
                                          parentState,
                                          profileNames,
                                          ic,
                                          variantInfo);
            ui->parentOutputMapping->setup(parentState->getOutputParameters(),
                                           transition->mappingToParentStatesOutput,
                                           transition,
                                           parentState,
                                           profileNames,
                                           ic,
                                           variantInfo);
        }
        else
        {
            ui->tabWidget->setTabEnabled(1, false);
            ui->tabWidget->setTabEnabled(2, false);
        }
    }
 
 
} // namespace armarx
 
void
armarx::TransitionDialog::on_btnAutoMap_clicked()
{
    TransitionMappingTable* mapping;
    if (ui->tabWidget->currentIndex() == 0)
    {
        mapping = ui->inputTableMapping;
    }
    else if (ui->tabWidget->currentIndex() == 1)
    {
        mapping = ui->parentLocalMapping;
    }
    else
    {
        mapping = ui->parentOutputMapping;
    }
 
 
    auto caseSensitive = [](QString s1, QString s2) { return std::make_pair(s1 == s2, 0.0f); };
    auto caseInsensitive = [](QString s1, QString s2)
    { return std::make_pair(s1.compare(s1, s2, Qt::CaseInsensitive) == 0, 0.0f); };
    auto editDistance = [](QString s1, QString s2)
    {
        auto distance =
            LevenshteinEditDistance(s1.toLower().toStdString(), s2.toLower().toStdString());
        return std::make_pair(distance <= 3, (float)distance);
    };
 
    ARMARX_INFO << "Casesensitive";
    auto mappedRows = mapping->mapByCriteria(caseSensitive);
    //    ARMARX_INFO << mappedRows.size() << " Caseinsensitive";
    mappedRows.append(mapping->mapByCriteria(caseInsensitive));
    //    ARMARX_INFO << mappedRows.size() << " editdistance";
    mappedRows.append(mapping->mapByCriteria(editDistance));
    //    ARMARX_INFO << mappedRows.size() << " after editdistance";
    QString foundMappingsString;
    for (auto& elem : mappedRows)
    {
        foundMappingsString += elem.first + " from " + elem.second + "\n";
    }
    if (!foundMappingsString.isEmpty())
    {
        foundMappingsString = ":\n" + foundMappingsString;
    }
    QMessageBox::information(this,
                             "Auto Mapping Results",
                             "Mapped " + QString::number(mappedRows.size()) +
                                 (mappedRows.size() == 1 ? " entry" : " entries") +
                                 foundMappingsString);
}