32 |
|
dnew->nrows = nr; |
33 |
|
dnew->ncols = nc; |
34 |
|
dnew->ncomp = n; |
35 |
+ |
setcolor(dnew->cexp, 1.f, 1.f, 1.f); |
36 |
|
} |
37 |
|
return(dnew); |
38 |
|
} |
119 |
|
char fmt[MAXFMTLEN]; |
120 |
|
int i; |
121 |
|
|
122 |
< |
if (headidval(fmt, s)) |
122 |
> |
if (headidval(NULL, s)) |
123 |
|
return(0); |
124 |
|
if (!strncmp(s, "NCOMP=", 6)) { |
125 |
|
ip->ncomp = atoi(s+6); |
138 |
|
return(0); |
139 |
|
} |
140 |
|
if (isexpos(s)) { |
141 |
< |
double d = exposval(s); |
142 |
< |
scalecolor(ip->cexp, d); |
141 |
> |
float f = exposval(s); |
142 |
> |
scalecolor(ip->cexp, f); |
143 |
|
return(0); |
144 |
|
} |
145 |
|
if (iscolcor(s)) { |
168 |
|
if (!rmx_prepare(rm)) |
169 |
|
return(0); |
170 |
|
for (i = 0; i < rm->nrows; i++) |
171 |
< |
for (j = 0; j < rm->ncols; j++) |
171 |
> |
for (j = 0; j < rm->ncols; j++) { |
172 |
> |
double *dp = rmx_lval(rm,i,j); |
173 |
|
for (k = 0; k < rm->ncomp; k++) |
174 |
< |
if (fscanf(fp, "%lf", &rmx_lval(rm,i,j,k)) != 1) |
174 |
> |
if (fscanf(fp, "%lf", &dp[k]) != 1) |
175 |
|
return(0); |
176 |
+ |
} |
177 |
|
return(1); |
178 |
|
} |
179 |
|
|
191 |
|
return(0); |
192 |
|
for (i = 0; i < rm->nrows; i++) |
193 |
|
for (j = 0; j < rm->ncols; j++) { |
194 |
+ |
double *dp = rmx_lval(rm,i,j); |
195 |
|
if (getbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp) |
196 |
|
return(0); |
197 |
|
if (rm->swapin) |
198 |
|
swap32((char *)val, rm->ncomp); |
199 |
|
for (k = rm->ncomp; k--; ) |
200 |
< |
rmx_lval(rm,i,j,k) = val[k]; |
200 |
> |
dp[k] = val[k]; |
201 |
|
} |
202 |
|
return(1); |
203 |
|
} |
207 |
|
{ |
208 |
|
int i; |
209 |
|
#ifdef MAP_FILE |
210 |
< |
long pos; /* map memory to file if possible */ |
211 |
< |
if (!rm->swapin && (pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) { |
210 |
> |
long pos; /* map memory for file > 1MB if possible */ |
211 |
> |
if (!rm->swapin && array_size(rm) >= 1L<<20 && |
212 |
> |
(pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) { |
213 |
|
rm->mapped = mmap(NULL, array_size(rm)+pos, PROT_READ|PROT_WRITE, |
214 |
|
MAP_PRIVATE, fileno(fp), 0); |
215 |
|
if (rm->mapped != MAP_FAILED) { |
216 |
|
rm->mtx = (double *)rm->mapped + pos/sizeof(double); |
217 |
|
return(1); |
218 |
< |
} |
218 |
> |
} /* else fall back on reading into memory */ |
219 |
|
rm->mapped = NULL; |
220 |
|
} |
221 |
|
#endif |
222 |
|
if (!rmx_prepare(rm)) |
223 |
|
return(0); |
224 |
|
for (i = 0; i < rm->nrows; i++) { |
225 |
< |
if (getbinary(&rmx_lval(rm,i,0,0), sizeof(double)*rm->ncomp, |
225 |
> |
if (getbinary(rmx_lval(rm,i,0), sizeof(double)*rm->ncomp, |
226 |
|
rm->ncols, fp) != rm->ncols) |
227 |
|
return(0); |
228 |
|
if (rm->swapin) |
229 |
< |
swap64((char *)&rmx_lval(rm,i,0,0), rm->ncols*rm->ncomp); |
229 |
> |
swap64((char *)rmx_lval(rm,i,0), rm->ncols*rm->ncomp); |
230 |
|
} |
231 |
|
return(1); |
232 |
|
} |
242 |
|
if (!rmx_prepare(rm)) |
243 |
|
return(0); |
244 |
|
for (i = 0; i < rm->nrows; i++) { |
245 |
+ |
double *dp = rmx_lval(rm,i,0); |
246 |
|
if (freadscan(scan, rm->ncols, fp) < 0) { |
247 |
|
free(scan); |
248 |
|
return(0); |
249 |
|
} |
250 |
< |
for (j = rm->ncols; j--; ) { |
251 |
< |
rmx_lval(rm,i,j,0) = colval(scan[j],RED); |
252 |
< |
rmx_lval(rm,i,j,1) = colval(scan[j],GRN); |
253 |
< |
rmx_lval(rm,i,j,2) = colval(scan[j],BLU); |
250 |
> |
for (j = 0; j < rm->ncols; j++, dp += 3) { |
251 |
> |
dp[0] = colval(scan[j],RED); |
252 |
> |
dp[1] = colval(scan[j],GRN); |
253 |
> |
dp[2] = colval(scan[j],BLU); |
254 |
|
} |
255 |
|
} |
256 |
|
free(scan); |
302 |
|
return(NULL); |
303 |
|
} |
304 |
|
dnew->dtype = DTascii; /* assumed w/o FORMAT */ |
299 |
– |
dnew->cexp[0] = dnew->cexp[1] = dnew->cexp[2] = 1.f; |
305 |
|
if (getheader(fp, get_dminfo, dnew) < 0) { |
306 |
|
fclose(fp); |
307 |
|
return(NULL); |
338 |
|
case DTxyze: |
339 |
|
if (!rmx_load_rgbe(dnew, fp)) |
340 |
|
goto loaderr; |
336 |
– |
/* undo exposure? */ |
337 |
– |
if ((dnew->cexp[0] != 1.f) | (dnew->cexp[1] != 1.f) | |
338 |
– |
(dnew->cexp[2] != 1.f)) { |
339 |
– |
double cmlt[3]; |
340 |
– |
cmlt[0] = 1./dnew->cexp[0]; |
341 |
– |
cmlt[1] = 1./dnew->cexp[1]; |
342 |
– |
cmlt[2] = 1./dnew->cexp[2]; |
343 |
– |
rmx_scale(dnew, cmlt); |
344 |
– |
} |
345 |
– |
dnew->swapin = 0; |
341 |
|
break; |
342 |
|
default: |
343 |
|
goto loaderr; |
352 |
|
else |
353 |
|
funlockfile(fp); |
354 |
|
#endif |
355 |
+ |
/* undo exposure? */ |
356 |
+ |
if (dnew->ncomp == 3 && (dnew->cexp[0] != 1.f) | |
357 |
+ |
(dnew->cexp[1] != 1.f) | (dnew->cexp[2] != 1.f)) { |
358 |
+ |
double cmlt[3]; |
359 |
+ |
cmlt[0] = 1./dnew->cexp[0]; |
360 |
+ |
cmlt[1] = 1./dnew->cexp[1]; |
361 |
+ |
cmlt[2] = 1./dnew->cexp[2]; |
362 |
+ |
rmx_scale(dnew, cmlt); |
363 |
+ |
setcolor(dnew->cexp, 1.f, 1.f, 1.f); |
364 |
+ |
} |
365 |
|
return(dnew); |
366 |
|
loaderr: /* should report error? */ |
367 |
|
if (inspec[0] == '!') |
382 |
|
|
383 |
|
for (i = 0; i < rm->nrows; i++) { |
384 |
|
for (j = 0; j < rm->ncols; j++) { |
385 |
+ |
const double *dp = rmx_lval(rm,i,j); |
386 |
|
for (k = 0; k < rm->ncomp; k++) |
387 |
< |
fprintf(fp, fmt, rmx_lval(rm,i,j,k)); |
387 |
> |
fprintf(fp, fmt, dp[k]); |
388 |
|
fputc('\t', fp); |
389 |
|
} |
390 |
|
fputc('\n', fp); |
404 |
|
} |
405 |
|
for (i = 0; i < rm->nrows; i++) |
406 |
|
for (j = 0; j < rm->ncols; j++) { |
407 |
+ |
const double *dp = rmx_lval(rm,i,j); |
408 |
|
for (k = rm->ncomp; k--; ) |
409 |
< |
val[k] = (float)rmx_lval(rm,i,j,k); |
410 |
< |
if (putbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp) |
409 |
> |
val[k] = (float)dp[k]; |
410 |
> |
if (putbinary(val, sizeof(float), rm->ncomp, fp) != rm->ncomp) |
411 |
|
return(0); |
412 |
|
} |
413 |
|
return(1); |
416 |
|
static int |
417 |
|
rmx_write_double(const RMATRIX *rm, FILE *fp) |
418 |
|
{ |
419 |
< |
int i, j; |
419 |
> |
int i; |
420 |
|
|
421 |
|
for (i = 0; i < rm->nrows; i++) |
422 |
< |
for (j = 0; j < rm->ncols; j++) |
423 |
< |
if (putbinary(&rmx_lval(rm,i,j,0), sizeof(double), rm->ncomp, fp) != rm->ncomp) |
422 |
> |
if (putbinary(rmx_lval(rm,i,0), sizeof(double)*rm->ncomp, |
423 |
> |
rm->ncols, fp) != rm->ncols) |
424 |
|
return(0); |
425 |
|
return(1); |
426 |
|
} |
434 |
|
if (!scan) |
435 |
|
return(0); |
436 |
|
for (i = 0; i < rm->nrows; i++) { |
437 |
< |
for (j = rm->ncols; j--; ) |
438 |
< |
setcolr(scan[j], rmx_lval(rm,i,j,0), |
439 |
< |
rmx_lval(rm,i,j,1), |
440 |
< |
rmx_lval(rm,i,j,2) ); |
437 |
> |
for (j = rm->ncols; j--; ) { |
438 |
> |
const double *dp = rmx_lval(rm,i,j); |
439 |
> |
if (rm->ncomp == 1) |
440 |
> |
setcolr(scan[j], dp[0], dp[0], dp[0]); |
441 |
> |
else |
442 |
> |
setcolr(scan[j], dp[0], dp[1], dp[2]); |
443 |
> |
} |
444 |
|
if (fwritecolrs(scan, rm->ncols, fp) < 0) { |
445 |
|
free(scan); |
446 |
|
return(0); |
471 |
|
int |
472 |
|
rmx_write(const RMATRIX *rm, int dtype, FILE *fp) |
473 |
|
{ |
464 |
– |
RMATRIX *mydm = NULL; |
474 |
|
int ok = 1; |
475 |
|
|
476 |
< |
if (!rm | !fp) |
476 |
> |
if (!rm | !fp || !rm->mtx) |
477 |
|
return(0); |
478 |
|
#ifdef getc_unlocked |
479 |
|
flockfile(fp); |
488 |
|
dtype = DTxyze; |
489 |
|
else if ((dtype == DTxyze) & (rm->dtype == DTrgbe)) |
490 |
|
dtype = DTrgbe; |
491 |
+ |
if (rm->ncomp == 3) { /* write exposure? */ |
492 |
+ |
if ((rm->cexp[RED] != rm->cexp[GRN]) | |
493 |
+ |
(rm->cexp[GRN] != rm->cexp[BLU])) |
494 |
+ |
fputcolcor(rm->cexp, fp); |
495 |
+ |
else if (rm->cexp[GRN] != 1.f) |
496 |
+ |
fputexpos(rm->cexp[GRN], fp); |
497 |
+ |
} |
498 |
|
if ((dtype != DTrgbe) & (dtype != DTxyze)) { |
499 |
|
fprintf(fp, "NROWS=%d\n", rm->nrows); |
500 |
|
fprintf(fp, "NCOLS=%d\n", rm->ncols); |
501 |
|
fprintf(fp, "NCOMP=%d\n", rm->ncomp); |
502 |
< |
} else if (rm->ncomp != 3) { /* wrong # components? */ |
503 |
< |
double cmtx[3]; |
488 |
< |
if (rm->ncomp != 1) /* only convert grayscale */ |
489 |
< |
return(0); |
490 |
< |
cmtx[0] = cmtx[1] = cmtx[2] = 1; |
491 |
< |
mydm = rmx_transform(rm, 3, cmtx); |
492 |
< |
if (!mydm) |
493 |
< |
return(0); |
494 |
< |
rm = mydm; |
495 |
< |
} |
502 |
> |
} else if ((rm->ncomp != 3) & (rm->ncomp != 1)) |
503 |
> |
return(0); /* wrong # components */ |
504 |
|
if ((dtype == DTfloat) | (dtype == DTdouble)) |
505 |
|
fputendian(fp); /* important to record */ |
506 |
|
fputformat(cm_fmt_id[dtype], fp); |
527 |
|
#ifdef getc_unlocked |
528 |
|
funlockfile(fp); |
529 |
|
#endif |
522 |
– |
if (mydm) |
523 |
– |
rmx_free(mydm); |
530 |
|
return(ok); |
531 |
|
} |
532 |
|
|
539 |
|
|
540 |
|
if (!rid) |
541 |
|
return(NULL); |
542 |
< |
memset(rid->mtx, 0, sizeof(rid->mtx[0])*n*dim*dim); |
543 |
< |
for (i = dim; i--; ) |
542 |
> |
memset(rid->mtx, 0, array_size(rid)); |
543 |
> |
for (i = dim; i--; ) { |
544 |
> |
double *dp = rmx_lval(rid,i,i); |
545 |
|
for (k = n; k--; ) |
546 |
< |
rmx_lval(rid,i,i,k) = 1; |
546 |
> |
dp[k] = 1.; |
547 |
> |
} |
548 |
|
return(rid); |
549 |
|
} |
550 |
|
|
561 |
|
return(NULL); |
562 |
|
rmx_addinfo(dnew, rm->info); |
563 |
|
dnew->dtype = rm->dtype; |
564 |
< |
memcpy(dnew->mtx, rm->mtx, |
557 |
< |
sizeof(rm->mtx[0])*rm->ncomp*rm->nrows*rm->ncols); |
564 |
> |
memcpy(dnew->mtx, rm->mtx, array_size(dnew)); |
565 |
|
return(dnew); |
566 |
|
} |
567 |
|
|
570 |
|
rmx_transpose(const RMATRIX *rm) |
571 |
|
{ |
572 |
|
RMATRIX *dnew; |
573 |
< |
int i, j, k; |
573 |
> |
int i, j; |
574 |
|
|
575 |
|
if (!rm) |
576 |
|
return(0); |
590 |
|
rmx_addinfo(dnew, "Transposed rows and columns\n"); |
591 |
|
} |
592 |
|
dnew->dtype = rm->dtype; |
593 |
< |
for (i = dnew->nrows; i--; ) |
594 |
< |
for (j = dnew->ncols; j--; ) |
595 |
< |
for (k = dnew->ncomp; k--; ) |
596 |
< |
rmx_lval(dnew,i,j,k) = rmx_lval(rm,j,i,k); |
593 |
> |
for (j = dnew->ncols; j--; ) |
594 |
> |
for (i = dnew->nrows; i--; ) |
595 |
> |
memcpy(rmx_lval(dnew,i,j), rmx_lval(rm,j,i), |
596 |
> |
sizeof(double)*dnew->ncomp); |
597 |
|
return(dnew); |
598 |
|
} |
599 |
|
|
617 |
|
for (i = mres->nrows; i--; ) |
618 |
|
for (j = mres->ncols; j--; ) |
619 |
|
for (k = mres->ncomp; k--; ) { |
620 |
< |
long double d = 0; |
620 |
> |
double d = 0; |
621 |
|
for (h = m1->ncols; h--; ) |
622 |
< |
d += rmx_lval(m1,i,h,k) * rmx_lval(m2,h,j,k); |
623 |
< |
rmx_lval(mres,i,j,k) = (double)d; |
622 |
> |
d += rmx_lval(m1,i,h)[k] * rmx_lval(m2,h,j)[k]; |
623 |
> |
rmx_lval(mres,i,j)[k] = d; |
624 |
|
} |
625 |
|
return(mres); |
626 |
|
} |
646 |
|
if (divide) { |
647 |
|
double d; |
648 |
|
if (m2->ncomp == 1) { |
649 |
< |
d = rmx_lval(m2,i,j,0); |
649 |
> |
d = rmx_lval(m2,i,j)[0]; |
650 |
|
if (d == 0) { |
651 |
|
++zeroDivides; |
652 |
|
for (k = m1->ncomp; k--; ) |
653 |
< |
rmx_lval(m1,i,j,k) = 0; |
653 |
> |
rmx_lval(m1,i,j)[k] = 0; |
654 |
|
} else { |
655 |
|
d = 1./d; |
656 |
|
for (k = m1->ncomp; k--; ) |
657 |
< |
rmx_lval(m1,i,j,k) *= d; |
657 |
> |
rmx_lval(m1,i,j)[k] *= d; |
658 |
|
} |
659 |
|
} else |
660 |
|
for (k = m1->ncomp; k--; ) { |
661 |
< |
d = rmx_lval(m2,i,j,k); |
661 |
> |
d = rmx_lval(m2,i,j)[k]; |
662 |
|
if (d == 0) { |
663 |
|
++zeroDivides; |
664 |
< |
rmx_lval(m1,i,j,k) = 0; |
664 |
> |
rmx_lval(m1,i,j)[k] = 0; |
665 |
|
} else |
666 |
< |
rmx_lval(m1,i,j,k) /= d; |
666 |
> |
rmx_lval(m1,i,j)[k] /= d; |
667 |
|
} |
668 |
|
} else { |
669 |
|
if (m2->ncomp == 1) { |
670 |
< |
const double d = rmx_lval(m2,i,j,0); |
670 |
> |
const double d = rmx_lval(m2,i,j)[0]; |
671 |
|
for (k = m1->ncomp; k--; ) |
672 |
< |
rmx_lval(m1,i,j,k) *= d; |
672 |
> |
rmx_lval(m1,i,j)[k] *= d; |
673 |
|
} else |
674 |
|
for (k = m1->ncomp; k--; ) |
675 |
< |
rmx_lval(m1,i,j,k) *= rmx_lval(m2,i,j,k); |
675 |
> |
rmx_lval(m1,i,j)[k] *= rmx_lval(m2,i,j)[k]; |
676 |
|
} |
677 |
|
if (zeroDivides) { |
678 |
|
rmx_addinfo(m1, "WARNING: zero divide(s) corrupted results\n"); |
707 |
|
else |
708 |
|
rmx_addinfo(msum, rmx_mismatch_warn); |
709 |
|
for (i = msum->nrows; i--; ) |
710 |
< |
for (j = msum->ncols; j--; ) |
710 |
> |
for (j = msum->ncols; j--; ) { |
711 |
> |
const double *da = rmx_lval(madd,i,j); |
712 |
> |
double *ds = rmx_lval(msum,i,j); |
713 |
|
for (k = msum->ncomp; k--; ) |
714 |
< |
rmx_lval(msum,i,j,k) += sf[k] * rmx_lval(madd,i,j,k); |
714 |
> |
ds[k] += sf[k] * da[k]; |
715 |
> |
} |
716 |
|
if (mysf) |
717 |
|
free(mysf); |
718 |
|
return(1); |
727 |
|
if (!rm | !sf) |
728 |
|
return(0); |
729 |
|
for (i = rm->nrows; i--; ) |
730 |
< |
for (j = rm->ncols; j--; ) |
730 |
> |
for (j = rm->ncols; j--; ) { |
731 |
> |
double *dp = rmx_lval(rm,i,j); |
732 |
|
for (k = rm->ncomp; k--; ) |
733 |
< |
rmx_lval(rm,i,j,k) *= sf[k]; |
734 |
< |
|
733 |
> |
dp[k] *= sf[k]; |
734 |
> |
} |
735 |
|
if (rm->info) |
736 |
|
rmx_addinfo(rm, "Applied scalar\n"); |
737 |
|
return(1); |
758 |
|
} |
759 |
|
dnew->dtype = msrc->dtype; |
760 |
|
for (i = dnew->nrows; i--; ) |
761 |
< |
for (j = dnew->ncols; j--; ) |
761 |
> |
for (j = dnew->ncols; j--; ) { |
762 |
> |
const double *ds = rmx_lval(msrc,i,j); |
763 |
|
for (kd = dnew->ncomp; kd--; ) { |
764 |
|
double d = 0; |
765 |
|
for (ks = msrc->ncomp; ks--; ) |
766 |
< |
d += cmat[kd*msrc->ncomp + ks] * rmx_lval(msrc,i,j,ks); |
767 |
< |
rmx_lval(dnew,i,j,kd) = d; |
766 |
> |
d += cmat[kd*msrc->ncomp + ks] * ds[ks]; |
767 |
> |
rmx_lval(dnew,i,j)[kd] = d; |
768 |
|
} |
769 |
+ |
} |
770 |
|
return(dnew); |
771 |
|
} |
772 |
|
|
786 |
|
for (i = dnew->nrows; i--; ) |
787 |
|
for (j = dnew->ncols; j--; ) { |
788 |
|
const COLORV *cv = cm_lval(cm,i,j); |
789 |
< |
rmx_lval(dnew,i,j,0) = cv[0]; |
790 |
< |
rmx_lval(dnew,i,j,1) = cv[1]; |
791 |
< |
rmx_lval(dnew,i,j,2) = cv[2]; |
789 |
> |
double *dp = rmx_lval(dnew,i,j); |
790 |
> |
dp[0] = cv[0]; |
791 |
> |
dp[1] = cv[1]; |
792 |
> |
dp[2] = cv[2]; |
793 |
|
} |
794 |
|
return(dnew); |
795 |
|
} |
801 |
|
int i, j; |
802 |
|
CMATRIX *cnew; |
803 |
|
|
804 |
< |
if (!rm || rm->ncomp != 3) |
804 |
> |
if (!rm || !rm->mtx | ((rm->ncomp != 3) & (rm->ncomp != 1))) |
805 |
|
return(NULL); |
806 |
|
cnew = cm_alloc(rm->nrows, rm->ncols); |
807 |
|
if (!cnew) |
808 |
|
return(NULL); |
809 |
|
for (i = cnew->nrows; i--; ) |
810 |
|
for (j = cnew->ncols; j--; ) { |
811 |
< |
COLORV *cv = cm_lval(cnew,i,j); |
812 |
< |
cv[0] = (COLORV)rmx_lval(rm,i,j,0); |
813 |
< |
cv[1] = (COLORV)rmx_lval(rm,i,j,1); |
814 |
< |
cv[2] = (COLORV)rmx_lval(rm,i,j,2); |
811 |
> |
const double *dp = rmx_lval(rm,i,j); |
812 |
> |
COLORV *cv = cm_lval(cnew,i,j); |
813 |
> |
if (rm->ncomp == 1) |
814 |
> |
setcolor(cv, dp[0], dp[0], dp[0]); |
815 |
> |
else |
816 |
> |
setcolor(cv, dp[0], dp[1], dp[2]); |
817 |
|
} |
818 |
|
return(cnew); |
819 |
|
} |