T max_flow(int s, int t) {
T ans = 0, f;
while (f = dfs(s, t, inf)) {
ans += f;
clr0(seen);
}
return ans;
}
virtual Vector3 sample(const Vector2& uv) const
{
assert(m_data0 != NULL && m_data1 != NULL);
int _u0 = (int)uv.x, _v0 = (int)uv.y;
int u0 = _u0, v0 = _v0;
m_uAddressingMethod(u0, m_w0);
m_vAddressingMethod(v0, m_h0);
assert(u0 >= 0 && u0 < m_w0);
assert(v0 >= 0 && v0 < m_h0);
const float *p00 = m_data0 + (v0 * m_w0 + u0) * 4 + 1;
const float *p10 = p00;
if (v0 + 1 < m_h0) p10 += m_w0 * 4;
const float *p01 = p00, *p11 = p10;
if (u0 + 1 < m_w0) p01 += 4, p11 += 4;
float xRatio = fabs(uv.x - _u0), yRatio = fabs(uv.y - _v0);
assert(xRatio >= 0 && xRatio <= 1);
assert(yRatio >= 0 && yRatio <= 1);
float invXRatio = 1 - xRatio, invYRatio = 1 - yRatio;
float r00 = invXRatio * invYRatio, r01 = xRatio * invYRatio;
float r10 = invXRatio * yRatio, r11 = xRatio * yRatio;
Vector3 clr0(p00);
clr0 *= r00;
clr0 += Vector3(p01) *= r01;
clr0 += Vector3(p10) *= r10;
clr0 += Vector3(p11) *= r11;
u0 >>= 1, v0 >>= 1;
if (u0 + 1 > m_w1) u0 = m_w1 - 1;
if (v0 + 1 > m_h1) v0 = m_h1 - 1;
assert(u0 >= 0 && u0 < m_w1);
assert(v0 >= 0 && v0 < m_h1);
p00 = m_data1 + (v0 * m_w1 + u0) * 4 + 1;
p10 = p00;
if (v0 + 1 < m_h1) p10 += m_w1 * 4;
p01 = p00, p11 = p10;
if (u0 + 1 < m_w1) p01 += 4, p11 += 4;
Vector3 clr1(p00);
clr1 *= r00;
clr1 += Vector3(p01) *= r01;
clr1 += Vector3(p10) *= r10;
clr1 += Vector3(p11) *= r11;
clr0 *= m_weight0;
clr1 *= 1 - m_weight0;
return clr0 += clr1;
}
void
format (struct obstack *obs, int argc, token_data **argv)
{
#ifdef HAVE_EFGCVT
const char *fmt; /* format control string */
int c; /* a simple character */
char fc; /* format code */
/* Flags. */
char flags; /* 1 iff treating flags */
char ljust; /* left justification */
char mandsign; /* mandatory sign */
char noplus; /* use space if no sign */
char alternate; /* use alternate form */
char zeropad; /* do zero padding */
char plus; /* plus-sign, according to mandatory and noplus */
/* Precision specifiers. */
int width; /* minimum field width */
int prec; /* precision */
int maxch; /* maximum no. of chars to print */
char lflag; /* long flag */
char hflag; /* short flag */
/* Different parts of each specification. */
char sign; /* wanted sign, iff any */
int ppad; /* pre-prefix zero padding */
const char *prefix; /* value prefix */
int lpad; /* zero padding on the left */
register char *s; /* ptr to formatted text */
int rpad; /* zero padding on the rigth*/
const char *suffix; /* value suffix */
/* Buffer and stuff. */
char str[MAXFIELD]; /* buffer for formatted text */
int length; /* length of str */
int padding; /* padding at the left or rigth */
register int i; /* an index */
/* Length of trailing string in str. */
#define LENGTH(s) (&str[MAXFIELD-1] - (s))
#define HAS_SIGN (sign != '\0')
fmt = ARG_STR (argc, argv);
for (;;)
{
while ((c = *fmt++) != '%')
{
if (c == 0)
return;
obstack_1grow (obs, c);
}
if (*fmt == '%')
{
obstack_1grow (obs, '%');
fmt++;
continue;
}
/* Parse flags. */
flags = 1;
ljust = mandsign = noplus = alternate = zeropad = 0;
do
{
switch (*fmt)
{
case '-': /* left justification */
ljust = 1;
break;
case '+': /* mandatory sign */
mandsign = 1;
break;
case ' ': /* space instead of positive sign */
noplus = 1;
break;
case '0': /* zero padding */
zeropad = 1;
break;
case '#': /* alternate output */
alternate = 1;
break;
default:
flags = 0;
break;
}
}
while (flags && fmt++);
plus = '\0'; /* what to use as a plus ??? */
if (mandsign)
plus = '+';
else if (noplus)
plus = ' ';
if (ljust)
zeropad = 0;
/* Minimum field width. */
width = -1;
if (*fmt == '*')
{
width = ARG_INT (argc, argv);
fmt++;
}
else if (isdigit (*fmt))
{
width = 0;
do
{
width = width * 10 + *fmt++ - '0';
}
while (isdigit (*fmt));
}
/* Maximum precision. */
prec = -1;
if (*fmt == '.')
{
if (*(++fmt) == '*')
{
prec = ARG_INT (argc, argv);
++fmt;
}
else if (isdigit (*fmt))
{
prec = 0;
do
{
prec = prec * 10 + *fmt++ - '0';
}
while (isdigit (*fmt))
;
}
}
/* Length modifiers. */
lflag = (*fmt == 'l');
hflag = (*fmt == 'h');
if (lflag || hflag)
fmt++;
sign = '\0';
ppad = lpad = rpad = 0;
maxch = -1;
prefix = suffix = "";
switch (fc = *fmt++)
{
case '\0':
return;
case 'c':
c = ARG_INT (argc, argv);
str[0] = (unsigned char) c;
str[1] = '\0';
s = str;
break;
case 's':
s = ARG_STR (argc, argv);
maxch = prec;
break;
case 'd':
case 'i':
if (lflag)
{
long val = ARG_LONG (argc, argv);
if (val < 0)
{
val = -val; /* does not work for MINLONG */
sign = '-';
}
else
sign = plus;
s = ulong_to_str ((unsigned long) val, str, 10, digits);
}
else
{
int val = ARG_INT (argc, argv);
if (hflag)
val = (short) val;
if (val < 0)
{
val = -val; /* does not work for MININT */
sign = '-';
}
else
sign = plus;
s = ulong_to_str ((unsigned long) val, str, 10, digits);
}
if (zeropad)
lpad = width - LENGTH (s) - HAS_SIGN;
break;
case 'o':
if (lflag)
{
unsigned long val = ARG_ULONG (argc, argv);
s = ulong_to_str ((unsigned long) val, str, 8, digits);
}
else
{
unsigned int val = ARG_UINT (argc, argv);
if (hflag)
val = (unsigned short) val;
s = ulong_to_str ((unsigned long) val, str, 8, digits);
}
if (alternate)
prefix = "0";
if (zeropad)
lpad = width - LENGTH (s) - alternate;
break;
case 'x':
case 'X':
if (lflag)
{
unsigned long val = ARG_ULONG (argc, argv);
s = ulong_to_str ((unsigned long) val, str, 16,
(fc == 'x') ? digits : Digits);
}
else
{
unsigned int val = ARG_UINT (argc, argv);
if (hflag)
val = (unsigned short) val;
s = ulong_to_str ((unsigned long) val, str, 16,
(fc == 'x') ? digits : Digits);
}
if (alternate)
prefix = (fc == 'X') ? "0X" : "0x";
if (zeropad)
lpad = width - LENGTH (s) - 2*alternate;
break;
case 'u':
if (lflag)
{
unsigned long val = ARG_ULONG (argc, argv);
s = ulong_to_str ((unsigned long) val, str, 10, digits);
}
else
{
unsigned int val = ARG_UINT (argc, argv);
if (hflag)
val = (unsigned short) val;
s = ulong_to_str ((unsigned long) val, str, 10, digits);
}
if (zeropad)
lpad = width - LENGTH (s);
break;
case 'e':
case 'E':
{
char *t;
int sgn, decpt, exp, n;
double val = ARG_DOUBLE (argc, argv);
if (prec < 0)
prec = 6;
t = clr0 (ecvt (val, min (prec + 1, ECVTMAX), &decpt, &sgn));
sign = sgn ? '-' : plus;
n = prec;
s = str;
exp = (t[0] == '0' && t[1] == '\0') ? 0 : decpt - 1;
*s++ = *t++;
if (n > 0 || alternate)
*s++ = '.';
while (*t != '\0' && --n >= 0)
*s++ = *t++;
*s = '\0';
rpad = n;
sgn = 0;
if (exp < 0)
{
exp = -exp;
sgn = 1;
}
t = ulong_to_str ((unsigned long) exp, str, 10, digits);
if (exp < 10)
*--t = '0'; /* always at least two digits */
*--t = sgn ? '-' : '+';
*--t = fc;
if (zeropad)
{
lpad = width - HAS_SIGN - (s - str) - LENGTH (t);
if (rpad > 0)
lpad -= rpad;
}
suffix = t;
s = str;
}
break;
case 'f':
{
const char *t;
int sgn, decpt, n;
double val = ARG_DOUBLE (argc, argv);
if (prec < 0)
prec = 6;
/* FIXME: For the following line, Dave Anglin reports
``warning: passing arg 1 of `clr0' discards `const' from
pointer target type''. I suspect fcvt might be declared
as returning const on some systems. Pouah! I should
revise this whole module, one of these days... */
t = clr0 (fcvt (val, min (prec, FCVTMAX), &decpt, &sgn));
sign = sgn ? '-' : plus;
n = prec;
s = str;
if (decpt <= 0)
{
prefix = (n > 0 || alternate) ? "0." : "0";
lpad = min (-decpt, prec);
n -= lpad;
}
else
{
while (--decpt >= 0)
*s++ = *t++;
if (n > 0 || alternate)
*s++ = '.';
}
while (*t && --n >= 0)
*s++ = *t++;
*s = '\0';
rpad = n;
if (zeropad)
ppad = width - HAS_SIGN - (prefix[1] ? 2 : 1) - lpad -
(s - str) - rpad;
s = str;
}
break;
default:
continue;
}
if (lpad < 0)
lpad = 0;
if (rpad < 0)
rpad = 0;
if (width < 0)
width = 0;
i = strlen (s);
if (maxch <= 0 || maxch > i)
maxch = i;
length = (HAS_SIGN + ppad + strlen (prefix) + lpad + maxch
+ rpad + strlen (suffix));
padding = 0;
if (width != 0)
{
padding = width - length;
}
if (ljust == 0) /* left padding */
for (i = padding; --i >= 0;)
obstack_1grow (obs, ' ');
if (HAS_SIGN) /* sign */
obstack_1grow (obs, sign);
for (i = ppad; --i >= 0;) /* pre-prefix zero padding */
obstack_1grow (obs, '0');
for (; *prefix; ++prefix) /* prefix */
obstack_1grow (obs, *prefix);
for (i = lpad; --i >= 0;) /* left zero padding */
obstack_1grow (obs, '0');
for (i = maxch; --i >= 0; ++s) /* actual text */
obstack_1grow (obs, *s);
for (i = rpad; --i >= 0;) /* right zero padding */
obstack_1grow (obs, '0');
for (; *suffix; ++suffix) /* suffix */
obstack_1grow (obs, *suffix);
if (ljust != 0) /* right padding */
for (i = padding; --i >= 0;)
obstack_1grow (obs, ' ');
}
#else /* not HAVE_EFGCVT */
char *fmt; /* format control string */
const char *fstart; /* beginning of current format spec */
int c; /* a simple character */
/* Flags. */
char flags; /* 1 iff treating flags */
/* Precision specifiers. */
int width; /* minimum field width */
int prec; /* precision */
char lflag; /* long flag */
char hflag; /* short flag */
/* Buffer and stuff. */
char str[256]; /* buffer for formatted text */
enum {INT, UINT, LONG, ULONG, DOUBLE, STR} datatype;
fmt = ARG_STR (argc, argv);
for (;;)
{
while ((c = *fmt++) != '%')
{
if (c == 0)
return;
obstack_1grow (obs, c);
}
fstart = fmt - 1;
if (*fmt == '%')
{
obstack_1grow (obs, '%');
fmt++;
continue;
}
/* Parse flags. */
flags = 1;
do
{
switch (*fmt)
{
case '-': /* left justification */
case '+': /* mandatory sign */
case ' ': /* space instead of positive sign */
case '0': /* zero padding */
case '#': /* alternate output */
break;
default:
flags = 0;
break;
}
}
while (flags && fmt++);
/* Minimum field width. */
width = -1;
if (*fmt == '*')
{
width = ARG_INT (argc, argv);
fmt++;
}
else if (isdigit (*fmt))
{
do
{
fmt++;
}
while (isdigit (*fmt));
}
/* Maximum precision. */
prec = -1;
if (*fmt == '.')
{
if (*(++fmt) == '*')
{
prec = ARG_INT (argc, argv);
++fmt;
}
else if (isdigit (*fmt))
{
do
{
fmt++;
}
while (isdigit (*fmt));
}
}
/* Length modifiers. */
lflag = (*fmt == 'l');
hflag = (*fmt == 'h');
if (lflag || hflag)
fmt++;
switch (*fmt++)
{
case '\0':
return;
case 'c':
datatype = INT;
break;
case 's':
datatype = STR;
break;
case 'd':
case 'i':
if (lflag)
{
datatype = LONG;
}
else
{
datatype = INT;
}
break;
case 'o':
case 'x':
case 'X':
case 'u':
if (lflag)
{
datatype = ULONG;
}
else
{
datatype = UINT;
}
break;
case 'e':
case 'E':
case 'f':
datatype = DOUBLE;
break;
default:
continue;
}
c = *fmt;
*fmt = '\0';
switch(datatype)
{
case INT:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_INT(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_INT(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_INT(argc, argv));
else
sprintf (str, fstart, ARG_INT(argc, argv));
break;
case UINT:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_UINT(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_UINT(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_UINT(argc, argv));
else
sprintf (str, fstart, ARG_UINT(argc, argv));
break;
case LONG:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_LONG(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_LONG(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_LONG(argc, argv));
else
sprintf (str, fstart, ARG_LONG(argc, argv));
break;
case ULONG:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_ULONG(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_ULONG(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_ULONG(argc, argv));
else
sprintf (str, fstart, ARG_ULONG(argc, argv));
break;
case DOUBLE:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_DOUBLE(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_DOUBLE(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_DOUBLE(argc, argv));
else
sprintf (str, fstart, ARG_DOUBLE(argc, argv));
break;
case STR:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_STR(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_STR(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_STR(argc, argv));
else
sprintf (str, fstart, ARG_STR(argc, argv));
break;
}
*fmt = c;
obstack_grow (obs, str, strlen (str));
}
#endif /* not HAVE_EFGCVT */
}
