void TranslationRotation3D::setF(const std::vector<double> &F_in) {
  if (F_in.size() != 16)
    throw std::runtime_error(
        "TranslationRotation3D::setF: F_in requires 16 elements");

  if ((F_in.at(12) != 0.0) || (F_in.at(13) != 0.0) || (F_in.at(14) != 0.0) ||
      (F_in.at(15) != 1.0))
    throw std::runtime_error(
        "TranslationRotation3D::setF: bottom row of F_in should be [0 0 0 1]");

  Eigen::Map<const Eigen::Matrix<double, 4, 4, Eigen::RowMajor> > F_in_eig(
      F_in.data());

  Eigen::Transform<double, 3, Eigen::Affine> F;
  F = F_in_eig;

  double tmpT[3];
  Eigen::Map<Eigen::Vector3d> tra_eig(tmpT);
  tra_eig = F.translation();

  double tmpR_mat[9];
  Eigen::Map<Eigen::Matrix<double, 3, 3, Eigen::RowMajor> > rot_eig(tmpR_mat);
  rot_eig = F.rotation();

  setT(tmpT);
  setR_mat(tmpR_mat);
  updateR_mat(); // for stability
}
TranslationRotation3D::TranslationRotation3D(const Type TR_in[6])
    : valid_{ true } {
  double T_in[3], R_in[3];
  for (int i = 0; i < 3; i++) {
    T_in[i] = static_cast<double>(TR_in[i]);
    R_in[i] = static_cast<double>(TR_in[i + 3]);
  }
  setT(T_in);
  setR(R_in);
}
TranslationRotation3D::TranslationRotation3D(Eigen::Vector3d T,
                                             Eigen::Vector3d R) {
  double T_in[3];
  double R_in[3];
  Eigen::Map<Eigen::Vector3d> T_tmp(T_in);
  Eigen::Map<Eigen::Vector3d> R_tmp(R_in);
  T_tmp = T;
  R_tmp = R;
  setT(T_in);
  setR(R_in);
}
Esempio n. 4
0
MainWindow::MainWindow(files_control *files) : /*QMainWindow(parent) , */ui(new Ui::MainWindow)
{
	this->files = files;
	ui->setupUi(this);

	resize(minimumWidth(), minimumHeight());

	seznam_ = new seznam();
	PV = new long double(0);
	R = new double(0);
	T = new unsigned short int(0);
	popl = new double(0);
	popl_last = new double(0);
	vysledna_hodnota = new QString();

	ui->r_line->hide();
	ui->r_label_3->hide();

	ui->poplatek_line->hide();
	ui->skutecny_label->hide();
	ui->procento->hide();

	ui->poplatek_line->setText("0,00");

	//********** doplnovani comboboxu ************
	for(int i = 0; i < 13; i++)
	{
	   ui->r_combo->addItem(QString("MIX %1: %2 %3").arg(i+1).arg(files->PA(i),6, 'f', 2).arg("p.a.", 5));
	}
	ui->r_combo->addItem(QString::fromUtf8("Vlastní hodnota"));

	//********** dosazovani hodnot ************
	connect(this->ui->r_combo, SIGNAL(currentIndexChanged(int)), this , SLOT(rLineVlastniSelected(int)));
	connect(this->ui->pv_line, SIGNAL(textChanged(QString)), this , SLOT(setPV(QString)));
	connect(this->ui->t_line, SIGNAL(textChanged(QString)), this, SLOT(setT(QString)));
	connect(this->ui->r_line, SIGNAL(textChanged(QString)), this, SLOT(setR(QString)));
	connect(this, SIGNAL(anyValueChanged()), this, SLOT(calculate()));
	connect(this->ui->otaznik_button, SIGNAL(clicked()), this, SLOT(otaznikClick()));
	connect(this->ui->action_close_window, SIGNAL(triggered()), this, SLOT(close()));
	connect(this->ui->poplatek_check, SIGNAL(clicked()), this, SLOT(poplatekChecked()));
	connect(this->ui->poplatek_line, SIGNAL(textChanged(QString)), this, SLOT(setPopl(QString)));

	rLineVlastniSelected(1);

	this->setWindowTitle(APP_NAME);

	this->ui->otaznik_button->setIcon(QIcon(QPixmap(":/img/info.png")));
}
Esempio n. 5
0
int Scene::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QQuickItem::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 6)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 6;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 6)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 6;
    }
