Model.cpp

Go to the documentation of this file.

#include "Model.h"

using namespace model;

Model::~Model() {

}

void Model::setVertexs(vector<Vertex*> vertexs) {
        m_vertexs = vertexs;
}

Vertex* Model::getVertex(int i) {
        return m_vertexs[i];
}

vector<Vertex*> Model::getVertexs() {
        return m_vertexs;
}

Matrix Model::getModelVertexs() {
        int size = m_vertexs.size();
        Matrix v(size*3,1);
        for(int i=0; i<(int)m_vertexs.size(); i++) {
                IvVector3* tmp = m_vertexs[i]->getCoordinates();
                v((i*3)+1,1) = tmp->x;
                v((i*3)+2,1) = tmp->y;
                v((i*3)+3,1) = tmp->z;
        }
        return v;
}

void Model::addVertex(Vertex* vertex) { 
        vertex->setIndex(m_vertexs.size());
        m_vertexs.push_back(vertex);
}

void Model::removeVertex(Vertex* vertex) {
        //m_vertexs.erase(vertex);
}

void Model::updateVertices(Matrix vertexs) {
        printf("Model::updateVertices\n");
        for(int i=0; i<(int)m_vertexs.size();i++) {
                float x = (float)vertexs(i*3+1,1);
                float y = (float)vertexs(i*3+2,1);
                float z = (float)vertexs(i*3+3,1);
                m_vertexs[i]->updateCoordinates(x,y,z);
        }
}


void Model::setFaces(vector<Face*> faces) {
        m_faces = faces;
}

Face* Model::getFace(int i) {
        return m_faces[i];
}

vector<Face*> Model::getFaces() {
        return m_faces;
}

void Model::addFace(Face* face) {
        m_faces.push_back(face);
}

void Model::removeFace(Face* face) {
        //m_faces.remove(face);
}

void Model::setLandmarks(vector<Landmark*> landmarks) {
        m_landmarks = landmarks;
}

vector<Landmark*> Model::getLandmarks() {
        return m_landmarks;
}

void Model::addLandmark(Landmark* landmark) {
        m_landmarks.push_back(landmark);
}

void Model::removeLandmark(Landmark* landmark) {
        //m_landmarks.remove(landmark);
}

void Model::setContours(vector<Contour*> contours) {
        m_contours = contours;
}

vector<Contour*> Model::getContours() {
        return m_contours;
}

void Model::addContour(Contour* contour) {
        m_contours.push_back(contour);
}

void Model::removeContour(Contour* contour) {
        //m_contours.remove(contour);
}

void Model::setAnnotations(vector<Annotation*> annotations) {
        m_annotations = annotations;
}

vector<Annotation*> Model::getAnnotations() {
        return m_annotations;
}

void Model::addAnnotation(Annotation* annotation) {
        m_annotations.push_back(annotation);
}

void Model::removeAnnotation(Annotation* annotation) {
        //m_annotations.remove(annotation);
}

bool Model::save(char* filename) {
        ofstream saveFile(filename);
        bool res = save(&saveFile);
        saveFile.close();
        return res;
}

bool Model::save(ofstream* saveFile) {
        if(saveFile->is_open()) {
                *saveFile << "Vertex\n";
                for(int i=0;i<(int)m_vertexs.size();i++) {
                        *saveFile << m_vertexs[i]->getCoordinates()->x << " ";
                        *saveFile << m_vertexs[i]->getCoordinates()->y << " ";
                        *saveFile << m_vertexs[i]->getCoordinates()->z << ",";
                }
                *saveFile << "\n";
                for(int i=0;i<(int)m_vertexs.size();i++) {
                        *saveFile << m_vertexs[i]->getNormal()->x << " ";
                        *saveFile << m_vertexs[i]->getNormal()->y << " ";
                        *saveFile << m_vertexs[i]->getNormal()->z << ",";
                }
                *saveFile << "\nFace\n";
                for(int i=0;i<(int)m_faces.size();i++) {
                        *saveFile << m_faces[i]->getVertex(0)->getIndex() << " ";
                        *saveFile << m_faces[i]->getVertex(1)->getIndex() << " ";
                        *saveFile << m_faces[i]->getVertex(2)->getIndex() << ",";
                }
                *saveFile << "\nLandmark\n";
                for(int i=0;i<(int)m_landmarks.size();i++) {
                        //saveFile << m_landmarks[i] << " ";
                }
                *saveFile << "\nContour\n";
                for(int i=0;i<(int)m_contours.size();i++) {
                        //saveFile << m_contours[i] << " ";
                }
                *saveFile << "\nAnnotation\n";
                for(int i=0;i<(int)m_annotations.size();i++) {
                        //saveFile << m_annotations[i] << " ";
                }
                *saveFile << "\n";
                return true;
        } else {
                return false;
        }
}

bool Model::load(char* filename) {
        ifstream loadFile(filename);
        bool res = load(&loadFile);
        loadFile.close();
        return res;
}

bool Model::load(ifstream* loadFile) {
        m_vertexs.clear();
        m_faces.clear();
        m_landmarks.clear();
        m_contours.clear();
        m_annotations.clear();


        string line;
        vector<string> tokens;
        vector<string> coords;
        if(loadFile->is_open()) {
                getline(*loadFile,line);//Vertex
                getline(*loadFile,line);//Coords
                tokens.clear();
                Tokenize(line,tokens,",");
                for(int i=0;i<(int)tokens.size();i++) {
                        coords.clear();
                        Tokenize(tokens[i],coords," ");
                        Vertex* vertex = new Vertex();
                        vertex->setCoordinates(convertTo<float>(coords[0]),convertTo<float>(coords[1]),convertTo<float>(coords[2]));
                        addVertex(vertex);
                }
                getline(*loadFile,line);//Normals
                tokens.clear();
                Tokenize(line,tokens,",");
                for(int i=0;i<(int)tokens.size();i++) {
                        coords.clear();
                        Tokenize(tokens[i],coords," ");
                        Vertex* vertex = getVertex(i);
                        vertex->setNormal(convertTo<float>(coords[0]),convertTo<float>(coords[1]),convertTo<float>(coords[2]));
                }
                getline(*loadFile,line);//Face
                getline(*loadFile,line);//Indexs
                tokens.clear();
                Tokenize(line,tokens,",");
                for(int i=0;i<(int)tokens.size();i++) {
                        coords.clear();
                        Tokenize(tokens[i],coords," ");
                        Face* face = new Face();
                        face->setVertices(m_vertexs[convertTo<int>(coords[0])],m_vertexs[convertTo<int>(coords[1])],m_vertexs[convertTo<int>(coords[2])]);
                        addFace(face);
                }
                getline(*loadFile,line);//Landmark
                getline(*loadFile,line);//Data
                tokens.clear();
                Tokenize(line,tokens,",");
                for(int i=0;i<(int)tokens.size();i++) {
                        coords.clear();
                        Tokenize(tokens[i],coords," ");
                        //addLandmark
                }
                getline(*loadFile,line);//Contour
                getline(*loadFile,line);//Data
                tokens.clear();
                Tokenize(line,tokens,",");
                for(int i=0;i<(int)tokens.size();i++) {
                        coords.clear();
                        Tokenize(tokens[i],coords," ");
                }
                getline(*loadFile,line);//Annotation
                getline(*loadFile,line);//Data
                tokens.clear();
                Tokenize(line,tokens,",");
                for(int i=0;i<(int)tokens.size();i++) {
                        coords.clear();
                        Tokenize(tokens[i],coords," ");
                }
                return true;
        } else {
                return false;
        }
}

---