main.cpp

Go to the documentation of this file.

#define _USE_MATH_DEFINES
#include <math.h>
#include <iostream>
#include <fstream>
#include <string>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#ifdef _WIN32
#ifndef MSKDLL 
#define MSKDLL 
#endif
#endif
#include "mosek.h"
#include "util.h"
#include "Mesh.h"
#include "AnglesOptimization.h"
#include "EnergyMinimization.h"
#include "Layout.h"

using namespace std;

void putOptionsInFromFile (int & argc, char * argv[], vector<string> & options);
void putOptionsIn         (int & argc, char * argv[], vector<string> & options);
void parseOptions (const vector<string> & options, ProgramOptions &po);
void checkOptions (ProgramOptions &po);
void initializeMosek (MSKenv_t & env, MSKtask_t & angleTask, MSKtask_t & radiiTask);

int main (int argc, char *argv[]) {

   vector<string> options;

   if (argc < 2 || (argc != 2 && argc < 5))
      usage();

   if (argc == 2) {
      if (!strcmp(argv[1],"-help")){
          usage();
          exit(1);
      }
      else if (!strcmp(argv[1],"-h")){
          usage();
          exit(1);
      }
      putOptionsInFromFile(argc, argv, options);
   }
   else
      putOptionsIn(argc, argv, options);

   clock_t startTime, finishTime;


   ProgramOptions po;
   parseOptions(options, po);
   checkOptions(po);

   // Read in the mesh
   cout << "Parsing the mesh ";
   Mesh mesh;
   if (po.read_obj) {
      cout << po.file_in << " (OBJ format)..." << endl;
      mesh.readOBJ(po.file_in.c_str());
      mesh.computeMeshInfo();
      mesh.computeLengths();
      mesh.computeInitAngles();
   }
   else if (po.read_conn) {
      cout << po.file_in << " (CON format)..." << endl;
      mesh.readCON(po.file_in.c_str());
      mesh.computeMeshInfo();
      mesh.computeInitAngles();
   }

   if (po.read_vert) {
      cout << "Reading cone singularities file " << po.vert_file << "..." << endl;
      mesh.readCONE_VERT(po.vert_file.c_str());
   }

   startTime = clock ();
  
   if (po.do_optim) {
      mesh.checkGaussianCurvature();

      // Create MOSEK enviroment
      MSKenv_t  env;
      MSKtask_t angleTask, radiiTask;
      initializeMosek(env, angleTask, radiiTask);

      // Optimize the angles
      cout << "Optimizing for valid angles..." << endl;
      AnglesOptimization anglesOptimization(&mesh, env);
      anglesOptimization.doSolve();

      cout << "Minimizing energy to find radii..." << endl;
      EnergyMinimization energyMin(&mesh, env);
      energyMin.doSolve();
   }

   // Layout the mesh
   cout << "Laying out the mesh.." << endl;
   Layout lay(&mesh);
   if (po.do_optim)
      lay.computeEdgeLengthAndAngles();


   if (po.read_edges) {
      cout << "Reading edges from " << po.edge_file << "..." << endl;
      cout << "Cutting the mesh..." << endl;
      mesh.readCUT_EDGES(po.edge_file.c_str());
   }

   if (po.write_obj || po.write_vt) {
      if (po.read_edges) {
          lay.validCuts();
      }
      lay.layoutMesh();
   }
    
   finishTime = clock();

   if (po.write_conn) {    
      cout << "Writing out the results " << endl;
      cout << po.conn_file_out << " (CON format)..." << endl;
      mesh.writeCON(po.conn_file_out.c_str());
   }

   if (po.write_obj) {
      cout << "Writing out the results " << endl;
      cout << po.obj_file_out << " (OBJ format)..." << endl;
      mesh.writeOBJ(po.obj_file_out.c_str());
   }

   if (po.write_vt) {
      cout << "Writing out the results " << endl;
      cout << po.obj_file_out << " (VT format)..." << endl;
      mesh.writeVT(po.vt_file_out.c_str());
   }

   cout << "\nFinnished, total: " 
      <<  ((double(finishTime)-double(startTime))/CLOCKS_PER_SEC) << " seconds." << endl;

}