#ifndef QT_NO_PROPERTIES
      else if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< qreal*>(_v) = t(); break;
        }
        _id -= 1;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setT(*reinterpret_cast< qreal*>(_v)); break;
        }
        _id -= 1;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 1;
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
TranslationRotation3D::TranslationRotation3D(
    const Ogre::Vector3 &ogre_translation,
    const Ogre::Quaternion &ogre_rotation)
    : valid_{ true } {
  double tmpT[3] = { ogre_translation.x, ogre_translation.y,
                     ogre_translation.z };
  double tmpR_mat[9];

  Eigen::Quaterniond q_eigen(ogre_rotation.w, ogre_rotation.x, ogre_rotation.y,
                             ogre_rotation.z);

  Eigen::Map<Eigen::Matrix<double, 3, 3, Eigen::RowMajor> > rot_eig(tmpR_mat);
  rot_eig = q_eigen.toRotationMatrix();

  setT(tmpT);
  setR_mat(tmpR_mat);
}
// Overloaded Constructor
Intersection::Intersection(Surface *surface, Point3 intersectionPoint, double t)
{	
	setSurface(surface);
	setIntersectionPoint(intersectionPoint);
	setT(t);
}
TranslationRotation3D::TranslationRotation3D(const double *T_in,
                                             const double *R_in)
    : valid_{ true } {
  setT(T_in);
  setR(R_in);
}
TranslationRotation3D::TranslationRotation3D(bool valid) : valid_{ valid } {
  double tmpT[3] = { 0.0, 0.0, 0.0 };
  setT(tmpT);
  double tmpR[3] = { 0.0, 0.0, 0.0 };
  setR(tmpR);
}
static void
create_markerss (void)
{
   GtkWidget *window = NULL;
   GtkWidget *box1;
   GtkWidget *box2;
   GtkWidget *close_button;
   GtkWidget *box;
   GtkWidget *table;
   GtkWidget *label;
   GtkWidget *separator;
   gfloat *X;
   gfloat *Y;
   gint i;
   GtkDataboxGraph *graph;
   GdkColor color;

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_widget_set_size_request (window, 600, 600);

   g_signal_connect (GTK_OBJECT (window), "destroy",
		     G_CALLBACK (gtk_main_quit), NULL);

   gtk_window_set_title (GTK_WINDOW (window), "GtkDatabox: Markers");
   gtk_container_set_border_width (GTK_CONTAINER (window), 0);

   box1 = gtk_vbox_new (FALSE, 0);
   gtk_container_add (GTK_CONTAINER (window), box1);

   label =
      gtk_label_new
      ("Some markerss (green) are shown below.\nThe text corresponds to the position of the text, relative to the markers.\n\nThere are also some texts (yellow).\n\nData points are red\n");
   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
   separator = gtk_hseparator_new ();
   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, FALSE, 0);

   gtk_databox_create_box_with_scrollbars_and_rulers (&box, &table,
						      TRUE, TRUE, TRUE, TRUE);
   gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);

   color.red = 16383;
   color.green = 16383;
   color.blue = 16383;
   gtk_widget_modify_bg (box, GTK_STATE_NORMAL, &color);

   X = g_new0 (gfloat, 20 + 4 + 5);
   Y = g_new0 (gfloat, 20 + 4 + 5);

   for (i = 0; i < 20 + 4 + 5; ++i)
   {
      X[i] = i % 4;
      Y[i] = i / 4;
   }
   X[20] = -0.5;
   Y[20] = -0.5;
   X[21] = -0.5;
   Y[21] = 4.5;
   X[22] = 3.5;
   Y[22] = -0.5;
   X[23] = 3.5;
   Y[23] = 4.5;

   X[24] = -1.;
   Y[24] = -1.;
   X[25] = -1.;
   Y[25] = +5.;
   X[26] = +4.;
   Y[26] = -1.;
   X[27] = +4.;
   Y[27] = +5.;
   X[28] = +1.5;
   Y[28] = +2.;

   color.red = 65535;
   color.green = 0;
   color.blue = 0;

   graph = gtk_databox_points_new (20 + 4 + 5, X, Y, &color, 3);
   gtk_databox_graph_add (GTK_DATABOX (box), graph);

   color.red = 0;
   color.green = 65535;
   color.blue = 0;

   graph = gtk_databox_markers_new (20, X, Y, &color, 15,
				   GTK_DATABOX_MARKERS_TRIANGLE);

   gtk_databox_graph_add (GTK_DATABOX (box), graph);
   setM (graph, 0, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_W, "West", FALSE);
   setM (graph, 1, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_N, "North", FALSE);
   setM (graph, 2, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_S, "South", FALSE);
   setM (graph, 3, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_E, "East", FALSE);

   setM (graph, 4, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE);
   setM (graph, 5, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE);
   setM (graph, 6, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE);
   setM (graph, 7, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE);

   setM (graph, 8, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE);
   setM (graph, 9, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE);
   setM (graph, 10, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE);
   setM (graph, 11, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE);

   setM (graph, 12, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE);
   setM (graph, 13, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE);
   setM (graph, 14, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE);
   setM (graph, 15, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE);

   setM (graph, 16, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_SW, "SW", TRUE);
   setM (graph, 17, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_NW, "NW", TRUE);
   setM (graph, 18, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_SE, "SE", TRUE);
   setM (graph, 19, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_NE, "NE", TRUE);


   graph = gtk_databox_markers_new (4, X + 20, Y + 20, &color, 1,
				   GTK_DATABOX_MARKERS_DASHED_LINE);

   gtk_databox_graph_add (GTK_DATABOX (box), graph);
   setL (graph, 0, GTK_DATABOX_MARKERS_N, GTK_DATABOX_MARKERS_TEXT_W, "West", TRUE);
   setL (graph, 1, GTK_DATABOX_MARKERS_E, GTK_DATABOX_MARKERS_TEXT_S, "South", TRUE);
   setL (graph, 2, GTK_DATABOX_MARKERS_W, GTK_DATABOX_MARKERS_TEXT_N, "North", TRUE);
   setL (graph, 3, GTK_DATABOX_MARKERS_S, GTK_DATABOX_MARKERS_TEXT_E, "East", TRUE);

   color.red = 65535;
   color.green = 65535;
   color.blue = 0;

   graph = gtk_databox_markers_new (5, X + 20 + 4, Y + 20 + 4, &color, 1,
				   GTK_DATABOX_MARKERS_NONE);

   gtk_databox_graph_add (GTK_DATABOX (box), graph);
   setT (graph, 0, GTK_DATABOX_MARKERS_TEXT_N, "North", FALSE);
   setT (graph, 1, GTK_DATABOX_MARKERS_TEXT_E, "East", FALSE);
   setT (graph, 2, GTK_DATABOX_MARKERS_TEXT_S, "South", FALSE);
   setT (graph, 3, GTK_DATABOX_MARKERS_TEXT_W, "West", FALSE);
   setT (graph, 4, GTK_DATABOX_MARKERS_TEXT_CENTER, "Centered", TRUE);


   gtk_databox_auto_rescale (GTK_DATABOX (box), 0.05);

   separator = gtk_hseparator_new ();
   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);

   box2 = gtk_vbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
   gtk_box_pack_end (GTK_BOX (box1), box2, FALSE, TRUE, 0);
   close_button = gtk_button_new_with_label ("close");
   g_signal_connect_swapped (GTK_OBJECT (close_button), "clicked",
			     G_CALLBACK (gtk_main_quit), GTK_OBJECT (box));
   gtk_box_pack_start (GTK_BOX (box2), close_button, TRUE, TRUE, 0);
   gtk_widget_set_can_default(close_button, GTK_CAN_DEFAULT);
   gtk_widget_grab_default (close_button);

   gtk_widget_show_all (window);

}