imshow.cpp

matlab的可执行程序

static mexFunctionTableEntry local_function_table_[3]
  = { { "ParseInputs", mlxImshow_ParseInputs, -1, 8, NULL },
      { "IsVector", mlxImshow_IsVector, 1, 1, NULL },
      { "SingleImageDefaultPos",
        mlxImshow_SingleImageDefaultPos, 2, 1, NULL } };

_mexLocalFunctionTable _local_function_table_imshow
  = { 3, local_function_table_ };

//
// The function "Nimshow" contains the nargout interface for the "imshow"
// M-function from file "e:\matlab6.5\toolbox\images\images\imshow.m" (lines
// 1-191). This interface is only produced if the M-function uses the special
// variable "nargout". The nargout interface allows the number of requested
// outputs to be specified via the nargout argument, as opposed to the normal
// interface which dynamically calculates the number of outputs based on the
// number of non-NULL inputs it receives. This function processes any input
// arguments and passes them to the implementation version of the function,
// appearing above.
//
mwArray Nimshow(int nargout, mwVarargin varargin) {
    mwArray h = mwArray::UNDEFINED;
    h = Mimshow(nargout, varargin.ToArray());
    return h;
}

//
// The function "imshow" contains the normal interface for the "imshow"
// M-function from file "e:\matlab6.5\toolbox\images\images\imshow.m" (lines
// 1-191). This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
mwArray imshow(mwVarargin varargin) {
    int nargout = 1;
    mwArray h = mwArray::UNDEFINED;
    h = Mimshow(nargout, varargin.ToArray());
    return h;
}

//
// The function "Vimshow" contains the void interface for the "imshow"
// M-function from file "e:\matlab6.5\toolbox\images\images\imshow.m" (lines
// 1-191). The void interface is only produced if the M-function uses the
// special variable "nargout", and has at least one output. The void interface
// function specifies zero output arguments to the implementation version of
// the function, and in the event that the implementation version still returns
// an output (which, in MATLAB, would be assigned to the "ans" variable), it
// deallocates the output. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void Vimshow(mwVarargin varargin) {
    mwArray h = mwArray::UNDEFINED;
    h = Mimshow(0, varargin.ToArray());
}

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

//
// The function "imshow_ParseInputs" contains the normal interface for the
// "imshow/ParseInputs" M-function from file
// "e:\matlab6.5\toolbox\images\images\imshow.m" (lines 191-511). This function
// processes any input arguments and passes them to the implementation version
// of the function, appearing above.
//
static mwArray imshow_ParseInputs(mwArray * cdatamapping,
                                  mwArray * clim,
                                  mwArray * map,
                                  mwArray * xdata,
                                  mwArray * ydata,
                                  mwArray * filename,
                                  mwArray * truesizeStr,
                                  mwVarargin varargin) {
    int nargout = 1;
    mwArray cdata = mwArray::UNDEFINED;
    mwArray cdatamapping__ = mwArray::UNDEFINED;
    mwArray clim__ = mwArray::UNDEFINED;
    mwArray map__ = mwArray::UNDEFINED;
    mwArray xdata__ = mwArray::UNDEFINED;
    mwArray ydata__ = mwArray::UNDEFINED;
    mwArray filename__ = mwArray::UNDEFINED;
    mwArray truesizeStr__ = mwArray::UNDEFINED;
    if (cdatamapping != NULL) {
        ++nargout;
    }
    if (clim != NULL) {
        ++nargout;
    }
    if (map != NULL) {
        ++nargout;
    }
    if (xdata != NULL) {
        ++nargout;
    }
    if (ydata != NULL) {
        ++nargout;
    }
    if (filename != NULL) {
        ++nargout;
    }
    if (truesizeStr != NULL) {
        ++nargout;
    }
    cdata
      = Mimshow_ParseInputs(
          &cdatamapping__,
          &clim__,
          &map__,
          &xdata__,
          &ydata__,
          &filename__,
          &truesizeStr__,
          nargout,
          varargin.ToArray());
    if (cdatamapping != NULL) {
        *cdatamapping = cdatamapping__;
    }
    if (clim != NULL) {
        *clim = clim__;
    }
    if (map != NULL) {
        *map = map__;
    }
    if (xdata != NULL) {
        *xdata = xdata__;
    }
    if (ydata != NULL) {
        *ydata = ydata__;
    }
    if (filename != NULL) {
        *filename = filename__;
    }
    if (truesizeStr != NULL) {
        *truesizeStr = truesizeStr__;
    }
    return cdata;
}

