37 #ifndef VIGRA_MATLAB_HXX
38 #define VIGRA_MATLAB_HXX
42 #include "array_vector.hxx"
43 #include "sized_int.hxx"
47 #include "matlab_FLEXTYPE.hxx"
56 #define VIGRA_MATLAB_VALUETYPE_UTIL(type, functionName, typeID, matTypeName) \
58 struct ValueType<type> \
60 static bool check(mxArray const * t) \
62 return mxIs##functionName(t); \
65 static mxClassID const classID = typeID; \
67 static std::string typeName() \
69 return #matTypeName; \
73 VIGRA_MATLAB_VALUETYPE_UTIL(
double, Double, mxDOUBLE_CLASS,
double)
74 VIGRA_MATLAB_VALUETYPE_UTIL(
float, Single, mxSINGLE_CLASS, single)
75 VIGRA_MATLAB_VALUETYPE_UTIL(
Int8, Int8, mxINT8_CLASS, int8)
76 VIGRA_MATLAB_VALUETYPE_UTIL(
UInt8, Uint8, mxUINT8_CLASS, uint8)
77 VIGRA_MATLAB_VALUETYPE_UTIL(
Int16, Int16, mxINT16_CLASS, int16)
78 VIGRA_MATLAB_VALUETYPE_UTIL(
UInt16, Uint16, mxUINT16_CLASS, uint16)
80 #if VIGRA_BITSOF_INT == 32
81 VIGRA_MATLAB_VALUETYPE_UTIL(
int,
Int32, mxINT32_CLASS, int32)
82 VIGRA_MATLAB_VALUETYPE_UTIL(
unsigned int, Uint32, mxUINT32_CLASS, uint32)
83 #elif VIGRA_BITSOF_INT == 64
84 VIGRA_MATLAB_VALUETYPE_UTIL(
int,
Int64, mxINT64_CLASS, int64)
85 VIGRA_MATLAB_VALUETYPE_UTIL(
unsigned int, Uint64, mxUINT64_CLASS, uint64)
88 #if VIGRA_BITSOF_LONG == 32
89 VIGRA_MATLAB_VALUETYPE_UTIL(
long,
Int32, mxINT32_CLASS, int32)
90 VIGRA_MATLAB_VALUETYPE_UTIL(
unsigned long, Uint32, mxUINT32_CLASS, uint32)
91 #elif VIGRA_BITSOF_LONG == 64
92 VIGRA_MATLAB_VALUETYPE_UTIL(
long,
Int64, mxINT64_CLASS, int64)
93 VIGRA_MATLAB_VALUETYPE_UTIL(
unsigned long, Uint64, mxUINT64_CLASS, uint64)
96 #if VIGRA_BITSOF_LONG_LONG == 32
97 VIGRA_MATLAB_VALUETYPE_UTIL(
long long,
Int32, mxINT32_CLASS, int32)
98 VIGRA_MATLAB_VALUETYPE_UTIL(
unsigned long long, Uint32, mxUINT32_CLASS, uint32)
99 #elif VIGRA_BITSOF_LONG_LONG == 64
100 VIGRA_MATLAB_VALUETYPE_UTIL(
long long,
Int64, mxINT64_CLASS, int64)
101 VIGRA_MATLAB_VALUETYPE_UTIL(
unsigned long long, Uint64, mxUINT64_CLASS, uint64)
104 #undef VIGRA_MATLAB_VALUETYPE_UTIL
106 class ConstStructArray
109 mxArray * matPointer_;
115 mxArray * matPointer_;
118 Proxy(mxArray * matPointer,
int index)
119 : matPointer_(matPointer),
123 operator const mxArray *()
const
125 return mxGetFieldByNumber(matPointer_, 0, index_);
129 ConstStructArray(
const mxArray * matPointer = 0)
130 : matPointer_(const_cast<mxArray *>(matPointer))
132 if(matPointer != 0 && !mxIsStruct(matPointer))
133 mexErrMsgTxt(
"StructArray(mxArray *): Argument must be a Matlab struct array.");
136 Proxy operator[](
const char * field_name)
const
139 mexErrMsgTxt(
"StructArray::operator[]: Cannot access uninitialized struct array.");
141 int i = mxGetFieldNumber(matPointer_, field_name);
143 mexErrMsgTxt(
"StructArray::operator[]: Unknown field name.");
145 return Proxy(matPointer_, i);
148 Proxy operator[](std::string field_name)
const
150 return operator[](field_name.c_str());
155 return matPointer_ != 0;
158 bool isValid(
const char * field_name)
const
160 return isValid() && mxGetFieldNumber(matPointer_, field_name) != -1;
163 bool isValid(std::string field_name)
const
165 return isValid(field_name.c_str());
172 mxArray * matPointer_;
179 mxArray * matPointer_;
182 Proxy(mxArray * matPointer,
int index)
183 : matPointer_(matPointer),
187 operator const mxArray *()
const
189 return mxGetCell(matPointer_, index_);
193 ConstCellArray(
const mxArray * matPointer = 0)
194 : matPointer_(const_cast<mxArray *>(matPointer)),
197 if(matPointer != 0 && !mxIsCell(matPointer))
198 mexErrMsgTxt(
"CellArray(mxArray *): Argument must be a Matlab cell array.");
200 size_ = mxGetNumberOfElements(matPointer);
205 Proxy operator[](
int i)
const
208 mexErrMsgTxt(
"CellArray::operator[]: Index out of range.");
209 return Proxy(matPointer_, i);
217 bool isValid(
int i )
const
219 return i >= 0 && i < size_;
225 :
public ConstCellArray
230 :
public ConstCellArray::Proxy
232 Proxy(mxArray * matPointer,
int index)
233 : ConstCellArray::Proxy(matPointer, index)
236 void operator=(mxArray * v)
238 mxDestroyArray(mxGetCell(matPointer_, index_));
239 mxSetCell(matPointer_, index_, v);
243 CellArray(
const mxArray * matPointer)
244 : ConstCellArray(matPointer)
247 Proxy operator[](
int i)
250 mexErrMsgTxt(
"CellArray::operator[]: Index out of range.");
251 return Proxy(matPointer_, i);
254 ConstCellArray::Proxy operator[](
int i)
const
257 mexErrMsgTxt(
"CellArray::operator[]: Index out of range.");
258 return ConstCellArray::Proxy(matPointer_, i);
266 template <
class T,
unsigned int SIZE>
267 TinyVectorView<T, SIZE>
268 getTinyVector(mxArray
const * t)
270 if(!ValueType<T>::check(t))
272 std::string msg = std::string(
"Input array must have type ") +
273 ValueType<T>::typeName() +
".";
274 mexErrMsgTxt(msg.c_str());
276 if(SIZE != mxGetNumberOfElements(t))
278 mexErrMsgTxt(
"getTinyVector(): Input array has wrong number of elements.");
281 return TinyVectorView<T, SIZE>((T *)mxGetData(t));
284 template <
unsigned int SIZE>
285 typename MultiArrayShape<SIZE>::type
286 getShape(mxArray
const * t)
288 if(!ValueType<Int32>::check(t))
290 std::string msg = std::string(
"Input array must have type 'int32'.");
291 mexErrMsgTxt(msg.c_str());
293 if(SIZE != mxGetNumberOfElements(t))
295 mexErrMsgTxt(
"getShape(): Input array has wrong number of elements.");
301 template <
int DIM,
class T>
302 MultiArrayView<DIM, T>
303 getMultiArray(mxArray
const * t)
305 typedef typename MultiArrayView<DIM, T>::difference_type Shape;
307 if(!ValueType<T>::check(t))
309 std::string msg = std::string(
"getMultiArray(): Input array must have type ") +
310 ValueType<T>::typeName() +
".";
311 mexErrMsgTxt(msg.c_str());
317 int mdim = mxGetNumberOfDimensions(t);
320 mexErrMsgTxt(
"getMultiArray(): Input array has too many dimensions.");
322 const mwSize * matlabShape = mxGetDimensions(t);
323 for(
int k=0; k<mdim; ++k)
325 shape[k] =
static_cast<typename Shape::value_type
>(matlabShape[k]);
327 for(
int k=mdim; k<DIM; ++k)
334 shape[0] =
static_cast<typename Shape::value_type
>(mxGetNumberOfElements(t));
336 return MultiArrayView<DIM, T>(shape, (T *)mxGetData(t));
339 template <
int DIM,
class T>
340 MultiArrayView<DIM, T>
341 createMultiArray(
typename MultiArrayShape<DIM>::type
const & shape, mxArray * & t)
343 mwSize matlabShape[DIM];
344 for(
int k=0; k<DIM; ++k)
345 matlabShape[k] = static_cast<mwSize>(shape[k]);
346 t = mxCreateNumericArray(DIM, matlabShape, ValueType<T>::classID, mxREAL);
348 return MultiArrayView<DIM, T>(shape, (T *)mxGetData(t));
351 template <
int DIM,
class T>
352 MultiArrayView<DIM, T>
353 createMultiArray(
typename MultiArrayShape<DIM>::type
const & shape, CellArray::Proxy t)
355 mwSize matlabShape[DIM];
356 for(
int k=0; k<DIM; ++k)
357 matlabShape[k] = static_cast<mwSize>(shape[k]);
358 t = mxCreateNumericArray(DIM, matlabShape, ValueType<T>::classID, mxREAL);
360 return MultiArrayView<DIM, T>(shape, (T *)mxGetData(t));
364 inline MultiArrayView<1, T>
365 getArray(mxArray
const * t)
367 return getMultiArray<1, T>(t);
371 inline MultiArrayView<1, T>
378 inline MultiArrayView<1, T>
386 getMatrix(mxArray
const * t)
388 typedef typename MultiArrayView<2, T>::difference_type Shape;
390 if(!ValueType<T>::check(t))
392 std::string msg = std::string(
"getMatrix(): Input matrix must have type ") +
393 ValueType<T>::typeName() +
".";
394 mexErrMsgTxt(msg.c_str());
397 if(2 != mxGetNumberOfDimensions(t))
398 mexErrMsgTxt(
"getMatrix(): Input matrix must have 2 dimensions.");
400 const mwSize * matlabShape = mxGetDimensions(t);
401 Shape shape(static_cast<MultiArrayIndex>(matlabShape[0]),
402 static_cast<MultiArrayIndex>(matlabShape[1]));
404 return MultiArrayView<2, T>(shape, (T *)mxGetData(t));
411 typedef typename MultiArrayView<2, T>::difference_type Shape;
413 Shape shape(rowCount, columnCount);
414 t = mxCreateNumericMatrix(rowCount, columnCount, ValueType<T>::classID, mxREAL);
416 return MultiArrayView<2, T>(shape, (T *)mxGetData(t));
421 createMatrix(mwSize rowCount, mwSize columnCount, CellArray::Proxy t)
423 typedef typename MultiArrayView<2, T>::difference_type Shape;
425 Shape shape(rowCount, columnCount);
426 t = mxCreateNumericMatrix(rowCount, columnCount, ValueType<T>::classID, mxREAL);
428 return MultiArrayView<2, T>(shape, (T *)mxGetData(t));
433 getImage(mxArray
const * t)
435 if(!ValueType<T>::check(t))
437 std::string msg = std::string(
"getImage(): Input matrix must have type ") +
438 ValueType<T>::typeName() +
".";
439 mexErrMsgTxt(msg.c_str());
442 if(2 != mxGetNumberOfDimensions(t))
443 mexErrMsgTxt(
"getImage(): Input matrix must have 2 dimensions.");
445 const mwSize * matlabShape = mxGetDimensions(t);
446 return BasicImageView<T>((T *)mxGetData(t),
static_cast<int>(matlabShape[0]),
447 static_cast<int>(matlabShape[1]));
452 createImage(mwSize width, mwSize height, mxArray * & t)
454 t = mxCreateNumericMatrix(width, height, ValueType<T>::classID, mxREAL);
456 return BasicImageView<T>((T *)mxGetData(t), width, height);
461 createImage(mwSize width, mwSize height, CellArray::Proxy t)
463 t = mxCreateNumericMatrix(width, height, ValueType<T>::classID, mxREAL);
465 return BasicImageView<T>((T *)mxGetData(t), width, height);
468 inline ConstCellArray
469 getCellArray(mxArray
const * t)
471 return ConstCellArray(t);
475 createCellArray(mwSize size, mxArray * & t)
477 mwSize matSize[] = { size };
478 t = mxCreateCellArray(1, matSize);
484 createCellArray(mwSize size, CellArray::Proxy t)
486 mwSize matSize[] = { size };
487 t = mxCreateCellArray(1, matSize);
492 inline ConstStructArray
493 getStructArray(mxArray
const * t)
495 return ConstStructArray(t);
500 getScalar(mxArray
const * t)
503 mexErrMsgTxt(
"getScalar() on empty input.");
504 if(!mxIsNumeric(t) && !mxIsLogical(t))
505 mexErrMsgTxt(
"getScalar(): argument is not numeric.");
506 return static_cast<T
>(mxGetScalar(t));
514 createMatrix<double>(1, 1, m)(0,0) =
static_cast<double>(v);
519 getString(mxArray
const * t)
522 mexErrMsgTxt(
"getString() on empty input.");
524 mexErrMsgTxt(
"getString(): argument is not a string.");
525 int size = mxGetNumberOfElements(t) + 1;
526 ArrayVector<char> buf(size);
527 mxGetString(t, buf.begin(), size);
528 return std::string(buf.begin());
533 class CompileTimeError;
540 void argumentWasProvided()
const { }
550 mutable bool * argumentWasProvided_;
552 DefaultImpl(T v,
bool * argFlag = 0)
554 argumentWasProvided_(argFlag)
556 if(argumentWasProvided_ != 0)
557 *argumentWasProvided_ =
false;
560 void argumentWasProvided()
const
562 if(argumentWasProvided_ != 0)
563 *argumentWasProvided_ =
true;
570 mutable bool * argumentWasProvided_;
572 OptionalImpl(
bool * argFlag = 0)
573 : argumentWasProvided_(argFlag)
575 if(argumentWasProvided_ != 0)
576 *argumentWasProvided_ =
false;
579 void argumentWasProvided()
const
581 if(argumentWasProvided_ != 0)
582 *argumentWasProvided_ =
true;
588 inline detail::Required v_required()
590 return detail::Required();
594 inline detail::DefaultImpl<T> v_default(T in)
596 return detail::DefaultImpl<T>(in);
600 inline detail::DefaultImpl<T> v_default(T in,
bool & argFlag)
602 return detail::DefaultImpl<T>(in, &argFlag);
605 inline detail::OptionalImpl v_optional()
607 return detail::OptionalImpl();
610 inline detail::OptionalImpl v_optional(
bool& argFlag)
612 return detail::OptionalImpl(&argFlag);
623 const mxArray ** data_;
625 std::string createErrMsg(std::string name)
628 s1 =
"Required input '" + name +
"' not found in option struct!";
631 std::string createErrMsg(
int pos)
633 char tmp[10] = {
'0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9'};
634 std::string oi(1, tmp[pos%10]);
635 std::string s1 =
"Required input in signature of function at position: '"+ oi+
"' has not been supplied";
641 ConstStructArray options_;
644 typedef const mxArray * value_type;
645 typedef value_type & reference;
646 typedef value_type
const & const_reference;
647 typedef value_type * pointer;
648 typedef value_type
const * const_pointer;
649 typedef int size_type;
650 typedef int difference_type;
653 InputArray(size_type size, pointer data)
656 options_(isValid(size-1) && mxIsStruct(data_[size-1])
662 const_reference operator[]( difference_type i )
const
665 mexErrMsgTxt(
"Too few input arguments.");
669 value_type operator[]( std::string name)
const
671 std::string errMsg =
"Not Found " + name +
" in OptionStruct or OptionStruct not set";
673 mexErrMsgTxt(errMsg.c_str());
674 return options_[name];
679 size_type size()
const
684 bool isValid( difference_type i )
const
686 return i >= 0 && i < size_;
689 bool isValid(std::string name)
const
691 return options_.isValid(name);
694 bool isEmpty(difference_type i)
const
696 return mxIsEmpty(data_[i]);
699 bool isEmpty(std::string name)
const
701 return mxIsEmpty(options_[name]);
704 bool hasData(difference_type i)
const
706 return isValid(i) && !isEmpty(i);
709 bool hasData(std::string name)
const
711 return isValid(name) && !isEmpty(name);
714 template<
class Place>
715 mxClassID typeOf(Place posOrName)
717 return mxGetClassID((*
this)[posOrName]);
721 template <
class T,
class U,
class Place>
722 T errorOrDefault(detail::DefaultImpl<U>
const & o, Place posOrName)
724 return o.defaultValue_;
727 template <
class T,
class Place>
728 T errorOrDefault(detail::OptionalImpl, Place posOrName)
733 template <
class T,
class Place>
734 T errorOrDefault(detail::Required r, Place posOrName)
736 std::string a = createErrMsg(posOrName);
737 mexErrMsgTxt( a.c_str());
742 template <
class Place,
class ReqType>
743 int getEnum(Place posOrName, ReqType req, std::map<std::string, int>
const & converter)
745 if(!hasData(posOrName))
747 return errorOrDefault<int>(req, posOrName);
749 std::string enumAsString = matlab::getString((*
this)[posOrName]);
750 typename std::map<std::string, int>::const_iterator m = converter.find(enumAsString);
751 if(m == converter.end())
753 std::string msg = std::string(
"Unknown option: ") + enumAsString +
".";
754 mexErrMsgTxt(msg.c_str());
757 req.argumentWasProvided();
763 template <
class Place,
class ReqType>
764 std::string getString(Place posOrName, ReqType req)
766 if(!hasData(posOrName))
768 return errorOrDefault<std::string>(req, posOrName);
772 req.argumentWasProvided();
773 return matlab::getString((*
this)[posOrName]);
778 template <
class T,
class Place,
class ReqType>
779 T getScalar(Place posOrName, ReqType req)
781 if(!hasData(posOrName))
783 return errorOrDefault<T>(req, posOrName);
787 req.argumentWasProvided();
788 return matlab::getScalar<T>((*this)[posOrName]);
793 template <
class T,
class Place,
class ReqType,
class minClass,
class maxClass>
794 T getScalarMinMax(Place posOrName, ReqType req, minClass min_, maxClass max_)
796 T temp = this->getScalar<T>(posOrName, req);
797 if (!is_in_range(temp, min_, max_))
798 mexErrMsgTxt(
"Value out of bounds.");
802 template <
class T,
class Place,
class ReqType,
class iteratorType>
803 T getScalarVals(Place posOrName, ReqType req, iteratorType begin_, iteratorType end_)
805 T temp = this->getScalar<T>(posOrName, req);
806 for(iteratorType iter = begin_; iter != end_; ++iter)
808 if((*iter) == temp)
return temp;
810 mexErrMsgTxt(
"Value not allowed");
815 template <
class T,
class Place,
class ReqType,
class iteratorType>
816 T getScalarVals2D3D(Place posOrName, ReqType req, iteratorType begin2D_, iteratorType end2D_,
817 iteratorType begin3D_, iteratorType end3D_,
820 T temp = this->getScalar<T>(posOrName, req);
824 for(iteratorType iter = begin2D_; iter != end2D_; ++iter)
826 if((*iter) == temp)
return temp;
830 for(iteratorType iter = begin3D_; iter != end3D_; ++iter)
832 if((*iter) == temp)
return temp;
836 mexErrMsgTxt(
"dimVar specified must be 2 or 3");
838 mexErrMsgTxt(
"Value not allowed");
841 template <
class Place,
class ReqType>
842 bool getBool(Place posOrName, ReqType req)
844 return this->getScalarMinMax<int>(posOrName, req, 0, 1) != 0;
848 template <
unsigned int N,
class T,
class Place,
class ReqType>
849 MultiArrayView<N,T> getMultiArray(Place posOrName, ReqType req)
851 if(!hasData(posOrName))
853 return errorOrDefault< MultiArrayView<N,T> >(req, posOrName);
857 req.argumentWasProvided();
858 value_type temp = (*this)[posOrName];
859 return matlab::getMultiArray<N,T>(temp);
863 template <
class T,
class Place,
class ReqType>
864 BasicImageView<T> getImage(Place posOrName, ReqType req)
866 if(!hasData(posOrName))
868 return errorOrDefault<BasicImageView<T> >(req, posOrName);
872 req.argumentWasProvided();
873 value_type temp = (*this)[posOrName];
874 return matlab::getImage<T>(temp);
878 template<
class T,
unsigned int sze,
class Place,
class ReqType>
879 TinyVectorView< T, sze> getTinyVector(Place posOrName, ReqType req)
881 if(!hasData(posOrName))
883 return errorOrDefault<TinyVectorView< T, sze> >(req, posOrName);
887 req.argumentWasProvided();
888 value_type temp = (*this)[posOrName];
889 return matlab::getTinyVector< T, sze>(temp);
893 template<
unsigned int sze,
class Place,
class ReqType>
894 TinyVectorView<MultiArrayIndex, sze> getShape(Place posOrName, ReqType req)
896 if(!hasData(posOrName))
898 return errorOrDefault<TinyVectorView<MultiArrayIndex, sze> >(req, posOrName);
902 req.argumentWasProvided();
903 value_type temp = (*this)[posOrName];
904 return matlab::getShape<sze>(temp);
909 template<
class Place,
class ReqType>
910 int getDimOfInput(Place posOrName, ReqType req)
912 if(!hasData(posOrName))
914 return errorOrDefault<int>(req, posOrName);
918 req.argumentWasProvided();
919 return mxGetNumberOfDimensions((*
this)[posOrName]);
923 template<
class ReqType>
924 ConstCellArray getCellArray(
int posOrName, ReqType req)
926 if(!hasData(posOrName))
928 return errorOrDefault<ConstCellArray>(req, posOrName);
932 req.argumentWasProvided();
933 value_type temp = (*this)[posOrName];
934 return matlab::getCellArray(temp);
938 template<
class ReqType>
939 ConstCellArray getCellArray(std::string posOrName, ReqType req)
941 CompileTimeError ERROR__Const_Cell_Array_May_Not_Be_In_Option_Struct;
942 return ConstCellArray();
951 std::string createErrMsgOut(
int pos)
953 char tmp[10] = {
'0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9'};
954 std::string oi(1, tmp[pos%10]);
955 std::string s1 =
"Required Output at position: '" + oi +
"' has not been supplied";
960 typedef mxArray * value_type;
961 typedef value_type & reference;
962 typedef value_type
const & const_reference;
963 typedef value_type * pointer;
964 typedef value_type
const * const_pointer;
965 typedef int size_type;
966 typedef int difference_type;
968 OutputArray(size_type size, pointer data)
973 reference operator[]( difference_type i )
976 mexErrMsgTxt(
"Too few output arguments.");
980 const_reference operator[]( difference_type i )
const
983 mexErrMsgTxt(
"Too few output arguments.");
987 size_type size()
const
992 bool isValid( difference_type i )
const
994 return i >= 0 && i < size_;
997 bool isEmpty(difference_type i){
998 return mxIsEmpty(data_[i]);
1002 T errorOrDefault(detail::OptionalImpl
const & o,
int Pos)
1008 T errorOrDefault(detail::Required r,
int Pos)
1010 mexErrMsgTxt(createErrMsgOut(Pos).c_str());
1015 template <
unsigned int DIM,
class T,
class ReqType>
1016 MultiArrayView<DIM, T> createMultiArray(
int pos,ReqType req,
1017 const TinyVector<int, DIM> & shape)
1020 return errorOrDefault<MultiArrayView<DIM, T> >(req, pos);
1021 req.argumentWasProvided();
1022 return matlab::createMultiArray<DIM, T>(shape, (*this)[pos]);
1025 template <
class T,
class ReqType>
1026 BasicImageView<T> createImage(
int pos, ReqType req,
1027 mwSize width, mwSize height)
1030 return errorOrDefault<BasicImageView<T> >(req, pos);
1031 req.argumentWasProvided();
1032 return matlab::createImage<T>(width, height, (*this)[pos]);
1035 template <
class T,
class ReqType>
1036 BasicImageView<T> createImage(
int pos, ReqType req,
1037 typename MultiArrayShape<2>::type
const & shape)
1039 return createImage<T>(pos, req, shape[1], shape[0]);
1042 template <
class T,
class ReqType>
1043 T* createScalar(
int pos, ReqType req)
1046 return errorOrDefault<T*>(req, pos);
1047 req.argumentWasProvided();
1048 BasicImageView<T> temp = matlab::createImage<T>(1, 1, (*this)[pos]);
1052 template <
class T,
class ReqType>
1053 void createScalar(
int pos, ReqType req, T val)
1057 errorOrDefault<T>(req, pos);
1060 req.argumentWasProvided();
1061 BasicImageView<T> temp = matlab::createImage<T>(1, 1, (*this)[pos]);
1065 template <
class ReqType>
1066 ConstCellArray createCellArray(
int pos, ReqType req, mwSize sze)
1069 return errorOrDefault<ConstCellArray>(req, pos);
1070 return matlab::createCellArray(sze, (*
this)[pos]);
1079 using namespace vigra;
1086 int cantorPair(
int x,
int y){
1087 return (
int)(((x+y)*(x+y+1))/2+y);
1090 int cantorPair(
int x,
int y,
int z){
1091 return cantorPair(cantorPair(x,y),z);
1094 template <
int x,
int y>
1096 enum { value = (int)(((x+y)*(x+y+1))/2+y)};
1099 template <
int x,
int y,
int z>
1101 enum { value = cP<cP<x, y>::value, z>::value};
1105 inline bool is_in_range(T in, T min, T max)
1107 return (in >= min && in <= max);
1110 inline bool is_in_range(T in, std::string min, T max)
1116 inline bool is_in_range(T in, T min, std::string max)
1129 return (s1[0] < s2[0]);
1131 return s1[1] < s2[1];
1140 std::map<TinyVector<int,2>, T,ShapeCmp> data;
1144 void assign(
int i = 1,
int j = 1){
1148 SparseArray(
int i = 1 ,
int j = 1){
1155 template<
class indexType>
1156 T& operator()(indexType i_, indexType j_){
1160 typename std::map<TinyVector<int,2>, T, ShapeCmp>::iterator iter;
1162 return data[newShapew];
1165 template<
class indexType>
1166 const T
get(indexType i_, indexType j_){
1170 if(data.find(newShape) == data.end())
return 0;
1171 else return data.find(newShape)->second;
1175 void mapToMxArray(mxArray * & in){
1177 int len = data.size();
1178 in = mxCreateSparse(width, length, len, mxREAL);
1179 int* jc = mxGetJc(in);
1180 int* ir = mxGetIr(in);
1181 double* pr = mxGetPr(in);
1186 typename std::map<TinyVector<int,2>, T, ShapeCmp>::iterator iter;
1191 for( iter = data.begin(); iter != data.end(); ++iter ) {
1192 newShape = iter->first;
1193 ir[ii] = newShape[1];
1194 pr[ii] = iter->second;
1195 if(newShape[0] != curjc){
1196 curjc = newShape[0] ;
1208 enum DataDimension {IMAGE = 2, VOLUME = 3};
1214 void vigraMexFunction(vigra::matlab::OutputArray, vigra::matlab::InputArray);
1216 #ifndef VIGRA_CUSTOM_MEXFUNCTION
1223 void mexFunction(
int nlhs, mxArray *plhs[],
1224 int nrhs,
const mxArray *prhs[])
1228 vigra::matlab::InputArray inputs(nrhs, prhs);
1229 vigra::matlab::OutputArray outputs(nlhs, plhs);
1231 vigraMexFunction(outputs, inputs);
1233 catch(std::exception & e)
1235 mexErrMsgTxt(e.what());
1242 #define VIGRA_CREATE_ENUM_AND_STD_MAP2(mapName, item1, item2) \
1243 const int item1 = 1;\
1244 const int item2 = 2;\
1245 std::map<std::string,int> mapName;\
1246 mapName[#item1] = (int)item1;\
1247 mapName[#item2] = (int)item2;\
1250 #define VIGRA_CREATE_ENUM_AND_STD_MAP3(mapName, item1, item2, item3) \
1251 const int item1 = 1;\
1252 const int item2 = 2;\
1253 const int item3 = 3;\
1254 std::map<std::string,int> mapName;\
1255 mapName[#item1] = (int)item1;\
1256 mapName[#item2] = (int)item2;\
1257 mapName[#item3] = (int)item3;\
1260 #define VIGRA_CREATE_ENUM_AND_STD_MAP4(mapName, item1, item2, item3, item4) \
1261 const int item1 = 1;\
1262 const int item2 = 2;\
1263 const int item3 = 3;\
1264 const int item4 = 4;\
1265 std::map<std::string,int> mapName;\
1266 mapName[#item1] = (int)item1;\
1267 mapName[#item2] = (int)item2;\
1268 mapName[#item3] = (int)item3;\
1269 mapName[#item4] = (int)item4;\
1271 #define VIGRA_CREATE_ENUM_AND_STD_MAP5(mapName, item1, item2, item3, item4, item5) \
1272 const int item1 = 1;\
1273 const int item2 = 2;\
1274 const int item3 = 3;\
1275 const int item4 = 4;\
1276 const int item5 = 5;\
1277 std::map<std::string, int> mapName;\
1278 mapName[#item1] = (int)item1;\
1279 mapName[#item2] = (int)item2;\
1280 mapName[#item3] = (int)item3;\
1281 mapName[#item4] = (int)item4;\
1282 mapName[#item5] = (int)item5;\
1284 #define VIGRA_CREATE_ENUM_AND_STD_MAP6(mapName, item1, item2, item3, item4, item5, item6) \
1285 const int item1 = 1;\
1286 const int item2 = 2;\
1287 const int item3 = 3;\
1288 const int item4 = 4;\
1289 const int item5 = 5;\
1290 const int item6 = 6;\
1291 std::map<std::string,int> mapName;\
1292 mapName[#item1] = (int)item1;\
1293 mapName[#item2] = (int)item2;\
1294 mapName[#item3] = (int)item3;\
1295 mapName[#item4] = (int)item4;\
1296 mapName[#item5] = (int)item5;\
1297 mapName[#item6] = (int)item6;\
1299 #endif // VIGRA_MATLAB_HXX