scilab/modules/graphics/sci_gateway/c/sci_fec.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2006 - INRIA - Fabrice Leray
   4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
   5  * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
   6  *
   7  * This file must be used under the terms of the CeCILL.
   8  * This source file is licensed as described in the file COPYING, which
   9  * you should have received as part of this distribution.  The terms
  10  * are also available at
  11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  12  *
  13  */
  14
  15 /*------------------------------------------------------------------------*/
  16 /* file: sci_fec.c                                                        */
  17 /* desc : interface for sci_fec routine                                   */
  18 /*------------------------------------------------------------------------*/
  19
  20 #include "gw_graphics.h"
  21 #include "api_scilab.h"
  22 #include "GetCommandArg.h"
  23 #include "BuildObjects.h"
  24 #include "sciCall.h"
  25 #include "DefaultCommandArg.h"
  26 #include "localization.h"
  27 #include "Scierror.h"
  28
  29 /*--------------------------------------------------------------------------*/
  30 int sci_fec(char *fname, unsigned long fname_len)
  31 {
  32     SciErr sciErr;
  33     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0, mn1 = 0;
  34
  35     static rhs_opts opts[] =
  36     {
  37         { -1, "colminmax", -1, 0, 0, NULL},
  38         { -1, "colout", -1, 0, 0, NULL},
  39         { -1, "leg", -1, 0, 0, NULL},
  40         { -1, "mesh", -1, 0, 0, NULL},
  41         { -1, "nax", -1, 0, 0, NULL},
  42         { -1, "rect", -1, 0, 0, NULL},
  43         { -1, "strf", -1, 0, 0, NULL},
  44         { -1, "zminmax", -1, 0, 0, NULL},
  45         { -1, NULL, -1, 0, 0, NULL}
  46     };
  47
  48     char* strf      = NULL;
  49     char* legend    = NULL;
  50     double* rect    = NULL;
  51     double* zminmax = NULL;
  52     int* colminmax  = NULL;
  53     int* nax        = NULL;
  54     int* colOut     = NULL;
  55     BOOL flagNax    = FALSE;
  56     BOOL withMesh   = FALSE;
  57
  58     int* piAddr1 = NULL;
  59     int* piAddr2 = NULL;
  60     int* piAddr3 = NULL;
  61     int* piAddr4 = NULL;
  62
  63     double* l1 = NULL;
  64     double* l2 = NULL;
  65     double* l3 = NULL;
  66     double* l4 = NULL;
  67
  68     if (nbInputArgument(pvApiCtx) <= 0)
  69     {
  70         sci_demo(fname, fname_len);
  71         return 0;
  72     }
  73
  74     CheckInputArgument(pvApiCtx, 4, 12);
  75
  76     if (getOptionals(pvApiCtx, fname, opts) == 0)
  77     {
  78         ReturnArguments(pvApiCtx);
  79         return 0;
  80     }
  81
  82     if (FirstOpt() < 5)
  83     {
  84         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
  85         return -1;
  86     }
  87
  88     //get variable address
  89     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
  90     if (sciErr.iErr)
  91     {
  92         printError(&sciErr, 0);
  93         return 1;
  94     }
  95
  96     // Retrieve a matrix of double at position 1.
  97     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
  98     if (sciErr.iErr)
  99     {
 100         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
 101         printError(&sciErr, 0);
 102         return 1;
 103     }
 104
 105     //get variable address
 106     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
 107     if (sciErr.iErr)
 108     {
 109         printError(&sciErr, 0);
 110         return 1;
 111     }
 112
 113     // Retrieve a matrix of double at position 2.
 114     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
 115     if (sciErr.iErr)
 116     {
 117         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
 118         printError(&sciErr, 0);
 119         return 1;
 120     }
 121
 122     //CheckSameDims
 123     if (m1 != m2 || n1 != n2)
 124     {
 125         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
 126         return 1;
 127     }
 128
 129
 130     //get variable address
 131     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
 132     if (sciErr.iErr)
 133     {
 134         printError(&sciErr, 0);
 135         return 1;
 136     }
 137
 138     // Retrieve a matrix of double at position 3.
 139     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
 140     if (sciErr.iErr)
 141     {
 142         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
 143         printError(&sciErr, 0);
 144         return 1;
 145     }
 146
 147     if (n3 != 5)
 148     {
 149         Scierror(999, _("%s: Wrong number of columns for input argument #%d: %d expected.\n"), fname, 3, 5);
 150         return 0;
 151     }
 152
 153     //get variable address
 154     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
 155     if (sciErr.iErr)
 156     {
 157         printError(&sciErr, 0);
 158         return 1;
 159     }
 160
 161     // Retrieve a matrix of double at position 4.
 162     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
 163     if (sciErr.iErr)
 164     {
 165         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
 166         printError(&sciErr, 0);
 167         return 1;
 168     }
 169
 170
 171     if (m1 * n1 == 0 || m3 == 0)
 172     {
 173         AssignOutputVariable(pvApiCtx, 1) = 0;
 174         ReturnArguments(pvApiCtx);
 175         return 0;
 176     }
 177
 178     GetStrf(pvApiCtx, fname, 5, opts, &strf);
 179     GetLegend(pvApiCtx, fname, 6, opts, &legend);
 180     GetRect(pvApiCtx, fname, 7, opts, &rect);
 181     GetNax(pvApiCtx, 8, opts, &nax, &flagNax);
 182     GetZminmax(pvApiCtx, fname, 9, opts, &zminmax);
 183     GetColminmax(pvApiCtx, fname, 10, opts, &colminmax);
 184     GetColOut(pvApiCtx, fname, 11, opts, &colOut);
 185     GetWithMesh(pvApiCtx, fname, 12, opts, &withMesh);
 186
 187     getOrCreateDefaultSubwin();
 188
 189     if (isDefStrf (strf))
 190     {
 191         char strfl[4];
 192
 193         strcpy(strfl, DEFSTRFN);
 194
 195         strf = strfl;
 196         if (!isDefRect(rect))
 197         {
 198             strfl[1] = '7';
 199         }
 200         if (!isDefLegend(legend))
 201         {
 202             strfl[0] = '1';
 203         }
 204     }
 205     mn1 = m1 * n1;
 206
 207     Objfec ((l1), (l2), (l3), (l4), &mn1, &m3, strf, legend, rect, nax, zminmax, colminmax, colOut, withMesh, flagNax);
 208
 209     AssignOutputVariable(pvApiCtx, 1) = 0;
 210     ReturnArguments(pvApiCtx);
 211
 212     return 0;
 213 }
 214
 215 /*--------------------------------------------------------------------------*/