truesize.cpp

matlab的可执行程序

//
// MATLAB Compiler: 3.0
// Date: Wed Jul 14 12:15:03 2004
// Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
// "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
// "array_indexing:on" "-O" "optimize_conditionals:on" "-B" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "QQchabu.m" 
//
#include "truesize.hpp"
#include "libsgl.hpp"
#include "iptgetpref.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
static mwArray _mxarray0_ = mclInitializeDouble(1.0);
static mwArray _mxarray1_ = mclInitializeDouble(2.0);
static mwArray _mxarray2_ = mclInitializeDouble(3.0);
static mwArray _mxarray3_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
static mwArray _mxarray4_ = mclInitializeCharVector(0, 0, (mxChar *)NULL);

static double _array6_[2] = { 1.0, 2.0 };
static mwArray _mxarray5_ = mclInitializeDoubleVector(1, 2, _array6_);

static mxChar _array8_[4] = { 't', 'y', 'p', 'e' };
static mwArray _mxarray7_ = mclInitializeString(4, _array8_);

static mxChar _array10_[6] = { 'f', 'i', 'g', 'u', 'r', 'e' };
static mwArray _mxarray9_ = mclInitializeString(6, _array10_);

static mxChar _array12_[33] = { 'F', 'I', 'G', ' ', 'm', 'u', 's', 't', ' ',
                                'b', 'e', ' ', 'a', ' ', 'v', 'a', 'l', 'i',
                                'd', ' ', 'f', 'i', 'g', 'u', 'r', 'e', ' ',
                                'h', 'a', 'n', 'd', 'l', 'e' };
static mwArray _mxarray11_ = mclInitializeString(33, _array12_);

static mxChar _array14_[11] = { 'C', 'u', 'r', 'r', 'e', 'n',
                                't', 'A', 'x', 'e', 's' };
static mwArray _mxarray13_ = mclInitializeString(11, _array14_);

static mxChar _array16_[26] = { 'C', 'u', 'r', 'r', 'e', 'n', 't', ' ', 'f',
                                'i', 'g', 'u', 'r', 'e', ' ', 'h', 'a', 's',
                                ' ', 'n', 'o', ' ', 'a', 'x', 'e', 's' };
static mwArray _mxarray15_ = mclInitializeString(26, _array16_);

static mxChar _array18_[31] = { 'R', 'E', 'Q', 'S', 'I', 'Z', 'E', ' ',
                                'm', 'u', 's', 't', ' ', 'b', 'e', ' ',
                                'a', ' ', '1', '-', 'b', 'y', '-', '2',
                                ' ', 'v', 'e', 'c', 't', 'o', 'r' };
static mwArray _mxarray17_ = mclInitializeString(31, _array18_);

static mxChar _array20_[6] = { 'P', 'a', 'r', 'e', 'n', 't' };
static mwArray _mxarray19_ = mclInitializeString(6, _array20_);

static mxChar _array22_[4] = { 'T', 'y', 'p', 'e' };
static mwArray _mxarray21_ = mclInitializeString(4, _array22_);

static mxChar _array24_[5] = { 'i', 'm', 'a', 'g', 'e' };
static mwArray _mxarray23_ = mclInitializeString(5, _array24_);

static mxChar _array26_[7] = { 's', 'u', 'r', 'f', 'a', 'c', 'e' };
static mwArray _mxarray25_ = mclInitializeString(7, _array26_);

static mxChar _array28_[9] = { 'F', 'a', 'c', 'e', 'C', 'o', 'l', 'o', 'r' };
static mwArray _mxarray27_ = mclInitializeString(9, _array28_);

static mxChar _array30_[10] = { 't', 'e', 'x', 't', 'u',
                                'r', 'e', 'm', 'a', 'p' };
static mwArray _mxarray29_ = mclInitializeString(10, _array30_);

static mxChar _array32_[3] = { 'T', 'a', 'g' };
static mwArray _mxarray31_ = mclInitializeString(3, _array32_);

static mxChar _array34_[12] = { 'T', 'M', 'W', '_', 'C', 'O',
                                'L', 'O', 'R', 'B', 'A', 'R' };
static mwArray _mxarray33_ = mclInitializeString(12, _array34_);

