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.25 by greg, Mon Aug 28 15:59:46 2017 UTC vs.
Revision 2.33 by greg, Mon Aug 12 18:15:44 2019 UTC

# Line 28 | Line 28 | rmx_alloc(int nr, int nc, int n)
28                  return(NULL);
29          dnew = (RMATRIX *)malloc(sizeof(RMATRIX)-sizeof(dnew->mtx) +
30                                          sizeof(dnew->mtx[0])*(n*nr*nc));
31 <        if (dnew == NULL)
31 >        if (!dnew)
32                  return(NULL);
33          dnew->nrows = nr; dnew->ncols = nc; dnew->ncomp = n;
34          dnew->dtype = DTdouble;
# Line 63 | Line 63 | rmx_newtype(int dtyp1, int dtyp2)
63   int
64   rmx_addinfo(RMATRIX *rm, const char *info)
65   {
66 <        if (!info || !*info)
66 >        if (!rm || !info || !*info)
67                  return(0);
68          if (!rm->info) {
69                  rm->info = (char *)malloc(strlen(info)+1);
# Line 81 | Line 81 | static int
81   get_dminfo(char *s, void *p)
82   {
83          RMATRIX *ip = (RMATRIX *)p;
84 <        char    fmt[64];
84 >        char    fmt[MAXFMTLEN];
85          int     i;
86  
87          if (headidval(fmt, s))
# Line 146 | Line 146 | rmx_load_float(RMATRIX *rm, FILE *fp)
146   static int
147   rmx_load_double(RMATRIX *rm, FILE *fp)
148   {
149 <        int     i, j, k;
150 <        double  val[100];
149 >        int     i, j;
150  
152 –        if (rm->ncomp > 100) {
153 –                fputs("Unsupported # components in rmx_load_double()\n", stderr);
154 –                exit(1);
155 –        }
151          for (i = 0; i < rm->nrows; i++)
152 <            for (j = 0; j < rm->ncols; j++) {
153 <                if (getbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
152 >            for (j = 0; j < rm->ncols; j++)
153 >                if (getbinary(&rmx_lval(rm,i,j,0), sizeof(double), rm->ncomp, fp) != rm->ncomp)
154                      return(0);
160 –                for (k = rm->ncomp; k--; )
161 –                     rmx_lval(rm,i,j,k) = val[k];
162 –            }
155          return(1);
156   }
157  
# Line 169 | Line 161 | rmx_load_rgbe(RMATRIX *rm, FILE *fp)
161          COLOR   *scan = (COLOR *)malloc(sizeof(COLOR)*rm->ncols);
162          int     i, j;
163  
164 <        if (scan == NULL)
164 >        if (!scan)
165                  return(0);
166          for (i = 0; i < rm->nrows; i++) {
167              if (freadscan(scan, rm->ncols, fp) < 0) {
# Line 194 | Line 186 | rmx_load(const char *inspec)
186          RMATRIX         dinfo;
187          RMATRIX         *dnew;
188  
189 <        if (inspec == NULL) {                   /* reading from stdin? */
189 >        if (!inspec) {                          /* reading from stdin? */
190                  inspec = "<stdin>";
191                  SET_FILE_BINARY(stdin);
192          } else if (inspec[0] == '!') {
193 <                if ((fp = popen(inspec+1, "r")) == NULL)
193 >                if (!(fp = popen(inspec+1, "r")))
194                          return(NULL);
195                  SET_FILE_BINARY(stdin);
196          } else {
# Line 209 | Line 201 | rmx_load(const char *inspec)
201                          --sp;
202                  if (!strcasecmp(sp, "XML")) {   /* assume it's a BSDF */
203                          CMATRIX *cm = cm_loadBTDF((char *)inspec);
204 <                        if (cm == NULL)
204 >                        if (!cm)
205                                  return(NULL);
206                          dnew = rmx_from_cmatrix(cm);
207                          cm_free(cm);
# Line 217 | Line 209 | rmx_load(const char *inspec)
209                          return(dnew);
210                  }
211                                                  /* else open it ourselves */
212 <                if ((fp = fopen(inspec, "rb")) == NULL)
212 >                if (!(fp = fopen(inspec, "rb")))
213                          return(NULL);
214          }
215   #ifdef getc_unlocked
# Line 244 | Line 236 | rmx_load(const char *inspec)
236                  }
237          }
238          dnew = rmx_alloc(dinfo.nrows, dinfo.ncols, dinfo.ncomp);
239 <        if (dnew == NULL) {
239 >        if (!dnew) {
240                  fclose(fp);
241                  return(NULL);
242          }
# Line 298 | Line 290 | loaderr:                                       /* should report error? */
290   static int
291   rmx_write_ascii(const RMATRIX *rm, FILE *fp)
292   {
293 +        const char      *fmt = (rm->dtype == DTfloat) ? " %.7e" :
294 +                        (rm->dtype == DTrgbe) | (rm->dtype == DTxyze) ? " %.3e" :
295 +                                " %.15e" ;
296          int     i, j, k;
297  
298          for (i = 0; i < rm->nrows; i++) {
299              for (j = 0; j < rm->ncols; j++) {
300                  for (k = 0; k < rm->ncomp; k++)
301 <                    fprintf(fp, " %.15e", rmx_lval(rm,i,j,k));
301 >                    fprintf(fp, fmt, rmx_lval(rm,i,j,k));
302                  fputc('\t', fp);
303              }
304              fputc('\n', fp);
# Line 334 | Line 329 | rmx_write_float(const RMATRIX *rm, FILE *fp)
329   static int
330   rmx_write_double(const RMATRIX *rm, FILE *fp)
331   {
332 <        int     i, j, k;
338 <        double  val[100];
332 >        int     i, j;
333  
340 –        if (rm->ncomp > 100) {
341 –                fputs("Unsupported # components in rmx_write_double()\n", stderr);
342 –                exit(1);
343 –        }
334          for (i = 0; i < rm->nrows; i++)
335 <            for (j = 0; j < rm->ncols; j++) {
336 <                for (k = rm->ncomp; k--; )
347 <                    val[k] = rmx_lval(rm,i,j,k);
348 <                if (putbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
335 >            for (j = 0; j < rm->ncols; j++)
336 >                if (putbinary(&rmx_lval(rm,i,j,0), sizeof(double), rm->ncomp, fp) != rm->ncomp)
337                          return(0);
350 –            }
338          return(1);
339   }
340  
341   static int
342   rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
343   {
344 <        COLOR   *scan = (COLOR *)malloc(sizeof(COLOR)*rm->ncols);
344 >        COLR    *scan = (COLR *)malloc(sizeof(COLR)*rm->ncols);
345          int     i, j;
346  
347 <        if (scan == NULL)
347 >        if (!scan)
348                  return(0);
349          for (i = 0; i < rm->nrows; i++) {
350              for (j = rm->ncols; j--; )
351 <                setcolor(scan[j],       rmx_lval(rm,i,j,0),
351 >                setcolr(scan[j],        rmx_lval(rm,i,j,0),
352                                          rmx_lval(rm,i,j,1),
353                                          rmx_lval(rm,i,j,2)      );
354 <            if (fwritescan(scan, rm->ncols, fp) < 0) {
354 >            if (fwritecolrs(scan, rm->ncols, fp) < 0) {
355                  free(scan);
356                  return(0);
357              }
# Line 380 | Line 367 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
367          RMATRIX *mydm = NULL;
368          int     ok = 1;
369  
370 <        if ((rm == NULL) | (fp == NULL))
370 >        if (!rm | !fp)
371                  return(0);
372   #ifdef getc_unlocked
373          flockfile(fp);
# Line 404 | Line 391 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
391                          return(0);
392                  cmtx[0] = cmtx[1] = cmtx[2] = 1;
393                  mydm = rmx_transform(rm, 3, cmtx);
394 <                if (mydm == NULL)
394 >                if (!mydm)
395                          return(0);
396                  rm = mydm;
397          }
# Line 432 | Line 419 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
419   #ifdef getc_unlocked
420          funlockfile(fp);
421   #endif
422 <        rmx_free(mydm);
422 >        if (mydm)
423 >                rmx_free(mydm);
424          return(ok);
425   }
426  
# Line 443 | Line 431 | rmx_identity(const int dim, const int n)
431          RMATRIX *rid = rmx_alloc(dim, dim, n);
432          int     i, k;
433  
434 <        if (rid == NULL)
434 >        if (!rid)
435                  return(NULL);
436          memset(rid->mtx, 0, sizeof(rid->mtx[0])*n*dim*dim);
437          for (i = dim; i--; )
# Line 458 | Line 446 | rmx_copy(const RMATRIX *rm)
446   {
447          RMATRIX *dnew;
448  
449 <        if (rm == NULL)
449 >        if (!rm)
450                  return(NULL);
451          dnew = rmx_alloc(rm->nrows, rm->ncols, rm->ncomp);
452 <        if (dnew == NULL)
452 >        if (!dnew)
453                  return(NULL);
454          rmx_addinfo(dnew, rm->info);
455          dnew->dtype = rm->dtype;
# Line 477 | Line 465 | rmx_transpose(const RMATRIX *rm)
465          RMATRIX *dnew;
466          int     i, j, k;
467  
468 <        if (rm == NULL)
468 >        if (!rm)
469                  return(0);
470 +        if ((rm->nrows == 1) | (rm->ncols == 1)) {
471 +                dnew = rmx_copy(rm);
472 +                if (!dnew)
473 +                        return(NULL);
474 +                dnew->nrows = rm->ncols;
475 +                dnew->ncols = rm->nrows;
476 +                return(dnew);
477 +        }
478          dnew = rmx_alloc(rm->ncols, rm->nrows, rm->ncomp);
479 <        if (dnew == NULL)
479 >        if (!dnew)
480                  return(NULL);
481          if (rm->info) {
482                  rmx_addinfo(dnew, rm->info);
# Line 501 | Line 497 | rmx_multiply(const RMATRIX *m1, const RMATRIX *m2)
497          RMATRIX *mres;
498          int     i, j, k, h;
499  
500 <        if ((m1 == NULL) | (m2 == NULL) ||
505 <                        (m1->ncomp != m2->ncomp) | (m1->ncols != m2->nrows))
500 >        if (!m1 | !m2 || (m1->ncomp != m2->ncomp) | (m1->ncols != m2->nrows))
501                  return(NULL);
502          mres = rmx_alloc(m1->nrows, m2->ncols, m1->ncomp);
503 <        if (mres == NULL)
503 >        if (!mres)
504                  return(NULL);
505          i = rmx_newtype(m1->dtype, m2->dtype);
506          if (i)
# Line 530 | Line 525 | rmx_elemult(RMATRIX *m1, const RMATRIX *m2, int divide
525          int     zeroDivides = 0;
526          int     i, j, k;
527  
528 <        if ((m1 == NULL) | (m2 == NULL) ||
534 <                        (m1->ncols != m2->ncols) | (m1->nrows != m2->nrows))
528 >        if (!m1 | !m2 || (m1->ncols != m2->ncols) | (m1->nrows != m2->nrows))
529                  return(0);
530          if ((m2->ncomp > 1) & (m2->ncomp != m1->ncomp))
531                  return(0);
# Line 587 | Line 581 | rmx_sum(RMATRIX *msum, const RMATRIX *madd, const doub
581          double  *mysf = NULL;
582          int     i, j, k;
583  
584 <        if ((msum == NULL) | (madd == NULL) ||
584 >        if (!msum | !madd ||
585                          (msum->nrows != madd->nrows) |
586                          (msum->ncols != madd->ncols) |
587                          (msum->ncomp != madd->ncomp))
588                  return(0);
589 <        if (sf == NULL) {
589 >        if (!sf) {
590                  mysf = (double *)malloc(sizeof(double)*msum->ncomp);
591 <                if (mysf == NULL)
591 >                if (!mysf)
592                          return(0);
593                  for (k = msum->ncomp; k--; )
594                          mysf[k] = 1;
# Line 609 | Line 603 | rmx_sum(RMATRIX *msum, const RMATRIX *madd, const doub
603              for (j = msum->ncols; j--; )
604                  for (k = msum->ncomp; k--; )
605                       rmx_lval(msum,i,j,k) += sf[k] * rmx_lval(madd,i,j,k);
606 <
607 <        free(mysf);
606 >        if (mysf)
607 >                free(mysf);
608          return(1);
609   }
610  
# Line 620 | Line 614 | rmx_scale(RMATRIX *rm, const double sf[])
614   {
615          int     i, j, k;
616  
617 <        if ((rm == NULL) | (sf == NULL))
617 >        if (!rm | !sf)
618                  return(0);
619          for (i = rm->nrows; i--; )
620              for (j = rm->ncols; j--; )
621                  for (k = rm->ncomp; k--; )
622                      rmx_lval(rm,i,j,k) *= sf[k];
623  
624 +        if (rm->info)
625 +                rmx_addinfo(rm, "Applied scalar\n");
626          return(1);
627   }
628  
# Line 637 | Line 633 | rmx_transform(const RMATRIX *msrc, int n, const double
633          int     i, j, ks, kd;
634          RMATRIX *dnew;
635  
636 <        if ((msrc == NULL) | (n <= 0) | (cmat == NULL))
636 >        if (!msrc | (n <= 0) | !cmat)
637                  return(NULL);
638          dnew = rmx_alloc(msrc->nrows, msrc->ncols, n);
639 <        if (dnew == NULL)
639 >        if (!dnew)
640                  return(NULL);
641 +        if (msrc->info) {
642 +                char    buf[128];
643 +                sprintf(buf, "Applied %dx%d matrix transform\n",
644 +                                dnew->ncomp, msrc->ncomp);
645 +                rmx_addinfo(dnew, msrc->info);
646 +                rmx_addinfo(dnew, buf);
647 +        }
648          dnew->dtype = msrc->dtype;
649          for (i = dnew->nrows; i--; )
650              for (j = dnew->ncols; j--; )
# Line 661 | Line 664 | rmx_from_cmatrix(const CMATRIX *cm)
664          int     i, j;
665          RMATRIX *dnew;
666  
667 <        if (cm == NULL)
667 >        if (!cm)
668                  return(NULL);
669          dnew = rmx_alloc(cm->nrows, cm->ncols, 3);
670 <        if (dnew == NULL)
670 >        if (!dnew)
671                  return(NULL);
672          dnew->dtype = DTfloat;
673          for (i = dnew->nrows; i--; )
# Line 684 | Line 687 | cm_from_rmatrix(const RMATRIX *rm)
687          int     i, j;
688          CMATRIX *cnew;
689  
690 <        if (rm == NULL || rm->ncomp != 3)
690 >        if (!rm || rm->ncomp != 3)
691                  return(NULL);
692          cnew = cm_alloc(rm->nrows, rm->ncols);
693 <        if (cnew == NULL)
693 >        if (!cnew)
694                  return(NULL);
695          for (i = cnew->nrows; i--; )
696              for (j = cnew->ncols; j--; ) {

Diff Legend

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