Lineare Interpolation und Spherical Linear Interpolation eines Affenköpfchens

[Kaira]

Hallo zusammen,

ich habe in 3d Computergrafik die Aufgabe den modellierten Kopf eines Affen zu transformieren

a) Lineare Interpolation (lerp) der Elemente der Rotationsmatrix
b) Lineare Interpolation (lerp) mittels Eulerwinkeln
c) Spherical Linear Interpolation (slerp) mittels Quaternionen

Die Variable t läuft während eines Durchlaufs von 0.0 bis 1.0 und definiert den aktuellen Stand der
Interpolation. Die Start- und Endorientierung werden durch Eulerwinkel beschrieben und in den
Variablen m_angles0 und m_angles1 gespeichert.
Implementieren Sie (1) eine lineare Interpolation der Matrixelemente in der Methode interpolateMatrix,
(2) eine lineare Interpolation mittels Eulerwinkeln in interpolateEuler, und schließlich (3) eine
sphärische Interpolation mit Hilfe von Quaternionen in der Methode interpolateQuaternion. Implementieren
Sie zudem die Hilfsmethoden lerp und slerp. Die Funktionen sollen in der Methode
applyBallTransformation in exercise13.cpp umgesetzt werden.

[code="cpp"]
#include <QMatrix4x4>
#include <QKeyEvent>
#include <QRectF>
#include <QSettings>

#include "exercise13.h"
#include "polygonaldrawable.h"
#include "objio.h"
#include "mathmacros.h"

#include <math.h>

//[-------------------------------------------------------]
//[ Definitions ]
//[-------------------------------------------------------]
namespace
{
const QString settingsGroup("SlerpRotation");
}

//[-------------------------------------------------------]
//[ Helper functions ]
//[-------------------------------------------------------]

Exercise13::Exercise13(QWidget * parent)
: AbstractGLExercise(parent),
m_drawable(NULL),
m_mesh(-1),
m_base(-1)
{
// setup angles and view
m_angles0[0] = 0.0f;
m_angles0[1] = 0.0f;
m_angles0[2] = 0.0f;

m_angles1[0] = 0.0f;
m_angles1[1] = 0.0f;
m_angles1[2] = 0.0f;

m_view = QMatrix4x4();
m_view.lookAt(
QVector3D( 0.0f, 2.0f, 10.0f),
QVector3D( 0.0f, 0.0f, 0.0f),
QVector3D( 0.0f, 1.0f, 0.0f));
}

Exercise13::~Exercise13()
{
// clean up, save view settings for later use
QSettings s;
s.beginGroup(settingsGroup);

s.setValue("angle_x", m_angles0[0]);
s.setValue("angle_y", m_angles0[1]);
s.setValue("angle_z", m_angles0[2]);

s.endGroup();

delete m_drawable;
}

const bool Exercise13::initialize()
{
if(m_drawable)
return true;

// load obj file
m_drawable = ObjIO::fromObjFile("../data/suzanne.obj");

//setup view by loading formerly saved view configuration
QSettings s;
s.beginGroup(settingsGroup);

m_angles0[0] = s.value("angle_x", 0.0f).toFloat();
m_angles0[1] = s.value("angle_y", 0.0f).toFloat();
m_angles0[2] = s.value("angle_z", 0.0f).toFloat();

m_angles1[0] = 0.0f;
m_angles1[1] = 0.0f;
m_angles1[2] = 0.0f;

s.endGroup();

return true;
}

