From 16c860854e0d55af6f1b2d07abb098e8869ad089 Mon Sep 17 00:00:00 2001 From: Tanglong Date: Thu, 2 Sep 2021 11:48:29 +0800 Subject: [PATCH 1/4] Add convert .exr file to .mat file function to imgtool (Windows only) --- CMakeLists.txt | 6 +- src/ext/matlab/inc/mat.h | 235 +++++ src/ext/matlab/inc/matrix.h | 1575 +++++++++++++++++++++++++++++++++ src/ext/matlab/inc/tmwtypes.h | 831 +++++++++++++++++ src/ext/matlab/lib/libmat.lib | Bin 0 -> 50128 bytes src/ext/matlab/lib/libmx.lib | Bin 0 -> 728036 bytes src/pbrt/cmd/imgtool.cpp | 201 +++-- src/pbrt/textures.cpp | 4 +- 8 files changed, 2780 insertions(+), 72 deletions(-) create mode 100644 src/ext/matlab/inc/mat.h create mode 100644 src/ext/matlab/inc/matrix.h create mode 100644 src/ext/matlab/inc/tmwtypes.h create mode 100644 src/ext/matlab/lib/libmat.lib create mode 100644 src/ext/matlab/lib/libmx.lib diff --git a/CMakeLists.txt b/CMakeLists.txt index ba92f8a55..bd80f1ba6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -924,6 +924,8 @@ add_sanitizers (pbrt_exe) ###################### # imgtool +link_directories (src/ext/matlab/lib) + add_executable (imgtool src/pbrt/cmd/imgtool.cpp) add_executable (pbrt::imgtool ALIAS imgtool) @@ -932,8 +934,8 @@ set_property (TARGET sky_lib PROPERTY FOLDER "ext") target_compile_definitions (imgtool PRIVATE ${PBRT_DEFINITIONS}) target_compile_options (imgtool PRIVATE ${PBRT_CXX_FLAGS}) -target_include_directories (imgtool PRIVATE src src/ext ${FLIP_INCLUDE}) -target_link_libraries (imgtool PRIVATE ${ALL_PBRT_LIBS} pbrt_opt pbrt_warnings sky_lib flip_lib) +target_include_directories (imgtool PRIVATE src src/ext src/ext/matlab/inc ${FLIP_INCLUDE}) +target_link_libraries (imgtool PRIVATE ${ALL_PBRT_LIBS} pbrt_opt pbrt_warnings sky_lib flip_lib libmat libmx) add_sanitizers (imgtool) diff --git a/src/ext/matlab/inc/mat.h b/src/ext/matlab/inc/mat.h new file mode 100644 index 000000000..c67840715 --- /dev/null +++ b/src/ext/matlab/inc/mat.h @@ -0,0 +1,235 @@ +/* Published header for libmat, the mat library. + Copyright 1984-2018 The MathWorks, Inc. + This file containes types, macros, and declarations necessary to + interface MEX files with the current version of MATLAB. + + See the release notes for information on supporting earlier versions. */ + +#ifndef mat_h +#define mat_h + +#include "matrix.h" + +#if defined(TARGET_API_VERSION) +#if !(TARGET_API_VERSION == 700 || TARGET_API_VERSION == 800) +#error invalid TARGET_VERSION_API definition +#elif defined(MEX_DOUBLE_HANDLE) && TARGET_API_VERSION != 700 +#error It is illegal to use MEX_DOUBLE_HANDLE with linear versioning +#elif defined(MX_COMPAT_32) && TARGET_API_VERSION != 700 +#error It is illegal to use MX_COMPAT_32 with linear versioning +#endif +#endif + + +#if TARGET_API_VERSION == 800 + +#define matOpen matOpen_800 +#define matClose matClose_800 +#define matGetFp matGetFp_800 +#define matPutVariable matPutVariable_800 +#define matPutVariableAsGlobal matPutVariableAsGlobal_800 +#define matGetVariable matGetVariable_800 +#define matGetNextVariable matGetNextVariable_800 +#define matGetNextVariableInfo matGetNextVariableInfo_800 +#define matGetVariableInfo matGetVariableInfo_800 +#define matDeleteVariable matDeleteVariable_800 +#define matGetDir matGetDir_800 +#define matGetErrno matGetErrno_800 + +#endif /* TARGET_API_VERSION */ +/* + * Copyright 1984-2018 The MathWorks, Inc. + * All Rights Reserved. + */ + +#if defined(_MSC_VER) +# pragma once +#endif +#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) +# pragma once +#endif + +#ifdef mat_core_api_h +#error the published and developer mat APIs cannot be combined +#endif + +#ifndef mat_published_c_api_h +#define mat_published_c_api_h + +#ifndef EXTERN_C +# ifdef __cplusplus +# define EXTERN_C extern "C" +# else +# define EXTERN_C extern +# endif +#endif + +#ifndef LIBMAT_API +# define LIBMAT_API +#endif + +#include /* for FILE */ + +#include "matrix.h" /* for mxArray */ + +/** + * \file + * \ingroup mat_pub_C_api + */ + + +/* incomplete typedef for MATFile */ +#ifdef __cplusplus +class MATFile; +#else +typedef struct MatFile_tag MATFile; +#endif + +#ifndef LIBMAT_API_OFFERS_ERROR_ENUMS +typedef int matError; +#endif + +/* + * Open a MAT-file "filename" using mode "mode". Return + * a pointer to a MATFile for use with other MAT API functions. + * + * Current valid entries for "mode" are + * "r" == read only. + * "w" == write only (deletes any existing file with name ). + * "w4" == as "w", but create a MATLAB 4.0 MAT-file. + * "w7.3" == as "w", but create a MATLAB 7.3 MAT-file. + * "u" == update. Read and write allowed, existing file is not deleted. + * + * Return NULL if an error occurs. + */ +EXTERN_C LIBMAT_API MATFile* matOpen(const char *filename, const char * mode); + + +/* + * Close a MAT-file opened with matOpen. + * The pointer-to-MATfile argument is invalid, once matClose returns. + * Return zero for success, EOF on error. + */ +EXTERN_C LIBMAT_API matError matClose(MATFile *pMF); + +/* + * Return zero if MATFile is successfully openedno error, nonzero value otherwise. + */ +EXTERN_C LIBMAT_API matError matGetErrno(MATFile *pMF); + + +/* + * Return the ANSI C FILE pointer obtained when the MAT-file was opened. + * Warning: the FILE pointer may be NULL in the case of a MAT file format + * that does not allow access to the raw file pointer. + */ +EXTERN_C LIBMAT_API FILE * matGetFp(MATFile *pMF); + + +/* + * Write array value with the specified name to the MAT-file, deleting any + * previously existing variable with that name in the MAT-file. + * + * Return zero for success, nonzero for error. + */ +EXTERN_C LIBMAT_API matError matPutVariable(MATFile * pMF, const char * name, const mxArray * pA); + + +/* + * Write array value with the specified name to the MAT-file pMF, deleting any + * previously existing variable in the MAT-file with the same name. + * + * The variable will be written such that when the MATLAB LOAD command + * loads the variable, it will automatically place it in the + * global workspace and establish a link to it in the local + * workspace (as if the command "global " had been + * issued after the variable was loaded.) + * + * Return zero for success, nonzero for error. + */ +EXTERN_C LIBMAT_API matError matPutVariableAsGlobal(MATFile * pMF, const char * name, const mxArray * pA); + + +/* + * Read the array value for the specified variable name from a MAT-file. + * + * Return NULL if an error occurs. + */ +EXTERN_C LIBMAT_API mxArray * matGetVariable(MATFile * pMF, const char * name); + + +/* + * Read the next array value from the current file location of the MAT-file + * pMF. This function should only be used in conjunction with + * matOpen and matClose. Passing pMF to any other API functions + * will cause matGetNextVariable() to work incorrectly. + * + * Return NULL if an error occurs. + */ +EXTERN_C LIBMAT_API mxArray * matGetNextVariable(MATFile *pMF, const char **nameptr); + + +/* + * Read the array header of the next array value in a MAT-file. + * This function should only be used in conjunction with + * matOpen and matClose. Passing pMF to any other API functions + * will cause matGetNextVariableInfo to work incorrectly. + * + * See the description of matGetVariableInfo() for the definition + * and valid uses of an array header. + * + * Return NULL if an error occurs. + */ +EXTERN_C LIBMAT_API mxArray * matGetNextVariableInfo(MATFile *pMF, const char **nameptr); + + +/* + * Read the array header for the variable with the specified name from + * the MAT-file. + * + * An array header contains all the same information as an + * array, except that the pr, pi, ir, and jc data structures are + * not allocated for non-recursive data types. That is, + * Cells, structures, and objects contain pointers to other + * array headers, but numeric, string, and sparse arrays do not + * contain valid data in their pr, pi, ir, or jc fields. + * + * The purpose of an array header is to gain fast access to + * information about an array without reading all the array's + * actual data. Thus, functions such as mxGetM, mxGetN, and mxGetClassID + * can be used with array headers, but mxGetPr, mxGetPi, mxGetIr, mxGetJc, + * mxSetPr, mxSetPi, mxSetIr, and mxSetJc cannot. + * + * An array header should NEVER be returned to MATLAB (for example via the + * MEX API), or any other non-matrix access API function that expects a + * full mxArray (examples include engPutVariable(), matPutVariable(), and + * mexPutVariable()). + * + * Return NULL if an error occurs. + */ +EXTERN_C LIBMAT_API mxArray * matGetVariableInfo(MATFile *pMF, const char * name); + + +/* + * Remove a variable with with the specified name from the MAT-file pMF. + * + * Return zero on success, non-zero on error. + */ +EXTERN_C LIBMAT_API matError matDeleteVariable(MATFile *pMF, const char *name); + + +/* + * Get a list of the names of the arrays in a MAT-file. + * The array of strings returned by this function contains "num" + * entries. It is allocated with one call to mxCalloc, and so + * can (must) be freed with one call to mxFree. + * + * If there are no arrays in the MAT-file, return value + * is NULL and num is set to zero. If an error occurs, + * return value is NULL and num is set to a negative number. + */ +EXTERN_C LIBMAT_API char ** matGetDir(MATFile * pMF, int *num); + +#endif /* mat_published_c_api_h */ + +#endif /* mat_h */ diff --git a/src/ext/matlab/inc/matrix.h b/src/ext/matlab/inc/matrix.h new file mode 100644 index 000000000..7975815c2 --- /dev/null +++ b/src/ext/matlab/inc/matrix.h @@ -0,0 +1,1575 @@ +/* + * PUBLISHed header for the libmx library. + * + * Copyright 1984-2017 The MathWorks, Inc. + * All Rights Reserved. + */ + +#ifdef MDA_ARRAY_HPP_ +#error Using MATLAB Data API with C Matrix API is not supported. +#endif + +#if defined(_MSC_VER) +#pragma once +#endif +#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) +#pragma once +#endif + +#ifndef MATRIX_DEVELOPER_API_HPP +#ifndef matrix_h +#define matrix_h +#include +#include +#include "tmwtypes.h" + +#ifdef _MSC_VER +#define MATRIX_DLL_EXPORT_SYM __declspec(dllexport) +#define MATRIX_DLL_IMPORT_SYM __declspec(dllimport) +#elif __GNUC__ >= 4 +#define MATRIX_DLL_EXPORT_SYM __attribute__((visibility("default"))) +#define MATRIX_DLL_IMPORT_SYM __attribute__((visibility("default"))) +#else +#define MATRIX_DLL_EXPORT_SYM +#define MATRIX_DLL_IMPORT_SYM +#endif + +/** + * Define symbol access for symbols exported from the libmwmatrix dll. + */ +#if defined(BUILDING_PUBLISHED_API_CPP) +#define LIBMMWMATRIX_PUBLISHED_API MATRIX_DLL_EXPORT_SYM +#else +#if defined(export_matrix_h) +/* we are a C file coming through /src/include/matrix.h */ +#define LIBMMWMATRIX_PUBLISHED_API MATRIX_DLL_IMPORT_SYM +#else +/* We are a C mex file coming through /extern/include/matrix.h + * LIBMMWMATRIX_PUBLISHED_API is empty to match definitions in mex.h. + */ +#ifdef LIBMMWMATRIX_PUBLISHED_API +#undef LIBMMWMATRIX_PUBLISHED_API +#endif +#define LIBMMWMATRIX_PUBLISHED_API +#endif /* export_matrix_h */ +#endif /* BUILDING_PUBLISHED_API_CPP */ + +#ifdef __cplusplus +#define LIBMMWMATRIX_PUBLISHED_API_EXTERN_C extern "C" LIBMMWMATRIX_PUBLISHED_API +#else +#define LIBMMWMATRIX_PUBLISHED_API_EXTERN_C extern LIBMMWMATRIX_PUBLISHED_API +#endif + + +#ifndef __RELEASE_VERSION_DETECTOR__ +#define __RELEASE_VERSION_DETECTOR__ + +#define MW_FIRST_API_VERSION 700 +#define R2017b 700 +#define R2018a 800 +#define MW_LATEST_API_VERSION 800 + + +#define MW_REL2VER(A) A + +#if defined(MX_COMPAT_32) || defined(MEX_DOUBLE_HANDLE) + +#if defined(MATLAB_MEXCMD_RELEASE) || defined(MATLAB_MEXSRC_RELEASE) + +/* Errors! Legacy knobs cannot be used with release-based hard knobs */ + +#if defined(MX_COMPAT_32) && defined(MATLAB_MEXCMD_RELEASE) +#error "MEX command option -R20XXx is incompatible with MX_COMPAT_32" +#endif + +#if defined(MEX_DOUBLE_HANDLE) && defined(MATLAB_MEXCMD_RELEASE) +#error "MEX command option -R20XXx is incompatible with MEX_DOUBLE_HANDLE" +#endif + +#if defined(MX_COMPAT_32) && defined(MATLAB_MEXSRC_RELEASE) +#error "Source code macro MATLAB_MEXSRC_RELEASE is incompatible with MX_COMPAT_32" +#endif + +#if defined(MEX_DOUBLE_HANDLE) && defined(MATLAB_MEXSRC_RELEASE) +#error "Source code macro MATLAB_MEXSRC_RELEASE is incompatible with MEX_DOUBLE_HANDLE" +#endif + +#else + +/* Legacy knobs are defined */ + +#define MATLAB_TARGET_API_VERSION MW_FIRST_API_VERSION + +#endif + +#else /* defined(MX_COMPAT_32) || defined(MEX_DOUBLE_HANDLE) */ + +/* No Legacy knobs. Check release-based tag */ + +#if defined(MATLAB_MEXCMD_RELEASE) +#define MW_MEXCMD_VERSION MW_REL2VER(MATLAB_MEXCMD_RELEASE) +#if MW_MEXCMD_VERSION < MW_FIRST_API_VERSION +#error invalid MATLAB_MEXCMD_RELEASE definition +#endif +#endif + +#if defined(MATLAB_MEXSRC_RELEASE) +#define MW_MEXSRC_VERSION MW_REL2VER(MATLAB_MEXSRC_RELEASE) +#if MW_MEXSRC_VERSION < MW_FIRST_API_VERSION +#error invalid MATLAB_MEXSRC_RELEASE definition +#endif +#endif + +#if defined(MATLAB_DEFAULT_RELEASE) +#define MW_DEFAULT_VERSION MW_REL2VER(MATLAB_DEFAULT_RELEASE) +#if MW_DEFAULT_VERSION < MW_FIRST_API_VERSION +#error invalid MATLAB_DEFAULT_RELEASE definition +#endif +#endif + +#if defined(MATLAB_MEXCMD_RELEASE) && defined(MATLAB_MEXSRC_RELEASE) +#if MW_MEXCMD_VERSION != MW_MEXSRC_VERSION +#error "MEX command option -R20XXx is incompatible with MATLAB_MEXSRC_RELEASE" +#endif +#endif + +#if defined(MATLAB_MEXCMD_RELEASE) || defined(MATLAB_MEXSRC_RELEASE) + +/* Check whether MEXCMD and MEXSRC release tags are compatible */ + +#if defined(MATLAB_MEXCMD_RELEASE) +#define MATLAB_TARGET_API_VERSION MW_MEXCMD_VERSION +#else +#define MATLAB_TARGET_API_VERSION MW_MEXSRC_VERSION +#endif + +#else /* defined(MATLAB_MEXCMD_RELEASE) || defined(MATLAB_MEXSRC_RELEASE) */ + +#if defined(MATLAB_DEFAULT_RELEASE) +#define MATLAB_TARGET_API_VERSION MW_DEFAULT_VERSION +#else + +/* None of the input macros are defined. Use LATEST */ +#define MATLAB_TARGET_API_VERSION MW_LATEST_API_VERSION + +#endif /* defined(MATLAB_DEFAULT_RELEASE) */ + +#endif /* defined(MATLAB_MEXCMD_RELEASE) || defined(MATLAB_MEXSRC_RELEASE) */ + +#endif /* defined(MX_COMPAT_32) || defined(MEX_DOUBLE_HANDLE) */ + +#if defined(TARGET_API_VERSION) +#if MATLAB_TARGET_API_VERSION != TARGET_API_VERSION +#error MATLAB_TARGET_API_VERSION != TARGET_API_VERSION +#endif +#else +#define TARGET_API_VERSION MATLAB_TARGET_API_VERSION +#endif + +#endif /* __RELEASE_VERSION_DETECTOR__ */ +#ifndef MXHBB__MATRIX__VERSION_DEFS__ +#define MXHBB__MATRIX__VERSION_DEFS__ + +#if defined(TARGET_API_VERSION) +#if !(TARGET_API_VERSION == 700 || TARGET_API_VERSION == 800) +#error invalid TARGET_VERSION_API definition +#elif defined(MEX_DOUBLE_HANDLE) && TARGET_API_VERSION != 700 +#error It is illegal to use MEX_DOUBLE_HANDLE with linear versioning +#elif defined(MX_COMPAT_32) && TARGET_API_VERSION != 700 +#error It is illegal to use MX_COMPAT_32 with linear versioning +#endif +#endif + +#ifndef BUILDING_LIBMX /*MXHBB__*/ + +#if !defined(TARGET_API_VERSION) || TARGET_API_VERSION == 700 +#if !defined(BUILDING_PUBLISHED_API_CPP) + +/* + * PUBLISHED APIs with changes in MATLAB 7.3 + */ + +#if !defined(MX_COMPAT_32) + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef mxSetProperty +#define mxSetProperty mxSetProperty_730 +#endif + +#ifndef mxGetProperty +#define mxGetProperty mxGetProperty_730 +#endif + +#ifndef mxSetField +#define mxSetField mxSetField_730 +#endif + +#ifndef mxSetFieldByNumber +#define mxSetFieldByNumber mxSetFieldByNumber_730 +#endif + +#ifndef mxGetFieldByNumber +#define mxGetFieldByNumber mxGetFieldByNumber_730 +#endif + +#ifndef mxGetField +#define mxGetField mxGetField_730 +#endif + +#ifndef mxCreateStructMatrix +#define mxCreateStructMatrix mxCreateStructMatrix_730 +#endif + +#ifndef mxCreateCellMatrix +#define mxCreateCellMatrix mxCreateCellMatrix_730 +#endif + +#ifndef mxCreateCharMatrixFromStrings +#define mxCreateCharMatrixFromStrings mxCreateCharMatrixFromStrings_730 +#endif + +#ifndef mxGetString +#define mxGetString mxGetString_730 +#endif + +#ifndef mxGetNumberOfDimensions +#define mxGetNumberOfDimensions mxGetNumberOfDimensions_730 +#endif + +#ifndef mxGetDimensions +#define mxGetDimensions mxGetDimensions_730 +#endif + +#ifndef mxSetDimensions +#define mxSetDimensions mxSetDimensions_730 +#endif + +#ifndef mxSetIr +#define mxSetIr mxSetIr_730 +#endif + +#ifndef mxGetIr +#define mxGetIr mxGetIr_730 +#endif + +#ifndef mxSetJc +#define mxSetJc mxSetJc_730 +#endif + +#ifndef mxGetJc +#define mxGetJc mxGetJc_730 +#endif + +#ifndef mxCreateStructArray +#define mxCreateStructArray mxCreateStructArray_730 +#endif + +#ifndef mxCreateCharArray +#define mxCreateCharArray mxCreateCharArray_730 +#endif + +#ifndef mxCreateNumericArray +#define mxCreateNumericArray mxCreateNumericArray_730 +#endif + +#ifndef mxCreateCellArray +#define mxCreateCellArray mxCreateCellArray_730 +#endif + +#ifndef mxCreateLogicalArray +#define mxCreateLogicalArray mxCreateLogicalArray_730 +#endif + +#ifndef mxGetCell +#define mxGetCell mxGetCell_730 +#endif + +#ifndef mxSetCell +#define mxSetCell mxSetCell_730 +#endif + +#ifndef mxSetNzmax +#define mxSetNzmax mxSetNzmax_730 +#endif + +#ifndef mxSetN +#define mxSetN mxSetN_730 +#endif + +#ifndef mxSetM +#define mxSetM mxSetM_730 +#endif + +#ifndef mxGetNzmax +#define mxGetNzmax mxGetNzmax_730 +#endif + +#ifndef mxCreateDoubleMatrix +#define mxCreateDoubleMatrix mxCreateDoubleMatrix_730 +#endif + +#ifndef mxCreateNumericMatrix +#define mxCreateNumericMatrix mxCreateNumericMatrix_730 +#endif + +#ifndef mxCreateLogicalMatrix +#define mxCreateLogicalMatrix mxCreateLogicalMatrix_730 +#endif + +#ifndef mxCreateSparse +#define mxCreateSparse mxCreateSparse_730 +#endif + +#ifndef mxCreateSparseLogicalMatrix +#define mxCreateSparseLogicalMatrix mxCreateSparseLogicalMatrix_730 +#endif + +#ifndef mxGetNChars +#define mxGetNChars mxGetNChars_730 +#endif + +#ifndef mxCreateStringFromNChars +#define mxCreateStringFromNChars mxCreateStringFromNChars_730 +#endif + +#ifndef mxCalcSingleSubscript +#define mxCalcSingleSubscript mxCalcSingleSubscript_730 +#endif + +#ifndef mxGetDimensions_fcn +#define mxGetDimensions_fcn mxGetDimensions_730 +#endif + +#ifdef __cplusplus +} +#endif + +#else /* MX_COMPAT_32 */ + +/* + * 32-bit compatibility APIs + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef mxGetNumberOfDimensions +#define mxGetNumberOfDimensions mxGetNumberOfDimensions_700 +#endif + +#ifndef mxGetDimensions +#define mxGetDimensions mxGetDimensions_700 +#endif + +#ifndef mxGetDimensions_fcn +#define mxGetDimensions_fcn mxGetDimensions_700 +#endif + +#ifndef mxGetIr +#define mxGetIr mxGetIr_700 +#endif + +#ifndef mxGetJc +#define mxGetJc mxGetJc_700 +#endif + +#ifndef mxGetCell +#define mxGetCell mxGetCell_700 +#endif + +#ifndef mxGetNzmax +#define mxGetNzmax mxGetNzmax_700 +#endif + +#ifndef mxSetNzmax +#define mxSetNzmax mxSetNzmax_700 +#endif + +#ifndef mxGetFieldByNumber +#define mxGetFieldByNumber mxGetFieldByNumber_700 +#endif + +#ifndef mxSetProperty +#define mxSetProperty mxSetProperty_700 +#endif + +#ifndef mxGetProperty +#define mxGetProperty mxGetProperty_700 +#endif + +#ifndef mxSetField +#define mxSetField mxSetField_700 +#endif + +#ifndef mxSetFieldByNumber +#define mxSetFieldByNumber mxSetFieldByNumber_700 +#endif + +#ifndef mxGetField +#define mxGetField mxGetField_700 +#endif + +#ifndef mxCreateStructMatrix +#define mxCreateStructMatrix mxCreateStructMatrix_700 +#endif + +#ifndef mxCreateCellMatrix +#define mxCreateCellMatrix mxCreateCellMatrix_700 +#endif + +#ifndef mxCreateCharMatrixFromStrings +#define mxCreateCharMatrixFromStrings mxCreateCharMatrixFromStrings_700 +#endif + +#ifndef mxGetString +#define mxGetString mxGetString_700 +#endif + +#ifndef mxSetDimensions +#define mxSetDimensions mxSetDimensions_700 +#endif + +#ifndef mxSetIr +#define mxSetIr mxSetIr_700 +#endif + +#ifndef mxSetJc +#define mxSetJc mxSetJc_700 +#endif + +#ifndef mxCreateStructArray +#define mxCreateStructArray mxCreateStructArray_700 +#endif + +#ifndef mxCreateCharArray +#define mxCreateCharArray mxCreateCharArray_700 +#endif + +#ifndef mxCreateNumericArray +#define mxCreateNumericArray mxCreateNumericArray_700 +#endif + +#ifndef mxCreateCellArray +#define mxCreateCellArray mxCreateCellArray_700 +#endif + +#ifndef mxCreateLogicalArray +#define mxCreateLogicalArray mxCreateLogicalArray_700 +#endif + +#ifndef mxSetCell +#define mxSetCell mxSetCell_700 +#endif + +#ifndef mxSetN +#define mxSetN mxSetN_700 +#endif + +#ifndef mxSetM +#define mxSetM mxSetM_700 +#endif + +#ifndef mxCreateDoubleMatrix +#define mxCreateDoubleMatrix mxCreateDoubleMatrix_700 +#endif + +#ifndef mxCreateNumericMatrix +#define mxCreateNumericMatrix mxCreateNumericMatrix_700 +#endif + +#ifndef mxCreateLogicalMatrix +#define mxCreateLogicalMatrix mxCreateLogicalMatrix_700 +#endif + +#ifndef mxCreateSparse +#define mxCreateSparse mxCreateSparse_700 +#endif + +#ifndef mxCreateSparseLogicalMatrix +#define mxCreateSparseLogicalMatrix mxCreateSparseLogicalMatrix_700 +#endif + +#ifndef mxGetNChars +#define mxGetNChars mxGetNChars_700 +#endif + +#ifndef mxCreateStringFromNChars +#define mxCreateStringFromNChars mxCreateStringFromNChars_700 +#endif + +#ifndef mxCalcSingleSubscript +#define mxCalcSingleSubscript mxCalcSingleSubscript_700 +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* #ifdef MX_COMPAT_32 */ +#endif /* !defined(BUILDING_PUBLISHED_API_CPP) */ + + +#elif TARGET_API_VERSION == 800 + +#define mxMalloc mxMalloc_800 +#define mxCalloc mxCalloc_800 +#define mxRealloc mxRealloc_800 +#define mxGetM mxGetM_800 +#define mxGetN mxGetN_800 +#define mxGetNumberOfElements mxGetNumberOfElements_800 +#define mxFree mxFree_800 +#define mxGetEps mxGetEps_800 +#define mxGetInf mxGetInf_800 +#define mxGetFieldNameByNumber mxGetFieldNameByNumber_800 +#define mxGetClassID mxGetClassID_800 +#define mxIsNumeric mxIsNumeric_800 +#define mxIsCell mxIsCell_800 +#define mxIsLogical mxIsLogical_800 +#define mxIsChar mxIsChar_800 +#define mxIsStruct mxIsStruct_800 +#define mxIsSparse mxIsSparse_800 +#define mxIsDouble mxIsDouble_800 +#define mxIsSingle mxIsSingle_800 +#define mxIsInt8 mxIsInt8_800 +#define mxIsUint8 mxIsUint8_800 +#define mxIsInt16 mxIsInt16_800 +#define mxIsUint16 mxIsUint16_800 +#define mxIsInt32 mxIsInt32_800 +#define mxIsUint32 mxIsUint32_800 +#define mxIsInt64 mxIsInt64_800 +#define mxIsUint64 mxIsUint64_800 +#define mxIsFromGlobalWS mxIsFromGlobalWS_800 +#define mxIsEmpty mxIsEmpty_800 +#define mxGetFieldNumber mxGetFieldNumber_800 +#define mxGetNumberOfFields mxGetNumberOfFields_800 +#define mxGetClassName mxGetClassName_800 +#define mxIsClass mxIsClass_800 +#define mxDestroyArray mxDestroyArray_800 +#define mxCreateDoubleScalar mxCreateDoubleScalar_800 +#define mxCreateString mxCreateString_800 +#define mxAddField mxAddField_800 +#define mxRemoveField mxRemoveField_800 +#define mxGetNaN mxGetNaN_800 +#define mxIsFinite mxIsFinite_800 +#define mxIsInf mxIsInf_800 +#define mxIsNaN mxIsNaN_800 +#define mxIsScalar mxIsScalar_800 +#define mxIsOpaque mxIsOpaque_800 +#define mxIsFunctionHandle mxIsFunctionHandle_800 +#define mxIsObject mxIsObject_800 +#define mxGetChars mxGetChars_800 +#define mxGetUserBits mxGetUserBits_800 +#define mxSetUserBits mxSetUserBits_800 +#define mxSetFromGlobalWS mxSetFromGlobalWS_800 +#define mxCreateUninitNumericMatrix mxCreateUninitNumericMatrix_800 +#define mxCreateUninitNumericArray mxCreateUninitNumericArray_800 +#define mxGetLogicals mxGetLogicals_800 +#define mxCreateLogicalScalar mxCreateLogicalScalar_800 +#define mxIsLogicalScalar mxIsLogicalScalar_800 +#define mxIsLogicalScalarTrue mxIsLogicalScalarTrue_800 +#define mxArrayToString mxArrayToString_800 +#define mxArrayToUTF8String mxArrayToUTF8String_800 +#define mxSetClassName mxSetClassName_800 +#define mxGetNumberOfDimensions mxGetNumberOfDimensions_800 +#define mxGetDimensions mxGetDimensions_800 +#define mxGetIr mxGetIr_800 +#define mxGetJc mxGetJc_800 +#define mxGetNzmax mxGetNzmax_800 +#define mxGetFieldByNumber mxGetFieldByNumber_800 +#define mxGetCell mxGetCell_800 +#define mxSetIr mxSetIr_800 +#define mxSetJc mxSetJc_800 +#define mxCalcSingleSubscript mxCalcSingleSubscript_800 +#define mxSetCell mxSetCell_800 +#define mxSetFieldByNumber mxSetFieldByNumber_800 +#define mxGetField mxGetField_800 +#define mxSetField mxSetField_800 +#define mxGetProperty mxGetProperty_800 +#define mxSetProperty mxSetProperty_800 +#define mxCreateNumericMatrix mxCreateNumericMatrix_800 +#define mxCreateNumericArray mxCreateNumericArray_800 +#define mxCreateCharArray mxCreateCharArray_800 +#define mxCreateDoubleMatrix mxCreateDoubleMatrix_800 +#define mxCreateSparse mxCreateSparse_800 +#define mxGetString mxGetString_800 +#define mxCreateCharMatrixFromStrings mxCreateCharMatrixFromStrings_800 +#define mxCreateCellMatrix mxCreateCellMatrix_800 +#define mxCreateCellArray mxCreateCellArray_800 +#define mxCreateStructMatrix mxCreateStructMatrix_800 +#define mxCreateStructArray mxCreateStructArray_800 +#define mxCreateLogicalArray mxCreateLogicalArray_800 +#define mxCreateLogicalMatrix mxCreateLogicalMatrix_800 +#define mxCreateSparseLogicalMatrix mxCreateSparseLogicalMatrix_800 +#define mxCreateStringFromNChars mxCreateStringFromNChars_800 +#define mxGetNChars mxGetNChars_800 +#define mxSetM mxSetM_800 +#define mxSetN mxSetN_800 +#define mxSetDimensions mxSetDimensions_800 +#define mxSetNzmax mxSetNzmax_800 +#define mxGetData mxGetData_800 +#define mxSetData mxSetData_800 +#define mxIsComplex mxIsComplex_800 +#define mxGetScalar mxGetScalar_800 +#define mxGetPr mxGetPr_800 +#define mxSetPr mxSetPr_800 +#define mxGetElementSize mxGetElementSize_800 +#define mxDuplicateArray mxDuplicateArray_800 +#define mxGetDoubles mxGetDoubles_800 +#define mxSetDoubles mxSetDoubles_800 +#define mxGetComplexDoubles mxGetComplexDoubles_800 +#define mxSetComplexDoubles mxSetComplexDoubles_800 +#define mxGetSingles mxGetSingles_800 +#define mxSetSingles mxSetSingles_800 +#define mxGetComplexSingles mxGetComplexSingles_800 +#define mxSetComplexSingles mxSetComplexSingles_800 +#define mxGetInt8s mxGetInt8s_800 +#define mxSetInt8s mxSetInt8s_800 +#define mxGetComplexInt8s mxGetComplexInt8s_800 +#define mxSetComplexInt8s mxSetComplexInt8s_800 +#define mxGetUint8s mxGetUint8s_800 +#define mxSetUint8s mxSetUint8s_800 +#define mxGetComplexUint8s mxGetComplexUint8s_800 +#define mxSetComplexUint8s mxSetComplexUint8s_800 +#define mxGetInt16s mxGetInt16s_800 +#define mxSetInt16s mxSetInt16s_800 +#define mxGetComplexInt16s mxGetComplexInt16s_800 +#define mxSetComplexInt16s mxSetComplexInt16s_800 +#define mxGetUint16s mxGetUint16s_800 +#define mxSetUint16s mxSetUint16s_800 +#define mxGetComplexUint16s mxGetComplexUint16s_800 +#define mxSetComplexUint16s mxSetComplexUint16s_800 +#define mxGetInt32s mxGetInt32s_800 +#define mxSetInt32s mxSetInt32s_800 +#define mxGetComplexInt32s mxGetComplexInt32s_800 +#define mxSetComplexInt32s mxSetComplexInt32s_800 +#define mxGetUint32s mxGetUint32s_800 +#define mxSetUint32s mxSetUint32s_800 +#define mxGetComplexUint32s mxGetComplexUint32s_800 +#define mxSetComplexUint32s mxSetComplexUint32s_800 +#define mxGetInt64s mxGetInt64s_800 +#define mxSetInt64s mxSetInt64s_800 +#define mxGetComplexInt64s mxGetComplexInt64s_800 +#define mxSetComplexInt64s mxSetComplexInt64s_800 +#define mxGetUint64s mxGetUint64s_800 +#define mxSetUint64s mxSetUint64s_800 +#define mxGetComplexUint64s mxGetComplexUint64s_800 +#define mxSetComplexUint64s mxSetComplexUint64s_800 +#define mxMakeArrayReal mxMakeArrayReal_800 +#define mxMakeArrayComplex mxMakeArrayComplex_800 +#define mxGetPi mxGetPiIsDeprecated +#define mxGetImagData mxGetImagDataIsDeprecated +#define mxSetImagData mxSetImagDataIsDeprecated +#define mxSetPi mxSetPiIsDeprecated +#define mxCreateSharedDataCopy mxCreateSharedDataCopyIsDeprecated +#define mxCreateUninitDoubleMatrix mxCreateUninitDoubleMatrixIsDeprecated +#define mxFastZeros mxFastZerosIsDeprecated +#define mxUnreference mxUnreferenceIsDeprecated +#define mxUnshareArray mxUnshareArrayIsDeprecated +#define mxGetPropertyShared mxGetPropertySharedIsDeprecated +#define mxSetPropertyShared mxSetPropertySharedIsDeprecated + +#endif /* TARGET_API_VERSION */ +#endif /* BUILDING_LIBMX MXHBB__*/ +#endif /* MXHBB__MATRIX__VERSION_DEFS__ */ +#ifndef MATHWORKS_MATRIX_DETAIL_PUBLISHED_FWD_DECLS_HPP +#define MATHWORKS_MATRIX_DETAIL_PUBLISHED_FWD_DECLS_HPP + +#include +#include + +/** + * Forward declaration for mxArray + */ +typedef struct mxArray_tag mxArray; + +/** + * Types representing MEX-file entry points + */ +typedef void (*mxFunctionPtr)(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]); + +/** + * Maximum mxArray name length + */ +#define mxMAXNAM TMW_NAME_LENGTH_MAX + +/** + * Logical type + */ +typedef bool mxLogical; + +/** + * Typedef required for Unicode support in MATLAB + */ +typedef CHAR16_T mxChar; + +/** + * Enumeration corresponding to all the valid mxArray types. + */ +typedef enum { + mxUNKNOWN_CLASS = 0, + mxCELL_CLASS, + mxSTRUCT_CLASS, + mxLOGICAL_CLASS, + mxCHAR_CLASS, + mxVOID_CLASS, + mxDOUBLE_CLASS, + mxSINGLE_CLASS, + mxINT8_CLASS, + mxUINT8_CLASS, + mxINT16_CLASS, + mxUINT16_CLASS, + mxINT32_CLASS, + mxUINT32_CLASS, + mxINT64_CLASS, + mxUINT64_CLASS, + mxFUNCTION_CLASS, + mxOPAQUE_CLASS, + mxOBJECT_CLASS, /* keep the last real item in the list */ +#if defined(_LP64) || defined(_WIN64) + mxINDEX_CLASS = mxUINT64_CLASS +#else + mxINDEX_CLASS = mxUINT32_CLASS +#endif +} mxClassID; + +/** + * Indicates whether floating-point mxArrays are real or complex. + */ +typedef enum { mxREAL, mxCOMPLEX } mxComplexity; + +/* + * MATRIX numeric real data types + */ +typedef double mxDouble; +typedef float mxSingle; +typedef int8_T mxInt8; +typedef uint8_T mxUint8; +typedef int16_T mxInt16; +typedef uint16_T mxUint16; +typedef int32_T mxInt32; +typedef uint32_T mxUint32; +typedef int64_T mxInt64; +typedef uint64_T mxUint64; + +#endif /* MATHWORKS_MATRIX_DETAIL_PUBLISHED_FWD_DECLS_HPP */ +#if TARGET_API_VERSION >= 800 +/* + * MATRIX numeric complex data types + */ +typedef struct { mxDouble real, imag; } mxComplexDouble; +typedef struct { mxSingle real, imag; } mxComplexSingle; +typedef struct { mxInt8 real, imag; } mxComplexInt8; +typedef struct { mxUint8 real, imag; } mxComplexUint8; +typedef struct { mxInt16 real, imag; } mxComplexInt16; +typedef struct { mxUint16 real, imag; } mxComplexUint16; +typedef struct { mxInt32 real, imag; } mxComplexInt32; +typedef struct { mxUint32 real, imag; } mxComplexUint32; +typedef struct { mxInt64 real, imag; } mxComplexInt64; +typedef struct { mxUint64 real, imag; } mxComplexUint64; + +#endif /* TARGET_API_VERSION >= 800 */ +#if TARGET_API_VERSION >= 800 + +/* + * Complex MATRIX types and real and complex data access + */ +#define MX_DECLARE_DATA_ACCESSORS(Name) \ + LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mx##Name *mxGet##Name##s(mxArray const *); \ + LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxSet##Name##s(mxArray *, mx##Name *); \ + LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mx##Complex##Name *mxGet##Complex##Name##s(mxArray const *); \ + LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxSet##Complex##Name##s(mxArray *, mx##Complex##Name *) + +MX_DECLARE_DATA_ACCESSORS(Double); /* mxDoubles*, mxComplexDoubles* in mx[SG]etDoubles, mx[SG]etComplexDoubles */ +MX_DECLARE_DATA_ACCESSORS(Single); /* mxSingles*, mxComplexSingles* in mx[SG]etSingles, mx[SG]etComplexSingles */ +MX_DECLARE_DATA_ACCESSORS(Int8); /* mxInt8s*, mxComplexInt8s* in mx[SG]etInt8s, mx[SG]etComplexInt8s */ +MX_DECLARE_DATA_ACCESSORS(Uint8); /* mxUint8s*, mxComplexUint8s* in mx[SG]etUint8s, mx[SG]etComplexUint8s */ +MX_DECLARE_DATA_ACCESSORS(Int16); /* mxInt16s*, mxComplexInt16s* in mx[SG]etInt16s, mx[SG]etComplexInt16s */ +MX_DECLARE_DATA_ACCESSORS(Uint16); /* mxUint16s*, mxComplexUint16s* in mx[SG]etUint16s, mx[SG]etComplexUint16s */ +MX_DECLARE_DATA_ACCESSORS(Int32); /* mxInt32s*, mxComplexInt32s* in mx[SG]etInt32s, mx[SG]etComplexInt32s */ +MX_DECLARE_DATA_ACCESSORS(Uint32); /* mxUint32s*, mxComplexUint32s* in mx[SG]etUint32s, mx[SG]etComplexUint32s */ +MX_DECLARE_DATA_ACCESSORS(Int64); /* mxInt64s*, mxComplexInt64s* in mx[SG]etInt64s, mx[SG]etComplexInt64s */ +MX_DECLARE_DATA_ACCESSORS(Uint64); /* mxUint64s*, mxComplexUint64s* in mx[SG]etUint64s, mx[SG]etComplexUint64s */ + +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxMakeArrayReal(mxArray *); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxMakeArrayComplex(mxArray *); + +#endif /* TARGET_API_VERSION >= 800 */ + +/* + * allocate memory, notifying registered listener + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxMalloc(size_t n /* number of bytes */ + ); + +/* + * allocate cleared memory, notifying registered listener. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxCalloc(size_t n, /* number of objects */ + size_t size /* size of objects */ + ); + +/* + * free memory, notifying registered listener. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxFree(void *ptr) /* pointer to memory to be freed */; + +/* + * reallocate memory, notifying registered listener. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxRealloc(void *ptr, size_t size); + +/* + * Get number of dimensions in array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwSize mxGetNumberOfDimensions(const mxArray *pa); + +/* + * Get pointer to dimension array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C const mwSize *mxGetDimensions(const mxArray *pa); + +/* + * Get row dimension + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C size_t mxGetM(const mxArray *pa); + +/* + * Get row data pointer for sparse numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwIndex *mxGetIr(const mxArray *pa); + +/* + * Get column data pointer for sparse numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwIndex *mxGetJc(const mxArray *pa); + +/* + * Get maximum nonzero elements for sparse numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwSize mxGetNzmax(const mxArray *pa); + +/* + * Set maximum nonzero elements for numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetNzmax(mxArray *pa, mwSize nzmax); + +/* + * Return pointer to the nth field name + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C const char *mxGetFieldNameByNumber(const mxArray *pa, int n); + + +/* + * Return a pointer to the contents of the named field for + * the ith element (zero based). + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxGetFieldByNumber(const mxArray *pa, mwIndex i, int fieldnum); + +/* + * Get a pointer to the specified cell element. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxGetCell(const mxArray *pa, mwIndex i); + +/* + * Return the class (category) of data that the array holds. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxClassID mxGetClassID(const mxArray *pa); + +/* + * Get pointer to data + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxGetData(const mxArray *pa /* pointer to array */ + ); + +/* + * Set pointer to data + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetData(mxArray *pa, /* pointer to array */ + void *newdata /* pointer to data */ + ); + +/* + * Determine whether the specified array contains numeric (as opposed + * to cell or struct) data. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsNumeric(const mxArray *pa); + +/* + * Determine whether the given array is a cell array. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsCell(const mxArray *pa); + +/* + * Determine whether the given array's logical flag is on. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsLogical(const mxArray *pa); + +/* + * Determine whether the given array's scalar flag is on. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsScalar(const mxArray *pa); + +/* + * Determine whether the given array contains character data. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsChar(const mxArray *pa); + +/* + * Determine whether the given array is a structure array. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsStruct(const mxArray *pa); + +/* + * Determine whether the given array is an opaque array. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsOpaque(const mxArray *pa); + +/* + * Returns true if specified array is a function object. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsFunctionHandle(const mxArray *pa); + +/* + * This function is deprecated and is preserved only for backward compatibility. + * DO NOT USE if possible. + * Is array user defined MATLAB v5 object + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsObject(const mxArray *pa /* pointer to array */ + ); +#if !defined(TARGET_API_VERSION) || (TARGET_API_VERSION == 700) +/* + * Get imaginary data pointer for numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxGetImagData(const mxArray *pa /* pointer to array */ + ); + +/* + * Set imaginary data pointer for numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void +mxSetImagData(mxArray *pa, /* pointer to array */ + void *newdata /* imaginary data array pointer */ + ); +#endif + +/* + * Determine whether the given array contains complex data. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsComplex(const mxArray *pa); + +/* + * Determine whether the given array is a sparse (as opposed to full). + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsSparse(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * double-precision floating-point numbers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsDouble(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * single-precision floating-point numbers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsSingle(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * signed 8-bit integers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInt8(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * unsigned 8-bit integers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsUint8(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * signed 16-bit integers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInt16(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * unsigned 16-bit integers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsUint16(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * signed 32-bit integers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInt32(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * unsigned 32-bit integers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsUint32(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * signed 64-bit integers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInt64(const mxArray *pa); + +/* + * Determine whether the specified array represents its data as + * unsigned 64-bit integers. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsUint64(const mxArray *pa); + +/* + * Get number of elements in array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C size_t mxGetNumberOfElements( + const mxArray *pa /* pointer to array */ + ); + +#if !defined(TARGET_API_VERSION) || (TARGET_API_VERSION == 700) +/* + * Get imaginary data pointer for numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double *mxGetPi(const mxArray *pa /* pointer to array */ + ); + +/* + * Set imaginary data pointer for numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetPi(mxArray *pa, /* pointer to array */ + double *pi /* imaginary data array pointer */ + ); +#endif + +/* + * Get string array data + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxChar *mxGetChars(const mxArray *pa /* pointer to array */ + ); + +/* + * Get 8 bits of user data stored in the mxArray header. NOTE: The state + * of these bits is not guaranteed to be preserved after API function + * calls. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxGetUserBits(const mxArray *pa /* pointer to array */ + ); + +/* + * Set 8 bits of user data stored in the mxArray header. NOTE: The state + * of these bits is not guaranteed to be preserved after API function + * calls. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetUserBits(mxArray *pa, /* pointer to array */ + int value); + +/* + * Get the real component of the specified array's first data element. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double mxGetScalar(const mxArray *pa); + +/* + * Inform Watcom compilers that scalar double return values + * will be in the FPU register. + */ +#ifdef __WATCOMC__ +#pragma aux mxGetScalar value[8087]; +#endif + +/* + * Is the isFromGlobalWorkspace bit set? + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsFromGlobalWS(const mxArray *pa); + +/* + * Set the isFromGlobalWorkspace bit. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetFromGlobalWS(mxArray *pa, bool global); + +/* + * Set row dimension + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetM(mxArray *pa, mwSize m); + +/* + * Get column dimension + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C size_t mxGetN(const mxArray *pa); + +/* + * Is array empty + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsEmpty(const mxArray *pa /* pointer to array */ + ); +/* + * Get the index to the named field. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxGetFieldNumber(const mxArray *pa, const char *name); + +/* + * Set row data pointer for sparse numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetIr(mxArray *pa, mwIndex *newir); + +/* + * Set column data pointer for sparse numeric array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetJc(mxArray *pa, mwIndex *newjc); + +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxGetData(const mxArray *pa); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetData(mxArray *pa, void *newdata); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double *mxGetPr(const mxArray *pa); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetPr(mxArray *pa, double *newdata); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C size_t mxGetElementSize(const mxArray *pa); + +/* + * Return the offset (in number of elements) from the beginning of + * the array to a given subscript. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwIndex mxCalcSingleSubscript(const mxArray *pa, + mwSize nsubs, + const mwIndex *subs); + +/* + * Get number of structure fields in array + * Returns 0 if mxArray is non-struct. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxGetNumberOfFields(const mxArray *pa /* pointer to array */ + ); + +/* + * Set an element in a cell array to the specified value. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetCell(mxArray *pa, mwIndex i, mxArray *value); + +/* + * Set pa[i][fieldnum] = value + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void +mxSetFieldByNumber(mxArray *pa, mwIndex i, int fieldnum, mxArray *value); + +/* + * Return a pointer to the contents of the named field for the ith + * element (zero based). Returns NULL on no such field or if the + * field itself is NULL + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxGetField(const mxArray *pa, mwIndex i, const char *fieldname); + +/* + * Sets the contents of the named field for the ith element (zero based). + * The input 'value' is stored in the input array 'pa' - no copy is made. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void +mxSetField(mxArray *pa, mwIndex i, const char *fieldname, mxArray *value); + +/* + * mxGetProperty returns the value of a property for a given object and index. + * The property must be public. + * + * If the given property name doesn't exist, or isn't public, or the object isn't + * the right type, then mxGetProperty returns NULL. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxGetProperty(const mxArray *pa, const mwIndex i, const char *propname); + +/* + * mxSetProperty sets the value of a property for a given object and index. + * The property must be public. + * + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void +mxSetProperty(mxArray *pa, mwIndex i, const char *propname, const mxArray *value); + +/* + * Return the name of an array's class. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C const char *mxGetClassName(const mxArray *pa); + +/* + * Determine whether an array is a member of the specified class. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsClass(const mxArray *pa, const char *name); + +/* + * Create a numeric matrix and initialize all its data elements to 0. + * In standalone mode, out-of-memory will mean a NULL pointer is returned. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateNumericMatrix(mwSize m, mwSize n, mxClassID classid, mxComplexity flag); + +/* + * Create an uninitialized numeric matrix. + * The resulting array must be freed with mxDestroyArray. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateUninitNumericMatrix(size_t m, size_t n, mxClassID classid, mxComplexity flag); + +/* + * Create an uninitialized numeric array. + * The resulting array must be freed with mxDestroyArray. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateUninitNumericArray(size_t ndim, size_t *dims, mxClassID classid, mxComplexity flag); + +/* + * Set column dimension + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetN(mxArray *pa, mwSize n); + +/* + * Set dimension array and number of dimensions. Returns 0 on success and 1 + * if there was not enough memory available to reallocate the dimensions array. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int +mxSetDimensions(mxArray *pa, const mwSize *pdims, mwSize ndims); + +/* + * mxArray destructor + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxDestroyArray(mxArray *pa); + +/* + * Create a numeric array and initialize all its data elements to 0. + * + * As with mxCreateNumericMatrix, in a standalone application, + * out-of-memory will mean a NULL pointer is returned. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateNumericArray(mwSize ndim, const mwSize *dims, mxClassID classid, mxComplexity flag); + +/* + * Create an N-Dimensional array to hold string data; + * initialize all elements to 0. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateCharArray(mwSize ndim, const mwSize *dims); + +/* + * Create a two-dimensional array to hold double-precision + * floating-point data; initialize each data element to 0. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateDoubleMatrix(mwSize m, mwSize n, mxComplexity flag); + +/* + * Get a properly typed pointer to the elements of a logical array. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxLogical *mxGetLogicals(const mxArray *pa); + +/* + * Create a logical array and initialize its data elements to false. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateLogicalArray(mwSize ndim, const mwSize *dims); + +/* + * Create a two-dimensional array to hold logical data and + * initialize each data element to false. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateLogicalMatrix(mwSize m, mwSize n); + +/* + * Create a logical scalar mxArray having the specified value. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateLogicalScalar(bool value); + +/* + * Returns true if we have a valid logical scalar mxArray. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsLogicalScalar(const mxArray *pa); + +/* + * Returns true if the logical scalar value is true. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsLogicalScalarTrue(const mxArray *pa); + +/* + * Create a double-precision scalar mxArray initialized to the + * value specified + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateDoubleScalar(double value); + +/* + * Create a 2-Dimensional sparse array. + * + * Z = mxCreateSparse(m,n,nzmax,cmplx_flag); + * An m-by-n, real or complex, sparse matrix with room for nzmax nonzeros. + * Use this to allocate storage for a sparse matrix. + * It allocates the structure, allocates the pr, pi, ir and jc arrays, + * and sets all the fields, which may be changed later. + * Avoids the question of malloc(0) by replacing nzmax = 0 with nzmax = 1. + * Also sets Z->pr[0] = 0.0 so that the scalar sparse(0.0) acts like 0.0. + * + * Notice that the value of m is almost irrelevant. It is only stored in + * the mxSetM field of the matrix structure. It does not affect the amount + * of storage required by sparse matrices, or the amount of time required + * by sparse algorithms. Consequently, m can be "infinite". The result + * is a semi-infinite matrix with a finite number of columns and a finite, + * but unspecified, number of nonzero rows. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateSparse(mwSize m, mwSize n, mwSize nzmax, mxComplexity flag); + +/* + * Create a 2-D sparse logical array + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateSparseLogicalMatrix(mwSize m, mwSize n, mwSize nzmax); + +/* + * Copies characters from a MATLAB array to a char array + * This function will attempt to perform null termination if it is possible. + * nChars is the number of bytes in the output buffer + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void +mxGetNChars(const mxArray *pa, char *buf, mwSize nChars); + +/* + * Converts a string array to a C-style string. The C-style string is in the + * local codepage encoding. If the conversion for the entire Unicode string + * cannot fit into the supplied character buffer, then the conversion includes + * the last whole codepoint that will fit into the buffer. The string is thus + * truncated at the greatest possible whole codepoint and does not split code- + * points. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int +mxGetString(const mxArray *pa, char *buf, mwSize buflen); + +/* + * Create a NULL terminated C string from an mxArray of type mxCHAR_CLASS + * Supports multibyte character sets. The resulting string must be freed + * with mxFree. Returns NULL on out of memory or non-character arrays. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C char *mxArrayToString(const mxArray *pa); + +/* + * Create a NULL terminated C string from an mxArray of type mxCHAR_CLASS + * The C style string is in UTF-8 encoding. The resulting + * string must be freed with mxFree. Returns NULL on out of memory or + * non-character arrays. + */ + +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C char *mxArrayToUTF8String(mxArray const *pa); + +/** + * Create a 1-by-n string array initialized to str. The supplied string is + * presumed to be in the local codepage encoding. The character data format + * in the mxArray will be UTF-16. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateStringFromNChars(const char *str, mwSize n); + +/* + * Create a 1-by-n string array initialized to null terminated string + * where n is the length of the string. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateString(const char *str); + +/* + * Create a string array initialized to the strings in str. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateCharMatrixFromStrings(mwSize m, const char **str); + +/* + * Create a 2-Dimensional cell array, with each cell initialized + * to NULL. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateCellMatrix(mwSize m, mwSize n); + +/* + * Create an N-Dimensional cell array, with each cell initialized + * to NULL. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateCellArray(mwSize ndim, const mwSize *dims); + +/* + * Create a 2-Dimensional structure array having the specified fields; + * initialize all values to NULL. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateStructMatrix(mwSize m, mwSize n, int nfields, const char **fieldnames); + +/* + * Create an N-Dimensional structure array having the specified fields; + * initialize all values to NULL. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * +mxCreateStructArray(mwSize ndim, const mwSize *dims, int nfields, const char **fieldnames); + +/* + * Make a deep copy of an array, return a pointer to the copy. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxDuplicateArray(const mxArray *in); + +/* + * Set classname of an unvalidated object array. It is illegal to + * call this function on a previously validated object array. + * Return 0 for success, 1 for failure. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxSetClassName(mxArray *pa, const char *classname); + +/* + * Add a field to a structure array. Returns field number on success or -1 + * if inputs are invalid or an out of memory condition occurs. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxAddField(mxArray *pa, const char *fieldname); + +/* + * Remove a field from a structure array. Does nothing if no such field exists. + * Does not destroy the field itself. +*/ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxRemoveField(mxArray *pa, int field); + +/* + * Function for obtaining MATLAB's concept of EPS + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double mxGetEps(void); + +/* + * Function for obtaining MATLAB's concept of INF (Used in MEX-File callback). + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double mxGetInf(void); + +/* + * Function for obtaining MATLAB's concept of NaN (Used in MEX-File callback). + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double mxGetNaN(void); + +/* + * test for finiteness in a machine-independent manner + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsFinite(double x /* value to test */ + ); + +/* + * test for infinity in a machine-independent manner + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInf(double x /* value to test */ + ); +/* + * test for NaN in a machine-independent manner + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsNaN(double x /* value to test */ + ); + +#if !defined(TARGET_API_VERSION) || (TARGET_API_VERSION == 700) +/* + * Undocumented. Removed in later APIs. + */ +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateSharedDataCopy(const mxArray *pa); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateUninitDoubleMatrix(int cmplx_flag, size_t m, size_t n); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxFastZeros(int cmplx_flag, int m, int n); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxUnreference(mxArray *pa); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxUnshareArray(mxArray *pa, int level); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxGetPropertyShared(const mxArray *pa, size_t i, const char *propname); +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetPropertyShared(mxArray *pa, size_t i, const char *propname, const mxArray *value); +#endif +/* + * Inform Watcom compilers that scalar double return values + * will be in the FPU register. + */ +#ifdef __WATCOMC__ +#pragma aux mxGetEps value[8087]; +#pragma aux mxGetInf value[8087]; +#pragma aux mxGetNaN value[8087]; +#endif + +#ifndef mxassert_h +#define mxassert_h +/* +mxAssert(int expression, char *error_message) +--------------------------------------------- + + Similar to ANSI C's assert() macro, the mxAssert macro checks the + value of an assertion, continuing execution only if the assertion + holds. If 'expression' evaluates to be true, then the mxAssert does + nothing. If, however, 'expression' is false, then mxAssert prints an + error message to the MATLAB Command Window, consisting of the failed + assertion's expression, the file name and line number where the failed + assertion occurred, and the string 'error_message'. 'error_message' + allows the user to specify a more understandable description of why + the assertion failed. (Use an empty string if no extra description + should follow the failed assertion message.) After a failed + assertion, control returns to the MATLAB command line. + + mxAssertS, (the S for Simple), takes the same inputs as mxAssert. It + does not print the text of the failed assertion, only the file and + line where the assertion failed, and the explanatory error_message. + + Note that script MEX will turn off these assertions when building + optimized MEX-functions, so they should be used for debugging + purposes only. +*/ + +#ifdef MATLAB_MEX_FILE +#ifndef NDEBUG + +LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void +mexPrintAssertion(const char *test, const char *fname, int linenum, const char *message); + +#define mxAssert(test, message) \ + ((test) ? (void)0 : mexPrintAssertion(#test, __FILE__, __LINE__, message)) +#define mxAssertS(test, message) \ + ((test) ? (void)0 : mexPrintAssertion("", __FILE__, __LINE__, message)) +#else +#define mxAssert(test, message) ((void)0) +#define mxAssertS(test, message) ((void)0) +#endif +#else +#include +#define mxAssert(test, message) assert(test) +#define mxAssertS(test, message) assert(test) +#endif + +#endif /* mxassert_h */ + +#endif /* matrix_h */ +#endif /* MATRIX_DEVELOPER_API_HPP */ +/* Copyright 2015-2017 The MathWorks, Inc. */ + +#ifndef __MX_API_VER_HPP__ +#define __MX_API_VER_HPP__ + +/* Current MATRIX published API version */ +#define MX_CURRENT_API_VER 0x08000000 + +/* Backward compatible current MATRIX published API version */ +#define MX_API_VER MX_CURRENT_API_VER + +/* Backward compatible MATRIX published API versions */ +#define MX_LAST_32BIT_VER 0x07000000 +#define MX_LAST_SEPARATE_COMPLEX_VER 0x07300000 + +/* Required MEX-file MATRIX published API version */ +#if TARGET_API_VERSION == 700 +#if defined(MX_COMPAT_32) +#define MX_TARGET_API_VER MX_LAST_32BIT_VER +#else +#define MX_TARGET_API_VER MX_LAST_SEPARATE_COMPLEX_VER +#endif +#else +#define MX_TARGET_API_VER MX_CURRENT_API_VER +#endif + +/* + * The following macros enable conditional compilation based on the + * target published API. The macros can be used in a single source file + * that is intended to be built against multiple matrix API versions. + * + * MX_HAS_64BIT_ARRAY_DIMS evaluates to a non-zero value if array + * dimensions are 64 bits wide. + * + * MX_HAS_INTERLEAVED_COMPLEX evaluates to a non-zero value if complex + * array data is interleaved. + * + */ +#define MX_HAS_64BIT_ARRAY_DIMS MX_TARGET_API_VER > MX_LAST_32BIT_VER +#define MX_HAS_INTERLEAVED_COMPLEX MX_TARGET_API_VER > MX_LAST_SEPARATE_COMPLEX_VER + +#endif /* __MX_API_VER_HPP__ */ diff --git a/src/ext/matlab/inc/tmwtypes.h b/src/ext/matlab/inc/tmwtypes.h new file mode 100644 index 000000000..fb478e15b --- /dev/null +++ b/src/ext/matlab/inc/tmwtypes.h @@ -0,0 +1,831 @@ +/* + * Copyright 1984-2018 The MathWorks, Inc. + */ + +#if defined(_MSC_VER) +# pragma once +#endif +#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) +# pragma once +#endif + +#ifndef tmwtypes_h +#define tmwtypes_h + +#ifndef __TMWTYPES__ +#define __TMWTYPES__ +/* + * File : tmwtypes.h + * Abstract: + * Data types for use with MATLAB/SIMULINK and the Real-Time Workshop. + * + * When compiling stand-alone model code, data types can be overridden + * via compiler switches. + * + * Define NO_FLOATS to eliminate reference to real_T, etc. + */ + +#include + +#ifdef __APPLE_CC__ +#include +#endif + +#define LOGICAL_IS_A_TYPE +#define SPARSE_GENERALIZATION + +#ifdef NO_FLOATS +# define double double_not_allowed +# define float float_not_allowed +#endif /*NO_FLOATS*/ + +#ifndef NO_FLOATS + +#ifndef __MWERKS__ +# ifdef __STDC__ +# include +# else +# define FLT_MANT_DIG 24 +# define DBL_MANT_DIG 53 +# endif +#endif + +#endif /*NO_FLOATS*/ + +/* + * The following data types cannot be overridden when building MEX files. + */ +#ifdef MATLAB_MEX_FILE +# undef CHARACTER_T +# undef INTEGER_T +# undef BOOLEAN_T +# undef REAL_T +# undef TIME_T +#endif + +/* + * The uchar_T, ushort_T and ulong_T types are needed for compilers which do + * not allow defines to be specified, at the command line, with spaces in them. + */ + +typedef unsigned char uchar_T; +typedef unsigned short ushort_T; +typedef unsigned long ulong_T; + +#if (defined(_MSC_VER) && _MSC_VER >= 1500) \ + || defined(__x86_64__) || defined(__LP64__) \ + || defined(__LCC64__) + +typedef unsigned long long ulonglong_T; +#endif + + + +/*=======================================================================* + * Fixed width word size data types: * + * int8_T, int16_T, int32_T - signed 8, 16, or 32 bit integers * + * uint8_T, uint16_T, uint32_T - unsigned 8, 16, or 32 bit integers * + * real32_T, real64_T - 32 and 64 bit floating point numbers * + *=======================================================================*/ + +/* When used with Real Time Workshop generated code, this + * header file can be used with a variety of compilers. + * + * The compiler could be for an 8 bit embedded processor that + * only had 8 bits per integer and 16 bits per long. + * In that example, a 32 bit integer size is not even available. + * This header file should be robust to that. + * + * For the case of an 8 bit processor, the preprocessor + * may be limited to 16 bit math like its target. That limitation + * would mean that 32 bit comparisons can't be done accurately. + * To increase robustness to this, comparisons are done against + * smaller values first. An inaccurate 32 bit comparison isn't + * attempted if the 16 bit comparison has already succeeded. + * + * Limitations on preprocessor math can also be stricter than + * for the target. There are known cases where a compiler + * targeting processors with 64 bit longs can't do accurate + * preprocessor comparisons on more than 32 bits. + */ + +/* Determine the number of bits for int, long, short, and char. + * If one fails to be determined, set the number of bits to -1 + */ + +#ifndef TMW_BITS_PER_INT +# if INT_MAX == 0x7FL +# define TMW_BITS_PER_INT 8 +# elif INT_MAX == 0x7FFFL +# define TMW_BITS_PER_INT 16 +# elif INT_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_INT 32 +# else +# define TMW_BITS_PER_INT -1 +# endif +#endif + +#ifndef TMW_BITS_PER_LONG +# if LONG_MAX == 0x7FL +# define TMW_BITS_PER_LONG 8 +# elif LONG_MAX == 0x7FFFL +# define TMW_BITS_PER_LONG 16 +# elif LONG_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_LONG 32 +# else +# define TMW_BITS_PER_LONG -1 +# endif +#endif + +#ifndef TMW_BITS_PER_SHRT +# if SHRT_MAX == 0x7FL +# define TMW_BITS_PER_SHRT 8 +# elif SHRT_MAX == 0x7FFFL +# define TMW_BITS_PER_SHRT 16 +# elif SHRT_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_SHRT 32 +# else +# define TMW_BITS_PER_SHRT -1 +# endif +#endif + +#ifndef TMW_BITS_PER_SCHAR +# if SCHAR_MAX == 0x7FL +# define TMW_BITS_PER_SCHAR 8 +# elif SCHAR_MAX == 0x7FFFL +# define TMW_BITS_PER_SCHAR 16 +# elif SCHAR_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_SCHAR 32 +# else +# define TMW_BITS_PER_SCHAR -1 +# endif +#endif + +#ifndef TMW_CHAR_SIGNED +# if SCHAR_MAX == CHAR_MAX +# define TMW_CHAR_SIGNED 1 +# else +# define TMW_CHAR_SIGNED 0 +# endif +#endif + +/* It is common for one or more of the integer types + * to be the same size. For example, on many embedded + * processors, both shorts and ints are 16 bits. On + * processors used for workstations, it is quite common + * for both int and long to be 32 bits. + * When there is more than one choice for typdef'ing + * a portable type like int16_T or uint32_T, in + * concept, it should not matter which choice is made. + * However, some style guides and some code checking + * tools do identify and complain about seemingly + * irrelevant differences. For example, a code + * checking tool may complain about an implicit + * conversion from int to short even though both + * are 16 bits. To reduce these types of + * complaints, it is best to make int the + * preferred choice when more than one is available. + */ + +#ifndef INT8_T +# if TMW_BITS_PER_INT == 8 +# define INT8_T int +# elif TMW_BITS_PER_LONG == 8 +# define INT8_T long +# elif TMW_BITS_PER_SCHAR == 8 +# define INT8_T signed char +# elif TMW_BITS_PER_SHRT == 8 +# define INT8_T short +# endif +#endif +#ifdef INT8_T + typedef INT8_T int8_T; +#endif + +#ifndef UINT8_T +# if TMW_BITS_PER_INT == 8 +# define UINT8_T unsigned int +# elif TMW_BITS_PER_LONG == 8 +# define UINT8_T unsigned long +# elif TMW_BITS_PER_SCHAR == 8 +# define UINT8_T unsigned char +# elif TMW_BITS_PER_SHRT == 8 +# define UINT8_T unsigned short +# endif +#endif +#ifdef UINT8_T + typedef UINT8_T uint8_T; +#endif + + +#ifndef INT16_T +# if TMW_BITS_PER_INT == 16 +# define INT16_T int +# elif TMW_BITS_PER_LONG == 16 +# define INT16_T long +# elif TMW_BITS_PER_SCHAR == 16 +# define INT16_T signed char +# elif TMW_BITS_PER_SHRT == 16 +# define INT16_T short +# endif +#endif +#ifdef INT16_T + typedef INT16_T int16_T; +#endif + + +#ifndef UINT16_T +# if TMW_BITS_PER_INT == 16 +# define UINT16_T unsigned int +# elif TMW_BITS_PER_LONG == 16 +# define UINT16_T unsigned long +# elif TMW_BITS_PER_SCHAR == 16 +# define UINT16_T unsigned char +# elif TMW_BITS_PER_SHRT == 16 +# define UINT16_T unsigned short +# endif +#endif +#ifdef UINT16_T + typedef UINT16_T uint16_T; +#endif + + +#ifndef INT32_T +# if TMW_BITS_PER_INT == 32 +# define INT32_T int +# elif TMW_BITS_PER_LONG == 32 +# define INT32_T long +# elif TMW_BITS_PER_SCHAR == 32 +# define INT32_T signed char +# elif TMW_BITS_PER_SHRT == 32 +# define INT32_T short +# endif +#endif +#ifdef INT32_T + typedef INT32_T int32_T; +#endif + + +#ifndef UINT32_T +# if TMW_BITS_PER_INT == 32 +# define UINT32_T unsigned int +# elif TMW_BITS_PER_LONG == 32 +# define UINT32_T unsigned long +# elif TMW_BITS_PER_SCHAR == 32 +# define UINT32_T unsigned char +# elif TMW_BITS_PER_SHRT == 32 +# define UINT32_T unsigned short +# endif +#endif +#ifdef UINT32_T + typedef UINT32_T uint32_T; +#endif + +/* The following is used to emulate smaller integer types when only + * larger types are available. For example, compilers for TI C3x/C4x DSPs + * define char and short to be 32 bits, so 8 and 16 bits are not directly + * available. This target is commonly used with RTW rapid prototyping. + * Other DSPs define char to be 16 bits, so 8 bits is not directly + * available. + */ +#ifndef INT8_T +# ifdef INT16_T +# define INT8_T INT16_T + typedef INT8_T int8_T; +# else +# ifdef INT32_T +# define INT8_T INT32_T + typedef INT8_T int8_T; +# endif +# endif +#endif + +#ifndef UINT8_T +# ifdef UINT16_T +# define UINT8_T UINT16_T + typedef UINT8_T uint8_T; +# else +# ifdef UINT32_T +# define UINT8_T UINT32_T + typedef UINT8_T uint8_T; +# endif +# endif +#endif + +#ifndef INT16_T +# ifdef INT32_T +# define INT16_T INT32_T + typedef INT16_T int16_T; +# endif +#endif + +#ifndef UINT16_T +# ifdef UINT32_T +# define UINT16_T UINT32_T + typedef UINT16_T uint16_T; +# endif +#endif + + +#ifndef NO_FLOATS + +#ifndef REAL32_T +# ifndef __MWERKS__ +# if FLT_MANT_DIG >= 23 +# define REAL32_T float +# endif +# else +# define REAL32_T float +# endif +#endif +#ifdef REAL32_T + typedef REAL32_T real32_T; +#endif + + +#ifndef REAL64_T +# ifndef __MWERKS__ +# if DBL_MANT_DIG >= 52 +# define REAL64_T double +# endif +# else +# define REAL64_T double +# endif +#endif +#ifdef REAL64_T + typedef REAL64_T real64_T; +#endif + +#endif /* NO_FLOATS*/ + +/*=======================================================================* + * Fixed width word size data types: * + * int64_T - signed 64 bit integers * + * uint64_T - unsigned 64 bit integers * + *=======================================================================*/ + + + +#ifndef INT64_T +# if defined(__APPLE__) +# define INT64_T long long +# define FMT64 "ll" +# if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif (defined(__x86_64__) || defined(__LP64__))&& !defined(__MINGW64__) +# define INT64_T long +# define FMT64 "l" +# if !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ + || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) +# define INT64_T __int64 +# define FMT64 "I64" +# elif defined(__GNUC__) || defined(TMW_ENABLE_INT64) \ + || defined(__LCC64__) +# define INT64_T long long +# define FMT64 "ll" +# endif +#endif + + + +#if defined(INT64_T) +# if defined(__GNUC__) && \ + ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))) + __extension__ +# endif + typedef INT64_T int64_T; +#endif + + + +#ifndef UINT64_T +# if defined(__APPLE__) +# define UINT64_T unsigned long long +# define FMT64 "ll" +# if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif (defined(__x86_64__) || defined(__LP64__))&& !defined(__MINGW64__) +# define UINT64_T unsigned long +# define FMT64 "l" +# if !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ + || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) +# define UINT64_T unsigned __int64 +# define FMT64 "I64" +# elif defined(__GNUC__) || defined(TMW_ENABLE_INT64) \ + || defined(__LCC64__) +# define UINT64_T unsigned long long +# define FMT64 "ll" +# endif +#endif + +#if defined(_WIN64) || (defined(__APPLE__) && defined(__LP64__)) \ + || defined(__x86_64__) \ + || defined(__LP64__) +# define INT_TYPE_64_IS_SUPPORTED +#endif + +#if defined(UINT64_T) +# if defined(__GNUC__) && \ + ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))) + __extension__ +# endif + typedef UINT64_T uint64_T; +#endif + +/*===========================================================================* + * Format string modifiers for using size_t variables in printf statements. * + *===========================================================================*/ + +#ifndef FMT_SIZE_T +# if (defined( __GNUC__ ) || defined(_STDC_C99))&& !defined(__MINGW64__) +# define FMT_SIZE_T "z" +# elif defined (__WATCOMC__) +# define FMT_SIZE_T "l" +# elif defined (_WIN32 ) +# define FMT_SIZE_T "I" +# else +# define FMT_SIZE_T "l" +# endif +#endif + +#ifndef FMT_PTRDIFF_T +# if defined(__APPLE__) +# define FMT_PTRDIFF_T "l" +# elif defined( __GNUC__ ) || defined(_STDC_C99) +# define FMT_PTRDIFF_T "t" +# elif defined (__WATCOMC__) +# define FMT_PTRDIFF_T "l" +# elif defined (_WIN32 ) +# define FMT_PTRDIFF_T "I" +# else +# define FMT_PTRDIFF_T "l" +# endif +#endif + +/*===========================================================================* + * General or logical data types where the word size is not guaranteed. * + * real_T - possible settings include real32_T or real64_T * + * time_T - possible settings include real32_T or real64_T * + * boolean_T * + * char_T * + * int_T * + * uint_T * + * byte_T * + *===========================================================================*/ + +#ifndef NO_FLOATS + +#ifndef REAL_T +# ifdef REAL64_T +# define REAL_T real64_T +# else +# ifdef REAL32_T +# define REAL_T real32_T +# endif +# endif +#endif +#ifdef REAL_T + typedef REAL_T real_T; +#endif + +#ifndef TIME_T +# ifdef REAL_T +# define TIME_T real_T +# endif +#endif +#ifdef TIME_T + typedef TIME_T time_T; +#endif + +#endif /* NO_FLOATS */ + +#ifndef BOOLEAN_T +# if defined(UINT8_T) +# define BOOLEAN_T UINT8_T +# else +# define BOOLEAN_T unsigned int +# endif +#endif +typedef BOOLEAN_T boolean_T; + + +#ifndef CHARACTER_T +# define CHARACTER_T char +#endif +typedef CHARACTER_T char_T; + + +#ifndef INTEGER_T +# define INTEGER_T int +#endif +typedef INTEGER_T int_T; + + +#ifndef UINTEGER_T +# define UINTEGER_T unsigned +#endif +typedef UINTEGER_T uint_T; + + +#ifndef BYTE_T +# define BYTE_T unsigned char +#endif +typedef BYTE_T byte_T; + + +/*===========================================================================* + * Define Complex Structures * + *===========================================================================*/ +#ifndef NO_FLOATS + +#ifndef CREAL32_T +# ifdef REAL32_T + typedef struct { + real32_T re, im; + } creal32_T; +# define CREAL32_T creal32_T +# endif +#endif + +#ifndef CREAL64_T +# ifdef REAL64_T + typedef struct { + real64_T re, im; + } creal64_T; +# define CREAL64_T creal64_T +# endif +#endif + +#ifndef CREAL_T +# ifdef REAL_T + typedef struct { + real_T re, im; + } creal_T; +# define CREAL_T creal_T +# endif +#endif + +#endif /* NO_FLOATS */ + +#ifndef CINT8_T +# ifdef INT8_T + typedef struct { + int8_T re, im; + } cint8_T; +# define CINT8_T cint8_T +# endif +#endif + +#ifndef CUINT8_T +# ifdef UINT8_T + typedef struct { + uint8_T re, im; + } cuint8_T; +# define CUINT8_T cuint8_T +# endif +#endif + +#ifndef CINT16_T +# ifdef INT16_T + typedef struct { + int16_T re, im; + } cint16_T; +# define CINT16_T cint16_T +# endif +#endif + +#ifndef CUINT16_T +# ifdef UINT16_T + typedef struct { + uint16_T re, im; + } cuint16_T; +# define CUINT16_T cuint16_T +# endif +#endif + +#ifndef CINT32_T +# ifdef INT32_T + typedef struct { + int32_T re, im; + } cint32_T; +# define CINT32_T cint32_T +# endif +#endif + +#ifndef CUINT32_T +# ifdef UINT32_T + typedef struct { + uint32_T re, im; + } cuint32_T; +# define CUINT32_T cuint32_T +# endif +#endif + +#ifndef CINT64_T +# ifdef INT64_T + typedef struct { + int64_T re, im; + } cint64_T; +# define CINT64_T cint64_T +# endif +#endif + +#ifndef CUINT64_T +# ifdef UINT64_T + typedef struct { + uint64_T re, im; + } cuint64_T; +# define CUINT64_T cuint64_T +# endif +#endif + +/*=======================================================================* + * Min and Max: * + * int8_T, int16_T, int32_T - signed 8, 16, or 32 bit integers * + * uint8_T, uint16_T, uint32_T - unsigned 8, 16, or 32 bit integers * + *=======================================================================*/ + +#define MAX_int8_T ((int8_T)(127)) /* 127 */ +#define MIN_int8_T ((int8_T)(-128)) /* -128 */ +#define MAX_uint8_T ((uint8_T)(255)) /* 255 */ +#define MIN_uint8_T ((uint8_T)(0)) + +#define MAX_int16_T ((int16_T)(32767)) /* 32767 */ +#define MIN_int16_T ((int16_T)(-32768)) /* -32768 */ +#define MAX_uint16_T ((uint16_T)(65535)) /* 65535 */ +#define MIN_uint16_T ((uint16_T)(0)) + +#define MAX_int32_T ((int32_T)(2147483647)) /* 2147483647 */ +#define MIN_int32_T ((int32_T)(-2147483647-1)) /* -2147483648 */ +#define MAX_uint32_T ((uint32_T)(0xFFFFFFFFU)) /* 4294967295 */ +#define MIN_uint32_T ((uint32_T)(0)) + +#if defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ + || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) \ + || defined(__LCC64__) +# ifdef INT64_T +# define MAX_int64_T ((int64_T)(9223372036854775807LL)) +# define MIN_int64_T ((int64_T)(-9223372036854775807LL-1LL)) +# endif +# ifdef UINT64_T +# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFULL)) +# define MIN_uint64_T ((uint64_T)(0)) +# endif +#else +# ifdef INT64_T +# ifdef INT_TYPE_64_IS_LONG +# define MAX_int64_T ((int64_T)(9223372036854775807L)) +# define MIN_int64_T ((int64_T)(-9223372036854775807L-1L)) +# else +# define MAX_int64_T ((int64_T)(9223372036854775807LL)) +# define MIN_int64_T ((int64_T)(-9223372036854775807LL-1LL)) +# endif +# endif +# ifdef UINT64_T +# ifdef INT_TYPE_64_IS_LONG +# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFUL)) +# define MIN_uint64_T ((uint64_T)(0)) +# else +# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFULL)) +# define MIN_uint64_T ((uint64_T)(0)) +# endif +# endif +#endif + +#ifdef _MSC_VER +/* Conversion from unsigned __int64 to double is not implemented in windows + * and results in a compile error, thus the value must first be cast to + * signed __int64, and then to double. + * + * If the 64 bit int value is greater than 2^63-1, which is the signed int64 max, + * the macro below provides a workaround for casting a uint64 value to a double + * in windows. + */ +# define uint64_to_double(u) ( ((u) > _I64_MAX) ? \ + (double)(__int64)((u) - _I64_MAX - 1) + (double)_I64_MAX + 1: \ + (double)(__int64)(u) ) + +/* The following inline function should only be used in the macro double_to_uint64, + * as it only handles the specfic range of double between 2^63 and 2^64-1 */ +__forceinline +uint64_T double_to_uint64_helper(double d) { + union double_to_uint64_union_type { + double dd; + uint64_T i64; + } di; + di.dd = d; + return (((di.i64 & 0x000fffffffffffff) | 0x0010000000000000) << 11); +} + +/* The largest double value that can be cast to uint64 in windows is the + * signed int64 max, which is 2^63-1. The macro below provides + * a workaround for casting large double values to uint64 in windows. + */ +/* The magic number 18446744073709551616.0 is 2^64 */ +/* The magic number 9223372036854775808.0 is 2^63 */ +# define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \ + 0xffffffffffffffffULL : \ + ((d) >= 0.0) ? \ + ((d) >= 9223372036854775808.0) ? \ + double_to_uint64_helper(d) : \ + (unsigned __int64)(d) : \ + 0ULL ) +#else +# define uint64_to_double(u) ((double)(u)) +# if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__TICCSC__) +/* double_to_uint64 defined only for MSVC and UNIX */ +# else +# define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \ + (unsigned long long) 0xffffffffffffffffULL : \ + ((d) >= 0) ? (unsigned long long)(d) : (unsigned long long) 0 ) +# endif +#endif + +#if !defined(__cplusplus) && !defined(__bool_true_false_are_defined) + +#ifndef _bool_T +#define _bool_T + +typedef boolean_T bool; + +#ifndef false +#define false (0) +#endif +#ifndef true +#define true (1) +#endif + +#endif /* _bool_T */ + +#endif /* !__cplusplus */ + +/* + * This software assumes that the code is being compiled on a target using a + * 2's complement representation for signed integer values. + */ +#if ((SCHAR_MIN + 1) != -SCHAR_MAX) +#error "This code must be compiled using a 2's complement representation for signed integer values" +#endif + +/* + * Maximum length of a MATLAB identifier (function/variable/model) + * including the null-termination character. + */ +#define TMW_NAME_LENGTH_MAX 64 + +/* + * Maximum values for indices and dimensions + */ +#include + +#ifdef MX_COMPAT_32 +typedef int mwSize; +typedef int mwIndex; +typedef int mwSignedIndex; +#else +typedef size_t mwSize; /* unsigned pointer-width integer */ +typedef size_t mwIndex; /* unsigned pointer-width integer */ +typedef ptrdiff_t mwSignedIndex; /* a signed pointer-width integer */ +#endif + +typedef int SLIndex; +typedef int SLSize; + +#if (defined(_LP64) || defined(_WIN64)) && !defined(MX_COMPAT_32) +/* Currently 2^48 based on hardware limitations */ +# define MWSIZE_MAX 281474976710655UL +# define MWINDEX_MAX 281474976710655UL +# define MWSINDEX_MAX 281474976710655L +# define MWSINDEX_MIN -281474976710655L +#else +# define MWSIZE_MAX 2147483647UL +# define MWINDEX_MAX 2147483647UL +# define MWSINDEX_MAX 2147483647L +# define MWSINDEX_MIN -2147483647L +#endif +#define MWSIZE_MIN 0UL +#define MWINDEX_MIN 0UL + +/** UTF-16 character type */ + +#if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT) +typedef char16_t CHAR16_T; +#define U16_STRING_LITERAL_PREFIX u +#elif defined(_MSC_VER) +typedef wchar_t CHAR16_T; +#define U16_STRING_LITERAL_PREFIX L +#else +typedef UINT16_T CHAR16_T; +#endif + +#endif /* __TMWTYPES__ */ + +#endif /* tmwtypes_h */ diff --git a/src/ext/matlab/lib/libmat.lib b/src/ext/matlab/lib/libmat.lib new file mode 100644 index 0000000000000000000000000000000000000000..6e2e05fbdf5ae6555fe62dc747efd76c2552db10 GIT binary patch literal 50128 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 literal 0 HcmV?d00001 diff --git a/src/ext/matlab/lib/libmx.lib b/src/ext/matlab/lib/libmx.lib new file mode 100644 index 0000000000000000000000000000000000000000..77ad77d641f9c23a506d4cbbd135733d7f0f3c51 GIT binary patch literal 728036 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
VFv+Sx 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 literal 0 HcmV?d00001 diff --git a/src/pbrt/cmd/imgtool.cpp b/src/pbrt/cmd/imgtool.cpp index 7694094e0..490297e6d 100644 --- a/src/pbrt/cmd/imgtool.cpp +++ b/src/pbrt/cmd/imgtool.cpp @@ -22,6 +22,9 @@ #include #include #include +#include +#include +#include extern "C" { #include @@ -127,6 +130,11 @@ static std::map commandUsage = { --despike For any pixels with a luminance value greater than , replace the pixel with the median of the 3x3 neighboring pixels. Default: infinity (i.e., disabled). + --exr2mat [|] + Convert input .exr file to .mat file according to channels specified. + e.g. imgtool convert --exr2mat 1,2,3,5 pbrt.exr + e.g. imgtool convert --exr2mat 1:5 pbrt.exr + Default: all channels --flipy Flip the image along the y axis --gamma Apply a gamma curve with exponent v. (Default: 1 (none)). --maxluminance Luminance value mapped to white by tonemapping. @@ -1595,78 +1603,79 @@ int bloom(std::vector args) { } } - if (outFile.empty()) - usage("bloom", "--outfile must be specified"); - if (inFile.empty()) - usage("bloom", "input filename must be specified"); - - ImageAndMetadata imRead = Image::Read(inFile); - Image &image = imRead.image; - - std::vector blurred; - - // First, threshold the source image - int nSurvivors = 0; - Point2i res = image.Resolution(); - int nc = image.NChannels(); - Image thresholdedImage(PixelFormat::Float, image.Resolution(), image.ChannelNames()); - for (int y = 0; y < res.y; ++y) { - for (int x = 0; x < res.x; ++x) { - bool overThreshold = false; +if (outFile.empty()) +usage("bloom", "--outfile must be specified"); +if (inFile.empty()) +usage("bloom", "input filename must be specified"); + +ImageAndMetadata imRead = Image::Read(inFile); +Image& image = imRead.image; + +std::vector blurred; + +// First, threshold the source image +int nSurvivors = 0; +Point2i res = image.Resolution(); +int nc = image.NChannels(); +Image thresholdedImage(PixelFormat::Float, image.Resolution(), image.ChannelNames()); +for (int y = 0; y < res.y; ++y) { + for (int x = 0; x < res.x; ++x) { + bool overThreshold = false; + for (int c = 0; c < nc; ++c) + if (image.GetChannel({ x, y }, c) > level) + overThreshold = true; + if (overThreshold) { + ++nSurvivors; for (int c = 0; c < nc; ++c) - if (image.GetChannel({x, y}, c) > level) - overThreshold = true; - if (overThreshold) { - ++nSurvivors; - for (int c = 0; c < nc; ++c) - thresholdedImage.SetChannel({x, y}, c, image.GetChannel({x, y}, c)); - } else - for (int c = 0; c < nc; ++c) - thresholdedImage.SetChannel({x, y}, c, 0.f); + thresholdedImage.SetChannel({ x, y }, c, image.GetChannel({ x, y }, c)); } + else + for (int c = 0; c < nc; ++c) + thresholdedImage.SetChannel({ x, y }, c, 0.f); } - if (nSurvivors == 0) { - fprintf(stderr, "imgtool: no pixels were above bloom threshold %f\n", level); - return 1; - } - blurred.push_back(std::move(thresholdedImage)); - - if ((width % 2) == 0) { - ++width; - fprintf(stderr, "imgtool bloom: width must be an odd value. Rounding up to %d.\n", - width); - } - int radius = width / 2; - - // Blur thresholded image. - Float sigma = radius / 2.; // TODO: make a parameter - - for (int iter = 0; iter < iterations; ++iter) { - Image blur = - blurred.back().GaussianFilter(image.AllChannelsDesc(), radius, sigma); - blurred.push_back(blur); - } - - // Finally, add all of the blurred images, scaled, to the original. - for (int y = 0; y < res.y; ++y) { - for (int x = 0; x < res.x; ++x) { - for (int c = 0; c < nc; ++c) { - Float blurredSum = 0.f; - // Skip the thresholded image, since it's already - // present in the original; just add pixels from the - // blurred ones. - for (size_t j = 1; j < blurred.size(); ++j) - blurredSum += blurred[j].GetChannel({x, y}, c); - image.SetChannel( - {x, y}, c, - image.GetChannel({x, y}, c) + (scale / iterations) * blurredSum); - } +} +if (nSurvivors == 0) { + fprintf(stderr, "imgtool: no pixels were above bloom threshold %f\n", level); + return 1; +} +blurred.push_back(std::move(thresholdedImage)); + +if ((width % 2) == 0) { + ++width; + fprintf(stderr, "imgtool bloom: width must be an odd value. Rounding up to %d.\n", + width); +} +int radius = width / 2; + +// Blur thresholded image. +Float sigma = radius / 2.; // TODO: make a parameter + +for (int iter = 0; iter < iterations; ++iter) { + Image blur = + blurred.back().GaussianFilter(image.AllChannelsDesc(), radius, sigma); + blurred.push_back(blur); +} + +// Finally, add all of the blurred images, scaled, to the original. +for (int y = 0; y < res.y; ++y) { + for (int x = 0; x < res.x; ++x) { + for (int c = 0; c < nc; ++c) { + Float blurredSum = 0.f; + // Skip the thresholded image, since it's already + // present in the original; just add pixels from the + // blurred ones. + for (size_t j = 1; j < blurred.size(); ++j) + blurredSum += blurred[j].GetChannel({ x, y }, c); + image.SetChannel( + { x, y }, c, + image.GetChannel({ x, y }, c) + (scale / iterations) * blurredSum); } } +} - image.Write(outFile); +image.Write(outFile); - return 0; +return 0; } int convert(std::vector args) { @@ -1679,14 +1688,16 @@ int convert(std::vector args) { Float despikeLimit = Infinity; bool preserveColors = false; bool bw = false; + bool exr2mat = false; std::string inFile, outFile; std::string colorspace; std::string channelNames; - std::array cropWindow = {-1, 0, -1, 0}; + std::vector exr2mat_channels; + std::array cropWindow = { -1, 0, -1, 0 }; Float clamp = Infinity; for (auto iter = args.begin(); iter != args.end(); ++iter) { - auto onError = [](const std::string &err) { + auto onError = [](const std::string& err) { usage("convert", "%s", err.c_str()); exit(1); }; @@ -1707,7 +1718,24 @@ int convert(std::vector args) { ParseArg(&iter, args.end(), "scale", &scale, onError) || ParseArg(&iter, args.end(), "tonemap", &tonemap, onError)) { // success - } else if ((*iter)[0] != '-' && inFile.empty()) { + } else if (normalizeArg(*iter) == normalizeArg("exr2mat")) { + exr2mat = true; + int n; + if (isdigit((*(iter+1))[0])) { + ++iter; + if ((n = (*iter).find(':')) != std::string::npos) { + int start = std::stoi((*iter).substr(0, n)); + int end = std::stoi((*iter).substr(n + 1, std::string::npos)); + for (int i = start; i != end + 1; i++) { + exr2mat_channels.push_back(i); + } + } else { + std::vector v = SplitStringToInts((*iter), ','); + std::copy(v.begin(), v.end(), exr2mat_channels.begin()); + } + } + } + else if ((*iter)[0] != '-' && inFile.empty()) { inFile = *iter; } else usage("convert", "%s: unknown command flag", iter->c_str()); @@ -1728,6 +1756,43 @@ int convert(std::vector args) { Image image = std::move(imRead.image); ImageMetadata metadata = std::move(imRead.metadata); + if (exr2mat) { + Point2i res = image.Resolution(); + int nc = image.NChannels(); + if (exr2mat_channels.empty()) + for (int i = 0; i != nc; ++i) { + exr2mat_channels.push_back(i); + } + int mc = exr2mat_channels.size(); + size_t datasize = res.x * res.y * mc; + Float *buf_exr = new float[datasize]; + for (int y = 0; y < res.y; ++y) + for (int x = 0; x < res.x; ++x) + for (int c = 0; c < mc; ++c) { + buf_exr[c * res.x * res.y + x * res.y + y] = + image.GetChannel({x, y}, c); + } + + mxArray *pWriteArray = NULL; + MATFile *pmatFile = NULL; + pmatFile = matOpen(outFile.c_str(), "w"); + mwSize *dims = new mwSize[3]; + memset((void *)dims, 0, sizeof(mwSize) * 3); + dims[0] = res.y; + dims[1] = res.x; + dims[2] = mc; + pWriteArray = mxCreateNumericArray(3, dims, mxSINGLE_CLASS, mxREAL); + memcpy((void *)(mxGetPr(pWriteArray)), (void *)buf_exr, sizeof(float) * datasize); + std::string vName = "exr"; + matPutVariable(pmatFile, vName.c_str(), pWriteArray); + matClose(pmatFile); + mxDestroyArray(pWriteArray); + delete[] buf_exr; + buf_exr = NULL; + delete[] dims; + dims = NULL; + } + if (channelNames.empty()) { // If the input image has AOVs and the target image is a regular // format, then just grab R,G,B... diff --git a/src/pbrt/textures.cpp b/src/pbrt/textures.cpp index 7d7176180..0eb2f5fc8 100644 --- a/src/pbrt/textures.cpp +++ b/src/pbrt/textures.cpp @@ -376,12 +376,12 @@ SampledSpectrum SpectrumImageTexture::Evaluate(TextureEvalContext ctx, basisSpectrum[nWave] = basisChannel[nWave]; } s = basisSpectrum * (rgb_spectrum[c] - offset) + s; - printf("CPU: tex_spectrum: %f channel %d \n basis_spectrum: %f %f %f %f %f " + /*printf("CPU: tex_spectrum: %f channel %d \n basis_spectrum: %f %f %f %f %f " "%f %f\n result_spectrum: %f %f %f %f %f %f %f\n", rgb_spectrum[c], c, basisSpectrum[1], basisSpectrum[3], basisSpectrum[5], basisSpectrum[7], basisSpectrum[9], basisSpectrum[11], basisSpectrum[13], s[1], s[3], s[5], s[7], s[9], - s[11], s[13]); + s[11], s[13]);*/ } return s; } else { From d6904d112a29ef0b06abbb38ec3c2b8220a1005d Mon Sep 17 00:00:00 2001 From: Tanglong Date: Thu, 2 Sep 2021 17:00:04 +0800 Subject: [PATCH 2/4] Add function to imgtool. Convert .exr file to binary file Usage: imgtool convert --exr2bin [|] Convert input .exr file to .mat file according to channels specified. e.g. imgtool convert --exr2bin 1,2,3,5 pbrt.exr e.g. imgtool convert --exr2bin 1:5 pbrt.exr e.g. imgtool convert --exr2bin B,G,R,Radiance.C05 pbrt.exr e.g. imgtool convert --exr2bin Radiance pbrt.exr Default: all channels --- CMakeLists.txt | 6 +- src/ext/matlab/inc/mat.h | 235 ----- src/ext/matlab/inc/matrix.h | 1575 --------------------------------- src/ext/matlab/inc/tmwtypes.h | 831 ----------------- src/ext/matlab/lib/libmat.lib | Bin 50128 -> 0 bytes src/ext/matlab/lib/libmx.lib | Bin 728036 -> 0 bytes src/pbrt/cmd/imgtool.cpp | 107 ++- 7 files changed, 66 insertions(+), 2688 deletions(-) delete mode 100644 src/ext/matlab/inc/mat.h delete mode 100644 src/ext/matlab/inc/matrix.h delete mode 100644 src/ext/matlab/inc/tmwtypes.h delete mode 100644 src/ext/matlab/lib/libmat.lib delete mode 100644 src/ext/matlab/lib/libmx.lib diff --git a/CMakeLists.txt b/CMakeLists.txt index bd80f1ba6..ba92f8a55 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -924,8 +924,6 @@ add_sanitizers (pbrt_exe) ###################### # imgtool -link_directories (src/ext/matlab/lib) - add_executable (imgtool src/pbrt/cmd/imgtool.cpp) add_executable (pbrt::imgtool ALIAS imgtool) @@ -934,8 +932,8 @@ set_property (TARGET sky_lib PROPERTY FOLDER "ext") target_compile_definitions (imgtool PRIVATE ${PBRT_DEFINITIONS}) target_compile_options (imgtool PRIVATE ${PBRT_CXX_FLAGS}) -target_include_directories (imgtool PRIVATE src src/ext src/ext/matlab/inc ${FLIP_INCLUDE}) -target_link_libraries (imgtool PRIVATE ${ALL_PBRT_LIBS} pbrt_opt pbrt_warnings sky_lib flip_lib libmat libmx) +target_include_directories (imgtool PRIVATE src src/ext ${FLIP_INCLUDE}) +target_link_libraries (imgtool PRIVATE ${ALL_PBRT_LIBS} pbrt_opt pbrt_warnings sky_lib flip_lib) add_sanitizers (imgtool) diff --git a/src/ext/matlab/inc/mat.h b/src/ext/matlab/inc/mat.h deleted file mode 100644 index c67840715..000000000 --- a/src/ext/matlab/inc/mat.h +++ /dev/null @@ -1,235 +0,0 @@ -/* Published header for libmat, the mat library. - Copyright 1984-2018 The MathWorks, Inc. - This file containes types, macros, and declarations necessary to - interface MEX files with the current version of MATLAB. - - See the release notes for information on supporting earlier versions. */ - -#ifndef mat_h -#define mat_h - -#include "matrix.h" - -#if defined(TARGET_API_VERSION) -#if !(TARGET_API_VERSION == 700 || TARGET_API_VERSION == 800) -#error invalid TARGET_VERSION_API definition -#elif defined(MEX_DOUBLE_HANDLE) && TARGET_API_VERSION != 700 -#error It is illegal to use MEX_DOUBLE_HANDLE with linear versioning -#elif defined(MX_COMPAT_32) && TARGET_API_VERSION != 700 -#error It is illegal to use MX_COMPAT_32 with linear versioning -#endif -#endif - - -#if TARGET_API_VERSION == 800 - -#define matOpen matOpen_800 -#define matClose matClose_800 -#define matGetFp matGetFp_800 -#define matPutVariable matPutVariable_800 -#define matPutVariableAsGlobal matPutVariableAsGlobal_800 -#define matGetVariable matGetVariable_800 -#define matGetNextVariable matGetNextVariable_800 -#define matGetNextVariableInfo matGetNextVariableInfo_800 -#define matGetVariableInfo matGetVariableInfo_800 -#define matDeleteVariable matDeleteVariable_800 -#define matGetDir matGetDir_800 -#define matGetErrno matGetErrno_800 - -#endif /* TARGET_API_VERSION */ -/* - * Copyright 1984-2018 The MathWorks, Inc. - * All Rights Reserved. - */ - -#if defined(_MSC_VER) -# pragma once -#endif -#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) -# pragma once -#endif - -#ifdef mat_core_api_h -#error the published and developer mat APIs cannot be combined -#endif - -#ifndef mat_published_c_api_h -#define mat_published_c_api_h - -#ifndef EXTERN_C -# ifdef __cplusplus -# define EXTERN_C extern "C" -# else -# define EXTERN_C extern -# endif -#endif - -#ifndef LIBMAT_API -# define LIBMAT_API -#endif - -#include /* for FILE */ - -#include "matrix.h" /* for mxArray */ - -/** - * \file - * \ingroup mat_pub_C_api - */ - - -/* incomplete typedef for MATFile */ -#ifdef __cplusplus -class MATFile; -#else -typedef struct MatFile_tag MATFile; -#endif - -#ifndef LIBMAT_API_OFFERS_ERROR_ENUMS -typedef int matError; -#endif - -/* - * Open a MAT-file "filename" using mode "mode". Return - * a pointer to a MATFile for use with other MAT API functions. - * - * Current valid entries for "mode" are - * "r" == read only. - * "w" == write only (deletes any existing file with name ). - * "w4" == as "w", but create a MATLAB 4.0 MAT-file. - * "w7.3" == as "w", but create a MATLAB 7.3 MAT-file. - * "u" == update. Read and write allowed, existing file is not deleted. - * - * Return NULL if an error occurs. - */ -EXTERN_C LIBMAT_API MATFile* matOpen(const char *filename, const char * mode); - - -/* - * Close a MAT-file opened with matOpen. - * The pointer-to-MATfile argument is invalid, once matClose returns. - * Return zero for success, EOF on error. - */ -EXTERN_C LIBMAT_API matError matClose(MATFile *pMF); - -/* - * Return zero if MATFile is successfully openedno error, nonzero value otherwise. - */ -EXTERN_C LIBMAT_API matError matGetErrno(MATFile *pMF); - - -/* - * Return the ANSI C FILE pointer obtained when the MAT-file was opened. - * Warning: the FILE pointer may be NULL in the case of a MAT file format - * that does not allow access to the raw file pointer. - */ -EXTERN_C LIBMAT_API FILE * matGetFp(MATFile *pMF); - - -/* - * Write array value with the specified name to the MAT-file, deleting any - * previously existing variable with that name in the MAT-file. - * - * Return zero for success, nonzero for error. - */ -EXTERN_C LIBMAT_API matError matPutVariable(MATFile * pMF, const char * name, const mxArray * pA); - - -/* - * Write array value with the specified name to the MAT-file pMF, deleting any - * previously existing variable in the MAT-file with the same name. - * - * The variable will be written such that when the MATLAB LOAD command - * loads the variable, it will automatically place it in the - * global workspace and establish a link to it in the local - * workspace (as if the command "global " had been - * issued after the variable was loaded.) - * - * Return zero for success, nonzero for error. - */ -EXTERN_C LIBMAT_API matError matPutVariableAsGlobal(MATFile * pMF, const char * name, const mxArray * pA); - - -/* - * Read the array value for the specified variable name from a MAT-file. - * - * Return NULL if an error occurs. - */ -EXTERN_C LIBMAT_API mxArray * matGetVariable(MATFile * pMF, const char * name); - - -/* - * Read the next array value from the current file location of the MAT-file - * pMF. This function should only be used in conjunction with - * matOpen and matClose. Passing pMF to any other API functions - * will cause matGetNextVariable() to work incorrectly. - * - * Return NULL if an error occurs. - */ -EXTERN_C LIBMAT_API mxArray * matGetNextVariable(MATFile *pMF, const char **nameptr); - - -/* - * Read the array header of the next array value in a MAT-file. - * This function should only be used in conjunction with - * matOpen and matClose. Passing pMF to any other API functions - * will cause matGetNextVariableInfo to work incorrectly. - * - * See the description of matGetVariableInfo() for the definition - * and valid uses of an array header. - * - * Return NULL if an error occurs. - */ -EXTERN_C LIBMAT_API mxArray * matGetNextVariableInfo(MATFile *pMF, const char **nameptr); - - -/* - * Read the array header for the variable with the specified name from - * the MAT-file. - * - * An array header contains all the same information as an - * array, except that the pr, pi, ir, and jc data structures are - * not allocated for non-recursive data types. That is, - * Cells, structures, and objects contain pointers to other - * array headers, but numeric, string, and sparse arrays do not - * contain valid data in their pr, pi, ir, or jc fields. - * - * The purpose of an array header is to gain fast access to - * information about an array without reading all the array's - * actual data. Thus, functions such as mxGetM, mxGetN, and mxGetClassID - * can be used with array headers, but mxGetPr, mxGetPi, mxGetIr, mxGetJc, - * mxSetPr, mxSetPi, mxSetIr, and mxSetJc cannot. - * - * An array header should NEVER be returned to MATLAB (for example via the - * MEX API), or any other non-matrix access API function that expects a - * full mxArray (examples include engPutVariable(), matPutVariable(), and - * mexPutVariable()). - * - * Return NULL if an error occurs. - */ -EXTERN_C LIBMAT_API mxArray * matGetVariableInfo(MATFile *pMF, const char * name); - - -/* - * Remove a variable with with the specified name from the MAT-file pMF. - * - * Return zero on success, non-zero on error. - */ -EXTERN_C LIBMAT_API matError matDeleteVariable(MATFile *pMF, const char *name); - - -/* - * Get a list of the names of the arrays in a MAT-file. - * The array of strings returned by this function contains "num" - * entries. It is allocated with one call to mxCalloc, and so - * can (must) be freed with one call to mxFree. - * - * If there are no arrays in the MAT-file, return value - * is NULL and num is set to zero. If an error occurs, - * return value is NULL and num is set to a negative number. - */ -EXTERN_C LIBMAT_API char ** matGetDir(MATFile * pMF, int *num); - -#endif /* mat_published_c_api_h */ - -#endif /* mat_h */ diff --git a/src/ext/matlab/inc/matrix.h b/src/ext/matlab/inc/matrix.h deleted file mode 100644 index 7975815c2..000000000 --- a/src/ext/matlab/inc/matrix.h +++ /dev/null @@ -1,1575 +0,0 @@ -/* - * PUBLISHed header for the libmx library. - * - * Copyright 1984-2017 The MathWorks, Inc. - * All Rights Reserved. - */ - -#ifdef MDA_ARRAY_HPP_ -#error Using MATLAB Data API with C Matrix API is not supported. -#endif - -#if defined(_MSC_VER) -#pragma once -#endif -#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) -#pragma once -#endif - -#ifndef MATRIX_DEVELOPER_API_HPP -#ifndef matrix_h -#define matrix_h -#include -#include -#include "tmwtypes.h" - -#ifdef _MSC_VER -#define MATRIX_DLL_EXPORT_SYM __declspec(dllexport) -#define MATRIX_DLL_IMPORT_SYM __declspec(dllimport) -#elif __GNUC__ >= 4 -#define MATRIX_DLL_EXPORT_SYM __attribute__((visibility("default"))) -#define MATRIX_DLL_IMPORT_SYM __attribute__((visibility("default"))) -#else -#define MATRIX_DLL_EXPORT_SYM -#define MATRIX_DLL_IMPORT_SYM -#endif - -/** - * Define symbol access for symbols exported from the libmwmatrix dll. - */ -#if defined(BUILDING_PUBLISHED_API_CPP) -#define LIBMMWMATRIX_PUBLISHED_API MATRIX_DLL_EXPORT_SYM -#else -#if defined(export_matrix_h) -/* we are a C file coming through /src/include/matrix.h */ -#define LIBMMWMATRIX_PUBLISHED_API MATRIX_DLL_IMPORT_SYM -#else -/* We are a C mex file coming through /extern/include/matrix.h - * LIBMMWMATRIX_PUBLISHED_API is empty to match definitions in mex.h. - */ -#ifdef LIBMMWMATRIX_PUBLISHED_API -#undef LIBMMWMATRIX_PUBLISHED_API -#endif -#define LIBMMWMATRIX_PUBLISHED_API -#endif /* export_matrix_h */ -#endif /* BUILDING_PUBLISHED_API_CPP */ - -#ifdef __cplusplus -#define LIBMMWMATRIX_PUBLISHED_API_EXTERN_C extern "C" LIBMMWMATRIX_PUBLISHED_API -#else -#define LIBMMWMATRIX_PUBLISHED_API_EXTERN_C extern LIBMMWMATRIX_PUBLISHED_API -#endif - - -#ifndef __RELEASE_VERSION_DETECTOR__ -#define __RELEASE_VERSION_DETECTOR__ - -#define MW_FIRST_API_VERSION 700 -#define R2017b 700 -#define R2018a 800 -#define MW_LATEST_API_VERSION 800 - - -#define MW_REL2VER(A) A - -#if defined(MX_COMPAT_32) || defined(MEX_DOUBLE_HANDLE) - -#if defined(MATLAB_MEXCMD_RELEASE) || defined(MATLAB_MEXSRC_RELEASE) - -/* Errors! Legacy knobs cannot be used with release-based hard knobs */ - -#if defined(MX_COMPAT_32) && defined(MATLAB_MEXCMD_RELEASE) -#error "MEX command option -R20XXx is incompatible with MX_COMPAT_32" -#endif - -#if defined(MEX_DOUBLE_HANDLE) && defined(MATLAB_MEXCMD_RELEASE) -#error "MEX command option -R20XXx is incompatible with MEX_DOUBLE_HANDLE" -#endif - -#if defined(MX_COMPAT_32) && defined(MATLAB_MEXSRC_RELEASE) -#error "Source code macro MATLAB_MEXSRC_RELEASE is incompatible with MX_COMPAT_32" -#endif - -#if defined(MEX_DOUBLE_HANDLE) && defined(MATLAB_MEXSRC_RELEASE) -#error "Source code macro MATLAB_MEXSRC_RELEASE is incompatible with MEX_DOUBLE_HANDLE" -#endif - -#else - -/* Legacy knobs are defined */ - -#define MATLAB_TARGET_API_VERSION MW_FIRST_API_VERSION - -#endif - -#else /* defined(MX_COMPAT_32) || defined(MEX_DOUBLE_HANDLE) */ - -/* No Legacy knobs. Check release-based tag */ - -#if defined(MATLAB_MEXCMD_RELEASE) -#define MW_MEXCMD_VERSION MW_REL2VER(MATLAB_MEXCMD_RELEASE) -#if MW_MEXCMD_VERSION < MW_FIRST_API_VERSION -#error invalid MATLAB_MEXCMD_RELEASE definition -#endif -#endif - -#if defined(MATLAB_MEXSRC_RELEASE) -#define MW_MEXSRC_VERSION MW_REL2VER(MATLAB_MEXSRC_RELEASE) -#if MW_MEXSRC_VERSION < MW_FIRST_API_VERSION -#error invalid MATLAB_MEXSRC_RELEASE definition -#endif -#endif - -#if defined(MATLAB_DEFAULT_RELEASE) -#define MW_DEFAULT_VERSION MW_REL2VER(MATLAB_DEFAULT_RELEASE) -#if MW_DEFAULT_VERSION < MW_FIRST_API_VERSION -#error invalid MATLAB_DEFAULT_RELEASE definition -#endif -#endif - -#if defined(MATLAB_MEXCMD_RELEASE) && defined(MATLAB_MEXSRC_RELEASE) -#if MW_MEXCMD_VERSION != MW_MEXSRC_VERSION -#error "MEX command option -R20XXx is incompatible with MATLAB_MEXSRC_RELEASE" -#endif -#endif - -#if defined(MATLAB_MEXCMD_RELEASE) || defined(MATLAB_MEXSRC_RELEASE) - -/* Check whether MEXCMD and MEXSRC release tags are compatible */ - -#if defined(MATLAB_MEXCMD_RELEASE) -#define MATLAB_TARGET_API_VERSION MW_MEXCMD_VERSION -#else -#define MATLAB_TARGET_API_VERSION MW_MEXSRC_VERSION -#endif - -#else /* defined(MATLAB_MEXCMD_RELEASE) || defined(MATLAB_MEXSRC_RELEASE) */ - -#if defined(MATLAB_DEFAULT_RELEASE) -#define MATLAB_TARGET_API_VERSION MW_DEFAULT_VERSION -#else - -/* None of the input macros are defined. Use LATEST */ -#define MATLAB_TARGET_API_VERSION MW_LATEST_API_VERSION - -#endif /* defined(MATLAB_DEFAULT_RELEASE) */ - -#endif /* defined(MATLAB_MEXCMD_RELEASE) || defined(MATLAB_MEXSRC_RELEASE) */ - -#endif /* defined(MX_COMPAT_32) || defined(MEX_DOUBLE_HANDLE) */ - -#if defined(TARGET_API_VERSION) -#if MATLAB_TARGET_API_VERSION != TARGET_API_VERSION -#error MATLAB_TARGET_API_VERSION != TARGET_API_VERSION -#endif -#else -#define TARGET_API_VERSION MATLAB_TARGET_API_VERSION -#endif - -#endif /* __RELEASE_VERSION_DETECTOR__ */ -#ifndef MXHBB__MATRIX__VERSION_DEFS__ -#define MXHBB__MATRIX__VERSION_DEFS__ - -#if defined(TARGET_API_VERSION) -#if !(TARGET_API_VERSION == 700 || TARGET_API_VERSION == 800) -#error invalid TARGET_VERSION_API definition -#elif defined(MEX_DOUBLE_HANDLE) && TARGET_API_VERSION != 700 -#error It is illegal to use MEX_DOUBLE_HANDLE with linear versioning -#elif defined(MX_COMPAT_32) && TARGET_API_VERSION != 700 -#error It is illegal to use MX_COMPAT_32 with linear versioning -#endif -#endif - -#ifndef BUILDING_LIBMX /*MXHBB__*/ - -#if !defined(TARGET_API_VERSION) || TARGET_API_VERSION == 700 -#if !defined(BUILDING_PUBLISHED_API_CPP) - -/* - * PUBLISHED APIs with changes in MATLAB 7.3 - */ - -#if !defined(MX_COMPAT_32) - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef mxSetProperty -#define mxSetProperty mxSetProperty_730 -#endif - -#ifndef mxGetProperty -#define mxGetProperty mxGetProperty_730 -#endif - -#ifndef mxSetField -#define mxSetField mxSetField_730 -#endif - -#ifndef mxSetFieldByNumber -#define mxSetFieldByNumber mxSetFieldByNumber_730 -#endif - -#ifndef mxGetFieldByNumber -#define mxGetFieldByNumber mxGetFieldByNumber_730 -#endif - -#ifndef mxGetField -#define mxGetField mxGetField_730 -#endif - -#ifndef mxCreateStructMatrix -#define mxCreateStructMatrix mxCreateStructMatrix_730 -#endif - -#ifndef mxCreateCellMatrix -#define mxCreateCellMatrix mxCreateCellMatrix_730 -#endif - -#ifndef mxCreateCharMatrixFromStrings -#define mxCreateCharMatrixFromStrings mxCreateCharMatrixFromStrings_730 -#endif - -#ifndef mxGetString -#define mxGetString mxGetString_730 -#endif - -#ifndef mxGetNumberOfDimensions -#define mxGetNumberOfDimensions mxGetNumberOfDimensions_730 -#endif - -#ifndef mxGetDimensions -#define mxGetDimensions mxGetDimensions_730 -#endif - -#ifndef mxSetDimensions -#define mxSetDimensions mxSetDimensions_730 -#endif - -#ifndef mxSetIr -#define mxSetIr mxSetIr_730 -#endif - -#ifndef mxGetIr -#define mxGetIr mxGetIr_730 -#endif - -#ifndef mxSetJc -#define mxSetJc mxSetJc_730 -#endif - -#ifndef mxGetJc -#define mxGetJc mxGetJc_730 -#endif - -#ifndef mxCreateStructArray -#define mxCreateStructArray mxCreateStructArray_730 -#endif - -#ifndef mxCreateCharArray -#define mxCreateCharArray mxCreateCharArray_730 -#endif - -#ifndef mxCreateNumericArray -#define mxCreateNumericArray mxCreateNumericArray_730 -#endif - -#ifndef mxCreateCellArray -#define mxCreateCellArray mxCreateCellArray_730 -#endif - -#ifndef mxCreateLogicalArray -#define mxCreateLogicalArray mxCreateLogicalArray_730 -#endif - -#ifndef mxGetCell -#define mxGetCell mxGetCell_730 -#endif - -#ifndef mxSetCell -#define mxSetCell mxSetCell_730 -#endif - -#ifndef mxSetNzmax -#define mxSetNzmax mxSetNzmax_730 -#endif - -#ifndef mxSetN -#define mxSetN mxSetN_730 -#endif - -#ifndef mxSetM -#define mxSetM mxSetM_730 -#endif - -#ifndef mxGetNzmax -#define mxGetNzmax mxGetNzmax_730 -#endif - -#ifndef mxCreateDoubleMatrix -#define mxCreateDoubleMatrix mxCreateDoubleMatrix_730 -#endif - -#ifndef mxCreateNumericMatrix -#define mxCreateNumericMatrix mxCreateNumericMatrix_730 -#endif - -#ifndef mxCreateLogicalMatrix -#define mxCreateLogicalMatrix mxCreateLogicalMatrix_730 -#endif - -#ifndef mxCreateSparse -#define mxCreateSparse mxCreateSparse_730 -#endif - -#ifndef mxCreateSparseLogicalMatrix -#define mxCreateSparseLogicalMatrix mxCreateSparseLogicalMatrix_730 -#endif - -#ifndef mxGetNChars -#define mxGetNChars mxGetNChars_730 -#endif - -#ifndef mxCreateStringFromNChars -#define mxCreateStringFromNChars mxCreateStringFromNChars_730 -#endif - -#ifndef mxCalcSingleSubscript -#define mxCalcSingleSubscript mxCalcSingleSubscript_730 -#endif - -#ifndef mxGetDimensions_fcn -#define mxGetDimensions_fcn mxGetDimensions_730 -#endif - -#ifdef __cplusplus -} -#endif - -#else /* MX_COMPAT_32 */ - -/* - * 32-bit compatibility APIs - */ - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef mxGetNumberOfDimensions -#define mxGetNumberOfDimensions mxGetNumberOfDimensions_700 -#endif - -#ifndef mxGetDimensions -#define mxGetDimensions mxGetDimensions_700 -#endif - -#ifndef mxGetDimensions_fcn -#define mxGetDimensions_fcn mxGetDimensions_700 -#endif - -#ifndef mxGetIr -#define mxGetIr mxGetIr_700 -#endif - -#ifndef mxGetJc -#define mxGetJc mxGetJc_700 -#endif - -#ifndef mxGetCell -#define mxGetCell mxGetCell_700 -#endif - -#ifndef mxGetNzmax -#define mxGetNzmax mxGetNzmax_700 -#endif - -#ifndef mxSetNzmax -#define mxSetNzmax mxSetNzmax_700 -#endif - -#ifndef mxGetFieldByNumber -#define mxGetFieldByNumber mxGetFieldByNumber_700 -#endif - -#ifndef mxSetProperty -#define mxSetProperty mxSetProperty_700 -#endif - -#ifndef mxGetProperty -#define mxGetProperty mxGetProperty_700 -#endif - -#ifndef mxSetField -#define mxSetField mxSetField_700 -#endif - -#ifndef mxSetFieldByNumber -#define mxSetFieldByNumber mxSetFieldByNumber_700 -#endif - -#ifndef mxGetField -#define mxGetField mxGetField_700 -#endif - -#ifndef mxCreateStructMatrix -#define mxCreateStructMatrix mxCreateStructMatrix_700 -#endif - -#ifndef mxCreateCellMatrix -#define mxCreateCellMatrix mxCreateCellMatrix_700 -#endif - -#ifndef mxCreateCharMatrixFromStrings -#define mxCreateCharMatrixFromStrings mxCreateCharMatrixFromStrings_700 -#endif - -#ifndef mxGetString -#define mxGetString mxGetString_700 -#endif - -#ifndef mxSetDimensions -#define mxSetDimensions mxSetDimensions_700 -#endif - -#ifndef mxSetIr -#define mxSetIr mxSetIr_700 -#endif - -#ifndef mxSetJc -#define mxSetJc mxSetJc_700 -#endif - -#ifndef mxCreateStructArray -#define mxCreateStructArray mxCreateStructArray_700 -#endif - -#ifndef mxCreateCharArray -#define mxCreateCharArray mxCreateCharArray_700 -#endif - -#ifndef mxCreateNumericArray -#define mxCreateNumericArray mxCreateNumericArray_700 -#endif - -#ifndef mxCreateCellArray -#define mxCreateCellArray mxCreateCellArray_700 -#endif - -#ifndef mxCreateLogicalArray -#define mxCreateLogicalArray mxCreateLogicalArray_700 -#endif - -#ifndef mxSetCell -#define mxSetCell mxSetCell_700 -#endif - -#ifndef mxSetN -#define mxSetN mxSetN_700 -#endif - -#ifndef mxSetM -#define mxSetM mxSetM_700 -#endif - -#ifndef mxCreateDoubleMatrix -#define mxCreateDoubleMatrix mxCreateDoubleMatrix_700 -#endif - -#ifndef mxCreateNumericMatrix -#define mxCreateNumericMatrix mxCreateNumericMatrix_700 -#endif - -#ifndef mxCreateLogicalMatrix -#define mxCreateLogicalMatrix mxCreateLogicalMatrix_700 -#endif - -#ifndef mxCreateSparse -#define mxCreateSparse mxCreateSparse_700 -#endif - -#ifndef mxCreateSparseLogicalMatrix -#define mxCreateSparseLogicalMatrix mxCreateSparseLogicalMatrix_700 -#endif - -#ifndef mxGetNChars -#define mxGetNChars mxGetNChars_700 -#endif - -#ifndef mxCreateStringFromNChars -#define mxCreateStringFromNChars mxCreateStringFromNChars_700 -#endif - -#ifndef mxCalcSingleSubscript -#define mxCalcSingleSubscript mxCalcSingleSubscript_700 -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* #ifdef MX_COMPAT_32 */ -#endif /* !defined(BUILDING_PUBLISHED_API_CPP) */ - - -#elif TARGET_API_VERSION == 800 - -#define mxMalloc mxMalloc_800 -#define mxCalloc mxCalloc_800 -#define mxRealloc mxRealloc_800 -#define mxGetM mxGetM_800 -#define mxGetN mxGetN_800 -#define mxGetNumberOfElements mxGetNumberOfElements_800 -#define mxFree mxFree_800 -#define mxGetEps mxGetEps_800 -#define mxGetInf mxGetInf_800 -#define mxGetFieldNameByNumber mxGetFieldNameByNumber_800 -#define mxGetClassID mxGetClassID_800 -#define mxIsNumeric mxIsNumeric_800 -#define mxIsCell mxIsCell_800 -#define mxIsLogical mxIsLogical_800 -#define mxIsChar mxIsChar_800 -#define mxIsStruct mxIsStruct_800 -#define mxIsSparse mxIsSparse_800 -#define mxIsDouble mxIsDouble_800 -#define mxIsSingle mxIsSingle_800 -#define mxIsInt8 mxIsInt8_800 -#define mxIsUint8 mxIsUint8_800 -#define mxIsInt16 mxIsInt16_800 -#define mxIsUint16 mxIsUint16_800 -#define mxIsInt32 mxIsInt32_800 -#define mxIsUint32 mxIsUint32_800 -#define mxIsInt64 mxIsInt64_800 -#define mxIsUint64 mxIsUint64_800 -#define mxIsFromGlobalWS mxIsFromGlobalWS_800 -#define mxIsEmpty mxIsEmpty_800 -#define mxGetFieldNumber mxGetFieldNumber_800 -#define mxGetNumberOfFields mxGetNumberOfFields_800 -#define mxGetClassName mxGetClassName_800 -#define mxIsClass mxIsClass_800 -#define mxDestroyArray mxDestroyArray_800 -#define mxCreateDoubleScalar mxCreateDoubleScalar_800 -#define mxCreateString mxCreateString_800 -#define mxAddField mxAddField_800 -#define mxRemoveField mxRemoveField_800 -#define mxGetNaN mxGetNaN_800 -#define mxIsFinite mxIsFinite_800 -#define mxIsInf mxIsInf_800 -#define mxIsNaN mxIsNaN_800 -#define mxIsScalar mxIsScalar_800 -#define mxIsOpaque mxIsOpaque_800 -#define mxIsFunctionHandle mxIsFunctionHandle_800 -#define mxIsObject mxIsObject_800 -#define mxGetChars mxGetChars_800 -#define mxGetUserBits mxGetUserBits_800 -#define mxSetUserBits mxSetUserBits_800 -#define mxSetFromGlobalWS mxSetFromGlobalWS_800 -#define mxCreateUninitNumericMatrix mxCreateUninitNumericMatrix_800 -#define mxCreateUninitNumericArray mxCreateUninitNumericArray_800 -#define mxGetLogicals mxGetLogicals_800 -#define mxCreateLogicalScalar mxCreateLogicalScalar_800 -#define mxIsLogicalScalar mxIsLogicalScalar_800 -#define mxIsLogicalScalarTrue mxIsLogicalScalarTrue_800 -#define mxArrayToString mxArrayToString_800 -#define mxArrayToUTF8String mxArrayToUTF8String_800 -#define mxSetClassName mxSetClassName_800 -#define mxGetNumberOfDimensions mxGetNumberOfDimensions_800 -#define mxGetDimensions mxGetDimensions_800 -#define mxGetIr mxGetIr_800 -#define mxGetJc mxGetJc_800 -#define mxGetNzmax mxGetNzmax_800 -#define mxGetFieldByNumber mxGetFieldByNumber_800 -#define mxGetCell mxGetCell_800 -#define mxSetIr mxSetIr_800 -#define mxSetJc mxSetJc_800 -#define mxCalcSingleSubscript mxCalcSingleSubscript_800 -#define mxSetCell mxSetCell_800 -#define mxSetFieldByNumber mxSetFieldByNumber_800 -#define mxGetField mxGetField_800 -#define mxSetField mxSetField_800 -#define mxGetProperty mxGetProperty_800 -#define mxSetProperty mxSetProperty_800 -#define mxCreateNumericMatrix mxCreateNumericMatrix_800 -#define mxCreateNumericArray mxCreateNumericArray_800 -#define mxCreateCharArray mxCreateCharArray_800 -#define mxCreateDoubleMatrix mxCreateDoubleMatrix_800 -#define mxCreateSparse mxCreateSparse_800 -#define mxGetString mxGetString_800 -#define mxCreateCharMatrixFromStrings mxCreateCharMatrixFromStrings_800 -#define mxCreateCellMatrix mxCreateCellMatrix_800 -#define mxCreateCellArray mxCreateCellArray_800 -#define mxCreateStructMatrix mxCreateStructMatrix_800 -#define mxCreateStructArray mxCreateStructArray_800 -#define mxCreateLogicalArray mxCreateLogicalArray_800 -#define mxCreateLogicalMatrix mxCreateLogicalMatrix_800 -#define mxCreateSparseLogicalMatrix mxCreateSparseLogicalMatrix_800 -#define mxCreateStringFromNChars mxCreateStringFromNChars_800 -#define mxGetNChars mxGetNChars_800 -#define mxSetM mxSetM_800 -#define mxSetN mxSetN_800 -#define mxSetDimensions mxSetDimensions_800 -#define mxSetNzmax mxSetNzmax_800 -#define mxGetData mxGetData_800 -#define mxSetData mxSetData_800 -#define mxIsComplex mxIsComplex_800 -#define mxGetScalar mxGetScalar_800 -#define mxGetPr mxGetPr_800 -#define mxSetPr mxSetPr_800 -#define mxGetElementSize mxGetElementSize_800 -#define mxDuplicateArray mxDuplicateArray_800 -#define mxGetDoubles mxGetDoubles_800 -#define mxSetDoubles mxSetDoubles_800 -#define mxGetComplexDoubles mxGetComplexDoubles_800 -#define mxSetComplexDoubles mxSetComplexDoubles_800 -#define mxGetSingles mxGetSingles_800 -#define mxSetSingles mxSetSingles_800 -#define mxGetComplexSingles mxGetComplexSingles_800 -#define mxSetComplexSingles mxSetComplexSingles_800 -#define mxGetInt8s mxGetInt8s_800 -#define mxSetInt8s mxSetInt8s_800 -#define mxGetComplexInt8s mxGetComplexInt8s_800 -#define mxSetComplexInt8s mxSetComplexInt8s_800 -#define mxGetUint8s mxGetUint8s_800 -#define mxSetUint8s mxSetUint8s_800 -#define mxGetComplexUint8s mxGetComplexUint8s_800 -#define mxSetComplexUint8s mxSetComplexUint8s_800 -#define mxGetInt16s mxGetInt16s_800 -#define mxSetInt16s mxSetInt16s_800 -#define mxGetComplexInt16s mxGetComplexInt16s_800 -#define mxSetComplexInt16s mxSetComplexInt16s_800 -#define mxGetUint16s mxGetUint16s_800 -#define mxSetUint16s mxSetUint16s_800 -#define mxGetComplexUint16s mxGetComplexUint16s_800 -#define mxSetComplexUint16s mxSetComplexUint16s_800 -#define mxGetInt32s mxGetInt32s_800 -#define mxSetInt32s mxSetInt32s_800 -#define mxGetComplexInt32s mxGetComplexInt32s_800 -#define mxSetComplexInt32s mxSetComplexInt32s_800 -#define mxGetUint32s mxGetUint32s_800 -#define mxSetUint32s mxSetUint32s_800 -#define mxGetComplexUint32s mxGetComplexUint32s_800 -#define mxSetComplexUint32s mxSetComplexUint32s_800 -#define mxGetInt64s mxGetInt64s_800 -#define mxSetInt64s mxSetInt64s_800 -#define mxGetComplexInt64s mxGetComplexInt64s_800 -#define mxSetComplexInt64s mxSetComplexInt64s_800 -#define mxGetUint64s mxGetUint64s_800 -#define mxSetUint64s mxSetUint64s_800 -#define mxGetComplexUint64s mxGetComplexUint64s_800 -#define mxSetComplexUint64s mxSetComplexUint64s_800 -#define mxMakeArrayReal mxMakeArrayReal_800 -#define mxMakeArrayComplex mxMakeArrayComplex_800 -#define mxGetPi mxGetPiIsDeprecated -#define mxGetImagData mxGetImagDataIsDeprecated -#define mxSetImagData mxSetImagDataIsDeprecated -#define mxSetPi mxSetPiIsDeprecated -#define mxCreateSharedDataCopy mxCreateSharedDataCopyIsDeprecated -#define mxCreateUninitDoubleMatrix mxCreateUninitDoubleMatrixIsDeprecated -#define mxFastZeros mxFastZerosIsDeprecated -#define mxUnreference mxUnreferenceIsDeprecated -#define mxUnshareArray mxUnshareArrayIsDeprecated -#define mxGetPropertyShared mxGetPropertySharedIsDeprecated -#define mxSetPropertyShared mxSetPropertySharedIsDeprecated - -#endif /* TARGET_API_VERSION */ -#endif /* BUILDING_LIBMX MXHBB__*/ -#endif /* MXHBB__MATRIX__VERSION_DEFS__ */ -#ifndef MATHWORKS_MATRIX_DETAIL_PUBLISHED_FWD_DECLS_HPP -#define MATHWORKS_MATRIX_DETAIL_PUBLISHED_FWD_DECLS_HPP - -#include -#include - -/** - * Forward declaration for mxArray - */ -typedef struct mxArray_tag mxArray; - -/** - * Types representing MEX-file entry points - */ -typedef void (*mxFunctionPtr)(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]); - -/** - * Maximum mxArray name length - */ -#define mxMAXNAM TMW_NAME_LENGTH_MAX - -/** - * Logical type - */ -typedef bool mxLogical; - -/** - * Typedef required for Unicode support in MATLAB - */ -typedef CHAR16_T mxChar; - -/** - * Enumeration corresponding to all the valid mxArray types. - */ -typedef enum { - mxUNKNOWN_CLASS = 0, - mxCELL_CLASS, - mxSTRUCT_CLASS, - mxLOGICAL_CLASS, - mxCHAR_CLASS, - mxVOID_CLASS, - mxDOUBLE_CLASS, - mxSINGLE_CLASS, - mxINT8_CLASS, - mxUINT8_CLASS, - mxINT16_CLASS, - mxUINT16_CLASS, - mxINT32_CLASS, - mxUINT32_CLASS, - mxINT64_CLASS, - mxUINT64_CLASS, - mxFUNCTION_CLASS, - mxOPAQUE_CLASS, - mxOBJECT_CLASS, /* keep the last real item in the list */ -#if defined(_LP64) || defined(_WIN64) - mxINDEX_CLASS = mxUINT64_CLASS -#else - mxINDEX_CLASS = mxUINT32_CLASS -#endif -} mxClassID; - -/** - * Indicates whether floating-point mxArrays are real or complex. - */ -typedef enum { mxREAL, mxCOMPLEX } mxComplexity; - -/* - * MATRIX numeric real data types - */ -typedef double mxDouble; -typedef float mxSingle; -typedef int8_T mxInt8; -typedef uint8_T mxUint8; -typedef int16_T mxInt16; -typedef uint16_T mxUint16; -typedef int32_T mxInt32; -typedef uint32_T mxUint32; -typedef int64_T mxInt64; -typedef uint64_T mxUint64; - -#endif /* MATHWORKS_MATRIX_DETAIL_PUBLISHED_FWD_DECLS_HPP */ -#if TARGET_API_VERSION >= 800 -/* - * MATRIX numeric complex data types - */ -typedef struct { mxDouble real, imag; } mxComplexDouble; -typedef struct { mxSingle real, imag; } mxComplexSingle; -typedef struct { mxInt8 real, imag; } mxComplexInt8; -typedef struct { mxUint8 real, imag; } mxComplexUint8; -typedef struct { mxInt16 real, imag; } mxComplexInt16; -typedef struct { mxUint16 real, imag; } mxComplexUint16; -typedef struct { mxInt32 real, imag; } mxComplexInt32; -typedef struct { mxUint32 real, imag; } mxComplexUint32; -typedef struct { mxInt64 real, imag; } mxComplexInt64; -typedef struct { mxUint64 real, imag; } mxComplexUint64; - -#endif /* TARGET_API_VERSION >= 800 */ -#if TARGET_API_VERSION >= 800 - -/* - * Complex MATRIX types and real and complex data access - */ -#define MX_DECLARE_DATA_ACCESSORS(Name) \ - LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mx##Name *mxGet##Name##s(mxArray const *); \ - LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxSet##Name##s(mxArray *, mx##Name *); \ - LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mx##Complex##Name *mxGet##Complex##Name##s(mxArray const *); \ - LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxSet##Complex##Name##s(mxArray *, mx##Complex##Name *) - -MX_DECLARE_DATA_ACCESSORS(Double); /* mxDoubles*, mxComplexDoubles* in mx[SG]etDoubles, mx[SG]etComplexDoubles */ -MX_DECLARE_DATA_ACCESSORS(Single); /* mxSingles*, mxComplexSingles* in mx[SG]etSingles, mx[SG]etComplexSingles */ -MX_DECLARE_DATA_ACCESSORS(Int8); /* mxInt8s*, mxComplexInt8s* in mx[SG]etInt8s, mx[SG]etComplexInt8s */ -MX_DECLARE_DATA_ACCESSORS(Uint8); /* mxUint8s*, mxComplexUint8s* in mx[SG]etUint8s, mx[SG]etComplexUint8s */ -MX_DECLARE_DATA_ACCESSORS(Int16); /* mxInt16s*, mxComplexInt16s* in mx[SG]etInt16s, mx[SG]etComplexInt16s */ -MX_DECLARE_DATA_ACCESSORS(Uint16); /* mxUint16s*, mxComplexUint16s* in mx[SG]etUint16s, mx[SG]etComplexUint16s */ -MX_DECLARE_DATA_ACCESSORS(Int32); /* mxInt32s*, mxComplexInt32s* in mx[SG]etInt32s, mx[SG]etComplexInt32s */ -MX_DECLARE_DATA_ACCESSORS(Uint32); /* mxUint32s*, mxComplexUint32s* in mx[SG]etUint32s, mx[SG]etComplexUint32s */ -MX_DECLARE_DATA_ACCESSORS(Int64); /* mxInt64s*, mxComplexInt64s* in mx[SG]etInt64s, mx[SG]etComplexInt64s */ -MX_DECLARE_DATA_ACCESSORS(Uint64); /* mxUint64s*, mxComplexUint64s* in mx[SG]etUint64s, mx[SG]etComplexUint64s */ - -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxMakeArrayReal(mxArray *); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxMakeArrayComplex(mxArray *); - -#endif /* TARGET_API_VERSION >= 800 */ - -/* - * allocate memory, notifying registered listener - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxMalloc(size_t n /* number of bytes */ - ); - -/* - * allocate cleared memory, notifying registered listener. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxCalloc(size_t n, /* number of objects */ - size_t size /* size of objects */ - ); - -/* - * free memory, notifying registered listener. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxFree(void *ptr) /* pointer to memory to be freed */; - -/* - * reallocate memory, notifying registered listener. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxRealloc(void *ptr, size_t size); - -/* - * Get number of dimensions in array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwSize mxGetNumberOfDimensions(const mxArray *pa); - -/* - * Get pointer to dimension array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C const mwSize *mxGetDimensions(const mxArray *pa); - -/* - * Get row dimension - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C size_t mxGetM(const mxArray *pa); - -/* - * Get row data pointer for sparse numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwIndex *mxGetIr(const mxArray *pa); - -/* - * Get column data pointer for sparse numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwIndex *mxGetJc(const mxArray *pa); - -/* - * Get maximum nonzero elements for sparse numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwSize mxGetNzmax(const mxArray *pa); - -/* - * Set maximum nonzero elements for numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetNzmax(mxArray *pa, mwSize nzmax); - -/* - * Return pointer to the nth field name - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C const char *mxGetFieldNameByNumber(const mxArray *pa, int n); - - -/* - * Return a pointer to the contents of the named field for - * the ith element (zero based). - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxGetFieldByNumber(const mxArray *pa, mwIndex i, int fieldnum); - -/* - * Get a pointer to the specified cell element. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxGetCell(const mxArray *pa, mwIndex i); - -/* - * Return the class (category) of data that the array holds. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxClassID mxGetClassID(const mxArray *pa); - -/* - * Get pointer to data - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxGetData(const mxArray *pa /* pointer to array */ - ); - -/* - * Set pointer to data - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetData(mxArray *pa, /* pointer to array */ - void *newdata /* pointer to data */ - ); - -/* - * Determine whether the specified array contains numeric (as opposed - * to cell or struct) data. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsNumeric(const mxArray *pa); - -/* - * Determine whether the given array is a cell array. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsCell(const mxArray *pa); - -/* - * Determine whether the given array's logical flag is on. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsLogical(const mxArray *pa); - -/* - * Determine whether the given array's scalar flag is on. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsScalar(const mxArray *pa); - -/* - * Determine whether the given array contains character data. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsChar(const mxArray *pa); - -/* - * Determine whether the given array is a structure array. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsStruct(const mxArray *pa); - -/* - * Determine whether the given array is an opaque array. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsOpaque(const mxArray *pa); - -/* - * Returns true if specified array is a function object. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsFunctionHandle(const mxArray *pa); - -/* - * This function is deprecated and is preserved only for backward compatibility. - * DO NOT USE if possible. - * Is array user defined MATLAB v5 object - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsObject(const mxArray *pa /* pointer to array */ - ); -#if !defined(TARGET_API_VERSION) || (TARGET_API_VERSION == 700) -/* - * Get imaginary data pointer for numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxGetImagData(const mxArray *pa /* pointer to array */ - ); - -/* - * Set imaginary data pointer for numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void -mxSetImagData(mxArray *pa, /* pointer to array */ - void *newdata /* imaginary data array pointer */ - ); -#endif - -/* - * Determine whether the given array contains complex data. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsComplex(const mxArray *pa); - -/* - * Determine whether the given array is a sparse (as opposed to full). - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsSparse(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * double-precision floating-point numbers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsDouble(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * single-precision floating-point numbers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsSingle(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * signed 8-bit integers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInt8(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * unsigned 8-bit integers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsUint8(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * signed 16-bit integers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInt16(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * unsigned 16-bit integers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsUint16(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * signed 32-bit integers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInt32(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * unsigned 32-bit integers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsUint32(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * signed 64-bit integers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInt64(const mxArray *pa); - -/* - * Determine whether the specified array represents its data as - * unsigned 64-bit integers. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsUint64(const mxArray *pa); - -/* - * Get number of elements in array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C size_t mxGetNumberOfElements( - const mxArray *pa /* pointer to array */ - ); - -#if !defined(TARGET_API_VERSION) || (TARGET_API_VERSION == 700) -/* - * Get imaginary data pointer for numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double *mxGetPi(const mxArray *pa /* pointer to array */ - ); - -/* - * Set imaginary data pointer for numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetPi(mxArray *pa, /* pointer to array */ - double *pi /* imaginary data array pointer */ - ); -#endif - -/* - * Get string array data - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxChar *mxGetChars(const mxArray *pa /* pointer to array */ - ); - -/* - * Get 8 bits of user data stored in the mxArray header. NOTE: The state - * of these bits is not guaranteed to be preserved after API function - * calls. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxGetUserBits(const mxArray *pa /* pointer to array */ - ); - -/* - * Set 8 bits of user data stored in the mxArray header. NOTE: The state - * of these bits is not guaranteed to be preserved after API function - * calls. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetUserBits(mxArray *pa, /* pointer to array */ - int value); - -/* - * Get the real component of the specified array's first data element. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double mxGetScalar(const mxArray *pa); - -/* - * Inform Watcom compilers that scalar double return values - * will be in the FPU register. - */ -#ifdef __WATCOMC__ -#pragma aux mxGetScalar value[8087]; -#endif - -/* - * Is the isFromGlobalWorkspace bit set? - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsFromGlobalWS(const mxArray *pa); - -/* - * Set the isFromGlobalWorkspace bit. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetFromGlobalWS(mxArray *pa, bool global); - -/* - * Set row dimension - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetM(mxArray *pa, mwSize m); - -/* - * Get column dimension - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C size_t mxGetN(const mxArray *pa); - -/* - * Is array empty - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsEmpty(const mxArray *pa /* pointer to array */ - ); -/* - * Get the index to the named field. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxGetFieldNumber(const mxArray *pa, const char *name); - -/* - * Set row data pointer for sparse numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetIr(mxArray *pa, mwIndex *newir); - -/* - * Set column data pointer for sparse numeric array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetJc(mxArray *pa, mwIndex *newjc); - -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void *mxGetData(const mxArray *pa); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetData(mxArray *pa, void *newdata); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double *mxGetPr(const mxArray *pa); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetPr(mxArray *pa, double *newdata); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C size_t mxGetElementSize(const mxArray *pa); - -/* - * Return the offset (in number of elements) from the beginning of - * the array to a given subscript. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mwIndex mxCalcSingleSubscript(const mxArray *pa, - mwSize nsubs, - const mwIndex *subs); - -/* - * Get number of structure fields in array - * Returns 0 if mxArray is non-struct. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxGetNumberOfFields(const mxArray *pa /* pointer to array */ - ); - -/* - * Set an element in a cell array to the specified value. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetCell(mxArray *pa, mwIndex i, mxArray *value); - -/* - * Set pa[i][fieldnum] = value - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void -mxSetFieldByNumber(mxArray *pa, mwIndex i, int fieldnum, mxArray *value); - -/* - * Return a pointer to the contents of the named field for the ith - * element (zero based). Returns NULL on no such field or if the - * field itself is NULL - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxGetField(const mxArray *pa, mwIndex i, const char *fieldname); - -/* - * Sets the contents of the named field for the ith element (zero based). - * The input 'value' is stored in the input array 'pa' - no copy is made. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void -mxSetField(mxArray *pa, mwIndex i, const char *fieldname, mxArray *value); - -/* - * mxGetProperty returns the value of a property for a given object and index. - * The property must be public. - * - * If the given property name doesn't exist, or isn't public, or the object isn't - * the right type, then mxGetProperty returns NULL. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxGetProperty(const mxArray *pa, const mwIndex i, const char *propname); - -/* - * mxSetProperty sets the value of a property for a given object and index. - * The property must be public. - * - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void -mxSetProperty(mxArray *pa, mwIndex i, const char *propname, const mxArray *value); - -/* - * Return the name of an array's class. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C const char *mxGetClassName(const mxArray *pa); - -/* - * Determine whether an array is a member of the specified class. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsClass(const mxArray *pa, const char *name); - -/* - * Create a numeric matrix and initialize all its data elements to 0. - * In standalone mode, out-of-memory will mean a NULL pointer is returned. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateNumericMatrix(mwSize m, mwSize n, mxClassID classid, mxComplexity flag); - -/* - * Create an uninitialized numeric matrix. - * The resulting array must be freed with mxDestroyArray. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateUninitNumericMatrix(size_t m, size_t n, mxClassID classid, mxComplexity flag); - -/* - * Create an uninitialized numeric array. - * The resulting array must be freed with mxDestroyArray. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateUninitNumericArray(size_t ndim, size_t *dims, mxClassID classid, mxComplexity flag); - -/* - * Set column dimension - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetN(mxArray *pa, mwSize n); - -/* - * Set dimension array and number of dimensions. Returns 0 on success and 1 - * if there was not enough memory available to reallocate the dimensions array. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int -mxSetDimensions(mxArray *pa, const mwSize *pdims, mwSize ndims); - -/* - * mxArray destructor - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxDestroyArray(mxArray *pa); - -/* - * Create a numeric array and initialize all its data elements to 0. - * - * As with mxCreateNumericMatrix, in a standalone application, - * out-of-memory will mean a NULL pointer is returned. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateNumericArray(mwSize ndim, const mwSize *dims, mxClassID classid, mxComplexity flag); - -/* - * Create an N-Dimensional array to hold string data; - * initialize all elements to 0. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateCharArray(mwSize ndim, const mwSize *dims); - -/* - * Create a two-dimensional array to hold double-precision - * floating-point data; initialize each data element to 0. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateDoubleMatrix(mwSize m, mwSize n, mxComplexity flag); - -/* - * Get a properly typed pointer to the elements of a logical array. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxLogical *mxGetLogicals(const mxArray *pa); - -/* - * Create a logical array and initialize its data elements to false. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateLogicalArray(mwSize ndim, const mwSize *dims); - -/* - * Create a two-dimensional array to hold logical data and - * initialize each data element to false. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateLogicalMatrix(mwSize m, mwSize n); - -/* - * Create a logical scalar mxArray having the specified value. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateLogicalScalar(bool value); - -/* - * Returns true if we have a valid logical scalar mxArray. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsLogicalScalar(const mxArray *pa); - -/* - * Returns true if the logical scalar value is true. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsLogicalScalarTrue(const mxArray *pa); - -/* - * Create a double-precision scalar mxArray initialized to the - * value specified - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateDoubleScalar(double value); - -/* - * Create a 2-Dimensional sparse array. - * - * Z = mxCreateSparse(m,n,nzmax,cmplx_flag); - * An m-by-n, real or complex, sparse matrix with room for nzmax nonzeros. - * Use this to allocate storage for a sparse matrix. - * It allocates the structure, allocates the pr, pi, ir and jc arrays, - * and sets all the fields, which may be changed later. - * Avoids the question of malloc(0) by replacing nzmax = 0 with nzmax = 1. - * Also sets Z->pr[0] = 0.0 so that the scalar sparse(0.0) acts like 0.0. - * - * Notice that the value of m is almost irrelevant. It is only stored in - * the mxSetM field of the matrix structure. It does not affect the amount - * of storage required by sparse matrices, or the amount of time required - * by sparse algorithms. Consequently, m can be "infinite". The result - * is a semi-infinite matrix with a finite number of columns and a finite, - * but unspecified, number of nonzero rows. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateSparse(mwSize m, mwSize n, mwSize nzmax, mxComplexity flag); - -/* - * Create a 2-D sparse logical array - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateSparseLogicalMatrix(mwSize m, mwSize n, mwSize nzmax); - -/* - * Copies characters from a MATLAB array to a char array - * This function will attempt to perform null termination if it is possible. - * nChars is the number of bytes in the output buffer - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void -mxGetNChars(const mxArray *pa, char *buf, mwSize nChars); - -/* - * Converts a string array to a C-style string. The C-style string is in the - * local codepage encoding. If the conversion for the entire Unicode string - * cannot fit into the supplied character buffer, then the conversion includes - * the last whole codepoint that will fit into the buffer. The string is thus - * truncated at the greatest possible whole codepoint and does not split code- - * points. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int -mxGetString(const mxArray *pa, char *buf, mwSize buflen); - -/* - * Create a NULL terminated C string from an mxArray of type mxCHAR_CLASS - * Supports multibyte character sets. The resulting string must be freed - * with mxFree. Returns NULL on out of memory or non-character arrays. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C char *mxArrayToString(const mxArray *pa); - -/* - * Create a NULL terminated C string from an mxArray of type mxCHAR_CLASS - * The C style string is in UTF-8 encoding. The resulting - * string must be freed with mxFree. Returns NULL on out of memory or - * non-character arrays. - */ - -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C char *mxArrayToUTF8String(mxArray const *pa); - -/** - * Create a 1-by-n string array initialized to str. The supplied string is - * presumed to be in the local codepage encoding. The character data format - * in the mxArray will be UTF-16. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateStringFromNChars(const char *str, mwSize n); - -/* - * Create a 1-by-n string array initialized to null terminated string - * where n is the length of the string. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateString(const char *str); - -/* - * Create a string array initialized to the strings in str. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateCharMatrixFromStrings(mwSize m, const char **str); - -/* - * Create a 2-Dimensional cell array, with each cell initialized - * to NULL. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateCellMatrix(mwSize m, mwSize n); - -/* - * Create an N-Dimensional cell array, with each cell initialized - * to NULL. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateCellArray(mwSize ndim, const mwSize *dims); - -/* - * Create a 2-Dimensional structure array having the specified fields; - * initialize all values to NULL. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateStructMatrix(mwSize m, mwSize n, int nfields, const char **fieldnames); - -/* - * Create an N-Dimensional structure array having the specified fields; - * initialize all values to NULL. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray * -mxCreateStructArray(mwSize ndim, const mwSize *dims, int nfields, const char **fieldnames); - -/* - * Make a deep copy of an array, return a pointer to the copy. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxDuplicateArray(const mxArray *in); - -/* - * Set classname of an unvalidated object array. It is illegal to - * call this function on a previously validated object array. - * Return 0 for success, 1 for failure. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxSetClassName(mxArray *pa, const char *classname); - -/* - * Add a field to a structure array. Returns field number on success or -1 - * if inputs are invalid or an out of memory condition occurs. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxAddField(mxArray *pa, const char *fieldname); - -/* - * Remove a field from a structure array. Does nothing if no such field exists. - * Does not destroy the field itself. -*/ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxRemoveField(mxArray *pa, int field); - -/* - * Function for obtaining MATLAB's concept of EPS - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double mxGetEps(void); - -/* - * Function for obtaining MATLAB's concept of INF (Used in MEX-File callback). - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double mxGetInf(void); - -/* - * Function for obtaining MATLAB's concept of NaN (Used in MEX-File callback). - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C double mxGetNaN(void); - -/* - * test for finiteness in a machine-independent manner - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsFinite(double x /* value to test */ - ); - -/* - * test for infinity in a machine-independent manner - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsInf(double x /* value to test */ - ); -/* - * test for NaN in a machine-independent manner - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C bool mxIsNaN(double x /* value to test */ - ); - -#if !defined(TARGET_API_VERSION) || (TARGET_API_VERSION == 700) -/* - * Undocumented. Removed in later APIs. - */ -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateSharedDataCopy(const mxArray *pa); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxCreateUninitDoubleMatrix(int cmplx_flag, size_t m, size_t n); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxFastZeros(int cmplx_flag, int m, int n); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxUnreference(mxArray *pa); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C int mxUnshareArray(mxArray *pa, int level); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C mxArray *mxGetPropertyShared(const mxArray *pa, size_t i, const char *propname); -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void mxSetPropertyShared(mxArray *pa, size_t i, const char *propname, const mxArray *value); -#endif -/* - * Inform Watcom compilers that scalar double return values - * will be in the FPU register. - */ -#ifdef __WATCOMC__ -#pragma aux mxGetEps value[8087]; -#pragma aux mxGetInf value[8087]; -#pragma aux mxGetNaN value[8087]; -#endif - -#ifndef mxassert_h -#define mxassert_h -/* -mxAssert(int expression, char *error_message) ---------------------------------------------- - - Similar to ANSI C's assert() macro, the mxAssert macro checks the - value of an assertion, continuing execution only if the assertion - holds. If 'expression' evaluates to be true, then the mxAssert does - nothing. If, however, 'expression' is false, then mxAssert prints an - error message to the MATLAB Command Window, consisting of the failed - assertion's expression, the file name and line number where the failed - assertion occurred, and the string 'error_message'. 'error_message' - allows the user to specify a more understandable description of why - the assertion failed. (Use an empty string if no extra description - should follow the failed assertion message.) After a failed - assertion, control returns to the MATLAB command line. - - mxAssertS, (the S for Simple), takes the same inputs as mxAssert. It - does not print the text of the failed assertion, only the file and - line where the assertion failed, and the explanatory error_message. - - Note that script MEX will turn off these assertions when building - optimized MEX-functions, so they should be used for debugging - purposes only. -*/ - -#ifdef MATLAB_MEX_FILE -#ifndef NDEBUG - -LIBMMWMATRIX_PUBLISHED_API_EXTERN_C void -mexPrintAssertion(const char *test, const char *fname, int linenum, const char *message); - -#define mxAssert(test, message) \ - ((test) ? (void)0 : mexPrintAssertion(#test, __FILE__, __LINE__, message)) -#define mxAssertS(test, message) \ - ((test) ? (void)0 : mexPrintAssertion("", __FILE__, __LINE__, message)) -#else -#define mxAssert(test, message) ((void)0) -#define mxAssertS(test, message) ((void)0) -#endif -#else -#include -#define mxAssert(test, message) assert(test) -#define mxAssertS(test, message) assert(test) -#endif - -#endif /* mxassert_h */ - -#endif /* matrix_h */ -#endif /* MATRIX_DEVELOPER_API_HPP */ -/* Copyright 2015-2017 The MathWorks, Inc. */ - -#ifndef __MX_API_VER_HPP__ -#define __MX_API_VER_HPP__ - -/* Current MATRIX published API version */ -#define MX_CURRENT_API_VER 0x08000000 - -/* Backward compatible current MATRIX published API version */ -#define MX_API_VER MX_CURRENT_API_VER - -/* Backward compatible MATRIX published API versions */ -#define MX_LAST_32BIT_VER 0x07000000 -#define MX_LAST_SEPARATE_COMPLEX_VER 0x07300000 - -/* Required MEX-file MATRIX published API version */ -#if TARGET_API_VERSION == 700 -#if defined(MX_COMPAT_32) -#define MX_TARGET_API_VER MX_LAST_32BIT_VER -#else -#define MX_TARGET_API_VER MX_LAST_SEPARATE_COMPLEX_VER -#endif -#else -#define MX_TARGET_API_VER MX_CURRENT_API_VER -#endif - -/* - * The following macros enable conditional compilation based on the - * target published API. The macros can be used in a single source file - * that is intended to be built against multiple matrix API versions. - * - * MX_HAS_64BIT_ARRAY_DIMS evaluates to a non-zero value if array - * dimensions are 64 bits wide. - * - * MX_HAS_INTERLEAVED_COMPLEX evaluates to a non-zero value if complex - * array data is interleaved. - * - */ -#define MX_HAS_64BIT_ARRAY_DIMS MX_TARGET_API_VER > MX_LAST_32BIT_VER -#define MX_HAS_INTERLEAVED_COMPLEX MX_TARGET_API_VER > MX_LAST_SEPARATE_COMPLEX_VER - -#endif /* __MX_API_VER_HPP__ */ diff --git a/src/ext/matlab/inc/tmwtypes.h b/src/ext/matlab/inc/tmwtypes.h deleted file mode 100644 index fb478e15b..000000000 --- a/src/ext/matlab/inc/tmwtypes.h +++ /dev/null @@ -1,831 +0,0 @@ -/* - * Copyright 1984-2018 The MathWorks, Inc. - */ - -#if defined(_MSC_VER) -# pragma once -#endif -#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) -# pragma once -#endif - -#ifndef tmwtypes_h -#define tmwtypes_h - -#ifndef __TMWTYPES__ -#define __TMWTYPES__ -/* - * File : tmwtypes.h - * Abstract: - * Data types for use with MATLAB/SIMULINK and the Real-Time Workshop. - * - * When compiling stand-alone model code, data types can be overridden - * via compiler switches. - * - * Define NO_FLOATS to eliminate reference to real_T, etc. - */ - -#include - -#ifdef __APPLE_CC__ -#include -#endif - -#define LOGICAL_IS_A_TYPE -#define SPARSE_GENERALIZATION - -#ifdef NO_FLOATS -# define double double_not_allowed -# define float float_not_allowed -#endif /*NO_FLOATS*/ - -#ifndef NO_FLOATS - -#ifndef __MWERKS__ -# ifdef __STDC__ -# include -# else -# define FLT_MANT_DIG 24 -# define DBL_MANT_DIG 53 -# endif -#endif - -#endif /*NO_FLOATS*/ - -/* - * The following data types cannot be overridden when building MEX files. - */ -#ifdef MATLAB_MEX_FILE -# undef CHARACTER_T -# undef INTEGER_T -# undef BOOLEAN_T -# undef REAL_T -# undef TIME_T -#endif - -/* - * The uchar_T, ushort_T and ulong_T types are needed for compilers which do - * not allow defines to be specified, at the command line, with spaces in them. - */ - -typedef unsigned char uchar_T; -typedef unsigned short ushort_T; -typedef unsigned long ulong_T; - -#if (defined(_MSC_VER) && _MSC_VER >= 1500) \ - || defined(__x86_64__) || defined(__LP64__) \ - || defined(__LCC64__) - -typedef unsigned long long ulonglong_T; -#endif - - - -/*=======================================================================* - * Fixed width word size data types: * - * int8_T, int16_T, int32_T - signed 8, 16, or 32 bit integers * - * uint8_T, uint16_T, uint32_T - unsigned 8, 16, or 32 bit integers * - * real32_T, real64_T - 32 and 64 bit floating point numbers * - *=======================================================================*/ - -/* When used with Real Time Workshop generated code, this - * header file can be used with a variety of compilers. - * - * The compiler could be for an 8 bit embedded processor that - * only had 8 bits per integer and 16 bits per long. - * In that example, a 32 bit integer size is not even available. - * This header file should be robust to that. - * - * For the case of an 8 bit processor, the preprocessor - * may be limited to 16 bit math like its target. That limitation - * would mean that 32 bit comparisons can't be done accurately. - * To increase robustness to this, comparisons are done against - * smaller values first. An inaccurate 32 bit comparison isn't - * attempted if the 16 bit comparison has already succeeded. - * - * Limitations on preprocessor math can also be stricter than - * for the target. There are known cases where a compiler - * targeting processors with 64 bit longs can't do accurate - * preprocessor comparisons on more than 32 bits. - */ - -/* Determine the number of bits for int, long, short, and char. - * If one fails to be determined, set the number of bits to -1 - */ - -#ifndef TMW_BITS_PER_INT -# if INT_MAX == 0x7FL -# define TMW_BITS_PER_INT 8 -# elif INT_MAX == 0x7FFFL -# define TMW_BITS_PER_INT 16 -# elif INT_MAX == 0x7FFFFFFFL -# define TMW_BITS_PER_INT 32 -# else -# define TMW_BITS_PER_INT -1 -# endif -#endif - -#ifndef TMW_BITS_PER_LONG -# if LONG_MAX == 0x7FL -# define TMW_BITS_PER_LONG 8 -# elif LONG_MAX == 0x7FFFL -# define TMW_BITS_PER_LONG 16 -# elif LONG_MAX == 0x7FFFFFFFL -# define TMW_BITS_PER_LONG 32 -# else -# define TMW_BITS_PER_LONG -1 -# endif -#endif - -#ifndef TMW_BITS_PER_SHRT -# if SHRT_MAX == 0x7FL -# define TMW_BITS_PER_SHRT 8 -# elif SHRT_MAX == 0x7FFFL -# define TMW_BITS_PER_SHRT 16 -# elif SHRT_MAX == 0x7FFFFFFFL -# define TMW_BITS_PER_SHRT 32 -# else -# define TMW_BITS_PER_SHRT -1 -# endif -#endif - -#ifndef TMW_BITS_PER_SCHAR -# if SCHAR_MAX == 0x7FL -# define TMW_BITS_PER_SCHAR 8 -# elif SCHAR_MAX == 0x7FFFL -# define TMW_BITS_PER_SCHAR 16 -# elif SCHAR_MAX == 0x7FFFFFFFL -# define TMW_BITS_PER_SCHAR 32 -# else -# define TMW_BITS_PER_SCHAR -1 -# endif -#endif - -#ifndef TMW_CHAR_SIGNED -# if SCHAR_MAX == CHAR_MAX -# define TMW_CHAR_SIGNED 1 -# else -# define TMW_CHAR_SIGNED 0 -# endif -#endif - -/* It is common for one or more of the integer types - * to be the same size. For example, on many embedded - * processors, both shorts and ints are 16 bits. On - * processors used for workstations, it is quite common - * for both int and long to be 32 bits. - * When there is more than one choice for typdef'ing - * a portable type like int16_T or uint32_T, in - * concept, it should not matter which choice is made. - * However, some style guides and some code checking - * tools do identify and complain about seemingly - * irrelevant differences. For example, a code - * checking tool may complain about an implicit - * conversion from int to short even though both - * are 16 bits. To reduce these types of - * complaints, it is best to make int the - * preferred choice when more than one is available. - */ - -#ifndef INT8_T -# if TMW_BITS_PER_INT == 8 -# define INT8_T int -# elif TMW_BITS_PER_LONG == 8 -# define INT8_T long -# elif TMW_BITS_PER_SCHAR == 8 -# define INT8_T signed char -# elif TMW_BITS_PER_SHRT == 8 -# define INT8_T short -# endif -#endif -#ifdef INT8_T - typedef INT8_T int8_T; -#endif - -#ifndef UINT8_T -# if TMW_BITS_PER_INT == 8 -# define UINT8_T unsigned int -# elif TMW_BITS_PER_LONG == 8 -# define UINT8_T unsigned long -# elif TMW_BITS_PER_SCHAR == 8 -# define UINT8_T unsigned char -# elif TMW_BITS_PER_SHRT == 8 -# define UINT8_T unsigned short -# endif -#endif -#ifdef UINT8_T - typedef UINT8_T uint8_T; -#endif - - -#ifndef INT16_T -# if TMW_BITS_PER_INT == 16 -# define INT16_T int -# elif TMW_BITS_PER_LONG == 16 -# define INT16_T long -# elif TMW_BITS_PER_SCHAR == 16 -# define INT16_T signed char -# elif TMW_BITS_PER_SHRT == 16 -# define INT16_T short -# endif -#endif -#ifdef INT16_T - typedef INT16_T int16_T; -#endif - - -#ifndef UINT16_T -# if TMW_BITS_PER_INT == 16 -# define UINT16_T unsigned int -# elif TMW_BITS_PER_LONG == 16 -# define UINT16_T unsigned long -# elif TMW_BITS_PER_SCHAR == 16 -# define UINT16_T unsigned char -# elif TMW_BITS_PER_SHRT == 16 -# define UINT16_T unsigned short -# endif -#endif -#ifdef UINT16_T - typedef UINT16_T uint16_T; -#endif - - -#ifndef INT32_T -# if TMW_BITS_PER_INT == 32 -# define INT32_T int -# elif TMW_BITS_PER_LONG == 32 -# define INT32_T long -# elif TMW_BITS_PER_SCHAR == 32 -# define INT32_T signed char -# elif TMW_BITS_PER_SHRT == 32 -# define INT32_T short -# endif -#endif -#ifdef INT32_T - typedef INT32_T int32_T; -#endif - - -#ifndef UINT32_T -# if TMW_BITS_PER_INT == 32 -# define UINT32_T unsigned int -# elif TMW_BITS_PER_LONG == 32 -# define UINT32_T unsigned long -# elif TMW_BITS_PER_SCHAR == 32 -# define UINT32_T unsigned char -# elif TMW_BITS_PER_SHRT == 32 -# define UINT32_T unsigned short -# endif -#endif -#ifdef UINT32_T - typedef UINT32_T uint32_T; -#endif - -/* The following is used to emulate smaller integer types when only - * larger types are available. For example, compilers for TI C3x/C4x DSPs - * define char and short to be 32 bits, so 8 and 16 bits are not directly - * available. This target is commonly used with RTW rapid prototyping. - * Other DSPs define char to be 16 bits, so 8 bits is not directly - * available. - */ -#ifndef INT8_T -# ifdef INT16_T -# define INT8_T INT16_T - typedef INT8_T int8_T; -# else -# ifdef INT32_T -# define INT8_T INT32_T - typedef INT8_T int8_T; -# endif -# endif -#endif - -#ifndef UINT8_T -# ifdef UINT16_T -# define UINT8_T UINT16_T - typedef UINT8_T uint8_T; -# else -# ifdef UINT32_T -# define UINT8_T UINT32_T - typedef UINT8_T uint8_T; -# endif -# endif -#endif - -#ifndef INT16_T -# ifdef INT32_T -# define INT16_T INT32_T - typedef INT16_T int16_T; -# endif -#endif - -#ifndef UINT16_T -# ifdef UINT32_T -# define UINT16_T UINT32_T - typedef UINT16_T uint16_T; -# endif -#endif - - -#ifndef NO_FLOATS - -#ifndef REAL32_T -# ifndef __MWERKS__ -# if FLT_MANT_DIG >= 23 -# define REAL32_T float -# endif -# else -# define REAL32_T float -# endif -#endif -#ifdef REAL32_T - typedef REAL32_T real32_T; -#endif - - -#ifndef REAL64_T -# ifndef __MWERKS__ -# if DBL_MANT_DIG >= 52 -# define REAL64_T double -# endif -# else -# define REAL64_T double -# endif -#endif -#ifdef REAL64_T - typedef REAL64_T real64_T; -#endif - -#endif /* NO_FLOATS*/ - -/*=======================================================================* - * Fixed width word size data types: * - * int64_T - signed 64 bit integers * - * uint64_T - unsigned 64 bit integers * - *=======================================================================*/ - - - -#ifndef INT64_T -# if defined(__APPLE__) -# define INT64_T long long -# define FMT64 "ll" -# if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG) -# define INT_TYPE_64_IS_LONG -# endif -# elif (defined(__x86_64__) || defined(__LP64__))&& !defined(__MINGW64__) -# define INT64_T long -# define FMT64 "l" -# if !defined(INT_TYPE_64_IS_LONG) -# define INT_TYPE_64_IS_LONG -# endif -# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ - || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) -# define INT64_T __int64 -# define FMT64 "I64" -# elif defined(__GNUC__) || defined(TMW_ENABLE_INT64) \ - || defined(__LCC64__) -# define INT64_T long long -# define FMT64 "ll" -# endif -#endif - - - -#if defined(INT64_T) -# if defined(__GNUC__) && \ - ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))) - __extension__ -# endif - typedef INT64_T int64_T; -#endif - - - -#ifndef UINT64_T -# if defined(__APPLE__) -# define UINT64_T unsigned long long -# define FMT64 "ll" -# if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG) -# define INT_TYPE_64_IS_LONG -# endif -# elif (defined(__x86_64__) || defined(__LP64__))&& !defined(__MINGW64__) -# define UINT64_T unsigned long -# define FMT64 "l" -# if !defined(INT_TYPE_64_IS_LONG) -# define INT_TYPE_64_IS_LONG -# endif -# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ - || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) -# define UINT64_T unsigned __int64 -# define FMT64 "I64" -# elif defined(__GNUC__) || defined(TMW_ENABLE_INT64) \ - || defined(__LCC64__) -# define UINT64_T unsigned long long -# define FMT64 "ll" -# endif -#endif - -#if defined(_WIN64) || (defined(__APPLE__) && defined(__LP64__)) \ - || defined(__x86_64__) \ - || defined(__LP64__) -# define INT_TYPE_64_IS_SUPPORTED -#endif - -#if defined(UINT64_T) -# if defined(__GNUC__) && \ - ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))) - __extension__ -# endif - typedef UINT64_T uint64_T; -#endif - -/*===========================================================================* - * Format string modifiers for using size_t variables in printf statements. * - *===========================================================================*/ - -#ifndef FMT_SIZE_T -# if (defined( __GNUC__ ) || defined(_STDC_C99))&& !defined(__MINGW64__) -# define FMT_SIZE_T "z" -# elif defined (__WATCOMC__) -# define FMT_SIZE_T "l" -# elif defined (_WIN32 ) -# define FMT_SIZE_T "I" -# else -# define FMT_SIZE_T "l" -# endif -#endif - -#ifndef FMT_PTRDIFF_T -# if defined(__APPLE__) -# define FMT_PTRDIFF_T "l" -# elif defined( __GNUC__ ) || defined(_STDC_C99) -# define FMT_PTRDIFF_T "t" -# elif defined (__WATCOMC__) -# define FMT_PTRDIFF_T "l" -# elif defined (_WIN32 ) -# define FMT_PTRDIFF_T "I" -# else -# define FMT_PTRDIFF_T "l" -# endif -#endif - -/*===========================================================================* - * General or logical data types where the word size is not guaranteed. * - * real_T - possible settings include real32_T or real64_T * - * time_T - possible settings include real32_T or real64_T * - * boolean_T * - * char_T * - * int_T * - * uint_T * - * byte_T * - *===========================================================================*/ - -#ifndef NO_FLOATS - -#ifndef REAL_T -# ifdef REAL64_T -# define REAL_T real64_T -# else -# ifdef REAL32_T -# define REAL_T real32_T -# endif -# endif -#endif -#ifdef REAL_T - typedef REAL_T real_T; -#endif - -#ifndef TIME_T -# ifdef REAL_T -# define TIME_T real_T -# endif -#endif -#ifdef TIME_T - typedef TIME_T time_T; -#endif - -#endif /* NO_FLOATS */ - -#ifndef BOOLEAN_T -# if defined(UINT8_T) -# define BOOLEAN_T UINT8_T -# else -# define BOOLEAN_T unsigned int -# endif -#endif -typedef BOOLEAN_T boolean_T; - - -#ifndef CHARACTER_T -# define CHARACTER_T char -#endif -typedef CHARACTER_T char_T; - - -#ifndef INTEGER_T -# define INTEGER_T int -#endif -typedef INTEGER_T int_T; - - -#ifndef UINTEGER_T -# define UINTEGER_T unsigned -#endif -typedef UINTEGER_T uint_T; - - -#ifndef BYTE_T -# define BYTE_T unsigned char -#endif -typedef BYTE_T byte_T; - - -/*===========================================================================* - * Define Complex Structures * - *===========================================================================*/ -#ifndef NO_FLOATS - -#ifndef CREAL32_T -# ifdef REAL32_T - typedef struct { - real32_T re, im; - } creal32_T; -# define CREAL32_T creal32_T -# endif -#endif - -#ifndef CREAL64_T -# ifdef REAL64_T - typedef struct { - real64_T re, im; - } creal64_T; -# define CREAL64_T creal64_T -# endif -#endif - -#ifndef CREAL_T -# ifdef REAL_T - typedef struct { - real_T re, im; - } creal_T; -# define CREAL_T creal_T -# endif -#endif - -#endif /* NO_FLOATS */ - -#ifndef CINT8_T -# ifdef INT8_T - typedef struct { - int8_T re, im; - } cint8_T; -# define CINT8_T cint8_T -# endif -#endif - -#ifndef CUINT8_T -# ifdef UINT8_T - typedef struct { - uint8_T re, im; - } cuint8_T; -# define CUINT8_T cuint8_T -# endif -#endif - -#ifndef CINT16_T -# ifdef INT16_T - typedef struct { - int16_T re, im; - } cint16_T; -# define CINT16_T cint16_T -# endif -#endif - -#ifndef CUINT16_T -# ifdef UINT16_T - typedef struct { - uint16_T re, im; - } cuint16_T; -# define CUINT16_T cuint16_T -# endif -#endif - -#ifndef CINT32_T -# ifdef INT32_T - typedef struct { - int32_T re, im; - } cint32_T; -# define CINT32_T cint32_T -# endif -#endif - -#ifndef CUINT32_T -# ifdef UINT32_T - typedef struct { - uint32_T re, im; - } cuint32_T; -# define CUINT32_T cuint32_T -# endif -#endif - -#ifndef CINT64_T -# ifdef INT64_T - typedef struct { - int64_T re, im; - } cint64_T; -# define CINT64_T cint64_T -# endif -#endif - -#ifndef CUINT64_T -# ifdef UINT64_T - typedef struct { - uint64_T re, im; - } cuint64_T; -# define CUINT64_T cuint64_T -# endif -#endif - -/*=======================================================================* - * Min and Max: * - * int8_T, int16_T, int32_T - signed 8, 16, or 32 bit integers * - * uint8_T, uint16_T, uint32_T - unsigned 8, 16, or 32 bit integers * - *=======================================================================*/ - -#define MAX_int8_T ((int8_T)(127)) /* 127 */ -#define MIN_int8_T ((int8_T)(-128)) /* -128 */ -#define MAX_uint8_T ((uint8_T)(255)) /* 255 */ -#define MIN_uint8_T ((uint8_T)(0)) - -#define MAX_int16_T ((int16_T)(32767)) /* 32767 */ -#define MIN_int16_T ((int16_T)(-32768)) /* -32768 */ -#define MAX_uint16_T ((uint16_T)(65535)) /* 65535 */ -#define MIN_uint16_T ((uint16_T)(0)) - -#define MAX_int32_T ((int32_T)(2147483647)) /* 2147483647 */ -#define MIN_int32_T ((int32_T)(-2147483647-1)) /* -2147483648 */ -#define MAX_uint32_T ((uint32_T)(0xFFFFFFFFU)) /* 4294967295 */ -#define MIN_uint32_T ((uint32_T)(0)) - -#if defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ - || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) \ - || defined(__LCC64__) -# ifdef INT64_T -# define MAX_int64_T ((int64_T)(9223372036854775807LL)) -# define MIN_int64_T ((int64_T)(-9223372036854775807LL-1LL)) -# endif -# ifdef UINT64_T -# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFULL)) -# define MIN_uint64_T ((uint64_T)(0)) -# endif -#else -# ifdef INT64_T -# ifdef INT_TYPE_64_IS_LONG -# define MAX_int64_T ((int64_T)(9223372036854775807L)) -# define MIN_int64_T ((int64_T)(-9223372036854775807L-1L)) -# else -# define MAX_int64_T ((int64_T)(9223372036854775807LL)) -# define MIN_int64_T ((int64_T)(-9223372036854775807LL-1LL)) -# endif -# endif -# ifdef UINT64_T -# ifdef INT_TYPE_64_IS_LONG -# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFUL)) -# define MIN_uint64_T ((uint64_T)(0)) -# else -# define MAX_uint64_T ((uint64_T)(0xFFFFFFFFFFFFFFFFULL)) -# define MIN_uint64_T ((uint64_T)(0)) -# endif -# endif -#endif - -#ifdef _MSC_VER -/* Conversion from unsigned __int64 to double is not implemented in windows - * and results in a compile error, thus the value must first be cast to - * signed __int64, and then to double. - * - * If the 64 bit int value is greater than 2^63-1, which is the signed int64 max, - * the macro below provides a workaround for casting a uint64 value to a double - * in windows. - */ -# define uint64_to_double(u) ( ((u) > _I64_MAX) ? \ - (double)(__int64)((u) - _I64_MAX - 1) + (double)_I64_MAX + 1: \ - (double)(__int64)(u) ) - -/* The following inline function should only be used in the macro double_to_uint64, - * as it only handles the specfic range of double between 2^63 and 2^64-1 */ -__forceinline -uint64_T double_to_uint64_helper(double d) { - union double_to_uint64_union_type { - double dd; - uint64_T i64; - } di; - di.dd = d; - return (((di.i64 & 0x000fffffffffffff) | 0x0010000000000000) << 11); -} - -/* The largest double value that can be cast to uint64 in windows is the - * signed int64 max, which is 2^63-1. The macro below provides - * a workaround for casting large double values to uint64 in windows. - */ -/* The magic number 18446744073709551616.0 is 2^64 */ -/* The magic number 9223372036854775808.0 is 2^63 */ -# define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \ - 0xffffffffffffffffULL : \ - ((d) >= 0.0) ? \ - ((d) >= 9223372036854775808.0) ? \ - double_to_uint64_helper(d) : \ - (unsigned __int64)(d) : \ - 0ULL ) -#else -# define uint64_to_double(u) ((double)(u)) -# if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__TICCSC__) -/* double_to_uint64 defined only for MSVC and UNIX */ -# else -# define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \ - (unsigned long long) 0xffffffffffffffffULL : \ - ((d) >= 0) ? (unsigned long long)(d) : (unsigned long long) 0 ) -# endif -#endif - -#if !defined(__cplusplus) && !defined(__bool_true_false_are_defined) - -#ifndef _bool_T -#define _bool_T - -typedef boolean_T bool; - -#ifndef false -#define false (0) -#endif -#ifndef true -#define true (1) -#endif - -#endif /* _bool_T */ - -#endif /* !__cplusplus */ - -/* - * This software assumes that the code is being compiled on a target using a - * 2's complement representation for signed integer values. - */ -#if ((SCHAR_MIN + 1) != -SCHAR_MAX) -#error "This code must be compiled using a 2's complement representation for signed integer values" -#endif - -/* - * Maximum length of a MATLAB identifier (function/variable/model) - * including the null-termination character. - */ -#define TMW_NAME_LENGTH_MAX 64 - -/* - * Maximum values for indices and dimensions - */ -#include - -#ifdef MX_COMPAT_32 -typedef int mwSize; -typedef int mwIndex; -typedef int mwSignedIndex; -#else -typedef size_t mwSize; /* unsigned pointer-width integer */ -typedef size_t mwIndex; /* unsigned pointer-width integer */ -typedef ptrdiff_t mwSignedIndex; /* a signed pointer-width integer */ -#endif - -typedef int SLIndex; -typedef int SLSize; - -#if (defined(_LP64) || defined(_WIN64)) && !defined(MX_COMPAT_32) -/* Currently 2^48 based on hardware limitations */ -# define MWSIZE_MAX 281474976710655UL -# define MWINDEX_MAX 281474976710655UL -# define MWSINDEX_MAX 281474976710655L -# define MWSINDEX_MIN -281474976710655L -#else -# define MWSIZE_MAX 2147483647UL -# define MWINDEX_MAX 2147483647UL -# define MWSINDEX_MAX 2147483647L -# define MWSINDEX_MIN -2147483647L -#endif -#define MWSIZE_MIN 0UL -#define MWINDEX_MIN 0UL - -/** UTF-16 character type */ - -#if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT) -typedef char16_t CHAR16_T; -#define U16_STRING_LITERAL_PREFIX u -#elif defined(_MSC_VER) -typedef wchar_t CHAR16_T; -#define U16_STRING_LITERAL_PREFIX L -#else -typedef UINT16_T CHAR16_T; -#endif - -#endif /* __TMWTYPES__ */ - -#endif /* tmwtypes_h */ diff --git a/src/ext/matlab/lib/libmat.lib b/src/ext/matlab/lib/libmat.lib deleted file mode 100644 index 6e2e05fbdf5ae6555fe62dc747efd76c2552db10..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 50128 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 diff --git a/src/ext/matlab/lib/libmx.lib b/src/ext/matlab/lib/libmx.lib deleted file mode 100644 index 77ad77d641f9c23a506d4cbbd135733d7f0f3c51..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 728036 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
VFv+Sx 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 diff --git a/src/pbrt/cmd/imgtool.cpp b/src/pbrt/cmd/imgtool.cpp index 490297e6d..f43396761 100644 --- a/src/pbrt/cmd/imgtool.cpp +++ b/src/pbrt/cmd/imgtool.cpp @@ -22,9 +22,6 @@ #include #include #include -#include -#include -#include extern "C" { #include @@ -38,6 +35,8 @@ extern "C" { #include #include #include +#include +#include #include @@ -130,10 +129,12 @@ static std::map commandUsage = { --despike For any pixels with a luminance value greater than , replace the pixel with the median of the 3x3 neighboring pixels. Default: infinity (i.e., disabled). - --exr2mat [|] + --exr2bin [|] Convert input .exr file to .mat file according to channels specified. - e.g. imgtool convert --exr2mat 1,2,3,5 pbrt.exr - e.g. imgtool convert --exr2mat 1:5 pbrt.exr + e.g. imgtool convert --exr2bin 1,2,3,5 pbrt.exr + e.g. imgtool convert --exr2bin 1:5 pbrt.exr + e.g. imgtool convert --exr2bin B,G,R,Radiance.C05 pbrt.exr + e.g. imgtool convert --exr2bin Radiance pbrt.exr Default: all channels --flipy Flip the image along the y axis --gamma Apply a gamma curve with exponent v. (Default: 1 (none)). @@ -1688,10 +1689,11 @@ int convert(std::vector args) { Float despikeLimit = Infinity; bool preserveColors = false; bool bw = false; - bool exr2mat = false; + bool exr2bin = false; std::string inFile, outFile; std::string colorspace; std::string channelNames; + std::vector targetChannelNames; std::vector exr2mat_channels; std::array cropWindow = { -1, 0, -1, 0 }; Float clamp = Infinity; @@ -1718,10 +1720,10 @@ int convert(std::vector args) { ParseArg(&iter, args.end(), "scale", &scale, onError) || ParseArg(&iter, args.end(), "tonemap", &tonemap, onError)) { // success - } else if (normalizeArg(*iter) == normalizeArg("exr2mat")) { - exr2mat = true; - int n; - if (isdigit((*(iter+1))[0])) { + } else if (normalizeArg(*iter) == normalizeArg("exr2bin")) { + exr2bin = true; + std::string::size_type n; + if ((*(iter + 1)).find(".exr") == std::string::npos) { ++iter; if ((n = (*iter).find(':')) != std::string::npos) { int start = std::stoi((*iter).substr(0, n)); @@ -1729,11 +1731,14 @@ int convert(std::vector args) { for (int i = start; i != end + 1; i++) { exr2mat_channels.push_back(i); } - } else { + } else if (isdigit((*iter)[0])) { std::vector v = SplitStringToInts((*iter), ','); std::copy(v.begin(), v.end(), exr2mat_channels.begin()); + } else { + targetChannelNames = + SplitString((*iter), ','); } - } + } } else if ((*iter)[0] != '-' && inFile.empty()) { inFile = *iter; @@ -1747,7 +1752,7 @@ int convert(std::vector args) { usage("convert", "--repeatpix value must be greater than zero"); if (scale == 0) usage("convert", "--scale value must be non-zero"); - if (outFile.empty()) + if (outFile.empty()&&!exr2bin) usage("convert", "--outfile filename must be specified"); if (inFile.empty()) usage("convert", "input filename not specified"); @@ -1756,41 +1761,57 @@ int convert(std::vector args) { Image image = std::move(imRead.image); ImageMetadata metadata = std::move(imRead.metadata); - if (exr2mat) { + if (exr2bin) { Point2i res = image.Resolution(); int nc = image.NChannels(); - if (exr2mat_channels.empty()) + std::vector exrChannelNames = image.ChannelNames(); + if (exr2mat_channels.empty() && targetChannelNames.empty()) for (int i = 0; i != nc; ++i) { - exr2mat_channels.push_back(i); + exr2mat_channels.push_back(i + 1); } - int mc = exr2mat_channels.size(); - size_t datasize = res.x * res.y * mc; - Float *buf_exr = new float[datasize]; - for (int y = 0; y < res.y; ++y) - for (int x = 0; x < res.x; ++x) - for (int c = 0; c < mc; ++c) { - buf_exr[c * res.x * res.y + x * res.y + y] = - image.GetChannel({x, y}, c); + else if (exr2mat_channels.empty() && !targetChannelNames.empty()) { + for (auto target : targetChannelNames) { + for (int i = 0; i < exrChannelNames.size(); ++i) { + auto name = exrChannelNames.at(i); + if ((!name.compare(target)) || + ((name.find(target) != std::string::npos) && + (name.at(name.find(target) + target.size()) == '.'))) { + exr2mat_channels.push_back(i + 1); + } } + } + } + int mc = exr2mat_channels.size(); + size_t datasize = res.x * res.y; - mxArray *pWriteArray = NULL; - MATFile *pmatFile = NULL; - pmatFile = matOpen(outFile.c_str(), "w"); - mwSize *dims = new mwSize[3]; - memset((void *)dims, 0, sizeof(mwSize) * 3); - dims[0] = res.y; - dims[1] = res.x; - dims[2] = mc; - pWriteArray = mxCreateNumericArray(3, dims, mxSINGLE_CLASS, mxREAL); - memcpy((void *)(mxGetPr(pWriteArray)), (void *)buf_exr, sizeof(float) * datasize); - std::string vName = "exr"; - matPutVariable(pmatFile, vName.c_str(), pWriteArray); - matClose(pmatFile); - mxDestroyArray(pWriteArray); - delete[] buf_exr; - buf_exr = NULL; - delete[] dims; - dims = NULL; + if (inFile.find(".exr") == inFile.npos || + inFile.find(".exr") != (inFile.size() - 4)) { + fprintf(stderr, "Wrong input filename: %s \n", inFile); + return 1; + } + for (int c = 0; c < mc; ++c) { + float *buf_exr = new float[datasize]; + for (int y = 0; y < res.y; ++y) + for (int x = 0; x < res.x; ++x) { + buf_exr[x * res.y + y] = + image.GetChannel({x, y}, exr2mat_channels.at(c) - 1); + } + std::string binaryName = inFile.substr(0, inFile.size() - 4) + '_' + + std::to_string(res.y) + '_' + std::to_string(res.x) + + '_' + exrChannelNames.at(exr2mat_channels.at(c)-1); + //'_' + std::to_string(exr2mat_channels.at(c)); + std::fstream file(binaryName, std::ios::out | std::ios::binary); + if (!file) { + fprintf(stderr, "Failed opening binary file. \n"); + return 1; + } + file.write((char *)buf_exr, datasize * sizeof(float)); + file.close(); + delete[] buf_exr; + buf_exr = NULL; + } + printf("exr2bin done."); + return 0; } if (channelNames.empty()) { From 4ea2ab8ede130682cc636fb6832dec15d14c65d7 Mon Sep 17 00:00:00 2001 From: Tanglong Date: Thu, 2 Sep 2021 17:17:37 +0800 Subject: [PATCH 3/4] Update imgtool.cpp --- src/pbrt/cmd/imgtool.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pbrt/cmd/imgtool.cpp b/src/pbrt/cmd/imgtool.cpp index f43396761..28e59a9b3 100644 --- a/src/pbrt/cmd/imgtool.cpp +++ b/src/pbrt/cmd/imgtool.cpp @@ -130,7 +130,7 @@ static std::map commandUsage = { replace the pixel with the median of the 3x3 neighboring pixels. Default: infinity (i.e., disabled). --exr2bin [|] - Convert input .exr file to .mat file according to channels specified. + Convert input .exr file to binary file according to channels specified. e.g. imgtool convert --exr2bin 1,2,3,5 pbrt.exr e.g. imgtool convert --exr2bin 1:5 pbrt.exr e.g. imgtool convert --exr2bin B,G,R,Radiance.C05 pbrt.exr From c80cdef4fba4c39b1e89060213169902233abc54 Mon Sep 17 00:00:00 2001 From: Tanglong Date: Thu, 2 Sep 2021 18:34:50 +0800 Subject: [PATCH 4/4] Update exr2bin function. Add custom output directory. Use [--outfile ] to specify output location and output filename. Whole argument example: imgtool convert --exr2bin Radiance,B,G,R --outfile E:\PBRT\pbrt_binary E:\PBRT\pbrt.exr --- src/pbrt/cmd/imgtool.cpp | 32 +++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-) diff --git a/src/pbrt/cmd/imgtool.cpp b/src/pbrt/cmd/imgtool.cpp index 28e59a9b3..ad739abc2 100644 --- a/src/pbrt/cmd/imgtool.cpp +++ b/src/pbrt/cmd/imgtool.cpp @@ -131,11 +131,13 @@ static std::map commandUsage = { pixels. Default: infinity (i.e., disabled). --exr2bin [|] Convert input .exr file to binary file according to channels specified. + --outfile can be specifiled for output path. e.g. imgtool convert --exr2bin 1,2,3,5 pbrt.exr e.g. imgtool convert --exr2bin 1:5 pbrt.exr e.g. imgtool convert --exr2bin B,G,R,Radiance.C05 pbrt.exr - e.g. imgtool convert --exr2bin Radiance pbrt.exr - Default: all channels + e.g. imgtool convert --exr2bin Radiance --outfile /path/to/dir/ pbrt.exr + e.g. imgtool convert --exr2bin Radiance --outfile /path/to/dir/filename pbrt.exr + Default: all channels at the same directory with pbrt.exr --flipy Flip the image along the y axis --gamma Apply a gamma curve with exponent v. (Default: 1 (none)). --maxluminance Luminance value mapped to white by tonemapping. @@ -1723,7 +1725,7 @@ int convert(std::vector args) { } else if (normalizeArg(*iter) == normalizeArg("exr2bin")) { exr2bin = true; std::string::size_type n; - if ((*(iter + 1)).find(".exr") == std::string::npos) { + if (((*(iter + 1)).find(".exr") == std::string::npos) && ((*(iter + 1)).find("outfile") == std::string::npos)) { ++iter; if ((n = (*iter).find(':')) != std::string::npos) { int start = std::stoi((*iter).substr(0, n)); @@ -1732,8 +1734,7 @@ int convert(std::vector args) { exr2mat_channels.push_back(i); } } else if (isdigit((*iter)[0])) { - std::vector v = SplitStringToInts((*iter), ','); - std::copy(v.begin(), v.end(), exr2mat_channels.begin()); + exr2mat_channels = SplitStringToInts((*iter), ','); } else { targetChannelNames = SplitString((*iter), ','); @@ -1786,7 +1787,7 @@ int convert(std::vector args) { if (inFile.find(".exr") == inFile.npos || inFile.find(".exr") != (inFile.size() - 4)) { - fprintf(stderr, "Wrong input filename: %s \n", inFile); + fprintf(stderr, "Wrong input filename: %s \n", inFile.c_str()); return 1; } for (int c = 0; c < mc; ++c) { @@ -1796,7 +1797,24 @@ int convert(std::vector args) { buf_exr[x * res.y + y] = image.GetChannel({x, y}, exr2mat_channels.at(c) - 1); } - std::string binaryName = inFile.substr(0, inFile.size() - 4) + '_' + + std::size_t dirOffset; + std::string outDir; + std::string fileName; + if (!outFile.empty()) { + dirOffset = outFile.find_last_of("/\\"); + outDir = outFile.substr(0, dirOffset + 1); + fileName = outFile.substr(dirOffset + 1); + if (fileName.empty()) + fileName = inFile.substr(0, inFile.size() - 4); + else if ((fileName.find(".bin") != fileName.npos) || + (fileName.find(".dat") != fileName.npos)) + fileName = fileName.substr(0, fileName.size() - 4); + else + fileName = outDir + fileName; + } + else + fileName = inFile.substr(0, inFile.size() - 4); + std::string binaryName = fileName + '_' + std::to_string(res.y) + '_' + std::to_string(res.x) + '_' + exrChannelNames.at(exr2mat_channels.at(c)-1); //'_' + std::to_string(exr2mat_channels.at(c));