scilab/modules/graphics/sci_gateway/c/sci_plot2d1.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  *
   6  * This file must be used under the terms of the CeCILL.
   7  * This source file is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at
  10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  11  *
  12  */
  13
  14 /*------------------------------------------------------------------------*/
  15 /* file: sci_plot2d1.c                                                    */
  16 /* desc : interface for plot2d1, plot2d2, plot2d3 and plot2d4 routines    */
  17 /*------------------------------------------------------------------------*/
  18
  19 #include "gw_graphics.h"
  20 #include "api_scilab.h"
  21 #include "GetCommandArg.h"
  22 #include "DefaultCommandArg.h"
  23 #include "sciCall.h"
  24 #include "localization.h"
  25 #include "Scierror.h"
  26 #include "MALLOC.h"
  27
  28 /*--------------------------------------------------------------------------*/
  29 int sci_plot2d1_1 (char *fname, unsigned long fname_len)
  30 {
  31     return sci_plot2d1_G("plot2d1", 1, fname_len); /* NG */
  32 }
  33 /*--------------------------------------------------------------------------*/
  34 int sci_plot2d1_2 (char *fname, unsigned long fname_len)
  35 {
  36     return sci_plot2d1_G("plot2d2", 2, fname_len); /* NG */
  37 }
  38 /*--------------------------------------------------------------------------*/
  39 int sci_plot2d1_3 (char *fname, unsigned long fname_len)
  40 {
  41     return sci_plot2d1_G("plot2d3", 3, fname_len); /* NG */
  42 }
  43 /*--------------------------------------------------------------------------*/
  44 int sci_plot2d1_4 (char *fname, unsigned long fname_len)
  45 {
  46     return sci_plot2d1_G("plot2d4", 4, fname_len); /* NG */
  47 }
  48 /*--------------------------------------------------------------------------*/
  49 int sci_plot2d1_G(char * fname, int ptype, unsigned long fname_len)
  50 {
  51     SciErr sciErr;
  52     int* piAddrl1 = NULL;
  53     double* l1 = NULL;
  54     int* piAddrl2 = NULL;
  55     double* l2 = NULL;
  56     double* lt = NULL;
  57
  58     int frame_def = 8;
  59     int *frame = &frame_def;
  60     int axes_def = 1;
  61     int *axes = &axes_def;
  62     int iskip = 0, test  = 0;
  63     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, i = 0, j = 0;
  64
  65     static rhs_opts opts[] =
  66     {
  67         { -1, "axesflag", -1, 0, 0, NULL},
  68         { -1, "frameflag", -1, 0, 0, NULL},
  69         { -1, "leg", -1, 0, 0, NULL},
  70         { -1, "logflag", -1, 0, 0, NULL},
  71         { -1, "nax", -1, 0, 0, NULL},
  72         { -1, "rect", -1, 0, 0, NULL},
  73         { -1, "strf", -1, 0, 0, NULL},
  74         { -1, "style", -1, 0, 0, NULL},
  75         { -1, NULL, -1, 0, 0, NULL}
  76     };
  77
  78     int    * style    = NULL ;
  79     double* rect     = NULL ;
  80     int    * nax      = NULL ;
  81     BOOL     flagNax  = FALSE;
  82     char   * strf     = NULL ;
  83     char   * legend   = NULL ;
  84     char   * logFlags = NULL ;
  85
  86     if (nbInputArgument(pvApiCtx) <= 0)
  87     {
  88         /* lauch the default routines depending on the name of the calling function */
  89         sci_demo(fname, fname_len);
  90         return 0;
  91     }
  92     CheckInputArgument(pvApiCtx, 1, 9); /* to allow plot2dxx(y) */
  93
  94
  95     iskip = 0;
  96     if (getOptionals(pvApiCtx, fname, opts) == 0)
  97     {
  98         ReturnArguments(pvApiCtx);
  99         return 0;
 100     }
 101
 102     if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
 103     {
 104         /* logflags */
 105         GetLogflags(pvApiCtx, fname, 1, opts, &logFlags);
 106         iskip = 1;
 107     }
 108
 109     /* added to support plot2dxx([logflags],y) */
 110     if (nbInputArgument(pvApiCtx) == 1 + iskip)
 111     {
 112         if (FirstOpt() <= nbInputArgument(pvApiCtx))
 113         {
 114             Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 3 + iskip);
 115             return (0);
 116         }
 117
 118         sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl2);
 119         if (sciErr.iErr)
 120         {
 121             printError(&sciErr, 0);
 122             return 1;
 123         }
 124
 125         // Retrieve a matrix of double at position 1 + iskip.
 126         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
 127         if (sciErr.iErr)
 128         {
 129             printError(&sciErr, 0);
 130             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1 + iskip);
 131             return 1;
 132         }
 133
 134         sciErr = allocMatrixOfDouble(pvApiCtx, 2 + iskip, m2, n2, &l1);
 135         if (sciErr.iErr)
 136         {
 137             printError(&sciErr, 0);
 138             Scierror(999, _("%s: Memory allocation error.\n"), fname);
 139             return 1;
 140         }
 141
 142         if (m2 == 1 && n2 > 1)
 143         {
 144             m2 = n2;
 145             n2 = 1;
 146         }
 147
 148         m1 = m2;
 149         n1 = n2;
 150
 151         for (i = 0; i < m2 ; ++i)
 152         {
 153             for (j = 0 ; j < n2 ;  ++j)
 154             {
 155                 *(l1 + i + m2 * j) = (double) i + 1;
 156             }
 157         }
 158     }
 159
 160
 161     if (nbInputArgument(pvApiCtx) >= 2 + iskip)
 162     {
 163         if (FirstOpt() < 3 + iskip)
 164         {
 165             Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
 166                      fname, 1, 3 + iskip);
 167             return (0);
 168         }
 169
 170
 171         /* x */
 172         sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl1);
 173         if (sciErr.iErr)
 174         {
 175             printError(&sciErr, 0);
 176             return 1;
 177         }
 178
 179         // Retrieve a matrix of double at position 1 + iskip.
 180         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
 181         if (sciErr.iErr)
 182         {
 183             printError(&sciErr, 0);
 184             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1 + iskip);
 185             return 1;
 186         }
 187
 188         if (iskip == 1)
 189         {
 190             if (logFlags[0] == 'e')
 191             {
 192                 m1 = 0;
 193                 n1 = 0;
 194             }
 195         }
 196
 197         /* y */
 198         sciErr = getVarAddressFromPosition(pvApiCtx, 2 + iskip, &piAddrl2);
 199         if (sciErr.iErr)
 200         {
 201             printError(&sciErr, 0);
 202             return 1;
 203         }
 204
 205         // Retrieve a matrix of double at position 2 + iskip.
 206         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
 207         if (sciErr.iErr)
 208         {
 209             printError(&sciErr, 0);
 210             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2 + iskip);
 211             return 1;
 212         }
 213
 214         /* if (m2 * n2 == 0) { m1 = 0; n1 = 0;}  */
 215
 216         test = (m1 * n1 == 0) /* x = [] */
 217                /* x,y vectors of same length */
 218                || ((m1 == 1 || n1 == 1) && (m2 == 1 || n2 == 1) && (m1 * n1 == m2 * n2))
 219                || ((m1 == m2) && (n1 == n2)) /* size(x) == size(y) */
 220                /* x vector size(y)==[size(x),.] */
 221                || ((m1 == 1 && n1 == m2) || (n1 == 1 && m1 == m2));
 222
 223         //CheckDimProp
 224         if (!test)
 225         {
 226             Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
 227             return 1;
 228         }
 229
 230
 231         if (m1 * n1 == 0)
 232         {
 233             /* default x=1:n */
 234             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
 235             if (sciErr.iErr)
 236             {
 237                 printError(&sciErr, 0);
 238                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
 239                 return 1;
 240             }
 241
 242             if (m2 == 1 && n2 > 1)
 243             {
 244                 m2 = n2;
 245                 n2 = 1;
 246             }
 247             for (i = 0; i < m2 ; ++i)
 248             {
 249                 for (j = 0 ; j < n2 ;  ++j)
 250                 {
 251                     *(lt + i + m2 * j) = (double) i + 1;
 252                 }
 253             }
 254             m1 = m2;
 255             n1 = n2;
 256             l1 = lt;
 257         }
 258         else if ((m1 == 1 || n1 == 1) && (m2 != 1 && n2 != 1))
 259         {
 260             /* a single x vector for mutiple columns for y */
 261             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
 262             if (sciErr.iErr)
 263             {
 264                 printError(&sciErr, 0);
 265                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
 266                 return 1;
 267             }
 268
 269             for (i = 0; i < m2 ; ++i)
 270             {
 271                 for (j = 0 ; j < n2 ;  ++j)
 272                 {
 273                     *(lt + i + m2 * j) = l1[i];
 274                 }
 275             }
 276             m1 = m2;
 277             n1 = n2;
 278             l1 = lt;
 279         }
 280         else if ((m1 == 1 && n1 == 1) && (n2 != 1))
 281         {
 282             /* a single y row vector  for a single x */
 283             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n2, &lt);
 284             if (sciErr.iErr)
 285             {
 286                 printError(&sciErr, 0);
 287                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
 288                 return 1;
 289             }
 290
 291             for (j = 0 ; j < n2 ;  ++j)
 292             {
 293                 lt[j] = *l1;
 294             }
 295             n1 = n2;
 296             l1 = lt;
 297         }
 298         else
 299         {
 300             if (m2 == 1 && n2 > 1)
 301             {
 302                 m2 = n2;
 303                 n2 = 1;
 304             }
 305             if (m1 == 1 && n1 > 1)
 306             {
 307                 m1 = n1;
 308                 n1 = 1;
 309             }
 310         }
 311     }
 312
 313     sciGetStyle(pvApiCtx, fname, 3 + iskip, n1, opts, &style);
 314     GetStrf(pvApiCtx, fname, 4 + iskip, opts, &strf);
 315     GetLegend(pvApiCtx, fname, 5 + iskip, opts, &legend);
 316     GetRect(pvApiCtx, fname, 6 + iskip, opts, &rect);
 317     GetNax(pvApiCtx, 7 + iskip, opts, &nax, &flagNax);
 318     if (iskip == 0)
 319     {
 320         GetLogflags(pvApiCtx, fname, 8, opts, &logFlags);
 321     }
 322
 323     if (isDefStrf(strf))
 324     {
 325         char strfl[4];
 326         strcpy(strfl, DEFSTRFN);
 327
 328         strf = strfl;
 329         if (!isDefRect(rect))
 330         {
 331             strfl[1] = '7';
 332         }
 333         if (!isDefLegend(legend))
 334         {
 335             strfl[0] = '1';
 336         }
 337         GetOptionalIntArg(pvApiCtx, fname, 9, "frameflag", &frame, 1, opts);
 338         if (frame != &frame_def)
 339         {
 340             strfl[1] = (char)(*frame + 48);
 341         }
 342         GetOptionalIntArg(pvApiCtx, fname, 9, "axesflag", &axes, 1, opts);
 343         if (axes != &axes_def)
 344         {
 345             strfl[2] = (char)(*axes + 48);
 346         }
 347     }
 348
 349     if (ptype == 0)
 350     {
 351         ptype = 1;
 352     }
 353
 354     Objplot2d (ptype, logFlags, (l1), (l2), &n1, &m1, style, strf, legend, rect, nax, flagNax);
 355
 356     // Allocated by sciGetStyle (get_style_arg function in GetCommandArg.c)
 357     FREE(style);
 358
 359     AssignOutputVariable(pvApiCtx, 1) = 0;
 360     ReturnArguments(pvApiCtx);
 361     return 0;
 362 }
 363 /*--------------------------------------------------------------------------*/