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.32 by greg, Mon Aug 12 04:46:34 2019 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 161 | 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 186 | 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 201 | 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 209 | 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 236 | 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 344 | Line 344 | rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
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--; )
# Line 367 | 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 391 | 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 419 | 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 430 | 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 445 | 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 464 | 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 == NULL)
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 496 | 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) ||
500 <                        (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 525 | 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) ||
529 <                        (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 582 | 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 604 | 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 615 | 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--; )
# Line 634 | 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];
# Line 665 | 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 688 | 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