void Exercise13::drawEnvironment(
const float x0,
const float y0,
const float x1,
const float y1)
{
const float dy = (y1 - y0) * 0.5;

glPushMatrix();
glTranslatef( x0, y0, 0.f);

for(int i = 0; i < 3; ++i)
{
glPushMatrix();
glRotatef(m_angles0[0], 1.0f, 0.0f, 0.0f);
glRotatef(m_angles0[1], 0.0f, 1.0f, 0.0f);
glRotatef(m_angles0[2], 0.0f, 0.0f, 1.0f);
drawUnitBase();
glPopMatrix();

glTranslatef( 0.0f, dy, 0.0f);
}
glPopMatrix();

glPushMatrix();
glTranslatef( x1, y0, 0.0f);

for(int i = 0; i < 3; ++i)
{
glPushMatrix();
glRotatef(m_angles1[0], 1.0f, 0.0f, 0.0f);
glRotatef(m_angles1[1], 0.0f, 1.0f, 0.0f);
glRotatef(m_angles1[2], 0.0f, 0.0f, 1.0f);
drawUnitBase();
glPopMatrix();

glTranslatef( 0.0f, dy, 0.0f);
}
glPopMatrix();
}

void Exercise13::paintGL()
{
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

glLoadMatrixf(m_view.data());

static const GLfloat mat_diffuse_white[] = { 1.0f, 1.0f, 1.0f, 0.0f};

static const float tx[2] = { -4.0f, +4.0f };
static const float ty[2] = { +2.0f, -2.0f };
static const float dy = (ty[1] - ty[0]) * 0.5f;

drawEnvironment(tx[0], ty[0], tx[1], ty[1]);

static QMatrix4x4 scale;
if(scale.isIdentity())
scale.scale(0.8f);

float t = static_cast<float>(m_frame % 360) / 360.f;
float x = (tx[1] - tx[0]) * t + tx[0];

glShadeModel(GL_FLAT);

for(int i = 0; i < 3; ++i)
{
glPushMatrix();

float y = ty[0] + dy * i;
glTranslatef( x, y, 0.0f);

// rotate the model
switch(i)
{
case 0:
interpolateMatrix(t);
break;
case 1:
interpolateEuler(t);
break;
case 2:
interpolateQuaternion(t);
break;
default:
break;
}

// set the material of the model
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse_white);
m_drawable->draw(m_mesh, scale);

// render local coordinate system of the model
glEnable(GL_DEPTH_TEST);
drawUnitBase(m_base);

glPopMatrix();
}
}

void Exercise13::interpolateEuler(const float t)
{
/////////////////////////////////////////////////////////////////////////////////////////////////
// TODO: Aufgabe 13
// - Interpolate rotations by interpolating between the euler angles
// - hint: use the lerp method (to be defined below)
// - hint: use glRotatef calls for applying the rotation(s)
/////////////////////////////////////////////////////////////////////////////////////////////////

//float x, y, z;
}

void Exercise13::interpolateQuaternion(const float t)
{
/////////////////////////////////////////////////////////////////////////////////////////////////
// TODO: Aufgabe 13
// - Implement a spherical interpolation based on quaternions
// - hint: use the quat method to convert the matrices to quaternions
// - hint: use the axisAngle method to get the axis and the angle represented by a quaternion
// - hint: use the slerp method (to be defined below)
// - hint: use glRotatef calls for applying the rotation(s)
/////////////////////////////////////////////////////////////////////////////////////////////////

//QMatrix4x4 A, B;
}

void Exercise13::interpolateMatrix(const float t)
{
/////////////////////////////////////////////////////////////////////////////////////////////////
// TODO: Aufgabe 13
// - Interpolate between the elements of the matrices
// - hint: use the lerp method (to be defined below)
// - hint: use glMultMatrix to apply the rotation
/////////////////////////////////////////////////////////////////////////////////////////////////

//QMatrix4x4 A, B;
//float C[16];
}

void Exercise13::slerp(
float result[4],
const float a[4],
const float b[4],
const float & t)
{
/////////////////////////////////////////////////////////////////////////////////////////////////
// TODO: Aufgabe 13
// - Implement the slerp function.
// - Keep in mind, that sin(x) might equal zero. Handle that case appropriately.
/////////////////////////////////////////////////////////////////////////////////////////////////
}

void Exercise13::lerp(
float & result,
const float & a,
const float & b,
const float & t)
{
/////////////////////////////////////////////////////////////////////////////////////////////////
// TODO: Aufgabe 13
// - Implement a linear interpolation between a and b as a function of t.
/////////////////////////////////////////////////////////////////////////////////////////////////
}

