Linear Transform

ofApp.cpp

#include "ofMain.h"

class LinearTransform {
public:
    LinearTransform() {
        
    }
    
    LinearTransform(float u11, float u12, float u13,
                       float u21, float u22, float u23,
                       float u31, float u32, float u33)
    {
        elements[0][0] = u11;
        elements[0][1] = u12;
        elements[0][2] = u13;
        
        elements[1][0] = u21;
        elements[1][1] = u22;
        elements[1][2] = u23;
        
        elements[2][0] = u31;
        elements[2][1] = u32;
        elements[2][2] = u33;
    }
    
    LinearTransform(const LinearTransform &transform) {
        *this = transform;
    }
    
    LinearTransform &operator=(const LinearTransform &transform) {
        for(int i = 0; i < 3; i++) for(int j = 0; j < 3; j++) elements[i][j] = transform.elements[i][j];
    }
    
    LinearTransform operator+(const LinearTransform &transform) const {
        return LinearTransform(elements[0][0] + transform.elements[0][0], elements[0][1] + transform.elements[0][1], elements[0][2] + transform.elements[0][2],
                                  elements[1][0] + transform.elements[1][0], elements[1][1] + transform.elements[1][1], elements[1][2] + transform.elements[1][2],
                                  elements[2][0] + transform.elements[2][0], elements[2][1] + transform.elements[2][1], elements[2][2] + transform.elements[2][2]);
    }
    
    LinearTransform operator-() const {
        return (*this) * -1.0f;
    }
    
    LinearTransform operator-(const LinearTransform &transform) const {
        return (*this) + (-transform);
    }
    
    LinearTransform operator*(float s) const {
        return LinearTransform(s * elements[0][0], s * elements[0][1], s * elements[0][2],
                                  s * elements[1][0], s * elements[1][1], s * elements[1][2],
                                  s * elements[2][0], s * elements[2][1], s * elements[2][2]);
    }
    
    ofVec3f operator*(const ofVec3f &v) const {
        return ofVec3f(elements[0][0] * v[0] + elements[0][1] * v[1] + elements[0][2] * v[2],
                       elements[1][0] * v[0] + elements[1][1] * v[1] + elements[1][2] * v[2],
                       elements[2][0] * v[0] + elements[2][1] * v[1] + elements[2][2] * v[2]);
    }
    
    inline ofVec3f operator()(const ofVec3f &v) {
        return (*this) * v;
    }
    
    float elements[3][3];
    static const LinearTransform Zero;
    static const LinearTransform E;
    
    static LinearTransform projection(const ofVec3f &u) {
        return LinearTransform(u[0] * u[0], u[0] * u[1], u[0] * u[2],
                                  u[1] * u[0], u[1] * u[1], u[1] * u[2],
                                  u[2] * u[0], u[2] * u[1], u[2] * u[2]);
    }
    
    static LinearTransform rejection(const ofVec3f &u) {
        return E - projection(u);
    }
};

const LinearTransform LinearTransform::Zero = LinearTransform();
const LinearTransform LinearTransform::E = LinearTransform(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);

std::ostream &operator<<(std::ostream &os, const LinearTransform &transform) {
    return os << transform.elements[0][0] << ", " << transform.elements[0][1] << ", " << transform.elements[0][2] << ", " << std::endl
              << transform.elements[1][0] << ", " << transform.elements[1][1] << ", " << transform.elements[1][2] << ", " << std::endl
              << transform.elements[2][0] << ", " << transform.elements[2][1] << ", " << transform.elements[2][2];
}

class ofApp : public ofBaseApp {
    ofVec3f v;
    ofVec3f u;
    ofEasyCam cam;
public:
    void setup() {
        v.set(100, 200, -50);
        u.set(4, 4, 2);
        u.normalize();
    }
    void update() {
        ofVec3f r(1, 0, 0);
        r.rotate(ofRandom(0, M_PI), ofVec3f(ofRandom(-1, 1), ofRandom(-1, 1), ofRandom(-1, 1)));
        v += r * ofRandom(-1, 1);
    }
    void draw() {
        cam.begin();
        
        ofBackground(0, 0, 0);
        
        ofSetColor(255, 255, 255);
        ofDrawLine(ofVec3f(), u * 300);
        
        ofSetColor(255, 0, 0);
        ofDrawLine(ofVec3f(), v);
        
        ofSetColor(0, 255, 0);
        LinearTransform prj(LinearTransform::projection(u));
        ofDrawLine(ofVec3f(), prj(v));
        
        ofSetColor(0, 0, 255);
        LinearTransform rej(LinearTransform::rejection(u));
        ofDrawLine(ofVec3f(), rej(v));
        
        cam.end();
    }
};

int main() {
    ofSetupOpenGL(1280, 720, OF_WINDOW);
    ofRunApp(new ofApp);
}