static mxChar _array36_[49] = { 'N', 'o', ' ', 'i', 'm', 'a', 'g', 'e', 's',
                                ' ', 'o', 'r', ' ', 't', 'e', 'x', 't', 'u',
                                'r', 'e', 'm', 'a', 'p', 'p', 'e', 'd', ' ',
                                's', 'u', 'r', 'f', 'a', 'c', 'e', 's', ' ',
                                'i', 'n', ' ', 't', 'h', 'e', ' ', 'f', 'i',
                                'g', 'u', 'r', 'e' };
static mwArray _mxarray35_ = mclInitializeString(49, _array36_);

static mxChar _array38_[4] = { 'f', 'l', 'a', 't' };
static mwArray _mxarray37_ = mclInitializeString(4, _array38_);

static mxChar _array40_[4] = { 'a', 'x', 'e', 's' };
static mwArray _mxarray39_ = mclInitializeString(4, _array40_);

static mxChar _array42_[9] = { 'u', 'i', 'c', 'o', 'n', 't', 'r', 'o', 'l' };
static mwArray _mxarray41_ = mclInitializeString(9, _array42_);

static mxChar _array44_[7] = { 'V', 'i', 's', 'i', 'b', 'l', 'e' };
static mwArray _mxarray43_ = mclInitializeString(7, _array44_);

static mxChar _array46_[2] = { 'o', 'n' };
static mwArray _mxarray45_ = mclInitializeString(2, _array46_);

static mxChar _array48_[6] = { 'u', 'i', 'm', 'e', 'n', 'u' };
static mwArray _mxarray47_ = mclInitializeString(6, _array48_);

static mxChar _array50_[3] = { 'o', 'f', 'f' };
static mwArray _mxarray49_ = mclInitializeString(3, _array50_);

static mxChar _array52_[5] = { 'C', 'D', 'a', 't', 'a' };
static mwArray _mxarray51_ = mclInitializeString(5, _array52_);
static mwArray _mxarray53_ = mclInitializeDouble(0.0);

static mxChar _array55_[5] = { 'U', 'n', 'i', 't', 's' };
static mwArray _mxarray54_ = mclInitializeString(5, _array55_);

static mxChar _array57_[6] = { 'p', 'i', 'x', 'e', 'l', 's' };
static mwArray _mxarray56_ = mclInitializeString(6, _array57_);

static mxChar _array59_[8] = { 'P', 'o', 's', 'i', 't', 'i', 'o', 'n' };
static mwArray _mxarray58_ = mclInitializeString(8, _array59_);
static mwArray _mxarray60_ = mclInitializeDouble(10.0);
static mwArray _mxarray61_ = mclInitializeDouble(100.0);
static mwArray _mxarray62_ = mclInitializeDouble(128.0);

static mxChar _array64_[10] = { 'S', 'c', 'r', 'e', 'e',
                                'n', 'S', 'i', 'z', 'e' };
static mwArray _mxarray63_ = mclInitializeString(10, _array64_);
static double _ieee_plusinf_ = mclGetInf();
static mwArray _mxarray65_ = mclInitializeDouble(_ieee_plusinf_);

static mxChar _array67_[19] = { 'D', 'e', 'f', 'a', 'u', 'l', 't',
                                'A', 'x', 'e', 's', 'P', 'o', 's',
                                'i', 't', 'i', 'o', 'n' };
static mwArray _mxarray66_ = mclInitializeString(19, _array67_);
static mwArray _mxarray68_ = mclInitializeDouble(4.0);

static mxChar _array70_[8] = { 'N', 'e', 'x', 't', 'P', 'l', 'o', 't' };
static mwArray _mxarray69_ = mclInitializeString(8, _array70_);

static mxChar _array72_[15] = { 'r', 'e', 'p', 'l', 'a', 'c', 'e', 'c',
                                'h', 'i', 'l', 'd', 'r', 'e', 'n' };
static mwArray _mxarray71_ = mclInitializeString(15, _array72_);

static mxChar _array74_[15] = { 'T', 'r', 'u', 'e', 's', 'i', 'z', 'e',
                                'W', 'a', 'r', 'n', 'i', 'n', 'g' };
static mwArray _mxarray73_ = mclInitializeString(15, _array74_);

static mxChar _array76_[35] = { 'I', 'm', 'a', 'g', 'e', ' ', 'i', 's', ' ',
                                't', 'o', 'o', ' ', 'b', 'i', 'g', ' ', 't',
                                'o', ' ', 'f', 'i', 't', ' ', 'o', 'n', ' ',
                                's', 'c', 'r', 'e', 'e', 'n', ';', ' ' };
static mwArray _mxarray75_ = mclInitializeString(35, _array76_);