void Exercise13::quat(
float q[4],
const float m[16])
{
double tr = m[0 + 4 * 0] + m[1 + 4 * 1] + m[2 + 4 * 2];
if (tr > 0.0)
{
q[3] = 0.5 * sqrt(tr + 1.0);
float s = 0.25 / q[3];
q[0] = (m[2 + 4 * 1] - m[1 + 4 * 2]) * s;
q[1] = (m[0 + 4 * 2] - m[2 + 4 * 0]) * s;
q[2] = (m[1 + 4 * 0] - m[0 + 4 * 1]) * s;
}
else
{
int i(0), j, k;

if (m[1 + 4 * 1] > m[0 + 4 * 0])
i = 1;
if (m[2 + 4 * 2] > m[i + 4 * i])
i = 2;

static const int nxt[3] = { 1, 2, 0 };

j = nxt[i];
k = nxt[j];

q[i] = 0.5 * sqrt(m[i + 4 * i] - m[j + 4 * j] - m[k + 4 * k] + 1.0);

float s = 0.25f / q[i];

q[3] = (m[k + 4 * j] - m[j + 4 * k]) * s;
q[j] = (m[j + 4 * i] + m[i + 4 * j]) * s;
q[k] = (m[k + 4 * i] + m[i + 4 * k]) * s;
}
}

void Exercise13::axisAngle(
float & angle,
float axis[3],
const float q[4])
{
const double d = q[0] * q[0] + q[1] * q[1] + q[2] * q[2];
double s = 1.0 / sqrt(d + q[3] * q[3]);

angle = _deg(2.f * atan2(sqrt(d), static_cast<double>(q[3])));

axis[0] = q[0] * s;
axis[1] = q[1] * s;
axis[2] = q[2] * s;
}

void Exercise13::keyPressEvent(QKeyEvent* keyEvent)
{
int i = 0;

switch(keyEvent->key())
{
// pause/unpause rendering when space key was pressed
case Qt::Key_Space:
isActive() ? disable() : enable();
break;
// adjust the start rotation
case Qt::Key_Z:
++i;
case Qt::Key_Y:
++i;
case Qt::Key_X:
m_angles0[i] += keyEvent->modifiers() & Qt::SHIFT ? 1.f : -1.f;
updateGL();
break;
// reset the start rotation
case Qt::Key_R:
m_angles0[0] = 0.0f;
m_angles0[1] = 0.0f;
m_angles0[2] = 0.0f;
updateGL();
break;
default:
break;
}

AbstractGLExercise::keyPressEvent(keyEvent);
}

const QString Exercise13::hints() const
{
return "Press [SPACE] to pause/resume animation. Use X, Y, and Z keys to modify orientation at start.";
}

Leider verstehe ich die Aufgabe überhaupt nicht und somit weiß ich auch nicht wonach ich im Internet wirklich suchen soll

Kann mir bitte jemand helfen?

Vielen Dank im Voraus.

Kaira

[Namenloser324]

Nutz doch zu aller erst die C++-Tags für deinen Code, dann sieht er deutlich besser aus im Forum und die Leute sind gewillter dir zu helfen.
Unter dem Postfenster einfach auf die Kachel mit "C++" klicken und damit deinen Code einrahmen.

[HPI-Student Nr 1]

Bin im selben Modul und fühle mich auch leicht überfordert (@Kaira: aber die folien anschauen hat mir deutlich weiter geholfen :D).

Also die erste Methode funktioniert im grundsätzlichen so, dass du das Objekt in den Ursprung eines Koordinatensystems bringts und dann rotierst mittels Rotationsmatrizen.
Wenn ich das richtig gesehen habe in den Folien, gibt es dafür die Matrizen R_x(Theta), R_y(Theta) und R_z(Theta), die jede Richtung separat drehen.
Wenn man also einen Richtungsvektor DoF ("Direction of Flight") hat, multipliziert man die 4x4-Matrix mit diesem Vektor und erhält den Vektor entsprechend rotiert um den Winkel Theta.
Das ist aber nur so, wie ich es verstanden habe