//
// The function "mlxImshow_ParseInputs" contains the feval interface for the
// "imshow/ParseInputs" M-function from file
// "e:\matlab6.5\toolbox\images\images\imshow.m" (lines 191-511). The feval
// function calls the implementation version of imshow/ParseInputs through this
// function. This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void mlxImshow_ParseInputs(int nlhs,
                           mxArray * plhs[],
                           int nrhs,
                           mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[1];
        mwArray mplhs[8];
        int i;
        mclCppUndefineArrays(8, mplhs);
        if (nlhs > 8) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: imshow/ParseInputs Line: 191 Col"
                  "umn: 1 The function \"imshow/ParseInputs\" was called "
                  "with more than the declared number of outputs (8).")));
        }
        mprhs[0] = mclCreateVararginCell(nrhs, prhs);
        mplhs[0]
          = Mimshow_ParseInputs(
              &mplhs[1],
              &mplhs[2],
              &mplhs[3],
              &mplhs[4],
              &mplhs[5],
              &mplhs[6],
              &mplhs[7],
              nlhs,
              mprhs[0]);
        plhs[0] = mplhs[0].FreezeData();
        for (i = 1; i < 8 && i < nlhs; ++i) {
            plhs[i] = mplhs[i].FreezeData();
        }
    }
    MW_END_MLX();
}

//
// The function "imshow_IsVector" contains the normal interface for the
// "imshow/IsVector" M-function from file
// "e:\matlab6.5\toolbox\images\images\imshow.m" (lines 511-519). This function
// processes any input arguments and passes them to the implementation version
// of the function, appearing above.
//
static mwArray imshow_IsVector(mwArray x) {
    int nargout = 1;
    mwArray tf = mwArray::UNDEFINED;
    tf = Mimshow_IsVector(nargout, x);
    return tf;
}

//
// The function "mlxImshow_IsVector" contains the feval interface for the
// "imshow/IsVector" M-function from file
// "e:\matlab6.5\toolbox\images\images\imshow.m" (lines 511-519). The feval
// function calls the implementation version of imshow/IsVector through this
// function. This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void mlxImshow_IsVector(int nlhs,
                        mxArray * plhs[],
                        int nrhs,
                        mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[1];
        mwArray mplhs[1];
        int i;
        mclCppUndefineArrays(1, mplhs);
        if (nlhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: imshow/IsVector Line: 511 Colu"
                  "mn: 1 The function \"imshow/IsVector\" was called wi"
                  "th more than the declared number of outputs (1).")));
        }
        if (nrhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: imshow/IsVector Line: 511 Colu"
                  "mn: 1 The function \"imshow/IsVector\" was called wi"
                  "th more than the declared number of inputs (1).")));
        }
        for (i = 0; i < 1 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 1; ++i) {
            mprhs[i].MakeDIN();
        }
        mplhs[0] = Mimshow_IsVector(nlhs, mprhs[0]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "imshow_SingleImageDefaultPos" contains the normal interface
// for the "imshow/SingleImageDefaultPos" M-function from file
// "e:\matlab6.5\toolbox\images\images\imshow.m" (lines 519-546). This function
// processes any input arguments and passes them to the implementation version
// of the function, appearing above.
//
static mwArray imshow_SingleImageDefaultPos(mwArray figHandle,
                                            mwArray axHandle) {
    int nargout = 1;
    mwArray tf = mwArray::UNDEFINED;
    tf = Mimshow_SingleImageDefaultPos(nargout, figHandle, axHandle);
    return tf;
}

//
// The function "mlxImshow_SingleImageDefaultPos" contains the feval interface
// for the "imshow/SingleImageDefaultPos" M-function from file
// "e:\matlab6.5\toolbox\images\images\imshow.m" (lines 519-546). The feval
// function calls the implementation version of imshow/SingleImageDefaultPos
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxImshow_SingleImageDefaultPos(int nlhs,
                                     mxArray * plhs[],
                                     int nrhs,
                                     mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[2];
        mwArray mplhs[1];
        int i;
        mclCppUndefineArrays(1, mplhs);
        if (nlhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: imshow/SingleImageDefaul"
                  "tPos Line: 519 Column: 1 The function \"imshow"
                  "/SingleImageDefaultPos\" was called with more "
                  "than the declared number of outputs (1).")));
        }
        if (nrhs > 2) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: imshow/SingleImageDefaul"
                  "tPos Line: 519 Column: 1 The function \"imshow"
                  "/SingleImageDefaultPos\" was called with more "
                  "than the declared number of inputs (2).")));
        }
        for (i = 0; i < 2 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 2; ++i) {
            mprhs[i].MakeDIN();
        }
        mplhs[0] = Mimshow_SingleImageDefaultPos(nlhs, mprhs[0], mprhs[1]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "Mimshow" is the implementation version of the "imshow"
// M-function from file "e:\matlab6.5\toolbox\images\images\imshow.m" (lines
// 1-191). It contains the actual compiled code for that M-function. It is a
// static function and must only be called from one of the interface functions,
// appearing below.
//
//
// function h=imshow(varargin)
//
static mwArray Mimshow(int nargout_, mwArray varargin) {
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_imshow;
    mwArray h = mwArray::UNDEFINED;
    mwArray borderPref = mwArray::UNDEFINED;
    mwArray callTruesize = mwArray::UNDEFINED;
    mwArray singleImage = mwArray::UNDEFINED;
    mwArray autoTruesize = mwArray::UNDEFINED;
    mwArray truesizePref = mwArray::UNDEFINED;
    mwArray ans = mwArray::UNDEFINED;
    mwArray showAxes = mwArray::UNDEFINED;
    mwArray hh = mwArray::UNDEFINED;
    mwArray axHandle = mwArray::UNDEFINED;