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

Comparing ray/src/util/rmatrix.c (file contents):
Revision 2.5 by greg, Fri Aug 1 23:37:24 2014 UTC vs.
Revision 2.6 by greg, Sat Aug 2 17:10:43 2014 UTC

# Line 12 | Line 12 | static const char RCSid[] = "$Id$";
12   #include "resolu.h"
13   #include "rmatrix.h"
14  
15 < #define MAX_INFO        16000
15 > static char     rmx_mismatch_warn[] = "WARNING: data type mismatch\n";
16  
17 – typedef struct {
18 –        int     nrows, ncols, ncomp;
19 –        int     dtype;
20 –        int     info_len;
21 –        char    info[MAX_INFO];
22 – } DMINFO;
23 –
17   /* Allocate a nr x nc matrix with n components */
18   RMATRIX *
19   rmx_alloc(int nr, int nc, int n)
# Line 34 | Line 27 | rmx_alloc(int nr, int nc, int n)
27          if (dnew == NULL)
28                  return(NULL);
29          dnew->nrows = nr; dnew->ncols = nc; dnew->ncomp = n;
30 +        dnew->dtype = DTdouble;
31          dnew->info = NULL;
32          return(dnew);
33   }
34  
35 + /* Free a RMATRIX array */
36 + void
37 + rmx_free(RMATRIX *rm)
38 + {
39 +        if (!rm) return;
40 +        if (rm->info)
41 +                free(rm->info);
42 +        free(rm);
43 + }
44 +
45 + /* Resolve data type based on two input types (returns 0 for mismatch) */
46 + int
47 + rmx_newtype(int dtyp1, int dtyp2)
48 + {
49 +        if ((dtyp1==DTxyze) | (dtyp1==DTrgbe) && dtyp1 != dtyp2)
50 +                return(0);
51 +        if (dtyp1 < dtyp2)
52 +                return(dtyp1);
53 +        return(dtyp2);
54 + }
55 +
56   /* Append header information associated with matrix data */
57   int
58   rmx_addinfo(RMATRIX *rm, const char *info)
# Line 58 | Line 73 | rmx_addinfo(RMATRIX *rm, const char *info)
73   static int
74   get_dminfo(char *s, void *p)
75   {
76 <        DMINFO  *ip = (DMINFO *)p;
76 >        RMATRIX *ip = (RMATRIX *)p;
77          char    fmt[64];
78          int     i;
79  
80 +        if (headidval(fmt, s))
81 +                return(0);
82          if (!strncmp(s, "NCOMP=", 6)) {
83                  ip->ncomp = atoi(s+6);
84                  return(0);
# Line 75 | Line 92 | get_dminfo(char *s, void *p)
92                  return(0);
93          }
94          if (!formatval(fmt, s)) {
95 <                if (headidval(fmt, s))
79 <                        return(0);
80 <                while (*s) {
81 <                        if (ip->info_len == MAX_INFO-2 &&
82 <                                        ip->info[MAX_INFO-3] != '\n')
83 <                                ip->info[ip->info_len++] = '\n';
84 <                        if (ip->info_len >= MAX_INFO-1)
85 <                                break;
86 <                        ip->info[ip->info_len++] = *s++;
87 <                }
88 <                ip->info[ip->info_len] = '\0';
95 >                rmx_addinfo(ip, s);
96                  return(0);
97          }
98          for (i = 1; i < DTend; i++)
# Line 179 | Line 186 | RMATRIX *
186   rmx_load(const char *fname)
187   {
188          FILE            *fp = stdin;
189 <        DMINFO          dinfo;
189 >        RMATRIX         dinfo;
190          RMATRIX         *dnew;
191  
192          if (fname == NULL) {                    /* reading from stdin? */
# Line 206 | Line 213 | rmx_load(const char *fname)
213          flockfile(fp);
214   #endif
215          dinfo.nrows = dinfo.ncols = dinfo.ncomp = 0;
216 <        dinfo.dtype = DTascii;
217 <        dinfo.info_len = 0;
216 >        dinfo.dtype = DTascii;                  /* assumed w/o FORMAT */
217 >        dinfo.info = NULL;
218          if (getheader(fp, get_dminfo, &dinfo) < 0) {
219                  fclose(fp);
220                  return(NULL);
# Line 230 | Line 237 | rmx_load(const char *fname)
237                  fclose(fp);
238                  return(NULL);
239          }
240 <        if (dinfo.info_len)
234 <                rmx_addinfo(dnew, dinfo.info);
240 >        dnew->info = dinfo.info;
241          switch (dinfo.dtype) {
242          case DTascii:
243                  if (!rmx_load_ascii(dnew, fp))
# Line 240 | Line 246 | rmx_load(const char *fname)
246          case DTfloat:
247                  if (!rmx_load_float(dnew, fp))
248                          goto loaderr;
249 +                dnew->dtype = DTfloat;
250                  break;
251          case DTdouble:
252                  if (!rmx_load_double(dnew, fp))
253                          goto loaderr;
254 +                dnew->dtype = DTdouble;
255                  break;
256          case DTrgbe:
257          case DTxyze:
258                  if (!rmx_load_rgbe(dnew, fp))
259                          goto loaderr;
260 +                dnew->dtype = dinfo.dtype;
261                  break;
262          default:
263                  goto loaderr;
# Line 342 | Line 351 | rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
351          return(1);
352   }
353  
354 < /* Write matrix to file type indicated by dt */
354 > /* Write matrix to file type indicated by dtype */
355   long
356   rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
357   {
# Line 354 | Line 363 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
363                                                  /* complete header */
364          if (rm->info)
365                  fputs(rm->info, fp);
366 +        if (dtype == DTfromHeader)
367 +                dtype = rm->dtype;
368 +        else if ((dtype == DTrgbe) & (rm->dtype == DTxyze))
369 +                dtype = DTxyze;
370 +        else if ((dtype = DTxyze) & (rm->dtype == DTrgbe))
371 +                dtype = DTrgbe;
372          if ((dtype != DTrgbe) & (dtype != DTxyze)) {
373                  fprintf(fp, "NROWS=%d\n", rm->nrows);
374                  fprintf(fp, "NCOLS=%d\n", rm->ncols);
# Line 423 | Line 438 | rmx_copy(const RMATRIX *rm)
438          if (dnew == NULL)
439                  return(NULL);
440          rmx_addinfo(dnew, rm->info);
441 +        dnew->dtype = rm->dtype;
442          memcpy(dnew->mtx, rm->mtx,
443                  sizeof(rm->mtx[0])*rm->ncomp*rm->nrows*rm->ncols);
444          return(dnew);
# Line 444 | Line 460 | rmx_transpose(const RMATRIX *rm)
460                  rmx_addinfo(dnew, rm->info);
461                  rmx_addinfo(dnew, "Transposed rows and columns\n");
462          }
463 +        dnew->dtype = rm->dtype;
464          for (i = dnew->nrows; i--; )
465              for (j = dnew->ncols; j--; )
466                  for (k = dnew->ncomp; k--; )
# Line 464 | Line 481 | rmx_multiply(const RMATRIX *m1, const RMATRIX *m2)
481          mres = rmx_alloc(m1->nrows, m2->ncols, m1->ncomp);
482          if (mres == NULL)
483                  return(NULL);
484 +        i = rmx_newtype(m1->dtype, m2->dtype);
485 +        if (i)
486 +                mres->dtype = i;
487 +        else
488 +                rmx_addinfo(mres, rmx_mismatch_warn);
489          for (i = mres->nrows; i--; )
490              for (j = mres->ncols; j--; )
491                  for (h = m1->ncols; h--; ) {
# Line 496 | Line 518 | rmx_sum(RMATRIX *msum, const RMATRIX *madd, const doub
518                          mysf[k] = 1;
519                  sf = mysf;
520          }
521 +        i = rmx_newtype(msum->dtype, madd->dtype);
522 +        if (i)
523 +                msum->dtype = i;
524 +        else
525 +                rmx_addinfo(msum, rmx_mismatch_warn);
526          for (i = msum->nrows; i--; )
527              for (j = msum->ncols; j--; )
528                  for (k = msum->ncomp; k--; )
# Line 533 | Line 560 | rmx_transform(const RMATRIX *msrc, int n, const double
560          dnew = rmx_alloc(msrc->nrows, msrc->ncols, n);
561          if (dnew == NULL)
562                  return(NULL);
563 +        dnew->dtype = msrc->dtype;
564          for (i = dnew->nrows; i--; )
565              for (j = dnew->ncols; j--; )
566                  for (kd = dnew->ncomp; kd--; ) {
# Line 556 | Line 584 | rmx_from_cmatrix(const CMATRIX *cm)
584          dnew = rmx_alloc(cm->nrows, cm->ncols, 3);
585          if (dnew == NULL)
586                  return(NULL);
587 +        dnew->dtype = DTfloat;
588          for (i = dnew->nrows; i--; )
589              for (j = dnew->ncols; j--; ) {
590                  const COLORV    *cv = cm_lval(cm,i,j);

Diff Legend

– Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)