Die genaue Aufgabenstellung mit einem veranschaulichendem Bild:
http://www.directupload.net/file/d/3634/sawn7ejr_png.htm

Das zu zeichnende Objekt (also der Affenkopf) liegt außerhalb in im Unterordner namens suzanne.obj.
Bei mir fängts schon da an mit den Problemen:

Reading geometry failed: "../../data/suzanne.obj" does not exist.
Das Programm ist abgestürzt.

Ich habe auch mal getwcd ausgeführt, um rauszufinden, in welchem Verzeichnis die auszuführende Datei liegt und der Pfad "../data/suzanne.obj", mit dem das geladen wird, ist richtig
Kennt sich jemand mit der Methode und möglichen Problemen aus?

Hier mal die Datei richtig codiert von mir

// ======================================
// 3D Computergrafik
// moodle.hpi3d.de
// ======================================
//
// Sommersemester 2014 - Aufgabenblatt 3
//                     - Aufgabe 13
//
// Diese Datei bearbeiten.
//
// Bearbeiter
// Matr.-Nr: xxxxx
// Matr.-Nr: xxxxx
//
// ======================================

//
// Qt
//
#include <QMatrix4x4>
#include <QKeyEvent>
#include <QRectF>
#include <QSettings>

#include "exercise13.h"
#include "polygonaldrawable.h"
#include "objio.h"
#include "mathmacros.h"

#include <math.h>
#include <iostream>
#include <unistd.h>

//[-------------------------------------------------------]
//[ Definitions                                           ]
//[-------------------------------------------------------]
namespace
{
    const QString settingsGroup("SlerpRotation");
}

//[-------------------------------------------------------]
//[ Helper functions                                      ]
//[-------------------------------------------------------]

Exercise13::Exercise13(QWidget * parent)
:   AbstractGLExercise(parent),
    m_drawable(NULL),
    m_mesh(-1),
    m_base(-1)
{
    // setup angles and view
    m_angles0[0] = 0.0f;
    m_angles0[1] = 0.0f;
    m_angles0[2] = 0.0f;

    m_angles1[0] = 0.0f;
    m_angles1[1] = 0.0f;
    m_angles1[2] = 0.0f;

    m_view = QMatrix4x4();
    m_view.lookAt(
        QVector3D( 0.0f, 2.0f, 10.0f),
        QVector3D( 0.0f, 0.0f,  0.0f),
        QVector3D( 0.0f, 1.0f,  0.0f));
}

Exercise13::~Exercise13()
{
    // clean up, save view settings for later use
    QSettings s;
    s.beginGroup(settingsGroup);

    s.setValue("angle_x", m_angles0[0]);
    s.setValue("angle_y", m_angles0[1]);
    s.setValue("angle_z", m_angles0[2]);

    s.endGroup();

    delete m_drawable;
}

const bool Exercise13::initialize()
{
    if(m_drawable)
        return true;

    // load obj file
    char *confpath;

    getcwd(confpath, 256);
    std::cout << "Path: %s\n" << confpath << std::endl;

    m_drawable = ObjIO::fromObjFile("../data/suzanne.obj");

    //setup view by loading formerly saved view configuration
    QSettings s;
    s.beginGroup(settingsGroup);

    m_angles0[0] = s.value("angle_x", 0.0f).toFloat();
    m_angles0[1] = s.value("angle_y", 0.0f).toFloat();
    m_angles0[2] = s.value("angle_z", 0.0f).toFloat();

    m_angles1[0] = 0.0f;
    m_angles1[1] = 0.0f;
    m_angles1[2] = 0.0f;

    s.endGroup();

    return true;
}

void Exercise13::drawEnvironment(
    const float x0,
    const float y0,
    const float x1,
    const float y1)
{
    const float dy = (y1 - y0) * 0.5;

    glPushMatrix();
    glTranslatef( x0,  y0, 0.f);

    for(int i = 0; i < 3; ++i)
    {
        glPushMatrix();
        glRotatef(m_angles0[0], 1.0f, 0.0f, 0.0f);
        glRotatef(m_angles0[1], 0.0f, 1.0f, 0.0f);
        glRotatef(m_angles0[2], 0.0f, 0.0f, 1.0f);
        drawUnitBase();
        glPopMatrix();

        glTranslatef( 0.0f, dy, 0.0f);
    }
    glPopMatrix();

    glPushMatrix();
    glTranslatef( x1,  y0, 0.0f);

    for(int i = 0; i < 3; ++i)
    {
        glPushMatrix();
        glRotatef(m_angles1[0], 1.0f, 0.0f, 0.0f);
        glRotatef(m_angles1[1], 0.0f, 1.0f, 0.0f);
        glRotatef(m_angles1[2], 0.0f, 0.0f, 1.0f);
        drawUnitBase();
        glPopMatrix();

        glTranslatef( 0.0f, dy, 0.0f);
    }
    glPopMatrix();
}

void Exercise13::paintGL()
{
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

    glLoadMatrixf(m_view.data());

    static const GLfloat mat_diffuse_white[] = { 1.0f, 1.0f, 1.0f, 0.0f};

    static const float tx[2] = { -4.0f, +4.0f };
    static const float ty[2] = { +2.0f, -2.0f };
    static const float dy    = (ty[1] - ty[0]) * 0.5f;

    drawEnvironment(tx[0], ty[0], tx[1], ty[1]);

    static QMatrix4x4 scale;
    if(scale.isIdentity())
        scale.scale(0.8f);

    float t = static_cast<float>(m_frame % 360) / 360.f;
    float x = (tx[1] - tx[0]) * t + tx[0];

    glShadeModel(GL_FLAT);

    for(int i = 0; i < 3; ++i)
    {
        glPushMatrix();

        float y = ty[0] + dy * i;
        glTranslatef( x, y, 0.0f);

        // rotate the model
        switch(i)
        {
            case 0: 
                interpolateMatrix(t);
                break;
            case 1: 
                interpolateEuler(t);
                break;
            case 2: 
                interpolateQuaternion(t);
                break;
            default: 
                break;
        }

        // set the material of the model
        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse_white);
        m_drawable->draw(m_mesh, scale);

        // render local coordinate system of the model
        glEnable(GL_DEPTH_TEST);
        drawUnitBase(m_base);

        glPopMatrix();
    }
}

void Exercise13::interpolateEuler(const float t)
{
    /////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO: Aufgabe 13
    // - Interpolate rotations by interpolating between the euler angles
    // - hint: use the lerp method (to be defined below)
    // - hint: use glRotatef calls for applying the rotation(s)
    /////////////////////////////////////////////////////////////////////////////////////////////////

    //float x, y, z;
}

void Exercise13::interpolateQuaternion(const float t)
{
    /////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO: Aufgabe 13
    // - Implement a spherical interpolation based on quaternions
    // - hint: use the quat method to convert the matrices to quaternions
    // - hint: use the axisAngle method to get the axis and the angle represented by a quaternion
    // - hint: use the slerp method (to be defined below)
    // - hint: use glRotatef calls for applying the rotation(s)
    /////////////////////////////////////////////////////////////////////////////////////////////////

    //QMatrix4x4 A, B;
}

void Exercise13::interpolateMatrix(const float t)
{
    /////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO: Aufgabe 13
    // - Interpolate between the elements of the matrices
    // - hint: use the lerp method (to be defined below)
    // - hint: use glMultMatrix to apply the rotation
    /////////////////////////////////////////////////////////////////////////////////////////////////

    //QMatrix4x4 A, B;
    //float C[16];
}