void initializeMosek (MSKenv_t & env, MSKtask_t & angleTask, MSKtask_t & radiiTask) {
   int r = MSK_RES_OK;

   /* Make the mosek environment. */
   //r = MSK_makeenv(&env, NULL, NULL, NULL);
   r = MSK_makeenv(&env,NULL,NULL,NULL,NULL);
   check_error (r != MSK_RES_OK, "Cannot create MOSEK enviroment.");

   /* Directs the log stream to the user
   specified procedure 'printstr'. */
   r = MSK_linkfiletoenvstream(env, MSK_STREAM_LOG, "_EnvMosekOut.txt", 0);
   check_error (r != MSK_RES_OK, "Cannot link MOSEK \"_EnvMosekOut.txt\" output file.");

   /* Initialize the environment. */   
   r = MSK_initenv(env);
   check_error (r != MSK_RES_OK, "Cannot initialize MOSEK enviroment.");
}

void putOptionsInFromFile (int & argc, char * argv[], vector<string> & options) {
   ifstream in (argv[1]);
   check_error(!in, "Cannot open input file with options: " + string(argv[1]));
   string option;
   while (!in.eof()) {
      in >> ws;
      if (in.peek() == '\"') {
         in.ignore(1);
          getline(in, option, '\"');
          in.ignore(1);
      }
      else
          in >> option;
      options.push_back(option);
   }
}

void putOptionsIn (int & argc, char * argv[], vector<string> & options) {
   for (int i = 1; i < argc; i++) {
      options.push_back(string(argv[i]));
   }
}

void checkOptions (ProgramOptions &po) {
   check_error((po.read_obj && po.read_conn), "Can only read one format at a time." );
   check_error((!po.read_obj && !po.read_conn), "No input file specified." );
   check_error((!po.write_conn && !po.write_obj && !po.write_vt), "No output file specified." ); 
}

void parseOptions (const vector<string> & options, ProgramOptions &po) {
   for (unsigned int i = 0; i < options.size(); i++) {
      if (!strcmp(options[i].c_str(),"-io")){
          po.read_obj = true;
          check_error(i >= (options.size() - 1), string("No value for option speficied: ")+options[i]);
          po.file_in = options[++i].c_str();

      }
      else if (!strcmp(options[i].c_str(),"-ic")){
          po.read_conn = true;
          check_error(i >= (options.size() - 1), string("No value for option speficied: ")+options[i]);
          po.file_in = options[++i].c_str();
      }
      else if (!strcmp(options[i].c_str(),"-iv")){
          po.read_vert = true;
          check_error(i >= (options.size() - 1), string("No value for option speficied: ")+options[i]);
          po.vert_file = options[++i].c_str();
      }
      else if (!strcmp(options[i].c_str(),"-ie")){
          po.read_edges = true;
          check_error(i >= (options.size() - 1), string("No value for option speficied: ")+options[i]);
          po.edge_file = options[++i].c_str();
      }
      else if (!strcmp(options[i].c_str(),"-oo")){
          po.write_obj = true;
          check_error(i >= (options.size() - 1), string("No value for option speficied: ")+options[i]);
          po.obj_file_out = options[++i].c_str();
      }
      else if (!strcmp(options[i].c_str(),"-ovt")){
          po.write_vt = true;
          check_error(i >= (options.size() - 1), string("No value for option speficied: ")+options[i]);
          po.vt_file_out = options[++i].c_str();
      }
      else if (!strcmp(options[i].c_str(),"-oc")){
          po.write_conn = true;
          check_error(i >= (options.size() - 1), string("No value for option speficied: ")+options[i]);
          po.conn_file_out = options[++i].c_str();
      }
      else if (!strcmp(options[i].c_str(),"-no")){
          po.do_optim = false;
      }
      else {
          cerr << "Warning, Unrecognized option: " << options[i].c_str() << endl;
      }
   }
}

---