home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / i / iritsm3s.zip / cagd_lib / bsp_read.c < prev    next >
C/C++ Source or Header  |  1991-09-11  |  13KB  |  421 lines
  1. /******************************************************************************
  2. * Bsp-Read.c - Bspline handling routines - read from file.              *
  3. *******************************************************************************
  4. * Written by Gershon Elber, Aug. 90.                          *
  5. ******************************************************************************/
  6.  
  7. #ifdef __MSDOS__
  8. #include <stdlib.h>
  9. #endif /* __MSDOS__ */
  10.  
  11. #include <ctype.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include "cagd_loc.h"
  15.  
  16. /******************************************************************************
  17. * Reads and returns a bspline curve.                          *
  18. * If error is found in reading the file, ErrStr is set to string describing   *
  19. * it and Line to the line it occured in file.                      *
  20. * If no error is detected *ErrStr = NULL.                      *
  21. ******************************************************************************/
  22. CagdCrvStruct *BspCrvReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  23. {
  24.     FILE *f;
  25.     char StringToken[LINE_LEN];
  26.     CagdCrvStruct *Crv,
  27.     *CrvTail = NULL,
  28.     *CrvList = NULL;
  29.  
  30.     if ((f = fopen(FileName, "r")) == NULL) {
  31.     *ErrStr = "File not found";
  32.     return NULL;
  33.     }
  34.  
  35.     while (_CagdGetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
  36.     _CagdUnGetToken(StringToken);
  37.         Crv = BspCrvReadFromFile2(f, FALSE, ErrStr, ErrLine);
  38.  
  39.     if (CrvList == NULL)
  40.         CrvList = CrvTail = Crv;
  41.     else {
  42.         CrvTail -> Pnext = Crv;
  43.         CrvTail = Crv;
  44.     }
  45.     }
  46.  
  47.     fclose(f);
  48.  
  49.     return CrvList;
  50. }
  51.  
  52. /******************************************************************************
  53. * Reads and returns a bspline curve.                          *
  54. * If NameWasRead is TRUE, it is assumed prefix "[CURVE BSPLINE" has already   *
  55. * been read. This is useful for a global parser which invokes this routine.   *
  56. * For exactly this reason, the file is NOT closed in the end.              *
  57. * If error is found in reading the file, ErrStr is set to string describing   *
  58. * it and ErrLine to line it occured in file relative to begining of curve.    *
  59. * If no error is detected *ErrStr is set to NULL.                  *
  60. ******************************************************************************/
  61. CagdCrvStruct *BspCrvReadFromFile2(FILE *f, CagdBType NameWasRead,
  62.                         char **ErrStr, int *ErrLine)
  63. {
  64.     CagdPointType PType;
  65.     TokenNumType Token;
  66.     int i, j, Length, Order, MaxCoord;
  67.     char StringToken[LINE_LEN];
  68.     CagdCrvStruct *NewCrv;
  69.  
  70.     _CagdGlblLineCount = *ErrLine;
  71.  
  72.     if (!NameWasRead) {
  73.     while ((Token = _CagdGetToken(f, StringToken)) != TOKEN_EOF &&
  74.            Token != TOKEN_OPEN_PAREN);
  75.  
  76.     /* We found beginning of definition - read one: */
  77.     if (_CagdGetToken(f, StringToken) != TOKEN_CURVE ||
  78.         _CagdGetToken(f, StringToken) != TOKEN_BSPLINE) {
  79.             *ErrStr = "CURVE BSPLINE key words expected";
  80.         *ErrLine = _CagdGlblLineCount;
  81.         return NULL;
  82.     }
  83.     }
  84.  
  85.     if ((Token = _CagdGetToken(f, StringToken)) == TOKEN_OPEN_PAREN) {
  86.     if ((*ErrStr = _CagdGetCurveAttributes(f)) != NULL) {
  87.             *ErrStr = "\"[\" expected";
  88.         *ErrLine = _CagdGlblLineCount;
  89.         return NULL;
  90.     }
  91.     }
  92.     else
  93.     _CagdUnGetToken(StringToken);
  94.  
  95.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  96.     sscanf(StringToken, "%d", &Length) != 1) {
  97.     *ErrStr = "BSPLINE Number of points expected";
  98.     *ErrLine = _CagdGlblLineCount;
  99.     return NULL;
  100.     }
  101.  
  102.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  103.     sscanf(StringToken, "%d", &Order) != 1) {
  104.     *ErrStr = "BSPLINE Order expected";
  105.     *ErrLine = _CagdGlblLineCount;
  106.     return NULL;
  107.     }
  108.  
  109.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  110.     strlen(StringToken) != 2 ||
  111.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  112.     !isdigit(StringToken[1]) ||
  113.     atoi(&StringToken[1]) >= CAGD_MAX_PT_COORD) {
  114.     *ErrStr = "BSPLINE Point type expected";
  115.     *ErrLine = _CagdGlblLineCount;
  116.     return NULL;
  117.     }
  118.  
  119.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  120.  
  121.     NewCrv = BspCrvNew(Length, Order, PType);
  122.  
  123.     /* Read the knot vector first: */
  124.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  125.     *ErrStr = "\"[\" expected";
  126.     *ErrLine = _CagdGlblLineCount;
  127.     CagdCrvFree(NewCrv);
  128.     return NULL;
  129.     }
  130.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_KV) {
  131.     *ErrStr = "KV expected";
  132.     *ErrLine = _CagdGlblLineCount;
  133.     CagdCrvFree(NewCrv);
  134.     return NULL;
  135.     }
  136.     for (i = 0; i < Order + Length; i++) {
  137.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  138. #ifdef CAGD_DOUBLE
  139.         sscanf(StringToken, "%lf", &NewCrv -> KnotVector[i]) != 1) {
  140. #else
  141.         sscanf(StringToken, "%f", &NewCrv -> KnotVector[i]) != 1) {
  142. #endif /* CAGD_DOUBLE */
  143.         *ErrStr = "Numeric data expected";
  144.         *ErrLine = _CagdGlblLineCount;
  145.         CagdCrvFree(NewCrv);
  146.         return NULL;
  147.     }
  148.     }
  149.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  150.     *ErrStr = "\"]\" expected";
  151.     *ErrLine = _CagdGlblLineCount;
  152.     CagdCrvFree(NewCrv);
  153.     return NULL;
  154.     }
  155.  
  156.     /* Read the points themselves: */
  157.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  158.     for (i = 0; i < Length; i++) {
  159.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  160.         *ErrStr = "\"[\" expected";
  161.         *ErrLine = _CagdGlblLineCount;
  162.         CagdCrvFree(NewCrv);
  163.         return NULL;
  164.     }
  165.     if (CAGD_IS_RATIONAL_PT(PType)) {
  166.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  167. #ifdef CAGD_DOUBLE
  168.         sscanf(StringToken, "%lf", &NewCrv -> Points[W][i]) != 1) {
  169. #else
  170.             sscanf(StringToken, "%f", &NewCrv -> Points[W][i]) != 1) {
  171. #endif /* CAGD_DOUBLE */
  172.         *ErrStr = "Numeric data expected";
  173.         *ErrLine = _CagdGlblLineCount;
  174.         CagdCrvFree(NewCrv);
  175.         return NULL;
  176.         }
  177.     }
  178.     for (j = 1; j <= MaxCoord; j++) {
  179.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  180. #ifdef CAGD_DOUBLE
  181.         sscanf(StringToken, "%lf", &NewCrv -> Points[j][i]) != 1) {
  182. #else
  183.             sscanf(StringToken, "%f", &NewCrv -> Points[j][i]) != 1) {
  184. #endif /* CAGD_DOUBLE */
  185.         *ErrStr = "Numeric data expected";
  186.         *ErrLine = _CagdGlblLineCount;
  187.         CagdCrvFree(NewCrv);
  188.         return NULL;
  189.         }
  190.     }
  191.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  192.         *ErrStr = "\"]\" expected";
  193.         *ErrLine = _CagdGlblLineCount;
  194.         CagdCrvFree(NewCrv);
  195.         return NULL;
  196.     }
  197.     }
  198.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  199.     *ErrStr = "\"]\" expected";
  200.     *ErrLine = _CagdGlblLineCount;
  201.     CagdCrvFree(NewCrv);
  202.     return NULL;
  203.     }
  204.  
  205.     *ErrLine = _CagdGlblLineCount;
  206.     *ErrStr = NULL;
  207.  
  208.     return NewCrv;
  209. }
  210.  
  211. /******************************************************************************
  212. * Reads and returns a bspline surface.                          *
  213. * If error is found in reading the file, ErrStr is set to string describing   *
  214. * it and Line to the line it occured in file.                      *
  215. * If no error is detected *ErrStr = NULL.                      *
  216. ******************************************************************************/
  217. CagdSrfStruct *BspSrfReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  218. {
  219.     FILE *f;
  220.     char StringToken[LINE_LEN];
  221.     CagdSrfStruct *Srf,
  222.     *SrfTail = NULL,
  223.     *SrfList = NULL;
  224.  
  225.     if ((f = fopen(FileName, "r")) == NULL) {
  226.     *ErrStr = "File not found";
  227.     return NULL;
  228.     }
  229.  
  230.     while (_CagdGetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
  231.     _CagdUnGetToken(StringToken);
  232.         Srf = BspSrfReadFromFile2(f, FALSE, ErrStr, ErrLine);
  233.  
  234.     if (SrfList == NULL)
  235.         SrfList = SrfTail = Srf;
  236.     else {
  237.         SrfTail -> Pnext = Srf;
  238.         SrfTail = Srf;
  239.     }
  240.     }
  241.  
  242.     fclose(f);
  243.  
  244.     return SrfList;
  245. }
  246.  
  247. /******************************************************************************
  248. * Reads and returns a bspline surface.                          *
  249. * If NameWasRead is TRUE, it is assumed prefix "[SURFACE BSPLINE" has already *
  250. * been read. This is useful for a global parser which invokes this routine.   *
  251. * For exactly this reason, the file is NOT closed in the end.              *
  252. * If error is found in reading the file, ErrStr is set to string describing   *
  253. * it and ErrLine to the line it occured in file.                    *
  254. * If no error is detected *ErrStr = NULL.                      *
  255. ******************************************************************************/
  256. CagdSrfStruct *BspSrfReadFromFile2(FILE *f, CagdBType NameWasRead,
  257.                         char **ErrStr, int *ErrLine)
  258. {
  259.     int i, j, k, Len, ULength, VLength, UOrder, VOrder, MaxCoord;
  260.     char StringToken[LINE_LEN];
  261.     CagdRType *KnotVector;
  262.     CagdPointType PType;
  263.     TokenNumType Token;
  264.     CagdSrfStruct *NewSrf;
  265.  
  266.     _CagdGlblLineCount = *ErrLine;
  267.  
  268.     if (!NameWasRead) {
  269.     while ((Token = _CagdGetToken(f, StringToken)) != TOKEN_EOF &&
  270.            Token != TOKEN_OPEN_PAREN);
  271.  
  272.     /* We found beginning of definition - read one: */
  273.     if (_CagdGetToken(f, StringToken) != TOKEN_SURFACE ||
  274.         _CagdGetToken(f, StringToken) != TOKEN_BSPLINE) {
  275.         *ErrStr = "SURFACE BSPLINE key words expected";
  276.         *ErrLine = _CagdGlblLineCount;
  277.         return NULL;
  278.         }
  279.     }
  280.  
  281.     if ((Token = _CagdGetToken(f, StringToken)) == TOKEN_OPEN_PAREN) {
  282.     if ((*ErrStr = _CagdGetSurfaceAttributes(f)) != NULL) {
  283.         *ErrStr = "\"[\" expected";
  284.         *ErrLine = _CagdGlblLineCount;
  285.         return NULL;
  286.     }
  287.     }
  288.     else
  289.     _CagdUnGetToken(StringToken);
  290.  
  291.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  292.         sscanf(StringToken, "%d", &ULength) != 1 ||
  293.     (Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  294.     sscanf(StringToken, "%d", &VLength) != 1) {
  295.     *ErrStr = "BSPLINE Number of points expected";
  296.     *ErrLine = _CagdGlblLineCount;
  297.     return NULL;
  298.     }
  299.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  300.     sscanf(StringToken, "%d", &UOrder) != 1 ||
  301.     (Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  302.     sscanf(StringToken, "%d", &VOrder) != 1) {
  303.     *ErrStr = "BSPLINE Order expected";
  304.     *ErrLine = _CagdGlblLineCount;
  305.     return NULL;
  306.     }
  307.  
  308.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  309.         strlen(StringToken) != 2 ||
  310.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  311.     !isdigit(StringToken[1]) ||
  312.     atoi(&StringToken[1]) >= CAGD_MAX_PT_COORD) {
  313.     *ErrStr = "BSPLINE Point type expected";
  314.     *ErrLine = _CagdGlblLineCount;
  315.     return NULL;
  316.     }
  317.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  318.  
  319.     NewSrf = BspSrfNew(ULength, VLength, UOrder, VOrder, PType);
  320.  
  321.     /* Read the knot vectors first: */
  322.     for (k = 0; k < 2; k++) {
  323.     if (k == 0) {
  324.         KnotVector = NewSrf -> UKnotVector;
  325.         Len = NewSrf -> UOrder + NewSrf -> ULength;
  326.     }
  327.     else {
  328.         KnotVector = NewSrf -> VKnotVector;
  329.         Len = NewSrf -> VOrder + NewSrf -> VLength;
  330.     }
  331.  
  332.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  333.             *ErrStr = "\"[\" expected";
  334.         *ErrLine = _CagdGlblLineCount;
  335.         CagdSrfFree(NewSrf);
  336.         return NULL;
  337.         }
  338.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_KV) {
  339.         *ErrStr = "KV expected";
  340.         *ErrLine = _CagdGlblLineCount;
  341.         CagdSrfFree(NewSrf);
  342.         return NULL;
  343.     }
  344.  
  345.     for (i = 0; i < Len; i++) {
  346.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  347. #ifdef CAGD_DOUBLE
  348.             sscanf(StringToken, "%lf", &KnotVector[i]) != 1) {
  349. #else
  350.             sscanf(StringToken, "%f", &KnotVector[i]) != 1) {
  351. #endif /* CAGD_DOUBLE */
  352.             *ErrStr = "Numeric data expected";
  353.         *ErrLine = _CagdGlblLineCount;
  354.         CagdSrfFree(NewSrf);
  355.         return NULL;
  356.         }
  357.     }
  358.  
  359.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  360.         *ErrStr = "\"]\" expected";
  361.         *ErrLine = _CagdGlblLineCount;
  362.         CagdSrfFree(NewSrf);
  363.         return NULL;
  364.     }
  365.     }
  366.  
  367.     /* Read the points themselves: */
  368.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  369.     for (i = 0; i < ULength * VLength; i++) {
  370.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  371.         *ErrStr = "\"[\" expected";
  372.         *ErrLine = _CagdGlblLineCount;
  373.         CagdSrfFree(NewSrf);
  374.         return NULL;
  375.     }
  376.     if (CAGD_IS_RATIONAL_PT(PType)) {
  377.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  378. #ifdef CAGD_DOUBLE
  379.             sscanf(StringToken, "%lf", &NewSrf -> Points[W][i]) != 1) {
  380. #else
  381.             sscanf(StringToken, "%f", &NewSrf -> Points[W][i]) != 1) {
  382. #endif /* CAGD_DOUBLE */
  383.         *ErrStr = "Numeric data expected";
  384.         *ErrLine = _CagdGlblLineCount;
  385.         CagdSrfFree(NewSrf);
  386.         return NULL;
  387.         }
  388.     }
  389.     for (j = 1; j <= MaxCoord; j++) {
  390.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  391. #ifdef CAGD_DOUBLE
  392.             sscanf(StringToken, "%lf", &NewSrf -> Points[j][i]) != 1) {
  393. #else
  394.             sscanf(StringToken, "%f", &NewSrf -> Points[j][i]) != 1) {
  395. #endif /* CAGD_DOUBLE */
  396.         *ErrStr = "Numeric data expected";
  397.         *ErrLine = _CagdGlblLineCount;
  398.         CagdSrfFree(NewSrf);
  399.         return NULL;
  400.         }
  401.     }
  402.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  403.         *ErrStr = "\"]\" expected";
  404.         *ErrLine = _CagdGlblLineCount;
  405.         CagdSrfFree(NewSrf);
  406.         return NULL;
  407.     }
  408.     }
  409.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  410.         *ErrStr = "\"]\" expected";
  411.     *ErrLine = _CagdGlblLineCount;
  412.     CagdSrfFree(NewSrf);
  413.     return NULL;
  414.     }
  415.  
  416.     *ErrStr = NULL;
  417.     *ErrLine = _CagdGlblLineCount;
  418.  
  419.     return NewSrf;
  420. }
  421.