Page MenuHome
Differential D6169 Diff 19896 source/blender/blenkernel/intern/colortools.c

Changeset View

Standalone View

View Options

source/blender/blenkernel/intern/colortools.c

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
/* ***************** operations on full struct ************* */ /* ***************** operations on full struct ************* */
void BKE_curvemapping_set_defaults( void BKE_curvemapping_set_defaults(
CurveMapping *cumap, int tot, float minx, float miny, float maxx, float maxy) CurveMapping *cumap, int tot, float minx, float miny, float maxx, float maxy)
{ {
int a; int a;
float clipminx, clipminy, clipmaxx, clipmaxy; float clipminx, clipminy, clipmaxx, clipmaxy;
cumap->flag = CUMA_DO_CLIP; cumap->flag = CUMA_DO_CLIP | CUMA_EXTEND_EXTRAPOLATE;
if (tot == 4) { if (tot == 4) {
cumap->cur = 3; /* rhms, hack for 'col' curve? */ cumap->cur = 3; /* rhms, hack for 'col' curve? */
} }
clipminx = min_ff(minx, maxx); clipminx = min_ff(minx, maxx);
clipminy = min_ff(miny, maxy); clipminy = min_ff(miny, maxy);
clipmaxx = max_ff(minx, maxx); clipmaxx = max_ff(minx, maxx);
clipmaxy = max_ff(miny, maxy); clipmaxy = max_ff(miny, maxy);
BLI_rctf_init(&cumap->curr, clipminx, clipmaxx, clipminy, clipmaxy); BLI_rctf_init(&cumap->curr, clipminx, clipmaxx, clipminy, clipmaxy);
cumap->clipr = cumap->curr; cumap->clipr = cumap->curr;
cumap->white[0] = cumap->white[1] = cumap->white[2] = 1.0f; cumap->white[0] = cumap->white[1] = cumap->white[2] = 1.0f;
cumap->bwmul[0] = cumap->bwmul[1] = cumap->bwmul[2] = 1.0f; cumap->bwmul[0] = cumap->bwmul[1] = cumap->bwmul[2] = 1.0f;
for (a = 0; a < tot; a++) { for (a = 0; a < tot; a++) {
cumap->cm[a].flag = CUMA_EXTEND_EXTRAPOLATE;
cumap->cm[a].totpoint = 2; cumap->cm[a].totpoint = 2;
cumap->cm[a].curve = MEM_callocN(2 * sizeof(CurveMapPoint), "curve points"); cumap->cm[a].curve = MEM_callocN(2 * sizeof(CurveMapPoint), "curve points");
cumap->cm[a].curve[0].x = minx; cumap->cm[a].curve[0].x = minx;
cumap->cm[a].curve[0].y = miny; cumap->cm[a].curve[0].y = miny;
cumap->cm[a].curve[1].x = maxx; cumap->cm[a].curve[1].x = maxx;
cumap->cm[a].curve[1].y = maxy; cumap->cm[a].curve[1].y = maxy;
} }
▲ Show 20 Lines • Show All 503 Lines • ▼ Show 20 Lines#define p2_h2 ((p2) + 3)
} }
#undef p2_h1 #undef p2_h1
#undef p2_h2 #undef p2_h2
} }
/* in X, out Y. /* in X, out Y.
* X is presumed to be outside first or last */ * X is presumed to be outside first or last */
static float curvemap_calc_extend(const CurveMap *cuma, static float curvemap_calc_extend(const CurveMapping *cumap,
const CurveMap *cuma,
float x, float x,
const float first[2], const float first[2],
const float last[2]) const float last[2])
{ {
if (x <= first[0]) { if (x <= first[0]) {
if ((cuma->flag & CUMA_EXTEND_EXTRAPOLATE) == 0) { if ((cumap->flag & CUMA_EXTEND_EXTRAPOLATE) == 0) {
/* no extrapolate */ /* extrapolate horizontally */
return first[1]; return first[1];
} }
else { else {
if (cuma->ext_in[0] == 0.0f) { if (cuma->ext_in[0] == 0.0f) {
return first[1] + cuma->ext_in[1] * 10000.0f; return first[1] + cuma->ext_in[1] * 10000.0f;
} }
else { else {
return first[1] + cuma->ext_in[1] * (x - first[0]) / cuma->ext_in[0]; return first[1] + cuma->ext_in[1] * (x - first[0]) / cuma->ext_in[0];
} }
} }
} }
else if (x >= last[0]) { else if (x >= last[0]) {
if ((cuma->flag & CUMA_EXTEND_EXTRAPOLATE) == 0) { if ((cumap->flag & CUMA_EXTEND_EXTRAPOLATE) == 0) {
/* no extrapolate */ /* extrapolate horizontally */
return last[1]; return last[1];
} }
else { else {
if (cuma->ext_out[0] == 0.0f) { if (cuma->ext_out[0] == 0.0f) {
return last[1] - cuma->ext_out[1] * 10000.0f; return last[1] - cuma->ext_out[1] * 10000.0f;
} }
else { else {
return last[1] + cuma->ext_out[1] * (x - last[0]) / cuma->ext_out[0]; return last[1] + cuma->ext_out[1] * (x - last[0]) / cuma->ext_out[0];
} }
} }
} }
return 0.0f; return 0.0f;
} }
/* only creates a table for a single channel in CurveMapping */ /* only creates a table for a single channel in CurveMapping */
static void curvemap_make_table(CurveMap *cuma, const rctf *clipr) static void curvemap_make_table(const CurveMapping *cumap, CurveMap *cuma)
{ {
const rctf *clipr = &cumap->clipr;
CurveMapPoint *cmp = cuma->curve; CurveMapPoint *cmp = cuma->curve;
BezTriple *bezt; BezTriple *bezt;
if (cuma->curve == NULL) { if (cuma->curve == NULL) {
return; return;
} }
/* default rect also is table range */ /* default rect also is table range */
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines for (int a = 0; a <= CM_TABLE; a++) {
if (point == firstpoint || (point == lastpoint && cur_x >= point[0])) { if (point == firstpoint || (point == lastpoint && cur_x >= point[0])) {
if (compare_ff(cur_x, point[0], 1e-6f)) { if (compare_ff(cur_x, point[0], 1e-6f)) {
/* When on the point exactly, use the value directly to avoid precision /* When on the point exactly, use the value directly to avoid precision
* issues with extrapolation of extreme slopes. */ * issues with extrapolation of extreme slopes. */
cmp[a].y = point[1]; cmp[a].y = point[1];
} }
else { else {
/* Extrapolate values that lie outside the start and end point. */ /* Extrapolate values that lie outside the start and end point. */
cmp[a].y = curvemap_calc_extend(cuma, cur_x, firstpoint, lastpoint); cmp[a].y = curvemap_calc_extend(cumap, cuma, cur_x, firstpoint, lastpoint);
} }
} }
else { else {
float fac1 = point[0] - point[-2]; float fac1 = point[0] - point[-2];
float fac2 = point[0] - cur_x; float fac2 = point[0] - cur_x;
if (fac1 > FLT_EPSILON) { if (fac1 > FLT_EPSILON) {
fac1 = fac2 / fac1; fac1 = fac2 / fac1;
} }
Show All 30 Lines if (cumap->flag & CUMA_PREMULLED) {
cumap->flag &= ~CUMA_PREMULLED; cumap->flag &= ~CUMA_PREMULLED;
} }
} }
else { else {
if ((cumap->flag & CUMA_PREMULLED) == 0) { if ((cumap->flag & CUMA_PREMULLED) == 0) {
/* verify and copy */ /* verify and copy */
for (a = 0; a < 3; a++) { for (a = 0; a < 3; a++) {
if (cumap->cm[a].table == NULL) { if (cumap->cm[a].table == NULL) {
curvemap_make_table(cumap->cm + a, &cumap->clipr); curvemap_make_table(cumap, cumap->cm + a);
} }
cumap->cm[a].premultable = cumap->cm[a].table; cumap->cm[a].premultable = cumap->cm[a].table;
cumap->cm[a].table = MEM_mallocN((CM_TABLE + 1) * sizeof(CurveMapPoint), "premul table"); cumap->cm[a].table = MEM_mallocN((CM_TABLE + 1) * sizeof(CurveMapPoint), "premul table");
memcpy( memcpy(
cumap->cm[a].table, cumap->cm[a].premultable, (CM_TABLE + 1) * sizeof(CurveMapPoint)); cumap->cm[a].table, cumap->cm[a].premultable, (CM_TABLE + 1) * sizeof(CurveMapPoint));
} }
if (cumap->cm[3].table == NULL) { if (cumap->cm[3].table == NULL) {
curvemap_make_table(cumap->cm + 3, &cumap->clipr); curvemap_make_table(cumap, cumap->cm + 3);
} }
/* premul */ /* premul */
for (a = 0; a < 3; a++) { for (a = 0; a < 3; a++) {
int b; int b;
for (b = 0; b <= CM_TABLE; b++) { for (b = 0; b <= CM_TABLE; b++) {
cumap->cm[a].table[b].y = BKE_curvemap_evaluateF(cumap->cm + 3, cumap->cm[a].table[b].y); cumap->cm[a].table[b].y = BKE_curvemap_evaluateF(
cumap, cumap->cm + 3, cumap->cm[a].table[b].y);
} }
copy_v2_v2(cumap->cm[a].premul_ext_in, cumap->cm[a].ext_in); copy_v2_v2(cumap->cm[a].premul_ext_in, cumap->cm[a].ext_in);
copy_v2_v2(cumap->cm[a].premul_ext_out, cumap->cm[a].ext_out); copy_v2_v2(cumap->cm[a].premul_ext_out, cumap->cm[a].ext_out);
mul_v2_v2(cumap->cm[a].ext_in, cumap->cm[3].ext_in); mul_v2_v2(cumap->cm[a].ext_in, cumap->cm[3].ext_in);
mul_v2_v2(cumap->cm[a].ext_out, cumap->cm[3].ext_out); mul_v2_v2(cumap->cm[a].ext_out, cumap->cm[3].ext_out);
} }
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines for (a = 0; a < cuma->totpoint - 1; a++) {
} }
break; /* we assume 1 deletion per edit is ok */ break; /* we assume 1 deletion per edit is ok */
} }
} }
if (a != cuma->totpoint - 1) { if (a != cuma->totpoint - 1) {
BKE_curvemap_remove(cuma, 2); BKE_curvemap_remove(cuma, 2);
} }
} }
curvemap_make_table(cuma, clipr); curvemap_make_table(cumap, cuma);
} }
void BKE_curvemapping_changed_all(CurveMapping *cumap) void BKE_curvemapping_changed_all(CurveMapping *cumap)
{ {
int a, cur = cumap->cur; int a, cur = cumap->cur;
for (a = 0; a < CM_TOT; a++) { for (a = 0; a < CM_TOT; a++) {
if (cumap->cm[a].curve) { if (cumap->cm[a].curve) {
cumap->cur = a; cumap->cur = a;
BKE_curvemapping_changed(cumap, false); BKE_curvemapping_changed(cumap, false);
} }
} }
cumap->cur = cur; cumap->cur = cur;
} }
/* table should be verified */ /* table should be verified */
float BKE_curvemap_evaluateF(const CurveMap *cuma, float value) float BKE_curvemap_evaluateF(const CurveMapping *cumap, const CurveMap *cuma, float value)
{ {
float fi; float fi;
int i; int i;
/* index in table */ /* index in table */
fi = (value - cuma->mintable) * cuma->range; fi = (value - cuma->mintable) * cuma->range;
i = (int)fi; i = (int)fi;
/* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */ /* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */
if (fi < 0.0f || fi > CM_TABLE) { if (fi < 0.0f || fi > CM_TABLE) {
return curvemap_calc_extend(cuma, value, &cuma->table[0].x, &cuma->table[CM_TABLE].x); return curvemap_calc_extend(cumap, cuma, value, &cuma->table[0].x, &cuma->table[CM_TABLE].x);
} }
else { else {
if (i < 0) { if (i < 0) {
return cuma->table[0].y; return cuma->table[0].y;
} }
if (i >= CM_TABLE) { if (i >= CM_TABLE) {
return cuma->table[CM_TABLE].y; return cuma->table[CM_TABLE].y;
} }
fi = fi - (float)i; fi = fi - (float)i;
return (1.0f - fi) * cuma->table[i].y + (fi)*cuma->table[i + 1].y; return (1.0f - fi) * cuma->table[i].y + (fi)*cuma->table[i + 1].y;
} }
} }
/* works with curve 'cur' */ /* works with curve 'cur' */
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value) float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
{ {
const CurveMap *cuma = cumap->cm + cur; const CurveMap *cuma = cumap->cm + cur;
float val = BKE_curvemap_evaluateF(cuma, value); float val = BKE_curvemap_evaluateF(cumap, cuma, value);
/* account for clipping */ /* account for clipping */
if (cumap->flag & CUMA_DO_CLIP) { if (cumap->flag & CUMA_DO_CLIP) {
if (val < cumap->curr.ymin) { if (val < cumap->curr.ymin) {
val = cumap->curr.ymin; val = cumap->curr.ymin;
} }
else if (val > cumap->curr.ymax) { else if (val > cumap->curr.ymax) {
val = cumap->curr.ymax; val = cumap->curr.ymax;
} }
} }
return val; return val;
} }
/* vector case */ /* vector case */
void BKE_curvemapping_evaluate3F(const CurveMapping *cumap, float vecout[3], const float vecin[3]) void BKE_curvemapping_evaluate3F(const CurveMapping *cumap, float vecout[3], const float vecin[3])
{ {
vecout[0] = BKE_curvemap_evaluateF(&cumap->cm[0], vecin[0]); vecout[0] = BKE_curvemap_evaluateF(cumap, &cumap->cm[0], vecin[0]);
vecout[1] = BKE_curvemap_evaluateF(&cumap->cm[1], vecin[1]); vecout[1] = BKE_curvemap_evaluateF(cumap, &cumap->cm[1], vecin[1]);
vecout[2] = BKE_curvemap_evaluateF(&cumap->cm[2], vecin[2]); vecout[2] = BKE_curvemap_evaluateF(cumap, &cumap->cm[2], vecin[2]);
} }
/* RGB case, no black/white points, no premult */ /* RGB case, no black/white points, no premult */
void BKE_curvemapping_evaluateRGBF(const CurveMapping *cumap, void BKE_curvemapping_evaluateRGBF(const CurveMapping *cumap,
float vecout[3], float vecout[3],
const float vecin[3]) const float vecin[3])
{ {
vecout[0] = BKE_curvemap_evaluateF(&cumap->cm[0], vecout[0] = BKE_curvemap_evaluateF(
BKE_curvemap_evaluateF(&cumap->cm[3], vecin[0])); cumap, &cumap->cm[0], BKE_curvemap_evaluateF(cumap, &cumap->cm[3], vecin[0]));
vecout[1] = BKE_curvemap_evaluateF(&cumap->cm[1], vecout[1] = BKE_curvemap_evaluateF(
BKE_curvemap_evaluateF(&cumap->cm[3], vecin[1])); cumap, &cumap->cm[1], BKE_curvemap_evaluateF(cumap, &cumap->cm[3], vecin[1]));
vecout[2] = BKE_curvemap_evaluateF(&cumap->cm[2], vecout[2] = BKE_curvemap_evaluateF(
BKE_curvemap_evaluateF(&cumap->cm[3], vecin[2])); cumap, &cumap->cm[2], BKE_curvemap_evaluateF(cumap, &cumap->cm[3], vecin[2]));
} }
static void curvemapping_evaluateRGBF_filmlike(const CurveMapping *cumap, static void curvemapping_evaluateRGBF_filmlike(const CurveMapping *cumap,
float vecout[3], float vecout[3],
const float vecin[3], const float vecin[3],
const int channel_offset[3]) const int channel_offset[3])
{ {
const float v0in = vecin[channel_offset[0]]; const float v0in = vecin[channel_offset[0]];
const float v1in = vecin[channel_offset[1]]; const float v1in = vecin[channel_offset[1]];
const float v2in = vecin[channel_offset[2]]; const float v2in = vecin[channel_offset[2]];
const float v0 = BKE_curvemap_evaluateF(&cumap->cm[channel_offset[0]], v0in); const float v0 = BKE_curvemap_evaluateF(cumap, &cumap->cm[channel_offset[0]], v0in);
const float v2 = BKE_curvemap_evaluateF(&cumap->cm[channel_offset[2]], v2in); const float v2 = BKE_curvemap_evaluateF(cumap, &cumap->cm[channel_offset[2]], v2in);
const float v1 = v2 + ((v0 - v2) * (v1in - v2in) / (v0in - v2in)); const float v1 = v2 + ((v0 - v2) * (v1in - v2in) / (v0in - v2in));
vecout[channel_offset[0]] = v0; vecout[channel_offset[0]] = v0;
vecout[channel_offset[1]] = v1; vecout[channel_offset[1]] = v1;
vecout[channel_offset[2]] = v2; vecout[channel_offset[2]] = v2;
} }
/** /**
Show All 14 Lines
{ {
const float r = (vecin[0] - black[0]) * bwmul[0]; const float r = (vecin[0] - black[0]) * bwmul[0];
const float g = (vecin[1] - black[1]) * bwmul[1]; const float g = (vecin[1] - black[1]) * bwmul[1];
const float b = (vecin[2] - black[2]) * bwmul[2]; const float b = (vecin[2] - black[2]) * bwmul[2];
switch (cumap->tone) { switch (cumap->tone) {
default: default:
case CURVE_TONE_STANDARD: { case CURVE_TONE_STANDARD: {
vecout[0] = BKE_curvemap_evaluateF(&cumap->cm[0], r); vecout[0] = BKE_curvemap_evaluateF(cumap, &cumap->cm[0], r);
vecout[1] = BKE_curvemap_evaluateF(&cumap->cm[1], g); vecout[1] = BKE_curvemap_evaluateF(cumap, &cumap->cm[1], g);
vecout[2] = BKE_curvemap_evaluateF(&cumap->cm[2], b); vecout[2] = BKE_curvemap_evaluateF(cumap, &cumap->cm[2], b);
break; break;
} }
case CURVE_TONE_FILMLIKE: { case CURVE_TONE_FILMLIKE: {
if (r >= g) { if (r >= g) {
if (g > b) { if (g > b) {
/* Case 1: r >= g > b */ /* Case 1: r >= g > b */
const int shuffeled_channels[] = {0, 1, 2}; const int shuffeled_channels[] = {0, 1, 2};
curvemapping_evaluateRGBF_filmlike(cumap, vecout, vecin, shuffeled_channels); curvemapping_evaluateRGBF_filmlike(cumap, vecout, vecin, shuffeled_channels);
} }
else if (b > r) { else if (b > r) {
/* Case 2: b > r >= g */ /* Case 2: b > r >= g */
const int shuffeled_channels[] = {2, 0, 1}; const int shuffeled_channels[] = {2, 0, 1};
curvemapping_evaluateRGBF_filmlike(cumap, vecout, vecin, shuffeled_channels); curvemapping_evaluateRGBF_filmlike(cumap, vecout, vecin, shuffeled_channels);
} }
else if (b > g) { else if (b > g) {
/* Case 3: r >= b > g */ /* Case 3: r >= b > g */
const int shuffeled_channels[] = {0, 2, 1}; const int shuffeled_channels[] = {0, 2, 1};
curvemapping_evaluateRGBF_filmlike(cumap, vecout, vecin, shuffeled_channels); curvemapping_evaluateRGBF_filmlike(cumap, vecout, vecin, shuffeled_channels);
} }
else { else {
/* Case 4: r >= g == b */ /* Case 4: r >= g == b */
copy_v2_fl2(vecout, copy_v2_fl2(vecout,
BKE_curvemap_evaluateF(&cumap->cm[0], r), BKE_curvemap_evaluateF(cumap, &cumap->cm[0], r),
BKE_curvemap_evaluateF(&cumap->cm[1], g)); BKE_curvemap_evaluateF(cumap, &cumap->cm[1], g));
vecout[2] = vecout[1]; vecout[2] = vecout[1];
} }
} }
else { else {
if (r >= b) { if (r >= b) {
/* Case 5: g > r >= b */ /* Case 5: g > r >= b */
const int shuffeled_channels[] = {1, 0, 2}; const int shuffeled_channels[] = {1, 0, 2};
curvemapping_evaluateRGBF_filmlike(cumap, vecout, vecin, shuffeled_channels); curvemapping_evaluateRGBF_filmlike(cumap, vecout, vecin, shuffeled_channels);
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Linesvoid BKE_curvemapping_initialize(CurveMapping *cumap)
int a; int a;
if (cumap == NULL) { if (cumap == NULL) {
return; return;
} }
for (a = 0; a < CM_TOT; a++) { for (a = 0; a < CM_TOT; a++) {
if (cumap->cm[a].table == NULL) { if (cumap->cm[a].table == NULL) {
curvemap_make_table(cumap->cm + a, &cumap->clipr); curvemap_make_table(cumap, cumap->cm + a);
} }
} }
} }
void BKE_curvemapping_table_RGBA(const CurveMapping *cumap, float **array, int *size) void BKE_curvemapping_table_RGBA(const CurveMapping *cumap, float **array, int *size)
{ {
int a; int a;
▲ Show 20 Lines • Show All 607 Lines • Show Last 20 Lines