static mxChar _array78_[25] = { 'd', 'i', 's', 'p', 'l', 'a', 'y', 'i', 'n',
                                'g', ' ', 'a', 't', ' ', '%', 'd', '%', '%',
                                ' ', 's', 'c', 'a', 'l', 'e', '.' };
static mwArray _mxarray77_ = mclInitializeString(25, _array78_);

static double _array80_[2] = { 2.0, 1.0 };
static mwArray _mxarray79_ = mclInitializeDoubleVector(1, 2, _array80_);
static mwArray _mxarray81_ = mclInitializeDouble(2.220446049250313e-16);

static mxChar _array83_[10] = { 'n', 'o', 'r', 'm', 'a',
                                'l', 'i', 'z', 'e', 'd' };
static mwArray _mxarray82_ = mclInitializeString(10, _array83_);

static mxChar _array85_[48] = { 'I', 'm', 'a', 'g', 'e', ' ', 'i', 's',
                                ' ', 't', 'o', 'o', ' ', 's', 'm', 'a',
                                'l', 'l', ' ', 'f', 'o', 'r', ' ', 't',
                                'r', 'u', 'e', 's', 'i', 'z', 'e', ' ',
                                'f', 'i', 'g', 'u', 'r', 'e', ' ', 's',
                                'c', 'a', 'l', 'i', 'n', 'g', ';', ' ' };
static mwArray _mxarray84_ = mclInitializeString(48, _array85_);

static mxChar _array87_[27] = { 0x005c, 'n', 'd', 'i', 's', 'p', 'l', 'a', 'y',
                                'i', 'n', 'g', ' ', 'a', 't', ' ', '%', 'd',
                                '%', '%', ' ', 's', 'c', 'a', 'l', 'e', '.' };
static mwArray _mxarray86_ = mclInitializeString(27, _array87_);
static mwArray _mxarray88_ = mclInitializeDouble(30.0);
static mwArray _mxarray89_ = mclInitializeDouble(20.0);

static mxChar _array91_[8] = { 'v', 'e', 'r', 't', 'i', 'c', 'a', 'l' };
static mwArray _mxarray90_ = mclInitializeString(8, _array91_);

static mxChar _array93_[10] = { 'h', 'o', 'r', 'i', 'z',
                                'o', 'n', 't', 'a', 'l' };
static mwArray _mxarray92_ = mclInitializeString(10, _array93_);

static mxChar _array95_[21] = { 'F', 'a', 'c', 't', 'o', 'r', 'y',
                                'F', 'i', 'g', 'u', 'r', 'e', 'P',
                                'o', 's', 'i', 't', 'i', 'o', 'n' };
static mwArray _mxarray94_ = mclInitializeString(21, _array95_);

static mxChar _array97_[19] = { 'F', 'a', 'c', 't', 'o', 'r', 'y',
                                'A', 'x', 'e', 's', 'P', 'o', 's',
                                'i', 't', 'i', 'o', 'n' };
static mwArray _mxarray96_ = mclInitializeString(19, _array97_);

void InitializeModule_truesize() {
}

void TerminateModule_truesize() {
}

