ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rmatrix.c
(Generate patch)

Comparing ray/src/util/rmatrix.c (file contents):
Revision 2.8 by greg, Wed Aug 27 13:33:47 2014 UTC vs.
Revision 2.14 by greg, Mon May 4 23:27:04 2015 UTC

# Line 46 | Line 46 | rmx_free(RMATRIX *rm)
46   int
47   rmx_newtype(int dtyp1, int dtyp2)
48   {
49 <        if ((dtyp1==DTxyze) | (dtyp1==DTrgbe) && dtyp1 != dtyp2)
49 >        if ((dtyp1==DTxyze) | (dtyp1==DTrgbe) |
50 >                        (dtyp2==DTxyze) | (dtyp2==DTrgbe)
51 >                        && dtyp1 != dtyp2)
52                  return(0);
53          if (dtyp1 < dtyp2)
54                  return(dtyp1);
# Line 184 | Line 186 | rmx_load_rgbe(RMATRIX *rm, FILE *fp)
186  
187   /* Load matrix from supported file type */
188   RMATRIX *
189 < rmx_load(const char *fname)
189 > rmx_load(const char *inspec)
190   {
191          FILE            *fp = stdin;
192          RMATRIX         dinfo;
193          RMATRIX         *dnew;
194  
195 <        if (fname == NULL) {                    /* reading from stdin? */
196 <                fname = "<stdin>";
195 >        if (inspec == NULL) {                   /* reading from stdin? */
196 >                inspec = "<stdin>";
197   #ifdef _WIN32
198                  _setmode(fileno(stdin), _O_BINARY);
199   #endif
200 +        } else if (inspec[0] == '!') {
201 +                if ((fp = popen(inspec+1, "r")) == NULL)
202 +                        return(NULL);
203 + #ifdef _WIN32
204 +                _setmode(fileno(fp), _O_BINARY);
205 + #endif
206          } else {
207 <                const char      *sp = fname;    /* check suffix */
207 >                const char      *sp = inspec;   /* check suffix */
208                  while (*sp)
209                          ++sp;
210 <                while (sp > fname && sp[-1] != '.')
210 >                while (sp > inspec && sp[-1] != '.')
211                          --sp;
212                  if (!strcasecmp(sp, "XML")) {   /* assume it's a BSDF */
213 <                        CMATRIX *cm = cm_loadBTDF((char *)fname);
213 >                        CMATRIX *cm = cm_loadBTDF((char *)inspec);
214                          if (cm == NULL)
215                                  return(NULL);
216                          dnew = rmx_from_cmatrix(cm);
# Line 210 | Line 218 | rmx_load(const char *fname)
218                          return(dnew);
219                  }
220                                                  /* else open it ourselves */
221 <                if ((fp = fopen(fname, "rb")) == NULL)
221 >                if ((fp = fopen(inspec, "rb")) == NULL)
222                          return(NULL);
223          }
224   #ifdef getc_unlocked
# Line 246 | Line 254 | rmx_load(const char *fname)
254          case DTascii:
255                  if (!rmx_load_ascii(dnew, fp))
256                          goto loaderr;
257 +                dnew->dtype = DTascii;          /* should leave double? */
258                  break;
259          case DTfloat:
260                  if (!rmx_load_float(dnew, fp))
# Line 266 | Line 275 | rmx_load(const char *fname)
275          default:
276                  goto loaderr;
277          }
278 <        if (fp != stdin)
279 <                fclose(fp);
278 >        if (fp != stdin) {
279 >                if (inspec[0] == '!')
280 >                        pclose(fp);
281 >                else
282 >                        fclose(fp);
283 >        }
284 > #ifdef getc_unlocked
285 >        else
286 >                funlockfile(fp);
287 > #endif
288          return(dnew);
289   loaderr:                                        /* should report error? */
290 <        fclose(fp);
290 >        if (inspec[0] == '!')
291 >                pclose(fp);
292 >        else
293 >                fclose(fp);
294          rmx_free(dnew);
295          return(NULL);
296   }
# Line 356 | Line 376 | rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
376   }
377  
378   /* Write matrix to file type indicated by dtype */
379 < long
379 > int
380   rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
381   {
382          RMATRIX *mydm = NULL;
# Line 371 | Line 391 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
391                  dtype = rm->dtype;
392          else if ((dtype == DTrgbe) & (rm->dtype == DTxyze))
393                  dtype = DTxyze;
394 <        else if ((dtype = DTxyze) & (rm->dtype == DTrgbe))
394 >        else if ((dtype == DTxyze) & (rm->dtype == DTrgbe))
395                  dtype = DTrgbe;
396          if ((dtype != DTrgbe) & (dtype != DTxyze)) {
397                  fprintf(fp, "NROWS=%d\n", rm->nrows);
# Line 409 | Line 429 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
429          }
430          ok &= (fflush(fp) == 0);
431          rmx_free(mydm);
432 <        return(ftell(fp) * ok);         /* return # bytes written */
432 >        return(ok);
433   }
434  
435   /* Allocate and assign square identity matrix with n components */
# Line 417 | Line 437 | RMATRIX *
437   rmx_identity(const int dim, const int n)
438   {
439          RMATRIX *rid = rmx_alloc(dim, dim, n);
440 <        int     i;
440 >        int     i, k;
441  
442          if (rid == NULL)
443                  return(NULL);
444 <        memset(rid->mtx, 0, sizeof(rid->mtx[0])*dim*dim);
444 >        memset(rid->mtx, 0, sizeof(rid->mtx[0])*n*dim*dim);
445          for (i = dim; i--; )
446 <                rmx_lval(rid,i,i,0) = 1;
447 <        for (i = n; --i; )
428 <                memcpy(rid->mtx+i*(dim*dim), rid->mtx,
429 <                                sizeof(rid->mtx[0])*dim*dim);
446 >            for (k = n; k--; )
447 >                rmx_lval(rid,i,i,k) = 1;
448          return(rid);
449   }
450  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines