Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Better C++11 and C++98 support/interop. Started writing map interface. Some core functions actually run

Browse Source
pull/1384/head
hbristow 12 years ago
parent 6fd296c0b0
commit 504558c0be
4 changed files with 110 additions and 33 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      modules/matlab/compile.cmake
  2. 1
      modules/matlab/generator/templates/template_function_base.cpp
  3. 94
      modules/matlab/include/bridge.hpp
  4. 46
      modules/matlab/include/map.hpp

2
modules/matlab/compile.cmake
Unescape View File

@ -3,7 +3,7 @@ macro(listify OUT_LIST IN_STRING)
endmacro()
listify(MEX_INCLUDE_DIRS_LIST ${MEX_INCLUDE_DIRS})
set(MEX_CXXFLAGS "CXXFLAGS=\$CXXFLAGS -pedantic -Wall -Wextra -Weffc++ -Wno-unused -Wold-style-cast -Wshadow -Wmissing-declarations -Wmissing-include-dirs -Wnon-virtual-dtor")
set(MEX_CXXFLAGS "CXXFLAGS=\$CXXFLAGS -pedantic -Wall -Wextra -Weffc++ -Wno-unused -Wold-style-cast -Wshadow -Wmissing-declarations -Wmissing-include-dirs -Wnon-virtual-dtor -Wno-newline-eof")
file(GLOB SOURCE_FILES "${CMAKE_CURRENT_BINARY_DIR}/src/*.cpp")
foreach(SOURCE_FILE ${SOURCE_FILES})
# strip out the filename

1
modules/matlab/generator/templates/template_function_base.cpp
Unescape View File

@ -53,3 +53,4 @@ void mexFunction(int nlhs, mxArray*{% if fun|noutputs %} plhs[]{% else %}*{% end
}
{% endif %}
}

94
modules/matlab/include/bridge.hpp
Unescape View File

