Octave.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
*/
#ifndef OCTAVE_H_
#define OCTAVE_H_

#include <Debug.H>

#ifndef OCTAVE_ERROR_OFFSET
#define OCTAVE_ERROR_OFFSET -2000
#endif
//#define GEN_ERROR_OCTAVE(errNo) OCTAVE_ERROR_OFFSET+errNo

//#define OCTAVE_ERROR_INCORRECT_RETCOUNT GEN_ERROR_OCTAVE(-1)
//#define OCTAVE_ERROR_INCORRECT_RETCOUNT_STR std::string("Octave returned the incorrect number of elements - error")

#define OCTAVE_NOBASE_ERROR -1+OCTAVE_ERROR_OFFSET
#define OCTAVE_OPENCV_TYPE_ERROR -2+OCTAVE_ERROR_OFFSET
#define OCTAVE_INCONSISTENT_COL_CNT_ERROR -3+OCTAVE_ERROR_OFFSET

class OctaveDebug : virtual public Debug {
public:
    OctaveDebug() {
#ifndef NDEBUG
    errors[OCTAVE_NOBASE_ERROR]=std::string("Octave: You didn't specify a global name. Global variables must start with a std::string and have sub std::strings separated by '.', e.g. 'base.name'");
    errors[OCTAVE_OPENCV_TYPE_ERROR]=std::string("Octave: OpenCV Mat types must all be CV_64F. ");
    errors[OCTAVE_INCONSISTENT_COL_CNT_ERROR]=std::string("Octave: You have specified a matrix with inconsistent column sizes, for the type vector<vector<vector<TYPE> > >.");
#endif
    }

    virtual ~OctaveDebug() {}
};

#include <Eigen/Dense>

#include <string>
#include <vector>
using namespace std;

class Matrix; 
class octave_value; 
//class Octave_map; ///< Octave's Octave_map class
class octave_map;
#define Octave_map octave_map
class octave_value_list; 

#ifdef HAVE_OPENCV
namespace cv {
class Mat; 
};
#endif

class Octave {
    Matrix *newMatrix(int r, int c);

    void setMatrixElem(Matrix *m, int i, int j, double val);

    void deleteMatrix(Matrix *m);

    void init(void);

public:
    octave_value_list *input; 

    Octave(const vector<std::string> &args);

    void startOctave(const vector<std::string> &args);

    Octave(void);

    virtual ~Octave();

    bool isReady(void);


    void stopOctaveAndExit();

    void stopOctave();

    template<class TYPE>
    vector<vector<vector<TYPE> > > &runM(const char* commandName, const vector<vector<vector<TYPE> > > &in, vector<vector<vector<TYPE> > > &out);

    template<class TYPE>
    vector<Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic> > &runM(const char* commandName, const vector<Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic> > &in, vector<Eigen::Matrix<TYPE, Eigen::Dynamic, Eigen::Dynamic> > &out);

    octave_value_list runMWithInput(const char* commandName);

    void runM(const char* commandName);

#ifdef HAVE_OPENCV

    vector<cv::Mat> &runM(const char* commandName, const vector<cv::Mat> &in, vector<cv::Mat> &out);
#endif

//    void setGlobalVariable(const std::string &name) {
//        set_global_value (name, octave_value());
//    }


    template<typename Derived>
    int setGlobalVariable(const std::string &name, const Eigen::DenseBase<Derived> &var) {
        Matrix *m=newMatrix(var.rows(),var.cols());
        for (int j=0; j<var.rows(); j++)
            for (int k=0; k<var.cols(); k++)
                setMatrixElem(m, j, k, (double)var(j,k));
        int ret=setGlobalVariable(name, *m);
        deleteMatrix(m);
        return ret;
    }

    int setGlobalVariable(const std::string &name, Matrix &m);

    Octave_map setGlobalSubVariable(const vector<std::string> &varNames, const Matrix &m, int index, octave_value &base);

    Octave_map createGlobalSubVariable(const vector<std::string> &varNames, const Matrix &m, int index, Octave_map &base);

    void clearAll(void);

    template<typename TYPE>
    Eigen::Matrix<TYPE, Eigen::Dynamic, 1> str2Mat(char *str){
        return str2Mat<TYPE>(std::string(str));
    }

    template<typename TYPE>
    Eigen::Matrix<TYPE, Eigen::Dynamic, 1> str2Mat(std::string str){
        return Eigen::Map<Eigen::Matrix<char,Eigen::Dynamic,1> >((char*)str.c_str(), str.size()).cast<TYPE>();
    }

    template<typename TYPE>
    vector<TYPE> str2Vec(std::string str){
        vector<TYPE> vec;
        std::copy(str.begin(), str.end(), back_inserter(vec));
        return vec;
    }
};
#endif // OCTAVE_H_