static mwArray truesize_ParseInputs(mwArray * imHandle,
                                    mwArray * colorbarHandle,
                                    mwArray * imSize,
                                    mwArray * resizeType,
                                    mwArray * msg,
                                    mwVarargin varargin = mwVarargin::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxTruesize_ParseInputs(int nlhs,
                             mxArray * plhs[],
                             int nrhs,
                             mxArray * prhs[]);
static void truesize_Resize1(mwArray axHandle = mwArray::DIN,
                             mwArray imHandle = mwArray::DIN,
                             mwArray imSize = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxTruesize_Resize1(int nlhs,
                         mxArray * plhs[],
                         int nrhs,
                         mxArray * prhs[]);
static void truesize_Resize2(mwArray axHandle = mwArray::DIN,
                             mwArray imHandle = mwArray::DIN,
                             mwArray imSize = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxTruesize_Resize2(int nlhs,
                         mxArray * plhs[],
                         int nrhs,
                         mxArray * prhs[]);
static void truesize_Resize3(mwArray axHandle = mwArray::DIN,
                             mwArray imHandle = mwArray::DIN,
                             mwArray imSize = mwArray::DIN,
                             mwArray colorbarHandle = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxTruesize_Resize3(int nlhs,
                         mxArray * plhs[],
                         int nrhs,
                         mxArray * prhs[]);
static void Mtruesize(mwArray varargin);
static mwArray Mtruesize_ParseInputs(mwArray * imHandle,
                                     mwArray * colorbarHandle,
                                     mwArray * imSize,
                                     mwArray * resizeType,
                                     mwArray * msg,
                                     int nargout_,
                                     mwArray varargin);
static void Mtruesize_Resize1(mwArray axHandle,
                              mwArray imHandle,
                              mwArray imSize);
static void Mtruesize_Resize2(mwArray axHandle,
                              mwArray imHandle,
                              mwArray imSize);
static void Mtruesize_Resize3(mwArray axHandle,
                              mwArray imHandle,
                              mwArray imSize,
                              mwArray colorbarHandle);

static mexFunctionTableEntry local_function_table_[4]
  = { { "ParseInputs", mlxTruesize_ParseInputs, -1, 6, NULL },
      { "Resize1", mlxTruesize_Resize1, 3, 0, NULL },
      { "Resize2", mlxTruesize_Resize2, 3, 0, NULL },
      { "Resize3", mlxTruesize_Resize3, 4, 0, NULL } };

_mexLocalFunctionTable _local_function_table_truesize
  = { 4, local_function_table_ };

//
// The function "truesize" contains the normal interface for the "truesize"
// M-function from file "e:\matlab6.5\toolbox\images\images\truesize.m" (lines
// 1-55). This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void truesize(mwVarargin varargin) {
    Mtruesize(varargin.ToArray());
}

//
// The function "mlxTruesize" contains the feval interface for the "truesize"
// M-function from file "e:\matlab6.5\toolbox\images\images\truesize.m" (lines
// 1-55). The feval function calls the implementation version of truesize
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxTruesize(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[1];
        if (nlhs > 0) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: truesize Line: 1 Column: "
                  "1 The function \"truesize\" was called with mor"
                  "e than the declared number of outputs (0).")));
        }
        mprhs[0] = mclCreateVararginCell(nrhs, prhs);
        Mtruesize(mprhs[0]);
    }
    MW_END_MLX();
}

//
// The function "truesize_ParseInputs" contains the normal interface for the
// "truesize/ParseInputs" M-function from file
// "e:\matlab6.5\toolbox\images\images\truesize.m" (lines 55-176). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
static mwArray truesize_ParseInputs(mwArray * imHandle,
                                    mwArray * colorbarHandle,
                                    mwArray * imSize,
                                    mwArray * resizeType,
                                    mwArray * msg,
                                    mwVarargin varargin) {
    int nargout = 1;
    mwArray axHandle = mwArray::UNDEFINED;
    mwArray imHandle__ = mwArray::UNDEFINED;
    mwArray colorbarHandle__ = mwArray::UNDEFINED;
    mwArray imSize__ = mwArray::UNDEFINED;
    mwArray resizeType__ = mwArray::UNDEFINED;
    mwArray msg__ = mwArray::UNDEFINED;
    if (imHandle != NULL) {
        ++nargout;
    }
    if (colorbarHandle != NULL) {
        ++nargout;
    }
    if (imSize != NULL) {
        ++nargout;
    }
    if (resizeType != NULL) {
        ++nargout;
    }
    if (msg != NULL) {
        ++nargout;
    }
    axHandle
      = Mtruesize_ParseInputs(
          &imHandle__,
          &colorbarHandle__,
          &imSize__,
          &resizeType__,
          &msg__,
          nargout,
          varargin.ToArray());
    if (imHandle != NULL) {
        *imHandle = imHandle__;
    }
    if (colorbarHandle != NULL) {
        *colorbarHandle = colorbarHandle__;
    }
    if (imSize != NULL) {
        *imSize = imSize__;
    }
    if (resizeType != NULL) {
        *resizeType = resizeType__;
    }
    if (msg != NULL) {
        *msg = msg__;
    }
    return axHandle;
}

//
// The function "mlxTruesize_ParseInputs" contains the feval interface for the
// "truesize/ParseInputs" M-function from file
// "e:\matlab6.5\toolbox\images\images\truesize.m" (lines 55-176). The feval
// function calls the implementation version of truesize/ParseInputs through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxTruesize_ParseInputs(int nlhs,
                             mxArray * plhs[],
                             int nrhs,
                             mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[1];
        mwArray mplhs[6];
        int i;
        mclCppUndefineArrays(6, mplhs);
        if (nlhs > 6) {