@ -2,11 +2,11 @@
#define OPENCV_BRIDGE_HPP_
#include "mex.h"
#include "map.hpp"
#include <vector>
#include <string>
#include <opencv2/core.hpp>
#include <opencv2/calib3d.hpp>
#include <unordered_map>
/*
* All recent versions of Matlab ship with the MKL library which contains
@ -180,7 +180,7 @@ namespace Matlab {
public:
static std::string ToString() { return "Inherited type"; }
};
};
}
@ -205,29 +205,15 @@ private:
mxArray* ptr_;
bool owns_;
// this function is called exclusively from constructors!!
template <typename Scalar>
void fromMat(const cv::Mat& mat) {
mwSize dims[] = { static_cast<mwSize>(mat.rows), static_cast<mwSize>(mat.cols), static_cast<mwSize>(mat.channels()) };
ptr_ = mxCreateNumericArray(3, dims, Matlab::Traits<Scalar>::ScalarType, Matlab::Traits<>::Real);
owns_ = true;
switch (mat.depth()) {
case CV_8U: deepCopyAndTranspose<uint8_t, Scalar>(mat, *this); break;
case CV_8S: deepCopyAndTranspose<int8_t, Scalar>(mat, *this); break;
case CV_16U: deepCopyAndTranspose<uint16_t, Scalar>(mat, *this); break;
case CV_16S: deepCopyAndTranspose<int16_t, Scalar>(mat, *this); break;
case CV_32S: deepCopyAndTranspose<int32_t, Scalar>(mat, *this); break;
case CV_32F: deepCopyAndTranspose<float, Scalar>(mat, *this); break;
case CV_64F: deepCopyAndTranspose<double, Scalar>(mat, *this); break;
default: error("Attempted to convert from unknown class");
}
void dealloc() {
if (owns_ && ptr_) { mxDestroyArray(ptr_); ptr_ = NULL; owns_ = false; }
}
public:
// constructors and destructor
MxArray() : ptr_(mxCreateDoubleMatrix(1, 1, Matlab::Traits<>::Real)), owns_(true) {}
MxArray(const mxArray* ptr) : ptr_(const_cast<mxArray *>(ptr)), owns_(false) {}
virtual ~MxArray() {
if (owns_ && ptr_) mxDestroyArray(ptr_);
dealloc();
}
// copy constructor
// all copies are deep copies
@ -286,9 +272,25 @@ public:
ptr_ = mxCreateNumericArray(3, dims, Matlab::Traits<Scalar>::ScalarType, Matlab::Traits<>::Real);
}
// this function is called exclusively from constructors!!
template <typename Scalar>
explicit MxArray(const cv::Mat& mat) : owns_(false) {
fromMat<Scalar>(mat);
MxArray& fromMat(const cv::Mat& mat) {
// dealloc any existing storage before reallocating
dealloc();
mwSize dims[] = { static_cast<mwSize>(mat.rows), static_cast<mwSize>(mat.cols), static_cast<mwSize>(mat.channels()) };
ptr_ = mxCreateNumericArray(3, dims, Matlab::Traits<Scalar>::ScalarType, Matlab::Traits<>::Real);
owns_ = true;
switch (mat.depth()) {
case CV_8U: deepCopyAndTranspose<uint8_t, Scalar>(mat, *this); break;
case CV_8S: deepCopyAndTranspose<int8_t, Scalar>(mat, *this); break;
case CV_16U: deepCopyAndTranspose<uint16_t, Scalar>(mat, *this); break;
case CV_16S: deepCopyAndTranspose<int16_t, Scalar>(mat, *this); break;
case CV_32S: deepCopyAndTranspose<int32_t, Scalar>(mat, *this); break;
case CV_32F: deepCopyAndTranspose<float, Scalar>(mat, *this); break;
case CV_64F: deepCopyAndTranspose<double, Scalar>(mat, *this); break;
default: error("Attempted to convert from unknown class");
}
return *this;
}
template <typename Scalar>
@ -364,17 +366,18 @@ public:
* that gets mapped to an unsigned 8-bit value
*/
template <>
void MxArray::fromMat<Matlab::InheritType>(const cv::Mat& mat) {
MxArray& MxArray::fromMat<Matlab::InheritType>(const cv::Mat& mat) {
switch (mat.depth()) {
case CV_8U: fromMat<uint8_t>(mat); break;
case CV_8S: fromMat<int8_t>(mat); break;
case CV_16U: fromMat<uint16_t>(mat); break;
case CV_16S: fromMat<int16_t>(mat); break;
case CV_32S: fromMat<int32_t>(mat); break;
case CV_32F: fromMat<double>(mat); break; //NOTE: Matlab uses double as native type!
case CV_64F: fromMat<double>(mat); break;
case CV_8U: return fromMat<uint8_t>(mat); break;
case CV_8S: return fromMat<int8_t>(mat); break;
case CV_16U: return fromMat<uint16_t>(mat); break;
case CV_16S: return fromMat<int16_t>(mat); break;
case CV_32S: return fromMat<int32_t>(mat); break;
case CV_32F: return fromMat<double>(mat); break; //NOTE: Matlab uses double as native type!
case CV_64F: return fromMat<double>(mat); break;
default: error("Attempted to convert from unknown class");
}
return *this;
}
/*!
@ -412,13 +415,40 @@ cv::Mat MxArray::toMat<Matlab::InheritType>() const {
// ----------------------------------------------------------------------------
template <typename InputScalar, typename OutputScalar>
void deepCopyAndTranspose(const cv::Mat&, MxArray&) {
void deepCopyAndTranspose(const cv::Mat& in, MxArray& out) {
conditionalError(static_cast<size_t>(in.rows) == out.rows(), "Matrices must have the same number of rows");
conditionalError(static_cast<size_t>(in.cols) == out.cols(), "Matrices must have the same number of cols");
conditionalError(static_cast<size_t>(in.channels()) == out.channels(), "Matrices must have the same number of channels");
OutputScalar* outp = out.real<OutputScalar>();
const size_t M = out.rows();
const size_t N = out.cols();
for (size_t m = 0; m < M; ++m) {
const InputScalar* inp = in.ptr<InputScalar>(m);
for (size_t n = 0; n < N; ++n) {
// copy and transpose
outp[m + n*M] = inp[n];
}
}
}
template <typename InputScalar, typename OutputScalar>
void deepCopyAndTranspose(const MxArray&, cv::Mat&) {
void deepCopyAndTranspose(const MxArray& in, cv::Mat& out) {
conditionalError(in.rows() == static_cast<size_t>(out.rows), "Matrices must have the same number of rows");
conditionalError(in.cols() == static_cast<size_t>(out.cols), "Matrices must have the same number of cols");
conditionalError(in.channels() == static_cast<size_t>(out.channels()), "Matrices must have the same number of channels");
const InputScalar* inp = in.real<InputScalar>();
const size_t M = in.rows();
const size_t N = in.cols();
for (size_t m = 0; m < M; ++m) {
OutputScalar* outp = out.ptr<OutputScalar>(m);
for (size_t n = 0; n < N; ++n) {
// copy and transpose
outp[n] = inp[m + n*M];
}
}
}
template <>
void deepCopyAndTranspose<float, float>(const cv::Mat&, MxArray&) {
}
@ -583,7 +613,7 @@ public:
// --------------------------------------------------------------------------
// --------------------------- cv::Mat --------------------------------------
Bridge& operator=(const cv::Mat& ) { return *this; }
Bridge& operator=(const cv::Mat& mat) { ptr_ = MxArray().fromMat<Matlab::InheritType>(mat); return *this; }
cv::Mat toMat() const { return ptr_.toMat<Matlab::InheritType>(); }
operator cv::Mat() const { return toMat(); }

46
modules/matlab/include/map.hpp
Unescape View File

@ -0,0 +1,46 @@
#ifndef OPENCV_MAP_HPP_
#define OPENCV_MAP_HPP_
#if __cplusplus >= 201103L
// If we have C++11 support, we just want to use unordered_map
#include <unordered_map>
template <typename KeyType, typename ValueType>
using Map = std::unordered_map<KeyType, ValueType>;
#else
// If we don't have C++11 support, we wrap another map implementation
// in the same public API as unordered_map
#include <map>
#include <stdexcept>
template <typename KeyType, typename ValueType>
class Map {
private:
std::map<KeyType, ValueType> map_;
public:
// map[key] = val;
ValueType& operator[] (const KeyType& k) {
return map_[k];
}
// map.at(key) = val (throws)
ValueType& at(const KeyType& k) {
typename std::map<KeyType, ValueType>::iterator it;
it = map_.find(k);
if (it == map_.end()) throw std::out_of_range("Key not found");
return *it;
}
// val = map.at(key) (throws, const)
const ValueType& at(const KeyType& k) const {
typename std::map<KeyType, ValueType>::const_iterator it;
it = map_.find(k);
if (it == map_.end()) throw std::out_of_range("Key not found");
return *it;
}
};
#endif
#endif
Write Preview
Loading…
Cancel
Save