void Exercise13::slerp(
    float result[4],
    const float a[4],
    const float b[4],
    const float & t)
{
    /////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO: Aufgabe 13
    // - Implement the slerp function.
    // - Keep in mind, that sin(x) might equal zero. Handle that case appropriately.
    /////////////////////////////////////////////////////////////////////////////////////////////////
    float th;
    for(int i=0; i<4; i++){
        th = acos(a[i]*b[i]);
        result[i] = sin((1-t)*th)/sin(th)*a[i] + sin(th*t)/sin(th) * b[i];
    }
}

void Exercise13::lerp(
    float & result,
    const float & a,
    const float & b,
    const float & t)
{
    /////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO: Aufgabe 13
    // - Implement a linear interpolation between a and b as a function of t.
    /////////////////////////////////////////////////////////////////////////////////////////////////

    result = a < b? (b-a)*t : (a-b)*t;
}

void Exercise13::quat(
    float q[4],
    const float m[16])
{   
	double tr = m[0 + 4 * 0] + m[1 + 4 * 1] + m[2 + 4 * 2];
	if (tr > 0.0) 
    {
		q[3] = 0.5 * sqrt(tr + 1.0);
		float s = 0.25 / q[3];
		q[0] = (m[2 + 4 * 1] - m[1 + 4 * 2]) * s;
		q[1] = (m[0 + 4 * 2] - m[2 + 4 * 0]) * s;
		q[2] = (m[1 + 4 * 0] - m[0 + 4 * 1]) * s;
	}
	else 
    {
        int i(0), j, k;

        if (m[1 + 4 * 1] > m[0 + 4 * 0])
            i = 1;
		if (m[2 + 4 * 2] > m[i + 4 * i]) 
            i = 2;

        static const int nxt[3] = { 1, 2, 0 };

        j = nxt[i];
		k = nxt[j];

        q[i] = 0.5 * sqrt(m[i + 4 * i] - m[j + 4 * j] - m[k + 4 * k] + 1.0);

		float s = 0.25f / q[i];

		q[3] = (m[k + 4 * j] - m[j + 4 * k]) * s;
		q[j] = (m[j + 4 * i] + m[i + 4 * j]) * s;
		q[k] = (m[k + 4 * i] + m[i + 4 * k]) * s;
	}
}

void Exercise13::axisAngle(
    float & angle,
    float axis[3],
    const float q[4])
{
	const double d = q[0] * q[0] + q[1] * q[1] + q[2] * q[2];
	double s = 1.0 / sqrt(d + q[3] * q[3]);

	angle = _deg(2.f * atan2(sqrt(d), static_cast<double>(q[3])));

    axis[0] = q[0] * s;
	axis[1] = q[1] * s;
	axis[2] = q[2] * s;
}

void Exercise13::keyPressEvent(QKeyEvent* keyEvent)
{
    int i = 0;

    switch(keyEvent->key())
    {
        // pause/unpause rendering when space key was pressed
        case Qt::Key_Space:
            isActive() ? disable() : enable();
            break;
        // adjust the start rotation
        case Qt::Key_Z:
            ++i;
        case Qt::Key_Y:
            ++i;
        case Qt::Key_X:
            m_angles0[i] += keyEvent->modifiers() & Qt::SHIFT ? 1.f : -1.f;
            updateGL();
            break;
        // reset the start rotation
        case Qt::Key_R:
            m_angles0[0] = 0.0f;
            m_angles0[1] = 0.0f;
            m_angles0[2] = 0.0f;
            updateGL();
            break;
        default:
            break;
    }

    AbstractGLExercise::keyPressEvent(keyEvent);
}

const QString Exercise13::hints() const
{
	return "Press [SPACE] to pause/resume animation. Use X, Y, and Z keys to modify orientation at start.";
}

[SeppJ]

Was sind eure Fragen? Ihr fragt im C++-Forum. Habt ihr Schwierigkeiten mit der Sprache? Welche?
Oder ist das Forum falsch gewählt? Versteht ihr die Mathematik nicht? Oder wie 3D-Grafik funktioniert? Oder habt ihr Fragen zu OpenGL?

Einfach nur eine Aufgabenstellung zu posten und zu sagen "ich kapier nichts" wird keine hilfreichen Antworten hervor bringen (außer eure Frage lautet "wer programmiert mir für XXX Euro meine Hausaufgaben?").

[HPI-Student Nr 1]

Hab ich das nicht? Upps
Naja, also das Problem mit dem Bildladen hat sich erledigen. Die Methode ObjIO::fromObjFile [Zeile 94] mochte anscheinende keine '/' Zeichen, sondern '\'.

Also zu meinem eigentlichen Problem im ersten Aufgabenteil - die lineare Interpolation der Matrixelemente:
Wir sollen ein Objekt drehen, welches in m_drawable (PolygonDrawable) liegt. Das klingt so einfach, aber welche Variable enthält den Ursprung des Systems, auf welchem das Objekt liegt und wie rotiere ich das. Wenn ich im Code eine OpenGL_Methode (z.B. glPushMatrix() oder glMultMatrixf()) sehe, deren Arbeitsweise ich nicht verstehe, finde ich dazu auch im Internet selten etwas.
Womit soll ich denn interpolateMatrix() ergänzen? Da steht ich soll interpolieren. Ich nehme an, man soll mittels einer selbst erstellen Funktion von dem gegebenen Anfangszustand zum Zielzustand kommen - und zwar genau auf dem gezeigten Intervall von -4 bis 4 (definiert in paintGL mit tx und ty).
Wie interpoliere ich denn so etwas und wo liegt denn die aktuelle Rotation des gezeigten Objekts, die ich bearbeiten soll?
Der Startzustand liegt halt in m_angles0 und der Zielzustand in m_angles1 - so viel weiß ich.

[Kaira]

Liebes Forum,

erst mal vielen Dank an HPI-Student, das du dir zu Mühe gemacht hast.

das ich den ganzen Quellcode reingeladen habe liegt daran das wir drei kurze Einführungstutorien hatten und dazu gekommen sind variablen zu deklarieren und dann eine kleine schleife zu bauen.

Als nächstes bekamen wir einen sogenannten Programmrahmen, der von uns vervollständigt werden sollte. Dieser Sprung war für mich zu groß. Ich habe keine großen Programmiererfahren und so habe ich weder wirklich Ahnung davon was die ganzen Bibliotheken machen, geschweige denn wie ich darauf komme, welche ich einbinden muss.

Mir geht es nicht darum dass jemand anderes meine Hausaufgaben erledigt, sondern das sich mal die Zeit genommen wird mir zu erklären wie sich das alles zusammensetzt.

Das alles Learning by doing ist und nur durch das Programmieren selbst man das Programmieren lernen kann, ist mir bewusst, doch für mich war der Sprung zu weit. Deswegen habe ich auch mit den Formeln aus dem Vorlesungsskript nicht viel anfangen können, weil ich dann trotzdem nicht weiß, wie ich die Formel in c++ darstellen kann.

Ich selbst bin keine Informatikerin, sondern in einem anderen Studiengang, der das Modul als "Einführung" beinhaltet. Das es dabei viele Probleme geben kann, kann man sich vielleicht denken. Es wurde bereits ein Dialog in unserem Studiengang angestossen, um für die künftigen Generationen es besser zu machen, beispielsweise durch einen Art Brückenkurs oder so. Doch für ich kommt diese Erneuerung nicht mehr rechtzeitig, sondern muss zuehen wie ich ohne umfangreiche Kenntnisse in Programmierung diese Aufgaben bewältige.

Sollte ich jemanden deswegen auf den Schlips getreten sein, tut mir das wirklich leid, aber ich weiß ich bin nicht zu doof um soetwas zu lernen, nur nach 3 a 1,5 Stunden Grundlagen würde wahrscheinlich jeder Probleme haben diesen Levelanstieg zu bewältigen.

Noch mal vielen Dank

Gruß Kaira